static void Main() { //Initializes OpenCL Platforms and Devices and sets everything up CLCalc.InitCL(); //Create vectors with 2000 numbers float[] v1 = new float[n], v2 = new float[n]; var vResult = new float[n]; //Creates population for v1 and v2 for (int i = 0; i < n; i++) { v1[i] = (float)i / 10; v2[i] = -(float)i / 9; } //var prog = new ComputeProgram(CLCalc.Program.Context, ""); //Compiles the source codes. The source is a string array because the user may want //to split the source into many strings. CLCalc.Program.Compile(new string[] { vecSum }); //Gets host access to the OpenCL floatVectorSum kernel CLCalc.Program.Kernel VectorSum = new CLCalc.Program.Kernel("floatVectorSum"); //Creates vectors v1 and v2 in the device memory CLCalc.Program.Variable varV1 = new CLCalc.Program.Variable(v1); CLCalc.Program.Variable varV2 = new CLCalc.Program.Variable(v2); //Arguments of VectorSum kernel CLCalc.Program.Variable[] args = new CLCalc.Program.Variable[] { varV1, varV2 }; //How many workers will there be? We need "n", one for each element int[] workers = new int[1] { n }; sw.Start(); //Execute the kernel for (int i = 0; i < count; i++) DoOCL(VectorSum, args, workers); sw.Stop(); //Read device memory varV1 to host memory vResult varV1.ReadFromDeviceTo(vResult); Console.WriteLine("OpenCL: {0}", sw.ElapsedTicks); sw.Restart(); for (int i = 0; i < count; i++) DoCPU(v1, v2, vResult); sw.Stop(); Console.WriteLine("CPU: {0}", sw.ElapsedTicks); PressAny(); }
/// <summary>Constructor. Initializes OpenCL</summary> public CLMatrixMult() { if (CLCalc.GLAcceleration == CLCalc.GLAccelerationType.Unknown) CLCalc.InitCL(); //Using OpenCL, declare variables if (CLCalc.GLAcceleration == CLCalc.GLAccelerationType.UsingGL) { floatMatrixMultSource src = new floatMatrixMultSource(); CLCalc.Program.Compile(new string[] { src.matrixMultLocals, src.matrixMultNoLocals }); //multiplication floatMatrixMultNoLocals = new CLCalc.Program.Kernel("floatMatrixMult"); floatMatrixMultLocals = new CLCalc.Program.Kernel("floatMatrixMultLocals"); } }
/// <summary>Initializes class</summary> private static void Init(int FilterSize) { if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.Unknown) CLCalc.InitCL(); //Compiles source code CLCalc.Program.Compile((new CLFilterSrc()).src); //Creates kernel kernelApplyFilter = new CLCalc.Program.Kernel("ApplyFilter"); kernelApplyFilterWorkDim2 = new CLCalc.Program.Kernel("ImgFilter"); //Creates filter varFilter = new CLCalc.Program.Variable(new float[3 * FilterSize * FilterSize]); //Width varWidth = new CLCalc.Program.Variable(new int[1]); Initialized = true; }
/// <summary>Static Constructor. Builds kernels</summary> static SparseLinalg() { if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.Unknown) { try { CLCalc.InitCL(); } catch { } } if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.UsingCL) { //Kernel CLLinalgSrc src = new CLLinalgSrc(); CLCalc.Program.Compile(new string[] { src.srcDotProd, src.srcMatVecMult, src.srcLinConjGrad }); kernelDotProduct = new CLCalc.Program.Kernel("dotProd"); kernelSum = new CLCalc.Program.Kernel("sumDotProd"); kernelGetDotSum = new CLCalc.Program.Kernel("GetResp"); kernelSparseMatrixVecMult = new CLCalc.Program.Kernel("SparseMatrixVecMult"); //Linear solving kernelInitRP = new CLCalc.Program.Kernel("InitRP"); kernelMultiplyAdd = new CLCalc.Program.Kernel("MultiplyAdd"); kernelCopyToTemp = new CLCalc.Program.Kernel("CopyToTemp"); } }
public OpenCLTest() { CLCalc.InitCL(); var buildlogs = new List<string>(); CLCalc.Program.Compile(new[] { run }, out buildlogs); Random r = new Random(); float[] sample = Enumerable.Range(0, 768).Select(x => (float)r.NextDouble() * 2 - 1).ToArray(); float[] hlW = Enumerable.Range(0, 10000 * 769).Select(x => (float)r.NextDouble() * 2 - 1).ToArray(); float[] olW = Enumerable.Range(0, 10001 * 10).Select(x => (float)r.NextDouble() * 2 - 1).ToArray(); float[] hlDest = new float[10000]; float[] olDest = new float[10]; //float[] sample = new[] { .3f, .7f }; //float[] hlW = new[] { .4f, .4f, .1f, .5f, .5f, .7f }; //float[] olW = new[] { .4f, .6f, .8f }; //float[] hlDest = new[] { 0f, 0f }; //float[] olDest = new[] { 0f }; var sw = Stopwatch.StartNew(); var sw2 = Stopwatch.StartNew(); var gSample = sample.ToGraphics(); var ghlW = hlW.ToGraphics(); var golW = olW.ToGraphics(); var ghlDest = hlDest.ToGraphics(); var golDest = olDest.ToGraphics(); sw2.Stop(); var kernel = new CLCalc.Program.Kernel("runNN"); var args = new[] {gSample, new CLCalc.Program.Variable(new[] { sample.Length}), ghlDest, new CLCalc.Program.Variable(new[] { hlDest.Length}), ghlW}; kernel.Execute(args, hlDest.Length); args = new CLCalc.Program.Variable[5]; args[0] = ghlDest; args[1] = new CLCalc.Program.Variable(new[] { hlDest.Length }); args[2] = golDest; args[3] = new CLCalc.Program.Variable(new[] { olDest.Length }); args[4] = golW; kernel.Execute(args, olDest.Length); sw2.Start(); ghlDest.ReadFromDeviceTo(hlDest); golDest.ReadFromDeviceTo(olDest); sw2.Stop(); sw.Stop(); Console.WriteLine("hlDest\n" + string.Join("\n", hlDest)); Console.WriteLine("olDest\n" + string.Join("\n", olDest)); Console.WriteLine("Total {0}ms", sw.ElapsedMilliseconds); Console.WriteLine("Memory {0}ms", sw2.ElapsedMilliseconds); }
/// <summary>Constructor. Builds OpenCL program.</summary> public doubleLinearAlgebra() { if (CLCalc.CLDevices == null) { try { CLCalc.InitCL(); } catch { throw new Exception("Could not initialize OpenCL"); } } try { LinalgSource Source = new LinalgSource(); string[] s = new string[] { Source.dblInclude, Source.vecSum, Source.matrixMult, Source.GaussSeidel, Source.LUDecomp }; CLCalc.Program.Compile(s); //sum doubleVecSum = new Program.Kernel("doubleVectorSum"); //multiplication doubleMatrixMult = new Program.Kernel("doubleMatrixMult"); //Linear system (Gauss Seidel) doubleGaussSeidel = new Program.Kernel("doubleGaussSeidel"); doubleGaussSeidelError = new Program.Kernel("doubleGaussSeidelError"); doubleCalcMtM = new Program.Kernel("doubleCalcMtM"); doubleCalcMtb = new Program.Kernel("doubleCalcMtb"); //Linear system (LU factorization) doubleLUScale = new Program.Kernel("doubleLUScale"); doubleLUCalcBetas = new Program.Kernel("doubleLUCalcBetas"); doubleLUCalcAlphas = new Program.Kernel("doubleLUCalcAlphas"); doubleLUCalcPivo = new Program.Kernel("doubleLUCalcPivo"); doubleLUTrocaCols = new Program.Kernel("doubleLUTrocaCols"); doubleLUDivByPivot = new Program.Kernel("doubleLUDivByPivot"); doubleLUForwardSubs = new Program.Kernel("doubleLUForwardSubs"); doubleLUBackSubs = new Program.Kernel("doubleLUBackSubs"); doubleLUDivide = new Program.Kernel("doubleLUDivide"); doubleLUUnscramble = new Program.Kernel("doubleLUUnscramble"); doubleSolveError = new Program.Kernel("doubleSolveError"); doubleLUSubErr = new Program.Kernel("doubleLUSubErr"); } catch { throw new Exception("Could not compile program"); } }
/// <summary>Constructor.</summary> /// <param name="nMasses">Number of masses in the system</param> /// <param name="nConnections">Number of connections</param> /// <param name="Masses">Mass of each vertex</param> /// <param name="InitialStateSpace">Position and velocity of vertexes /// [2*3*i] - posx, [2*(3*i+1)] - posy, [2*(3*i+2)] - posz, /// [1+2*3*i] - velx, [1+2*(3*i+1)] - vely, [1+2*(3*i+2)] - velz</param> /// <param name="Origins">Origin vertex of connections. Spring connects Origin[i] to Dests[i]</param> /// <param name="Dests">Destination vertex of connections. Spring connects Origin[i] to Dests[i]</param> /// <param name="SpringKs">Spring constant for each connection</param> /// <param name="GroundKs">Spring constant for each mass, connecting to ground (nMass)</param> /// <param name="Damp">Structural damping (relative-speed dependant) (nConnections)</param> /// <param name="GroundDamp">Absolute damping proportional to speed relative to Earth (nMass)</param> public floatDEM(int nMasses, int nConnections, float[] Masses, float[] InitialStateSpace, int[] Origins, int[] Dests, float[] SpringKs, float[] Damp, float[] GroundKs, float[] GroundDamp) { #region Consistency check if (Masses.Length != nMasses) throw new Exception("Invalid Masses length (!=nMasses)"); if (InitialStateSpace.Length != 6 * nMasses) throw new Exception("Invalid positions length (!=6*nMasses - x, y, z)"); if (Origins.Length != nConnections) throw new Exception("Invalid Origins length (!=nConnections)"); if (Dests.Length != nConnections) throw new Exception("Invalid Dests length (!=nConnections)"); if (SpringKs.Length != nConnections) throw new Exception("Invalid SpringKs length (!=nConnections)"); if (GroundKs.Length != nMasses) throw new Exception("Invalid GroundKs length (!=nMasses)"); if (Damp.Length != nConnections) throw new Exception("Invalid Damp length (!=nConnections)"); if (GroundDamp.Length != nMasses) throw new Exception("Invalid GroundDamp length (!=nMasses)"); #endregion if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.Unknown) { CLCalc.InitCL(); } #region Variables reading //Sizes nConn = new int[1] { nConnections }; nM = new int[1] { nMasses }; //Inputs m = new Program.Variable(Masses); float[] InitialPositions = new float[3 * nMasses]; for (int i = 0; i < 3 * nMasses; i++) InitialPositions[i] = InitialStateSpace[2 * i]; posOrig = new Program.Variable(InitialPositions); origs = new Program.Variable(Origins); dests = new Program.Variable(Dests); k = new Program.Variable(SpringKs); kGround = new Program.Variable(GroundKs); c = new Program.Variable(Damp); cGround = new Program.Variable(GroundDamp); //Outputs L0 = new Program.Variable(new float[nConnections]); forces = new Program.Variable(new float[3 * nMasses]); connForces = new Program.Variable(new float[3 * nConnections]); nConnec = new Program.Variable(new int[1] { nConnections }); int[] nodesConnects = new int[30 * nMasses]; for (int i = 0; i < nodesConnects.Length; i++) nodesConnects[i] = -1; nodesConnections = new Program.Variable(nodesConnects); #endregion #region Kernels initialization DEMSource Source = new DEMSource(); string[] s = new string[] { Source.floatcalcL0, Source.floatresetForces, Source.floatcalcForces, Source.floatderivs, Source.floatcalcGroundForces, Source.floatcalcNodesConnections }; CLCalc.Program.Compile(s); KernelcalcL0 = new Program.Kernel("floatcalcL0"); argscalcL0 = new Program.Variable[] { posOrig, origs, dests, L0 }; KernelcalcNodesConnections = new Program.Kernel("floatcalcNodesConnections"); argscalcNodesConnections = new Program.Variable[] { nodesConnections, nConnec, origs, dests }; KernelresetForces = new Program.Kernel("floatresetForces"); argsresetForces = new Program.Variable[] { forces }; KernelcalcForces = new Program.Kernel("floatcalcForces"); KernelcalcGroundForces = new Program.Kernel("floatcalcGroundForces"); Kernelderivs = new Program.Kernel("floatderivs"); #endregion // Initial lengths calculation KernelcalcL0.Execute(argscalcL0, nConn); //Connections calculation KernelcalcNodesConnections.Execute(argscalcNodesConnections, nM); //nodesConnections.ReadFromDeviceTo(nodesConnects); }
public float[] Add(float[] B, int startx, int starty, int startz, int Bx, int By) { float[] start = new float[3] { startx, starty, startz }; float[] size = new float[6] { X, Y, Z, B.GetLength(0), Bx, By }; float[] csResult = new float[X * Y * Z]; /*In order to avoid OOM, will start at the startz value, and pass in one 2D matrix at a time. * */ if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.Unknown) CLCalc.InitCL(); if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.UsingCL) { CLSource source = new CLSource(); CLCalc.Program.Compile(new string[] { source.AddSubset_3string }); Matrix = new CLCalc.Program.Kernel("AddSubset3"); } CLCalc.Program.Variable dev_A = new CLCalc.Program.Variable(M); CLCalc.Program.Variable dev_B = new CLCalc.Program.Variable(B); CLCalc.Program.Variable dev_start = new CLCalc.Program.Variable(start); CLCalc.Program.Variable dev_size = new CLCalc.Program.Variable(size); CLCalc.Program.Variable dev_Result = new CLCalc.Program.Variable(csResult); CLCalc.Program.Variable[] args = new CLCalc.Program.Variable[5] { dev_A, dev_B, dev_start, dev_size, dev_Result }; Matrix.Execute(args, new int[] { X * Y * Z }); dev_Result.ReadFromDeviceTo(csResult); M = csResult; return csResult; }
private static void InitKernels() { string s = new CLFFTSrc().s; CLCalc.InitCL(); try { CLCalc.Program.Compile(s); } catch { } kernelfft_radix16 = new CLCalc.Program.Kernel("fft_radix16"); kernelfft_radix4 = new CLCalc.Program.Kernel("fft_radix4"); kernelConjugate = new CLCalc.Program.Kernel("Conjugate"); CLp = new CLCalc.Program.Variable(new int[1]); }
private void frmCLInfo_Load(object sender, EventArgs e) { CLCalc.InitCL(ComputeDeviceTypes.All); if (CLCalc.CLAcceleration != CLCalc.CLAccelerationType.UsingCL) { cmbPlat.Items.Add("OpenCL ERROR"); if (cmbPlat.Items.Count > 0) cmbPlat.SelectedIndex = 0; } else { foreach(ComputePlatform p in CLCalc.CLPlatforms) { cmbPlat.Items.Add(p.Name + " " + p.Profile + " " + p.Vendor + " " + p.Version); } if (cmbPlat.Items.Count > 0) cmbPlat.SelectedIndex = 0; int i=0; foreach (ComputeDevice d in CLCalc.CLDevices) { //if (d.CLDeviceAvailable) //{ cmbDevices.Items.Add(d.Name + " " + d.Type + " " + d.Vendor + " " + d.Version); cmbCurDevice.Items.Add(d.Name + " " + d.Type + " " + d.Vendor + " " + d.Version); //} //else //{ // cmbDevices.Items.Add("NOT AVAILABLE: " + d.CLDeviceName + " " + d.CLDeviceType + " " + d.CLDeviceVendor + " " + d.CLDeviceVersion); // cmbCurDevice.Items.Add("NOT AVAILABLE: " + d.CLDeviceName + " " + d.CLDeviceType + " " + d.CLDeviceVendor + " " + d.CLDeviceVersion); //} i++; } if (cmbDevices.Items.Count > 0) { cmbDevices.SelectedIndex = 0; cmbCurDevice.SelectedIndex = CLCalc.Program.DefaultCQ; } } ReadImportantRegistryEntries(); //int[] n = new int[3] {1,1,1}; //int[] nn = new int[3]; //CLCalc.Program.Variable v = new CLCalc.Program.Variable(n); //v.WriteToDevice(n); //v.ReadFromDeviceTo(nn); string s = @" kernel void teste() {}"; CLCalc.Program.Compile(s); try { CLCalc.Program.Kernel k = new CLCalc.Program.Kernel("teste"); } catch { MessageBox.Show(""); } }
/// <summary>Compiles code and initializes kernel for this svm stance</summary> private void CLSVMInit() { if (CLResource == null) CLResource = new int[0]; lock (CLResource) { if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.Unknown) CLCalc.InitCL(); if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.UsingCL) { if (kernelComputeKernelRBF == null) { CLSVMSrc s = new CLSVMSrc(); CLCalc.Program.Compile(new string[] { s.srcKernels, s.srcFindMaxMinErr, s.srcMultClass }); //Kernel computation kernelComputeKernelRBF = new CLCalc.Program.Kernel("ComputeKernelRBF"); kernelMaxErr = new CLCalc.Program.Kernel("maxErr"); kernelComputeMax = new CLCalc.Program.Kernel("computeMax"); kernelMinErr = new CLCalc.Program.Kernel("minErr"); kernelComputeMin = new CLCalc.Program.Kernel("computeMin"); kernelGetResp = new CLCalc.Program.Kernel("getResp"); //Update error kernelUpdateErr = new CLCalc.Program.Kernel("UpdateErr"); //Multiple classification kernelComputeMultiKernelRBF = new CLCalc.Program.Kernel("ComputeMultiKernelRBF"); kernelSumKernels=new CLCalc.Program.Kernel("SumKernels"); } //Memory obbjects //Find max/min CLErrLen = new CLCalc.Program.Variable(new int[1]); HostResp = new int[1]; CLResp = new CLCalc.Program.Variable(HostResp); CLMaxMinErrs = new CLCalc.Program.Variable(new float[MAXMINWORKSIZE]); CLMaxMinInds = new CLCalc.Program.Variable(new int[MAXMINWORKSIZE]); //Update error CLUpdtErrParams = new CLCalc.Program.Variable(new float[3]); } } }
private void button4_Click(object sender, EventArgs e) { nMassas = new int[1] { 10 }; //Integrador de EDO float x0 = 0; float[] y0 = new float[2 * nMassas[0]]; //y0[0]=posicao, y0[1] = velocidade for (int i = 0; i < 2 * nMassas[0]; i += 2) { y0[i] = 1; } CLCalc.CLPrograms.floatODE46 ode46 = new CLCalc.CLPrograms.floatODE46(x0, 0.005f, y0, MassaMola); //CLCalc.Program.DefaultCQ = 0; //Retorno de derivadas string[] s = new string[] {CLCalc.EnableDblSupport, floatDerivsMMola }; CLCalc.Program.Compile(s); KernelDerivs = new CLCalc.Program.Kernel("floatDerivs"); System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); ode46.Integrate(20); sw.Stop(); this.Text = sw.ElapsedMilliseconds.ToString(); Application.DoEvents(); float[] y = ode46.State; ode46.Integrate(25); y = ode46.State; float[] yerr = ode46.AbsError; float x = ode46.IndepVar; }
private void button3_Click(object sender, EventArgs e) { float[] x = new float[] { 1, 2, 3, 0.123f }; float[] y = new float[] { 1, 2, 1, 1 }; string s = @" kernel void sum (global float4 * x, global float4 * y) { x[0] = x[0] + y[0]; } "; CLCalc.Program.Compile(new string[] { s }); CLCalc.Program.Kernel sum = new CLCalc.Program.Kernel("sum"); CLCalc.Program.Variable varx=new CLCalc.Program.Variable(x); CLCalc.Program.Variable vary=new CLCalc.Program.Variable(y); CLCalc.Program.Variable[] args = { varx, vary }; int[] max = new int[] { 1 }; sum.Execute(args, max); varx.ReadFromDeviceTo(x); //float[] t = new float[1] { 0 }; //float[] pos = new float[] { 1, 2, 3, 4, 5, 6 }; //float[] vel = new float[] { 1, 0, 0, 0, 0, 0 }; //float[] forces = new float[] { 0, 1, 0, 0, 0, 0 }; //float[] masses = new float[] { 1, 1 }; //float[] colSizes = new float[] { 0.1f, 0.1f }; //CLCalc.InitCL(); //CLCalc.CLPrograms.floatBodyPhysics phys = new CLCalc.CLPrograms.floatBodyPhysics(10); //CLCalc.CLPrograms.floatBodyPhysics phys2 = new CLCalc.CLPrograms.floatBodyPhysics(20); //CLCalc.FinishCL(); }
private void button1_Click(object sender, EventArgs e) { CLCalc.InitCL(); double[] a = new double[] { 2, 147483647, 2, 7 }; double[] b = new double[] { 1, 2, 7, 4 }; double[] c = new double[4]; CLCalc.Program.Variable v1 = new CLCalc.Program.Variable(a); CLCalc.Program.Variable v2 = new CLCalc.Program.Variable(b); CLCalc.Program.Variable v3 = new CLCalc.Program.Variable(c); CLCalc.CLPrograms.VectorSum VecSum = new CLCalc.CLPrograms.VectorSum(); CLCalc.CLPrograms.MinDifs Mdifs = new CLCalc.CLPrograms.MinDifs(); //string[] s = new string[] { VecSum.intVectorSum, VecSum.floatVectorSum }; string[] s = new string[] { VecSum.doubleVectorSum }; CLCalc.Program.Compile(s); CLCalc.Program.Kernel k = new CLCalc.Program.Kernel("doubleVectorSum"); //CLCalc.Program.Kernel k2 = new CLCalc.Program.Kernel("intVectorSum"); //CLCalc.Program.Kernel k = new CLCalc.Program.Kernel("floatMinDifs"); CLCalc.Program.Variable[] vv = new CLCalc.Program.Variable[3] { v1, v2, v3 }; int[] max=new int[1] {a.Length}; k.Execute(vv, max); CLCalc.Program.Sync(); v3.ReadFromDeviceTo(c); CLCalc.FinishCL(); }
static Kernels() { try { CLCalc.Program.Compile(src); CLCalc.Program.MemoryObject[] Args = new CLCalc.Program.MemoryObject[100]; ; int globalWorkSize = 4; // compile the kernels KernelStart = new CLCalc.Program.Kernel("KernelStart"); coalesced = new CLCalc.Program.Kernel("coalesced"); // run kernel start KernelStart.Execute(Args, globalWorkSize); } catch (NullReferenceException nre) { System.Console.WriteLine("" + nre); } // System.Diagnostics.Debug.WriteLine("Hello"); }
/// <summary>Constructor.</summary> /// <param name="InitialState">Initial state of system</param> /// <param name="StepSize">Desired step per integration pass</param> /// <param name="InitialIndepVarValue">Initial independent variable value</param> /// <param name="DerivativeCalculator">Function to calculate derivatives vector</param> public doubleODE46(double InitialIndepVarValue, double StepSize, double[] InitialState, DerivCalcDeleg DerivativeCalculator) { if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.Unknown) { CLCalc.InitCL(); } if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.NotUsingCL) throw new Exception("OpenCL not available"); if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.UsingCL) { ODE46Source Source = new ODE46Source(); string[] s = new string[] { @" #pragma OPENCL EXTENSION cl_khr_fp64 : enable ", Source.doubleStep2, Source.doubleStep3, Source.doubleStep4, Source.doubleStep5, Source.doubleStep6, Source.doubleFinalizeCalc }; CLCalc.Program.Compile(s); //Calculador de derivada Derivs = DerivativeCalculator; //Scalars double[] xx = new double[1] { InitialIndepVarValue }; x = new CLCalc.Program.Variable(xx); xsav = new CLCalc.Program.Variable(xx); //Sets initial values to Device and local variables hdid = new CLCalc.Program.Variable(xx); currentX = InitialIndepVarValue; SetStep(StepSize); //Vectors yy = new double[InitialState.Length]; for (int i = 0; i < InitialState.Length; i++) yy[i] = InitialState[i]; ysav = new CLCalc.Program.Variable(yy); k1 = new CLCalc.Program.Variable(InitialState); k2 = new CLCalc.Program.Variable(InitialState); k3 = new CLCalc.Program.Variable(InitialState); k4 = new CLCalc.Program.Variable(InitialState); k5 = new CLCalc.Program.Variable(InitialState); k6 = new CLCalc.Program.Variable(InitialState); absError = new CLCalc.Program.Variable(new double[InitialState.Length]); y = new CLCalc.Program.Variable(yy); //Kernels KernelFinalizeCalc = new CLCalc.Program.Kernel("doubleFinalizeCalc"); KernelUpdateX = new CLCalc.Program.Kernel("doubleUpdateX"); KernelRK46YStep2 = new CLCalc.Program.Kernel("doubleYStep2"); KernelRK46XStep2 = new CLCalc.Program.Kernel("doubleXStep2"); KernelRK46YStep3 = new CLCalc.Program.Kernel("doubleYStep3"); KernelRK46XStep3 = new CLCalc.Program.Kernel("doubleXStep3"); KernelRK46YStep4 = new CLCalc.Program.Kernel("doubleYStep4"); KernelRK46XStep4 = new CLCalc.Program.Kernel("doubleXStep4"); KernelRK46YStep5 = new CLCalc.Program.Kernel("doubleYStep5"); KernelRK46XStep5 = new CLCalc.Program.Kernel("doubleXStep5"); KernelRK46YStep6 = new CLCalc.Program.Kernel("doubleYStep6"); KernelRK46XStep6 = new CLCalc.Program.Kernel("doubleXStep6"); //Kernel arguments ArgsFinalize = new CLCalc.Program.Variable[] { x, hdid, y, ysav, absError, k1, k2, k3, k4, k5, k6 }; ArgsRK46Y = new CLCalc.Program.Variable[] { x, hdid, y, ysav, k1, k2, k3, k4, k5, k6 }; ArgsRK46X = new CLCalc.Program.Variable[] { x, hdid, xsav }; NStates = new int[1] { InitialState.Length }; NScalar = new int[1] { 1 }; //Data retrieving yerr = new double[NStates[0]]; xRet = new double[NScalar[0]]; } }
/// <summary>Initializes physics program. Components indexes: [i] - x, [i+1] - y, [i+2] - z</summary> /// <param name="nParticles">Number of particles</param> public floatBodyPhysics(int nParticles) { string[] s = new string[] { CollisionAppliers, ForceAppliers, ConstAccelMotionEDOSolver }; Program.Compile(s); //Kernels MotionStep = new Program.Kernel("constAccelStep"); Kernel_ApplyGravity = new Program.Kernel("ApplyGravity"); Kernel_FloorCollision = new Program.Kernel("FloorCollision"); Kernel_SelfCollision = new Program.Kernel("SelfCollision"); Kernel_WallCollision = new Program.Kernel("WallCollision"); Kernel_ResetForces = new Program.Kernel("ResetForces"); Kernel_ResetCloseNeighbors = new Program.Kernel("ResetCloseNeighbors"); float[] t = new float[1] { 0 }; float[] gg = new float[3] { 0, 0, 0 }; step = new float[1] { 0 }; //Tamanho de alocacao de velocidades e posicoes float[] aloc = new float[nParticles * 3]; //Tamanho de alocacao de caracteristicas das particulas float[] alocPart = new float[nParticles]; //3*Nparticulas CL_pos = new CLCalc.Program.Variable(aloc); CL_vel = new CLCalc.Program.Variable(aloc); CL_forces = new CLCalc.Program.Variable(aloc); //Nparticulas closeNeighbors = new int[nParticles]; CL_closeNeighbors = new CLCalc.Program.Variable(closeNeighbors); for (int i = 0; i < nParticles; i++) alocPart[i] = 1f; //inicializa massas como 1 e tamanhos de colisao como 1 CL_masses = new CLCalc.Program.Variable(alocPart); CL_collisionSizes = new CLCalc.Program.Variable(alocPart); //escalares CL_t = new CLCalc.Program.Variable(t); CL_step = new CLCalc.Program.Variable(step); //gravidade CL_g = new CLCalc.Program.Variable(gg); //Argumentos de funcoes stepArgs = new CLCalc.Program.Variable[] { CL_t, CL_step, CL_forces, CL_masses, CL_pos, CL_vel }; applyGravArgs = new CLCalc.Program.Variable[] { CL_forces, CL_masses, CL_g }; floorCollisionArgs = new CLCalc.Program.Variable[] { CL_vel, CL_pos, CL_collisionSizes }; wallCollisionArgs = floorCollisionArgs; selfCollisionArgs = new CLCalc.Program.Variable[] { CL_vel, CL_pos, CL_masses, CL_forces, CL_closeNeighbors, CL_collisionSizes }; resetForcesArgs = new Program.Variable[] { CL_forces }; resetCloseNeighborsArgs = new Program.Variable[] { CL_closeNeighbors }; nArgs = new int[1] { nParticles * 3 }; nPartics = new int[1] { nParticles }; nPartics2 = new int[2] { nParticles, nParticles }; }
/// <summary>Creates a new isosurface calculator. You may pass variables created from a OpenGL context to the CL variables if you are using interop or NULL /// if not using OpenCL/GL interop.</summary> /// <param name="FuncValues">Values of the evaluated 3D function f(x,y,z). FuncValues=float[maxX,maxY,maxZ]</param> /// <param name="CLEdgeCoords">OpenCL variable (float) to hold edge coordinates. Dimension has to be 9 * maxX * maxY * maxZ</param> /// <param name="CLEdgeNormals">OpenCL variable (float) to hold edge normals. Dimension has to be 9 * maxX * maxY * maxZ</param> /// <param name="CLElementArrayIndex">OpenCL variable (int) to hold element array index. Dimension has to be 5 * 3 * (maxX - 1) * (maxY - 1) * (maxZ - 1)</param> private void InitMarchingCubes(float[, ,] FuncValues, CLCalc.Program.Variable CLEdgeCoords, CLCalc.Program.Variable CLEdgeNormals, CLCalc.Program.Variable CLElementArrayIndex) { if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.Unknown) CLCalc.InitCL(); if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.UsingCL) { //Reads maximum lengths int maxX = FuncValues.GetLength(0); int maxY = FuncValues.GetLength(1); int maxZ = FuncValues.GetLength(2); max = new int[] { maxX, maxY, maxZ }; #region Creating variables //Isolevel isoLevel = new float[1] { 1.32746E-5f }; varIsoLevel = new CLCalc.Program.Variable(isoLevel); //Step size and x0,y0,z0 varStep = new CLCalc.Program.Variable(step); varInitVals = new CLCalc.Program.Variable(initVals); //Create and copy function values funcVals = new float[maxX * maxY * maxZ]; CLFuncVals = new CLCalc.Program.Variable(funcVals); SetFuncVals(FuncValues); //Edge coordinates - 3 coords * 3 possible directions * number of points edgeCoords = new float[9 * maxX * maxY * maxZ]; if (CLEdgeCoords != null) { varEdgeCoords = CLEdgeCoords; varEdgeCoords.WriteToDevice(edgeCoords); } else varEdgeCoords = new CLCalc.Program.Variable(edgeCoords); //4 preliminary normals per edge - has to be averaged afterwards edgePrelimNormals = new float[36 * maxX * maxY * maxZ]; varEdgePrelimNormals = new CLCalc.Program.Variable(edgePrelimNormals); //Edge normals edgeNormals = new float[9 * maxX * maxY * maxZ]; if (CLEdgeNormals != null) { varEdgeNormals = CLEdgeNormals; varEdgeNormals.WriteToDevice(edgeNormals); } else varEdgeNormals = new CLCalc.Program.Variable(edgeNormals); //Number of cubes: (maxX-1)*(maxY-1)*(maxZ-1) //Marching cube algorithm: each cube can have 5 triangles drawn, 3 vertexes per triangle //q-th vertex of p-th triangle of the ijk-th cube: [(5*(i+(maxX-1)*j+k*(maxX-1)*(maxY-1))+p)*3+q] elementIndex = new int[5 * 3 * (maxX - 1) * (maxY - 1) * (maxZ - 1)]; if (CLElementArrayIndex != null) { varElemIndex = CLElementArrayIndex; varElemIndex.WriteToDevice(elementIndex); } else varElemIndex = new CLCalc.Program.Variable(elementIndex); //Edge remapping to build output edges = new int[edgeCoords.Length / 3]; for (int i = 0; i < edges.Length; i++) edges[i] = -1; #endregion #region Compile code and create kernels CLMarchingCubesSrc cmsrc = new CLMarchingCubesSrc(); CLCalc.Program.Compile(new string[] { cmsrc.definitions, cmsrc.src }); kernelInterpPts = new CLCalc.Program.Kernel("interpPts"); kernelPolygonize = new CLCalc.Program.Kernel("Polygonize"); kernelSmoothNormals = new CLCalc.Program.Kernel("SmoothNormals"); kernelPolygonizeNoNormals = new CLCalc.Program.Kernel("PolygonizeNoNormals"); #endregion } else throw new Exception("OpenCL not available"); }
/// <summary>Initializes CL kernels</summary> public static void Init() { if (kernelCholeskyDiagBlock == null) { if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.Unknown) CLCalc.InitCL(); if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.UsingCL) { if (kernelCholeskyDiagBlock == null) { SUBMATRIXSIZE = (int)Math.Sqrt((double)CLCalc.Program.CommQueues[CLCalc.Program.DefaultCQ].Device.MaxWorkGroupSize); SUBMATRIXSIZE = Math.Min(16, SUBMATRIXSIZE); string strSubSize = SUBMATRIXSIZE.ToString(); string strTotSize = (SUBMATRIXSIZE * (SUBMATRIXSIZE + 1) / 2).ToString(); LinalgSrc src = new LinalgSrc(); string srcBlockChol = src.srcBlockCholesky.Replace("CONSTSUBMATRIXSIZE", strSubSize).Replace("CONSTGLOBALSIZE", strTotSize); CLCalc.Program.Compile(new string[] { srcBlockChol, src.srcBkSubs, src.srcOperations, src.srcVecSum, src.srcpNorm, src.strFeasibFunc, src.srcLogistReg }); kernelCholeskyDiagBlock = new CLCalc.Program.Kernel("CholeskyDiagBlock"); kernelCholeskyComputePanel = new CLCalc.Program.Kernel("CholeskyComputePanel"); kernelCholeskyForwardProp = new CLCalc.Program.Kernel("CholeskyForwardProp"); kernelFwdUpperBackSubs = new CLCalc.Program.Kernel("FwdUpperBackSubs"); kernelBkLowerBackSubs = new CLCalc.Program.Kernel("BkLowerBackSubs"); kernelFwdPropag = new CLCalc.Program.Kernel("FwdPropag"); kernelFwdPropag2 = new CLCalc.Program.Kernel("FwdPropag2"); kernelBackPropag = new CLCalc.Program.Kernel("BackPropag"); kernelBackPropag2 = new CLCalc.Program.Kernel("BackPropag2"); kernelInPlaceSubtract = new CLCalc.Program.Kernel("InPlaceSubtract"); kernelElemWiseAbs = new CLCalc.Program.Kernel("ElemWiseAbs"); kernelInnerProd = new CLCalc.Program.Kernel("InnerProd"); //Linear algebra kernelSymMatrVecMultiply = new CLCalc.Program.Kernel("SymMatrVecMultiply"); kernelSymMatrMatrMultiply = new CLCalc.Program.Kernel("SymMatrMatrMultiply"); kernelComputeAtWA = new CLCalc.Program.Kernel("ComputeAtWA"); kernelComputeAinvHAt = new CLCalc.Program.Kernel("ComputeAinvHAt"); kernelRegularMatrTranspMatrProd = new CLCalc.Program.Kernel("RegularMatrTranspMatrProd"); kernelCopyBuffer = new CLCalc.Program.Kernel("CopyBuffer"); kernelLinearComb = new CLCalc.Program.Kernel("LinearComb"); kernelMatrVecProd = new CLCalc.Program.Kernel("MatrVecProd"); kernelTranspMatrVecProdW = new CLCalc.Program.Kernel("TranspMatrVecProdW"); kernelMatrVecProdSumVec = new CLCalc.Program.Kernel("MatrVecProdSumVec"); kernelDiagVecProd = new CLCalc.Program.Kernel("DiagVecProd"); kernelDiagTranspMatProd = new CLCalc.Program.Kernel("DiagTranspMatProd"); kernelElemWiseProd = new CLCalc.Program.Kernel("ElemWiseProd"); kernelElemWiseInv = new CLCalc.Program.Kernel("ElemWiseInv"); kernelElemWiseInv2 = new CLCalc.Program.Kernel("ElemWiseInv2"); kernelClear = new CLCalc.Program.Kernel("ClearResps"); kernelPreSum = new CLCalc.Program.Kernel("PreSum"); kernelCoalLocalSum = new CLCalc.Program.Kernel("CoalLocalSum"); kernelHasPositiveEntry = new CLCalc.Program.Kernel("HasPositiveEntry"); //pNorm minimization floatOptimization.CurveFitting.kernelpNorm = new CLCalc.Program.Kernel("pNorm"); floatOptimization.CurveFitting.kerneldpNorm = new CLCalc.Program.Kernel("dpNorm"); //Logistic regression floatOptimization.LogisticRegression.kernelComputeLogistRegParams = new CLCalc.Program.Kernel("ComputeLogistRegParams"); floatOptimization.LogisticRegression.kernelpNorm = floatOptimization.CurveFitting.kernelpNorm; floatOptimization.LogisticRegression.kerneldpNorm = floatOptimization.CurveFitting.kerneldpNorm; //Feasibility floatOptimization.QuadraticProgramming.kernelgetLast = new CLCalc.Program.Kernel("getLast"); } } } }