public Horn_Schunck() { maxIteration = 10; alpha = 5; flowInterval = 3; w = 1; eps = (float)0.01; threshold = (float)0.5; pyramidLevel = 0; pyramidOn = 0; warps = 1; sources[0] = File_Handler.getKernelSourceFromLibrary("HornSchunck.cl"); Platform[] platforms = Cl.GetPlatformIDs(out error); Console.WriteLine("Error code: " + error.ToString()); devices = Cl.GetDeviceIDs(platforms[0], DeviceType.Gpu, out error); Console.WriteLine("Error code: " + error.ToString()); device = devices[0]; context = Cl.CreateContext(null, 1, devices, null, IntPtr.Zero, out error); Console.WriteLine("Error code: " + error.ToString()); program = Cl.CreateProgramWithSource(context, 1, sources, null, out error); Console.WriteLine("Error code: " + error.ToString()); Cl.BuildProgram(program, 1, devices, string.Empty, null, IntPtr.Zero); commandQueue = Cl.CreateCommandQueue(context, device, CommandQueueProperties.None, out error); Console.WriteLine("Error code: " + error.ToString()); }
public void GetContextByCl() { IntPtr context = Cl.CreateContext(null, 1, new Device[] { _device }, null, IntPtr.Zero, out ErrorCode _); Assert.IsTrue(context != IntPtr.Zero); Cl.ReleaseContext(context); }
public L1Flow() { tau = (float)0.25; lambda = (float)0.15; theta = (float)0.3; epsilon = (float)0.01; maxiter = 1; warps = 1; pyramidLevel = 2; threshold = (float)0.5; flowInterval = 2; sources[0] = File_Handler.getKernelSourceFromLibrary("TvL1gradrho.cl"); sources[1] = File_Handler.getKernelSourceFromLibrary("TvL1_divP_Flow.cl"); sources[2] = File_Handler.getKernelSourceFromLibrary("TvL1_calcP.cl"); Platform[] platforms = Cl.GetPlatformIDs(out error); Console.WriteLine("Error code: " + error.ToString()); devices = Cl.GetDeviceIDs(platforms[0], DeviceType.Gpu, out error); Console.WriteLine("Error code: " + error.ToString()); device = devices[0]; context = Cl.CreateContext(null, 1, devices, null, IntPtr.Zero, out error); Console.WriteLine("Error code: " + error.ToString()); program = Cl.CreateProgramWithSource(context, 3, sources, null, out error); Console.WriteLine("Error code: " + error.ToString()); Cl.BuildProgram(program, 1, devices, string.Empty, null, IntPtr.Zero); commandQueue = Cl.CreateCommandQueue(context, device, CommandQueueProperties.None, out error); Console.WriteLine("Error code: " + error.ToString()); }
private void init() { ErrorCode error; // Get platform info Platform[] platforms = Cl.GetPlatformIDs(out error); List <Device> devicesList = new List <Device>(); LogError(error, "Cl.GetPlaformIDs"); DeviceType deviceType = DeviceType.Default; switch (_parameters["DeviceType"]) { case "Gpu": deviceType = DeviceType.Gpu; break; case "Cpu": deviceType = DeviceType.Cpu; break; case "All": deviceType = DeviceType.All; break; case "Accelerator": deviceType = DeviceType.Accelerator; break; } // Get available devices foreach (Platform platform in platforms) { string platformName = Cl.GetPlatformInfo(platform, PlatformInfo.Name, out error).ToString(); Console.WriteLine("Platform: " + platformName); LogError(error, "Cl.GetPlatformInfo"); foreach (Device device in Cl.GetDeviceIDs(platform, deviceType, out error)) { LogError(error, "Cl.GetDeviceIDs"); Console.WriteLine("Device:" + device.ToString()); devicesList.Add(device); } } if (devicesList.Count <= 0) { Console.WriteLine("No devices found."); return; } _device = devicesList[0]; if (Cl.GetDeviceInfo(_device, DeviceInfo.ImageSupport, out error).CastTo <OpenCL.Net.Bool>() == OpenCL.Net.Bool.False) { Console.WriteLine("No image support."); return; } _context = Cl.CreateContext(null, 1, new[] { _device }, ContextNotify, IntPtr.Zero, out error); LogError(error, "Cl.CreateContext"); }
/// <summary> /// Initializes handle /// </summary> /// <returns> whether or not the handle was intialized succesfully </returns> public void Init() { Platform[] platforms = Cl.GetPlatformIDs(out _error); CLException.CheckException(_error); Console.WriteLine("Found " + platforms.Length + " platform(s)"); InfoBuffer platformNameBuffer = Cl.GetPlatformInfo(platforms[0], PlatformInfo.Name, out _error); CLException.CheckException(_error); Console.WriteLine(platformNameBuffer.ToString()); Device[] devices = Cl.GetDeviceIDs(platforms[0], DeviceType.Gpu, out _error); CLException.CheckException(_error); _device = devices[0]; InfoBuffer deviceNameBuffer = Cl.GetDeviceInfo(Device, DeviceInfo.Platform, out _error); CLException.CheckException(_error); Console.WriteLine(deviceNameBuffer.ToString()); _context = Cl.CreateContext(null, 1, new[] { devices[0] }, null, IntPtr.Zero, out _error); CLException.CheckException(_error); _queue = Cl.CreateCommandQueue(Context, Device, CommandQueueProperties.None, out _error); CLException.CheckException(_error); }
public LGFlow() { alpha = (float)15; mode = 1; w = (float)1.9; kernelSize = 3; sigma = 0; pyramidLevel = 5; iteration = 1; flowInterval = 2; threshold = (float)0.5; sources[0] = File_Handler.getKernelSourceFromLibrary("PushImgFlow.cl"); sources[1] = File_Handler.getKernelSourceFromLibrary("LocalGlobalFlow1.cl"); sources[2] = File_Handler.getKernelSourceFromLibrary("LocalGlobalFlow2.cl"); sources[3] = File_Handler.getKernelSourceFromLibrary("LocalGlobalFlow_J.cl"); sources[4] = File_Handler.getKernelSourceFromLibrary("LocalGlobalFlow3.cl"); Platform[] platforms = Cl.GetPlatformIDs(out error); Console.WriteLine("Error code: " + error.ToString()); devices = Cl.GetDeviceIDs(platforms[0], DeviceType.Gpu, out error); Console.WriteLine("Error code: " + error.ToString()); device = devices[0]; context = Cl.CreateContext(null, 1, devices, null, IntPtr.Zero, out error); Console.WriteLine("Error code: " + error.ToString()); program = Cl.CreateProgramWithSource(context, 5, sources, null, out error); Console.WriteLine("Error code: " + error.ToString()); Cl.BuildProgram(program, 1, devices, string.Empty, null, IntPtr.Zero); commandQueue = Cl.CreateCommandQueue(context, device, CommandQueueProperties.None, out error); Console.WriteLine("Error code: " + error.ToString()); }
public void Run() { ErrorCode e = ErrorCode.Unknown; uint num = 0; err = Cl.GetPlatformIDs(1, platforms, out num); InfoBuffer platformbuf = Cl.GetPlatformInfo(platforms[0], PlatformInfo.Name, out e); device = Cl.GetDeviceIDs(platforms[0], DeviceType.Gpu, out e); InfoBuffer devicebuf = Cl.GetDeviceInfo(device[0], DeviceInfo.Name, out e); IntPtr ptr = new IntPtr(); IntPtr ptr2 = new IntPtr(); context = Cl.CreateContext(null, 1, new[] { device[0] }, null, ptr, out e); InfoBuffer contextbuff = new InfoBuffer(); e = Cl.GetContextInfo(context, ContextInfo.Devices, ptr, contextbuff, out ptr2); Program pg = Cl.CreateProgramWithSource(context, 1, new[] { correctSource }, null, out e); e = Cl.BuildProgram(pg, 1, new[] { device[0] }, string.Empty, null, IntPtr.Zero); InfoBuffer pgbuild = Cl.GetProgramBuildInfo(pg, device[0], ProgramBuildInfo.Log, out e); // Cl.BuildProgram(pg,1,device,"-cl-std=CL") }
public void SetUp() { device = (from platformid in Cl.GetPlatformIDs(out error) from deviceid in Cl.GetDeviceIDs(platformid, Cl.DeviceType.Gpu, out error) select deviceid).First(); context = Cl.CreateContext(null, 1, new[] { device }, null, IntPtr.Zero, out error); }
public static void Main(string[] args) { int dimX = GetParameter("--dimX", 322, args); int dimY = GetParameter("--dimY", 242, args); int N = GetParameter("--N", 97760, args); bool lmem = GetFlag("--lmem", args); Console.WriteLine("Poisson equation solver: dimX = {0} dimY = {1} N = {2}, LMem: {3}", dimX, dimY, N, lmem); string options = string.Join(" ", args.Where(arg => arg.IndexOf("--") == -1)); Console.WriteLine("OpenCL program build options: " + options); Cl.ErrorCode error; Cl.Device device = (from platformid in Cl.GetPlatformIDs(out error) from deviceid in Cl.GetDeviceIDs(platformid, Cl.DeviceType.Gpu, out error) select deviceid).First(); clSafeCall(error); Cl.Context context = Cl.CreateContext(null, 1, new[] { device }, null, IntPtr.Zero, out error); clSafeCall(error); // create program from C# kernel IRBuildOptions.AutoInline = GetFlag("--inline", args); IRBuildOptions.WasteRegisters = GetFlag("--rwaste", args); Console.WriteLine("IR code build options: AutoInline: {0}; WasteRegisters: {1}", IRBuildOptions.AutoInline, IRBuildOptions.WasteRegisters); Cl.Program pcsharp = typeof(MainClass).BuildIR().ToGPUClProgram(device, context); // create program from OpenCL kernel Cl.Program popencl = Cl.CreateProgramWithSource(context, 1, new[] { PoissonRBSORCl }, null, out error); clSafeCall(error); // perform bandwidth comparison float x0 = (float)(-0.5 * Math.PI); float y0 = (float)(-0.5 * Math.PI); float x1 = -x0; float y1 = -y0; float omega = 0.8f; Console.WriteLine("C# benchmark:"); long tcsharp = PoissonRBSOR(device, context, pcsharp, lmem, x0, y0, x1, y1, dimX, dimY, N, omega, "unigpu.bin", options); pcsharp.Dispose(); Console.WriteLine("OpenCL benchmark:"); long topencl = PoissonRBSOR(device, context, popencl, lmem, x0, y0, x1, y1, dimX, dimY, N, omega, "opencl.bin", options); popencl.Dispose(); Console.WriteLine("OpenCL advantage: {0}", (double)tcsharp / (double)topencl); context.Dispose(); }
public static void initOpenCL() { var platforms = Cl.GetPlatformIDs(out error); List <Device> devicesList = new List <Device>(); CheckErr(error, "Cl.GetPlatformIDs"); foreach (Platform platform in platforms) { string platformName = Cl.GetPlatformInfo(platform, PlatformInfo.Name, out error).ToString(); Console.WriteLine("Platform: " + platformName); CheckErr(error, "Cl.GetPlatformInfo"); //We will be looking only for GPU devices foreach (Device device in Cl.GetDeviceIDs(platform, DeviceType.Gpu, out error)) { CheckErr(error, "Cl.GetDeviceIDs"); var vendor = Cl.GetDeviceInfo(device, DeviceInfo.Vendor, out error); var name = Cl.GetDeviceInfo(device, DeviceInfo.Name, out error); var worksize = Cl.GetDeviceInfo(device, DeviceInfo.MaxWorkGroupSize, out error); var maxCU = Cl.GetDeviceInfo(device, DeviceInfo.MaxComputeUnits, out error); Console.WriteLine("Vendor: " + vendor + " , " + name); Console.WriteLine("Device: " + device.GetType()); Console.WriteLine("Workgroupsize: " + worksize.CastTo <long>()); Console.WriteLine("CUS: " + maxCU.CastTo <int>()); devicesList.Add(device); } } if (devicesList.Count <= 0) { Console.WriteLine("No devices found."); return; } _device = devicesList[0]; if (Cl.GetDeviceInfo (_device, DeviceInfo.ImageSupport, out error).CastTo <Bool>() == Bool.False) { Console.WriteLine("No image support."); return; } cxGPUContext = Cl.CreateContext(null, 1, new[] { _device }, ContextNotify, IntPtr.Zero, out error); //Second parameter is amount of devices CheckErr(error, "Cl.CreateContext"); cqCommandQueue = Cl.CreateCommandQueue(cxGPUContext, _device, (CommandQueueProperties)0, out error); CheckErr(error, "Cl.CreateCommandQueue"); sort = new GPURadixSort(cqCommandQueue, cxGPUContext, _device); }
private void SetupDevice() { Event e; ErrorCode error; Platform[] platforms = Cl.GetPlatformIDs(out error); Device[] devices = Cl.GetDeviceIDs(platforms[0], DeviceType.Gpu, out error); device = devices[0]; context = Cl.CreateContext(null, 1, devices, null, IntPtr.Zero, out error); queue = Cl.CreateCommandQueue(context, device, CommandQueueProperties.None, out error); }
/// <summary> /// Laden der GPU und Eigenschaften /// </summary> static EasyClCompiler() { _hasDevice = false; Platform[] platforms = Cl.GetPlatformIDs(out ErrorCode error); if (error != ErrorCode.Success) { throw new GPUException("Paltform", error.ToString()); } List <Device> devices = new List <Device>(); if (platforms.Length > 0) { foreach (Platform platform in platforms) { foreach (Device device in Cl.GetDeviceIDs(platform, DeviceType.Gpu, out error)) { if (error != ErrorCode.Success) { throw new GPUException("Device", error.ToString()); } devices.Add(device); } } } if (devices.Count > 0) { foreach (Device device in devices) { if (Cl.GetDeviceInfo(device, DeviceInfo.ImageSupport, out error).CastTo <bool>()) { Context context = Cl.CreateContext(null, 1, new[] { device }, null, IntPtr.Zero, out error); if (error != ErrorCode.Success) { throw new GPUException("Init", error.ToString()); } _device = device; _context = context; _commandQueue = Cl.CreateCommandQueue(_context, _device, CommandQueueProperties.None, out _); _hasDevice = true; } } } #region Init Basic _memFlags = MemFlags.CopyHostPtr; _imageFormat = new ImageFormat(ChannelOrder.BGRA, ChannelType.Unsigned_Int8); _originPtr = new[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; #endregion Init Basic }
/** * Create for a given platform and device. */ public ExecutionContext(Platform platform, Device device) { Platform = platform; Device = device; OpenClContext = Cl.CreateContext(null, 1, new[] { Device }, null, IntPtr.Zero, out var error); if (error != ErrorCode.Success) { throw new NerotiqException($"Unable to create opencl context: {error}"); } }
public APITests() { ErrorCode error; _device = (from device in Cl.GetDeviceIDs( (from platform in Cl.GetPlatformIDs(out error) where Cl.GetPlatformInfo(platform, PlatformInfo.Name, out error).ToString() == "AMD Accelerated Parallel Processing" // Use "NVIDIA CUDA" if you don't have amd select platform).First(), DeviceType.Gpu, out error) select device).First(); _context = Cl.CreateContext(null, 1, new[] { _device }, null, IntPtr.Zero, out error); }
public void Setup() { ErrorCode error; _device = (from device in Cl.GetDeviceIDs( (from platform in Cl.GetPlatformIDs(out error) where Cl.GetPlatformInfo(platform, PlatformInfo.Name, out error).ToString() == "NVIDIA CUDA" select platform).First(), DeviceType.Gpu, out error) select device).First(); _context = Cl.CreateContext(null, 1, new[] { _device }, null, IntPtr.Zero, out error); }
public void ContextCreation() { ErrorCode error; // Select the device we want var device = (from dev in Cl.GetDeviceIDs( (from platform in Cl.GetPlatformIDs(out error) select platform).First(), DeviceType.Gpu, out error) select dev).First(); uint refCount; using (Context context = Cl.CreateContext(null, 1, new[] { device }, null, IntPtr.Zero, out error)) refCount = Cl.GetContextInfo(context, ContextInfo.ReferenceCount, out error).CastTo <uint>(); }
public void Setup() { ErrorCode error; Platform[] platforms = Cl.GetPlatformIDs(out error); List <Device> devicesList = new List <Device>(); CheckErr(error, "Cl.GetPlatformIDs"); foreach (Platform platform in platforms) { //ToDO:Log Platform Device Name; // status = clGetPlatformInfo(platform, CL_PLATFORM_NAME, sizeof(pbuff), pbuff, NULL); // status = clGetPlatformInfo(platform, CL_PLATFORM_VERSION, sizeof(pbuff), pbuff, NULL); // status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &numDevices); //ToDO: Saved the compiled version so it can be built the next time as a binary: //ToDO: Enable certain cards, fan control, scheduling string platformName = Cl.GetPlatformInfo(platform, PlatformInfo.Name, out error).ToString(); Console.WriteLine("Platform: " + platformName); CheckErr(error, "Cl.GetPlatformInfo"); //We will be looking only for GPU devices foreach (OpenCL.Net.Device device in Cl.GetDeviceIDs(platform, DeviceType.Gpu, out error)) { CheckErr(error, "Cl.GetDeviceIDs"); Console.WriteLine("Device: " + device.ToString()); devicesList.Add(device); } } if (devicesList.Count <= 0) { Console.WriteLine("No devices found."); return; } _device = devicesList[0]; if (Cl.GetDeviceInfo(_device, OpenCL.Net.DeviceInfo.ImageSupport, out error).CastTo <OpenCL.Net.Bool>() == OpenCL.Net.Bool.False) { Console.WriteLine("No image support."); return; } _context = Cl.CreateContext(null, 1, new[] { _device }, ContextNotify, IntPtr.Zero, out error); //Second parameter is amount of devices CheckErr(error, "Cl.CreateContext"); }
public void GetContextByClWithPlattform() { throw new NotSupportedException(""); IntPtr context = Cl.CreateContext( new ContextProperty[] { new ContextProperty(ContextProperties.Platform, _platforms.First().Handle) }, 1, new Device[] { _device }, null, IntPtr.Zero, out ErrorCode _ ); Assert.IsTrue(context != IntPtr.Zero); Cl.ReleaseContext(context); }
public static bool Init() { if (initialized) { return(true); } initialized = true; ErrorCode error; Platform[] platforms = Cl.GetPlatformIDs(out error); ErrorCheck(error, "Cl.GetPlatformIDs"); List <Device> devicesList = new List <Device>(); foreach (Platform platform in platforms) { string platformName = Cl.GetPlatformInfo(platform, PlatformInfo.Name, out error).ToString(); ErrorCheck(error, "Cl.GetPlatformInfo"); foreach (Device device in Cl.GetDeviceIDs(platform, DeviceType.Gpu, out error)) { devicesList.Add(device); } } if (devicesList.Count == 0) { return(false); } device = devicesList[0]; //Second parameter is amount of devices context = Cl.CreateContext(null, 1, new[] { device }, ContextNotify, IntPtr.Zero, out error); ErrorCheck(error, "Cl.CreateContext"); string crackHigh = Path.Combine(System.Environment.CurrentDirectory, "CrackHigh.cl"); LoadKernel(crackHigh, "CrackHigh", out crackHighProgram, out crackHighKernel); return(true); }
public static void Setup() { ErrorCode err; Platform[] platforms = Cl.GetPlatformIDs(out err); List <Device> CLDevices = new List <Device>(); CheckErr(err, "Cl.GetPlatformIDs"); foreach (Platform p in platforms) { string platformName = Cl.GetPlatformInfo(p, PlatformInfo.Name, out err).ToString(); Console.WriteLine($"Platform: {platformName}"); CheckErr(err, "Cl.GetPlatformInfo"); //Limit platforms to GPU-based platforms foreach (Device d in Cl.GetDeviceIDs(p, DeviceType.Gpu, out err)) { CheckErr(err, "Cl.GetDeviceIDs"); Console.WriteLine("Device: " + d.ToString()); CLDevices.Add(d); } } if (CLDevices.Count <= 0) { Console.Error.WriteLine("No suitable OpenCL devices found."); return; } _device = CLDevices[0]; if (Cl.GetDeviceInfo(_device, DeviceInfo.ImageSupport, out err).CastTo <Bool>() == Bool.False) { Console.Error.WriteLine($"Selected CL device {_device.ToString()} does not have image support."); return; } _context = Cl.CreateContext(null, 1, new Device[] { _device }, ContextNotify, IntPtr.Zero, out err); CheckErr(err, "Cl.CreateContext"); }
public OpenCLHelp() { ErrorCode error; Platform[] platforms = Cl.GetPlatformIDs(out error); List <Device> devicesList = new List <Device>(); CheckErr(error, "Cl.GetPlatformIDs"); foreach (Platform platform in platforms) { string platformName = Cl.GetPlatformInfo(platform, PlatformInfo.Name, out error).ToString(); Console.WriteLine("Platform: " + platformName); CheckErr(error, "Cl.GetPlatformInfo"); //We will be looking only for GPU devices foreach (Device device in Cl.GetDeviceIDs(platform, DeviceType.Gpu, out error)) { CheckErr(error, "Cl.GetDeviceIDs"); Console.WriteLine("Device: " + device.ToString()); devicesList.Add(device); } } if (devicesList.Count <= 0) { Console.WriteLine("No devices found."); return; } _device = devicesList[0]; if (Cl.GetDeviceInfo(_device, DeviceInfo.ImageSupport, out error).CastTo <Bool>() == Bool.False) { Console.WriteLine("No image support."); return; } _context = Cl.CreateContext(null, 1, new[] { _device }, ContextNotify, IntPtr.Zero, out error); //Second parameter is amount of devices CheckErr(error, "Cl.CreateContext"); }
public ComputeProvider(params Device[] devices) { if (devices == null) { throw new ArgumentNullException("devices"); } if (devices.Length == 0) { throw new ArgumentException("Need at least one device!"); } _devices = devices; ErrorCode error; _context = Cl.CreateContext(null, (uint)devices.Length, _devices, null, IntPtr.Zero, out error); if (error != ErrorCode.Success) { throw new Cl.Exception(error); } }
private void ready() { ErrorCode error; context = Cl.CreateContext(null, 1, new[] { device }, null, IntPtr.Zero, out error); string source = System.IO.File.ReadAllText("kernels.cl"); program = Cl.CreateProgramWithSource(context, 1, new[] { source }, null, out error); error = Cl.BuildProgram(program, 1, new[] { device }, string.Empty, null, IntPtr.Zero); InfoBuffer buildStatus = Cl.GetProgramBuildInfo(program, device, ProgramBuildInfo.Status, out error); if (buildStatus.CastTo <BuildStatus>() != BuildStatus.Success) { throw new Exception($"OpenCL could not build the kernel successfully: {buildStatus.CastTo<BuildStatus>()}"); } allGood(error); Kernel[] kernels = Cl.CreateKernelsInProgram(program, out error); kernel = kernels[0]; allGood(error); queue = Cl.CreateCommandQueue(context, device, CommandQueueProperties.None, out error); allGood(error); dataOut = Cl.CreateBuffer(context, MemFlags.WriteOnly, (IntPtr)(globalSize * sizeof(int)), out error); allGood(error); var intSizePtr = new IntPtr(Marshal.SizeOf(typeof(int))); error |= Cl.SetKernelArg(kernel, 2, new IntPtr(Marshal.SizeOf(typeof(IntPtr))), dataOut); error |= Cl.SetKernelArg(kernel, 3, intSizePtr, new IntPtr(worldSeed)); error |= Cl.SetKernelArg(kernel, 4, intSizePtr, new IntPtr(globalSize)); allGood(error); }
static void Main(string[] args) { Console.WriteLine("Hello World!"); uint platformCount; ErrorCode result = Cl.GetPlatformIDs(0, null, out platformCount); Console.WriteLine("{0} platforms found", platformCount); var platformIds = new Platform[platformCount]; result = Cl.GetPlatformIDs(platformCount, platformIds, out platformCount); var platformCounter = 0; foreach (var platformId in platformIds) { IntPtr paramSize; result = Cl.GetPlatformInfo(platformId, PlatformInfo.Name, IntPtr.Zero, InfoBuffer.Empty, out paramSize); using (var buffer = new InfoBuffer(paramSize)) { result = Cl.GetPlatformInfo(platformIds[0], PlatformInfo.Name, paramSize, buffer, out paramSize); Console.WriteLine($"Platform {platformCounter}: {buffer}"); } platformCounter++; } Console.WriteLine($"Using first platform..."); uint deviceCount; result = Cl.GetDeviceIDs(platformIds[0], DeviceType.All, 0, null, out deviceCount); Console.WriteLine("{0} devices found", deviceCount); var deviceIds = new Device[deviceCount]; result = Cl.GetDeviceIDs(platformIds[0], DeviceType.All, deviceCount, deviceIds, out var numberDevices); var selectedDevice = deviceIds[0]; var context = Cl.CreateContext(null, 1, new[] { selectedDevice }, null, IntPtr.Zero, out var error); const string kernelSrc = @" // Simple test; c[i] = a[i] + b[i] __kernel void add_array(__global float *a, __global float *b, __global float *c) { int xid = get_global_id(0); c[xid] = a[xid] + b[xid] - 1500; } __kernel void sub_array(__global float *a, __global float *b, __global float *c) { int xid = get_global_id(0); c[xid] = a[xid] - b[xid] - 2000; } __kernel void double_everything(__global float *a) { int xid = get_global_id(0); a[xid] = a[xid] * 2; } "; var src = kernelSrc; Console.WriteLine("=== src ==="); Console.WriteLine(src); Console.WriteLine("============"); var program = Cl.CreateProgramWithSource(context, 1, new[] { src }, null, out var error2); error2 = Cl.BuildProgram(program, 1, new[] { selectedDevice }, string.Empty, null, IntPtr.Zero); if (error2 == ErrorCode.BuildProgramFailure) { Console.Error.WriteLine(Cl.GetProgramBuildInfo(program, selectedDevice, ProgramBuildInfo.Log, out error)); } Console.WriteLine(error2); // Get the kernels. var kernels = Cl.CreateKernelsInProgram(program, out error); Console.WriteLine($"Program contains {kernels.Length} kernels."); var kernelAdd = kernels[0]; var kernelDouble = kernels[2]; // float[] A = new float[1000]; float[] B = new float[1000]; float[] C = new float[1000]; for (var i = 0; i < 1000; i++) { A[i] = i; B[i] = i; } IMem <float> hDeviceMemA = Cl.CreateBuffer(context, MemFlags.CopyHostPtr | MemFlags.ReadOnly, A, out error); IMem <float> hDeviceMemB = Cl.CreateBuffer(context, MemFlags.CopyHostPtr | MemFlags.ReadOnly, B, out error); IMem <float> hDeviceMemC = Cl.CreateBuffer(context, MemFlags.CopyHostPtr | MemFlags.ReadOnly, C, out error); // Create a command queue. var cmdQueue = Cl.CreateCommandQueue(context, selectedDevice, CommandQueueProperties.None, out error); int intPtrSize = 0; intPtrSize = Marshal.SizeOf(typeof(IntPtr)); error = Cl.SetKernelArg(kernelDouble, 0, new IntPtr(intPtrSize), hDeviceMemA); error = Cl.SetKernelArg(kernelAdd, 0, new IntPtr(intPtrSize), hDeviceMemA); error = Cl.SetKernelArg(kernelAdd, 1, new IntPtr(intPtrSize), hDeviceMemB); error = Cl.SetKernelArg(kernelAdd, 2, new IntPtr(intPtrSize), hDeviceMemC); // write data from host to device Event clevent; error = Cl.EnqueueWriteBuffer(cmdQueue, hDeviceMemA, Bool.True, IntPtr.Zero, new IntPtr(1000 * sizeof(float)), A, 0, null, out clevent); error = Cl.EnqueueWriteBuffer(cmdQueue, hDeviceMemB, Bool.True, IntPtr.Zero, new IntPtr(1000 * sizeof(float)), B, 1, new [] { clevent }, out clevent); // execute kernel error = Cl.EnqueueNDRangeKernel(cmdQueue, kernelDouble, 1, null, new IntPtr[] { new IntPtr(1000) }, null, 1, new [] { clevent }, out clevent); var infoBuffer = Cl.GetEventInfo(clevent, EventInfo.CommandExecutionStatus, out var e2); error = Cl.EnqueueNDRangeKernel(cmdQueue, kernelAdd, 1, null, new IntPtr[] { new IntPtr(1000) }, null, 1, new [] { clevent }, out clevent); Console.WriteLine($"Run result: {error}"); error = Cl.EnqueueReadBuffer(cmdQueue, hDeviceMemC, Bool.False, 0, C.Length, C, 1, new [] { clevent }, out clevent); Cl.WaitForEvents(1, new [] { clevent }); for (var i = 0; i < 1000; i++) { Console.WriteLine($"[{i}]: {C[i]}"); } program.Dispose(); foreach (var res in typeof(SourceLoader).Assembly.GetManifestResourceNames()) { Console.WriteLine(res); } }
public static Context CreateContext(Device device, out ErrorCode error) { return(Cl.CreateContext(null, 1, new Device[] { device }, null, IntPtr.Zero, out error)); }
public static void Initialize() { Platform[] platforms = Cl.GetPlatformIDs(out ErrorCode error); if (error != ErrorCode.Success) { Log.Print("Impossible to run OpenCL, no any graphic platform available, abording launch."); Application.Exit(); } Vector2I res = Graphics.RenderResolution; int pixelXAmount = res.x; int pixelYAmount = res.y; int amountOfObjects = 1; unsafe { inputSize = sizeof(C_CAMERA); outputSize = sizeof(byte) * pixelXAmount * pixelYAmount * 4; } UsedDevice = Cl.GetDeviceIDs(platforms[0], DeviceType.All, out error)[0]; gpu_context = Cl.CreateContext(null, 1, new Device[] { UsedDevice }, null, IntPtr.Zero, out error); InfoBuffer namebuffer = Cl.GetDeviceInfo(UsedDevice, DeviceInfo.Name, out error); Log.Print("OpenCL Running on " + namebuffer); Queue = Cl.CreateCommandQueue(gpu_context, UsedDevice, CommandQueueProperties.OutOfOrderExecModeEnable, out error); if (error != ErrorCode.Success) { Console.WriteLine("Impossible to create gpu queue, abording launch."); Application.Exit(); } CLoader.LoadProjectPaths(@".\libs", new[] { "c" }, out string[] cfiles, out string[] hfiles); Program program = CLoader.LoadProgram(cfiles, hfiles, UsedDevice, gpu_context); //Program prog = CLoader.LoadProgram(CLoader.GetCFilesDir(@".\", new[] { "cl" }).ToArray(), new[] { "headers" }, UsedDevice, gpu_context); kernel = Cl.CreateKernel(program, "rm_render_entry", out error); if (error != ErrorCode.Success) { Log.Print("Error when creating kernel: " + error.ToString()); } memory = new IntPtr(outputSize); memInput = (Mem)Cl.CreateBuffer(gpu_context, MemFlags.ReadOnly, inputSize, out error); memTime = (Mem)(Cl.CreateBuffer(gpu_context, MemFlags.ReadOnly, timeSize, out error)); memOutput = (Mem)Cl.CreateBuffer(gpu_context, MemFlags.WriteOnly, outputSize, out error); //GPU_PARAM param = new GPU_PARAM() { X_RESOLUTION = res.x, Y_RESOLUTION = res.y }; ////Vector3D pos = camera.Malleable.Position; //Quaternion q = camera.Malleable.Rotation; IntPtr notused; InfoBuffer local = new InfoBuffer(new IntPtr(4)); error = Cl.GetKernelWorkGroupInfo(kernel, UsedDevice, KernelWorkGroupInfo.WorkGroupSize, new IntPtr(sizeof(int)), local, out notused); if (error != ErrorCode.Success) { Log.Print("Error getting kernel workgroup info: " + error.ToString()); } //int intPtrSize = 0; intPtrSize = Marshal.SizeOf(typeof(IntPtr)); Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, memInput); Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, memTime); Cl.SetKernelArg(kernel, 4, (IntPtr)intPtrSize, memOutput); //Cl.SetKernelArg(kernel, 2, new IntPtr(4), pixelAmount * 4); workGroupSizePtr = new IntPtr[] { new IntPtr(pixelXAmount * pixelYAmount) }; }
public static void SetupSpace(int deviceID) { //int deviceID; // will be asked to user List <Device> devicesList = new List <Device>(); List <string> deviceNames = new List <string>(); List <string> platformNames = new List <string>(); int nDevices = 0; // Get list of available platforms Console.WriteLine("\nSearching for OpenCL-capable platforms... "); Platform[] platforms = Cl.GetPlatformIDs(out ClError); CheckErr(ClError, "CL.Setup: Cl.GetPlatformIDs"); Console.WriteLine("{0} platforms found.\n", platforms.Length); foreach (Platform platform in platforms) { // Get platform info string platformName = Cl.GetPlatformInfo(platform, PlatformInfo.Name, out ClError).ToString(); Console.WriteLine("Platform: " + platformName); CheckErr(ClError, "CL.Setup: Cl.GetPlatformInfo"); // Get all available devices within this platform and list them on screen foreach (Device dev in Cl.GetDeviceIDs(platform, DeviceType.All, out ClError)) { CheckErr(ClError, "CL.Setup: Cl.GetDeviceIDs"); string deviceName = Cl.GetDeviceInfo(dev, DeviceInfo.Name, out ClError).ToString(); CheckErr(ClError, "CL.Setup: Cl.GetDeviceInfo"); Console.WriteLine("Device {0}: {1}", nDevices, deviceName); devicesList.Add(dev); deviceNames.Add(deviceName); platformNames.Add(platformName); nDevices++; } Console.WriteLine(); } if (nDevices == 0) { throw new PlatformNotSupportedException("No OpenCL-capable platform and/or devices were found on this system."); } //Console.Write("Enter ID of device to use: "); //deviceID = int.Parse(Console.ReadLine()); // Select device according to user's choice device = devicesList[deviceID]; Console.WriteLine("\nUsing device {0}", deviceNames[deviceID]); // Create OpenCL context context = Cl.CreateContext(null, 1, new[] { device }, ContextNotify, IntPtr.Zero, out ClError); //Second parameter is amount of devices CheckErr(ClError, "CL.Setup: Cl.CreateContext"); // Create OpenCL command queue queue = Cl.CreateCommandQueue(context, device, (CommandQueueProperties)0, out ClError); CheckErr(ClError, "CL.Setup: Cl.CreateCommandQueue"); // Extract some device info maxWorkItemSizes = Cl.GetDeviceInfo(device, DeviceInfo.MaxWorkItemSizes, out ClError).CastToEnumerable <int>(new int[] { 0, 1, 2 }).ToList(); Console.WriteLine("Max work item sizes: {0}, {1}, {2}", maxWorkItemSizes[0], maxWorkItemSizes[1], maxWorkItemSizes[2]); maxWorkGroupSize = Cl.GetDeviceInfo(device, DeviceInfo.MaxWorkGroupSize, out ClError).CastTo <int>(); Console.WriteLine("Max work group size: {0}", maxWorkGroupSize); maxComputeUnits = Cl.GetDeviceInfo(device, DeviceInfo.MaxComputeUnits, out ClError).CastTo <int>(); Console.WriteLine("Max compute units: {0}", maxComputeUnits); }
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 unsafe Context CreateContext() { return(new Context(Cl.CreateContext(null, 1, new[] { this }, null, IntPtr.Zero, out ErrorCode _))); }
private void init(string oclProgramSourcePath) { string kernelSource = File.ReadAllText(oclProgramSourcePath); string[] kernelNames = new string[] { "accumulate", "quickBlurImgH", "quickBlurImgV", "upsizeImg", "halfSizeImgH", "halfSizeImgV", "getLumaImg", "mapToGreyscaleBmp", "getContrastImg", "capHolesImg", "maxReduceImgH", "maxReduceImgV", "mapToFauxColorsBmp", "quickSpikesFilterImg", "convolveImg" }; bool gpu = true; //err = clGetDeviceIDs(NULL, gpu ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU, 1, &device_id, NULL); // NVidia driver doesn't seem to support a NULL first param (properties) // http://stackoverflow.com/questions/19140989/how-to-remove-cl-invalid-platform-error-in-opencl-code // now get all the platform IDs Platform[] platforms = Cl.GetPlatformIDs(out err); assert(err, "Error: Failed to get platform ids!"); InfoBuffer deviceInfo = Cl.GetPlatformInfo(platforms[0], PlatformInfo.Name, out err); assert(err, "error retrieving platform name"); Console.WriteLine("Platform name: {0}\n", deviceInfo.ToString()); // Arbitrary, should be configurable Device[] devices = Cl.GetDeviceIDs(platforms[0], gpu ? DeviceType.Gpu : DeviceType.Cpu, out err); assert(err, "Error: Failed to create a device group!"); _device = devices[0]; // Arbitrary, should be configurable deviceInfo = Cl.GetDeviceInfo(_device, DeviceInfo.Name, out err); assert(err, "error retrieving device name"); Debug.WriteLine("Device name: {0}", deviceInfo.ToString()); deviceInfo = Cl.GetDeviceInfo(_device, DeviceInfo.ImageSupport, out err); assert(err, "error retrieving device image capability"); Debug.WriteLine("Device supports img: {0}", (deviceInfo.CastTo <Bool>() == Bool.True)); // Create a compute context // _context = Cl.CreateContext(null, 1, new[] { _device }, ContextNotify, IntPtr.Zero, out err); assert(err, "Error: Failed to create a compute context!"); // Create the compute program from the source buffer // _program = Cl.CreateProgramWithSource(_context, 1, new[] { kernelSource }, new[] { (IntPtr)kernelSource.Length }, out err); assert(err, "Error: Failed to create compute program!"); // Build the program executable // err = Cl.BuildProgram(_program, 1, new[] { _device }, string.Empty, null, IntPtr.Zero); assert(err, "Error: Failed to build program executable!"); InfoBuffer buffer = Cl.GetProgramBuildInfo(_program, _device, ProgramBuildInfo.Log, out err); Debug.WriteLine("build success: {0}", buffer.CastTo <BuildStatus>() == BuildStatus.Success); foreach (string kernelName in kernelNames) { // Create the compute kernel in the program we wish to run // OpenCL.Net.Kernel kernel = Cl.CreateKernel(_program, kernelName, out err); assert(err, "Error: Failed to create compute kernel!"); _kernels.Add(kernelName, kernel); } // Create a command queue // _commandsQueue = Cl.CreateCommandQueue(_context, _device, CommandQueueProperties.None, out err); assert(err, "Error: Failed to create a command commands!"); }