/// <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="data"> The data for the <see cref="ComputeBuffer{T}"/>. </param>
/// <remarks> Note, that <paramref name="data"/> cannot be an "immediate" parameter, i.e.: <c>new T[100]</c>, because it could be quickly collected by the GC causing Amplifier.OpenCL.Cloo to send and invalid reference to OpenCL. </remarks>
public ComputeBuffer(ComputeContext context, ComputeMemoryFlags flags, T[] data)
: base(context, flags)
{
var size = ComputeTools.SizeOf <T>() * data.Length;
GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
try
{
Handle = CL12.CreateBuffer(context.Handle, flags, new IntPtr(size), dataPtr.AddrOfPinnedObject(), out var error);
ComputeException.ThrowOnError(error);
}
finally
{
dataPtr.Free();
}
Init(size, data.Length);
}
/// <summary>
///
/// </summary>
/// <typeparam name="THandleType"></typeparam>
/// <typeparam name="TInfoType"></typeparam>
/// <typeparam name="TQueriedType"></typeparam>
/// <param name="handle"></param>
/// <param name="paramName"></param>
/// <param name="getInfoDelegate"></param>
/// <returns></returns>
protected static TQueriedType GetInfo <THandleType, TInfoType, TQueriedType>
(THandleType handle, TInfoType paramName, GetInfoDelegate <THandleType, TInfoType> getInfoDelegate)
where TQueriedType : struct
{
TQueriedType result = new TQueriedType();
GCHandle gcHandle = GCHandle.Alloc(result, GCHandleType.Pinned);
try
{
ComputeErrorCode error = getInfoDelegate(handle, paramName, (IntPtr)Marshal.SizeOf(result), gcHandle.AddrOfPinnedObject(), out _);
ComputeException.ThrowOnError(error);
}
finally
{
result = (TQueriedType)gcHandle.Target;
gcHandle.Free();
}
return(result);
}
/// <summary>
/// Gets a read-only collection of available <see cref="ComputeDevice"/>s on the <see cref="ComputePlatform"/>.
/// </summary>
/// <returns> A read-only collection of the available <see cref="ComputeDevice"/>s on the <see cref="ComputePlatform"/>. </returns>
/// <remarks> This method resets the <c>ComputePlatform.Devices</c>. This is useful if one or more of them become unavailable (<c>ComputeDevice.Available</c> is <c>false</c>) after a <see cref="ComputeContext"/> and <see cref="ComputeCommandQueue"/>s that use the <see cref="ComputeDevice"/> have been created and commands have been queued to them. Further calls will trigger an <c>OutOfResourcesComputeException</c> until this method is executed. You will also need to recreate any <see cref="ComputeResource"/> that was created on the no longer available <see cref="ComputeDevice"/>. </remarks>
public ReadOnlyCollection <ComputeDevice> QueryDevices()
{
ComputeErrorCode error = CL12.GetDeviceIDs(Handle, ComputeDeviceTypes.All, 0, null, out var handlesLength);
ComputeException.ThrowOnError(error);
CLDeviceHandle[] handles = new CLDeviceHandle[handlesLength];
error = CL12.GetDeviceIDs(Handle, ComputeDeviceTypes.All, handlesLength, handles, out handlesLength);
ComputeException.ThrowOnError(error);
ComputeDevice[] devices = new ComputeDevice[handlesLength];
for (int i = 0; i < handlesLength; i++)
{
devices[i] = new ComputeDevice(this, handles[i]);
}
_devices = new ReadOnlyCollection <ComputeDevice>(devices);
return(_devices);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TMainHandleType"></typeparam>
/// <typeparam name="TSecondHandleType"></typeparam>
/// <typeparam name="TInfoType"></typeparam>
/// <typeparam name="TQueriedType"></typeparam>
/// <param name="mainHandle"></param>
/// <param name="secondHandle"></param>
/// <param name="paramName"></param>
/// <param name="getInfoDelegate"></param>
/// <returns></returns>
protected static TQueriedType[] GetArrayInfo <TMainHandleType, TSecondHandleType, TInfoType, TQueriedType>
(TMainHandleType mainHandle, TSecondHandleType secondHandle, TInfoType paramName, GetInfoDelegateEx <TMainHandleType, TSecondHandleType, TInfoType> getInfoDelegate)
{
var error = getInfoDelegate(mainHandle, secondHandle, paramName, IntPtr.Zero, IntPtr.Zero, out var bufferSizeRet);
ComputeException.ThrowOnError(error);
var buffer = new TQueriedType[bufferSizeRet.ToInt64() / Marshal.SizeOf(typeof(TQueriedType))];
GCHandle gcHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
try
{
error = getInfoDelegate(mainHandle, secondHandle, paramName, bufferSizeRet, gcHandle.AddrOfPinnedObject(), out bufferSizeRet);
ComputeException.ThrowOnError(error);
}
finally
{
gcHandle.Free();
}
return(buffer);
}
public static void Unload()
{
ComputeErrorCode error = CL12.UnloadCompiler();
ComputeException.ThrowOnError(error);
}
/// <summary>
/// Sets the new status of the <see cref="ComputeUserEvent"/> to an error value.
/// </summary>
/// <param name="status"> The error status of the <see cref="ComputeUserEvent"/>. This should be a negative value. </param>
public void SetStatus(int status)
{
ComputeErrorCode error = CL11.SetUserEventStatus(Handle, status);
ComputeException.ThrowOnError(error);
}
