/// <summary>
/// Enqueues a command to map a part of a buffer into the host address space.
/// </summary>
/// <param name="buffer"> The buffer to map. </param>
/// <param name="blocking"> The mode of operation of this call. </param>
/// <param name="flags"> A list of properties for the mapping mode. </param>
/// <param name="offset"> The <paramref name="buffer"/> element position where mapping starts. </param>
/// <param name="region"> The region of elements to map. </param>
/// <param name="events"> A collection of events that need to complete before this particular command can be executed. If <paramref name="events"/> is not <c>null</c> or read-only a new <see cref="ComputeEvent"/> identifying this command is created and attached to the end of the collection. </param>
/// <remarks> If <paramref name="blocking"/> is <c>true</c> this method will not return until the command completes. If <paramref name="blocking"/> is <c>false</c> this method will return immediately after the command is enqueued. </remarks>
public IntPtr Map <T>(ComputeBufferBase <T> buffer, bool blocking, ComputeMemoryMappingFlags flags, long offset, long region, 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;
IntPtr mappedPtr = IntPtr.Zero;
ComputeErrorCode error = ComputeErrorCode.Success;
mappedPtr = CL10.EnqueueMapBuffer(Handle, buffer.Handle, blocking, flags, new IntPtr(offset * sizeofT), new IntPtr(region * sizeofT), eventWaitListSize, eventHandles, newEventHandle, out error);
ComputeException.ThrowOnError(error);
if (eventsWritable)
{
events.Add(new ComputeEvent(newEventHandle[0], this));
}
return(mappedPtr);
}
public void ReadFromBuffer <T>(ComputeBufferBase <T> source, ref T[] destination, bool blocking, long sourceOffset, long destinationOffset, long region, IList <ComputeEventBase> events) where T : struct
{
GCHandle destinationGCHandle = GCHandle.Alloc(destination, GCHandleType.Pinned);
IntPtr destinationOffsetPtr = Marshal.UnsafeAddrOfPinnedArrayElement(destination, (int)destinationOffset);
if (blocking)
{
Read(source, blocking, sourceOffset, region, destinationOffsetPtr, events);
destinationGCHandle.Free();
}
else
{
bool userEventsWritable = (events != null && !events.IsReadOnly);
IList <ComputeEventBase> eventList = (userEventsWritable) ? events : Events;
Read(source, blocking, sourceOffset, region, destinationOffsetPtr, eventList);
ComputeEvent newEvent = (ComputeEvent)eventList[eventList.Count - 1];
newEvent.TrackGCHandle(destinationGCHandle);
}
}
/// <summary>
/// Enqueues a command to write data to a buffer.
/// </summary>
/// <param name="destination"> The buffer to write to. </param>
/// <param name="blocking"> The mode of operation of this command. If <c>true</c> this call will not return until the command has finished execution. </param>
/// <param name="destinationOffset"> The <paramref name="destination"/> element position where writing starts. </param>
/// <param name="region"> The region of elements to write. </param>
/// <param name="source"> The data written to the buffer. </param>
/// <param name="events"> A collection of events that need to complete before this particular command can be executed. If <paramref name="events"/> is not <c>null</c> or read-only a new <see cref="ComputeEvent"/> identifying this command is created and attached to the end of the collection. </param>
/// <remarks> If <paramref name="blocking"/> is <c>true</c> this method will not return until the command completes. If <paramref name="blocking"/> is <c>false</c> this method will return immediately after the command is enqueued. </remarks>
public void Write <T>(ComputeBufferBase <T> destination, 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, destination.Handle, 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));
}
}
/// <summary>
/// Enqueues a command to copy data from buffer to <see cref="ComputeImage"/>.
/// </summary>
/// <typeparam name="T"> The type of data in <paramref name="source"/>. </typeparam>
/// <param name="source"> The buffer to copy from. </param>
/// <param name="destination"> The image to copy to. </param>
/// <param name="sourceOffset"> The <paramref name="source"/> element position where reading starts. </param>
/// <param name="destinationOffset"> The <paramref name="destination"/> element position where writing starts. </param>
/// <param name="region"> The region of elements to copy. </param>
/// <param name="events"> A collection of events that need to complete before this particular command can be executed. If <paramref name="events"/> is not <c>null</c> or read-only a new <see cref="ComputeEvent"/> identifying this command is created and attached to the end of the collection. </param>
public void Copy <T>(ComputeBufferBase <T> source, ComputeImage destination, long sourceOffset, SysIntX3 destinationOffset, SysIntX3 region, 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.EnqueueCopyBufferToImage(Handle, source.Handle, destination.Handle, new IntPtr(sourceOffset * sizeofT), ref destinationOffset, ref region, eventWaitListSize, eventHandles, newEventHandle);
ComputeException.ThrowOnError(error);
if (eventsWritable)
{
events.Add(new ComputeEvent(newEventHandle[0], this));
}
}
/// <summary>
/// Enqueues a command to write a 2D or 3D region of elements to a buffer.
/// </summary>
/// <typeparam name="T"> The type of the elements of the buffer. </typeparam>
/// <param name="destination"> The buffer to write to. </param>
/// <param name="blocking"> The mode of operation of this command. If <c>true</c> this call will not return until the command has finished execution. </param>
/// <param name="destinationOffset"> The <paramref name="destination"/> element position where writing starts. </param>
/// <param name="sourceOffset"> The <paramref name="source"/> element position where reading starts. </param>
/// <param name="region"> The region of elements to copy. </param>
/// <param name="destinationRowPitch"> The size of the destination buffer row in bytes. If set to zero then <paramref name="destinationRowPitch"/> equals <c>region.X * sizeof(T)</c>. </param>
/// <param name="destinationSlicePitch"> The size of the destination buffer 2D slice in bytes. If set to zero then <paramref name="destinationSlicePitch"/> equals <c>region.Y * sizeof(T) * destinationRowPitch</c>. </param>
/// <param name="sourceRowPitch"> The size of the memory area row in bytes. If set to zero then <paramref name="sourceRowPitch"/> equals <c>region.X * sizeof(T)</c>. </param>
/// <param name="sourceSlicePitch"> The size of the memory area 2D slice in bytes. If set to zero then <paramref name="sourceSlicePitch"/> equals <c>region.Y * sizeof(T) * sourceRowPitch</c>. </param>
/// <param name="source"> The data written to the buffer. </param>
/// <param name="events"> A collection of events that need to complete before this particular command can be executed. If <paramref name="events"/> is not <c>null</c> or read-only a new <see cref="ComputeEvent"/> identifying this command is created and attached to the end of the collection. </param>
/// <remarks> Requires OpenCL 1.1. </remarks>
private void Write <T>(ComputeBufferBase <T> destination, bool blocking, SysIntX3 sourceOffset, SysIntX3 destinationOffset, SysIntX3 region, long destinationRowPitch, long destinationSlicePitch, long sourceRowPitch, long sourceSlicePitch, IntPtr source, ICollection <ComputeEventBase> events) where T : struct
{
int sizeofT = HDSPUtils.SizeOf(typeof(T));
sourceOffset.X = new IntPtr(sizeofT * sourceOffset.X.ToInt64());
destinationOffset.X = new IntPtr(sizeofT * destinationOffset.X.ToInt64());
region.X = new IntPtr(sizeofT * region.X.ToInt64());
int eventWaitListSize;
CLEventHandle[] eventHandles = ComputeTools.ExtractHandles(events, out eventWaitListSize);
bool eventsWritable = (events != null && !events.IsReadOnly);
CLEventHandle[] newEventHandle = (eventsWritable) ? new CLEventHandle[1] : null;
ComputeErrorCode error = CL11.EnqueueWriteBufferRect(this.Handle, destination.Handle, blocking, ref destinationOffset, ref sourceOffset, ref region, new IntPtr(destinationRowPitch), new IntPtr(destinationSlicePitch), new IntPtr(sourceRowPitch), new IntPtr(sourceSlicePitch), source, eventWaitListSize, eventHandles, newEventHandle);
ComputeException.ThrowOnError(error);
if (eventsWritable)
{
events.Add(new ComputeEvent(newEventHandle[0], this));
}
}
public void ReadFromBuffer <T>(ComputeBufferBase <T> source, ref T[] destination, bool blocking, IList <ComputeEventBase> events) where T : struct
{
ReadFromBuffer(source, ref destination, blocking, 0, 0, source.Count, events);
}
