public override void Init()
{
cuda = new CUDA(0, true);
var cuCtx = cuda.CreateContext(0, CUCtxFlags.MapHost);
cuda.SetCurrentContext(cuCtx);
cuModule = cuda.LoadModule(Path.Combine(Environment.CurrentDirectory, cudaModuleName));
cuFunc = cuda.GetModuleFunction(cudaEvaluatorKernelName);
cuFuncSign = cuda.GetModuleFunction(cudaSignKernelName);
//reserved memory based on dimension of support vector
//svVector = new float[TrainedModel.SupportElements[0].Count];
stream = cuda.CreateStream();
//memSvSize = (uint)(TrainedModel.SupportElements[0].Count * sizeof(float));
memSvSize = (uint)(TrainedModel.SupportElements[0].Dim * sizeof(float));
//allocates memory for buffers
svVecIntPtrs[0] = cuda.AllocateHost(memSvSize);
svVecIntPtrs[1] = cuda.AllocateHost(memSvSize);
mainVecPtr = cuda.CopyHostToDeviceAsync(svVecIntPtrs[0], memSvSize, stream);
cuSVTexRef = cuda.GetModuleTexture(cuModule, "svTexRef");
cuda.SetTextureFlags(cuSVTexRef, 0);
cuda.SetTextureAddress(cuSVTexRef, mainVecPtr, memSvSize);
//todo: copy labels and alphas
float[] svLabels = new float[TrainedModel.SupportElements.Length];
float[] svAlphas = new float[TrainedModel.SupportElements.Length];
Parallel.For(0, TrainedModel.SupportElementsIndexes.Length,
i => {
int idx = TrainedModel.SupportElementsIndexes[i];
svLabels[i] = TrainedModel.Y[i];
//svLabels[i] = TrainningProblem.Labels[idx];
svAlphas[i] = TrainedModel.Alpha[idx];
});
//for (int i = 0; i < TrainedModel.SupportElementsIndexes.Length; i++)
//{
// int idx = TrainedModel.SupportElementsIndexes[i];
// svLabels[i]= TrainningProblem.Labels[idx];
// svAlphas[i] = TrainedModel.Alpha[idx];
//}
labelsPtr = cuda.CopyHostToDevice(svLabels);
alphasPtr = cuda.CopyHostToDevice(svAlphas);
IsInitialized = true;
}
protected void SetCudaData()
{
float[] svLabels = new float[sizeSV];
float[] svAlphas = new float[sizeSV];
Parallel.For(0, sizeSV,
i =>
{
int idx = TrainedModel.SupportElementsIndexes[i];
svLabels[i] = TrainedModel.Y[i];
//svLabels[i] = TrainningProblem.Labels[idx];
svAlphas[i] = TrainedModel.Alpha[idx];
});
labelsPtr = cuda.CopyHostToDevice(svLabels);
alphasPtr = cuda.CopyHostToDevice(svAlphas);
vectorsDimMemSize = (uint)((TrainedModel.SupportElements[0].Dim + 1) * sizeof(float));
for (int i = 0; i < NUM_STREAMS; i++)
{
stream[i] = cuda.CreateStream();
//allocates memory for one vector, size = vector dim
mainVecIntPtrs[i] = cuda.AllocateHost(vectorsDimMemSize);
mainVecCuPtr[i] = cuda.CopyHostToDevice(mainVecIntPtrs[i], vectorsDimMemSize);
//allocate memory for output, size == #SV
evalOutputCuPtr[i] = cuda.Allocate(svAlphas);
cuVecTexRef[i] = cuda.GetModuleTexture(cuModule, cudaVecTexRefName[i]);
//cuda.SetTextureFlags(cuVecTexRef[i], 0);
cuda.SetTextureAddress(cuVecTexRef[i], mainVecCuPtr[i], vectorsDimMemSize);
uint reduceMemSize = (uint)maxReductionBlocks * sizeof(float);
reduceIntPtrs[i] = cuda.AllocateHost(reduceMemSize);
reduceCuPtr[i] = cuda.CopyHostToDevice(reduceIntPtrs[i], reduceMemSize);
//reduceCuPtr[i] = cuda.Allocate((uint)maxReductionBlocks * sizeof(float));
}
}
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);
}
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;
}
unsafe public FlaCudaTask(CUDA _cuda, int channelCount, int channels, uint bits_per_sample, int max_frame_size, bool do_verify)
{
cuda = _cuda;
residualTasksLen = sizeof(FlaCudaSubframeTask) * channelCount * (lpc.MAX_LPC_ORDER * lpc.MAX_LPC_WINDOWS + 8) * FlaCudaWriter.maxFrames;
bestResidualTasksLen = sizeof(FlaCudaSubframeTask) * channelCount * FlaCudaWriter.maxFrames;
samplesBufferLen = sizeof(int) * FlaCudaWriter.MAX_BLOCKSIZE * channelCount;
int partitionsLen = sizeof(int) * (30 << 8) * channelCount * FlaCudaWriter.maxFrames;
int riceParamsLen = sizeof(int) * (4 << 8) * channelCount * FlaCudaWriter.maxFrames;
int lpcDataLen = sizeof(float) * 32 * 33 * lpc.MAX_LPC_WINDOWS * channelCount * FlaCudaWriter.maxFrames;
cudaSamplesBytes = cuda.Allocate((uint)samplesBufferLen / 2);
cudaSamples = cuda.Allocate((uint)samplesBufferLen);
cudaResidual = cuda.Allocate((uint)samplesBufferLen);
cudaLPCData = cuda.Allocate((uint)lpcDataLen);
cudaPartitions = cuda.Allocate((uint)partitionsLen);
cudaRiceParams = cuda.Allocate((uint)riceParamsLen);
cudaBestRiceParams = cuda.Allocate((uint)riceParamsLen / 4);
cudaAutocorOutput = cuda.Allocate((uint)(sizeof(float) * channelCount * lpc.MAX_LPC_WINDOWS * (lpc.MAX_LPC_ORDER + 1) * (FlaCudaWriter.maxAutocorParts + FlaCudaWriter.maxFrames)));
cudaResidualTasks = cuda.Allocate((uint)residualTasksLen);
cudaBestResidualTasks = cuda.Allocate((uint)bestResidualTasksLen);
cudaResidualOutput = cuda.Allocate((uint)(sizeof(int) * channelCount * (lpc.MAX_LPC_WINDOWS * lpc.MAX_LPC_ORDER + 8) * 64 /*FlaCudaWriter.maxResidualParts*/ * FlaCudaWriter.maxFrames));
CUResult cuErr = CUResult.Success;
if (cuErr == CUResult.Success)
cuErr = CUDADriver.cuMemAllocHost(ref samplesBytesPtr, (uint)samplesBufferLen/2);
if (cuErr == CUResult.Success)
cuErr = CUDADriver.cuMemAllocHost(ref residualBufferPtr, (uint)samplesBufferLen);
if (cuErr == CUResult.Success)
cuErr = CUDADriver.cuMemAllocHost(ref bestRiceParamsPtr, (uint)riceParamsLen / 4);
if (cuErr == CUResult.Success)
cuErr = CUDADriver.cuMemAllocHost(ref residualTasksPtr, (uint)residualTasksLen);
if (cuErr == CUResult.Success)
cuErr = CUDADriver.cuMemAllocHost(ref bestResidualTasksPtr, (uint)bestResidualTasksLen);
if (cuErr != CUResult.Success)
{
if (samplesBytesPtr != IntPtr.Zero) CUDADriver.cuMemFreeHost(samplesBytesPtr); samplesBytesPtr = IntPtr.Zero;
if (residualBufferPtr != IntPtr.Zero) CUDADriver.cuMemFreeHost(residualBufferPtr); residualBufferPtr = IntPtr.Zero;
if (bestRiceParamsPtr != IntPtr.Zero) CUDADriver.cuMemFreeHost(bestRiceParamsPtr); bestRiceParamsPtr = IntPtr.Zero;
if (residualTasksPtr != IntPtr.Zero) CUDADriver.cuMemFreeHost(residualTasksPtr); residualTasksPtr = IntPtr.Zero;
if (bestResidualTasksPtr != IntPtr.Zero) CUDADriver.cuMemFreeHost(bestResidualTasksPtr); bestResidualTasksPtr = IntPtr.Zero;
throw new CUDAException(cuErr);
}
cudaComputeAutocor = cuda.GetModuleFunction("cudaComputeAutocor");
cudaStereoDecorr = cuda.GetModuleFunction("cudaStereoDecorr");
cudaChannelDecorr = cuda.GetModuleFunction("cudaChannelDecorr");
cudaChannelDecorr2 = cuda.GetModuleFunction("cudaChannelDecorr2");
cudaFindWastedBits = cuda.GetModuleFunction("cudaFindWastedBits");
cudaComputeLPC = cuda.GetModuleFunction("cudaComputeLPC");
cudaQuantizeLPC = cuda.GetModuleFunction("cudaQuantizeLPC");
cudaComputeLPCLattice = cuda.GetModuleFunction("cudaComputeLPCLattice");
cudaEstimateResidual = cuda.GetModuleFunction("cudaEstimateResidual");
cudaEstimateResidual8 = cuda.GetModuleFunction("cudaEstimateResidual8");
cudaEstimateResidual12 = cuda.GetModuleFunction("cudaEstimateResidual12");
cudaEstimateResidual1 = cuda.GetModuleFunction("cudaEstimateResidual1");
cudaChooseBestMethod = cuda.GetModuleFunction("cudaChooseBestMethod");
cudaCopyBestMethod = cuda.GetModuleFunction("cudaCopyBestMethod");
cudaCopyBestMethodStereo = cuda.GetModuleFunction("cudaCopyBestMethodStereo");
cudaEncodeResidual = cuda.GetModuleFunction("cudaEncodeResidual");
cudaCalcPartition = cuda.GetModuleFunction("cudaCalcPartition");
cudaCalcPartition16 = cuda.GetModuleFunction("cudaCalcPartition16");
cudaCalcLargePartition = cuda.GetModuleFunction("cudaCalcLargePartition");
cudaSumPartition = cuda.GetModuleFunction("cudaSumPartition");
cudaFindRiceParameter = cuda.GetModuleFunction("cudaFindRiceParameter");
cudaFindPartitionOrder = cuda.GetModuleFunction("cudaFindPartitionOrder");
stream = cuda.CreateStream();
samplesBuffer = new int[FlaCudaWriter.MAX_BLOCKSIZE * channelCount];
outputBuffer = new byte[max_frame_size * FlaCudaWriter.maxFrames + 1];
frame = new FlacFrame(channelCount);
frame.writer = new BitWriter(outputBuffer, 0, outputBuffer.Length);
if (do_verify)
{
verify = new FlakeReader(new AudioPCMConfig((int)bits_per_sample, channels, 44100));
verify.DoCRC = false;
}
}
