Example #1
0
        static void Main(string[] args)
        {
            try
            {
                if (args.Length > 0)
                {
                    deviceID = int.Parse(args[0]);
                }
                if (args.Length > 2)
                {
                    platformID = int.Parse(args[2]);
                }
            }
            catch (Exception ex)
            {
                Logger.Log(LogLevel.Error, "Device ID parse error", ex);
            }

            try
            {
                if (args.Length > 1)
                {
                    port = int.Parse(args[1]);
                    Comms.ConnectToMaster(port);
                }
                else
                {
                    TEST = true;
                    CGraph.ShowCycles    = true;
                    Logger.CopyToConsole = true;
                }
            }
            catch (Exception ex)
            {
                Logger.Log(LogLevel.Error, "Master connection error");
            }


            // Gets all available platforms and their corresponding devices, and prints them out in a table
            List <Platform> platforms = null;

            try
            {
                platforms = Platform.GetPlatforms().ToList();
            }
            catch (Exception ex)
            {
                Logger.Log(LogLevel.Error, "Failed to get OpenCL platform list");
                return;
            }

            if (TEST)
            {
                currentJob = nextJob = new Job()
                {
                    jobID = 0,
                    k0    = 0xf4956dc403730b01L,
                    k1    = 0xe6d45de39c2a5a3eL,
                    k2    = 0xcbf626a8afee35f6L,
                    k3    = 0x4307b94b1a0c9980L,
                    //k0 = 0x10ef16eadd6aa061L,
                    //k1 = 0x563f07e7a3c788b3L,
                    //k2 = 0xe8d7c8db1518f29aL,
                    //k3 = 0xc0ab7d1b4ca1adffL,
                    pre_pow   = TestPrePow,
                    timestamp = DateTime.Now
                };
            }
            else
            {
                currentJob = nextJob = new Job()
                {
                    jobID     = 0,
                    k0        = 0xf4956dc403730b01L,
                    k1        = 0xe6d45de39c2a5a3eL,
                    k2        = 0xcbf626a8afee35f6L,
                    k3        = 0x4307b94b1a0c9980L,
                    pre_pow   = TestPrePow,
                    timestamp = DateTime.Now
                };

                if (!Comms.IsConnected())
                {
                    Console.WriteLine("Master connection failed, aborting");
                    Logger.Log(LogLevel.Error, "No master connection, exitting!");
                    Task.Delay(500).Wait();
                    return;
                }

                if (deviceID < 0)
                {
                    try
                    {
                        //Environment.SetEnvironmentVariable("GPU_FORCE_64BIT_PTR", "1", EnvironmentVariableTarget.Machine);
                        Environment.SetEnvironmentVariable("GPU_MAX_HEAP_SIZE", "100", EnvironmentVariableTarget.User);
                        Environment.SetEnvironmentVariable("GPU_USE_SYNC_OBJECTS", "1", EnvironmentVariableTarget.User);
                        Environment.SetEnvironmentVariable("GPU_MAX_ALLOC_PERCENT", "100", EnvironmentVariableTarget.User);
                        Environment.SetEnvironmentVariable("GPU_SINGLE_ALLOC_PERCENT", "100", EnvironmentVariableTarget.User);
                        Environment.SetEnvironmentVariable("GPU_64BIT_ATOMICS", "1", EnvironmentVariableTarget.User);
                        Environment.SetEnvironmentVariable("GPU_MAX_WORKGROUP_SIZE", "1024", EnvironmentVariableTarget.User);
                        //Environment.SetEnvironmentVariable("AMD_OCL_BUILD_OPTIONS_APPEND", "-cl-std=CL2.0", EnvironmentVariableTarget.Machine);

                        GpuDevicesMessage gpum = new GpuDevicesMessage()
                        {
                            devices = new List <GpuDevice>()
                        };
                        //foreach (Platform platform in platforms)
                        for (int p = 0; p < platforms.Count(); p++)
                        {
                            Platform platform = platforms[p];
                            var      devices  = platform.GetDevices(DeviceType.Gpu).ToList();
                            //foreach (Device device in platform.GetDevices(DeviceType.All))
                            for (int d = 0; d < devices.Count(); d++)
                            {
                                Device device = devices[d];
                                string name   = device.Name;
                                string pName  = platform.Name;
                                //Console.WriteLine(device.Name + " " + platform.Version.VersionString);
                                gpum.devices.Add(new GpuDevice()
                                {
                                    deviceID = d, platformID = p, platformName = pName, name = name, memory = device.GlobalMemorySize
                                });
                            }
                        }
                        Comms.gpuMsg = gpum;
                        Comms.SetEvent();
                        Task.Delay(1000).Wait();
                        Comms.Close();
                        return;
                    }
                    catch (Exception ex)
                    {
                        Logger.Log(LogLevel.Error, "Unable to enumerate OpenCL devices");
                        Task.Delay(500).Wait();
                        Comms.Close();
                        return;
                    }
                }
            }

            try
            {
                Device chosenDevice = null;
                try
                {
                    chosenDevice = platforms[platformID].GetDevices(DeviceType.Gpu).ToList()[deviceID];
                    Console.WriteLine($"Using OpenCL device: {chosenDevice.Name} ({chosenDevice.Vendor})");
                    Console.WriteLine();
                }
                catch (Exception ex)
                {
                    Logger.Log(LogLevel.Error, $"Unable to select OpenCL device {deviceID} on platform {platformID} ");
                    Task.Delay(500).Wait();
                    Comms.Close();
                    return;
                }

                var assembly       = Assembly.GetEntryAssembly();
                var resourceStream = assembly.GetManifestResourceStream("OclSolver.kernel.cl");
                using (StreamReader reader = new StreamReader(resourceStream))
                {
                    using (Context context = Context.CreateContext(chosenDevice))
                    {
                        /*
                         * Once the program has been created you can use clGetProgramInfo with CL_PROGRAM_BINARY_SIZES and then CL_PROGRAM_BINARIES, storing the resulting binary programs (one for each device of the context) into a buffer you supply. You can then save this binary data to disk for use in later runs.
                         * Not all devices might support binaries, so you will need to check the CL_PROGRAM_BINARY_SIZES result (it returns a zero size for that device if binaries are not supported).
                         */
                        using (OpenCl.DotNetCore.Programs.Program program = context.CreateAndBuildProgramFromString(reader.ReadToEnd()))
                        {
                            using (CommandQueue commandQueue = CommandQueue.CreateCommandQueue(context, chosenDevice))
                            {
                                IntPtr clearPattern = IntPtr.Zero;
                                uint[] edgesCount;
                                int[]  edgesLeft;
                                int    trims = 0;
                                try
                                {
                                    clearPattern = Marshal.AllocHGlobal(4);
                                    Marshal.Copy(new byte[4] {
                                        0, 0, 0, 0
                                    }, 0, clearPattern, 4);

                                    try
                                    {
                                        bufferA1 = context.CreateBuffer <uint>(MemoryFlag.ReadWrite, BUFFER_SIZE_A1);
                                        bufferA2 = context.CreateBuffer <uint>(MemoryFlag.ReadWrite, BUFFER_SIZE_A2);
                                        bufferB  = context.CreateBuffer <uint>(MemoryFlag.ReadWrite, BUFFER_SIZE_B);

                                        bufferI1 = context.CreateBuffer <uint>(MemoryFlag.ReadWrite, INDEX_SIZE);
                                        bufferI2 = context.CreateBuffer <uint>(MemoryFlag.ReadWrite, INDEX_SIZE);

                                        bufferR = context.CreateBuffer <uint>(MemoryFlag.ReadOnly, 42 * 2);
                                    }
                                    catch (Exception ex)
                                    {
                                        Task.Delay(500).Wait();
                                        Logger.Log(LogLevel.Error, "Unable to allocate buffers, out of memory?");
                                        Task.Delay(500).Wait();
                                        Comms.Close();
                                        return;
                                    }

                                    using (Kernel kernelSeedA = program.CreateKernel("FluffySeed2A"))
                                        using (Kernel kernelSeedB1 = program.CreateKernel("FluffySeed2B"))
                                            using (Kernel kernelSeedB2 = program.CreateKernel("FluffySeed2B"))
                                                using (Kernel kernelRound1 = program.CreateKernel("FluffyRound1"))
                                                    using (Kernel kernelRoundO = program.CreateKernel("FluffyRoundNO1"))
                                                        using (Kernel kernelRoundNA = program.CreateKernel("FluffyRoundNON"))
                                                            using (Kernel kernelRoundNB = program.CreateKernel("FluffyRoundNON"))
                                                                using (Kernel kernelTail = program.CreateKernel("FluffyTailO"))
                                                                    using (Kernel kernelRecovery = program.CreateKernel("FluffyRecovery"))
                                                                    {
                                                                        Stopwatch sw = new Stopwatch();

                                                                        kernelSeedA.SetKernelArgumentGeneric(0, currentJob.k0);
                                                                        kernelSeedA.SetKernelArgumentGeneric(1, currentJob.k1);
                                                                        kernelSeedA.SetKernelArgumentGeneric(2, currentJob.k2);
                                                                        kernelSeedA.SetKernelArgumentGeneric(3, currentJob.k3);
                                                                        kernelSeedA.SetKernelArgument(4, bufferB);
                                                                        kernelSeedA.SetKernelArgument(5, bufferA1);
                                                                        kernelSeedA.SetKernelArgument(6, bufferI1);

                                                                        kernelSeedB1.SetKernelArgument(0, bufferA1);
                                                                        kernelSeedB1.SetKernelArgument(1, bufferA1);
                                                                        kernelSeedB1.SetKernelArgument(2, bufferA2);
                                                                        kernelSeedB1.SetKernelArgument(3, bufferI1);
                                                                        kernelSeedB1.SetKernelArgument(4, bufferI2);
                                                                        kernelSeedB1.SetKernelArgumentGeneric(5, (uint)32);

                                                                        kernelSeedB2.SetKernelArgument(0, bufferB);
                                                                        kernelSeedB2.SetKernelArgument(1, bufferA1);
                                                                        kernelSeedB2.SetKernelArgument(2, bufferA2);
                                                                        kernelSeedB2.SetKernelArgument(3, bufferI1);
                                                                        kernelSeedB2.SetKernelArgument(4, bufferI2);
                                                                        kernelSeedB2.SetKernelArgumentGeneric(5, (uint)0);

                                                                        kernelRound1.SetKernelArgument(0, bufferA1);
                                                                        kernelRound1.SetKernelArgument(1, bufferA2);
                                                                        kernelRound1.SetKernelArgument(2, bufferB);
                                                                        kernelRound1.SetKernelArgument(3, bufferI2);
                                                                        kernelRound1.SetKernelArgument(4, bufferI1);
                                                                        kernelRound1.SetKernelArgumentGeneric(5, (uint)DUCK_SIZE_A * 1024);
                                                                        kernelRound1.SetKernelArgumentGeneric(6, (uint)DUCK_SIZE_B * 1024);

                                                                        kernelRoundO.SetKernelArgument(0, bufferB);
                                                                        kernelRoundO.SetKernelArgument(1, bufferA1);
                                                                        kernelRoundO.SetKernelArgument(2, bufferI1);
                                                                        kernelRoundO.SetKernelArgument(3, bufferI2);

                                                                        kernelRoundNA.SetKernelArgument(0, bufferB);
                                                                        kernelRoundNA.SetKernelArgument(1, bufferA1);
                                                                        kernelRoundNA.SetKernelArgument(2, bufferI1);
                                                                        kernelRoundNA.SetKernelArgument(3, bufferI2);

                                                                        kernelRoundNB.SetKernelArgument(0, bufferA1);
                                                                        kernelRoundNB.SetKernelArgument(1, bufferB);
                                                                        kernelRoundNB.SetKernelArgument(2, bufferI2);
                                                                        kernelRoundNB.SetKernelArgument(3, bufferI1);

                                                                        kernelTail.SetKernelArgument(0, bufferB);
                                                                        kernelTail.SetKernelArgument(1, bufferA1);
                                                                        kernelTail.SetKernelArgument(2, bufferI1);
                                                                        kernelTail.SetKernelArgument(3, bufferI2);

                                                                        kernelRecovery.SetKernelArgumentGeneric(0, currentJob.k0);
                                                                        kernelRecovery.SetKernelArgumentGeneric(1, currentJob.k1);
                                                                        kernelRecovery.SetKernelArgumentGeneric(2, currentJob.k2);
                                                                        kernelRecovery.SetKernelArgumentGeneric(3, currentJob.k3);
                                                                        kernelRecovery.SetKernelArgument(4, bufferR);
                                                                        kernelRecovery.SetKernelArgument(5, bufferI2);

                                                                        int loopCnt = 0;
                                                                        //for (int i = 0; i < runs; i++)
                                                                        while (!Comms.IsTerminated)
                                                                        {
                                                                            try
                                                                            {
                                                                                if (!TEST && (Comms.nextJob.pre_pow == null || Comms.nextJob.pre_pow == "" || Comms.nextJob.pre_pow == TestPrePow))
                                                                                {
                                                                                    Logger.Log(LogLevel.Info, string.Format("Waiting for job...."));
                                                                                    Task.Delay(1000).Wait();
                                                                                    continue;
                                                                                }

                                                                                if (!TEST && ((currentJob.pre_pow != Comms.nextJob.pre_pow) || (currentJob.origin != Comms.nextJob.origin)))
                                                                                {
                                                                                    currentJob           = Comms.nextJob;
                                                                                    currentJob.timestamp = DateTime.Now;
                                                                                }

                                                                                if (!TEST && (currentJob.timestamp.AddMinutes(30) < DateTime.Now) && Comms.lastIncoming.AddMinutes(30) < DateTime.Now)
                                                                                {
                                                                                    Logger.Log(LogLevel.Info, string.Format("Job too old..."));
                                                                                    Task.Delay(1000).Wait();
                                                                                    continue;
                                                                                }

                                                                                // test runs only once
                                                                                if (TEST && loopCnt++ > 100000)
                                                                                {
                                                                                    Comms.IsTerminated = true;
                                                                                }

                                                                                Logger.Log(LogLevel.Debug, string.Format("GPU AMD{4}:Trimming #{4}: {0} {1} {2} {3}", currentJob.k0, currentJob.k1, currentJob.k2, currentJob.k3, currentJob.jobID, deviceID));

                                                                                //Stopwatch srw = new Stopwatch();
                                                                                //srw.Start();

                                                                                Solution s;
                                                                                while (graphSolutions.TryDequeue(out s))
                                                                                {
                                                                                    kernelRecovery.SetKernelArgumentGeneric(0, s.job.k0);
                                                                                    kernelRecovery.SetKernelArgumentGeneric(1, s.job.k1);
                                                                                    kernelRecovery.SetKernelArgumentGeneric(2, s.job.k2);
                                                                                    kernelRecovery.SetKernelArgumentGeneric(3, s.job.k3);
                                                                                    commandQueue.EnqueueWriteBufferEdges(bufferR, s.GetLongEdges());
                                                                                    commandQueue.EnqueueClearBuffer(bufferI2, 64 * 64 * 4, clearPattern);
                                                                                    commandQueue.EnqueueNDRangeKernel(kernelRecovery, 1, 2048 * 256, 256, 0);
                                                                                    s.nonces = commandQueue.EnqueueReadBuffer <uint>(bufferI2, 42);
                                                                                    OpenCl.DotNetCore.Interop.CommandQueues.CommandQueuesNativeApi.Finish(commandQueue.Handle);
                                                                                    s.nonces = s.nonces.OrderBy(n => n).ToArray();
                                                                                    Comms.graphSolutionsOut.Enqueue(s);
                                                                                    Comms.SetEvent();
                                                                                }

                                                                                //srw.Stop();
                                                                                //Console.WriteLine("RECOVERY " + srw.ElapsedMilliseconds);

                                                                                currentJob = currentJob.Next();

                                                                                kernelSeedA.SetKernelArgumentGeneric(0, currentJob.k0);
                                                                                kernelSeedA.SetKernelArgumentGeneric(1, currentJob.k1);
                                                                                kernelSeedA.SetKernelArgumentGeneric(2, currentJob.k2);
                                                                                kernelSeedA.SetKernelArgumentGeneric(3, currentJob.k3);

                                                                                sw.Restart();

                                                                                commandQueue.EnqueueClearBuffer(bufferI2, 64 * 64 * 4, clearPattern);
                                                                                commandQueue.EnqueueClearBuffer(bufferI1, 64 * 64 * 4, clearPattern);
                                                                                commandQueue.EnqueueNDRangeKernel(kernelSeedA, 1, 2048 * 128, 128, 0);
                                                                                commandQueue.EnqueueNDRangeKernel(kernelSeedB1, 1, 1024 * 128, 128, 0);
                                                                                commandQueue.EnqueueNDRangeKernel(kernelSeedB2, 1, 1024 * 128, 128, 0);
                                                                                commandQueue.EnqueueClearBuffer(bufferI1, 64 * 64 * 4, clearPattern);
                                                                                commandQueue.EnqueueNDRangeKernel(kernelRound1, 1, 4096 * 1024, 1024, 0);

                                                                                commandQueue.EnqueueClearBuffer(bufferI2, 64 * 64 * 4, clearPattern);
                                                                                commandQueue.EnqueueNDRangeKernel(kernelRoundO, 1, 4096 * 1024, 1024, 0);
                                                                                commandQueue.EnqueueClearBuffer(bufferI1, 64 * 64 * 4, clearPattern);
                                                                                commandQueue.EnqueueNDRangeKernel(kernelRoundNB, 1, 4096 * 1024, 1024, 0);

                                                                                for (int r = 0; r < trimRounds; r++)
                                                                                {
                                                                                    commandQueue.EnqueueClearBuffer(bufferI2, 64 * 64 * 4, clearPattern);
                                                                                    commandQueue.EnqueueNDRangeKernel(kernelRoundNA, 1, 4096 * 1024, 1024, 0);
                                                                                    commandQueue.EnqueueClearBuffer(bufferI1, 64 * 64 * 4, clearPattern);
                                                                                    commandQueue.EnqueueNDRangeKernel(kernelRoundNB, 1, 4096 * 1024, 1024, 0);
                                                                                }

                                                                                commandQueue.EnqueueClearBuffer(bufferI2, 64 * 64 * 4, clearPattern);
                                                                                commandQueue.EnqueueNDRangeKernel(kernelTail, 1, 4096 * 1024, 1024, 0);

                                                                                edgesCount    = commandQueue.EnqueueReadBuffer <uint>(bufferI2, 1);
                                                                                edgesCount[0] = edgesCount[0] > 1000000 ? 1000000 : edgesCount[0];
                                                                                edgesLeft     = commandQueue.EnqueueReadBuffer(bufferA1, (int)edgesCount[0] * 2);

                                                                                OpenCl.DotNetCore.Interop.CommandQueues.CommandQueuesNativeApi.Flush(commandQueue.Handle);
                                                                                OpenCl.DotNetCore.Interop.CommandQueues.CommandQueuesNativeApi.Finish(commandQueue.Handle);

                                                                                sw.Stop();

                                                                                currentJob.trimTime = sw.ElapsedMilliseconds;
                                                                                currentJob.solvedAt = DateTime.Now;

                                                                                Logger.Log(LogLevel.Info, string.Format("GPU AMD{2}:    Trimmed in {0}ms to {1} edges", sw.ElapsedMilliseconds, edgesCount[0], deviceID));

                                                                                CGraph cg = new CGraph();
                                                                                cg.SetEdges(edgesLeft, (int)edgesCount[0]);
                                                                                cg.SetHeader(currentJob);

                                                                                Task.Factory.StartNew(() =>
                                                                                {
                                                                                    if (edgesCount[0] < 200000)
                                                                                    {
                                                                                        try
                                                                                        {
                                                                                            if (findersInFlight++ < 3)
                                                                                            {
                                                                                                Stopwatch cycleTime = new Stopwatch();
                                                                                                cycleTime.Start();
                                                                                                cg.FindSolutions(graphSolutions);
                                                                                                cycleTime.Stop();
                                                                                                AdjustTrims(cycleTime.ElapsedMilliseconds);
                                                                                                if (TEST)
                                                                                                {
                                                                                                    Logger.Log(LogLevel.Info, string.Format("Finder completed in {0}ms on {1} edges with {2} solution(s) and {3} dupes", sw.ElapsedMilliseconds, edgesCount[0], graphSolutions.Count, cg.dupes));

                                                                                                    if (++trims % 50 == 0)
                                                                                                    {
                                                                                                        Console.ForegroundColor = ConsoleColor.Green;
                                                                                                        Console.WriteLine("SOLS: {0}/{1} - RATE: {2:F1}", solutions, trims, (float)trims / solutions);
                                                                                                        Console.ResetColor();
                                                                                                    }
                                                                                                }
                                                                                                if (graphSolutions.Count > 0)
                                                                                                {
                                                                                                    solutions++;
                                                                                                }
                                                                                            }
                                                                                            else
                                                                                            {
                                                                                                Logger.Log(LogLevel.Warning, "CPU overloaded!");
                                                                                            }
                                                                                        }
                                                                                        catch (Exception ex)
                                                                                        {
                                                                                            Logger.Log(LogLevel.Error, "Cycle finder crashed " + ex.Message);
                                                                                        }
                                                                                        finally
                                                                                        {
                                                                                            findersInFlight--;
                                                                                        }
                                                                                    }
                                                                                });
                                                                            }
                                                                            catch (Exception ex)
                                                                            {
                                                                                Logger.Log(LogLevel.Error, "Critical error in main ocl loop " + ex.Message);
                                                                                Task.Delay(5000).Wait();
                                                                            }
                                                                        }

                                                                        //uint[] resultArray = commandQueue.EnqueueReadBuffer<uint>(bufferI1, 64 * 64);
                                                                        //uint[] resultArray2 = commandQueue.EnqueueReadBuffer<uint>(bufferI2, 64 * 64);
                                                                        //Console.WriteLine("SeedA: " + resultArray.Sum(e => e) + " in " + sw.ElapsedMilliseconds / runs);
                                                                        //Console.WriteLine("SeedB: " + resultArray2.Sum(e => e) + " in " + sw.ElapsedMilliseconds / runs);
                                                                        //Task.Delay(1000).Wait();
                                                                        //Console.WriteLine("");
                                                                    }
                                }
                                finally
                                {
                                    // clear pattern
                                    if (clearPattern != IntPtr.Zero)
                                    {
                                        Marshal.FreeHGlobal(clearPattern);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Log(LogLevel.Error, "Critical error in OCL Init " + ex.Message);
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine(ex.Message);
                Console.ResetColor();
                Task.Delay(500).Wait();
            }
            finally
            {
                Task.Delay(500).Wait();

                try
                {
                    Comms.Close();
                    bufferA1.Dispose();
                    bufferA2.Dispose();
                    bufferB.Dispose();
                    bufferI1.Dispose();
                    bufferI2.Dispose();
                    bufferR.Dispose();

                    if (OpenCl.DotNetCore.CommandQueues.CommandQueue.resultValuePointer != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(OpenCl.DotNetCore.CommandQueues.CommandQueue.resultValuePointer);
                    }
                }
                catch { }
            }

            //Console.ReadKey();
        }