Esempio n. 1
0
        /// <summary>
        /// This function adds two numbers on the FPGA using <see cref="KpzKernelsInterface.TestAdd(SimpleMemory)"/>.
        /// </summary>
        public static uint TestAddWrapper(this KpzKernelsInterface kernels, uint a, uint b)
        {
            var sm = new SimpleMemory(3);

            sm.WriteUInt32(0, a);
            sm.WriteUInt32(1, b);
            kernels.TestAdd(sm);
            return(sm.ReadUInt32(2));
        }
Esempio n. 2
0
        /// <summary>
        /// This is a wrapper for running the KPZ algorithm on the FPGA.
        /// </summary>
        /// <param name="kernels"></param>
        /// <param name="hostGrid">
        ///     This is the grid of initial <see cref="KpzNode"/> items for the algorithm to work on.
        /// </param>
        /// <param name="pushToFpga">
        ///     If this parameter is false, the FPGA will work on the grid currently available in it,
        ///     instead of the grid in the <see cref="hostGrid"/> parameter.
        /// </param>
        /// <param name="testMode">
        ///     does several things:
        ///     <list type="bullet">
        ///         <item>
        ///             if it is true, <see cref="KpzKernels.RandomlySwitchFourCells(bool)"/> always switches the cells
        ///             if it finds an adequate place,
        ///         </item>
        ///         <item>
        ///             it also does only a single poke, then sends the grid back to the host so that the algorithm
        ///             can be analyzed in the step-by-step window.
        ///         </item>
        ///     </list>
        /// </param>
        /// <param name="randomSeed1">is a random seed for the algorithm.</param>
        /// <param name="randomSeed2">is a random seed for the algorithm.</param>
        /// <param name="numberOfIterations">is the number of iterations to perform.</param>
        public static void DoIterationsWrapper(this KpzKernelsInterface kernels, KpzNode[,] hostGrid, bool pushToFpga,
                                               bool testMode, ulong randomSeed1, ulong randomSeed2, uint numberOfIterations)
        {
            SimpleMemory sm = new SimpleMemory(KpzKernels.SizeOfSimpleMemory);

            if (pushToFpga)
            {
                CopyParametersToMemory(sm, testMode, randomSeed1, randomSeed2, numberOfIterations);
                CopyFromGridToSimpleMemory(hostGrid, sm);
            }

            kernels.DoIterations(sm);
            CopyFromSimpleMemoryToGrid(hostGrid, sm);
        }
Esempio n. 3
0
        /// <summary>
        /// This function generates random numbers on the FPGA using
        /// <see cref="KpzKernelsInterface.TestPrng(SimpleMemory)"/>.
        /// </summary>
        public static uint[] TestPrngWrapper(this KpzKernelsInterface kernels)
        {
            var numbers = new uint[KpzKernels.GridWidth * KpzKernels.GridHeight];
            var sm      = new SimpleMemory(KpzKernels.SizeOfSimpleMemory);

            CopyParametersToMemory(sm, false, 0x5289a3b89ac5f211, 0x5289a3b89ac5f211, 0);

            kernels.TestPrng(sm);

            for (int i = 0; i < KpzKernels.GridWidth * KpzKernels.GridHeight; i++)
            {
                numbers[i] = sm.ReadUInt32(i);
            }

            return(numbers);
        }
