private void f(TcpListener listener, TcpClient client_)
{
bool tmpWorking = true;
while (tmpWorking)
{
client.ReceiveBufferSize = NetworkBuffer.receiveSendBufferSize;
client.SendBufferSize = NetworkBuffer.receiveSendBufferSize;
byte[] buffer = new byte[NetworkBuffer.receiveSendBufferSize];
//---read incoming stream---
int bytesRead = NetworkBuffer.receiveSendBufferSize;
int counter = 0;
int length = -1;
int bytesTotal = 0;
nb.resetExceptArrays();
NetworkStream nwStream = client.GetStream();
while (!nwStream.DataAvailable)
{
Thread.Sleep(1);
}
while (nwStream.CanRead && bytesRead > 0 && (length == -1 || bytesTotal < length))
{
bytesRead = nwStream.Read(buffer, 0, NetworkBuffer.receiveSendBufferSize);
if (length == -1)
{
length = nb.readLengthOfBuffer(buffer);
}
if (length == 0)
{
Console.WriteLine("Server: couldn't receive buffer.");
return;
}
else
{
if (serverBuffer.Length < length)
{
serverBuffer = new byte[length];
}
Buffer.BlockCopy(buffer, 0, serverBuffer, bytesTotal, bytesRead);
bytesTotal += bytesRead;
}
}
List <NetworkBuffer.HashIndisSiraDizi> arrays = nb.oku(serverBuffer, "server");
if (nb.bufferCommand() == NetworkBuffer.SETUP)
{
string deviceTypes = new string((char[])arrays[0].backingArray);
string kernelsString = new string((char[])arrays[1].backingArray);
string[] kernelNamesStringArray = (new string((char[])arrays[2].backingArray)).Split(" ".ToCharArray());
int localRAnge = ((int[])arrays[3].backingArray)[0];
int numberOfGPUsToUse = ((int[])arrays[4].backingArray)[0];
bool GPU_STREAM = ((bool[])arrays[5].backingArray)[0];
int MAX_CPU = ((int[])arrays[6].backingArray)[0];
openclSystemToCrunchNumbers = new Cores(
deviceTypes, kernelsString,
kernelNamesStringArray, false, localRAnge,
numberOfGPUsToUse, GPU_STREAM,
MAX_CPU);
if (openclSystemToCrunchNumbers.errorCode() != 0)
{
Console.WriteLine("Compiling error!");
Console.WriteLine(openclSystemToCrunchNumbers.errorMessage());
openclSystemToCrunchNumbers.dispose();
return;
}
NetworkBuffer nbAnswer = new NetworkBuffer(NetworkBuffer.ANSWER_SUCCESS);
byte[] bytesToSend = nbAnswer.buf();
int pos = 0;
while (pos < bytesToSend.Length)
{
int l = Math.Min(bytesToSend.Length - pos, client.ReceiveBufferSize);
nwStream.Write(bytesToSend, pos, l);
pos += l;
}
Console.WriteLine("--------------------------------------------------");
}
else if (nb.bufferCommand() == NetworkBuffer.COMPUTE)
{
string[] kernelNamesString_ = new string((char[])arrays[0].backingArray).Split(" ".ToCharArray());
int numberOfSteps = ((int[])arrays[1].backingArray)[0];
string stepFunction = new string((char[])arrays[2].backingArray);
int numberOfArrays = ((int[])arrays[3].backingArray)[0];
string[] readWrite = new string[numberOfArrays];
for (int i = 0; i < numberOfArrays; i++)
{
readWrite[i] = new string((char[])arrays[numberOfArrays + 4 + i].backingArray);
}
int[] arrayElementsPerWorkItem = new int[numberOfArrays];
for (int i = 0; i < numberOfArrays; i++)
{
arrayElementsPerWorkItem[i] = ((int[])arrays[numberOfArrays * 2 + 4].backingArray)[i];
}
int totalGlobalRange = ((int[])arrays[numberOfArrays * 2 + 5].backingArray)[0];
int computeId = ((int[])arrays[numberOfArrays * 2 + 6].backingArray)[0];
int globalRangeOffset = ((int[])arrays[numberOfArrays * 2 + 7].backingArray)[0];
bool pipelineEnabled = ((bool[])arrays[numberOfArrays * 2 + 8].backingArray)[0];
int pipelineNumberOfBlobs = ((int[])arrays[numberOfArrays * 2 + 9].backingArray)[0];
bool pipelineType = ((bool[])arrays[numberOfArrays * 2 + 10].backingArray)[0];
object[] tmpArrays = new object[numberOfArrays];
int[] tmpHashValues = new int[numberOfArrays];
for (int o = 0; o < numberOfArrays; o++)
{
tmpArrays[o] = arrays[4 + o].backingArray;
tmpHashValues[o] = arrays[4 + o].hash_;
if (!d0.ContainsKey(tmpHashValues[o]))
{
d0.Add(tmpHashValues[o], tmpArrays[o]);
d1.Add(tmpArrays[o], tmpHashValues[o]);
}
}
openclSystemToCrunchNumbers.compute(kernelNamesString_, numberOfSteps, stepFunction, tmpArrays, readWrite,
arrayElementsPerWorkItem, totalGlobalRange, computeId,
globalRangeOffset, pipelineEnabled, pipelineNumberOfBlobs, pipelineType);
openclSystemToCrunchNumbers.performanceReport(computeId);
// todo: "true ||" must be deleted but then array update is not working on same array because hash values don't match
// /
// /
// /
// /
// |
// v
if (true || nbComputeAnswer == null)
{
nbComputeAnswer = new NetworkBuffer(NetworkBuffer.ANSWER_COMPUTE_COMPLETE);
for (int m = 0; m < numberOfArrays; m++)
{
if (tmpArrays[m].GetType() == typeof(float[]))
{
nbComputeAnswer.addArray((float[])tmpArrays[m], tmpHashValues[m],
globalRangeOffset, totalGlobalRange, arrayElementsPerWorkItem[m]);
}
else if (tmpArrays[m].GetType() == typeof(int[]))
{
nbComputeAnswer.addComputeSteps((int[])tmpArrays[m], tmpHashValues[m]);
}
else if (tmpArrays[m].GetType() == typeof(byte[]))
{
nbComputeAnswer.addArray((byte[])tmpArrays[m], tmpHashValues[m]);
}
else if (tmpArrays[m].GetType() == typeof(char[]))
{
nbComputeAnswer.addCompute((char[])tmpArrays[m], tmpHashValues[m]);
}
else if (tmpArrays[m].GetType() == typeof(double[]))
{
nbComputeAnswer.addArray((double[])tmpArrays[m], tmpHashValues[m]);
}
else if (tmpArrays[m].GetType() == typeof(long[]))
{
nbComputeAnswer.addArray((long[])tmpArrays[m], tmpHashValues[m]);
}
}
}
else
{
for (int m = 0; m < numberOfArrays; m++)
{
if (tmpArrays[m].GetType() == typeof(float[]))
{
nbComputeAnswer.update((float[])tmpArrays[m], tmpHashValues[m],
globalRangeOffset, totalGlobalRange, arrayElementsPerWorkItem[m]);
}
else if (tmpArrays[m].GetType() == typeof(int[]))
{
nbComputeAnswer.update((int[])tmpArrays[m], tmpHashValues[m]);
}
else if (tmpArrays[m].GetType() == typeof(byte[]))
{
nbComputeAnswer.update((byte[])tmpArrays[m], tmpHashValues[m]);
}
else if (tmpArrays[m].GetType() == typeof(char[]))
{
nbComputeAnswer.update((char[])tmpArrays[m], tmpHashValues[m]);
}
else if (tmpArrays[m].GetType() == typeof(double[]))
{
nbComputeAnswer.update((double[])tmpArrays[m], tmpHashValues[m]);
}
else if (tmpArrays[m].GetType() == typeof(long[]))
{
nbComputeAnswer.update((long[])tmpArrays[m], tmpHashValues[m]);
}
}
}
byte[] bytesToSend = nbComputeAnswer.buf();
int pos = 0;
while (pos < bytesToSend.Length)
{
int l = Math.Min(bytesToSend.Length - pos, NetworkBuffer.receiveSendBufferSize);
nwStream.Write(bytesToSend, pos, l);
pos += l;
}
}
else if (nb.bufferCommand() == NetworkBuffer.DISPOSE)
{
Console.WriteLine("Server-side Cekirdekler API is being deleted");
openclSystemToCrunchNumbers.dispose();
NetworkBuffer nbAnswer = new NetworkBuffer(NetworkBuffer.ANSWER_DELETED);
byte[] bytesToSend = nbAnswer.buf();
int pos = 0;
while (pos < bytesToSend.Length)
{
Console.WriteLine("server: writing segment");
int l = Math.Min(bytesToSend.Length - pos, NetworkBuffer.receiveSendBufferSize);
nwStream.Write(bytesToSend, pos, l);
pos += l;
Console.WriteLine("server: segment written: " + pos + " " + bytesToSend.Length);
}
Console.WriteLine("--------------------------------------------------");
tmpWorking = false;
dispose();
}
else if (nb.bufferCommand() == NetworkBuffer.SERVER_STOP)
{
Console.WriteLine("stopping server");
NetworkBuffer nbAnswer = new NetworkBuffer(NetworkBuffer.ANSWER_STOPPED);
byte[] bytesToSend = nbAnswer.buf();
int pos = 0;
while (pos < bytesToSend.Length)
{
Console.WriteLine("server: writing segment");
int l = Math.Min(bytesToSend.Length - pos, NetworkBuffer.receiveSendBufferSize);
nwStream.Write(bytesToSend, pos, l);
pos += l;
Console.WriteLine("server: segment written: " + pos + " " + bytesToSend.Length);
}
Console.WriteLine("--------------------------------------------------");
tmpWorking = false;
server.stop();
}
else if (nb.bufferCommand() == NetworkBuffer.SERVER_CONTROL)
{
Console.WriteLine("controlling server");
NetworkBuffer nbAnswer = new NetworkBuffer(NetworkBuffer.ANSWER_CONTROL);
byte[] bytesToSend = nbAnswer.buf();
int pos = 0;
while (pos < bytesToSend.Length)
{
Console.WriteLine("server: writing segment");
int l = Math.Min(bytesToSend.Length - pos, NetworkBuffer.receiveSendBufferSize);
nwStream.Write(bytesToSend, pos, l);
pos += l;
Console.WriteLine("server: segment written: " + pos + " " + bytesToSend.Length);
}
Console.WriteLine("--------------------------------------------------");
}
else if (nb.bufferCommand() == NetworkBuffer.SERVER_NUMBER_OF_DEVICES)
{
Console.WriteLine("receiving number of devices in server");
NetworkBuffer nbAnswer = new NetworkBuffer(NetworkBuffer.ANSWER_NUMBER_OF_DEVICES);
int[] numDevices_ = new int[1];
numDevices_[0] = openclSystemToCrunchNumbers.numberOfDevices();
nbAnswer.addComputeSteps(numDevices_, numDevices_.GetHashCode());
byte[] bytesToSend = nbAnswer.buf();
int pos = 0;
while (pos < bytesToSend.Length)
{
Console.WriteLine("server: writing segment");
int l = Math.Min(bytesToSend.Length - pos, NetworkBuffer.receiveSendBufferSize);
nwStream.Write(bytesToSend, pos, l);
pos += l;
Console.WriteLine("server: segment written: " + pos + " " + bytesToSend.Length);
}
Console.WriteLine("--------------------------------------------------");
}
}
}