/// <summary>
/// Builds (compiles and links) a program executable from the program source or binary for all or some of the <see cref="ComputeProgram.Devices"/>.
/// </summary>
/// <param name="devices"> A subset or all of <see cref="ComputeProgram.Devices"/>. If <paramref name="devices"/> is <c>null</c>, the executable is built for every item of <see cref="ComputeProgram.Devices"/> for which a source or a binary has been loaded. </param>
/// <param name="options"> A set of options for the OpenCL compiler. </param>
/// <param name="notify"> A delegate instance that represents a reference to a notification routine. This routine is a callback function that an application can register and which will be called when the program executable has been built (successfully or unsuccessfully). If <paramref name="notify"/> is not <c>null</c>, <see cref="ComputeProgram.Build"/> does not need to wait for the build to complete and can return immediately. If <paramref name="notify"/> is <c>null</c>, <see cref="ComputeProgram.Build"/> does not return until the build has completed. The callback function may be called asynchronously by the OpenCL implementation. It is the application's responsibility to ensure that the callback function is thread-safe and that the delegate instance doesn't get collected by the Garbage Collector until the build operation triggers the callback. </param>
/// <param name="notifyDataPtr"> Optional user data that will be passed to <paramref name="notify"/>. </param>
public void Build(ICollection <ComputeDevice> devices, string options, ComputeProgramBuildNotifier notify, IntPtr notifyDataPtr)
{
int handleCount;
CLDeviceHandle[] deviceHandles = ComputeTools.ExtractHandles(devices, out handleCount);
buildOptions = (options != null) ? options : "";
buildNotify = notify;
ComputeErrorCode error = CL12.BuildProgram(Handle, handleCount, deviceHandles, options, buildNotify, notifyDataPtr);
#if DEBUG
if (error != ComputeErrorCode.Success)
{
string str = String.Empty;
var ptr = Marshal.StringToHGlobalAnsi(str);
IntPtr size = IntPtr.Zero;
var errorCode = CL12.GetProgramBuildInfo(Handle, deviceHandles[0], ComputeProgramBuildInfo.BuildLog,
new IntPtr(4096), ptr,
out size);
if (errorCode == ComputeErrorCode.Success)
{
Debug.WriteLine($"Build Error:{Marshal.PtrToStringAnsi(ptr, (int) size)}");
}
}
#endif
ComputeException.ThrowOnError(error);
}
public static unsafe extern ComputeErrorCode BuildProgram(
IntPtr program,
Int32 num_devices,
IntPtr* device_list,
String options,
/* void (*pfn_notify)(cl_program program , IntPtr user_data ) */ ComputeProgramBuildNotifier pfn_notify,
/* void* */ IntPtr user_data);
public void Build(ICollection <ComputeDevice> devices, string options, ComputeProgramBuildNotifier notify, IntPtr notifyDataPtr)
{
IntPtr[] deviceHandles = ComputeTools.ExtractHandles(devices, out var handleCount);
buildNotify = notify;
CL10.BuildProgram(handle, handleCount, deviceHandles, options, buildNotify, notifyDataPtr);
}
public extern static ComputeErrorCode BuildProgram(
CLProgramHandle program,
Int32 num_devices,
[MarshalAs(UnmanagedType.LPArray)] CLDeviceHandle[] device_list,
String options,
ComputeProgramBuildNotifier pfn_notify,
IntPtr user_data);
/// <summary>
/// Builds (compiles and links) a program executable from the program source or binary for all or some of the devices.
/// </summary>
/// <param name="devices"> A subset or all of devices. If devices is <c>null</c>, the executable is built for every item of devices for which a source or a binary has been loaded. </param>
/// <param name="options"> A set of options for the OpenCL compiler. </param>
/// <param name="notify"> A delegate instance that represents a reference to a notification routine. This routine is a callback function that an application can register and which will be called when the program executable has been built (successfully or unsuccessfully). If <paramref name="notify"/> is not <c>null</c>, build does not need to wait for the build to complete and can return immediately. If <paramref name="notify"/> is <c>null</c>, build does not return until the build has completed. The callback function may be called asynchronously by the OpenCL implementation. It is the application's responsibility to ensure that the callback function is thread-safe and that the delegate instance doesn't get collected by the Garbage Collector until the build operation triggers the callback. </param>
/// <param name="notifyDataPtr"> Optional user data that will be passed to <paramref name="notify"/>. </param>
public void Build(ICollection <IComputeDevice> devices, string options,
ComputeProgramBuildNotifier notify, IntPtr notifyDataPtr)
{
var deviceHandles = ComputeTools.ExtractHandles(devices, out int handleCount);
var BuildOptions = options ?? "";
OpenCL110.BuildProgramWrapper(Handle, handleCount, deviceHandles, options, notify, notifyDataPtr);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Builds (compiles and links) a program executable from the program source or binary for all or
/// some of the <see cref="ComputeProgram.Devices"/>.
/// </summary>
///
/// <param name="devices"> A subset or all of <see cref="ComputeProgram.Devices"/>. If
/// <paramref name="devices"/> is <c>null</c>, the executable is
/// built for every item of <see cref="ComputeProgram.Devices"/> for
/// which a source or a binary has been loaded. </param>
/// <param name="options"> A set of options for the OpenCL compiler. </param>
/// <param name="notify"> A delegate instance that represents a reference to a
/// notification routine. This routine is a callback function that an
/// application can register and which will be called when the
/// program executable has been built (successfully or
/// unsuccessfully). If <paramref name="notify"/> is not <c>null</c>,
/// <see cref="ComputeProgram.Build"/> does not need to wait for the
/// build to complete and can return immediately. If
/// <paramref name="notify"/> is <c>null</c>,
/// <see cref="ComputeProgram.Build"/> does not return until the
/// build has completed. The callback function may be called
/// asynchronously by the OpenCL implementation. It is the
/// application's responsibility to ensure that the callback function
/// is thread-safe and that the delegate instance doesn't get
/// collected by the Garbage Collector until the build operation
/// triggers the callback. </param>
/// <param name="notifyDataPtr"> Optional user data that will be passed to
/// <paramref name="notify"/>. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
public void Build(ICollection <ComputeDevice> devices, string options, ComputeProgramBuildNotifier notify, IntPtr notifyDataPtr)
{
Ensure.Argument(devices).NotNull("devices is null");
CLDeviceHandle[] deviceHandles = ComputeTools.ExtractHandles(devices, out var handleCount);
buildOptions = options ?? "";
buildNotify = notify;
ComputeErrorCode error = CL12.BuildProgram(Handle, handleCount, deviceHandles, options, buildNotify, notifyDataPtr);
ComputeException.ThrowOnError(error);
}
/// <summary>
/// Builds (compiles and links) a program executable from the program source or binary for all or some of the <see cref="ComputeProgram.Devices"/>.
/// </summary>
/// <param name="devices"> A subset or all of <see cref="ComputeProgram.Devices"/>. If <paramref name="devices"/> is <c>null</c>, the executable is built for every item of <see cref="ComputeProgram.Devices"/> for which a source or a binary has been loaded. </param>
/// <param name="options"> A set of options for the OpenCL compiler. </param>
/// <param name="notify"> A delegate instance that represents a reference to a notification routine. This routine is a callback function that an application can register and which will be called when the program executable has been built (successfully or unsuccessfully). If <paramref name="notify"/> is not <c>null</c>, <see cref="ComputeProgram.Build"/> does not need to wait for the build to complete and can return immediately. If <paramref name="notify"/> is <c>null</c>, <see cref="ComputeProgram.Build"/> does not return until the build has completed. The callback function may be called asynchronously by the OpenCL implementation. It is the application's responsibility to ensure that the callback function is thread-safe and that the delegate instance doesn't get collected by the Garbage Collector until the build operation triggers the callback. </param>
/// <param name="notifyDataPtr"> Optional user data that will be passed to <paramref name="notify"/>. </param>
public void Build(ICollection <ComputeDevice> devices, string options, ComputeProgramBuildNotifier notify, IntPtr notifyDataPtr)
{
int handleCount;
CLDeviceHandle[] deviceHandles = ComputeTools.ExtractHandles(devices, out handleCount);
buildOptions = (options != null) ? options : "";
buildNotify = notify;
ComputeErrorCode error = CL10.BuildProgram(Handle, handleCount, deviceHandles, options, buildNotify, notifyDataPtr);
ComputeException.ThrowOnError(error);
}
/// <summary>
/// Builds (compiles and links) a program executable from the program source or binary for all or some of the devices.
/// </summary>
/// <param name="devices"> A subset or all of devices. If devices is <c>null</c>, the executable is built for every item of devices for which a source or a binary has been loaded. </param>
/// <param name="options"> A set of options for the OpenCL compiler. </param>
/// <param name="notify"> A delegate instance that represents a reference to a notification routine. This routine is a callback function that an application can register and which will be called when the program executable has been built (successfully or unsuccessfully). If <paramref name="notify"/> is not <c>null</c>, build does not need to wait for the build to complete and can return immediately. If <paramref name="notify"/> is <c>null</c>, build does not return until the build has completed. The callback function may be called asynchronously by the OpenCL implementation. It is the application's responsibility to ensure that the callback function is thread-safe and that the delegate instance doesn't get collected by the Garbage Collector until the build operation triggers the callback. </param>
/// <param name="notifyDataPtr"> Optional user data that will be passed to <paramref name="notify"/>. </param>
public void Build(ICollection <IComputeDevice> devices, string options,
ComputeProgramBuildNotifier notify, IntPtr notifyDataPtr)
{
var deviceHandles = ComputeTools.ExtractHandles(devices, out int handleCount);
var BuildOptions = options ?? "";
var error = OpenCL100.BuildProgram(
Handle,
handleCount,
deviceHandles,
options,
notify,
notifyDataPtr);
ComputeException.ThrowOnError(error);
}
public static extern ComputeErrorCode StaticCompileProgram(CLProgramHandle program, Int32 num_devices, [MarshalAs(UnmanagedType.LPArray)] CLDeviceHandle[] device_list, String options, Int32 num_input_headers, [MarshalAs(UnmanagedType.LPArray)] CLProgramHandle[] input_headers, String[] header_include_names, ComputeProgramBuildNotifier pfn_notify, IntPtr user_data);
public static extern ComputeErrorCode BuildProgram(
CLProgramHandle program,
Int32 num_devices,
[MarshalAs(UnmanagedType.LPArray)] CLDeviceHandle[] device_list,
String options,
ComputeProgramBuildNotifier pfn_notify,
IntPtr user_data);
/// <summary>
/// Builds (compiles and links) a program executable from the program source or binary for all or some of the <see cref="ComputeProgram.Devices"/>.
/// </summary>
/// <param name="devices"> A subset or all of <see cref="ComputeProgram.Devices"/>. If <paramref name="devices"/> is <c>null</c>, the executable is built for every item of <see cref="ComputeProgram.Devices"/> for which a source or a binary has been loaded. </param>
/// <param name="options"> A set of options for the OpenCL compiler. </param>
/// <param name="notify"> A delegate instance that represents a reference to a notification routine. This routine is a callback function that an application can register and which will be called when the program executable has been built (successfully or unsuccessfully). If <paramref name="notify"/> is not <c>null</c>, <see cref="ComputeProgram.Build"/> does not need to wait for the build to complete and can return immediately. If <paramref name="notify"/> is <c>null</c>, <see cref="ComputeProgram.Build"/> does not return until the build has completed. The callback function may be called asynchronously by the OpenCL implementation. It is the application's responsibility to ensure that the callback function is thread-safe and that the delegate instance doesn't get collected by the Garbage Collector until the build operation triggers the callback. </param>
/// <param name="notifyDataPtr"> Optional user data that will be passed to <paramref name="notify"/>. </param>
public void Build(ICollection<ComputeDevice> devices, string options, ComputeProgramBuildNotifier notify, IntPtr notifyDataPtr)
{
int handleCount;
CLDeviceHandle[] deviceHandles = ComputeTools.ExtractHandles(devices, out handleCount);
buildOptions = (options != null) ? options : "";
buildNotify = notify;
ComputeErrorCode error = CLInterface.CL10.BuildProgram(Handle, handleCount, deviceHandles, options, buildNotify, notifyDataPtr);
ComputeException.ThrowOnError(error);
}
/// <summary>
/// Builds (compiles and links) a program executable from the program source or binary for all or some of the <see cref="ComputeProgram.Devices"/>.
/// </summary>
/// <param name="devices"> A subset or all of <see cref="ComputeProgram.Devices"/>. If <paramref name="devices"/> is <c>null</c>, the executable is built for every item of <see cref="ComputeProgram.Devices"/> for which a source or a binary has been loaded. </param>
/// <param name="options"> A set of options for the OpenCL compiler. </param>
/// <param name="notify"> A delegate instance that represents a reference to a notification routine. This routine is a callback function that an application can register and which will be called when the program executable has been built (successfully or unsuccessfully). If <paramref name="notify"/> is not <c>null</c>, <see cref="ComputeProgram.Build"/> does not need to wait for the build to complete and can return immediately. If <paramref name="notify"/> is <c>null</c>, <see cref="ComputeProgram.Build"/> does not return until the build has completed. The callback function may be called asynchronously by the OpenCL implementation. It is the application's responsibility to ensure that the callback function is thread-safe and that the delegate instance doesn't get collected by the Garbage Collector until the build operation triggers the callback. </param>
/// <param name="notifyDataPtr"> Optional user data that will be passed to <paramref name="notify"/>. </param>
public void Build(ICollection<ComputeDevice> devices, string options, ComputeProgramBuildNotifier notify, IntPtr notifyDataPtr)
{
unsafe
{
IntPtr[] deviceHandles = Tools.ExtractHandles(devices);
buildOptions = (options != null) ? options : "";
buildNotify = notify;
fixed (IntPtr* deviceHandlesPtr = deviceHandles)
{
ComputeErrorCode error = CL10.BuildProgram(
Handle,
deviceHandles.Length,
deviceHandlesPtr,
options,
buildNotify,
notifyDataPtr);
ComputeException.ThrowOnError(error);
}
binaries = GetBinaries();
}
}
public ComputeErrorCode LinkProgram(CLContextHandle context, int num_devices, [MarshalAs(UnmanagedType.LPArray)] CLDeviceHandle[] device_list, string options, int num_input_programs, ComputeProgramBuildNotifier pfn_notify, IntPtr user_data, out ComputeErrorCode errcode_ret)
{
throw new NotImplementedException();
}
/// <summary>
/// Builds (compiles and links) a program executable from the program source or binary for all or some of the <c>ComputeProgram.Devices</c>.
/// </summary>
/// <param name="devices"> A subset or all of the <c>ComputeProgram.Devices</c>. If <paramref name="devices"/> is <c>null</c>, the executable is built for every item of the <c>ComputeProgram.Devices</c> for which a source or a binary has been loaded. </param>
/// <param name="options"> A set of options for the OpenCL compiler. </param>
/// <param name="notify"> A notification routine. The notification routine is a callback function that an application can register and which will be called when the program executable has been built (successfully or unsuccessfully). If <paramref name="notify"/> is not <c>null</c>, <c>ComputeProgram.Build</c> does not need to wait for the build to complete and can return immediately. If <paramref name="notify"/> is <c>null</c>, <c>ComputeProgram.Build</c> does not return until the build has completed. This callback function may be called asynchronously by the OpenCL implementation. It is the application's responsibility to ensure that the callback function is thread-safe. </param>
/// <param name="notifyDataPtr"> Optional user data that will be passed to <paramref name="notify"/>. </param>
public void Build(ICollection<ComputeDevice> devices, string options, ComputeProgramBuildNotifier notify, IntPtr notifyDataPtr)
{
unsafe
{
IntPtr[] deviceHandles = Tools.ExtractHandles(devices);
buildOptions = (options != null) ? options : "";
IntPtr notifyPtr = (notify != null) ? Marshal.GetFunctionPointerForDelegate(notify) : IntPtr.Zero;
fixed (IntPtr* deviceHandlesPtr = deviceHandles)
{
ComputeErrorCode error = CL10.BuildProgram(
Handle,
deviceHandles.Length,
deviceHandlesPtr,
options,
notifyPtr,
notifyDataPtr);
ComputeException.ThrowOnError(error);
}
binaries = GetBinaries();
}
}
public static void BuildProgramWrapper(CLProgramHandle program, int num_devices, CLDeviceHandle[] device_list, string options, ComputeProgramBuildNotifier pfn_notify, IntPtr user_data)
{
ComputeException.ThrowOnError(BuildProgram(program, num_devices, device_list, options, pfn_notify, user_data));
}
public ComputeErrorCode CompileProgram(CLProgramHandle program, int num_devices, [MarshalAs(UnmanagedType.LPArray)] CLDeviceHandle[] device_list, string options, int num_input_headers, [MarshalAs(UnmanagedType.LPArray)] CLProgramHandle[] input_headers, string[] header_include_names, ComputeProgramBuildNotifier pfn_notify, IntPtr user_data)
{
throw new NotImplementedException();
}
/// <summary>
/// Build program
/// </summary>
/// <param name="devices">list of devices to compile to</param>
/// <param name="options">compile options</param>
/// <param name="notify">build notifier</param>
/// <param name="notifyDataPtr">build notifier data pointer</param>
/// <param name="addToBinaryCache">put built binaries into cache to reuse already compiled programs later</param>
public void Build(IEnumerable<ClooDevice> devices, string options, ComputeProgramBuildNotifier notify,
IntPtr notifyDataPtr, bool addToBinaryCache = false)
{
List<ComputeDevice> listDevices = new List<ComputeDevice>();
int hashCode = 0;
if (addToBinaryCache)
{
// check if we already have binaries
hashCode = Source.GetArrayHashCode() ^ (options != null ? options.GetHashCode() : 0);
foreach (ClooDevice device in devices)
{
hashCode ^= device.GetHashCode();
listDevices.Add(device);
}
}
else
{
// build a list of ClooDevices only
foreach (ClooDevice device in devices)
listDevices.Add(device);
}
base.Build(devices.Cast<ComputeDevice>().ToList(), options, notify, notifyDataPtr);
if (addToBinaryCache)
_binariesCache[hashCode] = base.Binaries;
}
public new ComputeErrorCode LinkProgram(CLContextHandle context, Int32 num_devices, [MarshalAs(UnmanagedType.LPArray)] CLDeviceHandle[] device_list, String options, Int32 num_input_programs, ComputeProgramBuildNotifier pfn_notify, IntPtr user_data, out ComputeErrorCode errcode_ret)
{
return StaticLinkProgram(context, num_devices, device_list, options, num_input_programs, pfn_notify, user_data, out errcode_ret);
}
ComputeErrorCode ICL10.BuildProgram(CLProgramHandle program, int num_devices, CLDeviceHandle[] device_list, string options,
ComputeProgramBuildNotifier pfn_notify, IntPtr user_data)
{
return(BuildProgram(program, num_devices, device_list, options, pfn_notify, user_data));
}
ComputeErrorCode ICL10.BuildProgram(CLProgramHandle program, int num_devices, CLDeviceHandle[] device_list, string options,
ComputeProgramBuildNotifier pfn_notify, IntPtr user_data)
{
return BuildProgram(program, num_devices, device_list, options, pfn_notify, user_data);
}
public static extern int BuildProgram(IntPtr program, int num_devices, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] device_list, string options, ComputeProgramBuildNotifier pfn_notify, IntPtr user_data);