Esempio n. 4
0
        public async Task <IHastlayer> InitializeHastlayer(bool verifyOutput, bool randomSeedEnable)
        {
            _verifyOutput     = verifyOutput;
            _randomSeedEnable = randomSeedEnable;

            LogItFunction("Creating Hastlayer Factory...");

            var hastlayer = await Hastlayer.Create();

            hastlayer.ExecutedOnHardware += (sender, e) =>
            {
                LogItFunction("Hastlayer timer: " +
                              e.HardwareExecutionInformation.HardwareExecutionTimeMilliseconds + "ms (net) / " +
                              e.HardwareExecutionInformation.FullExecutionTimeMilliseconds + " ms (total)"
                              );
            };

            var configuration = new HardwareGenerationConfiguration((await hastlayer.GetSupportedDevices()).First().Name);

            configuration.VhdlTransformerConfiguration().VhdlGenerationConfiguration = VhdlGenerationConfiguration.Debug;
            configuration.EnableCaching = false;

            LogItFunction("Generating hardware...");

            if (_kpzTarget.HastlayerParallelizedAlgorithm())
            {
                configuration.AddHardwareEntryPointType <KpzKernelsParallelizedInterface>();
                configuration.TransformerConfiguration().AddAdditionalInlinableMethod <RandomMwc64X>(r => r.NextUInt32());
            }
            else if (_kpzTarget.HastlayerPlainAlgorithm())
            {
                configuration.AddHardwareEntryPointType <KpzKernelsInterface>();
            }
            else // if (kpzTarget == KpzTarget.PrngTest)
            {
                configuration.AddHardwareEntryPointType <PrngTestInterface>();
            }


            var hardwareRepresentation = await hastlayer.GenerateHardware(new[] {
                typeof(KpzKernelsParallelizedInterface).Assembly,
                typeof(RandomMwc64X).Assembly
            }, configuration);

            await hardwareRepresentation.HardwareDescription.WriteSource(VhdlOutputFilePath);

            LogItFunction("Generating proxy...");

            if (_kpzTarget.HastlayerOnFpga())
            {
                var proxyConf = new ProxyGenerationConfiguration
                {
                    VerifyHardwareResults = _verifyOutput
                };

                if (_kpzTarget == KpzTarget.Fpga)
                {
                    Kernels = await hastlayer.GenerateProxy(
                        hardwareRepresentation,
                        new KpzKernelsInterface(),
                        proxyConf);
                }
                else if (_kpzTarget == KpzTarget.FpgaParallelized)
                {
                    KernelsParallelized = await hastlayer.GenerateProxy(
                        hardwareRepresentation,
                        new KpzKernelsParallelizedInterface(),
                        proxyConf);
                }
                else //if(kpzTarget == KpzTarget.PrngTest)
                {
                    KernelsP = await hastlayer.GenerateProxy(
                        hardwareRepresentation,
                        new PrngTestInterface(),
                        proxyConf);
                }

                LogItFunction("FPGA target detected");
            }
            else //if (kpzTarget == KpzTarget.HastlayerSimulation())
            {
                Kernels             = new KpzKernelsInterface();
                KernelsParallelized = new KpzKernelsParallelizedInterface();
                LogItFunction("Simulation target detected");
            }

            if (_kpzTarget.HastlayerPlainAlgorithm())
            {
                LogItFunction("Running TestAdd...");
                uint resultFpga = Kernels.TestAddWrapper(4313, 123);
                uint resultCpu  = 4313 + 123;
                if (resultCpu == resultFpga)
                {
                    LogItFunction(string.Format("Success: {0} == {1}", resultFpga, resultCpu));
                }
                else
                {
                    LogItFunction(string.Format("Fail: {0} != {1}", resultFpga, resultCpu));
                }
            }

            if (_kpzTarget == KpzTarget.PrngTest)
            {
                LogItFunction("Running TestPrng...");

                var   kernelsCpu = new PrngTestInterface();
                ulong randomSeed = 0x37a92d76a96ef210UL;
                var   smCpu      = kernelsCpu.PushRandomSeed(randomSeed);
                var   smFpga     = KernelsP.PushRandomSeed(randomSeed);
                LogItFunction("PRNG results:");
                bool success = true;

                for (int PrngTestIndex = 0; PrngTestIndex < 10; PrngTestIndex++)
                {
                    uint prngCpuResult  = kernelsCpu.GetNextRandom(smCpu);
                    uint prngFpgaResult = KernelsP.GetNextRandom(smFpga);
                    if (prngCpuResult != prngFpgaResult)
                    {
                        success = false;
                    }
                    LogItFunction(String.Format("{0}, {1}", prngCpuResult, prngFpgaResult));
                }

                if (success)
                {
                    LogItFunction("TestPrng succeeded!");
                }
                else
                {
                    LogItFunction("TestPrng failed!");
                }
            }
            return(hastlayer);
        }