public static ContextSafeHandle CreateContextFromType(DeviceType deviceType, CreateContextCallback pfnNotify, IntPtr userData)
{
ErrorCode errorCode = ErrorCode.Success;
ContextSafeHandle result = clCreateContextFromType(null, deviceType, pfnNotify, userData, out errorCode);
ErrorHandler.ThrowOnFailure(errorCode);
return(result);
}
public static CommandQueueSafeHandle CreateCommandQueue(ContextSafeHandle context, ClDeviceID device, CommandQueueProperties properties)
{
ErrorCode errorCode;
CommandQueueSafeHandle result = clCreateCommandQueue(context, device, properties, out errorCode);
ErrorHandler.ThrowOnFailure(errorCode);
return(result);
}
private static extern ProgramSafeHandle clCreateProgramWithBinary(
ContextSafeHandle context,
uint numDevices,
[In, MarshalAs(UnmanagedType.LPArray)] ClDeviceID[] devices,
[In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] lengths,
[In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] binaries,
[Out, MarshalAs(UnmanagedType.LPArray)] ErrorCode[] binaryStatus,
out ErrorCode errorCode);
public static ContextSafeHandle CreateContext(ClDeviceID[] devices, CreateContextCallback pfnNotify, IntPtr userData)
{
ErrorCode errorCode = ErrorCode.Success;
ContextSafeHandle result = clCreateContext(null, (uint)devices.Length, devices, pfnNotify, userData, out errorCode);
ErrorHandler.ThrowOnFailure(errorCode);
return(result);
}
private Context(ContextSafeHandle context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
_context = context;
}
public static ContextSafeHandle CreateContext(ClPlatformID platform, ClDeviceID[] devices, CreateContextCallback pfnNotify, IntPtr userData)
{
IntPtr[] properties = { ContextProperties.Platform, platform.Handle, IntPtr.Zero };
ErrorCode errorCode = ErrorCode.Success;
ContextSafeHandle result = clCreateContext(properties, (uint)devices.Length, devices, pfnNotify, userData, out errorCode);
ErrorHandler.ThrowOnFailure(errorCode);
return(result);
}
/// <summary>
/// Destroy the Forms API context.
/// </summary>
public static void Destroy()
{
if (_context.IsInvalid)
{
return;
}
_context.Dispose();
_context = null;
}
private static extern ProgramSafeHandle clLinkProgram(
ContextSafeHandle context,
uint numDevices,
[In, MarshalAs(UnmanagedType.LPArray)] ClDeviceID[] devices,
[MarshalAs(UnmanagedType.LPStr)] string options,
uint numInputPrograms,
[In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SafeHandleArrayMarshaler))] ProgramSafeHandle[] inputPrograms,
BuildProgramCallback pfnNotify,
IntPtr userData,
out ErrorCode errorCode);
public static Context Create(Platform platform, DeviceType deviceType)
{
if (platform == null)
{
throw new ArgumentNullException("platform");
}
ContextSafeHandle handle = UnsafeNativeMethods.CreateContextFromType(platform.ID, deviceType, null, IntPtr.Zero);
return(new Context(handle));
}
/// <summary>
/// Creates a program object for a <paramref name="context"/>, and loads specified binary
/// data into the <see cref="Program"/> object.
/// </summary>
/// <remarks>
/// OpenCL allows applications to create a program object using the program source or binary
/// and build appropriate program executables. This allows applications to determine whether
/// they want to use the pre-built offline binary or load and compile the program source
/// and use the executable compiled/linked online as the program executable. This can be
/// very useful as it allows applications to load and build program executables online on
/// its first instance for appropriate OpenCL devices in the system. These executables can
/// now be queried and cached by the application. Future instances of the application
/// launching will no longer need to compile and build the program executables. The cached
/// executables can be read and loaded by the application, which can help significantly
/// reduce the application initialization time.
/// </remarks>
/// <param name="context">Must be a valid OpenCL context.</param>
/// <param name="devices">A pointer to a list of devices that are in context. device_list
/// must be a non-NULL value. The binaries are loaded for devices specified in this list.</param>
/// <param name="bins">An array of pointers to program binaries to be loaded for devices
/// specified by device_list. For each device given by device_list[i], the pointer to the
/// program binary for that device is given by binaries[i] and the length of this
/// corresponding binary is given by lengths[i]. lengths[i] cannot be zero and binaries[i]
/// cannot be a NULL pointer.</param>
/// <returns>
/// <see cref="clUnloadPlatformCompiler"/> returns <see cref="ErrorCode.Success"/>
/// if the function is executed successfully. Otherwise, it returns one of the following
/// errors:
///
/// <list type="bullet">
/// <item><see cref="ErrorCode.InvalidContext"/> if <paramref name="context"/> is not a valid context.</item>
/// <item><see cref="ErrorCode.InvalidValue"/> if device_list is NULL or num_devices is zero; or if lengths or binaries are null or if any entry in lengths[i] or binaries[i] is NULL.</item>
/// <item><see cref="ErrorCode.InvalidDevice"/> if OpenCL devices listed in device_list are not in the list of devices associated with context.</item>
/// <item><see cref="ErrorCode.InvalidBinary"/> if an invalid program binary was encountered for any device. binary_status will return specific status for each device.</item>
/// <item><see cref="ErrorCode.OutOfHostMemory"/> if there is a failure to allocate resources required by the OpenCL implementation on the host.</item>
/// </list>
/// </returns>
public static ProgramSafeHandle CreateProgramWithBinary(ContextSafeHandle context, ClDeviceID[] devices, byte[][] bins)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (bins == null)
{
throw new ArgumentNullException("bins");
}
if (devices == null)
{
throw new ArgumentNullException("devices");
}
if (devices.Length == 0)
{
throw new ArgumentException("No devices specified.");
}
uint devCt = (devices != null && devices.Length > 0) ? (uint)devices.Length : 0;
int binCt = bins.Length;
IntPtr[] lengths = Array.ConvertAll(bins, b => (IntPtr)b.Length);
ErrorCode errorCode;
ErrorCode[] binaryStatus = new ErrorCode[binCt];
GCHandle[] gh = null;
ProgramSafeHandle handle;
try
{
gh = Array.ConvertAll(bins, b => GCHandle.Alloc(b, GCHandleType.Pinned));
IntPtr[] binaries = Array.ConvertAll(gh, h => h.AddrOfPinnedObject());
//todo: had to put in a 1 for devCt. On systems with more then 1 device using
//anything larger then 1 here fails so forcing 1 for now because at least it works.
//was: handle = clCreateProgramWithBinary(context, devCt, devices, lengths, binaries, binaryStatus, out errorCode);
handle = clCreateProgramWithBinary(context, 1, devices, lengths, binaries, binaryStatus, out errorCode);
}
finally
{
for (int i = 0; i < gh.Length; i++)
{
gh[i].Free();
}
}
ErrorHandler.ThrowOnFailure(errorCode);
return(handle);
}
internal static SamplerSafeHandle CreateSampler(ContextSafeHandle context, bool normalizedCoordinates, AddressingMode addressingMode, FilterMode filterMode)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
ErrorCode errorCode;
SamplerSafeHandle handle = clCreateSampler(context, normalizedCoordinates, addressingMode, filterMode, out errorCode);
ErrorHandler.ThrowOnFailure(errorCode);
return(handle);
}
public static EventSafeHandle CreateUserEvent(ContextSafeHandle context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ErrorCode errorCode;
EventSafeHandle handle = clCreateUserEvent(context, out errorCode);
ErrorHandler.ThrowOnFailure(errorCode);
return(handle);
}
public static Context Create(Platform platform, params Device[] devices)
{
if (devices == null)
{
throw new ArgumentNullException("devices");
}
if (devices.Length == 0)
{
throw new ArgumentException("No devices specified.");
}
UnsafeNativeMethods.ClDeviceID[] deviceIDs = Array.ConvertAll(devices, device => device.ID);
ContextSafeHandle handle = UnsafeNativeMethods.CreateContext(platform.ID, deviceIDs, null, IntPtr.Zero);
return(new Context(handle));
}
public static ProgramSafeHandle CreateProgramWithSource(ContextSafeHandle context, string[] strings)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (strings == null)
{
throw new ArgumentNullException("strings");
}
ErrorCode errorCode;
ProgramSafeHandle handle = clCreateProgramWithSource(context, (uint)strings.Length, strings, null, out errorCode);
ErrorHandler.ThrowOnFailure(errorCode);
return(handle);
}
public static T GetContextInfo <T>(ContextSafeHandle context, ContextParameterInfo <T> parameter)
{
int?fixedSize = parameter.ParameterInfo.FixedSize;
#if DEBUG
bool verifyFixedSize = true;
#else
bool verifyFixedSize = false;
#endif
UIntPtr requiredSize;
if (fixedSize.HasValue && !verifyFixedSize)
{
requiredSize = (UIntPtr)fixedSize;
}
else
{
ErrorHandler.ThrowOnFailure(clGetContextInfo(context, parameter.ParameterInfo.Name, UIntPtr.Zero, IntPtr.Zero, out requiredSize));
}
if (verifyFixedSize && fixedSize.HasValue)
{
if (requiredSize.ToUInt64() != (ulong)fixedSize.Value)
{
throw new ArgumentException("The parameter definition includes a fixed size that does not match the required size according to the runtime.");
}
}
IntPtr memory = IntPtr.Zero;
try
{
memory = Marshal.AllocHGlobal((int)requiredSize.ToUInt32());
UIntPtr actualSize;
ErrorHandler.ThrowOnFailure(clGetContextInfo(context, parameter.ParameterInfo.Name, requiredSize, memory, out actualSize));
return(parameter.ParameterInfo.Deserialize(actualSize, memory));
}
finally
{
Marshal.FreeHGlobal(memory);
}
}
private static extern EventSafeHandle clCreateUserEvent(ContextSafeHandle context, out ErrorCode errorCode);
public static extern D2fErrorCode d2fcrdap_Apply(ContextSafeHandle pd2fctx, ObjectSafeHandle pd2fcrd, ObjectSafeHandle pd2ffmd);
private static extern ProgramSafeHandle clCreateProgramWithBuiltInKernels(
ContextSafeHandle context,
uint numDevices,
[In, MarshalAs(UnmanagedType.LPArray)] ClDeviceID[] devices,
[MarshalAs(UnmanagedType.LPStr)] string kernelNames,
out ErrorCode errorCode);
public static extern D2fErrorCode d2fobfo_FindObj(ContextSafeHandle pd2fctx,
ObjectSafeHandle owner,
string name,
ObjectType objtyp,
out ObjectSafeHandle ppd2fob);
private static extern ProgramSafeHandle clCreateProgramWithSource(
ContextSafeHandle context,
uint count,
[In, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPStr)] string[] strings,
[In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] lengths,
out ErrorCode errorCode);
public static extern D2fErrorCode d2ffmdsv_Save(ContextSafeHandle pd2fctx,
ObjectSafeHandle pd2ffmd,
string formname,
[MarshalAs(UnmanagedType.I1)] bool db);
private static extern ErrorCode clRetainContext(ContextSafeHandle context);
public static extern D2fErrorCode d2fcrdex_Extract(ContextSafeHandle pd2fctx, ObjectSafeHandle pd2fcrd, ObjectSafeHandle pd2ffmd);
public static extern D2fErrorCode d2ffntcr_Create(ContextSafeHandle pd2fctx, out ObjectSafeHandle ppd2ffnt);
public static extern D2fErrorCode d2fobmv_Move(ContextSafeHandle pd2fctx, ObjectSafeHandle pd2fob, ObjectSafeHandle pd2fob_nxt);
public static extern D2fErrorCode d2ffntap_Apply(ContextSafeHandle pd2fctx, ObjectSafeHandle pd2ffnt, ObjectSafeHandle pd2fob, VisualAttributeType vat_typ);
private static extern ErrorCode clGetContextInfo(
ContextSafeHandle context,
int paramName,
UIntPtr paramValueSize,
IntPtr paramValue,
out UIntPtr paramValueSizeRet);
public static extern D2fErrorCode d2ffmdco_CompileObj(ContextSafeHandle pd2fctx, ObjectSafeHandle pd2ffmd);
public static extern D2fErrorCode d2fobsc_SubClass(ContextSafeHandle pd2fctx,
ObjectSafeHandle pd2fob,
ObjectSafeHandle parent,
[MarshalAs(UnmanagedType.I1)] bool keep_path);
public static extern D2fErrorCode d2falbdt_Detach(ContextSafeHandle pd2fctx, ObjectSafeHandle pd2falb);