public CudaTest(CUDA cuda)
{
_cuda = cuda;
//+ load frame module
LoadFrameModule(Cuda.CudaModle.BuiltinModules.Test);
//+ create cuda event handles
_cudaStartEvent = _cuda.CreateEvent();
_cudaStopEvent = _cuda.CreateEvent();
}
static void Main(string[] args)
{
// Create a new instance of CUDA class, select 1st device.
CUDA cuda = new CUDA(0, true);
// Prepare parameters.
int n = 16 * 1024 * 1024;
uint nbytes = (uint)(n * sizeof(int));
int value = 26;
// allocate host memory
int[] a = new int[n];
// allocate device memory
CUdeviceptr d_a = cuda.Allocate<int>(a);
CUDADriver.cuMemsetD8(d_a, 0xff, nbytes);
// load module
cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "asyncAPI.ptx"));
CUfunction func = cuda.GetModuleFunction("increment_kernel");
// set kernel launch configuration
cuda.SetFunctionBlockShape(func, 512, 1, 1);
// create cuda event handles
CUevent start = cuda.CreateEvent();
CUevent stop = cuda.CreateEvent();
// asynchronously issue work to the GPU (all to stream 0)
CUstream stream = new CUstream();
cuda.RecordEvent(start);
cuda.CopyHostToDeviceAsync<int>(d_a, a, stream);
// set parameters for kernel function
cuda.SetParameter(func, 0, (uint)d_a.Pointer);
cuda.SetParameter(func, IntPtr.Size, (uint)value);
cuda.SetParameterSize(func, (uint)(IntPtr.Size + 4));
// actually launch kernel
cuda.LaunchAsync(func, n / 512, 1, stream);
// wait for every thing to finish, then start copy back data
cuda.CopyDeviceToHostAsync<int>(d_a, a, stream);
cuda.RecordEvent(stop);
// print the cpu and gpu times
Console.WriteLine("time spent executing by the GPU: {0} ms", cuda.ElapsedTime(start, stop));
// check the output for correctness
if (CorrectOutput(a, value))
Console.WriteLine("Test PASSED");
else
Console.WriteLine("Test FAILED");
// release resources
cuda.DestroyEvent(start);
cuda.DestroyEvent(stop);
cuda.Free(d_a);
}
static void Main(string[] args)
{
// Init and select 1st device.
CUDA cuda = new CUDA(0, true);
// load module
//cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "transpose_kernel.cubin"));
cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "transpose_kernel.ptx"));
CUfunction transpose = cuda.GetModuleFunction("transpose");
CUfunction transpose_naive = cuda.GetModuleFunction("transpose_naive");
const int size_x = 4096;
const int size_y = 4096;
const int mem_size = sizeof(float) * size_x * size_y;
float[] h_idata = new float[size_x * size_y];
for (int i = 0; i < h_idata.Length; i++)
{
h_idata[i] = (float)i;
}
// allocate device memory
// copy host memory to device
CUdeviceptr d_idata = cuda.CopyHostToDevice <float>(h_idata);
CUdeviceptr d_odata = cuda.Allocate <float>(h_idata);
// setup execution parameters
cuda.SetFunctionBlockShape(transpose_naive, BLOCK_DIM, BLOCK_DIM, 1);
cuda.SetParameter(transpose_naive, 0, (uint)d_odata.Pointer);
cuda.SetParameter(transpose_naive, IntPtr.Size, (uint)d_idata.Pointer);
cuda.SetParameter(transpose_naive, IntPtr.Size * 2, (uint)size_x);
cuda.SetParameter(transpose_naive, IntPtr.Size * 2 + 4, (uint)size_y);
cuda.SetParameterSize(transpose_naive, (uint)(IntPtr.Size * 2 + 8));
cuda.SetFunctionBlockShape(transpose, BLOCK_DIM, BLOCK_DIM, 1);
cuda.SetParameter(transpose, 0, (uint)d_odata.Pointer);
cuda.SetParameter(transpose, IntPtr.Size, (uint)d_idata.Pointer);
cuda.SetParameter(transpose, IntPtr.Size * 2, (uint)size_x);
cuda.SetParameter(transpose, IntPtr.Size * 2 + 4, (uint)size_y);
cuda.SetParameterSize(transpose, (uint)(IntPtr.Size * 2 + 8));
// warmup so we don't time CUDA startup
cuda.Launch(transpose_naive, size_x / BLOCK_DIM, size_y / BLOCK_DIM);
cuda.Launch(transpose, size_x / BLOCK_DIM, size_y / BLOCK_DIM);
//System.Threading.Thread.Sleep(10);
int numIterations = 100;
Console.WriteLine("Transposing a {0} by {1} matrix of floats...", size_x, size_y);
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
cuda.RecordEvent(start);
for (int i = 0; i < numIterations; i++)
{
cuda.Launch(transpose_naive, size_x / BLOCK_DIM, size_y / BLOCK_DIM);
}
cuda.SynchronizeContext();
cuda.RecordEvent(end);
cuda.SynchronizeContext();
float naiveTime = cuda.ElapsedTime(start, end);
Console.WriteLine("Naive transpose average time: {0} ms\n", naiveTime / numIterations);
cuda.RecordEvent(start);
for (int i = 0; i < numIterations; i++)
{
cuda.Launch(transpose, size_x / BLOCK_DIM, size_y / BLOCK_DIM);
}
cuda.SynchronizeContext();
cuda.RecordEvent(end);
cuda.SynchronizeContext();
float optimizedTime = cuda.ElapsedTime(start, end);
Console.WriteLine("Optimized transpose average time: {0} ms\n", optimizedTime / numIterations);
float[] h_odata = new float[size_x * size_y];
cuda.CopyDeviceToHost <float>(d_odata, h_odata);
float[] reference = new float[size_x * size_y];
computeGold(reference, h_idata, size_x, size_y);
bool res = CompareF(reference, h_odata, size_x * size_y);
Console.WriteLine("Test {0}", res == true? "PASSED":"FAILED");
cuda.Free(d_idata);
cuda.Free(d_odata);
Console.ReadKey();
}
static void Main(string[] args)
{
// Init and select 1st device.
CUDA cuda = new CUDA(0, true);
// load module
//cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "transpose_kernel.cubin"));
cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "transpose_kernel.ptx"));
CUfunction transpose = cuda.GetModuleFunction("transpose");
CUfunction transpose_naive = cuda.GetModuleFunction("transpose_naive");
const int size_x = 4096;
const int size_y = 4096;
const int mem_size = sizeof(float) * size_x * size_y;
float[] h_idata = new float[size_x * size_y];
for (int i = 0; i < h_idata.Length; i++)
{
h_idata[i] = (float)i;
}
// allocate device memory
// copy host memory to device
CUdeviceptr d_idata = cuda.CopyHostToDevice<float>(h_idata);
CUdeviceptr d_odata = cuda.Allocate<float>(h_idata);
// setup execution parameters
cuda.SetFunctionBlockShape(transpose_naive, BLOCK_DIM, BLOCK_DIM, 1);
cuda.SetParameter(transpose_naive, 0, (uint)d_odata.Pointer);
cuda.SetParameter(transpose_naive, IntPtr.Size, (uint)d_idata.Pointer);
cuda.SetParameter(transpose_naive, IntPtr.Size * 2, (uint)size_x);
cuda.SetParameter(transpose_naive, IntPtr.Size * 2 + 4, (uint)size_y);
cuda.SetParameterSize(transpose_naive, (uint)(IntPtr.Size * 2 + 8));
cuda.SetFunctionBlockShape(transpose, BLOCK_DIM, BLOCK_DIM, 1);
cuda.SetParameter(transpose, 0, (uint)d_odata.Pointer);
cuda.SetParameter(transpose, IntPtr.Size, (uint)d_idata.Pointer);
cuda.SetParameter(transpose, IntPtr.Size * 2, (uint)size_x);
cuda.SetParameter(transpose, IntPtr.Size * 2 + 4, (uint)size_y);
cuda.SetParameterSize(transpose, (uint)(IntPtr.Size * 2 + 8));
// warmup so we don't time CUDA startup
cuda.Launch(transpose_naive, size_x / BLOCK_DIM, size_y / BLOCK_DIM);
cuda.Launch(transpose, size_x / BLOCK_DIM, size_y / BLOCK_DIM);
//System.Threading.Thread.Sleep(10);
int numIterations = 100;
Console.WriteLine("Transposing a {0} by {1} matrix of floats...", size_x, size_y);
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
cuda.RecordEvent(start);
for (int i = 0; i < numIterations; i++)
{
cuda.Launch(transpose_naive, size_x / BLOCK_DIM, size_y / BLOCK_DIM);
}
cuda.SynchronizeContext();
cuda.RecordEvent(end);
cuda.SynchronizeContext();
float naiveTime = cuda.ElapsedTime(start, end);
Console.WriteLine("Naive transpose average time: {0} ms\n", naiveTime / numIterations);
cuda.RecordEvent(start);
for (int i = 0; i < numIterations; i++)
{
cuda.Launch(transpose, size_x / BLOCK_DIM, size_y / BLOCK_DIM);
}
cuda.SynchronizeContext();
cuda.RecordEvent(end);
cuda.SynchronizeContext();
float optimizedTime = cuda.ElapsedTime(start, end);
Console.WriteLine("Optimized transpose average time: {0} ms\n", optimizedTime / numIterations);
float[] h_odata = new float[size_x * size_y];
cuda.CopyDeviceToHost<float>(d_odata, h_odata);
float[] reference = new float[size_x * size_y];
computeGold(reference, h_idata, size_x, size_y);
bool res = CompareF(reference, h_odata, size_x * size_y);
Console.WriteLine("Test {0}", res == true? "PASSED":"FAILED");
cuda.Free(d_idata);
cuda.Free(d_odata);
Console.ReadKey();
}
/// <summary>
/// implementation of sparese matrix product
/// </summary>
/// <param name="repetition">how many times kernel should be launch</param>
/// <param name="moduleFunction">cuda kenrel name</param>
/// <param name="blockSizeX">block size X</param>
/// <param name="blockSizeY">block size Y</param>
/// <param name="transposeGrid">indicate that grid dimensions should be
/// computed alternativly, if false than gridDimY- connected with rows
/// else gridDim.Y conected with cols</param>
/// <returns></returns>
public static float[] CRSSparseMM(int repetition, string moduleFunction,
int blockSizeX, int blockSizeY, bool transposeGrid)
{
//int blockSizeX = 4;
//int blockSizeY = 4;
CUDA cuda = new CUDA(0, true);
// load module
CUmodule module = cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "matrixKernels.cubin"));
CUfunction cuFunc = cuda.GetModuleFunction(moduleFunction);
int maxRowSize = avgElements + stdElements - 1;
Console.WriteLine("------------------------------------");
Console.WriteLine("init Matrix");
Stopwatch t = Stopwatch.StartNew();
//values in CRS format
float[] AVals, BVals;
//indexes in Crs format
int[] AIdx, BIdx;
//Lenght of each row in CRS format
int[] ARowLen, BRowLen;
int maxIndex = 0;
MakeRandCrsSparseMatrix(Rows, maxRowSize, out AVals, out AIdx, out ARowLen, out maxIndex);
// DisplayCrsMatrix(AVals, AIdx, ARowLen,maxIndex);
MakeRandCrsSparseMatrix(Cols, maxRowSize, out BVals, out BIdx, out BRowLen, out maxIndex);
//DisplayCrsMatrix(BVals, BIdx, BRowLen, maxIndex);
Console.WriteLine("Init takes {0}", t.Elapsed);
t.Start();
CUdeviceptr AValsPtr = cuda.CopyHostToDevice(AVals);
CUdeviceptr AIdxPtr = cuda.CopyHostToDevice(AIdx);
CUdeviceptr ALenghtPtr = cuda.CopyHostToDevice(ARowLen);
CUdeviceptr BValsPtr = cuda.CopyHostToDevice(BVals);
CUdeviceptr BIdxPtr = cuda.CopyHostToDevice(BIdx);
CUdeviceptr BLenghtPtr = cuda.CopyHostToDevice(BRowLen);
int outputSize = Rows * Cols;
float[] output = new float[outputSize];
//CUdeviceptr dOutput = cuda.Allocate(output);
IntPtr outputPtr2 = cuda.HostAllocate((uint)(outputSize * sizeof(float)), CUDADriver.CU_MEMHOSTALLOC_DEVICEMAP);
CUdeviceptr dOutput = cuda.GetHostDevicePointer(outputPtr2, 0);
Console.WriteLine("copy to device takes {0}", t.Elapsed);
#region set cuda parameters
int Aelements = AVals.Length;
int Belements = BVals.Length;
cuda.SetFunctionBlockShape(cuFunc, blockSizeX, blockSizeY, 1);
int offset = 0;
cuda.SetParameter(cuFunc, offset, AValsPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, AIdxPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, ALenghtPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, BValsPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, BIdxPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, BLenghtPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, dOutput.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, (uint)Rows);
offset += sizeof(int);
cuda.SetParameter(cuFunc, offset, (uint)Cols);
offset += sizeof(int);
cuda.SetParameter(cuFunc, offset, (uint)Aelements);
offset += sizeof(int);
cuda.SetParameter(cuFunc, offset, (uint)Belements);
offset += sizeof(int);
cuda.SetParameterSize(cuFunc, (uint)offset);
#endregion
Console.WriteLine("start computation");
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
//CUtexref cuTexRef = cuda.GetModuleTexture(module, "texRef");
//cuda.SetTextureFlags(cuTexRef, 0);
int gridDimX = (int)Math.Ceiling((Cols + 0.0) / (blockSizeX));
int gridDimY = (int)Math.Ceiling((0.0 + Rows) / blockSizeY);
if (transposeGrid)
{
gridDimX = (int)Math.Ceiling((Rows + 0.0) / (blockSizeX));
gridDimY = (int)Math.Ceiling((0.0 + Cols) / blockSizeY);
}
Stopwatch timer = Stopwatch.StartNew();
cuda.RecordEvent(start);
for (int k = 0; k < repetition; k++)
{
cuda.Launch(cuFunc, gridDimX, gridDimY);
cuda.SynchronizeContext();
// cuda.CopyDeviceToHost(dOutput, output);
Marshal.Copy(outputPtr2, output, 0, outputSize);
}
cuda.RecordEvent(end);
cuda.SynchronizeContext();
timer.Stop();
float cudaTime = cuda.ElapsedTime(start, end);
Console.WriteLine("Matrix products with kernel {0}", moduleFunction);
Console.WriteLine(" takes {0} ms stopwatch time {1} ms", cudaTime, timer.Elapsed);
int lenght = displayCount;// Math.Min(displayCount, Rows);
Console.WriteLine();
for (int i = 0; i < lenght; i++)
{
Console.WriteLine("{0}-{1}", i, output[i]);
}
cuda.Free(AValsPtr);
cuda.Free(AIdxPtr);
cuda.Free(ALenghtPtr);
cuda.Free(BValsPtr);
cuda.Free(BIdxPtr);
cuda.Free(BLenghtPtr);
cuda.Free(dOutput);
cuda.DestroyEvent(start);
cuda.DestroyEvent(end);
return(output);
}
public static float[] CRSSparseMMwithDenseVector(int repetition,
string moduleFunction, int blockSizeX, int blockSizeY)
{
CUDA cuda = new CUDA(0, true);
// load module
CUmodule module = cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "matrixKernels.cubin"));
CUfunction cuFunc = cuda.GetModuleFunction(moduleFunction);
int maxRowSize = avgElements + stdElements - 1;
Console.WriteLine("------------------------------------");
Console.WriteLine("init Matrix");
Stopwatch t = Stopwatch.StartNew();
//values in CRS format
float[] AVals, BVals;
//indexes in Crs format
int[] AIdx, BIdx;
//Lenght of each row in CRS format
int[] ARowLen, BRowLen;
int maxIndex = 0;
MakeRandCrsSparseMatrix(Rows, maxRowSize, out AVals, out AIdx, out ARowLen, out maxIndex);
// DisplayCrsMatrix(AVals, AIdx, ARowLen,maxIndex);
MakeRandCrsSparseMatrix(Cols, maxRowSize, out BVals, out BIdx, out BRowLen, out maxIndex);
//DisplayCrsMatrix(BVals, BIdx, BRowLen, maxIndex);
Console.WriteLine("Init takes {0}", t.Elapsed);
t.Start();
CUdeviceptr AValsPtr = cuda.CopyHostToDevice(AVals);
CUdeviceptr AIdxPtr = cuda.CopyHostToDevice(AIdx);
CUdeviceptr ALenghtPtr = cuda.CopyHostToDevice(ARowLen);
int outputSize = Rows * Cols;
float[] output = new float[outputSize];
//allocate memory for output
IntPtr outputPtr2 = cuda.HostAllocate((uint)(outputSize * sizeof(float)), CUDADriver.CU_MEMHOSTALLOC_DEVICEMAP);
CUdeviceptr dOutput = cuda.GetHostDevicePointer(outputPtr2, 0);
//create dense vector for each column in B matrix
float[] mainVec = new float[maxIndex + 1];
uint memSize = (uint)((maxIndex + 1) * sizeof(float));
CUstream stream0 = cuda.CreateStream();
IntPtr[] mainVecIntPtrs = new IntPtr[2];
//write combined memory allocation
//IntPtr mainVecIPtr = cuda.HostAllocate(memSize,CUDADriver.CU_MEMHOSTALLOC_WRITECOMBINED);
//CUdeviceptr mainVecPtr=cuda.CopyHostToDeviceAsync(mainVecIPtr,memSize,stream0);
//
//mainVecIntPtrs[0] = cuda.HostAllocate(memSize, CUDADriver.CU_MEMHOSTALLOC_WRITECOMBINED);
//mainVecIntPtrs[1] = cuda.HostAllocate(memSize, CUDADriver.CU_MEMHOSTALLOC_WRITECOMBINED);
mainVecIntPtrs[0] = cuda.AllocateHost(memSize);
mainVecIntPtrs[1] = cuda.AllocateHost(memSize);
CUdeviceptr mainVecPtr = cuda.CopyHostToDeviceAsync(mainVecIntPtrs[0], memSize, stream0);
//IntPtr mainVecIPtr = cuda.HostAllocate(memSize,CUDADriver.CU_MEMHOSTALLOC_PORTABLE);
//CUdeviceptr mainVecPtr=cuda.CopyHostToDeviceAsync(mainVecIPtr,memSize,stream0);
//mapped memory allocation
//IntPtr mainVecIPtr = cuda.HostAllocate(memSize, CUDADriver.CU_MEMHOSTALLOC_DEVICEMAP);
//CUdeviceptr mainVecPtr = cuda.CopyHostToDevice(mainVecIPtr, memSize);
//get texture reference
CUtexref cuTexRef = cuda.GetModuleTexture(module, "vectorTexRef");
cuda.SetTextureFlags(cuTexRef, 0);
cuda.SetTextureAddress(cuTexRef, mainVecPtr, memSize);
Console.WriteLine("copy to device takes {0}", t.Elapsed);
#region set cuda parameters
int Aelements = AVals.Length;
cuda.SetFunctionBlockShape(cuFunc, blockSizeX, blockSizeY, 1);
int offset = 0;
cuda.SetParameter(cuFunc, offset, AValsPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, AIdxPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, ALenghtPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, dOutput.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, (uint)Rows);
offset += sizeof(int);
cuda.SetParameter(cuFunc, offset, (uint)Cols);
offset += sizeof(int);
int colIndexParamOffset = offset;
cuda.SetParameter(cuFunc, offset, (uint)0);
offset += sizeof(int);
cuda.SetParameterSize(cuFunc, (uint)offset);
#endregion
Console.WriteLine("start computation");
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
int gridDimX = (int)Math.Ceiling((Rows + 0.0) / (blockSizeX));
int gridDim = (Rows + blockSizeX - 1) / blockSizeX;
Stopwatch timer = Stopwatch.StartNew();
cuda.RecordEvent(start);
for (int rep = 0; rep < repetition; rep++)
{
for (int k = 0; k < Cols; k++)
{
Helpers.InitBuffer(BVals, BIdx, BRowLen, k, mainVecIntPtrs[k % 2]);
cuda.SynchronizeStream(stream0);
cuda.CopyHostToDeviceAsync(mainVecPtr, mainVecIntPtrs[k % 2], memSize, stream0);
cuda.SetParameter(cuFunc, colIndexParamOffset, (uint)k);
cuda.LaunchAsync(cuFunc, gridDimX, 1, stream0);
//cuda.SynchronizeStream(stream0);
////clear host buffer
Helpers.SetBufferIdx(BIdx, BRowLen, k - 1, mainVecIntPtrs[(k + 1) % 2], 0.0f);
//Helpers.InitBuffer(BVals, BIdx, BRowLen, k, mainVecIPtr);
////make asynchronius copy and kernel lauch
//cuda.CopyHostToDeviceAsync(mainVecPtr, mainVecIPtr, memSize, stream0);
//cuda.SetParameter(cuFunc, colIndexParamOffset,(uint) k);
//cuda.LaunchAsync(cuFunc, gridDimX, 1, stream0);
//cuda.SynchronizeStream(stream0);
////clear host buffer
//Helpers.SetBufferIdx(BIdx, BRowLen, k, mainVecIPtr, 0.0f);
}
}
cuda.RecordEvent(end);
cuda.SynchronizeContext();
timer.Stop();
float cudaTime = cuda.ElapsedTime(start, end);
Marshal.Copy(outputPtr2, output, 0, outputSize);
Console.WriteLine("Matrix products with kernel {0}", moduleFunction);
Console.WriteLine(" takes {0} ms stopwatch time {1} ms", cudaTime, timer.Elapsed);
int lenght = displayCount;// Math.Min(displayCount, Rows);
Console.WriteLine();
for (int i = 0; i < lenght; i++)
{
Console.WriteLine("{0}-{1}", i, output[i]);
}
cuda.Free(AValsPtr);
cuda.Free(AIdxPtr);
cuda.Free(ALenghtPtr);
cuda.Free(dOutput);
cuda.DestroyEvent(start);
cuda.DestroyEvent(end);
cuda.DestroyStream(stream0);
cuda.Free(mainVecPtr);
cuda.DestroyTexture(cuTexRef);
return(output);
}
/// <summary>
/// implementation of sparese matrix product
/// </summary>
/// <param name="repetition">how many times kernel should be launch</param>
/// <param name="moduleFunction">cuda kenrel name</param>
/// <param name="blockSizeX">block size X</param>
/// <param name="blockSizeY">block size Y</param>
/// <param name="transposeGrid">indicate that grid dimensions should be
/// computed alternativly, if false than gridDimY- connected with rows
/// else gridDim.Y conected with cols</param>
/// <returns></returns>
public static float[] CRSSparseMM(int repetition, string moduleFunction,
int blockSizeX,int blockSizeY, bool transposeGrid)
{
//int blockSizeX = 4;
//int blockSizeY = 4;
CUDA cuda = new CUDA(0, true);
// load module
CUmodule module = cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "matrixKernels.cubin"));
CUfunction cuFunc = cuda.GetModuleFunction(moduleFunction);
int maxRowSize = avgElements + stdElements - 1;
Console.WriteLine("------------------------------------");
Console.WriteLine("init Matrix");
Stopwatch t = Stopwatch.StartNew();
//values in CRS format
float[] AVals, BVals;
//indexes in Crs format
int[] AIdx, BIdx;
//Lenght of each row in CRS format
int[] ARowLen, BRowLen;
int maxIndex = 0;
MakeRandCrsSparseMatrix(Rows, maxRowSize, out AVals, out AIdx, out ARowLen,out maxIndex);
// DisplayCrsMatrix(AVals, AIdx, ARowLen,maxIndex);
MakeRandCrsSparseMatrix(Cols, maxRowSize, out BVals, out BIdx, out BRowLen,out maxIndex);
//DisplayCrsMatrix(BVals, BIdx, BRowLen, maxIndex);
Console.WriteLine("Init takes {0}", t.Elapsed);
t.Start();
CUdeviceptr AValsPtr = cuda.CopyHostToDevice(AVals);
CUdeviceptr AIdxPtr = cuda.CopyHostToDevice(AIdx);
CUdeviceptr ALenghtPtr = cuda.CopyHostToDevice(ARowLen);
CUdeviceptr BValsPtr = cuda.CopyHostToDevice(BVals);
CUdeviceptr BIdxPtr = cuda.CopyHostToDevice(BIdx);
CUdeviceptr BLenghtPtr = cuda.CopyHostToDevice(BRowLen);
int outputSize = Rows * Cols;
float[] output = new float[outputSize];
//CUdeviceptr dOutput = cuda.Allocate(output);
IntPtr outputPtr2 = cuda.HostAllocate((uint)(outputSize * sizeof(float)), CUDADriver.CU_MEMHOSTALLOC_DEVICEMAP);
CUdeviceptr dOutput = cuda.GetHostDevicePointer(outputPtr2, 0);
Console.WriteLine("copy to device takes {0}", t.Elapsed);
#region set cuda parameters
int Aelements = AVals.Length;
int Belements = BVals.Length;
cuda.SetFunctionBlockShape(cuFunc,blockSizeX,blockSizeY, 1);
int offset = 0;
cuda.SetParameter(cuFunc, offset, AValsPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, AIdxPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, ALenghtPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, BValsPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, BIdxPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, BLenghtPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, dOutput.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, (uint)Rows);
offset += sizeof(int);
cuda.SetParameter(cuFunc, offset, (uint)Cols);
offset += sizeof(int);
cuda.SetParameter(cuFunc, offset, (uint)Aelements);
offset += sizeof(int);
cuda.SetParameter(cuFunc, offset, (uint)Belements);
offset += sizeof(int);
cuda.SetParameterSize(cuFunc, (uint)offset);
#endregion
Console.WriteLine("start computation");
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
//CUtexref cuTexRef = cuda.GetModuleTexture(module, "texRef");
//cuda.SetTextureFlags(cuTexRef, 0);
int gridDimX =(int) Math.Ceiling((Cols + 0.0) / (blockSizeX));
int gridDimY = (int)Math.Ceiling((0.0+Rows)/blockSizeY);
if (transposeGrid)
{
gridDimX = (int)Math.Ceiling((Rows + 0.0) / (blockSizeX));
gridDimY = (int)Math.Ceiling((0.0 + Cols) / blockSizeY);
}
Stopwatch timer = Stopwatch.StartNew();
cuda.RecordEvent(start);
for (int k = 0; k < repetition; k++)
{
cuda.Launch(cuFunc, gridDimX, gridDimY);
cuda.SynchronizeContext();
// cuda.CopyDeviceToHost(dOutput, output);
Marshal.Copy(outputPtr2, output, 0, outputSize);
}
cuda.RecordEvent(end);
cuda.SynchronizeContext();
timer.Stop();
float cudaTime = cuda.ElapsedTime(start, end);
Console.WriteLine("Matrix products with kernel {0}",moduleFunction);
Console.WriteLine(" takes {0} ms stopwatch time {1} ms", cudaTime, timer.Elapsed);
int lenght = displayCount;// Math.Min(displayCount, Rows);
Console.WriteLine();
for (int i = 0; i < lenght; i++)
{
Console.WriteLine("{0}-{1}", i, output[i]);
}
cuda.Free(AValsPtr);
cuda.Free(AIdxPtr);
cuda.Free(ALenghtPtr);
cuda.Free(BValsPtr);
cuda.Free(BIdxPtr);
cuda.Free(BLenghtPtr);
cuda.Free(dOutput);
cuda.DestroyEvent(start);
cuda.DestroyEvent(end);
return output;
}
public static float[] CRSSparseMMwithDenseVector(int repetition,
string moduleFunction, int blockSizeX, int blockSizeY)
{
CUDA cuda = new CUDA(0, true);
// load module
CUmodule module = cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "matrixKernels.cubin"));
CUfunction cuFunc = cuda.GetModuleFunction(moduleFunction);
int maxRowSize = avgElements + stdElements - 1;
Console.WriteLine("------------------------------------");
Console.WriteLine("init Matrix");
Stopwatch t = Stopwatch.StartNew();
//values in CRS format
float[] AVals, BVals;
//indexes in Crs format
int[] AIdx, BIdx;
//Lenght of each row in CRS format
int[] ARowLen, BRowLen;
int maxIndex = 0;
MakeRandCrsSparseMatrix(Rows, maxRowSize, out AVals, out AIdx, out ARowLen, out maxIndex);
// DisplayCrsMatrix(AVals, AIdx, ARowLen,maxIndex);
MakeRandCrsSparseMatrix(Cols, maxRowSize, out BVals, out BIdx, out BRowLen, out maxIndex);
//DisplayCrsMatrix(BVals, BIdx, BRowLen, maxIndex);
Console.WriteLine("Init takes {0}", t.Elapsed);
t.Start();
CUdeviceptr AValsPtr = cuda.CopyHostToDevice(AVals);
CUdeviceptr AIdxPtr = cuda.CopyHostToDevice(AIdx);
CUdeviceptr ALenghtPtr = cuda.CopyHostToDevice(ARowLen);
int outputSize = Rows * Cols;
float[] output = new float[outputSize];
//allocate memory for output
IntPtr outputPtr2 = cuda.HostAllocate((uint)(outputSize * sizeof(float)), CUDADriver.CU_MEMHOSTALLOC_DEVICEMAP);
CUdeviceptr dOutput = cuda.GetHostDevicePointer(outputPtr2, 0);
//create dense vector for each column in B matrix
float[] mainVec = new float[maxIndex + 1];
uint memSize = (uint)((maxIndex + 1) * sizeof(float));
CUstream stream0 =cuda.CreateStream();
IntPtr[] mainVecIntPtrs= new IntPtr[2];
//write combined memory allocation
//IntPtr mainVecIPtr = cuda.HostAllocate(memSize,CUDADriver.CU_MEMHOSTALLOC_WRITECOMBINED);
//CUdeviceptr mainVecPtr=cuda.CopyHostToDeviceAsync(mainVecIPtr,memSize,stream0);
//
//mainVecIntPtrs[0] = cuda.HostAllocate(memSize, CUDADriver.CU_MEMHOSTALLOC_WRITECOMBINED);
//mainVecIntPtrs[1] = cuda.HostAllocate(memSize, CUDADriver.CU_MEMHOSTALLOC_WRITECOMBINED);
mainVecIntPtrs[0] = cuda.AllocateHost(memSize);
mainVecIntPtrs[1] = cuda.AllocateHost(memSize);
CUdeviceptr mainVecPtr = cuda.CopyHostToDeviceAsync(mainVecIntPtrs[0], memSize, stream0);
//IntPtr mainVecIPtr = cuda.HostAllocate(memSize,CUDADriver.CU_MEMHOSTALLOC_PORTABLE);
//CUdeviceptr mainVecPtr=cuda.CopyHostToDeviceAsync(mainVecIPtr,memSize,stream0);
//mapped memory allocation
//IntPtr mainVecIPtr = cuda.HostAllocate(memSize, CUDADriver.CU_MEMHOSTALLOC_DEVICEMAP);
//CUdeviceptr mainVecPtr = cuda.CopyHostToDevice(mainVecIPtr, memSize);
//get texture reference
CUtexref cuTexRef = cuda.GetModuleTexture(module, "vectorTexRef");
cuda.SetTextureFlags(cuTexRef, 0);
cuda.SetTextureAddress(cuTexRef, mainVecPtr, memSize);
Console.WriteLine("copy to device takes {0}", t.Elapsed);
#region set cuda parameters
int Aelements = AVals.Length;
cuda.SetFunctionBlockShape(cuFunc, blockSizeX, blockSizeY, 1);
int offset = 0;
cuda.SetParameter(cuFunc, offset, AValsPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, AIdxPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, ALenghtPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, dOutput.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, (uint)Rows);
offset += sizeof(int);
cuda.SetParameter(cuFunc, offset, (uint)Cols);
offset += sizeof(int);
int colIndexParamOffset = offset;
cuda.SetParameter(cuFunc, offset, (uint)0);
offset += sizeof(int);
cuda.SetParameterSize(cuFunc, (uint)offset);
#endregion
Console.WriteLine("start computation");
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
int gridDimX = (int)Math.Ceiling((Rows + 0.0) / (blockSizeX));
int gridDim= (Rows + blockSizeX - 1) / blockSizeX;
Stopwatch timer = Stopwatch.StartNew();
cuda.RecordEvent(start);
for (int rep = 0; rep < repetition; rep++)
{
for (int k = 0; k < Cols; k++)
{
Helpers.InitBuffer(BVals, BIdx, BRowLen, k, mainVecIntPtrs[k % 2]);
cuda.SynchronizeStream(stream0);
cuda.CopyHostToDeviceAsync(mainVecPtr, mainVecIntPtrs[k % 2], memSize, stream0);
cuda.SetParameter(cuFunc, colIndexParamOffset,(uint) k);
cuda.LaunchAsync(cuFunc, gridDimX, 1, stream0);
//cuda.SynchronizeStream(stream0);
////clear host buffer
Helpers.SetBufferIdx(BIdx, BRowLen, k-1, mainVecIntPtrs[(k+1) % 2], 0.0f);
//Helpers.InitBuffer(BVals, BIdx, BRowLen, k, mainVecIPtr);
////make asynchronius copy and kernel lauch
//cuda.CopyHostToDeviceAsync(mainVecPtr, mainVecIPtr, memSize, stream0);
//cuda.SetParameter(cuFunc, colIndexParamOffset,(uint) k);
//cuda.LaunchAsync(cuFunc, gridDimX, 1, stream0);
//cuda.SynchronizeStream(stream0);
////clear host buffer
//Helpers.SetBufferIdx(BIdx, BRowLen, k, mainVecIPtr, 0.0f);
}
}
cuda.RecordEvent(end);
cuda.SynchronizeContext();
timer.Stop();
float cudaTime = cuda.ElapsedTime(start, end);
Marshal.Copy(outputPtr2, output, 0, outputSize);
Console.WriteLine("Matrix products with kernel {0}", moduleFunction);
Console.WriteLine(" takes {0} ms stopwatch time {1} ms", cudaTime, timer.Elapsed);
int lenght = displayCount;// Math.Min(displayCount, Rows);
Console.WriteLine();
for (int i = 0; i < lenght; i++)
{
Console.WriteLine("{0}-{1}", i, output[i]);
}
cuda.Free(AValsPtr);
cuda.Free(AIdxPtr);
cuda.Free(ALenghtPtr);
cuda.Free(dOutput);
cuda.DestroyEvent(start);
cuda.DestroyEvent(end);
cuda.DestroyStream(stream0);
cuda.Free(mainVecPtr);
cuda.DestroyTexture(cuTexRef);
return output;
}
private static float[] CuRBFCSRCached()
{
//always the same values
Random rnd = new Random(1);
CUDA cuda = new CUDA(0, true);
// load module
CUmodule module = cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "structKernel.cubin"));
CUfunction structPassFunc = cuda.GetModuleFunction("RBFspmv_csr_vector");
int maxRowSize = avgElements + stdElements - 1;
Console.WriteLine("init arrays");
Stopwatch t = Stopwatch.StartNew();
List<float> vecValsL = new List<float>(N * maxRowSize / 2);
List<int> vecIdxL = new List<int>(N * maxRowSize / 2);
List<int> vecLenghtL = new List<int>(N);
float[] vecVals;
int[] vecIdx;
int[] vecLenght;
float[] selfDot = new float[N];
maxIndex = 0;
int vecStartIdx = 0;
for (int i = 0; i < N; i++)
{
int vecSize = avgElements + i % stdElements;
float[] vals = Helpers.InitValues(i, vecSize, maxVal);
vecValsL.AddRange(vals);
for (int z = 0; z < vals.Length; z++)
{
selfDot[i] += vals[z] * vals[z];
}
int[] index = Helpers.InitIndices(i, vecSize, ref maxIndex);
vecIdxL.AddRange(index);
vecLenghtL.Add(vecStartIdx);
vecStartIdx += vecSize;
}
//for last index
vecLenghtL.Add(vecStartIdx);
vecVals = vecValsL.ToArray();
vecIdx = vecIdxL.ToArray();
vecLenght = vecLenghtL.ToArray();
float[] mainVec = new float[maxIndex + 1];
for (int j = vecLenght[mainIndex]; j < vecLenght[mainIndex + 1]; j++)
{
int idx = vecIdx[j];
float val = vecVals[j];
mainVec[idx] = val;
}
Console.WriteLine("Init takes {0}", t.Elapsed);
t.Start();
CUdeviceptr valsPtr = cuda.CopyHostToDevice(vecVals);
CUdeviceptr idxPtr = cuda.CopyHostToDevice(vecIdx);
CUdeviceptr vecLenghtPtr = cuda.CopyHostToDevice(vecLenght);
CUdeviceptr selfDotPtr = cuda.CopyHostToDevice(selfDot);
//copy to texture
CUarray cuArr = cuda.CreateArray(mainVec);
cuda.CopyHostToArray(cuArr, mainVec, 0);
CUtexref cuTexRef = cuda.GetModuleTexture(module, "texRef");
cuda.SetTextureFlags(cuTexRef, 0);
cuda.SetTextureArray(cuTexRef, cuArr);
float[] output = new float[N];
CUdeviceptr dOutput = cuda.Allocate(output);
Console.WriteLine("copy to device takes {0}", t.Elapsed);
cuda.SetFunctionBlockShape(structPassFunc, threadsPerBlock, 1, 1);
int offset = 0;
cuda.SetParameter(structPassFunc, offset, valsPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, idxPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, vecLenghtPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, selfDotPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, dOutput.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, (uint)N);
offset += sizeof(int);
cuda.SetParameter(structPassFunc, offset, (uint)mainIndex);
offset += sizeof(int);
cuda.SetParameter(structPassFunc, offset, Gamma);
offset += sizeof(float);
cuda.SetParameter(structPassFunc, offset, (uint)vecStartIdx);
offset += sizeof(int);
cuda.SetParameterSize(structPassFunc, (uint)offset);
Console.WriteLine("start computation");
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
Stopwatch timer = Stopwatch.StartNew();
cuda.RecordEvent(start);
cuda.Launch(structPassFunc, blocksPerGrid, 1);
cuda.RecordEvent(end);
cuda.SynchronizeContext();
//cuda.SynchronizeEvent(end);
timer.Stop();
float naiveTime = cuda.ElapsedTime(start, end);
Console.Write("csr vector Dot products with mainIndex {0} and {1}-vectors takes {2} ms stopwatch time {3} ms", mainIndex, N, naiveTime, timer.Elapsed);
cuda.CopyDeviceToHost(dOutput, output);
int lenght = Math.Min(displayCount, N);
Console.WriteLine();
for (int i = 0; i < lenght; i++)
{
Console.WriteLine("{0}-{1}", i, output[i]);
}
cuda.Free(valsPtr);
cuda.Free(idxPtr);
cuda.Free(dOutput);
cuda.Free(selfDotPtr);
cuda.Free(vecLenghtPtr);
cuda.DestroyArray(cuArr);
cuda.DestroyTexture(cuTexRef);
cuda.DestroyEvent(start);
cuda.DestroyEvent(end);
return output;
}
private static unsafe float[] CuDotProdSparseVecStruct()
{
int sparseVecSize = sizeof(SparseVecPtr);
uint size = (uint)(N * sizeof(SparseVecPtr));
//always the same values
Random rnd = new Random(1);
CUDA cuda = new CUDA(0, true);
// load module
cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "structKernel.cubin"));
//CUfunction structPassFunc = cuda.GetModuleFunction("DotProd");
CUfunction structPassFunc = cuda.GetModuleFunction("DotProd2");
SparseVecPtr[] vectors = new SparseVecPtr[N];
Console.WriteLine("init and copy data");
Stopwatch t = Stopwatch.StartNew();
mainIndex = StartingIndex;
for (int i = 0; i < N; i++)
{
vectors[i] = new SparseVecPtr();
int vecSize = avgElements + i % stdElements;
vectors[i].size = vecSize;
float[] vals = Helpers.InitValues(i, vecSize, maxVal);
int[] index = Helpers.InitIndices(i, vecSize, ref maxIndex);
CUdeviceptr valsPtr = cuda.CopyHostToDevice(vals);
CUdeviceptr idxPtr = cuda.CopyHostToDevice(index);
vectors[i].indices = new IntPtr(idxPtr.Pointer);
vectors[i].values = (IntPtr)valsPtr.Pointer;
}
GCHandle handle = GCHandle.Alloc(vectors, GCHandleType.Pinned);
IntPtr ptr = handle.AddrOfPinnedObject();
float[] output = new float[N];
//CUdeviceptr dVectors = cuda.CopyHostToDevice(vectors);
CUdeviceptr dVectors = cuda.CopyHostToDevice(ptr, size);
CUdeviceptr dOutput = cuda.Allocate(output);
Console.WriteLine("copy and init takes {0}", t.Elapsed);
#region set cuda parameters
cuda.SetFunctionBlockShape(structPassFunc, threadsPerBlock, 1, 1);
int offset = 0;
cuda.SetParameter(structPassFunc, offset, dVectors.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, dOutput.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, (uint)mainIndex);
offset += sizeof(int);
cuda.SetParameter(structPassFunc, offset, (uint)N);
offset += sizeof(int);
cuda.SetParameterSize(structPassFunc, (uint)offset);
#endregion
Console.WriteLine("start computation");
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
Stopwatch timer = Stopwatch.StartNew();
cuda.RecordEvent(start);
cuda.Launch(structPassFunc, blocksPerGrid, 1);
cuda.RecordEvent(end);
cuda.SynchronizeContext();
//cuda.SynchronizeEvent(end);
timer.Stop();
float naiveTime = cuda.ElapsedTime(start, end);
Console.Write("Dot products with mainIndex {0} and {1}-vectors takes {2} ms stopwatch time {3} ms", mainIndex, N, naiveTime, timer.Elapsed);
cuda.CopyDeviceToHost(dOutput, output);
int lenght = Math.Min(displayCount, N);
Console.WriteLine();
for (int i = 0; i < lenght; i++)
{
Console.WriteLine("{0}-{1}", i, output[i]);
}
cuda.Free(dVectors);
cuda.Free(dOutput);
return output;
}
private static float[] CuDotProdEllPackTexCached()
{
//always the same values
Random rnd = new Random(1);
CUDA cuda = new CUDA(0, true);
// load module
CUmodule module = cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "structKernel.cubin"));
CUfunction structPassFunc = cuda.GetModuleFunction("DotProdEllPackCached");
int maxRowSize = avgElements + stdElements - 1;
Console.WriteLine("init arrays");
Stopwatch t = Stopwatch.StartNew();
float[] vecVals = new float[N * maxRowSize];
int[] vecIdx = new int[N * maxRowSize];
maxIndex = 0;
for (int i = 0; i < N; i++)
{
int vecSize = avgElements + i % stdElements;
float[] vals = Helpers.InitValues(i, vecSize, maxVal);
//values are column-major aligment
for (int z = 0; z < vals.Length; z++)
{
int m = z * N + i;
vecVals[m] = vals[z];
}
//Array.Copy(vals,0,vecVals,i*maxRowSize,vals.Length);
int[] index = Helpers.InitIndices(i, vecSize, ref maxIndex);
//Array.Copy(index, 0, vecIdx, i * maxRowSize, index.Length);
for (int z = 0; z < index.Length; z++)
{
int m = z * N + i;
vecIdx[m] = index[z];
}
}
float[] mainVec = new float[maxIndex + 1];
for (int j = 0; j < maxRowSize; j++)
{
int idx = vecIdx[mainIndex + N * j];
float val = vecVals[mainIndex + N * j];
mainVec[idx] = val;
}
Console.WriteLine("Init takes {0}", t.Elapsed);
t.Start();
CUdeviceptr valsPtr = cuda.CopyHostToDevice(vecVals);
CUdeviceptr idxPtr = cuda.CopyHostToDevice(vecIdx);
CUarray cuArr = cuda.CreateArray(mainVec);
cuda.CopyHostToArray(cuArr, mainVec, 0);
//CUDAArrayDescriptor cuDesc = new CUDAArrayDescriptor();
//cuDesc.Format = CUArrayFormat.Float;
//cuDesc.NumChannels = 1;
//cuDesc.Width = maxIndex+1;
CUtexref cuTexRef = cuda.GetModuleTexture(module, "texRef");
cuda.SetTextureFlags(cuTexRef, 0);
cuda.SetTextureArray(cuTexRef, cuArr);
float[] output = new float[N];
CUdeviceptr dOutput = cuda.Allocate(output);
Console.WriteLine("copy to device takes {0}", t.Elapsed);
cuda.SetFunctionBlockShape(structPassFunc, threadsPerBlock, 1, 1);
int offset = 0;
cuda.SetParameter(structPassFunc, offset, valsPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, idxPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, dOutput.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, (uint)maxRowSize);
offset += sizeof(int);
cuda.SetParameter(structPassFunc, offset, (uint)N);
offset += sizeof(int);
cuda.SetParameterSize(structPassFunc, (uint)offset);
Console.WriteLine("start computation");
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
Stopwatch timer = Stopwatch.StartNew();
cuda.RecordEvent(start);
cuda.Launch(structPassFunc, blocksPerGrid, 1);
cuda.RecordEvent(end);
cuda.SynchronizeContext();
//cuda.SynchronizeEvent(end);
timer.Stop();
float naiveTime = cuda.ElapsedTime(start, end);
Console.Write("EllPack Cached Dot products with mainIndex {0} and {1}-vectors takes {2} ms stopwatch time {3} ms", mainIndex, N, naiveTime, timer.Elapsed);
cuda.CopyDeviceToHost(dOutput, output);
int lenght = Math.Min(displayCount, N);
Console.WriteLine();
for (int i = 0; i < lenght; i++)
{
Console.WriteLine("{0}-{1}", i, output[i]);
}
cuda.Free(valsPtr);
cuda.Free(idxPtr);
cuda.Free(dOutput);
cuda.DestroyArray(cuArr);
cuda.DestroyTexture(cuTexRef);
return output;
}
private static void CuAddVec()
{
int N = 50000;
uint size = (uint)N * sizeof(float);
CUDA cuda = new CUDA(0, true);
// load module
cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "structKernel.cubin"));
CUfunction vecAddFunc = cuda.GetModuleFunction("VecAdd");
float[] A = new float[N];
float[] B = new float[N];
float[] C = new float[N];
for (int i = 0; i < A.Length; i++)
{
A[i] = (float)i;
B[i] = (float)i + 0.1f;
}
CUdeviceptr dA = cuda.CopyHostToDevice(A);
CUdeviceptr dB = cuda.CopyHostToDevice(B);
CUdeviceptr dC = cuda.Allocate(A);
int threadsPerBlock = 256;
int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
//error = cuFuncSetBlockShape(vecAdd, threadsPerBlock, 1, 1);
cuda.SetFunctionBlockShape(vecAddFunc, threadsPerBlock, 1, 1);
int offset = 0;
cuda.SetParameter(vecAddFunc, offset, (uint)dA.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(vecAddFunc, offset, (uint)dB.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(vecAddFunc, offset, (uint)dC.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(vecAddFunc, offset, (uint)N);
offset += sizeof(int);
cuda.SetParameterSize(vecAddFunc, (uint)offset);
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
cuda.RecordEvent(start);
cuda.Launch(vecAddFunc, blocksPerGrid, 1);
cuda.RecordEvent(end);
cuda.SynchronizeContext();
//cuda.SynchronizeEvent(end);
float naiveTime = cuda.ElapsedTime(start, end);
Console.Write("adding takes {0}ms", naiveTime);
cuda.CopyDeviceToHost(dC, C);
for (int i = 0; i < 10; i++)
{
Console.WriteLine("{0}-{1}", i, C[i]);
}
}
//private static void InitMainVector(float[] vecVals, int[] vecIdx, int[] vecLenght, float[] mainVec)
//{
// for (int j = vecLenght[mainIndex]; j < vecLenght[mainIndex + 1]; j++)
// {
// int idx = vecIdx[j];
// float val = vecVals[j];
// mainVec[idx] = val;
// }
//}
private static float[] CuDotProdCSRwriteCombined(int repetition)
{
//always the same values
Random rnd = new Random(1);
CUDA cuda = new CUDA(0, true);
// load module
CUmodule module = cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "structKernel.cubin"));
CUfunction cuFunc = cuda.GetModuleFunction("spmv_csr_vector_kernel_wc");
int maxRowSize = avgElements + stdElements - 1;
Console.WriteLine("init arrays");
Stopwatch t = Stopwatch.StartNew();
//temp lists for values, indices and vecotr lenght
List<float> vecValsL = new List<float>(N * maxRowSize / 2);
List<int> vecIdxL = new List<int>(N * maxRowSize / 2);
List<int> vecLenghtL = new List<int>(N);
float[] vecVals;
int[] vecIdx;
int[] vecLenght;
maxIndex = 0;
int vecStartIdx = 0;
for (int i = 0; i < N; i++)
{
int vecSize = avgElements + i % stdElements;
float[] vals = Helpers.InitValues(i, vecSize, maxVal);
vecValsL.AddRange(vals);
int[] index = Helpers.InitIndices(i, vecSize, ref maxIndex);
vecIdxL.AddRange(index);
vecLenghtL.Add(vecStartIdx);
vecStartIdx += vecSize;
}
//for last index
vecLenghtL.Add(vecStartIdx);
vecVals = vecValsL.ToArray();
vecIdx = vecIdxL.ToArray();
vecLenght = vecLenghtL.ToArray();
Console.WriteLine("Init takes {0}", t.Elapsed);
t.Start();
CUdeviceptr valsPtr = cuda.CopyHostToDevice(vecVals);
CUdeviceptr idxPtr = cuda.CopyHostToDevice(vecIdx);
CUdeviceptr vecLenghtPtr = cuda.CopyHostToDevice(vecLenght);
float[] output = new float[N];
//CUdeviceptr dOutput = cuda.Allocate(output);
IntPtr outputPtr2 = cuda.HostAllocate((uint)(N * sizeof(float)), CUDADriver.CU_MEMHOSTALLOC_DEVICEMAP);
CUdeviceptr dOutput = cuda.GetHostDevicePointer(outputPtr2, 0);
uint memSize = (uint)((maxIndex + 1) * sizeof(float));
uint flags = CUDADriver.CU_MEMHOSTALLOC_DEVICEMAP | CUDADriver.CU_MEMHOSTALLOC_WRITECOMBINED;
uint tt = (uint)CUMemHostAllocFlags.WriteCombined;
uint s = (uint)CUMemHostAllocFlags.DeviceMap;
IntPtr mainVecIntPtr = cuda.HostAllocate(memSize, flags);
CUdeviceptr mainVecPtr = cuda.GetHostDevicePointer(mainVecIntPtr, 0);
Console.WriteLine("copy to device takes {0}", t.Elapsed);
#region set cuda parameters
cuda.SetFunctionBlockShape(cuFunc, threadsPerBlock, 1, 1);
int offset = 0;
cuda.SetParameter(cuFunc, offset, valsPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, idxPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, vecLenghtPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, mainVecPtr.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, dOutput.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(cuFunc, offset, (uint)N);
offset += sizeof(int);
cuda.SetParameter(cuFunc, offset, (uint)vecStartIdx);
offset += sizeof(int);
cuda.SetParameterSize(cuFunc, (uint)offset);
#endregion
Console.WriteLine("start computation");
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
mainIndex = StartingIndex;
Stopwatch timer = Stopwatch.StartNew();
cuda.RecordEvent(start);
for (int k = 0; k < repetition; k++)
{
//float[] tempFloatarr = new float[memSize];
Helpers.InitBuffer(vecVals, vecIdx, vecLenght,mainIndex, mainVecIntPtr);
//Marshal.Copy(mainVecIntPtr, tempFloatarr, 0, tempFloatarr.Length);
cuda.Launch(cuFunc, blocksPerGrid, 1);
cuda.SynchronizeContext();
//cuda.CopyDeviceToHost(dOutput, output);
Marshal.Copy(outputPtr2, output, 0, N);
//mainVec = new float[maxIndex + 1];
//Array.Clear(mainVec, 0, mainVec.Length);
//clear previous vector values
Helpers.SetBufferIdx(vecIdx, vecLenght,mainIndex, mainVecIntPtr,0.0f);
mainIndex++;
}
cuda.RecordEvent(end);
cuda.SynchronizeContext();
//cuda.SynchronizeEvent(end);
// cuda.CopyDeviceToHost(dOutput, output);
timer.Stop();
float naiveTime = cuda.ElapsedTime(start, end);
Console.Write("csr vector Dot products with mainIndex {0} and {1}-vectors takes {2} ms stopwatch time {3} ms", mainIndex, N, naiveTime, timer.Elapsed);
int lenght = Math.Min(displayCount, N);
Console.WriteLine();
for (int i = 0; i < lenght; i++)
{
Console.WriteLine("{0}-{1}", i, output[i]);
}
cuda.Free(valsPtr);
cuda.Free(idxPtr);
cuda.Free(dOutput);
cuda.Free(vecLenghtPtr);
//cuda.DestroyArray(cuArr);
cuda.Free(mainVecPtr);
//cuda.DestroyTexture(cuTexRef);
// cuda.Free(mainVecPtr);
cuda.DestroyEvent(start);
cuda.DestroyEvent(end);
return output;
}
private static unsafe void CuStructPass()
{
int N = 4;
int sparseVecSize = sizeof(SparseVecPtr);
uint size = (uint)(N * sizeof(SparseVecPtr));
CUDA cuda = new CUDA(0, true);
// load module
cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "structKernel.cubin"));
CUfunction structPassFunc = cuda.GetModuleFunction("StructPass");
SparseVecPtr[] vectors = new SparseVecPtr[N];
for (int i = 0; i < N; i++)
{
vectors[i] = new SparseVecPtr();
vectors[i].size = 2;
float[] vals = new float[2] { (float)i + 1 % 5, (float)i + 2 % 7 };
//GCHandle valHandle = GCHandle.Alloc(vals, GCHandleType.Pinned);
//vectors[i].values = valHandle.AddrOfPinnedObject();
int[] index = new int[2] { i % 5, i % 7 };
//GCHandle idxHandle = GCHandle.Alloc(index, GCHandleType.Pinned);
//vectors[i].indices = idxHandle.AddrOfPinnedObject();
//valHandle.Free();
//idxHandle.Free();
CUdeviceptr valsPtr = cuda.CopyHostToDevice(vals);
CUdeviceptr idxPtr = cuda.CopyHostToDevice(index);
vectors[i].indices = new IntPtr(idxPtr.Pointer);
vectors[i].values = (IntPtr)valsPtr.Pointer;
}
GCHandle handle = GCHandle.Alloc(vectors, GCHandleType.Pinned);
IntPtr ptr = handle.AddrOfPinnedObject();
float[] output = new float[N];
//CUdeviceptr dVectors = cuda.CopyHostToDevice(vectors);
CUdeviceptr dVectors = cuda.CopyHostToDevice(ptr, size);
CUdeviceptr dOutput = cuda.Allocate(output);
int threadsPerBlock = 256;
int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
//error = cuFuncSetBlockShape(vecAdd, threadsPerBlock, 1, 1);
cuda.SetFunctionBlockShape(structPassFunc, threadsPerBlock, 1, 1);
int offset = 0;
cuda.SetParameter(structPassFunc, offset, (uint)dVectors.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, (uint)dOutput.Pointer);
offset += IntPtr.Size;
cuda.SetParameter(structPassFunc, offset, (uint)N);
offset += sizeof(int);
cuda.SetParameterSize(structPassFunc, (uint)offset);
CUevent start = cuda.CreateEvent();
CUevent end = cuda.CreateEvent();
cuda.RecordEvent(start);
cuda.Launch(structPassFunc, blocksPerGrid, 1);
cuda.RecordEvent(end);
cuda.SynchronizeContext();
//cuda.SynchronizeEvent(end);
float naiveTime = cuda.ElapsedTime(start, end);
Console.Write("passing struct takes {0}ms", naiveTime);
cuda.CopyDeviceToHost(dOutput, output);
int lenght = Math.Min(10, N);
Console.WriteLine();
for (int i = 0; i < lenght; i++)
{
Console.WriteLine("{0}-{1}", i, output[i]);
}
}
static void Main(string[] args)
{
// Create a new instance of CUDA class, select 1st device.
CUDA cuda = new CUDA(0, true);
// Prepare parameters.
int n = 16 * 1024 * 1024;
uint nbytes = (uint)(n * sizeof(int));
int value = 26;
// allocate host memory
int[] a = new int[n];
// allocate device memory
CUdeviceptr d_a = cuda.Allocate <int>(a);
CUDADriver.cuMemsetD8(d_a, 0xff, nbytes);
// load module
cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, "asyncAPI.ptx"));
CUfunction func = cuda.GetModuleFunction("increment_kernel");
// set kernel launch configuration
cuda.SetFunctionBlockShape(func, 512, 1, 1);
// create cuda event handles
CUevent start = cuda.CreateEvent();
CUevent stop = cuda.CreateEvent();
// asynchronously issue work to the GPU (all to stream 0)
CUstream stream = new CUstream();
cuda.RecordEvent(start);
cuda.CopyHostToDeviceAsync <int>(d_a, a, stream);
// set parameters for kernel function
cuda.SetParameter(func, 0, (uint)d_a.Pointer);
cuda.SetParameter(func, IntPtr.Size, (uint)value);
cuda.SetParameterSize(func, (uint)(IntPtr.Size + 4));
// actually launch kernel
cuda.LaunchAsync(func, n / 512, 1, stream);
// wait for every thing to finish, then start copy back data
cuda.CopyDeviceToHostAsync <int>(d_a, a, stream);
cuda.RecordEvent(stop);
// print the cpu and gpu times
Console.WriteLine("time spent executing by the GPU: {0} ms", cuda.ElapsedTime(start, stop));
// check the output for correctness
if (CorrectOutput(a, value))
{
Console.WriteLine("Test PASSED");
}
else
{
Console.WriteLine("Test FAILED");
}
// release resources
cuda.DestroyEvent(start);
cuda.DestroyEvent(stop);
cuda.Free(d_a);
}