public async stt::Task GetRequestObjectAsync()
{
moq::Mock <AcceleratorTypes.AcceleratorTypesClient> mockGrpcClient = new moq::Mock <AcceleratorTypes.AcceleratorTypesClient>(moq::MockBehavior.Strict);
GetAcceleratorTypeRequest request = new GetAcceleratorTypeRequest
{
Zone = "zone255f4ea8",
AcceleratorType = "accelerator_type68a25f42",
Project = "projectaa6ff846",
};
AcceleratorType expectedResponse = new AcceleratorType
{
Id = "id74b70bb8",
Kind = "kindf7aa39d9",
Name = "name1c9368b0",
Zone = "zone255f4ea8",
CreationTimestamp = "creation_timestamp235e59a1",
Description = "description2cf9da67",
SelfLink = "self_link7e87f12d",
Deprecated = new DeprecationStatus(),
MaximumCardsPerInstance = 739769688,
};
mockGrpcClient.Setup(x => x.GetAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <AcceleratorType>(stt::Task.FromResult(expectedResponse), null, null, null, null));
AcceleratorTypesClient client = new AcceleratorTypesClientImpl(mockGrpcClient.Object, null);
AcceleratorType responseCallSettings = await client.GetAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
AcceleratorType responseCancellationToken = await client.GetAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public async stt::Task GetAcceleratorTypeResourceNamesAsync()
{
moq::Mock <Tpu.TpuClient> mockGrpcClient = new moq::Mock <Tpu.TpuClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetAcceleratorTypeRequest request = new GetAcceleratorTypeRequest
{
AcceleratorTypeName = AcceleratorTypeName.FromProjectLocationAcceleratorType("[PROJECT]", "[LOCATION]", "[ACCELERATOR_TYPE]"),
};
AcceleratorType expectedResponse = new AcceleratorType
{
AcceleratorTypeName = AcceleratorTypeName.FromProjectLocationAcceleratorType("[PROJECT]", "[LOCATION]", "[ACCELERATOR_TYPE]"),
Type = "typee2cc9d59",
};
mockGrpcClient.Setup(x => x.GetAcceleratorTypeAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <AcceleratorType>(stt::Task.FromResult(expectedResponse), null, null, null, null));
TpuClient client = new TpuClientImpl(mockGrpcClient.Object, null);
AcceleratorType responseCallSettings = await client.GetAcceleratorTypeAsync(request.AcceleratorTypeName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
AcceleratorType responseCancellationToken = await client.GetAcceleratorTypeAsync(request.AcceleratorTypeName, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Prints general header information that should appear at the top.
/// </summary>
/// <param name="writer">The target text writer to write to.</param>
protected virtual void PrintHeader(TextWriter writer)
{
writer.Write("Device: ");
writer.WriteLine(Name);
writer.Write(" Accelerator Type: ");
writer.WriteLine(AcceleratorType.ToString());
}
/// <summary>
/// Constructs a new accelerator.
/// </summary>
/// <param name="context">The target context.</param>
/// <param name="type">The target accelerator type.</param>
internal Accelerator(Context context, AcceleratorType type)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
AcceleratorType = type;
InitGC();
memoryCache = new MemoryBufferCache(this);
}
/// <summary>
/// <para>prepares devices and compiles kernels in the kernel string</para>
/// <para>does optionally pipelined kernel execution load balancing between multiple devices</para>
/// </summary>
/// <param name="cpuGpu">AcceleratorType.CPU|AcceleratorType.GPU or similar</param>
/// <param name="kernelString">something like: @"multi-line C# string that has multiple kernel definitions"</param>
/// <param name="numberofCPUCoresToUseAsDeviceFission">AcceleratorType.CPU uses number of threads for an N-core CPU(between 1 and N-1)(-1 means N-1)</param>
/// <param name="numberOfGPUsToUse">AcceleratorType.GPU uses number of GPUs equal to this parameter. Between 1 and N(-1 means N)</param>
/// <param name="stream">devices that share RAM with CPU will not do extra copies. Devices that don't share RAM will directly access RAM and reduce number of copies</param>
/// <param name="noPipelining">disables extra command queue allocation, can't enable driver-driven pipelining later. Useful for device to device pipelining with many stages.</param>
public ClNumberCruncher(AcceleratorType cpuGpu, string kernelString,
int numberofCPUCoresToUseAsDeviceFission = -1,
int numberOfGPUsToUse = -1, bool stream = true, bool noPipelining = false)
{
bool defaultQueue = false;
if (kernelString.Contains("enqueue_kernel("))
{
defaultQueue = true;
}
repeatCount = 1;
numberOfErrorsHappened = 0;
StringBuilder cpuGpu_ = new StringBuilder("");
if (((int)cpuGpu & ((int)AcceleratorType.CPU)) > 0)
{
cpuGpu_.Append("cpu ");
}
if (((int)cpuGpu & ((int)AcceleratorType.GPU)) > 0)
{
cpuGpu_.Append("gpu ");
}
if (((int)cpuGpu & ((int)AcceleratorType.ACC)) > 0)
{
cpuGpu_.Append("acc ");
}
List <string> kernelNames_ = new List <string>();
// extracting patterns kernel _ _ _ void _ _ name _ _ (
string kernelVoidRegex = "(kernel[\\s]+void[\\s]+[a-zA-Z\\d_]+[^\\(])";
Regex regex = new Regex(kernelVoidRegex);
MatchCollection match = regex.Matches(kernelString);
for (int i = 0; i < match.Count; i++)
{
// extracting name
Regex rgx = new Regex("([\\s]+[a-zA-Z\\d_]+)");
MatchCollection mc = rgx.Matches(match[i].Value.Trim());
kernelNames_.Add(mc[mc.Count - 1].Value.Trim());
}
if (kernelNames_.Count == 0)
{
Console.WriteLine("Error: no kernel definitions are found in string. Kernel string: \n" + kernelString);
errorNotification = 1;
return;
}
numberCruncher = new Cores(cpuGpu_.ToString(), kernelString, kernelNames_.ToArray(), defaultQueue, 256,
numberOfGPUsToUse, stream, numberofCPUCoresToUseAsDeviceFission, noPipelining);
if (numberCruncher.errorCode() != 0)
{
errorMessage_ = numberCruncher.errorMessage();
Console.WriteLine(numberCruncher.errorMessage());
errorNotification = numberCruncher.errorCode();
numberCruncher.dispose();
numberOfErrorsHappened++;
return;
}
}
bool GetAccelerator(AcceleratorType t, out AcceleratorId aid)
{
aid = Accelerator.Accelerators.Where(id => id.AcceleratorType == t).FirstOrDefault();
if (aid.AcceleratorType != t)
{
Console.WriteLine(@"There is accelerator present of the desired type. Doing nothing.");
}
return(aid.AcceleratorType == t);
}
/// <summary>
/// Constructs a new device specializer.
/// </summary>
/// <param name="acceleratorType">The accelerator type.</param>
/// <param name="warpSize">The warp size (if any).</param>
/// <param name="intPointerType">The native integer pointer type.</param>
public AcceleratorSpecializer(
AcceleratorType acceleratorType,
int?warpSize,
PrimitiveType intPointerType)
{
AcceleratorType = acceleratorType;
WarpSize = warpSize;
IntPointerType = intPointerType;
}
/// <summary>
/// Constructs a new accelerator id.
/// </summary>
/// <param name="type">The accelerator type.</param>
/// <param name="deviceId">The referenced device id.</param>
public AcceleratorId(AcceleratorType type, int deviceId)
{
if (deviceId < 0)
{
throw new ArgumentOutOfRangeException(nameof(deviceId));
}
AcceleratorType = type;
DeviceId = deviceId;
}
/// <summary>
/// Constructs a new device specializer.
/// </summary>
/// <param name="acceleratorType">The accelerator type.</param>
/// <param name="warpSize">The warp size (if any).</param>
/// <param name="intPointerType">The native integer pointer type.</param>
/// <param name="enableAssertions">True, if the assertions are enabled.</param>
public AcceleratorSpecializer(
AcceleratorType acceleratorType,
int?warpSize,
PrimitiveType intPointerType,
bool enableAssertions)
{
AcceleratorType = acceleratorType;
WarpSize = warpSize;
IntPointerType = intPointerType;
EnableAssertions = enableAssertions;
}
public FileRunner(CodeFile code, OutputTabs output, AcceleratorType type, int OptimizationLevel, Action onRunStop, Action framebufferSwap, Action <TimeSpan, double> onTimersUpdate)
{
this.code = code;
this.output = output;
this.type = type;
this.OptimizationLevel = OptimizationLevel;
this.onRunStop = onRunStop;
this.framebufferSwap = framebufferSwap;
this.onTimersUpdate = onTimersUpdate;
timer = new FrameTimer();
}
/// <summary>
/// Returns a user-friendly name for an accelerator type.
/// </summary>
/// <param name="acceleratorType">The accelerator to return a name for.</param>
/// <returns>A user friendly name.</returns>
/// <remarks>
/// Adapted from https://codereview.stackexchange.com/questions/157871/method-that-returns-description-attribute-of-enum-value.</remarks>
public static string ToFriendlyName(this AcceleratorType acceleratorType)
{
return
(acceleratorType
.GetType()
.GetMember(acceleratorType.ToString())
.FirstOrDefault()
?.GetCustomAttribute <DescriptionAttribute>()
?.Description
?? acceleratorType.ToString());
}
/// <summary>Snippet for Get</summary>
public void Get()
{
// Snippet: Get(string, string, string, CallSettings)
// Create client
AcceleratorTypesClient acceleratorTypesClient = AcceleratorTypesClient.Create();
// Initialize request argument(s)
string project = "";
string zone = "";
string acceleratorType = "";
// Make the request
AcceleratorType response = acceleratorTypesClient.Get(project, zone, acceleratorType);
// End snippet
}
/// <summary>
/// Constructs a new accelerator.
/// </summary>
/// <param name="context">The target context.</param>
/// <param name="type">The target accelerator type.</param>
internal Accelerator(Context context, AcceleratorType type)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
AcceleratorType = type;
AutomaticBufferDisposalEnabled = !context.HasFlags(
ContextFlags.DisableAutomaticBufferDisposal);
AutomaticKernelDisposalEnabled = !context.HasFlags(
ContextFlags.DisableAutomaticKernelDisposal);
InitKernelCache();
InitGC();
memoryCache = new MemoryBufferCache(this);
}
public void Initialize(AcceleratorType acceleratorType, double[,] independents, double[] dependants)
{
Context = new Context();
List <AcceleratorId> acceleratorIds = Accelerator.Accelerators.Where(x => x.AcceleratorType == acceleratorType).ToList();
List <double[, ]> splitIndependents = SplitArray(independents, acceleratorIds.Count);
List <double[]> splitDependants = SplitArray(dependants, acceleratorIds.Count);
for (int gpuIndex = 0; gpuIndex < acceleratorIds.Count; gpuIndex++)
{
GPUManager gpuManager = new GPUManager();
gpuManager.Initialize(Context, acceleratorIds[gpuIndex], splitIndependents[gpuIndex], splitDependants[gpuIndex]);
GPUManagers.Add(gpuManager);
}
TotalIndependentsRows = splitDependants.Select(x => x.Length).Sum();
}
/// <summary>Snippet for GetAsync</summary>
public async Task GetAsync()
{
// Snippet: GetAsync(string, string, string, CallSettings)
// Additional: GetAsync(string, string, string, CancellationToken)
// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
string project = "";
string zone = "";
string acceleratorType = "";
// Make the request
AcceleratorType response = await acceleratorTypesClient.GetAsync(project, zone, acceleratorType);
// End snippet
}
/// <summary>Snippet for Get</summary>
public void GetRequestObject()
{
// Snippet: Get(GetAcceleratorTypeRequest, CallSettings)
// Create client
AcceleratorTypesClient acceleratorTypesClient = AcceleratorTypesClient.Create();
// Initialize request argument(s)
GetAcceleratorTypeRequest request = new GetAcceleratorTypeRequest
{
Zone = "",
AcceleratorType = "",
Project = "",
};
// Make the request
AcceleratorType response = acceleratorTypesClient.Get(request);
// End snippet
}
public static string getDesc(AcceleratorType type)
{
switch (type)
{
case AcceleratorType.Default:
case AcceleratorType.CPU:
return(CPUAccelerator.CPUAccelerators.FirstOrDefault().ToString());
case AcceleratorType.Cuda:
return(CudaAccelerator.CudaAccelerators.FirstOrDefault().ToString());
case AcceleratorType.OpenCL:
return(CLAccelerator.AllCLAccelerators.FirstOrDefault().ToString());
}
return("");
}
/// <summary>Snippet for GetAsync</summary>
public async Task GetRequestObjectAsync()
{
// Snippet: GetAsync(GetAcceleratorTypeRequest, CallSettings)
// Additional: GetAsync(GetAcceleratorTypeRequest, CancellationToken)
// Create client
AcceleratorTypesClient acceleratorTypesClient = await AcceleratorTypesClient.CreateAsync();
// Initialize request argument(s)
GetAcceleratorTypeRequest request = new GetAcceleratorTypeRequest
{
Zone = "",
AcceleratorType = "",
Project = "",
};
// Make the request
AcceleratorType response = await acceleratorTypesClient.GetAsync(request);
// End snippet
}
public void GetAcceleratorTypeResourceNames()
{
moq::Mock <Tpu.TpuClient> mockGrpcClient = new moq::Mock <Tpu.TpuClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetAcceleratorTypeRequest request = new GetAcceleratorTypeRequest
{
AcceleratorTypeName = AcceleratorTypeName.FromProjectLocationAcceleratorType("[PROJECT]", "[LOCATION]", "[ACCELERATOR_TYPE]"),
};
AcceleratorType expectedResponse = new AcceleratorType
{
AcceleratorTypeName = AcceleratorTypeName.FromProjectLocationAcceleratorType("[PROJECT]", "[LOCATION]", "[ACCELERATOR_TYPE]"),
Type = "typee2cc9d59",
};
mockGrpcClient.Setup(x => x.GetAcceleratorType(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
TpuClient client = new TpuClientImpl(mockGrpcClient.Object, null);
AcceleratorType response = client.GetAcceleratorType(request.AcceleratorTypeName);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void Run(double[,] independents, double[] dependants, int maxNodesPerExpression, AcceleratorType acceleratorType, List <Node> startExpressions, List <Transform> transforms)
{
if (IsRunning)
{
return;
}
IsRunning = true;
if (UseSymCalculate)
{
Independents = ToJagged(independents);
Dependants = dependants;
}
else
{
GPUsManager.Initialize(acceleratorType, independents, dependants);
}
MaxNodesPerExpression = maxNodesPerExpression;
ModelManager.MaxNodesPerExpression = maxNodesPerExpression;
ModelManager.CorrelationItems = Correlation.ComputeRankedCorrelationItems(independents, dependants);
ModelManager.Run(independents.GetUpperBound(1) + 1, startExpressions, transforms);
IsRunning = false;
}
/// <summary>
/// Constructs a new device specializer.
/// </summary>
/// <param name="acceleratorType">The accelerator type.</param>
/// <param name="warpSize">The warp size (if any).</param>
public AcceleratorSpecializer(AcceleratorType acceleratorType, int?warpSize)
{
AcceleratorType = acceleratorType;
WarpSize = warpSize;
}
/// <summary>
/// Constructs a new accelerator id.
/// </summary>
/// <param name="type">The accelerator type.</param>
protected AcceleratorId(AcceleratorType type)
{
AcceleratorType = type;
}
/// <summary>
/// Constructs a new kernel accelerator.
/// </summary>
/// <param name="context">The target context.</param>
/// <param name="type">The target accelerator type.</param>
protected KernelAccelerator(Context context, AcceleratorType type)
: base(context, type)
{
}
/// <summary>
/// Constructs a new device type attribute.
/// </summary>
/// <param name="acceleratorType">
/// The accelerator type of the annotated device.
/// </param>
public DeviceTypeAttribute(AcceleratorType acceleratorType)
{
AcceleratorType = acceleratorType;
}
