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 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; }
//Initializing everything OpenGL related public void OpenGLInit() { ComputePlatform platform = null; ComputeDevice device = null; for (int p = 0; p < ComputePlatform.Platforms.Count; ++p) { platform = ComputePlatform.Platforms[p]; /*Console.WriteLine * ("Platform {0} \"{1}\" has {2} devices attached" * , p * , platform.Name * , platform.Devices.Count);*/ for (int d = 0; d < platform.Devices.Count; d++) { device = platform.Devices[d]; //Console.WriteLine(" device [{0}]: {1}", d, device.Name); } } context = new ComputeContext( ComputeDeviceTypes.Gpu, new ComputeContextPropertyList(platform), null, IntPtr.Zero); queue = new ComputeCommandQueue (context , device , ComputeCommandQueueFlags.Profiling // enable event timing ); StreamReader reader = new StreamReader("../../GameOfLife.cl"); string source = reader.ReadToEnd(); reader.Close(); //Console.WriteLine(source); program = new ComputeProgram(context, source); try { program.Build(null, null, null, IntPtr.Zero); } catch { Console.WriteLine(program.GetBuildLog(device)); // error log System.Environment.Exit(7); } Console.WriteLine(program.GetBuildLog(device)); // warnings }
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 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); }
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]); }
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 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; } } }
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 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"; 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); }
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); }
// 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 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 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"); }
void InitComputeKernel() { if (this.openCLSources == null) { GetOpenCLSources(); } var properties = new ComputeContextPropertyList(this.computeDevice.Platform); this.computeContext = new ComputeContext(new[] { this.computeDevice }, properties, null, IntPtr.Zero); this.computeProgram = new ComputeProgram(this.computeContext, this.openCLSources); try { this.computeProgram.Build(new[] { this.computeDevice }, null, null, IntPtr.Zero); } catch (Exception e) { Console.WriteLine(e.Message); Console.WriteLine(computeProgram.GetBuildLog(this.computeDevice)); } this.computeKernels = this.computeProgram.CreateAllKernels().ToList(); this.computeKernel = this.computeKernels.First(k => k.FunctionName == openCLKernelFunction); }
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 ComputeKernel GetKernel(string file, string kernelName) { var program = new ComputeProgram(Context, new StreamReader(@"CL\" + file).ReadToEnd()); try { program.Build(null, null, null, IntPtr.Zero); } catch (Exception) { var buildLog = program.GetBuildLog(Device); throw new Exception(buildLog); } System.Diagnostics.Debug.WriteLine(program.GetBuildLog(Device)); return(program.CreateKernel(kernelName)); }
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 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) { } }
private void OnProgramBuilt(ComputeProgram program, ComputeDevice device) { var status = program.GetBuildStatus(device); if (status == ComputeProgramBuildStatus.Error) { var log = program.GetBuildLog(device); Console.WriteLine(log); } }
public int ArrayTest(int[,] a1, int[,] b) { Point f; int[,] a = new int[2, 2]; MyPoint[] plist = new MyPoint[100000]; MyPoint p1 = new MyPoint() { X = 1, Y = 1 }; MyPoint p2 = new MyPoint() { X = 2, Y = 2 }; plist[0] = p1; plist[1] = p2; IntPtr dataaddr_a = Marshal.UnsafeAddrOfPinnedArrayElement(plist, 0); ComputeBuffer <MyPoint> abuffer = new ComputeBuffer <MyPoint>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, plist); string source = Encoding.ASCII.GetString(FZYK.Nest.Properties.Resources.nest); 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("Sum"); ComputeBuffer <MyPoint> outdata = new ComputeBuffer <MyPoint>(context, ComputeMemoryFlags.ReadWrite, plist.Length); kernel.SetMemoryArgument(0, abuffer); kernel.SetMemoryArgument(1, outdata); commands.Execute(kernel, null, new long[] { 2 }, null, events); MyPoint[] myresult = new MyPoint[2]; GCHandle arrCHandle = GCHandle.Alloc(myresult, GCHandleType.Pinned); commands.Read(outdata, true, 0, 2, arrCHandle.AddrOfPinnedObject(), events); MyPoint[] test = myresult; arrCHandle.Free(); return(0); }
static void Main(string[] args) { int w = 11, h = 11, sx = 5, sy = 5, iters = 2; var properties = new ComputeContextPropertyList(ComputePlatform.Platforms[0]); var context = new ComputeContext(ComputeDeviceTypes.All, properties, null, IntPtr.Zero); var quene = new ComputeCommandQueue(context, ComputePlatform.Platforms[0].Devices[0], ComputeCommandQueueFlags.None); //Компиляция программы var prog = new ComputeProgram(context, Source); try { prog.Build(context.Devices, "", null, IntPtr.Zero); } catch { Console.WriteLine(prog.GetBuildLog(context.Devices[0])); } //Создание ядра var kernel = prog.CreateKernel("Test"); var mat = new float[w * h]; for (int i = 0; i < w * h; i++) { mat[i] = (i == w * sy + sx) ? 1f : 0f; } var mat1 = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, mat); var mat2 = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadWrite, w * h); kernel.SetMemoryArgument(0, mat1); kernel.SetMemoryArgument(1, mat2); kernel.SetValueArgument(2, iters); kernel.SetValueArgument(3, w); kernel.SetValueArgument(4, h); quene.Execute(kernel, null, new long[] { (long)h, (long)w }, null, null); quene.ReadFromBuffer(mat1, ref mat, true, null); for (int i = 0; i < h; i++) { for (int j = 0; j < w; j++) { Console.Write($"{mat[i*w+j]:.00} "); } Console.WriteLine(); } Console.ReadKey(); }
private static ComputeKernel GetKernel(ComputeProgram program) { try { return(program.CreateKernel("place")); } catch { string log = program.GetBuildLog(program.Context.Platform.Devices[0]); Console.WriteLine(log); throw; } }
private Tuple <TFP[], TFP[]> Compute(int imageWidth, int imageHeight, int unit, float originx, float originy, string funcCode, string funcdxCode, string funcdyCode) { int w = imageWidth - 2; int h = imageHeight - 2; int cx = imageWidth / 2; int cy = imageHeight / 2; int bufferSize = w * h; ComputeBuffer <TFP> points = new ComputeBuffer <TFP>(context, ComputeMemoryFlags.WriteOnly, bufferSize); string source = Encoding.ASCII.GetString(Properties.Resources.function_vis); source = source.Replace("{func}", funcCode); source = source.Replace("{dfuncdx}", funcdxCode); source = source.Replace("{dfuncdy}", funcdyCode); 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 kernelx = program.CreateKernel("ComputeX"); ComputeKernel kernely = program.CreateKernel("ComputeY"); TFP[] pointsArrayX = RunKernal(unit, w, h, cx, cy, originx, originy, bufferSize, points, kernelx); TFP[] pointsArrayY = RunKernal(unit, w, h, cx, cy, originx, originy, bufferSize, points, kernely); kernelx.Dispose(); kernely.Dispose(); program.Dispose(); points.Dispose(); return(Tuple.Create(pointsArrayX, pointsArrayY)); }
/// <summary> /// Called when the window has finished loading. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param> /// Initialises the OpenCL parts that can be cached and re-used. Compiles the kernels and sets up the larger data storage /// properties. private void WindowLoaded(object sender, RoutedEventArgs e) { platformList = ComputePlatform.Platforms; context = new ComputeContext(ComputeDeviceTypes.Gpu, new ComputeContextPropertyList(platformList[0]), null, IntPtr.Zero); var code = File.ReadAllText(@"D:\Users\Tony\Documents\tr-robot-football\Simulator\field_kernel.cl"); using (var program = new ComputeProgram(context, code)) { try { program.Build(context.Devices, null, null, IntPtr.Zero); } catch (BuildProgramFailureComputeException) { var s = program.GetBuildLog(context.Devices[0]); MessageBox.Show(s); Close(); } kernel = program.CreateKernel("main"); possessionKernel = program.CreateKernel("possessionMain"); colourKernel = program.CreateKernel("colorize"); gradientKernel = program.CreateKernel("calculateGradient"); } gridWidth = (int)Math.Ceiling(FieldWidth / GridResolution); var remainder = gridWidth % WorkGroupSize; gridWidth += WorkGroupSize - remainder; gridHeight = (int)Math.Ceiling(FieldHeight / GridResolution); remainder = gridHeight % WorkGroupSize; gridHeight += WorkGroupSize - remainder; var length = gridWidth * gridHeight; points = new float[length]; pixels = new byte[length * 3]; gradientPoints = new float[length]; outCl = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadWrite, points.Length); outPix = new ComputeBuffer <byte>(context, ComputeMemoryFlags.WriteOnly, pixels.Length); outGradient = new ComputeBuffer <float>(context, ComputeMemoryFlags.ReadWrite, gradientPoints.Length); pipeServer = new NamedPipeServerStream("fieldRendererPipe", PipeDirection.InOut, 5, PipeTransmissionMode.Message, PipeOptions.Asynchronous); pipeServer.BeginWaitForConnection(EnvironmentReceived, null); }
/// <summary> /// Creates the kernels. /// </summary> /// <param name="name">The name.</param> /// <param name="code">The code.</param> /// <exception cref="CompileException"></exception> private void CreateKernels(string code) { var program = new ComputeProgram(_context, code); try { program.Build(null, null, null, IntPtr.Zero); _compiledKernels.AddRange(program.CreateAllKernels()); } catch (Exception ex) { string log = program.GetBuildLog(_defaultDevice); throw new CompileException(string.Format("Compilation error code: {0} \n Message: {1}", ex.Message, log)); } }
public void LoadKernel(string Kernel) { this.kernel = Kernel; program = new ComputeProgram(context, Kernel); try { program.Build(null, null, null, IntPtr.Zero); //compile } catch (BuildProgramFailureComputeException) { string message = program.GetBuildLog(Accelerator.Device); throw new ArgumentException(message); } }
/// <summary> /// Compiles the OpenCL program on a given platform /// </summary> /// <param name="platform">The platform to run this program on</param> public void Compile(ComputePlatform platform) { if (context != null) { return; } // Creating context on platform context = new ComputeContext(ComputeDeviceTypes.All, new ComputeContextPropertyList(platform), null, IntPtr.Zero); // CPU Fallback? // Reading the static source file string include = Resources.noise; // Stub string stub = @" __kernel void cl_main(__global Single3 *input, __global int *perm, __global float *output) { int index = get_global_id(0); Single3 in_pos = input[index]; output[index] = " + module.Code + @"; } __kernel void cl_main_range(ImplicitCube cube, __global int *perm, __global float *output) { int index = cube.lengthY * cube.lengthX * get_global_id(2) + cube.lengthX * get_global_id(1) + get_global_id(0); Single3 in_pos = { cube.startX + get_global_id(0) * cube.offsetX, cube.startY + get_global_id(1) * cube.offsetY, cube.startZ + get_global_id(2) * cube.offsetZ }; output[index] = " + module.Code + @"; }"; completeSource = include + stub; ComputeProgram program = new ComputeProgram(context, completeSource); try { program.Build(context.Platform.Devices, null, null, IntPtr.Zero); } catch { // TODO: Replace this nasty exception re-throwing throw new Exception(program.GetBuildLog(program.Devices[0])); } kernelExplicit = program.CreateKernel("cl_main"); kernelImplicit = program.CreateKernel("cl_main_range"); setupPermutationBuffer(); queue = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None); }