Ejemplo n.º 1
0
        public static ProcResult ProcMarkBlocks(int steps)
        {
            var strRet = String.Empty;

            int[] res = new int[_area];

            _stopwatch.Reset();
            _stopwatch.Start();

            for (var i = 0; i < steps; i++)
            {
                //uint[] rrands = IntArrayGen.RandUInts((int)DateTime.Now.Ticks, _blockCount);
                //strRet = strRet + _cudaArray.CopyUIntsToDevice(rrands, d_rands, _blockCount);

                strRet = strRet + _randoProcs.MakeRandomInts(d_indexRands, _blockCount);

                strRet = strRet + _gridProcs.Run_k_RandBlockPick(
                    destPtr: d_grid,
                    randPtr: d_indexRands,
                    block_size: _block_size,
                    blocks_per_span: _blocks_per_span
                    );
            }

            strRet = strRet + _cudaArray.CopyIntsFromDevice(res, d_grid, _area);

            _stopwatch.Stop();


            //uint[] res2 = new uint[_blockCount];
            //strRet = strRet + _cudaArray.CopyUIntsFromDevice(res2, d_rands, _blockCount);

            var dRet = new Dictionary <string, object>();

            dRet["Grid"] = new SimGrid <int>(name: "Update",
                                             width: _span,
                                             height: _span,
                                             data: res);

            return(new ProcResult(data: dRet,
                                  err: strRet,
                                  stepsCompleted: steps,
                                  time: _stopwatch.ElapsedMilliseconds));
        }
Ejemplo n.º 2
0
        public static ProcResult UpdateH(int steps, float rate)
        {
            var strRet = String.Empty;

            _stopwatch.Reset();
            _stopwatch.Start();

            for (var s = 0; s < steps; s++)
            {
                strRet = strRet + _randoProcs.MakeRandomInts(d_indexRands, _blockCount);

                strRet = strRet + _gridProcs.Run_k_Thermo_bp(
                    dataOut: d_grid,
                    index_rands: d_indexRands,
                    block_size: _block_size,
                    blocks_per_span: _blocks_per_span,
                    rate: rate,
                    fixed_colA: _span / 4,
                    fixed_colB: 3 * _span / 4);
            }


            var res = new float[_area];

            strRet = strRet + _cudaArray.CopyFloatsFromDevice(res, d_grid, _area);

            _stopwatch.Stop();

            var dRet = new Dictionary <string, object>();

            dRet["Grid"] = new SimGrid <float>(name: "UpdateH",
                                               width: _span,
                                               height: _span,
                                               data: res);

            return(new ProcResult(data: dRet,
                                  err: strRet,
                                  stepsCompleted: steps,
                                  time: _stopwatch.ElapsedMilliseconds));
        }
Ejemplo n.º 3
0
        public static ProcResult UpdateH(int steps, float qRate, float filpEnergy, float beta)
        {
            var strRet = String.Empty;

            _stopwatch.Reset();
            _stopwatch.Start();

            for (var s = 0; s < steps; s++)
            {
                var res9 = new int[_area];
                strRet = strRet + _cudaArray.CopyIntsFromDevice(res9, d_flipData, _area);

                var bbs = FloatFuncs.Betas(_tempSteps, beta);
                strRet = strRet + _cudaArray.CopyFloatsToDevice(bbs, d_threshes, _allTempSteps);
                strRet = strRet + _randoProcs.MakeRandomInts(d_indexRands, _blockCount);
                strRet = strRet + _randoProcs.MakeUniformRands(d_flipRands, _blockCount);

                strRet = strRet + _gridProcs.Run_k_ThermoIsing_bp(
                    temp_data: d_tempData,
                    flip_data: d_flipData,
                    index_rands: d_indexRands,
                    flip_rands: d_flipRands,
                    threshes: d_threshes,
                    flip_energy: filpEnergy,
                    block_size: _block_size,
                    blocks_per_span: _blocks_per_span,
                    q_rate: qRate);
            }

            _stopwatch.Stop();

            var dRet = new Dictionary <string, object>();


            float[] bhts = new float[_area / 1024];
            strRet = strRet + _cudaArray.RunBlockAddFloats_32_Kernel(
                destPtr: d_heatBlocks,
                srcPtr: d_tempData,
                span: _span
                );

            strRet = strRet + _cudaArray.CopyFloatsFromDevice(bhts, d_heatBlocks, _area / 1024);
            float tot = bhts.Sum();

            tot /= _area;
            dRet["TotalHeat"] = tot;


            var tres = new float[_area];

            strRet            = strRet + _cudaArray.CopyFloatsFromDevice(tres, d_tempData, _area);
            dRet["ThermGrid"] = new SimGrid <float>(name: "Therms",
                                                    width: _span,
                                                    height: _span,
                                                    data: tres);


            var fres = new int[_area];

            strRet           = strRet + _cudaArray.CopyIntsFromDevice(fres, d_flipData, _area);
            dRet["FlipGrid"] = new SimGrid <int>(name: "Flips",
                                                 width: _span,
                                                 height: _span,
                                                 data: fres);


            return(new ProcResult(data: dRet,
                                  err: strRet,
                                  stepsCompleted: steps,
                                  time: _stopwatch.ElapsedMilliseconds));
        }