/// <summary>
/// Creates a new <see cref="ComputeImage2D"/> from a <c>Bitmap</c>.
/// </summary>
/// <param name="context"> A valid <see cref="ComputeContext"/> in which the <see cref="ComputeImage2D"/> is created. </param>
/// <param name="flags"> A bit-field that is used to specify allocation and usage information about the <see cref="ComputeImage2D"/>. </param>
/// <param name="bitmap"> The bitmap to use. </param>
/// <remarks> Note that only bitmaps with <c>Alpha</c>, <c>Format16bppRgb555</c>, <c>Format16bppRgb565</c> or <c>Format32bppArgb</c> pixel formats are currently supported. </remarks>
public ComputeImage2D(ComputeContext context, ComputeMemoryFlags flags, Bitmap bitmap)
: base(context, flags)
{
unsafe
{
ComputeImageFormat format = Tools.ConvertImageFormat(bitmap.PixelFormat);
BitmapData bitmapData = bitmap.LockBits(new Rectangle(new Point(), bitmap.Size), ImageLockMode.ReadOnly, bitmap.PixelFormat);
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL10.CreateImage2D(
context.Handle,
flags,
&format,
new IntPtr(bitmap.Width),
new IntPtr(bitmap.Height),
new IntPtr(bitmapData.Stride),
bitmapData.Scan0,
&error);
ComputeException.ThrowOnError(error);
bitmap.UnlockBits(bitmapData);
Init();
}
}
private ComputeImage3D(IntPtr handle, ComputeContext context, ComputeMemoryFlags flags)
: base(context, flags)
{
Handle = handle;
Init();
}
/// <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));
}
private RenderKernel(ComputeContext context, ComputeKernel kernel, string[] sourcecodes, Dictionary<string, string> defines)
{
_context = context;
_kernel = kernel;
_sourcecodes = sourcecodes;
_defines = defines;
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
ComputeProgram program = new ComputeProgram(context, kernelSources);
program.Build(null, null, null, IntPtr.Zero);
log.WriteLine("Program successfully built.");
ICollection<ComputeKernel> kernels = program.CreateAllKernels();
log.WriteLine("Kernels successfully created.");
// cleanup kernels
foreach (ComputeKernel kernel in kernels)
{
kernel.Dispose();
}
kernels.Clear();
// cleanup program
program.Dispose();
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
public OpenCLProxy(bool useSoftware = false)
{
HardwareAccelerationEnabled = ComputePlatform.Platforms.Count != 0 && !useSoftware;
if (HardwareAccelerationEnabled)
{
ComputePlatform platform = ComputePlatform.Platforms[0];
var devices = new List<ComputeDevice> { platform.Devices[0] };
var properties = new ComputeContextPropertyList(platform);
_context = new ComputeContext(devices, properties, null, IntPtr.Zero);
_commands = new ComputeCommandQueue(_context, _context.Devices[0], ComputeCommandQueueFlags.None);
_intComputeBuffers = new Dictionary<string, ComputeBuffer<int>>();
_floatComputeBuffers = new Dictionary<string, ComputeBuffer<float>>();
AcceleratorName = platform.Name;
}
else
{
AcceleratorName = "CPU";
}
_intArguments = new Dictionary<string, int>();
_intBuffers = new Dictionary<string, int[]>();
_floatArguments = new Dictionary<string, float>();
_floatBuffers = new Dictionary<string, float[]>();
_doubleArguments = new Dictionary<string, double>();
}
private ComputeImage(CLMemoryHandle handle, ComputeContext context, ComputeMemoryFlags flags)
: base(context, flags)
{
Handle = handle;
Init();
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <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();
}
/// <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 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="ComputeBuffer{T}"/> from an existing OpenGL buffer object.
/// </summary>
/// <typeparam name="DataType"> 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 <DataType> CreateFromGLBuffer <DataType>(ComputeContext context, ComputeMemoryFlags flags, int bufferId) where DataType : struct
{
ComputeErrorCode error = ComputeErrorCode.Success;
CLMemoryHandle handle = CLInterface.CL12.CreateFromGLBuffer(context.Handle, flags, bufferId, out error);
ComputeException.ThrowOnError(error);
return(new ComputeBuffer <DataType>(handle, context, flags));
}
public ComputeImage3D(ComputeContext context, ComputeMemoryFlags flags, ComputeImageFormat format, int width, int height, int depth, long rowPitch, long slicePitch, IntPtr data)
: base(context, flags)
{
Handle = CL12.CreateImage3D(context.Handle, flags, ref format, new IntPtr(width), new IntPtr(height), new IntPtr(depth), new IntPtr(rowPitch), new IntPtr(slicePitch), data, out var error);
ComputeException.ThrowOnError(error);
Init();
}
public virtual void Initialize() {
platform = ComputePlatform.Platforms[0];
device = platform.Devices[0];
properties = new ComputeContextPropertyList(platform);
context = new ComputeContext(new[] { device }, properties, null, IntPtr.Zero);
program = new ComputeProgram(context, KernelSrc);
}
public static ComputeImage3D CreateFromGLTexture3D(ComputeContext context, ComputeMemoryFlags flags, int textureTarget, int mipLevel, int textureId)
{
var image = CL12.CreateFromGLTexture3D(context.Handle, flags, textureTarget, mipLevel, textureId, out var error);
ComputeException.ThrowOnError(error);
return(new ComputeImage3D(image, context, flags));
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="flags"></param>
/// <param name="packetSize"></param>
/// <param name="maxPackets"></param>
public ComputePipe(ComputeContext context, ComputeMemoryFlags flags, int packetSize, int maxPackets)
: this(context, flags)
{
ComputeErrorCode error;
Handle = CLInterface.CL20.CreatePipe(context.Handle, flags, packetSize, maxPackets, null, out error);
ComputeException.ThrowOnError(error);
Init();
}
/// <summary>
/// Creates a new <see cref="ComputeImage3D"/>.
/// </summary>
/// <param name="context"> A valid <see cref="ComputeContext"/> in which the <see cref="ComputeImage3D"/> is created. </param>
/// <param name="flags"> A bit-field that is used to specify allocation and usage information about the <see cref="ComputeImage3D"/>. </param>
/// <param name="format"> A structure that describes the format properties of the <see cref="ComputeImage3D"/>. </param>
/// <param name="width"> The width of the <see cref="ComputeImage3D"/> in pixels. </param>
/// <param name="height"> The height of the <see cref="ComputeImage3D"/> in pixels. </param>
/// <param name="depth"> The depth of the <see cref="ComputeImage3D"/> in pixels. </param>
/// <param name="rowPitch"> The size in bytes of each row of elements of the <see cref="ComputeImage3D"/>. If <paramref name="rowPitch"/> is zero, OpenCL will compute the proper value based on <see cref="ComputeImage.Width"/> and <see cref="ComputeImage.ElementSize"/>. </param>
/// <param name="slicePitch"> The size in bytes of each 2D slice in the <see cref="ComputeImage3D"/>. If <paramref name="slicePitch"/> is zero, OpenCL will compute the proper value based on <see cref="ComputeImage.RowPitch"/> and <see cref="ComputeImage.Height"/>. </param>
/// <param name="data"> The data to initialize the <see cref="ComputeImage3D"/>. Can be <c>IntPtr.Zero</c>. </param>
public ComputeImage3D(ComputeContext context, ComputeMemoryFlags flags, ComputeImageFormat format, int width, int height, int depth, long rowPitch, long slicePitch, IntPtr data)
: base(context, flags)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL10.CreateImage3D(context.Handle, flags, ref format, new IntPtr(width), new IntPtr(height), new IntPtr(depth), new IntPtr(rowPitch), new IntPtr(slicePitch), data, out error);
ComputeException.ThrowOnError(error);
Init();
}
private void buttonCalculate_Click(object sender, EventArgs e)
{
SetOutputDimensions();
// construct context
var context = new ComputeContext(_selectedComputeDevice.Type, new ComputeContextPropertyList(_selectedComputePlatform), null, IntPtr.Zero);
CalculateConvolution(context);
}
/// <summary>
/// Creates a new <see cref="ComputeBuffer{T}"/>.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/> used to create the <see cref="ComputeBuffer{T}"/>. </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="count"> The number of elements of the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="dataPtr"> A pointer to the data for the <see cref="ComputeBuffer{T}"/>. </param>
public ComputeBuffer(ComputeContext context, ComputeMemoryFlags flags, long count, IntPtr dataPtr)
: base(context, flags)
{
var size = ComputeTools.SizeOf <T>() * count;
Handle = CL12.CreateBuffer(context.Handle, flags, new IntPtr(size), dataPtr, out var error);
ComputeException.ThrowOnError(error);
Init(size, count);
}
/// <summary>
/// Creates a new <see cref="ComputeImage"/>.
/// </summary>
/// <param name="context"> A valid <see cref="ComputeContext"/> in which the <see cref="ComputeImage"/> is created. </param>
/// <param name="flags"> A bit-field that is used to specify allocation and usage information about the <see cref="ComputeImage"/>. </param>
/// <param name="format"> A structure that describes the format properties of the <see cref="ComputeImage"/>. </param>
/// <param name="imageDescription"> A structure that describes the <see cref="ComputeImage"/>. </param>
/// <param name="data"> The data to initialize the <see cref="ComputeImage"/>. Can be <c>IntPtr.Zero</c>. </param>
public ComputeImage(ComputeContext context, ComputeMemoryFlags flags, ComputeImageFormat format, ComputeImageDescription imageDescription, IntPtr data)
: base(context, flags)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CLInterface.CL12.CreateImage(context.Handle, flags, ref format, ref imageDescription, data, out error);
ComputeException.ThrowOnError(error);
Init();
}
internal ComputeKernel(CLKernelHandle handle, ComputeProgram program)
{
Handle = handle;
SetID(Handle.Value);
context = program.Context;
functionName = GetStringInfo <CLKernelHandle, ComputeKernelInfo>(Handle, ComputeKernelInfo.FunctionName, CLInterface.CL12.GetKernelInfo);
this.program = program;
}
/// <summary>
/// Creates a new <see cref="ComputeBuffer{T}"/>.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/> used to create the <see cref="ComputeBuffer{T}"/>. </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="count"> The number of elements of the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="dataPtr"> A pointer to the data for the <see cref="ComputeBuffer{T}"/>. </param>
public ComputeBuffer(ComputeContext context, ComputeMemoryFlags flags, long count, IntPtr dataPtr)
: base(context, flags)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL10.CreateBuffer(context.Handle, flags, new IntPtr(Marshal.SizeOf(typeof(T)) * count), dataPtr, out error);
ComputeException.ThrowOnError(error);
Init();
}
///<summary>
///Creates a new <see cref = "ComputeImage 2 D"/> from an OpenGL 2D texture object.
///</summary>
///<param name = "context"> A <see cref = "ComputeContext"/> with enabled CL / GL sharing. </param>
///Only <c> ComputeMemoryFlags.ReadOnly </c>, <c> ComputeMemoryFlags.WriteOnly </c>, where <param name = "flags"> A bit-field that is used to specify usage information about the < / c> and <c> ComputeMemoryFlags.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 = "ComputeImage2D"/>. </returns>
public static ComputeImage2D CreateFromGLTexture2D(ComputeContext context, ComputeMemoryFlags flags, int textureTarget, int mipLevel, int textureId)
{
ComputeErrorCode error = ComputeErrorCode.Success;
CLMemoryHandle image = CL12.CreateFromGLTexture2D(context.Handle, flags, textureTarget, mipLevel, textureId, out error);
ComputeException.ThrowOnError(error);
return(new ComputeImage2D(image, context, flags));
}
internal ComputeUserEvent(ComputeContext context, CLEventHandle handle, ComputeCommandType type)
{
Handle = handle;
SetID(Handle.Value);
Type = type;
Context = context;
}
public ComputeSampler(ComputeContext context, bool normalizedCoords, ComputeImageAddressing addressing, ComputeImageFiltering filtering)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CLInterface.CL12.CreateSampler(context.Handle, normalizedCoords, addressing, filtering, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.context = context;
}
/*
* ///<summary>
* /// Creates a new <see cref="ComputeImage2D"/> from a <c>Bitmap</c>.
* ///</summary>
* ///<para name = "context"> A valid <see cref = "ComputeContext"/> in which the <see cref = "ComputeImage 2 D"/> is created. </param>
* ///<para name = "flags"> A bit-field that is used to specify allocation and usage information about the <see cref = "ComputeImage 2 D"/>. </param>
* /// <param name="bitmap"> The bitmap to use. </param>
* /// <remarks> Note that only bitmaps with <c>Format32bppArgb</c> pixel format are currently supported. </remarks>
* public ComputeImage2D(ComputeContext context, ComputeMemoryFlags flags, Bitmap bitmap)
* :base(context, flags)
* {
* unsafe
* {
* if(bitmap.PixelFormat != PixelFormat.Format32bppArgb)
* throw new ArgumentException("Pixel format not supported.");
*
* //ComputeImageFormat format = Tools.ConvertImageFormat(bitmap.PixelFormat);
* ComputeImageFormat format = new ComputeImageFormat(ComputeImageChannelOrder.Bgra, ComputeImageChannelType.UnsignedInt8);
* BitmapData bitmapData = bitmap.LockBits(new Rectangle(new Point(), bitmap.Size), ImageLockMode.ReadOnly, bitmap.PixelFormat);
*
* try
* {
* ComputeErrorCode error = ComputeErrorCode.Success;
* Handle = CL12.CreateImage2D(
* context.Handle,
* flags,
* &format,
* new IntPtr(bitmap.Width),
* new IntPtr(bitmap.Height),
* new IntPtr(bitmapData.Stride),
* bitmapData.Scan0,
* &error);
* ComputeException.ThrowOnError(error);
* }
* finally
* {
* bitmap.UnlockBits(bitmapData);
* }
*
* Init();
* }
* }*/
///<summary>
///Creates a new <see cref = "ComputeImage 2 D"/>.
///</summary>
///<para name = "context"> A valid <see cref = "ComputeContext"/> in which the <see cref = "ComputeImage 2 D"/> is created. </param>
///<para name = "flags"> A bit-field that is used to specify allocation and usage information about the <see cref = "ComputeImage 2 D"/>. </param>
///<param name = "format"> A structure that describes the format properties of the <see cref = "ComputeImage 2 D"/>. </param>
///<param name = "width"> The width of the <see cref = "ComputeImage 2 D"/> in pixels. </param>
///<param name = "height"> The height of the <see cref = "ComputeImage 2 D"/> in pixels. </param>
///<para name = "rowPitch">> The size in bytes of each row of elements of the <see cref = "ComputeImage2D"/>. If <paramref name = "rowPitch"/> is zero, OpenCL will compute the proper value based on <see cref = "ComputeImage.Width"/> and <see cref = "ComputeImage.ElementSize"/>. </param>
///<param name = "data"> The data to initialize the <see cref = "ComputeImage 2 D"/>. Can be <c> IntPtr.Zero </c>. </param>
public ComputeImage2D(ComputeContext context, ComputeMemoryFlags flags, ComputeImageFormat format, int width, int height, long rowPitch, IntPtr data)
: base(context, flags)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL12.CreateImage2D(context.Handle, flags, ref format, new IntPtr(width), new IntPtr(height), new IntPtr(rowPitch), data, out error);
ComputeException.ThrowOnError(error);
Init();
}
public static RenderPackage? LoadFromXml(ComputeContext computeContext, KernelXmlFile kernelXml, IParameterSet oldParameterSetCache)
{
var kernel = RenderKernel.Create(computeContext, kernelXml.Files.Select(File.ReadAllText).ToArray());
if (kernel == null)
return null;
var controls = kernelXml.ControlsFunc();
if (oldParameterSetCache != null && controls.GetType() == oldParameterSetCache.GetType())
controls = oldParameterSetCache;
return new RenderPackage(kernel, controls);
}
/// <summary>
/// ComputeSamplerWithProperties
/// </summary>
/// <param name="context"></param>
/// <param name="sampler_properties"></param>
/// <param name="error"></param>
public ComputeSampler(ComputeContext context, ComputeSamplerInfo[] sampler_properties, out ComputeErrorCode error)
{
error = ComputeErrorCode.Success;
Handle = CLInterface.CL20.CreateSamplerWithProperties(context.Handle, sampler_properties, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.context = context;
}
public static void Run(TextWriter log, ComputeContext context)
{
StartTest(log, "Vector addition test");
try
{
int count = 10;
float[] arrA = new float[count];
float[] arrB = new float[count];
float[] arrC = new float[count];
Random rand = new Random();
for (int i = 0; i < count; i++)
{
arrA[i] = (float)(rand.NextDouble() * 100);
arrB[i] = (float)(rand.NextDouble() * 100);
}
ComputeBuffer<float> a = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrA);
ComputeBuffer<float> b = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrB);
ComputeBuffer<float> c = new ComputeBuffer<float>(context, ComputeMemoryFlags.WriteOnly, arrC.Length);
ComputeProgram program = new ComputeProgram(context, kernelSource);
program.Build(null, null, null, IntPtr.Zero);
ComputeKernel kernel = program.CreateKernel("VectorAdd");
kernel.SetMemoryArgument(0, a);
kernel.SetMemoryArgument(1, b);
kernel.SetMemoryArgument(2, c);
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
ICollection<ComputeEventBase> events = new Collection<ComputeEventBase>();
// BUG: ATI Stream v2.2 crash if event list not null.
commands.Execute(kernel, null, new long[] { count }, null, events);
//commands.Execute(kernel, null, new long[] { count }, null, null);
arrC = new float[count];
GCHandle arrCHandle = GCHandle.Alloc(arrC, GCHandleType.Pinned);
commands.Read(c, true, 0, count, arrCHandle.AddrOfPinnedObject(), events);
arrCHandle.Free();
for (int i = 0; i < count; i++)
log.WriteLine("{0} + {1} = {2}", arrA[i], arrB[i], arrC[i]);
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
EndTest(log, "Vector addition test");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Initializes a new instance of the Cloo.ComputeKernel class. </summary>
///
/// <param name="handle"> The handle of the <see cref="ComputeKernel"/>. </param>
/// <param name="program"> Gets the <see cref="ComputeProgram"/> that the
/// <see cref="ComputeKernel"/> belongs to. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
internal ComputeKernel(CLKernelHandle handle, ComputeProgram program)
{
Handle = handle;
SetID(Handle.Value);
context = program.Context;
functionName = GetStringInfo <CLKernelHandle, ComputeKernelInfo>(Handle, ComputeKernelInfo.FunctionName, CL12.GetKernelInfo);
this.program = program;
RILogManager.Default?.SendTrace(string.Intern("Create ") + this + string.Intern(" in Thread(") + Thread.CurrentThread.ManagedThreadId + string.Intern(")."), string.Intern("Information"));
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Initializes a new instance of the Cloo.ComputeKernel class. </summary>
///
/// <param name="handle"> The handle of the <see cref="ComputeKernel"/>. </param>
/// <param name="program"> Gets the <see cref="ComputeProgram"/> that the
/// <see cref="ComputeKernel"/> belongs to. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
internal ComputeKernel(CLKernelHandle handle, ComputeProgram program)
{
Handle = handle;
SetID(Handle.Value);
context = program.Context;
functionName = GetStringInfo <CLKernelHandle, ComputeKernelInfo>(Handle, ComputeKernelInfo.FunctionName, CL12.GetKernelInfo);
this.program = program;
Trace.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
/// <summary>
/// Creates a new <see cref="ComputeUserEvent"/>.
/// </summary>
/// <param name="context"> The <see cref="ComputeContext"/> in which the <see cref="ComputeUserEvent"/> is created. </param>
/// <remarks> Requires OpenCL 1.1. </remarks>
public ComputeUserEvent(ComputeContext context)
{
ComputeErrorCode error;
Handle = CLInterface.CL11.CreateUserEvent(context.Handle, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
Type = (ComputeCommandType)GetInfo<CLEventHandle, ComputeEventInfo, uint>(Handle, ComputeEventInfo.CommandType, CLInterface.CL12.GetEventInfo);
Context = context;
HookNotifier();
}
/// <summary>
/// Creates a new <see cref="ComputeProgram"/> from a source code string.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="source"> The source code for the <see cref="ComputeProgram"/>. </param>
/// <remarks> The created <see cref="ComputeProgram"/> is associated with the <see cref="ComputeContext.Devices"/>. </remarks>
public ComputeProgram(ComputeContext context, string source)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CLInterface.CL10.CreateProgramWithSource(context.Handle, 1, new string[] { source }, null, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.context = context;
this.devices = context.Devices;
this.source = new ReadOnlyCollection<string>(new string[] { source });
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="flags"></param>
/// <param name="type"></param>
/// <returns></returns>
protected static ICollection <ComputeImageFormat> GetSupportedFormats(ComputeContext context, ComputeMemoryFlags flags, ComputeMemoryType type)
{
ComputeErrorCode error = CL12.GetSupportedImageFormats(context.Handle, flags, type, 0, null, out var formatCountRet);
ComputeException.ThrowOnError(error);
ComputeImageFormat[] formats = new ComputeImageFormat[formatCountRet];
error = CL12.GetSupportedImageFormats(context.Handle, flags, type, formatCountRet, formats, out formatCountRet);
ComputeException.ThrowOnError(error);
return(new Collection <ComputeImageFormat>(formats));
}
/// <summary>
/// Creates a new <see cref="ComputeUserEvent"/>.
/// </summary>
/// <param name="context"> The <see cref="ComputeContext"/> in which the <see cref="ComputeUserEvent"/> is created. </param>
/// <remarks> Requires OpenCL 1.1. </remarks>
public ComputeUserEvent(ComputeContext context)
{
ComputeErrorCode error;
Handle = CLInterface.CL11.CreateUserEvent(context.Handle, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
Type = (ComputeCommandType)GetInfo <CLEventHandle, ComputeEventInfo, uint>(Handle, ComputeEventInfo.CommandType, CLInterface.CL12.GetEventInfo);
Context = context;
HookNotifier();
}
internal ComputeKernel(string functionName, ComputeProgram program)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CLInterface.CL12.CreateKernel(program.Handle, functionName, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
context = program.Context;
this.functionName = functionName;
this.program = program;
}
/// <summary>
/// Creates a new <see cref="ComputeProgram"/> from a source code string.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="source"> The source code for the <see cref="ComputeProgram"/>. </param>
/// <remarks> The created <see cref="ComputeProgram"/> is associated with the <see cref="ComputeContext.Devices"/>. </remarks>
public ComputeProgram(ComputeContext context, string source)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CLInterface.CL12.CreateProgramWithSource(context.Handle, 1, new string[] { source }, null, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.context = context;
this.devices = context.Devices;
this.source = new ReadOnlyCollection <string>(new string[] { source });
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Initializes a new instance of the Cloo.ComputeKernel class. </summary>
///
/// <param name="functionName"> Gets the function name of the <see cref="ComputeKernel"/>. </param>
/// <param name="program"> Gets the <see cref="ComputeProgram"/> that the
/// <see cref="ComputeKernel"/> belongs to. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
internal ComputeKernel(string functionName, ComputeProgram program)
{
Handle = CL12.CreateKernel(program.Handle, functionName, out var error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
context = program.Context;
this.functionName = functionName;
this.program = program;
RILogManager.Default?.SendTrace(string.Intern("Create ") + this + string.Intern(" in Thread(") + Thread.CurrentThread.ManagedThreadId + string.Intern(")."), string.Intern("Information"));
}
/// <summary>
/// Creates a new <see cref="ComputeUserEvent"/>.
/// </summary>
/// <param name="context"> The <see cref="ComputeContext"/> in which the <see cref="ComputeUserEvent"/> is created. </param>
/// <remarks> Requires OpenCL 1.1. </remarks>
public ComputeUserEvent(ComputeContext context)
{
Handle = CL11.CreateUserEvent(context.Handle, out var error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
Type = (ComputeCommandType)GetInfo <CLEventHandle, ComputeEventInfo, uint>(Handle, ComputeEventInfo.CommandType, CL12.GetEventInfo);
Context = context;
//HookNotifier();
//Debug.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates a new <see cref="ComputeProgram"/> from an array of source code strings.
/// </summary>
///
/// <remarks>
/// The created <see cref="ComputeProgram"/> is associated with the
/// <see cref="ComputeContext.Devices"/>.
/// </remarks>
///
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="source"> The source code lines for the <see cref="ComputeProgram"/>. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
public ComputeProgram(ComputeContext context, string[] source)
{
Ensure.Argument(context).NotNull("context is null");
Handle = CL12.CreateProgramWithSource(context.Handle, source.Length, source, null, out var error);
ComputeException.ThrowOnError(error);
this.context = context;
devices = context.Devices;
this.source = new ReadOnlyCollection <string>(source);
RILogManager.Default?.SendTrace("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
/// <summary>
/// Creates a new <c>ComputeUserEvent</c>.
/// </summary>
/// <param name="context"> The <c>ComputeContext</c> in which the <c>ComputeUserEvent</c> is created. </param>
/// <remarks> Requires OpenCL 1.1. </remarks>
public ComputeUserEvent(ComputeContext context)
{
unsafe
{
ComputeErrorCode error;
Handle = CL11.CreateUserEvent(context.Handle, &error);
ComputeException.ThrowOnError(error);
Type = (ComputeCommandType)GetInfo<ComputeEventInfo, uint>(
ComputeEventInfo.CommandType, CL10.GetEventInfo);
Context = context;
HookNotifier();
}
}
public void Run(ComputeContext context, TextWriter log)
{
this.log = log;
try
{
program = new ComputeProgram(context, clSource);
program.Build(null, null, notify, IntPtr.Zero);
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
/// <summary>
/// Creates a new <see cref="ComputeUserEvent"/>.
/// </summary>
/// <param name="context"> The <see cref="ComputeContext"/> in which the <see cref="ComputeUserEvent"/> is created. </param>
/// <remarks> Requires OpenCL 1.1. </remarks>
public ComputeUserEvent(ComputeContext context)
{
ComputeErrorCode error;
Handle = CL11.CreateUserEvent(context.Handle, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
Type = (ComputeCommandType)GetInfo<CLEventHandle, ComputeEventInfo, uint>(Handle, ComputeEventInfo.CommandType, CL12.GetEventInfo);
Context = context;
HookNotifier();
Trace.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
public static void Run(TextWriter log, ComputeContext context)
{
StartTest(log, "Image test");
try
{
log.Write("Creating command queue... ");
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
log.WriteLine("done.");
int width = 16;
int height = 16;
log.Write("Creating first bitmap and drawing shapes... ");
Bitmap firstBitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
Graphics graphics = Graphics.FromImage(firstBitmap);
graphics.FillEllipse(Brushes.Red, 0, 0, width / 2, height / 2);
graphics.FillRectangle(Brushes.Green, width / 2 + 1, 0, width / 2, height / 2);
graphics.FillRectangle(Brushes.Blue, width / 2 + 1, height / 2 + 1, width / 2, height / 2);
log.WriteLine("done.");
log.Write("Creating OpenCL image object from first bitmap... ");
ComputeImage2D clImage = new ComputeImage2D(context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.CopyHostPointer, firstBitmap);
log.WriteLine("done.");
log.Write("Creating second bitmap... ");
Bitmap secondBitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
BitmapData bmpData = secondBitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, secondBitmap.PixelFormat);
log.WriteLine("done.");
log.Write("Reading from OpenCL image object... ");
commands.ReadFromImage(clImage, bmpData.Scan0, true, null);
log.WriteLine("done.");
secondBitmap.UnlockBits(bmpData);
log.Write("Comparing bitmaps... ");
for (int i = 0; i < width; i++)
for (int j = 0; j < height; j++)
if (firstBitmap.GetPixel(i, j) != secondBitmap.GetPixel(i, j))
throw new Exception("Image data mismatch!");
log.WriteLine("passed.");
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
EndTest(log, "Image test");
}
public static IGpuHelper CreateHelper(ComputePlatform platform, ComputeDevice device, FPType fptype)
{
ComputeContextPropertyList properties = new ComputeContextPropertyList(platform);
var context = new ComputeContext(new[] { device }, properties, null, IntPtr.Zero);
if (fptype == FPType.Single)
{
return new GpuHelper<float>(context, fptype);
}
else
{
return new GpuHelper<double>(context, fptype);
}
}
/// <summary>
/// Creates a new <see cref="ComputeSampler"/>.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="normalizedCoords"> The usage state of normalized coordinates when accessing a <see cref="ComputeImage"/> in a <see cref="ComputeKernel"/>. </param>
/// <param name="addressing"> The <see cref="ComputeImageAddressing"/> mode of the <see cref="ComputeSampler"/>. Specifies how out-of-range image coordinates are handled while reading. </param>
/// <param name="filtering"> The <see cref="ComputeImageFiltering"/> mode of the <see cref="ComputeSampler"/>. Specifies the type of filter that must be applied when reading data from an image. </param>
public ComputeSampler(ComputeContext context, bool normalizedCoords, ComputeImageAddressing addressing, ComputeImageFiltering filtering)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CLInterface.CL12.CreateSampler(context.Handle, normalizedCoords, addressing, filtering, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.addressing = addressing;
this.context = context;
this.filtering = filtering;
this.normalizedCoords = normalizedCoords;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Creates a new <see cref="ComputeSampler"/>. </summary>
///
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="normalizedCoords"> The usage state of normalized coordinates when accessing a
/// <see cref="ComputeImage"/> in a <see cref="ComputeKernel"/>. </param>
/// <param name="addressing"> The <see cref="ComputeImageAddressing"/> mode of the
/// <see cref="ComputeSampler"/>. Specifies how out-of-range
/// image coordinates are handled while reading. </param>
/// <param name="filtering"> The <see cref="ComputeImageFiltering"/> mode of the
/// <see cref="ComputeSampler"/>. Specifies the type of filter
/// that must be applied when reading data from an image. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
public ComputeSampler(ComputeContext context, bool normalizedCoords, ComputeImageAddressing addressing, ComputeImageFiltering filtering)
{
Handle = CL12.CreateSampler(context.Handle, normalizedCoords, addressing, filtering, out var error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.addressing = addressing;
this.context = context;
this.filtering = filtering;
this.normalizedCoords = normalizedCoords;
RILogManager.Default?.SendTrace(string.Intern("Create ") + this + string.Intern(" in Thread(") + Thread.CurrentThread.ManagedThreadId + string.Intern(")."), string.Intern("Information"));
}
/// <summary>
/// Creates a new <see cref="ComputeProgram"/> from a specified list of binaries.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="binaries"> A list of binaries, one for each item in <paramref name="devices"/>. </param>
/// <param name="devices"> A subset of the <see cref="ComputeContext.Devices"/>. If <paramref name="devices"/> is <c>null</c>, OpenCL will associate every binary from <see cref="ComputeProgram.Binaries"/> with a corresponding <see cref="ComputeDevice"/> from <see cref="ComputeContext.Devices"/>. </param>
public ComputeProgram(ComputeContext context, IList <byte[]> binaries, IList <ComputeDevice> devices)
{
int count;
CLDeviceHandle[] deviceHandles = (devices != null) ?
ComputeTools.ExtractHandles(devices, out count) :
ComputeTools.ExtractHandles(context.Devices, out count);
IntPtr[] binariesPtrs = new IntPtr[count];
IntPtr[] binariesLengths = new IntPtr[count];
int[] binariesStats = new int[count];
ComputeErrorCode error = ComputeErrorCode.Success;
GCHandle[] binariesGCHandles = new GCHandle[count];
try
{
for (int i = 0; i < count; i++)
{
binariesGCHandles[i] = GCHandle.Alloc(binaries[i], GCHandleType.Pinned);
binariesPtrs[i] = binariesGCHandles[i].AddrOfPinnedObject();
binariesLengths[i] = new IntPtr(binaries[i].Length);
}
Handle = CL10.CreateProgramWithBinary(
context.Handle,
count,
deviceHandles,
binariesLengths,
binariesPtrs,
binariesStats,
out error);
ComputeException.ThrowOnError(error);
}
finally
{
for (int i = 0; i < count; i++)
{
binariesGCHandles[i].Free();
}
}
this.binaries = new ReadOnlyCollection <byte[]>(binaries);
this.context = context;
this.devices = new ReadOnlyCollection <ComputeDevice>(
(devices != null) ? devices : context.Devices);
//Console.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
/// <summary>
/// Creates a new <see cref="ComputeProgram"/> from a source code string.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="source"> The source code for the <see cref="ComputeProgram"/>. </param>
/// <remarks> The created <see cref="ComputeProgram"/> is associated with the <see cref="ComputeContext.Devices"/>. </remarks>
public ComputeProgram(ComputeContext context, string source)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL10.CreateProgramWithSource(context.Handle, 1, new string[] { source }, null, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.context = context;
this.devices = context.Devices;
this.source = new ReadOnlyCollection<string>(new string[] { source });
Trace.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
/// <summary>
/// Creates a new <see cref="ComputeProgram"/> from a source code string.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="source"> The source code for the <see cref="ComputeProgram"/>. </param>
/// <remarks> The created <see cref="ComputeProgram"/> is associated with the <see cref="ComputeContext.Devices"/>. </remarks>
public ComputeProgram(ComputeContext context, string source)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL10.CreateProgramWithSource(context.Handle, 1, new string[] { source }, null, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.context = context;
this.devices = context.Devices;
this.source = new ReadOnlyCollection <string>(new string[] { source });
//Console.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
/// <summary>
/// Creates a new <see cref="ComputeSampler"/>.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="normalizedCoords"> The usage state of normalized coordinates when accessing a <see cref="ComputeImage"/> in a <see cref="ComputeKernel"/>. </param>
/// <param name="addressing"> The <see cref="ComputeImageAddressing"/> mode of the <see cref="ComputeSampler"/>. Specifies how out-of-range image coordinates are handled while reading. </param>
/// <param name="filtering"> The <see cref="ComputeImageFiltering"/> mode of the <see cref="ComputeSampler"/>. Specifies the type of filter that must be applied when reading data from an image. </param>
public ComputeSampler(ComputeContext context, bool normalizedCoords, ComputeImageAddressing addressing, ComputeImageFiltering filtering)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL12.CreateSampler(context.Handle, normalizedCoords, addressing, filtering, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.addressing = addressing;
this.context = context;
this.filtering = filtering;
this.normalizedCoords = normalizedCoords;
Trace.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Initializes a new instance of the Cloo.ComputeKernel class. </summary>
///
/// <param name="functionName"> Gets the function name of the <see cref="ComputeKernel"/>. </param>
/// <param name="program"> Gets the <see cref="ComputeProgram"/> that the
/// <see cref="ComputeKernel"/> belongs to. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
internal ComputeKernel(string functionName, ComputeProgram program)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL12.CreateKernel(program.Handle, functionName, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
context = program.Context;
this.functionName = functionName;
this.program = program;
Trace.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Creates a new <see cref="ComputeUserEvent"/>. </summary>
///
/// <remarks> Requires OpenCL 1.1. </remarks>
///
/// <param name="context"> The <see cref="ComputeContext"/> in which the
/// <see cref="ComputeUserEvent"/> is created. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
public ComputeUserEvent(ComputeContext context)
{
ComputeErrorCode error;
Handle = CL11.CreateUserEvent(context.Handle, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
Type = (ComputeCommandType)GetInfo <CLEventHandle, ComputeEventInfo, uint>(Handle, ComputeEventInfo.CommandType, CL12.GetEventInfo);
Context = context;
HookNotifier();
RILogManager.Default?.SendTrace("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
ComputeProgram program = new ComputeProgram(context, kernelSources);
program.Build(null, null, null, IntPtr.Zero);
log.WriteLine("Program successfully built.");
program.CreateAllKernels();
log.WriteLine("Kernels successfully created.");
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
/// <summary>
/// Creates a new <see cref="ComputeUserEvent"/>.
/// </summary>
/// <param name="context"> The <see cref="ComputeContext"/> in which the <see cref="ComputeUserEvent"/> is created. </param>
/// <remarks> Requires OpenCL 1.1. </remarks>
public ComputeUserEvent(ComputeContext context)
{
unsafe
{
ComputeErrorCode error;
Handle = CL11.CreateUserEvent(context.Handle, &error);
ComputeException.ThrowOnError(error);
Type = (ComputeCommandType)GetInfo<ComputeEventInfo, uint>(
ComputeEventInfo.CommandType, CL10.GetEventInfo);
Context = context;
HookNotifier();
}
Trace.WriteLine("Created " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").");
}
/// <summary>
/// Creates a new <see cref="ComputeSampler"/>.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/>. </param>
/// <param name="normalizedCoords"> The usage state of normalized coordinates when accessing a <see cref="ComputeImage"/> in a <see cref="ComputeKernel"/>. </param>
/// <param name="addressing"> The <see cref="ComputeImageAddressing"/> mode of the <see cref="ComputeSampler"/>. Specifies how out-of-range image coordinates are handled while reading. </param>
/// <param name="filtering"> The <see cref="ComputeImageFiltering"/> mode of the <see cref="ComputeSampler"/>. Specifies the type of filter that must be applied when reading data from an image. </param>
public ComputeSampler(ComputeContext context, bool normalizedCoords, ComputeImageAddressing addressing, ComputeImageFiltering filtering)
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL12.CreateSampler(context.Handle, normalizedCoords, addressing, filtering, out error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
this.addressing = addressing;
this.context = context;
this.filtering = filtering;
this.normalizedCoords = normalizedCoords;
Trace.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
/// <summary>
/// Construct an OpenCL platform.
/// </summary>
///
/// <param name="platform">The OpenCL platform.</param>
public EncogCLPlatform(ComputePlatform platform)
{
this.platform = platform;
this.devices = new List<EncogCLDevice>();
ComputeContextPropertyList cpl = new ComputeContextPropertyList(platform);
this.context = new ComputeContext(ComputeDeviceTypes.Default, cpl, null, IntPtr.Zero);
this.Name = platform.Name;
this.Vender = platform.Vendor;
this.Enabled = true;
foreach (ComputeDevice device in context.Devices)
{
EncogCLDevice adapter = new EncogCLDevice(this, device);
this.devices.Add(adapter);
}
}
/// <summary>
/// Creates a new <c>ComputeSampler</c>.
/// </summary>
/// <param name="context"> A <c>ComputeContext</c>. </param>
/// <param name="normalizedCoords"> The usage state of normalized coordinates when accessing a <c>ComputeImage</c> in a <c>ComputeKernel</c>. </param>
/// <param name="addressing"> The <c>ComputeImageAddressing</c> mode of the <c>ComputeSampler</c>. Specifies how out-of-range image coordinates are handled while reading. </param>
/// <param name="filtering"> The <c>ComputeImageFiltering</c> mode of the <c>ComputeSampler</c>. Specifies the type of filter that must be applied when reading data from an image. </param>
public ComputeSampler(ComputeContext context, bool normalizedCoords, ComputeImageAddressing addressing, ComputeImageFiltering filtering)
{
unsafe
{
ComputeErrorCode error = ComputeErrorCode.Success;
Handle = CL10.CreateSampler(
context.Handle,
(normalizedCoords) ? ComputeBoolean.True : ComputeBoolean.False,
addressing,
filtering,
&error);
ComputeException.ThrowOnError(error);
this.addressing = addressing;
this.context = context;
this.filtering = filtering;
this.normalizedCoords = normalizedCoords;
}
}
private static void ConductSearch(ComputeContext context, ComputeKernel kernel)
{
var todos = GetQueenTaskPartition(NumQueens, 4);
var done = new List<QueenTask>();
ComputeEventList eventList = new ComputeEventList();
var commands = new ComputeCommandQueue(context, context.Devices[1], ComputeCommandQueueFlags.None);
Console.WriteLine("Starting {0} tasks, and working {1} at a time.", todos.Count, Spread);
QueenTask[] inProgress = GetNextAssignment(new QueenTask[] {}, todos, done);
var sw = new Stopwatch();
sw.Start();
while (inProgress.Any())
{
var taskBuffer =
new ComputeBuffer<QueenTask>(context,
ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.CopyHostPointer,
inProgress);
kernel.SetMemoryArgument(0, taskBuffer);
commands.WriteToBuffer(inProgress, taskBuffer, false, null);
for (int i = 0; i < 12; i++)
commands.Execute(kernel, null, new long[] { inProgress.Length }, null, eventList);
commands.ReadFromBuffer(taskBuffer, ref inProgress, false, eventList);
commands.Finish();
inProgress = GetNextAssignment(inProgress, todos, done);
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds / 1000.0);
ulong sum = done.Select(state => state.solutions)
.Aggregate((total, next) => total + next);
Console.WriteLine("Q({0})={1}", NumQueens, sum);
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
log.WriteLine("Original content:");
Random rand = new Random();
int count = 6;
long[] bufferContent = new long[count];
for (int i = 0; i < count; i++)
{
bufferContent[i] = (long)(rand.NextDouble() * long.MaxValue);
log.WriteLine("\t" + bufferContent[i]);
}
ComputeBuffer<long> buffer = new ComputeBuffer<long>(context, ComputeMemoryFlags.CopyHostPointer, bufferContent);
IntPtr mappedPtr = commands.Map(buffer, true, ComputeMemoryMappingFlags.Read, 0, bufferContent.Length, null);
log.WriteLine("Mapped content:");
for (int i = 0; i < bufferContent.Length; i++)
{
IntPtr ptr = new IntPtr(mappedPtr.ToInt64() + i * sizeof(long));
log.WriteLine("\t" + Marshal.ReadInt64(ptr));
}
commands.Unmap(buffer, ref mappedPtr, null);
// wait for the unmap to happen
commands.Finish();
// cleanup buffer
buffer.Dispose();
// cleanup commands
commands.Dispose();
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
