public static ComputeProgram CreateProgram(string source) { //string realType = Real.Size == sizeof(double) ? "double" : "float"; string realType = "float"; //For setting precision of floating point source = REAL_HEADER_STRING + source; //Add at double precision if (realType == "double") { source = USE_DOUBLE_HEADER_STRING + source; } ComputeProgram program = new ComputeProgram(Context, source); try { program.Build(Devices, $"-D REAL={realType} -Werror", null, IntPtr.Zero); } catch { MessageBox.Show(program.GetBuildLog(Devices[DeviceIndex])); } return(program); }
public string vectorSum() { string vecSum = @" __kernel void vectorSum(__global float *v1, __global float *v2, __global float *v3) { int i = get_global_id(0); v3[i] = v1[i] + v2[i]; } "; int size = 100000; float[] v1_ = new float[size]; float[] v2_ = new float[size]; float[] v3_ = new float[size]; for (var i = 0; i < size; i++) { v1_[i] = (float)i; v2_[i] = (float).5f; } var platform_ = ComputePlatform.Platforms[0]; ComputeContextPropertyList properties = new ComputeContextPropertyList(platform_); ComputeContext ctx = new ComputeContext(ComputeDeviceTypes.Gpu, properties, null, IntPtr.Zero); ComputeCommandQueue commands = new ComputeCommandQueue(ctx, ctx.Devices[0], ComputeCommandQueueFlags.None); ComputeProgram program = new ComputeProgram(ctx, vecSum); try { program.Build(null, null, null, IntPtr.Zero); Console.WriteLine("program build completed"); } catch { string log = program.GetBuildLog(ctx.Devices[0]); } ComputeBuffer <float> v1, v2, v3; v1 = new ComputeBuffer <float>(ctx, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, v1_); v2 = new ComputeBuffer <float>(ctx, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, v2_); v3 = new ComputeBuffer <float>(ctx, ComputeMemoryFlags.WriteOnly | ComputeMemoryFlags.CopyHostPointer, v3_); long[] worker = { size }; commands.WriteToBuffer(v1_, v1, false, null); commands.WriteToBuffer(v2_, v2, false, null); ComputeKernel sumKernal = program.CreateKernel("vectorSum"); Console.WriteLine("kernal created"); sumKernal.SetMemoryArgument(0, v1); sumKernal.SetMemoryArgument(1, v2); sumKernal.SetMemoryArgument(2, v3); commands.Execute(sumKernal, null, worker, null, null); Console.WriteLine("Executed"); commands.ReadFromBuffer <float>(v3, ref v3_, false, null); StringBuilder sb = new StringBuilder(); for (int i = 0; i < size; i++) { sb.AppendFormat("{0} + {1} = {2}<br>", v1_[i].ToString(), v2_[i].ToString(), v3_[i].ToString()); } var sum_expression_result = sb.ToString(); return(sum_expression_result); }
private void Initialize() { // get the intel integrated GPU _integratedIntelGPUPlatform = ComputePlatform.Platforms.Where(n => n.Name.Contains("Intel")).First(); // create the compute context. _context = new ComputeContext( ComputeDeviceTypes.Gpu, // use the gpu new ComputeContextPropertyList(_integratedIntelGPUPlatform), // use the intel openCL platform null, IntPtr.Zero); // the command queue is the, well, queue of commands sent to the "device" (GPU) _commandQueue = new ComputeCommandQueue( _context, // the compute context _context.Devices[0], // first device matching the context specifications ComputeCommandQueueFlags.None); // no special flags string kernelSource = null; using (StreamReader sr = new StreamReader("kernel.cl")) { kernelSource = sr.ReadToEnd(); } // create the "program" _program = new ComputeProgram(_context, new string[] { kernelSource }); // compile. _program.Build(null, null, null, IntPtr.Zero); _kernel = _program.CreateKernel("ComputeMatrix"); }
// initialiseer OpenCL static void InitCL() { // kies platform 0 (op sommige machines moet dit 1 of 2 zijn) var platform = ComputePlatform.Platforms[CLPlatform]; Console.Write( "initializing OpenCL... " + platform.Name + " (" + platform.Profile + ").\n" ); Console.Write( platform.Devices.First().Name + " (" + platform.Devices.First().Type + ")\n"); Console.Write( (platform.Devices.First().GlobalMemorySize / 1024 / 1024) ); Console.WriteLine( " MiB global memory / " + (platform.Devices.First().LocalMemorySize / 1024) + " KiB local memory"); // maak een compute context context = new ComputeContext( ComputeDeviceTypes.Gpu, new ComputeContextPropertyList( platform ), null, IntPtr.Zero ); // laad opencl programma var streamReader = new StreamReader( "../../program.cl" ); string clSource = streamReader.ReadToEnd(); streamReader.Close(); // compileer opencl source code program = new ComputeProgram( context, clSource ); try { program.Build( null, null, null, IntPtr.Zero ); } catch { // fout in OpenCL code; check console window voor details. Console.Write( "error in kernel code:\n" ); Console.Write( program.GetBuildLog( context.Devices[0] ) + "\n" ); } // maak een commandorij queue = new ComputeCommandQueue( context, context.Devices[0], 0 ); // lokaliseer de gewenste kernel in het programma kernel = program.CreateKernel( "device_function" ); // alloceer data in RAM }
public bool CreateProgram(string name, string source) { try { Console.WriteLine("\"{0}\" ProgramKernel Build.", name); Console.WriteLine(source); ComputeProgram program; try { program = new ComputeProgram(Context, source); program.Build(Platform.Devices, null, null, IntPtr.Zero); } catch (Exception ex) { if (ex is BuildProgramFailureComputeException) { } throw ex; } Programs.Add(new ProgramKernel(name, program)); Console.WriteLine("\"{0}\" ProgramKernel Created.", name); return(true); } catch (Exception exception) { throw exception; } }
public override void Init(WaveFormat AFormat) { base.Init(AFormat); try { FDevice = App.Settings.Preferences.OpenCL.GetComputeDevice(); FContext = new ComputeContext(new ComputeDevice[] { FDevice }, new ComputeContextPropertyList(FDevice.Platform), null, IntPtr.Zero); program = new ComputeProgram(FContext, FProgramSource); program.Build(new[] { FDevice }, null, null, IntPtr.Zero); kernel = program.CreateKernel("Wave"); commands = new ComputeCommandQueue(FContext, FContext.Devices[0], ComputeCommandQueueFlags.None); } catch (BuildProgramFailureComputeException bex) { Debug.WriteLine(bex.Message); Debug.WriteLine(program.GetBuildLog(FDevice)); throw; } catch (Exception ex) { Debug.WriteLine(ex.Message); throw; } }
public OpenCLProgram(string sourceFile) { // pick first platform SelectBestDevice(); // load opencl source string clSource = ""; try { var streamReader = new StreamReader(sourceFile); clSource = streamReader.ReadToEnd(); streamReader.Close(); } catch { FatalError("File not found:\n" + sourceFile); } // create program with opencl source program = new ComputeProgram(context, clSource); // compile opencl source try { program.Build(null, null, null, IntPtr.Zero); } catch { FatalError("Error in kernel code:\n" + program.GetBuildLog(context.Devices[0])); } // create a command queue with first gpu found queue = new ComputeCommandQueue(context, context.Devices[0], 0); }
private void BuildEthashProgram() { ComputeDevice computeDevice = OpenCLDevice.GetComputeDevice(); try { mProgramArrayMutex.WaitOne(5000); } catch (Exception) { } if (mEthashProgramArray.ContainsKey(new long[] { DeviceIndex, mEthashLocalWorkSizeArray[0] })) { mEthashProgram = mEthashProgramArray[new long[] { DeviceIndex, mEthashLocalWorkSizeArray[0] }]; mEthashDAGKernel = mEthashDAGKernelArray[new long[] { DeviceIndex, mEthashLocalWorkSizeArray[0] }]; mEthashSearchKernel = mEthashSearchKernelArray[new long[] { DeviceIndex, mEthashLocalWorkSizeArray[0] }]; } else { try { if (mEthashLocalWorkSizeArray[0] != 192) { throw new Exception("No suitable binary file was found."); } string fileName = @"BinaryKernels\" + computeDevice.Name + "_ethash.bin"; byte[] binary = System.IO.File.ReadAllBytes(fileName); mEthashProgram = new ComputeProgram(Context, new List <byte[]>() { binary }, new List <ComputeDevice>() { computeDevice }); MainForm.Logger("Loaded " + fileName + " for Device #" + DeviceIndex + "."); } catch (Exception) { //MainForm.Logger("ex.message: " + ex.Message); String source = System.IO.File.ReadAllText(@"Kernels\ethash.cl"); mEthashProgram = new ComputeProgram(Context, source); MainForm.Logger(@"Loaded Kernels\ethash.cl for Device #" + DeviceIndex + "."); } String buildOptions = (OpenCLDevice.GetVendor() == "AMD" ? "-O1 " : OpenCLDevice.GetVendor() == "NVIDIA" ? "" : // "-cl-nv-opt-level=1 -cl-nv-maxrregcount=256 " : "") + " -IKernels -DWORKSIZE=" + mEthashLocalWorkSizeArray[0]; try { mEthashProgram.Build(OpenCLDevice.DeviceList, buildOptions, null, IntPtr.Zero); } catch (Exception) { MainForm.Logger(mEthashProgram.GetBuildLog(computeDevice)); throw; } MainForm.Logger("Built Ethash program for Device #" + DeviceIndex + "."); MainForm.Logger("Build options: " + buildOptions); mEthashProgramArray[new long[] { DeviceIndex, mEthashLocalWorkSizeArray[0] }] = mEthashProgram; mEthashDAGKernelArray[new long[] { DeviceIndex, mEthashLocalWorkSizeArray[0] }] = mEthashDAGKernel = mEthashProgram.CreateKernel("GenerateDAG"); mEthashSearchKernelArray[new long[] { DeviceIndex, mEthashLocalWorkSizeArray[0] }] = mEthashSearchKernel = mEthashProgram.CreateKernel("search"); } try { mProgramArrayMutex.ReleaseMutex(); } catch (Exception) { } }
public void Load(string directory, string kernelFileName, string function) { #if DEBUG DeleteCache(); #endif m_platform = ComputePlatform.Platforms[0]; Context = new ComputeContext(ComputeDeviceTypes.Gpu, new ComputeContextPropertyList(m_platform), null, IntPtr.Zero); m_graphicsCard = Context.Devices[0]; Queue = new ComputeCommandQueue(Context, m_graphicsCard, ComputeCommandQueueFlags.None); ComputeProgram program = new ComputeProgram(Context, GetKernelSource(directory + "/" + kernelFileName)); try { program.Build(null, "-I " + directory, null, IntPtr.Zero); } catch { string error = program.GetBuildLog(m_graphicsCard); throw new Exception(error); } Program = program.CreateKernel(function); }
public GPURadixSort( ComputeCommandQueue commandQue, ComputeContext context, ComputeDevice device ) { gpuConstants = new GPUConstants(); gpuConstants.L = radix_BitsL; gpuConstants.numGroupsPerBlock = NumGroupsPerBlock; gpuConstants.R = R; gpuConstants.numThreadsPerGroup = numThreadsPerBlock / NumGroupsPerBlock; gpuConstants.numThreadsPerBlock = numThreadsPerBlock; gpuConstants.numBlocks = numBlocks; gpuConstants.numRadices = num_Radices; gpuConstants.numRadicesPerBlock = num_Radices / numBlocks; gpuConstants.bitMask = BIT_MASK_START; counters.Initialize(); ComputeErrorCode error; cxGPUContext = context.Handle; cqCommandQueue = commandQue.Handle; _device = device.Handle; //Create a command queue, where all of the commands for execution will be added /*cqCommandQueue = CL10.CreateCommandQueue(cxGPUContext, _device, (CommandQueueProperties)0, out error); * CheckErr(error, "CL10.CreateCommandQueue");*/ string programSource = System.IO.File.ReadAllText(programPath); IntPtr[] progSize = new IntPtr[] { (IntPtr)programSource.Length }; string flags = "-cl-fast-relaxed-math"; ComputeProgram prog = new ComputeProgram(context, programSource); prog.Build(new List <ComputeDevice>() { device }, flags, null, IntPtr.Zero); if (prog.GetBuildStatus(device) != ComputeProgramBuildStatus.Success) { Debug.WriteLine(prog.GetBuildLog(device)); throw new ArgumentException("UNABLE to build programm"); } // ComputeProgram clProgramRadix = CL10.CreateProgramWithSource(cxGPUContext, 1, new[] { programSource },progSize, // out error); CLProgramHandle clProgramRadix = prog.Handle; ckSetupAndCount = CL10.CreateKernel(clProgramRadix, "SetupAndCount", out error); CheckErr(error, "CL10.CreateKernel"); ckSumIt = CL10.CreateKernel(clProgramRadix, "SumIt", out error); CheckErr(error, "CL10.CreateKernel"); ckReorderingKeysOnly = CL10.CreateKernel(clProgramRadix, "ReorderingKeysOnly", out error); CheckErr(error, "CL10.CreateKernel"); ckReorderingKeyValue = CL10.CreateKernel(clProgramRadix, "ReorderingKeyValue", out error); CheckErr(error, "CL10.CreateKernel"); }
public BlockedMatMulThread(ComputePlatform platform, ComputeDevice device, int inN, float[] inA, float[] inB) { ComputeDevice[] devices = { device }; context = new ComputeContext(devices, new ComputeContextPropertyList(platform), null, IntPtr.Zero); program = new ComputeProgram(context, clProgramSource); try { program.Build(null, null, null, IntPtr.Zero); } catch (BuildProgramFailureComputeException e) { string buildLog = program.GetBuildLog(device); Console.WriteLine(buildLog); throw; } kernel = program.CreateKernel("mmul"); queue = new ComputeCommandQueue(context, device, ComputeCommandQueueFlags.None); n = inN; a = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, inA); b = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, inB); int resultCount = (int)(device.MaxMemoryAllocationSize / n / n / sizeof(float)); results = new ComputeBuffer <float> [resultCount]; for (int i = 0; i < results.Length; ++i) { results[i] = new ComputeBuffer <float>(context, ComputeMemoryFlags.WriteOnly, n * n); } HaltRequested = false; operationCounter = 0; completionCounter = 0; startTime = 0; }
public ComputeProgram BuildProgramm(string code) { var programm = new ComputeProgram(Context, code); programm.Build(new[] { Device }, null, null, IntPtr.Zero); return(programm); }
public void Run(ComputeContext context, TextWriter log) { try { ComputeProgram program = new ComputeProgram(context, kernelSources); program.Build(null, null, null, IntPtr.Zero); log.WriteLine("Program successfully built."); ICollection <ComputeKernel> kernels = program.CreateAllKernels(); log.WriteLine("Kernels successfully created."); // cleanup kernels foreach (ComputeKernel kernel in kernels) { kernel.Dispose(); } kernels.Clear(); // cleanup program program.Dispose(); } catch (Exception e) { log.WriteLine(e.ToString()); } }
public static ComputeProgram CreateProgram(string source) { string realType = Marshal.SizeOf(typeof(Real)) == Marshal.SizeOf(typeof(double)) ? "double" : "float"; //for precision setting of floating point source = REAL_HEADER_STRING + source; //Add at double precision if (realType == "double") { source = USE_DOUBLE_HEADER_STRING + source; } ComputeProgram program = new ComputeProgram(Context, source); try { program.Build(Devices, string.Format("-D REAL={0} -Werror", realType), null, IntPtr.Zero); } catch { MessageBox.Show(program.GetBuildLog(Devices[DeviceIndex])); } return(program); }
static void Main(string[] args) { int[] r1 = new int[] { 8, 2, 3, 4 }; int[] r2 = new int[] { 4, 3, 2, 5 }; int[] r3 = new int[4]; int rowSize = r1.Length; // pick first platform ComputePlatform platform = ComputePlatform.Platforms[0]; // create context with all gpu devices ComputeContext context = new ComputeContext(ComputeDeviceTypes.Gpu, new ComputeContextPropertyList(platform), null, IntPtr.Zero); // create a command queue with first gpu found ComputeCommandQueue queue = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None); // load opencl source and // create program with opencl source ComputeProgram program = new ComputeProgram(context, CalculateKernel); // compile opencl source program.Build(null, null, null, IntPtr.Zero); // load chosen kernel from program ComputeKernel kernel = program.CreateKernel("Calc"); // allocate a memory buffer with the message (the int array) ComputeBuffer <int> row1Buffer = new ComputeBuffer <int>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, r1); // allocate a memory buffer with the message (the int array) ComputeBuffer <int> row2Buffer = new ComputeBuffer <int>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, r2); // allocate a memory buffer with the message (the int array) ComputeBuffer <int> resultBuffer = new ComputeBuffer <int>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, new int[4]); kernel.SetMemoryArgument(0, row1Buffer); // set the integer array kernel.SetMemoryArgument(1, row2Buffer); // set the integer array kernel.SetValueArgument(2, rowSize); // set the array size kernel.SetMemoryArgument(3, resultBuffer); // set the integer array // execute kernel queue.ExecuteTask(kernel, null); // wait for completion queue.Finish(); GCHandle arrCHandle = GCHandle.Alloc(r3, GCHandleType.Pinned); queue.Read <int>(resultBuffer, true, 0, r3.Length, arrCHandle.AddrOfPinnedObject(), null); Console.WriteLine("display result from gpu buffer:"); for (int i = 0; i < r3.Length; i++) { Console.WriteLine(r3[i]); } arrCHandle.Free(); row1Buffer.Dispose(); row2Buffer.Dispose(); kernel.Dispose(); program.Dispose(); queue.Dispose(); context.Dispose(); Console.WriteLine("Finished"); Console.ReadKey(); }
public Kernel(string name, string compile_options, string [] kernel_names) { _path = _paths + name + _exts; StreamReader streamReader = new StreamReader(_path); string source = streamReader.ReadToEnd(); streamReader.Close(); // Create and build the opencl program. _program = new ComputeProgram(Example.context, source); _program.Build(Example.context.Devices, compile_options, null, IntPtr.Zero); // Create the kernel function and set its arguments. ComputeKernel kernel; for (int i = 0; i < kernel_names.Length; i++) { kernel = _program.CreateKernel(kernel_names[i]); _kernels.Add(kernel); } _eventList = new ComputeEventList(); // Create the command queue. This is used to control kernel execution and manage read/write/copy operations. _commands = new ComputeCommandQueue(Example.context, Example.context.Devices[0], ComputeCommandQueueFlags.None); Console.WriteLine(_path); }
public void SetKernel(string OpenCLBody, string EntryPoint) { this.OpenCLBody = OpenCLBody; this.EntryPoint = EntryPoint; ComputeProgram program = new ComputeProgram(context, OpenCLBody); try { program.Build(null, null, null, IntPtr.Zero); kernel = program.CreateKernel(EntryPoint); } catch (BuildProgramFailureComputeException) { string message = program.GetBuildLog(Accelerator.Device); throw new ArgumentException(message); } catch (ComputeException) { string message = program.GetBuildLog(Accelerator.Device); throw new ArgumentException(message); } MethodInfo = new CLMethod(EntryPoint, OpenCLBody); MethodSet = true; }
public void SetDevice(int deviceIndx) { if ((deviceIndx < 0) || (deviceIndx >= oclDevices.Count)) { throw new IndexOutOfRangeException("Invalid OpenCL device index."); } if (oclContext != null) { oclContext.Dispose(); oclContext = null; } if (oclCommandQueue != null) { oclCommandQueue.Dispose(); oclCommandQueue = null; } if (oclKernel != null) { oclKernel.Dispose(); oclKernel = null; } ComputeProgram oclProgram = null; try { oclContext = new ComputeContext(new ComputeDevice[] { oclDevices[deviceIndx] }, new ComputeContextPropertyList(oclDevices[deviceIndx].Platform), null, IntPtr.Zero); oclCommandQueue = new ComputeCommandQueue(oclContext, oclDevices[deviceIndx], ComputeCommandQueueFlags.None); oclProgram = new ComputeProgram(oclContext, Encoding.Default.GetString(Properties.Resources.Test)); oclProgram.Build(new ComputeDevice[] { oclDevices[deviceIndx] }, "", null, IntPtr.Zero); oclKernel = oclProgram.CreateKernel("Test"); } catch (BuildProgramFailureComputeException ex) { string buildLog = oclProgram.GetBuildLog(oclDevices[deviceIndx]); throw new Exception(buildLog, ex); } catch (Exception) { throw; } finally { if (oclProgram != null) { oclProgram.Dispose(); oclProgram = null; } } }
/// <summary> /// Initializes a new instance of the <see cref="Julia"/> class. /// </summary> public Julia() : base() { this.Mode = ConcurrencyMode.SequentialCPU; this.options = new ParallelOptions(); this.options.MaxDegreeOfParallelism = Environment.ProcessorCount; // Initialize OpenCL. platform = ComputePlatform.Platforms[0]; properties = new ComputeContextPropertyList(platform); context = new ComputeContext(platform.Devices, properties, null, IntPtr.Zero); // Create the OpenCL kernel. program = new ComputeProgram(context, new string[] { kernelSource }); program.Build(null, "-cl-mad-enable", null, IntPtr.Zero); kernel = program.CreateKernel("julia"); // Create objects needed for kernel launch/execution. commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None); events = new ComputeEventList(); }
public void BuildNeoScryptProgram() { ComputeDevice computeDevice = OpenCLDevice.GetComputeDevice(); try { mProgramArrayMutex.WaitOne(5000); } catch (Exception) { } if (mNeoScryptProgramArray.ContainsKey(new ProgramArrayIndex(DeviceIndex, mNeoScryptLocalWorkSizeArray[0]))) { mNeoScryptProgram = mNeoScryptProgramArray[new ProgramArrayIndex(DeviceIndex, mNeoScryptLocalWorkSizeArray[0])]; mNeoScryptSearchKernel = mNeoScryptSearchKernelArray[new ProgramArrayIndex(DeviceIndex, mNeoScryptLocalWorkSizeArray[0])]; } else { String source = System.IO.File.ReadAllText(@"Kernels\neoscrypt.cl"); mNeoScryptProgram = new ComputeProgram(Context, source); MainForm.Logger(@"Loaded Kernels\neoscrypt.cl for Device #" + DeviceIndex + "."); String buildOptions = (OpenCLDevice.GetVendor() == "AMD" ? "-O5 -legacy" : // "-legacy" : OpenCLDevice.GetVendor() == "NVIDIA" ? "" : //"-cl-nv-opt-level=1 -cl-nv-maxrregcount=256 " : "") + " -IKernels -DWORKSIZE=" + mNeoScryptLocalWorkSizeArray[0]; try { mNeoScryptProgram.Build(OpenCLDevice.DeviceList, buildOptions, null, IntPtr.Zero); } catch (Exception) { MainForm.Logger(mNeoScryptProgram.GetBuildLog(computeDevice)); throw; } MainForm.Logger("Built NeoScrypt program for Device #" + DeviceIndex + "."); MainForm.Logger("Build options: " + buildOptions); mNeoScryptProgramArray[new ProgramArrayIndex(DeviceIndex, mNeoScryptLocalWorkSizeArray[0])] = mNeoScryptProgram; mNeoScryptSearchKernelArray[new ProgramArrayIndex(DeviceIndex, mNeoScryptLocalWorkSizeArray[0])] = mNeoScryptSearchKernel = mNeoScryptProgram.CreateKernel("search"); } try { mProgramArrayMutex.ReleaseMutex(); } catch (Exception) { } }
public static ComputeProgram CreateProgram(string source) { string realType = Real.Size == sizeof(double) ? "double" : "float"; //浮動小数点の精度設定用 source = REAL_HEADER_STRING + source; //倍精度時に追加 if (realType == "double") { source = USE_DOUBLE_HEADER_STRING + source; } ComputeProgram program = new ComputeProgram(Context, source); try { program.Build(ComputePlatform.Platforms[PlatformId].Devices, string.Format("-D REAL={0} -Werror", realType), null, IntPtr.Zero); } catch (Exception e) { throw new Exception(program.GetBuildLog(ComputePlatform.Platforms[PlatformId].Devices[DeviceIndex]), e); } return(program); }
public KernelManager(GraphicsInterop interop, InputManager input, string source) { _input = input; var localSizeSingle = (long)Math.Sqrt(interop.Device.MaxWorkGroupSize); _localSize = new[] { localSizeSingle, localSizeSingle }; //_localSize = new[] { interop.Device.MaxWorkGroupSize, 1 }; _program = new ComputeProgram(interop.Context, source); try { _program.Build(new[] { interop.Device }, "", null, IntPtr.Zero); } catch (InvalidBinaryComputeException) { Console.WriteLine(_program.GetBuildLog(interop.Device)); return; } catch (BuildProgramFailureComputeException) { Console.WriteLine(_program.GetBuildLog(interop.Device)); return; } Console.WriteLine(_program.GetBuildLog(interop.Device)); _kernels = _program.CreateAllKernels().ToArray(); }
public TFP Hello(float num) { ComputeBuffer <TFP> result = new ComputeBuffer <TFP>(context, ComputeMemoryFlags.WriteOnly, 1); string source = Encoding.ASCII.GetString(FZYK.Nest.Properties.Resources.nest); if (fpType == FPType.FP64AMD) { source = "#define AMDFP64\n" + source; } else if (fpType == FPType.FP64) { source = "#define FP64\n" + source; } ComputeProgram program = new ComputeProgram(context, source); try { program.Build(null, null, null, IntPtr.Zero); } catch (Exception) { var log = program.GetBuildLog(context.Devices[0]); Debugger.Break(); } ComputeKernel kernel = program.CreateKernel("hello"); TFP[] myresult = RunKernalTest(num, result, kernel); return(myresult[0]); }
protected ComputeProgram BuildProgram(string programName, long localWorkSize, string optionsAMD, string optionsNVIDIA, string optionsOthers) { ComputeProgram program; string defultBinaryFilePath = @"BinaryKernels\" + ComputeDevice.Name + "_" + programName + "_" + localWorkSize + ".bin"; string savedBinaryFilePath = (MainForm.SavedOpenCLBinaryKernelPathBase + @"\") + ComputeDevice.Name + "_" + programName + "_" + localWorkSize + ".bin"; string sourceFilePath = @"Kernels\" + programName + ".cl"; String buildOptions = (OpenCLDevice.GetVendor() == "AMD" ? optionsAMD : OpenCLDevice.GetVendor() == "NVIDIA" ? optionsNVIDIA : optionsOthers) + " -IKernels -DWORKSIZE=" + localWorkSize; try { if (!MainForm.UseDefaultOpenCLBinariesChecked) { throw new Exception(); } byte[] binary = System.IO.File.ReadAllBytes(defultBinaryFilePath); program = new ComputeProgram(Context, new List <byte[]>() { binary }, new List <ComputeDevice>() { ComputeDevice }); MainForm.Logger("Loaded " + defultBinaryFilePath + " for Device #" + DeviceIndex + "."); } catch (Exception) { try { if (!MainForm.ReuseCompiledBinariesChecked) { throw new Exception(); } byte[] binary = System.IO.File.ReadAllBytes(savedBinaryFilePath); program = new ComputeProgram(Context, new List <byte[]>() { binary }, new List <ComputeDevice>() { ComputeDevice }); MainForm.Logger("Loaded " + savedBinaryFilePath + " for Device #" + DeviceIndex + "."); } catch (Exception) { String source = System.IO.File.ReadAllText(sourceFilePath); program = new ComputeProgram(Context, source); MainForm.Logger(@"Loaded " + sourceFilePath + " for Device #" + DeviceIndex + "."); } } try { program.Build(OpenCLDevice.DeviceList, buildOptions, null, IntPtr.Zero); if (MainForm.ReuseCompiledBinariesChecked) { System.IO.File.WriteAllBytes(savedBinaryFilePath, program.Binaries[0]); } } catch (Exception) { MainForm.Logger(program.GetBuildLog(ComputeDevice)); program.Dispose(); throw; } MainForm.Logger("Built " + programName + " program for Device #" + DeviceIndex + "."); MainForm.Logger("Build options: " + buildOptions); return(program); }
public FindPointOpenCl() { cpl = new ComputeContextPropertyList(ComputePlatform.Platforms[0]); context = new ComputeContext(ComputeDeviceTypes.Gpu, cpl, null, IntPtr.Zero); program = new ComputeProgram(context, new string[] { FindPointCalculationGpu }); program.Build(null, null, null, IntPtr.Zero); kernel = program.CreateKernel("FindPointCalculationGpu"); }
public static Tuple <List <List <int> >, TimeSpan> MultiplyParallel(List <List <int> > matrixOne, List <List <int> > matrixTwo) { if (!isRegularMatrix(matrixOne) || !isRegularMatrix(matrixTwo)) { throw new ArgumentException("Non regular matrix detected. Rows size mismatch detected."); } if (matrixOne[0].Count != matrixTwo.Count) { throw new ArgumentException("Matrixes is not compatible. Columns count of first matrix is not equal to rows count of second matrix."); } List <List <int> > result = new List <List <int> >(); ComputePlatform platform = GetGPU(); if (platform is null) { throw new PlatformNotSupportedException("Platform doesn't have a dedicated GPU. Run is impossible."); } ComputeContext context = new ComputeContext(ComputeDeviceTypes.Gpu, new ComputeContextPropertyList(platform), null, IntPtr.Zero); ComputeCommandQueue queue = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None); ComputeProgram program = new ComputeProgram(context, CalculateKernel); program.Build(null, null, null, IntPtr.Zero); ComputeKernel kernel = program.CreateKernel("Multiply"); List <ComputeBuffer <int> > rowsMatrixOne = matrixOne.TransformMatrixToComputerBuffersOfRows(context); List <ComputeBuffer <int> > columnsMatrixTwo = matrixTwo.TransformMatrixToComputerBuffersOfColumns(context); List <ComputeBuffer <int> > resultRowsMatrix = TwoDToOneDResult(matrixOne.Count, matrixTwo[0].Count, context); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); for (int i = 0; i < resultRowsMatrix.Count; ++i) { for (int j = 0; j < resultRowsMatrix[i].Count; ++j) { kernel.SetMemoryArgument(0, rowsMatrixOne[i]); kernel.SetMemoryArgument(1, columnsMatrixTwo[j]); kernel.SetMemoryArgument(2, resultRowsMatrix[i]); kernel.SetValueArgument(3, matrixTwo.Count); kernel.SetValueArgument(4, j); queue.ExecuteTask(kernel, null); } } queue.Finish(); stopwatch.Stop(); for (int i = 0; i < resultRowsMatrix.Count; ++i) { int[] res = new int[resultRowsMatrix[i].Count]; GCHandle gCHandle = GCHandle.Alloc(res, GCHandleType.Pinned); queue.Read <int>(resultRowsMatrix[i], true, 0, res.Length, gCHandle.AddrOfPinnedObject(), null); result.Add(new List <int>(res)); } return(new Tuple <List <List <int> >, TimeSpan>(result, stopwatch.Elapsed)); }
public async Task Can_use_struct() { var platform = ComputePlatform.Platforms.First(); var device = platform.Devices.First(); var context = new ComputeContext(new[] { device }, new ComputeContextPropertyList(platform), null, IntPtr.Zero); using var program = new ComputeProgram(context, Struct_kernel); try { program.Build(new[] { device }, "-cl-std=CL1.2", null, IntPtr.Zero); } catch (Exception ex) { OnProgramBuilt(program, device); return; } using var queue = new ComputeCommandQueue(context, device, ComputeCommandQueueFlags.None); using var kernel = program.CreateKernel("fill"); var target = new Target[10]; var gcHandle = GCHandle.Alloc(target, GCHandleType.Pinned); var ptr = gcHandle.AddrOfPinnedObject(); var buffer = new ComputeBuffer <Target>( context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, 10, ptr); kernel.SetMemoryArgument(0, buffer); var events = new List <ComputeEventBase>(); queue.Execute(kernel, null, new long[] { 10 }, null, events); //await events.WaitForEvents(); unsafe { target[0].a.Should().Be(0); target[0].b.Should().BeApproximately(0.5f, 0.01f); target[0].c.Should().Be(1); target[0].d[0].Should().Be(1); target[0].d[1].Should().Be(2); target[1].a.Should().Be(2); target[1].b.Should().BeApproximately(1.5f, 0.01f); target[1].c.Should().Be(2); target[1].d[0].Should().Be(1); target[1].d[1].Should().Be(2); target[9].a.Should().Be(18); target[9].b.Should().BeApproximately(9.5f, 0.01f); target[9].c.Should().Be(10); target[9].d[0].Should().Be(1); target[9].d[1].Should().Be(2); } }
public async Task Can_multiply_using_pinned_host_pointer() { // This doesn't seem to work on NVidia platforms var platform = ComputePlatform.Platforms.First(); var device = platform.Devices.First(); var context = new ComputeContext(new[] { device }, new ComputeContextPropertyList(platform), null, IntPtr.Zero); using var program = new ComputeProgram(context, Sum_kernel); program.Build(new[] { device }, "-cl-std=CL1.2", (handle, ptr) => OnProgramBuilt(program, device), IntPtr.Zero); using var queue = new ComputeCommandQueue(context, device, ComputeCommandQueueFlags.None); using var kernel = program.CreateKernel("sum"); var source = new byte[] { 1, 2, 3, 4, 5 }; var sourceHandle = GCHandle.Alloc(source, GCHandleType.Pinned); var sourcePtr = sourceHandle.AddrOfPinnedObject(); using var sourceBuffer = new ComputeBuffer <byte>( context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, source.LongLength, sourcePtr); var target = new byte[5]; var targetHandle = GCHandle.Alloc(target, GCHandleType.Pinned); var targetPtr = targetHandle.AddrOfPinnedObject(); using var targetBuffer = new ComputeBuffer <byte>( context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, target.LongLength, targetPtr); try { kernel.SetMemoryArgument(0, sourceBuffer); kernel.SetMemoryArgument(1, targetBuffer); var events = new List <ComputeEventBase>(); queue.Execute(kernel, null, new long[] { source.Length }, null, events); //await events.WaitForEvents(); for (var i = 0; i < target.Length; i++) { Console.WriteLine($"{source[i]} * 2 = {target[i]}"); } } finally { sourceHandle.Free(); targetHandle.Free(); } }
public void BuildLbryProgram() { ComputeDevice computeDevice = OpenCLDevice.GetComputeDevice(); try { mProgramArrayMutex.WaitOne(5000); } catch (Exception) { } if (mLbryProgramArray.ContainsKey(new ProgramArrayIndex(DeviceIndex, mLbryLocalWorkSizeArray[0]))) { mLbryProgram = mLbryProgramArray[new ProgramArrayIndex(DeviceIndex, mLbryLocalWorkSizeArray[0])]; mLbrySearchKernel = mLbrySearchKernelArray[new ProgramArrayIndex(DeviceIndex, mLbryLocalWorkSizeArray[0])]; } else { try { if (mLbryLocalWorkSizeArray[0] != 256) { throw new Exception("No suitable binary file was found."); } string fileName = @"BinaryKernels\" + computeDevice.Name + "_lbry.bin"; byte[] binary = System.IO.File.ReadAllBytes(fileName); mLbryProgram = new ComputeProgram(Context, new List <byte[]>() { binary }, new List <ComputeDevice>() { computeDevice }); //MainForm.Logger("Loaded " + fileName + " for Device #" + DeviceIndex + "."); } catch (Exception) { String source = System.IO.File.ReadAllText(@"Kernels\lbry.cl"); mLbryProgram = new ComputeProgram(Context, source); //MainForm.Logger(@"Loaded Kernels\lbry.cl for Device #" + DeviceIndex + "."); } String buildOptions = (OpenCLDevice.GetVendor() == "AMD" ? "-O1 " : //"-O1 " : OpenCLDevice.GetVendor() == "NVIDIA" ? "" : //"-cl-nv-opt-level=1 -cl-nv-maxrregcount=256 " : "") + " -IKernels -DWORKSIZE=" + mLbryLocalWorkSizeArray[0] + " -DITERATIONS=" + mIterations; try { mLbryProgram.Build(OpenCLDevice.DeviceList, buildOptions, null, IntPtr.Zero); } catch (Exception) { MainForm.Logger(mLbryProgram.GetBuildLog(computeDevice)); throw; } //MainForm.Logger("Built Lbry program for Device #" + DeviceIndex + "."); //MainForm.Logger("Build options: " + buildOptions); mLbryProgramArray[new ProgramArrayIndex(DeviceIndex, mLbryLocalWorkSizeArray[0])] = mLbryProgram; mLbrySearchKernelArray[new ProgramArrayIndex(DeviceIndex, mLbryLocalWorkSizeArray[0])] = mLbrySearchKernel = mLbryProgram.CreateKernel("search_combined"); } try { mProgramArrayMutex.ReleaseMutex(); } catch (Exception) { } }
public GPU() { context = new ComputeContext(ComputeDeviceTypes.Gpu, new ComputeContextPropertyList(ComputePlatform.Platforms[0]), null, IntPtr.Zero); queue = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None); var program = new ComputeProgram(context, ArrayCopy); program.Build(null, null, null, IntPtr.Zero); kernel = program.CreateKernel("ArrayCopy"); }