public Mandelbrot( Platform platform, int width, int height ) { openCLPlatform = platform; openCLDevices = openCLPlatform.QueryDevices(DeviceType.ALL); openCLContext = openCLPlatform.CreateDefaultContext(); openCLCQ = openCLContext.CreateCommandQueue(openCLDevices[0], CommandQueueProperties.PROFILING_ENABLE); mandelBrotProgram = openCLContext.CreateProgramWithSource(File.ReadAllText("Mandelbrot.cl")); try { mandelBrotProgram.Build(); } catch (OpenCLException) { string buildLog = mandelBrotProgram.GetBuildLog(openCLDevices[0]); MessageBox.Show(buildLog,"Build error(64 bit debug sessions in vs2008 always fail like this - debug in 32 bit or use vs2010)"); Application.Exit(); } mandelbrotKernel = mandelBrotProgram.CreateKernel("Mandelbrot"); Left = -2.0f; Top = 2.0f; Right = 2.0f; Bottom = -2.0f; BitmapWidth = width; BitmapHeight = height; mandelbrotMemBuffer = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.WRITE_ONLY), width*height*4, IntPtr.Zero); }
public void Initialize(int index) { // Query Devices, create a Context+Command Queue and compile a program context = devices[index].Platform.CreateDefaultContext(); queue = context.CreateCommandQueue(devices[index], CommandQueueProperties.PROFILING_ENABLE); Console.WriteLine(devices[index].Vendor + " " + devices[index].Name); // Load and build source+create a kernel OpenCLNet.Program programForTimeSeries = context.CreateProgramWithSource(processTimeSeriesSource); try { programForTimeSeries.Build(); } catch { Console.WriteLine(programForTimeSeries.GetBuildLog(devices[index])); } kernelForTimeSeries = programForTimeSeries.CreateKernel("KernelFunction"); OpenCLNet.Program programForDataSets = context.CreateProgramWithSource(processDataSetSource); try { programForDataSets.Build(); } catch { Console.WriteLine(programForDataSets.GetBuildLog(devices[index])); } kernelForDataSets = programForDataSets.CreateKernel("KernelFunction"); selectedDevice = index; workGroupSize = (int)devices[index].MaxWorkGroupSize; }
/// <summary> /// Create a OpenCLManager, configure it, and then create a context using all devices in platform 0, /// Once the context is up and running we compile our source file "OpenCLFunctions.cl" /// The Helper automatically compiles and creates kernels. /// We can then extract named kernels using the GetKernel method. /// /// For more advanced scenarios, one might use the functions in the Platform class /// to query devices, create contexts etc. Platforms can be enumerated using /// for( int i=0; i<OpenCL.NumberofPlatforms; i++ ) /// Platform p = OpenCL.GetPlatform(i); /// </summary> private void InitializeOpenCL() { if (OpenCL.NumberOfPlatforms == 0) { MessageBox.Show("OpenCL not available"); Application.Exit(); } OCLMan = new OpenCLManager(); // Attempt to save binaries after compilation, as well as load precompiled binaries // to avoid compilation. Usually you'll want this to be true. OCLMan.AttemptUseBinaries = true; // Attempt to compile sources. This should probably be true for almost all projects. // Setting it to false means that when you attempt to compile "mysource.cl", it will // only scan the precompiled binary directory for a binary corresponding to a source // with that name. There's a further restriction that the compiled binary also has to // use the same Defines and BuildOptions OCLMan.AttemptUseSource = true; // Binary and source paths // This is where we store our sources and where compiled binaries are placed OCLMan.BinaryPath = @"OpenCL\bin"; OCLMan.SourcePath = @"OpenCL\src"; // If true, RequireImageSupport will filter out any devices without image support // In this project we don't need image support though, so we set it to false OCLMan.RequireImageSupport = false; // The Defines string gets prepended to any and all sources that are compiled // and serve as a convenient way to pass configuration information to the compilation process OCLMan.Defines = "#define MyCompany_MyProject_Define 1"; // The BuildOptions string is passed directly to clBuild and can be used to do debug builds etc OCLMan.BuildOptions = ""; OCLMan.CreateDefaultContext(0, DeviceType.ALL); OCLProgram = OCLMan.CompileFile("OpenCLFunctions.cl"); for (int i = 0; i < OCLMan.Context.Devices.Length; i++) { comboBoxDeviceSelector.Items.Add(OCLMan.Context.Devices[i].Vendor + ":" + OCLMan.Context.Devices[i].Name); } comboBoxDeviceSelector.SelectedIndex = 0; CrossFadeKernel = OCLProgram.CreateKernel("CrossFade"); }
private void InitializeOpenCL() { if (OpenCL.NumberOfPlatforms == 0) { MessageBox.Show("OpenCL не поддерживается вашей системой!"); Application.Exit(); } manager = new OpenCLManager(); manager.AttemptUseBinaries = true; manager.AttemptUseSource = true; manager.RequireImageSupport = false; manager.BuildOptions = ""; manager.CreateDefaultContext(0, DeviceType.ALL); // Компиляция OpenCL кода program = manager.CompileSource(Properties.Resources.DVR); kernel = program.CreateKernel("DVR"); }
public void BuildOCLSource(string source) { oclProgram = oclContext.CreateProgramWithSource(source); oclProgram.Build(); FilterKernel = oclProgram.CreateKernel("FilterImage"); }
private void InitializeOpenCL() { if (OpenCL.NumberOfPlatforms == 0) { MessageBox.Show("OpenCL не поддерживается вашей системой!"); Application.Exit(); } manager = new OpenCLManager(); manager.AttemptUseBinaries = true; manager.AttemptUseSource = true; manager.RequireImageSupport = false; manager.BuildOptions = ""; manager.CreateDefaultContext(0, DeviceType.ALL); // Компиляция OpenCL кода program = manager.CompileSource(Properties.Resources.DVR); kernel = program.CreateKernel("DVR"); }
unsafe public FLACCLTask(Program _openCLProgram, int channelsCount, int channels, uint bits_per_sample, int max_frame_size, FLACCLWriter writer, int groupSize, bool gpuOnly, bool gpuRice) { this.UseGPUOnly = gpuOnly; this.UseGPURice = gpuOnly && gpuRice; this.UseMappedMemory = writer._settings.MappedMemory || writer._settings.DeviceType == OpenCLDeviceType.CPU; this.groupSize = groupSize; this.channels = channels; this.channelsCount = channelsCount; this.writer = writer; openCLProgram = _openCLProgram; #if DEBUG var prop = CommandQueueProperties.PROFILING_ENABLE; #else var prop = CommandQueueProperties.NONE; #endif openCLCQ = openCLProgram.Context.CreateCommandQueue(openCLProgram.Context.Devices[0], prop); int MAX_ORDER = this.writer.eparams.max_prediction_order; int MAX_FRAMES = this.writer.framesPerTask; int MAX_CHANNELSIZE = MAX_FRAMES * ((writer.eparams.block_size + 3) & ~3); residualTasksLen = sizeof(FLACCLSubframeTask) * 32 * channelsCount * MAX_FRAMES; bestResidualTasksLen = sizeof(FLACCLSubframeTask) * channels * MAX_FRAMES; int samplesBufferLen = writer.PCM.BlockAlign * MAX_CHANNELSIZE * channelsCount; int residualBufferLen = sizeof(int) * MAX_CHANNELSIZE * channels; // need to adjust residualOffset? int partitionsLen = sizeof(int) * ((writer.PCM.BitsPerSample > 16 ? 31 : 15) * 2 << 8) * channels * MAX_FRAMES; int riceParamsLen = sizeof(int) * (4 << 8) * channels * MAX_FRAMES; int autocorLen = sizeof(float) * (MAX_ORDER + 1) * lpc.MAX_LPC_WINDOWS * channelsCount * MAX_FRAMES; int lpcDataLen = autocorLen * 32; int resOutLen = sizeof(int) * channelsCount * (lpc.MAX_LPC_WINDOWS * lpc.MAX_LPC_ORDER + 8) * MAX_FRAMES; int wndLen = sizeof(float) * MAX_CHANNELSIZE /** 2*/ * lpc.MAX_LPC_WINDOWS; int selectedLen = sizeof(int) * 32 * channelsCount * MAX_FRAMES; int riceLen = sizeof(int) * channels * MAX_CHANNELSIZE; if (!this.UseMappedMemory) { clSamplesBytes = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, samplesBufferLen / 2); clResidual = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, residualBufferLen); clBestRiceParams = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, riceParamsLen / 4); clResidualTasks = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, residualTasksLen); clBestResidualTasks = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, bestResidualTasksLen); clWindowFunctions = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, wndLen); clSelectedTasks = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, selectedLen); clRiceOutput = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, riceLen); clSamplesBytesPinned = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, samplesBufferLen / 2); clResidualPinned = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, residualBufferLen); clBestRiceParamsPinned = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, riceParamsLen / 4); clResidualTasksPinned = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, residualTasksLen); clBestResidualTasksPinned = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, bestResidualTasksLen); clWindowFunctionsPinned = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, wndLen); clSelectedTasksPinned = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, selectedLen); clRiceOutputPinned = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, riceLen); clSamplesBytesPtr = openCLCQ.EnqueueMapBuffer(clSamplesBytesPinned, true, MapFlags.READ_WRITE, 0, samplesBufferLen / 2); clResidualPtr = openCLCQ.EnqueueMapBuffer(clResidualPinned, true, MapFlags.READ_WRITE, 0, residualBufferLen); clBestRiceParamsPtr = openCLCQ.EnqueueMapBuffer(clBestRiceParamsPinned, true, MapFlags.READ_WRITE, 0, riceParamsLen / 4); clResidualTasksPtr = openCLCQ.EnqueueMapBuffer(clResidualTasksPinned, true, MapFlags.READ_WRITE, 0, residualTasksLen); clBestResidualTasksPtr = openCLCQ.EnqueueMapBuffer(clBestResidualTasksPinned, true, MapFlags.READ_WRITE, 0, bestResidualTasksLen); clWindowFunctionsPtr = openCLCQ.EnqueueMapBuffer(clWindowFunctionsPinned, true, MapFlags.READ_WRITE, 0, wndLen); clSelectedTasksPtr = openCLCQ.EnqueueMapBuffer(clSelectedTasksPinned, true, MapFlags.READ_WRITE, 0, selectedLen); clRiceOutputPtr = openCLCQ.EnqueueMapBuffer(clRiceOutputPinned, true, MapFlags.READ_WRITE, 0, riceLen); } else { clSamplesBytes = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, (uint)samplesBufferLen / 2); clResidual = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, residualBufferLen); clBestRiceParams = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, riceParamsLen / 4); clResidualTasks = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, residualTasksLen); clBestResidualTasks = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, bestResidualTasksLen); clWindowFunctions = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, wndLen); clSelectedTasks = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, selectedLen); clRiceOutput = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE | MemFlags.ALLOC_HOST_PTR, riceLen); clSamplesBytesPtr = openCLCQ.EnqueueMapBuffer(clSamplesBytes, true, MapFlags.READ_WRITE, 0, samplesBufferLen / 2); clResidualPtr = openCLCQ.EnqueueMapBuffer(clResidual, true, MapFlags.READ_WRITE, 0, residualBufferLen); clBestRiceParamsPtr = openCLCQ.EnqueueMapBuffer(clBestRiceParams, true, MapFlags.READ_WRITE, 0, riceParamsLen / 4); clResidualTasksPtr = openCLCQ.EnqueueMapBuffer(clResidualTasks, true, MapFlags.READ_WRITE, 0, residualTasksLen); clBestResidualTasksPtr = openCLCQ.EnqueueMapBuffer(clBestResidualTasks, true, MapFlags.READ_WRITE, 0, bestResidualTasksLen); clWindowFunctionsPtr = openCLCQ.EnqueueMapBuffer(clWindowFunctions, true, MapFlags.READ_WRITE, 0, wndLen); clSelectedTasksPtr = openCLCQ.EnqueueMapBuffer(clSelectedTasks, true, MapFlags.READ_WRITE, 0, selectedLen); clRiceOutputPtr = openCLCQ.EnqueueMapBuffer(clRiceOutput, true, MapFlags.READ_WRITE, 0, riceLen); //clSamplesBytesPtr = clSamplesBytes.HostPtr; //clResidualPtr = clResidual.HostPtr; //clBestRiceParamsPtr = clBestRiceParams.HostPtr; //clResidualTasksPtr = clResidualTasks.HostPtr; //clBestResidualTasksPtr = clBestResidualTasks.HostPtr; //clWindowFunctionsPtr = clWindowFunctions.HostPtr; } clSamples = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, samplesBufferLen); clLPCData = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, lpcDataLen); clAutocorOutput = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, autocorLen); clSelectedTasksSecondEstimate = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, selectedLen); clSelectedTasksBestMethod = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, selectedLen); if (UseGPUOnly) { clPartitions = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, partitionsLen); clRiceParams = openCLProgram.Context.CreateBuffer(MemFlags.READ_WRITE, riceParamsLen); } //openCLCQ.EnqueueMapBuffer(clSamplesBytes, true, MapFlags.WRITE, 0, samplesBufferLen / 2); clComputeAutocor = openCLProgram.CreateKernel("clComputeAutocor"); clStereoDecorr = openCLProgram.CreateKernel("clStereoDecorr"); //cudaChannelDecorr = openCLProgram.CreateKernel("clChannelDecorr"); clChannelDecorr2 = openCLProgram.CreateKernel("clChannelDecorr2"); clChannelDecorrX = openCLProgram.CreateKernel("clChannelDecorrX"); clFindWastedBits = openCLProgram.CreateKernel("clFindWastedBits"); clComputeLPC = openCLProgram.CreateKernel("clComputeLPC"); clQuantizeLPC = openCLProgram.CreateKernel("clQuantizeLPC"); //cudaComputeLPCLattice = openCLProgram.CreateKernel("clComputeLPCLattice"); clSelectStereoTasks = openCLProgram.CreateKernel("clSelectStereoTasks"); clEstimateResidual = openCLProgram.CreateKernel("clEstimateResidual"); clChooseBestMethod = openCLProgram.CreateKernel("clChooseBestMethod"); if (UseGPUOnly) { clEncodeResidual = openCLProgram.CreateKernel("clEncodeResidual"); if (openCLCQ.Device.DeviceType != DeviceType.CPU) { clCalcPartition = openCLProgram.CreateKernel("clCalcPartition"); clCalcPartition16 = openCLProgram.CreateKernel("clCalcPartition16"); } clSumPartition = openCLProgram.CreateKernel("clSumPartition"); clFindRiceParameter = openCLProgram.CreateKernel("clFindRiceParameter"); clFindPartitionOrder = openCLProgram.CreateKernel("clFindPartitionOrder"); if (UseGPURice) { clCalcOutputOffsets = openCLProgram.CreateKernel("clCalcOutputOffsets"); clRiceEncoding = openCLProgram.CreateKernel("clRiceEncoding"); } } samplesBuffer = new int[MAX_CHANNELSIZE * channelsCount]; outputBuffer = new byte[max_frame_size * MAX_FRAMES + 1]; frame = new FlacFrame(channelsCount); frame.writer = new BitWriter(outputBuffer, 0, outputBuffer.Length); if (writer._settings.DoVerify) { verify = new FlakeReader(new AudioPCMConfig((int)bits_per_sample, channels, 44100)); verify.DoCRC = false; } }
public Core(int Nxp,int Nyp, int Nzp, int Ntm, double Bbeta, double Flux) { Nx = Nxp; Ny = Nyp; Nz = Nzp; Nt = Ntm; betagauge = (floattype)Bbeta; flux = (floattype)Flux; N = Nx * Ny * Nz * Nt; Nspace = Nx * Ny * Nz; string strforcompiler = "-D Nt=" + Nt.ToString() + " -D Nxyz=" + (Nx * Ny * Nz).ToString() + " -D Nxy=" + (Nx*Ny).ToString() + " -D Nx="+(Nx).ToString()+" -D Ny="+(Ny).ToString()+" -D Nz="+(Nz).ToString(); strforcompiler += typeof(floattype) == typeof(double) ? " -D floattype=double -D floattype2=double2 -D floattype4=double4" : " -D floattype=float -D floattype2=float2 -D floattype4=float4"; strforcompiler += " -D phi=" + flux.ToString().Replace(',', '.') + " -D KAPPA=" + kappa.ToString().Replace(',', '.'); string fp64support = "#pragma OPENCL EXTENSION cl_khr_fp64 : enable\n"; Plocalsize = AdjustLocalSize(Nspace); Slocalsize = AdjustLocalSize(N / 2); XhermYlocalsize = AdjustLocalSize(4 * N); // Plocalsize = 16; Slocalsize = 16; PNumGroups = Nx * Ny * Nz / Plocalsize; SNumGroups = N/2 / Slocalsize; XhermYNumGroups = 4*4*N / XhermYlocalsize; BufferLength = N * 4 * 9 * 2 * sizeof(floattype); SeedBufLen = N * sizeof(Int32)/2 * 4; AllocBuffers(); openCLPlatform = OpenCL.GetPlatform(0); openCLDevices = openCLPlatform.QueryDevices(DeviceType.ALL); openCLContext = openCLPlatform.CreateDefaultContext(); openCLCQ = openCLContext.CreateCommandQueue(openCLDevices[0], CommandQueueProperties.PROFILING_ENABLE); MyKernelProgram = openCLContext.CreateProgramWithSource( (typeof(floattype)==typeof(double)?fp64support:"") + File.ReadAllText("MyKernel.cl")+File.ReadAllText("dirak_mul.cl")); try { MyKernelProgram.Build(openCLDevices, strforcompiler, null, IntPtr.Zero); } catch (OpenCLException) { string buildLog = MyKernelProgram.GetBuildLog(openCLDevices[0]); MessageBox.Show(buildLog, "Build error(64 bit debug sessions in vs2008 always fail like this - debug in 32 bit or use vs2010)"); // Application.Exit(); } MyKernelKernel = MyKernelProgram.CreateKernel("MyKernel"); PReductionKernel = MyKernelProgram.CreateKernel("PLoop"); SReductionKernel = MyKernelProgram.CreateKernel("CalcS"); DiralMulKernel = MyKernelProgram.CreateKernel("dirakMatrMul"); FillWithKernel = MyKernelProgram.CreateKernel("FillWith"); FillLinkWithKernel = MyKernelProgram.CreateKernel("FillLinkWith"); FillWithRandomKernel = MyKernelProgram.CreateKernel("FillWithRandom"); AXPYKernel = MyKernelProgram.CreateKernel("AXPY"); XhermYKernel = MyKernelProgram.CreateKernel("XhermY"); BackupLinkKernel = MyKernelProgram.CreateKernel("BackupLink"); RestoreLinkKernel = MyKernelProgram.CreateKernel("RestoreLink"); SeedMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), SeedBufLen, IntPtr.Zero); LinkMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), BufferLength, IntPtr.Zero); PGroupMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), floatsize * PNumGroups, IntPtr.Zero); PResMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), floatsize, IntPtr.Zero); SGroupMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), floatsize * SNumGroups, IntPtr.Zero); SResMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), floatsize, IntPtr.Zero); XhermYGroupMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), floatsize * 2*XhermYNumGroups, IntPtr.Zero); XhermYresMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), floatsize * 2, IntPtr.Zero); XhermYrespointer = System.Runtime.InteropServices.Marshal.AllocHGlobal(floatsize * 2); SeedVectorMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), SeedVectorBuf.Length * sizeof(int), IntPtr.Zero); StorageMem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), linksize, IntPtr.Zero); dSmem = openCLContext.CreateBuffer((MemFlags)((long)MemFlags.READ_WRITE), floatsize, IntPtr.Zero); dSpointer = System.Runtime.InteropServices.Marshal.AllocHGlobal(floatsize); MyKernelKernel.SetArg(0, (byte)EvenOdd); MyKernelKernel.SetArg(1, (floattype)betagauge); MyKernelKernel.SetArg(2, (floattype)flux); MyKernelKernel.SetArg(3, SeedMem); MyKernelKernel.SetArg(4, LinkMem); PReductionKernel.SetArg(0, LinkMem); PReductionKernel.SetArg(1, PGroupMem); PReductionKernel.SetArg(2, PResMem); IntPtr ptr = new IntPtr(Plocalsize * floatsize); PReductionKernel.SetArg(3, ptr, IntPtr.Zero); SReductionKernel.SetArg(0, LinkMem); SReductionKernel.SetArg(1, SGroupMem); SReductionKernel.SetArg(2, SResMem); IntPtr ptr1 = new IntPtr(Slocalsize * floatsize); SReductionKernel.SetArg(3, ptr1, IntPtr.Zero); XhermYKernel.SetArg(2, XhermYresMem); XhermYKernel.SetArg(3, XhermYGroupMem); XhermYKernel.SetArg(4, new IntPtr(XhermYlocalsize*floatsize*2),IntPtr.Zero); openCLCQ.EnqueueWriteBuffer(SeedMem, true, 0, SeedBufLen, ipseed); openCLCQ.EnqueueWriteBuffer(LinkMem, true, 0, BufferLength, ip); openCLCQ.EnqueueWriteBuffer(SeedVectorMem, true, 0, SeedVectorBuf.Length*sizeof(int), ipseedvector); rhat0 = new Vector(); //init BICGStab vectors phi = new Vector(); r0 = new Vector(); //rprev = new Vector(); pi = new Vector(); vi = new Vector(); t = new Vector(); s = new Vector(); // xprev = new Vector(); // vprev = new Vector(); // pprev = new Vector(); temp = new Vector(); ri = new Vector(); x = new Vector(); //for fermion update chi = new Vector(); CalculateS(); double s1 = S[0]; BackupLink(0, 0,1, 0, 1); CalculateS(); double s2 = S[0]; RestoreLink(0, 0, 1, 0, 1); CalculateS(); double s3 = S[0]; //MessageBox.Show(s1.ToString() + s2.ToString() + s3.ToString()); }
private void InitializeOpenCL() { if (OpenCL.NumberOfPlatforms == 0){ MessageBox.Show("OpenCL is not supported on your system!"); Application.Exit(); } manager = new OpenCLManager(); manager.AttemptUseBinaries = true; manager.AttemptUseSource = true; manager.RequireImageSupport = false; manager.BuildOptions = ""; manager.CreateDefaultContext(0, DeviceType.ALL); // Compiling OpenCL code program = manager.CompileSource(Properties.Resources.DVR); kernel = program.CreateKernel("DVR"); }
public void BuildOCLSource(string source) { oclProgram = oclContext.CreateProgramWithSource(source); oclProgram.Build(); FilterKernel = oclProgram.CreateKernel("FilterImage"); }
/// <summary> /// Create a OpenCLManager, configure it, and then create a context using all devices in platform 0, /// Once the context is up and running we compile our source file "OpenCLFunctions.cl" /// The Helper automatically compiles and creates kernels. /// We can then extract named kernels using the GetKernel method. /// /// For more advanced scenarios, one might use the functions in the Platform class /// to query devices, create contexts etc. Platforms can be enumerated using /// for( int i=0; i<OpenCL.NumberofPlatforms; i++ ) /// Platform p = OpenCL.GetPlatform(i); /// </summary> private void InitializeOpenCL() { if (OpenCL.NumberOfPlatforms == 0) { MessageBox.Show("OpenCL not available"); Application.Exit(); } OCLMan = new OpenCLManager(); // Attempt to save binaries after compilation, as well as load precompiled binaries // to avoid compilation. Usually you'll want this to be true. OCLMan.AttemptUseBinaries = true; // Attempt to compile sources. This should probably be true for almost all projects. // Setting it to false means that when you attempt to compile "mysource.cl", it will // only scan the precompiled binary directory for a binary corresponding to a source // with that name. There's a further restriction that the compiled binary also has to // use the same Defines and BuildOptions OCLMan.AttemptUseSource = true; // Binary and source paths // This is where we store our sources and where compiled binaries are placed OCLMan.BinaryPath = @"OpenCL\bin"; OCLMan.SourcePath = @"OpenCL\src"; // If true, RequireImageSupport will filter out any devices without image support // In this project we don't need image support though, so we set it to false OCLMan.RequireImageSupport = false; // The Defines string gets prepended to any and all sources that are compiled // and serve as a convenient way to pass configuration information to the compilation process OCLMan.Defines = "#define MyCompany_MyProject_Define 1"; // The BuildOptions string is passed directly to clBuild and can be used to do debug builds etc OCLMan.BuildOptions = ""; OCLMan.CreateDefaultContext(0, DeviceType.ALL); OCLProgram = OCLMan.CompileFile("OpenCLFunctions.cl"); for (int i = 0; i < OCLMan.Context.Devices.Length; i++) comboBoxDeviceSelector.Items.Add(OCLMan.Context.Devices[i].Vendor+":"+OCLMan.Context.Devices[i].Name); comboBoxDeviceSelector.SelectedIndex = 0; CrossFadeKernel = OCLProgram.CreateKernel("CrossFade"); }
static void Main(string[] args) { for (int i = 0; i < OpenCL.NumberOfPlatforms; ++i) { Platform clPlatformTemp = OpenCL.GetPlatform(i); Console.WriteLine("Platform {0} -> {1}, {2}", i, clPlatformTemp.Vendor, clPlatformTemp.Name); Device[] clDevicesTemp = clPlatformTemp.QueryDevices(DeviceType.ALL); foreach (Device clDeviceTemp in clDevicesTemp) { Console.WriteLine("-----> {0}, {1}, {2} Bytes, {3}", clDeviceTemp.Name, clDeviceTemp.DeviceType, clDeviceTemp.GlobalMemSize, clDeviceTemp.OpenCL_C_Version); } } Platform clPlatform = null; Device clDevice = null; for (int i = 0; i < OpenCL.NumberOfPlatforms; ++i) { clPlatform = OpenCL.GetPlatform(i); if (!clPlatform.Name.Contains("AMD") && !clPlatform.Name.Contains("NVIDIA") && !clPlatform.Name.Contains("INTEL")) { continue; } Device[] clDevices = clPlatform.QueryDevices(DeviceType.GPU); clDevice = clDevices[0]; break; } Console.WriteLine(); Context clContext = null; clContext = clPlatform.CreateDefaultContext(); CommandQueue clCommandQueue = null; clCommandQueue = clContext.CreateCommandQueue(clDevice, CommandQueueProperties.NONE); int[] ArrayA = { 1, 2 }; int[] ArrayB = { 2, 3 }; int[] ArrayC = new int[2]; int N = 100; float[] array = new float[N]; for (int i = 0; i < N; ++i) { array[i] = 1.0f * i / N; } GCHandle arrayHandle; arrayHandle = GCHandle.Alloc(array, GCHandleType.Pinned); GCHandle ArrayAHandle; ArrayAHandle = GCHandle.Alloc(array, GCHandleType.Pinned); GCHandle ArrayBHandle; ArrayBHandle = GCHandle.Alloc(array, GCHandleType.Pinned); GCHandle ArrayCHandle; ArrayCHandle = GCHandle.Alloc(array, GCHandleType.Pinned); Mem arrayBuffer = null; arrayBuffer = clContext.CreateBuffer(MemFlags.COPY_HOST_PTR, array.Length * sizeof(float), arrayHandle.AddrOfPinnedObject()); Mem ArrayABuffer = null; ArrayABuffer = clContext.CreateBuffer(MemFlags.COPY_HOST_PTR, ArrayA.Length * sizeof(int), ArrayAHandle.AddrOfPinnedObject()); Mem ArrayBBuffer = null; ArrayBBuffer = clContext.CreateBuffer(MemFlags.COPY_HOST_PTR, ArrayB.Length * sizeof(int), ArrayBHandle.AddrOfPinnedObject()); Mem ArrayCBuffer = null; ArrayCBuffer = clContext.CreateBuffer(MemFlags.COPY_HOST_PTR, ArrayC.Length * sizeof(int), ArrayCHandle.AddrOfPinnedObject()); //cos clCommandQueue.EnqueueReadBuffer(arrayBuffer, true, 0, array.Length * sizeof(float), arrayHandle.AddrOfPinnedObject()); OpenCLNet.Program clProgram = null; clProgram = clContext.CreateProgramWithSource(File.ReadAllText("openCLkernels.cl")); clProgram.Build(); Kernel clKernel = null; clKernel = clProgram.CreateKernel("Multiply"); clKernel.SetArg(0, arrayBuffer); clKernel.SetArg(1, 25); Kernel clKernel2 = null; clKernel2 = clProgram.CreateKernel("Add"); clKernel2.SetArg(0, ArrayABuffer); clKernel2.SetArg(1, ArrayBBuffer); clKernel2.SetArg(2, ArrayCBuffer); clCommandQueue.EnqueueNDRangeKernel(clKernel, 1, null, new int[] { N }, null); clCommandQueue.EnqueueReadBuffer(arrayBuffer, true, 0, array.Length * sizeof(float), arrayHandle.AddrOfPinnedObject()); clCommandQueue.EnqueueNDRangeKernel(clKernel2, 1, null, new int[] { 2 }, null); clCommandQueue.EnqueueReadBuffer(ArrayABuffer, true, 0, ArrayA.Length * sizeof(int), ArrayAHandle.AddrOfPinnedObject()); clCommandQueue.EnqueueReadBuffer(ArrayBBuffer, true, 0, ArrayB.Length * sizeof(int), ArrayBHandle.AddrOfPinnedObject()); clCommandQueue.EnqueueReadBuffer(ArrayCBuffer, true, 0, ArrayC.Length * sizeof(int), ArrayCHandle.AddrOfPinnedObject()); // for (int i = 0; i < N; ++i) // Console.Write("{0} ", array[i]); Console.WriteLine(); Console.WriteLine(); for (int i = 0; i < 2; i++) { Console.WriteLine("{0}", ArrayC[i]); } }