public void Release() { ClHelper.ThrowNullException(Handle); int error = Cl.ReleaseContext(Handle); try { // try to get the ref count var test = ReferenceCount; } catch (OpenCLException) { // if the context is released ReferenceCount will throw var data = CallbackPointers[Handle]; data.Free(); CallbackPointers.Remove(Handle); } finally { Handle = IntPtr.Zero; } ClHelper.GetError(error); }
public static Kernel[] CreateKernelsInProgram(Program program) { if (program == Program.Null) { throw new ArgumentNullException("context"); } unsafe { uint num_kernels = 0; ClHelper.GetError(Cl.CreateKernelsInProgram(program.Handle, 0, null, &num_kernels)); IntPtr *kernel_ptrs = stackalloc IntPtr[(int)num_kernels]; ClHelper.GetError(Cl.CreateKernelsInProgram(program.Handle, num_kernels, kernel_ptrs, null)); Kernel[] kernels = new Kernel[(int)num_kernels]; for (int i = 0; i < kernels.Length; ++i) { kernels[i] = new Kernel(kernel_ptrs[i]); } return(kernels); } }
public static Program LinkProgram(Context context, Device[] devices, string options, Program[] programs, Action <Program, object> notify, object user_data) { if (context == Context.Null) { throw new ArgumentNullException("context"); } unsafe { var devices_length = devices == null ? 0 : devices.Length; var device_list = stackalloc IntPtr[devices_length]; for (int i = 0; i < devices_length; ++i) { device_list[i] = devices[i].Handle; } device_list = devices_length == 0 ? null : device_list; int length = options == null ? 0 : Encoding.ASCII.GetByteCount(options); byte *chars = stackalloc byte[length + 1]; if (options != null) { fixed(char *options_ptr = options) { Encoding.ASCII.GetBytes(options_ptr, options.Length, chars, length); } chars[length] = 0; //null terminator } else { chars = null; } var num_programs = programs == null ? 0 : programs.Length; IntPtr *input_programs = stackalloc IntPtr[num_programs]; for (int i = 0; i < num_programs; ++i) { input_programs[i] = programs[i].Handle; } var function_ptr = IntPtr.Zero; var data_ptr = new GCHandle(); if (notify != null) { var data = Tuple.Create(notify, user_data); data_ptr = GCHandle.Alloc(data); function_ptr = Marshal.GetFunctionPointerForDelegate(new CallbackDelegate(Callback)); } try { int errcode = 0; var program = Cl.LinkProgram(context.Handle, (uint)devices_length, device_list, chars, (uint)num_programs, input_programs, function_ptr, GCHandle.ToIntPtr(data_ptr).ToPointer(), &errcode); ClHelper.GetError(errcode); return(new Program(program)); } catch (Exception) { data_ptr.Free(); throw; } } }
public void CompileProgram(Device[] devices, string options, Tuple <Program, string>[] headers, Action <Program, object> notify, object user_data) { unsafe { var devices_length = devices == null ? 0 : devices.Length; var device_list = stackalloc IntPtr[devices_length]; for (int i = 0; i < devices_length; ++i) { device_list[i] = devices[i].Handle; } device_list = devices_length == 0 ? null : device_list; int length = options == null ? 0 : Encoding.ASCII.GetByteCount(options); byte *chars = stackalloc byte[length + 1]; if (options != null) { fixed(char *options_ptr = options) { Encoding.ASCII.GetBytes(options_ptr, options.Length, chars, length); } chars[length] = 0; //null terminator } else { chars = null; } var num_headers = headers == null ? 0 : headers.Length; IntPtr *input_headers = stackalloc IntPtr[num_headers]; byte ** header_include_names = stackalloc byte *[num_headers]; for (int i = 0; i < num_headers; ++i) { input_headers[i] = headers[i].Item1.Handle; var name = headers[i].Item2; var header_length = Encoding.ASCII.GetByteCount(name); byte *header_chars = (byte *)Marshal.AllocHGlobal(length + 1).ToPointer(); fixed(char *name_ptr = name) { Encoding.ASCII.GetBytes(name_ptr, name.Length, header_chars, header_length); } header_chars[header_length] = 0; //null terminator header_include_names[i] = header_chars; } if (headers == null) { input_headers = null; header_include_names = null; } var function_ptr = IntPtr.Zero; var data_ptr = new GCHandle(); if (notify != null) { var data = Tuple.Create(notify, user_data); data_ptr = GCHandle.Alloc(data); function_ptr = Marshal.GetFunctionPointerForDelegate(new CallbackDelegate(Callback)); } try { ClHelper.GetError(Cl.CompileProgram(Handle, (uint)devices_length, device_list, chars, (uint)num_headers, input_headers, header_include_names, function_ptr, GCHandle.ToIntPtr(data_ptr).ToPointer())); } catch (Exception) { data_ptr.Free(); throw; } finally { for (int i = 0; i < num_headers; ++i) { Marshal.FreeHGlobal(new IntPtr(header_include_names[i])); } } } }
public void RetainImage() { ClHelper.ThrowNullException(Handle); ClHelper.GetError(Cl.RetainMemObject(Handle)); }
public static Image CreateImage3D(Context context, MemoryFlags flags, ChannelOrder order, ChannelType type, ulong width, ulong height, ulong depth, ulong rowPitch, ulong slicePitch, IntPtr hostPtr) { 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 (width == 0) { throw new ArgumentOutOfRangeException("width", width, "width is 0."); } if (height == 0) { throw new ArgumentOutOfRangeException("height", height, "height is 0."); } if (depth == 0) { throw new ArgumentOutOfRangeException("depth", depth, "depth is 0."); } 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."); } if (rowPitch != 0) { throw new ArgumentOutOfRangeException("rowPitch", rowPitch, "rowPitch is not 0."); } if (slicePitch != 0) { throw new ArgumentOutOfRangeException("slicePitch", slicePitch, "slicePitch is not 0."); } } 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 (rowPitch != 0 && rowPitch < width) { throw new ArgumentOutOfRangeException("rowPitch", rowPitch, "rowPitch is not 0 and is less than width."); } if (slicePitch != 0 && slicePitch < height) { throw new ArgumentOutOfRangeException("slicePitch", slicePitch, "slicePitch is not 0 and is less than height."); } } unsafe { Cl.image_format image_format = new Cl.image_format() { image_channel_order = (uint)order, image_channel_data_type = (uint)type, }; int error; var handle = Cl.CreateImage3D( context.Handle, (ulong)flags, &image_format, new UIntPtr(width), new UIntPtr(height), new UIntPtr(depth), new UIntPtr(rowPitch), new UIntPtr(slicePitch), hostPtr.ToPointer(), &error); ClHelper.GetError(error); return(new Image(handle)); } }
public Image(Context context, MemoryFlags flags, ChannelOrder order, ChannelType type, ImageType imageType, ulong width, ulong height, ulong depth, ulong arraySize, ulong rowPitch, ulong slicePitch, 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 (width == 0) { throw new ArgumentOutOfRangeException("width", width, "width is 0."); } if (height == 0) { throw new ArgumentOutOfRangeException("height", height, "height is 0."); } if (depth == 0) { throw new ArgumentOutOfRangeException("depth", depth, "depth is 0."); } 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."); } if (rowPitch != 0) { throw new ArgumentOutOfRangeException("rowPitch", rowPitch, "rowPitch is not 0."); } if (slicePitch != 0) { throw new ArgumentOutOfRangeException("slicePitch", slicePitch, "slicePitch is not 0."); } } 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 (rowPitch != 0 && rowPitch < width) { throw new ArgumentOutOfRangeException("rowPitch", rowPitch, "rowPitch is not 0 and is less than width."); } if (slicePitch != 0 && slicePitch < height) { throw new ArgumentOutOfRangeException("slicePitch", slicePitch, "slicePitch is not 0 and is less than height."); } } unsafe { Cl.image_format image_format = new Cl.image_format() { image_channel_order = (uint)order, image_channel_data_type = (uint)type, }; Cl.image_desc image_desc = new Cl.image_desc() { image_type = (uint)imageType, image_width = new UIntPtr(width), image_height = new UIntPtr(height), image_depth = new UIntPtr(depth), image_array_size = new UIntPtr(arraySize), image_row_pitch = new UIntPtr(rowPitch), image_slice_pitch = new UIntPtr(slicePitch), num_mip_level = 0, num_samples = 0, buffer = IntPtr.Zero, }; int error; Handle = Cl.CreateImage( context.Handle, (ulong)flags, &image_format, &image_desc, hostPtr.ToPointer(), &error); ClHelper.GetError(error); } }
public Event EnqueueKernel(Kernel kernel, ulong[] global_work_offset, ulong[] global_work_size, ulong[] local_work_size, Event[] events) { ClHelper.ThrowNullException(Handle); if (kernel == Kernel.Null) { throw new ArgumentNullException("kernel"); } if (global_work_size == null) { throw new ArgumentNullException("global_work_size"); } if (global_work_offset != null && global_work_size.Length != global_work_offset.Length) { throw new ArgumentException("global_work_size and global_work_offset must be the same length."); } if (local_work_size != null && global_work_size.Length != local_work_size.Length) { throw new ArgumentException("global_work_size and local_work_size must be the same length."); } int work_dim = global_work_size.Length; unsafe { UIntPtr *global_offset = stackalloc UIntPtr[work_dim]; UIntPtr *global_size = stackalloc UIntPtr[work_dim]; UIntPtr *local_size = stackalloc UIntPtr[work_dim]; for (int i = 0; i < work_dim; ++i) { if (global_work_offset != null) { global_offset[i] = new UIntPtr(global_work_offset[i]); } global_size[i] = new UIntPtr(global_work_size[i]); if (local_work_size != null) { local_size[i] = new UIntPtr(local_work_size[i]); } } if (global_work_offset == null) { global_offset = null; } if (local_work_size == null) { local_size = null; } int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; ClHelper.GetError(Cl.EnqueueNDRangeKernel(Handle, kernel.Handle, (uint)work_dim, global_offset, global_size, local_size, (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public static void UnloadCompiler() { ClHelper.GetError(Cl.UnloadCompiler()); }
public void Retain() { ClHelper.ThrowNullException(Handle); ClHelper.GetError(Cl.RetainCommandQueue(Handle)); }
public Context(Dictionary <IntPtr, IntPtr> properties, Device[] devices, Action <string, byte[], object> notify, object user_data) : this() { if (devices == null) { throw new ArgumentNullException("devices"); } unsafe { IntPtr *device_ptrs = stackalloc IntPtr[devices.Length]; for (int i = 0; i < devices.Length; ++i) { device_ptrs[i] = devices[i].Handle; } int property_count = properties == null ? 0 : properties.Count; IntPtr *properties_ptr = stackalloc IntPtr[property_count * 2 + 1]; int index = 0; if (properties != null) { foreach (var pair in properties) { properties_ptr[index++] = pair.Key; properties_ptr[index++] = pair.Value; } properties_ptr[index] = IntPtr.Zero; } else { properties_ptr = null; } var function_ptr = IntPtr.Zero; var data_handle = new GCHandle(); var data_ptr = IntPtr.Zero; if (notify != null) { var data = Tuple.Create(notify, user_data); data_handle = GCHandle.Alloc(data); data_ptr = GCHandle.ToIntPtr(data_handle); function_ptr = Marshal.GetFunctionPointerForDelegate(new CallbackDelegete(Callback)); } try { int errcode = 0; Handle = Cl.CreateContext(properties_ptr, (uint)devices.Length, device_ptrs, function_ptr, data_ptr.ToPointer(), &errcode); ClHelper.GetError(errcode); CallbackPointers.Add(Handle, data_handle); } catch (Exception) { if (data_handle.IsAllocated) { data_handle.Free(); } throw; } } }
public void Retain() { ClHelper.ThrowNullException(Handle); ClHelper.GetError(Cl.RetainKernel(Handle)); }
public void UnloadPlatformCompiler() { ClHelper.ThrowNullException(Handle); ClHelper.GetError(Cl.UnloadPlatformCompiler(Handle)); }
public void RetainProgram() { ClHelper.ThrowNullException(Handle); ClHelper.GetError(Cl.RetainProgram(Handle)); }
public void Finish() { ClHelper.ThrowNullException(Handle); ClHelper.GetError(Cl.Finish(Handle)); }
public Program(Context context, Device[] devices, byte[][] binaries) : this() { if (context == Context.Null) { throw new ArgumentNullException("context"); } if (devices == null) { throw new ArgumentNullException("devices"); } if (binaries == null) { throw new ArgumentNullException("binaries"); } if (devices.Length == 0) { throw new ArgumentException("devices is empty.", "devices"); } if (devices.Length != binaries.Length) { throw new ArgumentException("binaries must be the same length as devices.", "binaries"); } unsafe { var device_list = stackalloc IntPtr[devices.Length]; for (int i = 0; i < devices.Length; ++i) { device_list[i] = devices[i].Handle; } var lengths_list = stackalloc UIntPtr[binaries.Length]; var binary_list = stackalloc byte *[binaries.Length]; var binary_status = stackalloc int[binaries.Length]; for (int i = 0; i < binaries.Length; ++i) { lengths_list[i] = new UIntPtr((uint)binaries[i].Length); var handle = GCHandle.Alloc(binaries[i], GCHandleType.Pinned); binary_list[i] = (byte *)GCHandle.ToIntPtr(handle).ToPointer(); } int errcode = 0; Handle = Cl.CreateProgramWithBinary(context.Handle, (uint)devices.Length, device_list, lengths_list, binary_list, binary_status, &errcode); for (int i = 0; i < binaries.Length; ++i) { var handel = GCHandle.FromIntPtr(new IntPtr(binary_list[i])); handel.Free(); } List <int> errors = new List <int>(binaries.Length); for (int i = 0; i < binaries.Length; ++i) { if (binary_status[i] != Cl.SUCCESS) { errors.Add(i); } } if (errors.Count != 0) { throw new OpenCLException(string.Format("{0} {1} failed.", errors.Count == 1 ? "Binary" : "Binaries", string.Join(", ", errors))); } ClHelper.GetError(errcode); } }
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); } }