public Image CreateImage(MemoryFlags flags, ImageFormat format, ImageDescriptor descriptor)
{
return CreateImage(flags, format, descriptor, IntPtr.Zero);
}
internal BufferMemoryUsageConfiguration(IOpenClApi api, Context context, Action <Buffer <T> > memoryObjectCreatedCallback, MemoryFlags flags, Memory <T> hostMemory)
: base(api, context, memoryObjectCreatedCallback, flags)
{
_hostMemory = hostMemory;
}
private unsafe void ExecuteKernel(
Context context,
Device device,
CommandQueue commandQueue,
Kernel kernel,
float[] input,
float[] output,
int globalWorkSize,
int localWorkSize,
bool warming,
bool useHostPointer,
bool autoGroupSize,
bool enableProfiling,
out TimeSpan stopwatchTime,
out TimeSpan profiledTime,
out TimeSpan readTime)
{
MemoryFlags inFlags = (useHostPointer ? MemoryFlags.UseHostPointer : MemoryFlags.CopyHostPointer) | MemoryFlags.ReadOnly;
MemoryFlags outFlags = (useHostPointer ? MemoryFlags.UseHostPointer : MemoryFlags.CopyHostPointer) | MemoryFlags.ReadWrite;
int taskSize = input.Length;
// allocate buffers
fixed(float *pinput = input, poutput = output)
{
using (Buffer inputBuffer = context.CreateBuffer(inFlags, sizeof(float) * taskSize, (IntPtr)pinput),
outputBuffer = context.CreateBuffer(outFlags, sizeof(float) * taskSize, (IntPtr)poutput))
{
kernel.Arguments[0].SetValue(inputBuffer);
kernel.Arguments[1].SetValue(outputBuffer);
Console.WriteLine("Original global work size {0}", globalWorkSize);
Console.WriteLine("Original local work size {0}", localWorkSize);
if (autoGroupSize)
{
Console.WriteLine("Run-time determines optimal workgroup size");
}
IntPtr workGroupSizeMaximum = kernel.GetWorkGroupSize(device);
Console.WriteLine("Maximum workgroup size for this kernel {0}", workGroupSizeMaximum.ToInt64());
if (warming)
{
Console.Write("Warming up OpenCL execution...");
using (commandQueue.EnqueueNDRangeKernel(kernel, new[] { (IntPtr)globalWorkSize }, autoGroupSize ? null : new[] { (IntPtr)localWorkSize }))
{
}
commandQueue.Finish();
Console.WriteLine("Done");
}
Console.Write("Executing OpenCL kernel...");
var timer = Stopwatch.StartNew();
// execute kernel, pls notice autoGroupSize
using (Event perfEvent = commandQueue.EnqueueNDRangeKernel(kernel, new[] { (IntPtr)globalWorkSize }, autoGroupSize ? null : new[] { (IntPtr)localWorkSize }))
{
Event.WaitAll(perfEvent);
stopwatchTime = timer.Elapsed;
Console.WriteLine("Done");
if (enableProfiling)
{
ulong start = perfEvent.CommandStartTime;
ulong end = perfEvent.CommandEndTime;
// a tick is 100ns
profiledTime = TimeSpan.FromTicks((long)(end - start) / 100);
}
else
{
profiledTime = TimeSpan.Zero;
}
}
timer.Restart();
if (useHostPointer)
{
IntPtr tmpPtr;
using (commandQueue.EnqueueMapBuffer(outputBuffer, true, MapFlags.Read, 0, sizeof(float) * taskSize, out tmpPtr))
{
}
Assert.AreEqual((IntPtr)poutput, tmpPtr, "EnqueueMapBuffer failed to return original pointer");
using (commandQueue.EnqueueUnmapMemObject(outputBuffer, tmpPtr))
{
}
}
else
{
using (commandQueue.EnqueueReadBuffer(outputBuffer, true, 0, sizeof(float) * taskSize, (IntPtr)poutput))
{
}
}
commandQueue.Finish();
readTime = timer.Elapsed;
}
}
}
public Buffer CreateBuffer(MemoryFlags flags, long size)
{
return CreateBuffer(flags, size, IntPtr.Zero);
}
public static IntPtr Create(IntPtr address, uint size, MemoryProtection protection, MemoryFlags memoryflags, int fileDescriptor, uint offset)
{
var result = mmap(address, new UIntPtr(size), (int)protection, (int)memoryflags, fileDescriptor, new UIntPtr(offset));
ThrowOnError <MemoryMapFailedException>(result);
return(result);
}
public CLArgumentInfo SetReturnArgument <T>(int index, long size, MemoryFlags flags) where T : struct
{
MethodInfo.Arguments[index].CopyBack = true;
MethodInfo.Arguments[index].ComputeMemory = new ComputeBuffer <T>(context, (ComputeMemoryFlags)flags, size);
return(MethodInfo.Arguments[index]);
}
/// <summary>
/// Creates a 3D <see cref="Image"/>.
/// </summary>
/// <param name="width">The width of the image.</param>
/// <param name="height">The height of the image.</param>
/// <param name="depth">The depth of the image.</param>
/// <param name="memoryFlags">Is used to specify allocation and usage information about the image memory object being created.</param>
/// <param name="channelOrder">Specifies the number of channels and the channel layout.</param>
/// <param name="channelType">Describes the size of the channel data type.</param>
/// <returns>A new image.</returns>
public Image CreateImage3D(UInt64 width, UInt64 height, UInt64 depth, MemoryFlags memoryFlags, ImageChannelOrder channelOrder, ImageChannelType channelType)
{
return(CreateImage3D <dynamic>(null, width, height, depth, memoryFlags, channelOrder, channelType));
}
public Buffer <T> CreateBuffer <T>(MemoryFlags flags, long size)
where T : struct
{
return(CreateBuffer <T>(flags, size, IntPtr.Zero));
}
/// <summary>
/// Creates an array of 2D <see cref="Image"/>s.
/// </summary>
/// <param name="arraySize">The number of images in the image array.</param>
/// <param name="width">The width of the image.</param>
/// <param name="height">The height of the image.</param>
/// <param name="memoryFlags">Is used to specify allocation and usage information about the image memory object being created.</param>
/// <param name="channelOrder">Specifies the number of channels and the channel layout.</param>
/// <param name="channelType">Describes the size of the channel data type.</param>
/// <returns>A new image.</returns>
public Image CreateImage2DArray(UInt64 arraySize, UInt64 width, UInt64 height, MemoryFlags memoryFlags, ImageChannelOrder channelOrder, ImageChannelType channelType)
{
return(CreateImage2DArray <dynamic>(null, arraySize, width, height, memoryFlags, channelOrder, channelType));
}
/// <summary>
/// Creates a 3D <see cref="Image"/>.
/// </summary>
/// <typeparam name="DataType">The type of image data.</typeparam>
/// <param name="data">An array of data to use with the image.</param>
/// <param name="width">The width of the image.</param>
/// <param name="height">The height of the image.</param>
/// <param name="depth">The depth of the image.</param>
/// <param name="memoryFlags">Is used to specify allocation and usage information about the image memory object being created.</param>
/// <param name="channelOrder">Specifies the number of channels and the channel layout.</param>
/// <param name="channelType">Describes the size of the channel data type.</param>
/// <returns>A new image.</returns>
public Image CreateImage3D <DataType>(DataType[] data, UInt64 width, UInt64 height, UInt64 depth, MemoryFlags memoryFlags, ImageChannelOrder channelOrder, ImageChannelType channelType)
{
ImageFormat format = new ImageFormat
{
ChannelOrder = channelOrder,
ChannelType = channelType
};
ImageDescriptor descriptor = new ImageDescriptor
{
ImageType = MemoryObjectType.Image3D,
Width = new UIntPtr(width),
Height = new UIntPtr(height),
Depth = new UIntPtr(depth),
ImageArraySize = UIntPtr.Zero,
ImageRowPitch = UIntPtr.Zero,
ImageSlicePitch = UIntPtr.Zero,
NumMipLevels = 0,
NumSamples = 0,
Buffer = IntPtr.Zero
};
return(CreateImage <DataType>(data, memoryFlags, format, descriptor));
}
/// <summary>
/// Creates a monodimensional <see cref="Image"/> using the data from a buffer.
/// </summary>
/// <param name="buffer">The buffer from where the image pixels are taken.</param>
/// <param name="width">The width of the image.</param>
/// <param name="memoryFlags">Is used to specify allocation and usage information about the image memory object being created.</param>
/// <param name="channelOrder">Specifies the number of channels and the channel layout.</param>
/// <param name="channelType">Describes the size of the channel data type.</param>
/// <returns>A new image.</returns>
public Image CreateImage1DBuffer(MemoryObject buffer, UInt64 width, MemoryFlags memoryFlags, ImageChannelOrder channelOrder, ImageChannelType channelType)
{
return(CreateImage1DBuffer <dynamic>(buffer, null, width, memoryFlags, channelOrder, channelType));
}
/// <summary>
/// Creates a monodimensional <see cref="Image"/>.
/// </summary>
/// <param name="width">The width of the image.</param>
/// <param name="memoryFlags">Is used to specify allocation and usage information about the image memory object being created.</param>
/// <param name="channelOrder">Specifies the number of channels and the channel layout.</param>
/// <param name="channelType">Describes the size of the channel data type.</param>
/// <returns>A new image.</returns>
public Image CreateImage1D(UInt64 width, MemoryFlags memoryFlags, ImageChannelOrder channelOrder, ImageChannelType channelType)
{
return(CreateImage1D <dynamic>(null, width, memoryFlags, channelOrder, channelType));
}
public extern static IntPtr clCreateBuffer ( IntPtr context, MemoryFlags flags, IntPtr size, IntPtr host_ptr, out int errcode_ret);
public extern static IntPtr clCreateBuffer(
IntPtr context,
MemoryFlags flags,
IntPtr size,
IntPtr host_ptr,
out int errcode_ret);
private extern static IntPtr clCreateBuffer(
IntPtr context,
MemoryFlags flags,
UIntPtr size,
IntPtr host_ptr,
out ErrorCode errcode_ret);
public static extern CLBuffer CreateFromGLRenderbuffer(
[In] CLContext context,
[In] MemoryFlags flags,
[In] int renderBuffer,
[Out] out CLResultCode error
);
public static Buffer Create <T>(Context context, MemoryFlags flags, T[] data) where T : struct
{
return(Create(context, flags, data, 0, data.Length));
}
public Image CreateImage(MemoryFlags flags, ImageFormat format, ImageDescriptor descriptor)
{
return(CreateImage(flags, format, descriptor, IntPtr.Zero));
}
public static Buffer Create <T>(Context context, MemoryFlags flags, T[] data, int index, int count) where T : struct
{
if (context == Context.Null)
{
throw new ArgumentNullException("context");
}
if (flags.HasFlag(MemoryFlags.WriteOnly) & flags.HasFlag(MemoryFlags.ReadOnly))
{
throw new ArgumentException("MemoryFlags.WriteOnly and MemoryFlags.ReadOnly are mutually exclusive.");
}
if (flags.HasFlag(MemoryFlags.HostWriteOnly) & flags.HasFlag(MemoryFlags.HostReadOnly))
{
throw new ArgumentException("MemoryFlags.HostWriteOnly and MemoryFlags.HostReadOnly are mutually exclusive.");
}
if (flags.HasFlag(MemoryFlags.HostWriteOnly) & flags.HasFlag(MemoryFlags.HostNoAccess))
{
throw new ArgumentException("MemoryFlags.HostWriteOnly and MemoryFlags.HostNoAccess are mutually exclusive.");
}
if (flags.HasFlag(MemoryFlags.HostReadOnly) & flags.HasFlag(MemoryFlags.HostNoAccess))
{
throw new ArgumentException("MemoryFlags.HostReadOnly and MemoryFlags.HostNoAccess are mutually exclusive.");
}
if (flags.HasFlag(MemoryFlags.UseHostPtr))
{
throw new ArgumentException("MemoryFlags.UseHostPtr is not valid.");
}
if (flags.HasFlag(MemoryFlags.CopyHostPtr))
{
throw new ArgumentException("MemoryFlags.CopyHostPtr is not valid.");
}
if (data == null)
{
throw new ArgumentNullException("data");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("index", index, "index is less than 0.");
}
if (count == 0)
{
throw new ArgumentOutOfRangeException("count", count, "count is 0.");
}
if (index + count > data.Length)
{
throw new ArgumentOutOfRangeException("count", count, "index + count is greater than data.Length.");
}
var handle = GCHandle.Alloc(data, GCHandleType.Pinned);
var size = Marshal.SizeOf(typeof(T));
var ptr = handle.AddrOfPinnedObject();
flags |= MemoryFlags.CopyHostPtr;
Buffer buffer = Buffer.Null;
try
{
buffer = new Buffer(context, flags, (ulong)(size * count), IntPtr.Add(ptr, size * index));
}
finally
{
handle.Free();
}
return(buffer);
}
public CLArgumentInfo SetArgument <T>(int index, T[] Value, MemoryFlags flags) where T : struct
{
MethodInfo.Arguments[index].ComputeMemory = new ComputeBuffer <T>(context, (ComputeMemoryFlags)flags, Value);
return(MethodInfo.Arguments[index]);
}
public Buffer(Context context, MemoryFlags flags, ulong size, IntPtr hostPtr)
: this()
{
if (context == Context.Null)
{
throw new ArgumentNullException("context");
}
if (flags.HasFlag(MemoryFlags.WriteOnly) & flags.HasFlag(MemoryFlags.ReadOnly))
{
throw new ArgumentException("MemoryFlags.WriteOnly and MemoryFlags.ReadOnly are mutually exclusive.");
}
if (flags.HasFlag(MemoryFlags.HostWriteOnly) & flags.HasFlag(MemoryFlags.HostReadOnly))
{
throw new ArgumentException("MemoryFlags.HostWriteOnly and MemoryFlags.HostReadOnly are mutually exclusive.");
}
if (flags.HasFlag(MemoryFlags.HostWriteOnly) & flags.HasFlag(MemoryFlags.HostNoAccess))
{
throw new ArgumentException("MemoryFlags.HostWriteOnly and MemoryFlags.HostNoAccess are mutually exclusive.");
}
if (flags.HasFlag(MemoryFlags.HostReadOnly) & flags.HasFlag(MemoryFlags.HostNoAccess))
{
throw new ArgumentException("MemoryFlags.HostReadOnly and MemoryFlags.HostNoAccess are mutually exclusive.");
}
if (hostPtr == IntPtr.Zero)
{
if (flags.HasFlag(MemoryFlags.UseHostPtr))
{
throw new ArgumentException("MemoryFlags.UseHostPtr is not valid.");
}
if (flags.HasFlag(MemoryFlags.CopyHostPtr))
{
throw new ArgumentException("MemoryFlags.CopyHostPtr is not valid.");
}
}
else
{
if (!flags.HasFlag(MemoryFlags.UseHostPtr) & !flags.HasFlag(MemoryFlags.CopyHostPtr))
{
throw new ArgumentException("MemoryFlags.UseHostPtr or MemoryFlags.CopyHostPtr is required.");
}
if (flags.HasFlag(MemoryFlags.UseHostPtr) & flags.HasFlag(MemoryFlags.CopyHostPtr))
{
throw new ArgumentException("MemoryFlags.UseHostPtr and MemoryFlags.CopyHostPtr are mutually exclusive.");
}
if (flags.HasFlag(MemoryFlags.UseHostPtr) & flags.HasFlag(MemoryFlags.AllocHostPtr))
{
throw new ArgumentException("MemoryFlags.UseHostPtr and MemoryFlags.AllocHostPtr are mutually exclusive.");
}
}
if (size == 0)
{
throw new ArgumentOutOfRangeException("size", size, "size is 0.");
}
unsafe
{
int error;
Handle = Cl.CreateBuffer(context.Handle, (ulong)flags, new UIntPtr(size), hostPtr.ToPointer(), &error);
ClHelper.GetError(error);
}
}
public CLArgument(bool copyback, T[] data, MemoryFlags flags)
{
CopyBack = copyback;
Data = data;
Flags = flags;
}
public Buffer CreateBuffer(MemoryFlags flags, long size)
{
return(CreateBuffer(flags, size, IntPtr.Zero));
}
public void SetFlag(MemoryFlags flag)
{
_flags = _flags | flag;
}
public Buffer CreateSubBuffer(MemoryFlags flags, BufferRegion regionInfo)
{
BufferSafeHandle subBuffer = UnsafeNativeMethods.CreateSubBuffer(Handle, flags, regionInfo);
return(new Buffer(Context, this, subBuffer));
}
public Buffer CreateBuffer(MemoryFlags flags, long size, IntPtr hostAddress)
{
if (size < 0)
throw new ArgumentOutOfRangeException("size");
else if (size == 0)
throw new ArgumentException("Invalid buffer size.");
if (hostAddress == IntPtr.Zero && (flags & (MemoryFlags.UseHostPointer | MemoryFlags.CopyHostPointer)) != 0)
throw new ArgumentException("Invalid host address.");
if (hostAddress != IntPtr.Zero && (flags & (MemoryFlags.UseHostPointer | MemoryFlags.CopyHostPointer)) == 0)
throw new ArgumentException("Invalid host address.");
BufferSafeHandle handle = UnsafeNativeMethods.CreateBuffer(Handle, flags, (IntPtr)size, hostAddress);
return new Buffer(this, handle);
}
public static extern IntPtr LocalAlloc(
[In, MarshalAs(UnmanagedType.I4)] MemoryFlags flags,
int size);
public Image CreateImage(MemoryFlags flags, ImageFormat format, ImageDescriptor descriptor, IntPtr hostAddress)
{
if (hostAddress == IntPtr.Zero && (flags & (MemoryFlags.UseHostPointer | MemoryFlags.CopyHostPointer)) != 0)
throw new ArgumentException("Invalid host address.");
if (hostAddress != IntPtr.Zero && (flags & (MemoryFlags.UseHostPointer | MemoryFlags.CopyHostPointer)) == 0)
throw new ArgumentException("Invalid host address.");
ImageSafeHandle handle = UnsafeNativeMethods.CreateImage(Handle, flags, ref format, ref descriptor, hostAddress);
return new Image(this, handle);
}
/// <summary>
/// Constructor of the <see cref="Buffer"/> object. Don't use this constructor, use <see cref="Context.CreateBuffer{DataType}(DataType[], MemoryFlags)"/> or <see cref="Context.CreateBuffer{DataType}(ulong, MemoryFlags)"/> instead.
/// </summary>
public Buffer(IntPtr handle, Context context, UInt64 length, UInt64 itemSize, MemoryObjectType objectType, MemoryFlags memoryFlags) : base(handle, context, objectType, memoryFlags)
{
Length = length;
ItemSize = itemSize;
}
