public void netSetup(string deviceTypesParameter = "",
string kernelsString = "",
string[] kernelNamesStringArray = null,
int localWorkgroupSizeInWorkitems = 256,
int numberOfGpusToUse = -1,
bool GPU_STREAM_ = false,
int MAX_CPU_ = -1)
{
NetworkBuffer nb = new NetworkBuffer(NetworkBuffer.SETUP);
if (deviceTypesParameter.Equals(""))
{
deviceTypesParameter = "cpu gpu";
}
if (kernelsString.Equals(""))
{
kernelsString = @"__kernel void serverDeneme(__global float *a){a[get_global_id(0)]+=3.14f;}";
}
if (kernelNamesStringArray == null)
{
kernelNamesStringArray = new string[] { "serverDeneme" }
}
;
int[] localThreadNumber = new int[] { localWorkgroupSizeInWorkitems };
int[] gpusToUse = new int[] { numberOfGpusToUse };
bool[] GPU_STREAM = new bool[] { GPU_STREAM_ };
int[] MAX_CPU = new int[] { MAX_CPU_ };
string ki = String.Join(" ", kernelNamesStringArray);
nb.addCompute(deviceTypesParameter.ToCharArray(), deviceTypesParameter.GetHashCode());
nb.addCompute(kernelsString.ToCharArray(), kernelsString.GetHashCode());
nb.addCompute(ki.ToCharArray(), ki.GetHashCode());
nb.addComputeSteps(localThreadNumber, localThreadNumber.GetHashCode());
nb.addComputeSteps(gpusToUse, gpusToUse.GetHashCode());
nb.addPipeline(GPU_STREAM, GPU_STREAM.GetHashCode());
nb.addComputeSteps(MAX_CPU, MAX_CPU.GetHashCode());
upload(nwStream, nb.buf());
Console.WriteLine(download(nwStream));
}
public void compute(string[] kernelNameStringArray = null,
int numberOfSteps = 0, string stepFunction = "",
object[] arrays = null, string[] readWrite = null,
int[] arrayElementsPerWorkItem = null,
int globalRange = 1024, int computeId = 1,
int globalOffset = 0, bool enablePipeline = false,
int numberOfPipelineBlobs = 4, bool typeOfPipeline = Cores.PIPELINE_EVENT)
{
NetworkBuffer nbCompute = new NetworkBuffer(NetworkBuffer.COMPUTE);
if (kernelNameStringArray == null)
{
kernelNameStringArray = new string[] { "serverDeneme" }
}
;
string kernelName = String.Join(" ", kernelNameStringArray);
int[] numberOfStepsArray = new int[] { numberOfSteps };
if (arrays == null)
{
arrays = new object[] { new float[1024] }
}
;
int[] numberOfArrays = new int[] { arrays.Length };
if (readWrite == null)
{
readWrite = new string[] { "read write" }
}
; // unoptimized for now
if (arrayElementsPerWorkItem == null)
{
arrayElementsPerWorkItem = new int[] { 1 }
}
;
int[] totalGlobalRange = new int[] { globalRange };
int[] computeIdArray = new int[] { computeId };
int[] globalOffsetArray = new int[] { globalOffset };
bool[] pipelineEnabledArray = new bool[] { enablePipeline };
int[] pipelineBlobsArray = new int[] { numberOfPipelineBlobs /* default 4 but unimportant when pipelining is disabled*/ };
bool[] pipelineTypeArray = new bool[] { typeOfPipeline };
nbCompute.addCompute(kernelName.ToCharArray(), kernelName.GetHashCode());
nbCompute.addComputeSteps(numberOfStepsArray, numberOfStepsArray.GetHashCode());
nbCompute.addCompute(stepFunction.ToCharArray(), stepFunction.GetHashCode());
nbCompute.addComputeSteps(numberOfArrays, numberOfArrays.GetHashCode());
for (int m = 0; m < arrays.Length; m++)
{
if (readWrite[m].Contains("partial"))
{
// not all array types are covered here, todo: add all types
if (arrays[m].GetType() == typeof(float[]))
{
nbCompute.addArray((float[])arrays[m], arrays[m].GetHashCode(),
globalOffset, globalRange, arrayElementsPerWorkItem[m]);
}
else if (arrays[m].GetType() == typeof(int[]))
{
nbCompute.addComputeSteps((int[])arrays[m], arrays[m].GetHashCode(),
globalOffset, globalRange, arrayElementsPerWorkItem[m]);
}
else if (arrays[m].GetType() == typeof(byte[]))
{
nbCompute.addArray((byte[])arrays[m], arrays[m].GetHashCode(),
globalOffset, globalRange, arrayElementsPerWorkItem[m]);
}
else if (arrays[m].GetType() == typeof(char[]))
{
nbCompute.addCompute((char[])arrays[m], arrays[m].GetHashCode(),
globalOffset, globalRange, arrayElementsPerWorkItem[m]);
}
else if (arrays[m].GetType() == typeof(double[]))
{
nbCompute.addArray((double[])arrays[m], arrays[m].GetHashCode(),
globalOffset, globalRange, arrayElementsPerWorkItem[m]);
}
else if (arrays[m].GetType() == typeof(long[]))
{
nbCompute.addArray((long[])arrays[m], arrays[m].GetHashCode(),
globalOffset, globalRange, arrayElementsPerWorkItem[m]);
}
}
else if (readWrite[m].Contains("read"))
{
if (arrays[m].GetType() == typeof(float[]))
{
nbCompute.addArray((float[])arrays[m], arrays[m].GetHashCode());
}
else if (arrays[m].GetType() == typeof(int[]))
{
nbCompute.addComputeSteps((int[])arrays[m], arrays[m].GetHashCode());
}
else if (arrays[m].GetType() == typeof(byte[]))
{
nbCompute.addArray((byte[])arrays[m], arrays[m].GetHashCode());
}
else if (arrays[m].GetType() == typeof(char[]))
{
nbCompute.addCompute((char[])arrays[m], arrays[m].GetHashCode());
}
else if (arrays[m].GetType() == typeof(double[]))
{
nbCompute.addArray((double[])arrays[m], arrays[m].GetHashCode());
}
else if (arrays[m].GetType() == typeof(long[]))
{
nbCompute.addArray((long[])arrays[m], arrays[m].GetHashCode());
}
}
}
for (int m = 0; m < arrays.Length; m++)
{
nbCompute.addCompute(readWrite[m].ToCharArray(), readWrite[m].GetHashCode());
}
nbCompute.addComputeSteps(arrayElementsPerWorkItem, arrayElementsPerWorkItem.GetHashCode());
nbCompute.addComputeSteps(totalGlobalRange, totalGlobalRange.GetHashCode());
nbCompute.addComputeSteps(computeIdArray, computeIdArray.GetHashCode());
nbCompute.addComputeSteps(globalOffsetArray, globalOffsetArray.GetHashCode());
nbCompute.addPipeline(pipelineEnabledArray, pipelineEnabledArray.GetHashCode());
nbCompute.addComputeSteps(pipelineBlobsArray, pipelineBlobsArray.GetHashCode());
nbCompute.addPipeline(pipelineTypeArray, pipelineTypeArray.GetHashCode());
upload(nwStream, nbCompute.buf());
NetworkBuffer nbCevap = new NetworkBuffer();
download(nwStream, arrays);
}
