/// <summary>
/// Creates a new <see cref="ComputeBuffer{T}"/> from an existing OpenGL buffer object.
/// </summary>
/// <typeparam name="TDataType"> The type of the elements of the <see cref="ComputeBuffer{T}"/>. <typeparamref name="T"/> should match the type of the elements in the OpenGL buffer. </typeparam>
/// <param name="context"> A <see cref="ComputeContext"/> with enabled CL/GL sharing. </param>
/// <param name="flags"> A bit-field that is used to specify usage information about the <see cref="ComputeBuffer{T}"/>. Only <see cref="ComputeMemoryFlags.ReadOnly"/>, <see cref="ComputeMemoryFlags.WriteOnly"/> and <see cref="ComputeMemoryFlags.ReadWrite"/> are allowed. </param>
/// <param name="bufferId"> The OpenGL buffer object id to use for the creation of the <see cref="ComputeBuffer{T}"/>. </param>
/// <returns> The created <see cref="ComputeBuffer{T}"/>. </returns>
public static ComputeBuffer <TDataType> CreateFromGLBuffer <TDataType>(ComputeContext context, ComputeMemoryFlags flags, int bufferId) where TDataType : struct
{
CLMemoryHandle handle = CL12.CreateFromGLBuffer(context.Handle, flags, bufferId, out var error);
ComputeException.ThrowOnError(error);
return(new ComputeBuffer <TDataType>(handle, context, flags));
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Creates a new <see cref="ComputeImage3D"/>. </summary>
///
/// <param name="handle"> The handle. </param>
/// <param name="context"> The context. </param>
/// <param name="flags"> The flags. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
private ComputeImage3D(CLMemoryHandle handle, ComputeContext context, ComputeMemoryFlags flags)
: base(context, flags)
{
Handle = handle;
Init();
}
internal ComputeSubBuffer(ComputeContext context, CLMemoryHandle handle, ComputeMemoryFlags flags)
: base(context, flags)
{
Handle = handle;
Init();
}
private OpenCLImage3D(CLMemoryHandle handle, OpenCLContext context, OpenCLMemoryFlags flags)
: base(context, flags)
{
Handle = handle;
Init();
}
public static ComputeImage2D CreateFromGLTexture2D(ComputeContext context, ComputeMemoryFlags flags, int textureTarget, int mipLevel, int textureId)
{
CLMemoryHandle image = CL12.CreateFromGLTexture2D(context.Handle, flags, textureTarget, mipLevel, textureId, out var error);
ComputeException.ThrowOnError(error);
return(new ComputeImage2D(image, context, flags));
}
/// <summary>
/// Creates a new <see cref="ComputeImage2D"/> from an OpenGL renderbuffer object.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/> with enabled CL/GL sharing. </param>
/// <param name="flags"> A bit-field that is used to specify usage information about the <see cref="ComputeImage2D"/>. Only <c>ComputeMemoryFlags.ReadOnly</c>, <c>ComputeMemoryFlags.WriteOnly</c> and <c>ComputeMemoryFlags.ReadWrite</c> are allowed. </param>
/// <param name="renderbufferId"> The OpenGL renderbuffer object id to use. </param>
/// <returns> The created <see cref="ComputeImage2D"/>. </returns>
public static ComputeImage2D CreateFromGLRenderbuffer(ComputeContext context, ComputeMemoryFlags flags, int renderbufferId)
{
CLMemoryHandle image = CL12.CreateFromGLRenderbuffer(context.Handle, flags, renderbufferId, out var error);
ComputeException.ThrowOnError(error);
return(new ComputeImage2D(image, context, flags));
}
/// <summary>
/// Creates a new buffer from an existing OpenGL buffer object.
/// </summary>
/// <typeparam name="DataType"> The type of the elements of the buffer. <typeparamref name="T"/> should match the type of the elements in the OpenGL buffer. </typeparam>
/// <param name="context"> A context with enabled CL/GL sharing. </param>
/// <param name="flags"> A bit-field that is used to specify usage information about the buffer. Only <see cref="ComputeMemoryFlags.ReadOnly"/>, <see cref="ComputeMemoryFlags.WriteOnly"/> and <see cref="ComputeMemoryFlags.ReadWrite"/> are allowed. </param>
/// <param name="bufferId"> The OpenGL buffer object id to use for the creation of the buffer. </param>
/// <returns> The created buffer. </returns>
public static ComputeBuffer <DataType> CreateFromGLBuffer <DataType>(IComputeContext context, ComputeMemoryFlags flags, int bufferId) where DataType : struct
{
ComputeErrorCode error = ComputeErrorCode.Success;
CLMemoryHandle handle = CL10.CreateFromGLBuffer(context.Handle, flags, bufferId, out error);
ComputeException.ThrowOnError(error);
return(new ComputeBuffer <DataType>(handle, context, flags));
}
/// <summary>
/// Creates a new ComputeBuffer from external memory handles.
/// </summary>
/// <param name="handle"></param>
/// <param name="context"></param>
/// <returns></returns>
public static ComputeBuffer <T> From(IntPtr handle, ComputeContext context)
{
var memoryHandle = new CLMemoryHandle(handle);
var flags = (ComputeMemoryFlags)GetInfo <CLMemoryHandle, ComputeMemoryInfo, long>(memoryHandle, ComputeMemoryInfo.Flags, CL12.GetMemObjectInfo);
return(new ComputeBuffer <T>(memoryHandle, context, flags));
}
/// <summary>
/// Creates a new <see cref="OpenCLImage2D"/> from an OpenGL 2D texture object.
/// </summary>
/// <param name="context"> A <see cref="OpenCLContext"/> with enabled CL/GL sharing. </param>
/// <param name="flags"> A bit-field that is used to specify usage information about the <see cref="OpenCLImage2D"/>. Only <c>OpenCLMemoryFlags.ReadOnly</c>, <c>OpenCLMemoryFlags.WriteOnly</c> and <c>OpenCLMemoryFlags.ReadWrite</c> are allowed. </param>
/// <param name="textureTarget"> One of the following values: GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, or GL_TEXTURE_RECTANGLE. Using GL_TEXTURE_RECTANGLE for texture_target requires OpenGL 3.1. Alternatively, GL_TEXTURE_RECTANGLE_ARB may be specified if the OpenGL extension GL_ARB_texture_rectangle is supported. </param>
/// <param name="mipLevel"> The mipmap level of the OpenGL 2D texture object to be used. </param>
/// <param name="textureId"> The OpenGL 2D texture object id to use. </param>
/// <returns> The created <see cref="OpenCLImage2D"/>. </returns>
public static OpenCLImage2D CreateFromGLTexture2D(OpenCLContext context, OpenCLMemoryFlags flags, int textureTarget, int mipLevel, int textureId)
{
OpenCLErrorCode error = OpenCLErrorCode.Success;
CLMemoryHandle image = CL10.CreateFromGLTexture2D(context.Handle, flags, textureTarget, mipLevel, textureId, out error);
OpenCLException.ThrowOnError(error);
return(new OpenCLImage2D(image, context, flags));
}
/// <summary>
/// Creates a new <see cref="OpenCLImage2D"/> from an OpenGL renderbuffer object.
/// </summary>
/// <param name="context"> A <see cref="OpenCLContext"/> with enabled CL/GL sharing. </param>
/// <param name="flags"> A bit-field that is used to specify usage information about the <see cref="OpenCLImage2D"/>. Only <c>OpenCLMemoryFlags.ReadOnly</c>, <c>OpenCLMemoryFlags.WriteOnly</c> and <c>OpenCLMemoryFlags.ReadWrite</c> are allowed. </param>
/// <param name="renderbufferId"> The OpenGL renderbuffer object id to use. </param>
/// <returns> The created <see cref="OpenCLImage2D"/>. </returns>
public static OpenCLImage2D CreateFromGLRenderbuffer(OpenCLContext context, OpenCLMemoryFlags flags, int renderbufferId)
{
OpenCLErrorCode error = OpenCLErrorCode.Success;
CLMemoryHandle image = CL10.CreateFromGLRenderbuffer(context.Handle, flags, renderbufferId, out error);
OpenCLException.ThrowOnError(error);
return(new OpenCLImage2D(image, context, flags));
}
/// <summary>
/// Creates a new <see cref="OpenCLSubBuffer{T}"/> from a specified <see cref="OpenCLBuffer{T}"/>.
/// </summary>
/// <param name="buffer"> The buffer to create the <see cref="OpenCLSubBuffer{T}"/> from. </param>
/// <param name="flags"> A bit-field that is used to specify allocation and usage information about the <see cref="OpenCLBuffer{T}"/>. </param>
/// <param name="offset"> The index of the element of <paramref name="buffer"/>, where the <see cref="OpenCLSubBuffer{T}"/> starts. </param>
/// <param name="count"> The number of elements of <paramref name="buffer"/> to include in the <see cref="OpenCLSubBuffer{T}"/>. </param>
public OpenCLSubBuffer(OpenCLBuffer buffer, OpenCLMemoryFlags flags, long offset, long count)
: base(buffer.Context, flags, buffer.ElementType, new long[] { count })
{
SysIntX2 region = new SysIntX2(offset * Marshal.SizeOf(buffer.ElementType), count * Marshal.SizeOf(buffer.ElementType));
OpenCLErrorCode error;
CLMemoryHandle handle = CL11.CreateSubBuffer(Handle, flags, OpenCLBufferCreateType.Region, ref region, out error);
OpenCLException.ThrowOnError(error);
Init();
}
/// <summary>
/// Creates a new <see cref="ComputeSubBuffer{T}"/> from a specified <see cref="ComputeBuffer{T}"/>.
/// </summary>
/// <param name="buffer"> The buffer to create the <see cref="ComputeSubBuffer{T}"/> from. </param>
/// <param name="flags"> A bit-field that is used to specify allocation and usage information about the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="offset"> The index of the element of <paramref name="buffer"/>, where the <see cref="ComputeSubBuffer{T}"/> starts. </param>
/// <param name="count"> The number of elements of <paramref name="buffer"/> to include in the <see cref="ComputeSubBuffer{T}"/>. </param>
public ComputeSubBuffer(ComputeBuffer <T> buffer, ComputeMemoryFlags flags, long offset, long count)
: base(buffer.Context, flags)
{
SysIntX2 region = new SysIntX2(offset * Marshal.SizeOf(typeof(T)), count * Marshal.SizeOf(typeof(T)));
ComputeErrorCode error;
CLMemoryHandle handle = CL11.CreateSubBuffer(Handle, flags, ComputeBufferCreateType.Region, ref region, out error);
ComputeException.ThrowOnError(error);
Init();
}
private void SetupAndCount(CLMemoryHandle input, int bitOffset)
{
ComputeErrorCode error;
IntPtr agentPtrSize = (IntPtr)0;
agentPtrSize = (IntPtr)Marshal.SizeOf(typeof(IntPtr));
var ptrSize = (IntPtr)Marshal.SizeOf(typeof(Mem));
int globalWorkSize = gpuConstants.numThreadsPerBlock * gpuConstants.numBlocks;
int localWorkSize = gpuConstants.numThreadsPerBlock;
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)globalWorkSize };
IntPtr[] localWorkGroupSizePtr = new IntPtr[] { (IntPtr)localWorkSize };
ComputeEvent clevent;
error = CL10.SetKernelArg(ckSetupAndCount, 0, ptrSize, input);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckSetupAndCount, 1, ptrSize, mCounters);
CheckErr(error, "CL10.SetKernelArg");
//if(DEBUG_CONSOLE_OUTPUT) Console.WriteLine((Marshal.SizeOf(typeof(GPUConstants))));
error = CL10.SetKernelArg(ckSetupAndCount, 2, (IntPtr)(Marshal.SizeOf(typeof(GPUConstants))), gpuConstants);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckSetupAndCount, 3, (IntPtr)4, bitOffset);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.EnqueueNDRangeKernel(cqCommandQueue, ckSetupAndCount, 1, null, workGroupSizePtr, localWorkGroupSizePtr, 0, null, out clevent);
CheckErr(error, "CL10.EnqueueNDRangeKernel");
error = CL10.Finish(cqCommandQueue);
CheckErr(error, "CL10.Finish");
if (DEBUG)
{
ComputeEvent eve;
CL10.EnqueueReadBuffer(cqCommandQueue, input, Bool.True, IntPtr.Zero, (IntPtr)(gpuConstants.numTotalElements * 4), debugRead, 0,
null, out eve);
CheckErr(error, "CL10.EnqueueReadBuffer");
PrintElementBuffer(debugRead, gpuConstants.numTotalElements, "Setup and Count -> Input -> bitoffset = " + bitOffset);
CL10.EnqueueReadBuffer(cqCommandQueue, mCounters, Bool.True, IntPtr.Zero, (IntPtr)(numCounters * sizeof(int)), debugRead, 0,
null, out eve);
CheckErr(error, "CL10.EnqueueReadBuffer");
PrintCounterBuffer(debugRead, "Setup and Count -> bitoffset = " + bitOffset);
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine("Setup and Count -> bitoffset = " + bitOffset);
}
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine();
}
}
}
internal static CLMemoryHandle[] ExtractHandles(ICollection <ComputeMemory> computeObjects, out int handleCount)
{
if (computeObjects == null || computeObjects.Count == 0)
{
handleCount = 0;
return(null);
}
var result = new CLMemoryHandle[computeObjects.Count];
int i = 0;
foreach (var computeObj in computeObjects)
{
result[i] = computeObj.Handle;
i++;
}
handleCount = computeObjects.Count;
return(result);
}
internal static CLMemoryHandle[] ExtractHandles(IList <OpenCLMemory> computeObjects, out int handleCount)
{
if (computeObjects == null || computeObjects.Count == 0)
{
handleCount = 0;
return(null);
}
CLMemoryHandle[] result = new CLMemoryHandle[computeObjects.Count];
int i = 0;
foreach (OpenCLMemory computeObj in computeObjects)
{
result[i] = computeObj.Handle;
i++;
}
handleCount = computeObjects.Count;
return(result);
}
/// <summary>
/// Added by Hybrid DSP
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="destinationHandle">The destination.</param>
/// <param name="blocking">if set to <c>true</c> [blocking].</param>
/// <param name="destinationOffset">The destination offset.</param>
/// <param name="region">The region.</param>
/// <param name="source">The source.</param>
/// <param name="events">The events.</param>
public void WriteEx <T>(CLMemoryHandle destinationHandle, bool blocking, long destinationOffset, long region, IntPtr source, ICollection <ComputeEventBase> events) where T : struct
{
int sizeofT = HDSPUtils.SizeOf(typeof(T));
int eventWaitListSize;
CLEventHandle[] eventHandles = ComputeTools.ExtractHandles(events, out eventWaitListSize);
bool eventsWritable = (events != null && !events.IsReadOnly);
CLEventHandle[] newEventHandle = (eventsWritable) ? new CLEventHandle[1] : null;
ComputeErrorCode error = CL10.EnqueueWriteBuffer(Handle, destinationHandle, blocking, new IntPtr(destinationOffset * sizeofT), new IntPtr(region * sizeofT), source, eventWaitListSize, eventHandles, newEventHandle);
ComputeException.ThrowOnError(error);
if (eventsWritable)
{
events.Add(new ComputeEvent(newEventHandle[0], this));
}
}
public void sortKeysOnly(CLMemoryHandle input, CLMemoryHandle output,
int numElements)
{
debugRead = new int[Math.Max(numElements, numCounters)];
ComputeErrorCode error;
Compute ComputeEvent eve;
mCounters = CL10.CreateBuffer(cxGPUContext, ComputeMemoryFlags.ReadWrite, gpuConstants.numGroupsPerBlock * gpuConstants.numRadices * gpuConstants.numBlocks * sizeof(int),
out error);
CheckErr(error, "CL10.CreateBuffer");
mRadixPrefixes = CL10.CreateBuffer(cxGPUContext, ComputeMemoryFlags.ReadWrite, gpuConstants.numRadices * sizeof(int), out error);
CheckErr(error, "CL10.CreateBuffer");
gpuConstants.numElementsPerGroup = (numElements / (gpuConstants.numBlocks * gpuConstants.numGroupsPerBlock)) + 1;
gpuConstants.numTotalElements = numElements;
if (DEBUG)
{
CL10.EnqueueReadBuffer(cqCommandQueue, input, Bool.True, IntPtr.Zero, (IntPtr)(gpuConstants.numTotalElements * 4), debugRead, 0,
null, out eve);
CheckErr(error, "CL10.EnqueueReadBuffer");
PrintAsArray(debugRead, gpuConstants.numTotalElements);
}
int i;
for (i = 0; i < 8; i++)
{
error = CL10.EnqueueWriteBuffer(cqCommandQueue, mCounters, true, IntPtr.Zero, (IntPtr)(numCounters * 4),
counters, 0, null, out eve);
CheckErr(error, "CL10.EnqueueWriteBuffer Counter initialize");
if (i % 2 == 0)
{
DateTime before = DateTime.Now;
SetupAndCount(input, 4 * i);
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine("Setup and Count =" + (DateTime.Now - before).TotalMilliseconds);
}
before = DateTime.Now;
SumIt(input, 4 * i);
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine("SumIt =" + (DateTime.Now - before).TotalMilliseconds);
}
before = DateTime.Now;
ReorderingKeysOnly(input, output, 4 * i);
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine("Reorder =" + (DateTime.Now - before).TotalMilliseconds);
}
}
else
{
SetupAndCount(output, 4 * i);
SumIt(output, 4 * i);
ReorderingKeysOnly(output, input, 4 * i);
}
}
if (i % 2 != 0)
{
error = CL10.EnqueueCopyBuffer(cqCommandQueue, input, output, IntPtr.Zero, IntPtr.Zero, (IntPtr)(numElements * 4), 0, null, out eve);
CheckErr(error, "CL10.EnqueueCopyBuffer");
error = CL10.Finish(cqCommandQueue);
CheckErr(error, "CL10.Finish Copybuffer");
}
error = CL10.ReleaseMemObject(mRadixPrefixes);
CheckErr(error, "CL10.ReleaseMemObj");
error = CL10.ReleaseMemObject(mCounters);
CheckErr(error, "CL10.ReleaseMemObj");
Log_Idx++;
}
private void ReorderingKeyValue(CLMemoryHandle inputKey, CLMemoryHandle outputKey, CLMemoryHandle inputValue, CLMemoryHandle outputValue, int bitOffset)
{
ComputeErrorCode error;
IntPtr agentPtrSize = (IntPtr)0;
agentPtrSize = (IntPtr)Marshal.SizeOf(typeof(IntPtr));
var ptrSize = (IntPtr)Marshal.SizeOf(typeof(Mem));
int globalWorkSize = gpuConstants.numThreadsPerBlock * gpuConstants.numBlocks;
int localWorkSize = gpuConstants.numThreadsPerBlock;
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)globalWorkSize };
IntPtr[] localWorkGroupSizePtr = new IntPtr[] { (IntPtr)localWorkSize };
ComputeEvent clevent;
error = CL10.SetKernelArg(ckReorderingKeyValue, 0, ptrSize, inputKey);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckReorderingKeyValue, 1, ptrSize, outputKey);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckReorderingKeyValue, 2, ptrSize, inputValue);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckReorderingKeyValue, 3, ptrSize, outputValue);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckReorderingKeyValue, 4, ptrSize, mCounters);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckReorderingKeyValue, 5, ptrSize, mRadixPrefixes);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckReorderingKeyValue, 6, (IntPtr)(gpuConstants.numGroupsPerBlock * gpuConstants.numBlocks * gpuConstants.numRadicesPerBlock * 4), null);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckReorderingKeyValue, 7, (IntPtr)(gpuConstants.numRadices * 4), null);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckReorderingKeyValue, 8, (IntPtr)(Marshal.SizeOf(typeof(GPUConstants))), gpuConstants);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.SetKernelArg(ckReorderingKeyValue, 9, (IntPtr)4, bitOffset);
CheckErr(error, "CL10.SetKernelArg");
error = CL10.EnqueueNDRangeKernel(cqCommandQueue, ckReorderingKeyValue, 1, null, workGroupSizePtr, localWorkGroupSizePtr, 0, null, out clevent);
CheckErr(error, "CL10.EnqueueNDRangeKernel");
error = CL10.Finish(cqCommandQueue);
CheckErr(error, "CL10.Finish");
if (DEBUG)
{
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine("-------------------------------Reordering-------------------------------------------------");
}
ComputeEvent eve;
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine(" Input ");
}
CL10.EnqueueReadBuffer(cqCommandQueue, inputKey, Bool.True, IntPtr.Zero, (IntPtr)(gpuConstants.numTotalElements * 4), debugRead, 0,
null, out eve);
CheckErr(error, "CL10.EnqueueReadBuffer");
PrintElementBuffer(debugRead, gpuConstants.numTotalElements, "Reordering -> Input -> bitoffset = " + bitOffset);
CL10.EnqueueReadBuffer(cqCommandQueue, inputValue, Bool.True, IntPtr.Zero, (IntPtr)(gpuConstants.numTotalElements * 4), debugRead, 0,
null, out eve);
CheckErr(error, "CL10.EnqueueReadBuffer");
PrintElementBuffer(debugRead, gpuConstants.numTotalElements, "Reordering -> InputValues -> bitoffset = " + bitOffset);
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine(" Counters ");
}
CL10.EnqueueReadBuffer(cqCommandQueue, mCounters, Bool.True, IntPtr.Zero, (IntPtr)(numCounters * sizeof(int)), debugRead, 0,
null, out eve);
CheckErr(error, "CL10.EnqueueReadBuffer");
PrintCounterBuffer(debugRead, "Reordering -> bitoffset = " + bitOffset);
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine(" Counters ");
}
CL10.EnqueueReadBuffer(cqCommandQueue, mRadixPrefixes, Bool.True, IntPtr.Zero, (IntPtr)(gpuConstants.numRadices * sizeof(int)), debugRead, 0,
null, out eve);
CheckErr(error, "CL10.EnqueueReadBuffer");
PrintElementBuffer(debugRead, gpuConstants.numRadices, "Reordering -> RadixPrefixe -> bitoffset = " + bitOffset);
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine(" Output ");
}
CL10.EnqueueReadBuffer(cqCommandQueue, outputKey, Bool.True, IntPtr.Zero, (IntPtr)(gpuConstants.numTotalElements * 4), debugRead, 0,
null, out eve);
CheckErr(error, "CL10.EnqueueReadBuffer");
PrintElementBuffer(debugRead, gpuConstants.numTotalElements, "Reordering -> Output -> bitoffset = " + bitOffset);
CL10.EnqueueReadBuffer(cqCommandQueue, outputValue, Bool.True, IntPtr.Zero, (IntPtr)(gpuConstants.numTotalElements * 4), debugRead, 0,
null, out eve);
CheckErr(error, "CL10.EnqueueReadBuffer");
PrintElementBuffer(debugRead, gpuConstants.numTotalElements, "Reordering -> OutputValue -> bitoffset = " + bitOffset);
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine("Reordering -> bitoffset = " + bitOffset);
}
if (DEBUG_CONSOLE_OUTPUT)
{
Console.WriteLine();
}
}
;
}
/// <summary>
/// Added by Hybrid DSP
/// </summary>
/// <param name="index"></param>
/// <param name="memObj"></param>
public void SetMemoryArgument(int index, CLMemoryHandle handle)
{
SetValueArgument <CLMemoryHandle>(index, handle);
}
private ComputeBuffer(CLMemoryHandle handle, ComputeContext context, ComputeMemoryFlags flags, long size, long count)
: base(context, flags)
{
Handle = handle;
Init(size, count);
}
private ComputeBuffer(CLMemoryHandle handle, IComputeContext context, ComputeMemoryFlags flags)
: base(context, flags)
{
Handle = handle;
Init();
}
public void sortKeysValue(CLMemoryHandle key, CLMemoryHandle value,
int numElements)
{
debugRead = new int[Math.Max(numElements, numCounters)];
ComputeErrorCode error;
ComputeEvent eve;
/*
* error = CL10.EnqueueReadBuffer(cqCommandQueue, input, Bool.True, IntPtr.Zero, (IntPtr)(numElements * 4),
* debugRead, 0, null, out eve);
* CheckErr(error, "CL10.EnqueueReadBuffer");
*/
mCounters = CL10.CreateBuffer(cxGPUContext, ComputeMemoryFlags.ReadWrite, gpuConstants.numGroupsPerBlock * gpuConstants.numRadices * gpuConstants.numBlocks * sizeof(int),
out error);
CheckErr(error, "CL10.CreateBuffer");
mRadixPrefixes = CL10.CreateBuffer(cxGPUContext, ComputeMemoryFlags.ReadWrite, gpuConstants.numRadices * sizeof(int), out error);
CheckErr(error, "CL10.CreateBuffer");
CLMemoryHandle outputValue = CL10.CreateBuffer(cxGPUContext, ComputeMemoryFlags.ReadWrite, (IntPtr)(8 * numElements),
out error);
CheckErr(error, "CL10.CreateBuffer");
CLMemoryHandle outputKey = CL10.CreateBuffer(cxGPUContext, ComputeMemoryFlags.ReadWrite, (IntPtr)(4 * numElements),
out error);
CheckErr(error, "CL10.CreateBuffer");
gpuConstants.numElementsPerGroup = (numElements / (gpuConstants.numBlocks * gpuConstants.numGroupsPerBlock)) + 1;
gpuConstants.numTotalElements = numElements;
int i;
for (i = 0; i < 8; i++)
{
error = CL10.EnqueueWriteBuffer(cqCommandQueue, mCounters, Bool.True, IntPtr.Zero, (IntPtr)(numCounters * 4),
counters, 0, null, out eve);
CheckErr(error, "CL10.EnqueueWriteBuffer Counter initialize");
if (i % 2 == 0)
{
SetupAndCount(key, 4 * i);
SumIt(key, 4 * i);
ReorderingKeyValue(key, outputKey, value, outputValue, 4 * i);
}
else
{
SetupAndCount(outputKey, 4 * i);
SumIt(outputKey, 4 * i);
ReorderingKeyValue(outputKey, key, outputValue, value, 4 * i);
}
}
if (i % 2 == 0)
{
error = CL10.EnqueueCopyBuffer(cqCommandQueue, outputKey, key, IntPtr.Zero, IntPtr.Zero, (IntPtr)(numElements * 4), 0, null, out eve);
CheckErr(error, "CL10.EnqueueCopyBuffer");
error = CL10.Finish(cqCommandQueue);
CheckErr(error, "CL10.Finish Copybuffer");
error = CL10.EnqueueCopyBuffer(cqCommandQueue, outputValue, value, IntPtr.Zero, IntPtr.Zero, (IntPtr)(numElements * 8), 0, null, out eve);
CheckErr(error, "CL10.EnqueueCopyBuffer");
error = CL10.Finish(cqCommandQueue);
CheckErr(error, "CL10.Finish Copybuffer");
}
error = CL10.ReleaseMemObject(outputKey);
CheckErr(error, "CL10.ReleaseMemObj");
error = CL10.ReleaseMemObject(outputValue);
CheckErr(error, "CL10.ReleaseMemObj");
error = CL10.ReleaseMemObject(mRadixPrefixes);
CheckErr(error, "CL10.ReleaseMemObj");
error = CL10.ReleaseMemObject(mCounters);
CheckErr(error, "CL10.ReleaseMemObj");
Log_Idx++;
}
