internal ProgramBuildLog(ComputeDevice computeDevice, string log) { Contract.Requires(computeDevice != null); ComputeDevice = computeDevice; Log = log; }
public virtual void Initialize() { platform = ComputePlatform.Platforms[0]; device = platform.Devices[0]; properties = new ComputeContextPropertyList(platform); context = new ComputeContext(new[] { device }, properties, null, IntPtr.Zero); program = new ComputeProgram(context, KernelSrc); }
public RenderWindow(ComputeDevice device, Action<string> setStatusBar) : base(GraphicsMode.Default, 0, 0, GraphicsContextFlags.ForwardCompatible) { _setStatusBar = setStatusBar; _interop = new GraphicsInterop(Context, device); _lastUpdate = DateTime.UtcNow; ThreadPool.QueueUserWorkItem(DoTimerTick); }
/// <summary> /// Construct an OpenCL device. /// </summary> /// /// <param name="platform">The platform.</param> /// <param name="device">The device.</param> public EncogCLDevice(EncogCLPlatform platform, ComputeDevice device) { this.platform = platform; Enabled = true; this.device = device; Name = this.device.Name; Vender = this.device.Vendor; this.cpu = (this.device.Type == ComputeDeviceTypes.Cpu); this.queue = new EncogCLQueue(this); }
public static IGpuHelper CreateHelper(ComputePlatform platform, ComputeDevice device, FPType fptype) { ComputeContextPropertyList properties = new ComputeContextPropertyList(platform); var context = new ComputeContext(new[] { device }, properties, null, IntPtr.Zero); if (fptype == FPType.Single) { return new GpuHelper<float>(context, fptype); } else { return new GpuHelper<double>(context, fptype); } }
public OpenCLPasswordMatcher () { if (ComputePlatform.Platforms.Count == 0) { Console.WriteLine ("Cound not find any OpenCL platforms"); Environment.Exit (1); } var platform = ComputePlatform.Platforms [0]; logger.Info ("Found {0} computing devices:", platform.Devices.Count); foreach (var d in platform.Devices) { logger.Info ("* {0}", d.Name); } Context = new ComputeContext (ComputeDeviceTypes.All, new ComputeContextPropertyList (platform), null, IntPtr.Zero); Device = Context.Devices [0]; logger.Info ("Using first device."); // load opencl source StreamReader streamReader = new StreamReader (MD5_OPENCL_FILE); string clSource = streamReader.ReadToEnd (); streamReader.Close (); // create program with opencl source ComputeProgram program = new ComputeProgram (Context, clSource); // compile opencl source try { program.Build (null, null, null, IntPtr.Zero); } catch (Exception e) { logger.Error ("Build log: " + program.GetBuildLog(Device)); throw e; } // load chosen kernel from program Kernel = program.CreateKernel ("crackMD5"); }
public GraphicsInterop() { var glHandle = ((IGraphicsContextInternal)GraphicsContext.CurrentContext).Context.Handle; var wglHandle = wglGetCurrentDC(); _device = ComputePlatform.Platforms[0].Devices[0]; var p1 = new ComputeContextProperty(ComputeContextPropertyName.Platform, Device.Platform.Handle.Value); var p2 = new ComputeContextProperty(ComputeContextPropertyName.CL_GL_CONTEXT_KHR, glHandle); var p3 = new ComputeContextProperty(ComputeContextPropertyName.CL_WGL_HDC_KHR, wglHandle); var cpl = new ComputeContextPropertyList(new[] { p1, p2, p3 }); _context = new ComputeContext(ComputeDeviceTypes.Gpu, cpl, null, IntPtr.Zero); _queue = new ComputeCommandQueue(Context, Device, ComputeCommandQueueFlags.None); GL.ClearColor(0f, 0f, 1f, 1f); GL.MatrixMode(MatrixMode.Projection); GL.LoadIdentity(); GL.Ortho(0, 1.0f, 0, 1.0f, -1.0f, 1.0f); GL.MatrixMode(MatrixMode.Modelview); GL.LoadIdentity(); GL.GenBuffers(1, out _pub); GL.Enable(EnableCap.Texture2D); _texture = GL.GenTexture(); }
private void CreateOpenCLContext(OpenCLNNInitParameters oclInitPars) { ComputePlatform platform = null; if (String.IsNullOrEmpty(oclInitPars.PlatformName)) { platform = OpenCLContext.DefaultPlatform; } else { platform = OpenCLContext.Platforms.Where(p => string.Compare(oclInitPars.PlatformName, p.Name, true) == 0).FirstOrDefault(); } if (platform == null) throw new OpenCLException("Platform '" + oclInitPars.PlatformName + "' not found."); oclContext = new OpenCLContext(ComputeDeviceTypes.All, platform); try { if (string.IsNullOrEmpty(oclInitPars.DeviceName)) { oclDevice = oclContext.DefaultDevice; //oclDevice = oclContext.Devices.Where(d => d.Type == ComputeDeviceTypes.Cpu).First(); } else { oclDevice = oclContext.Devices.Where(d => string.Compare(oclInitPars.DeviceName, d.Name, true) == 0).FirstOrDefault(); } if (oclDevice == null) throw new OpenCLException("Device '" + oclInitPars.DeviceName + "' not found."); oclQueue = oclContext.CreateQueue(oclDevice, ComputeCommandQueueFlags.OutOfOrderExecution); } catch { oclContext.Dispose(); oclContext = null; throw; } }
public static Tuple <ComputeDevice, DeviceMiningStatus> GetDeviceMiningStatus(ComputeDevice device) { var status = DeviceMiningStatus.CanMine; if (device == null) { // C# is null happy status = DeviceMiningStatus.DeviceNull; } else if (device.IsDisabled) { status = DeviceMiningStatus.Disabled; } else { var hasEnabledAlgo = device.AlgorithmSettings.Aggregate(false, (current, algo) => current | (IsAlgoMiningCapable(algo) || algo is PluginAlgorithm)); if (hasEnabledAlgo == false) { status = DeviceMiningStatus.NoEnabledAlgorithms; } } return(new Tuple <ComputeDevice, DeviceMiningStatus>(device, status)); }
private static string ParseForMiningPairs(List <MiningPair> MiningPairs, AlgorithmType algorithmType, DeviceType deviceType, string minerPath, bool showLog = true) { _showLog = showLog; // parse for nheqminer bool deviceCheckSkip = algorithmType == AlgorithmType.Equihash || algorithmType == AlgorithmType.DaggerHashimoto; if (algorithmType == AlgorithmType.Equihash) { // nheqminer if (minerPath == MinerPaths.nheqminer) { if (deviceType == DeviceType.CPU) { CheckAndSetCPUPairs(MiningPairs); return(Parse(MiningPairs, _nheqminer_CPU_Options)); } if (deviceType == DeviceType.NVIDIA) { return(Parse(MiningPairs, _nheqminer_CUDA_Options)); } if (deviceType == DeviceType.AMD) { return(Parse(MiningPairs, _nheqminer_AMD_Options)); } } else if (minerPath == MinerPaths.eqm) { if (deviceType == DeviceType.CPU) { CheckAndSetCPUPairs(MiningPairs); return(Parse(MiningPairs, _eqm_CPU_Options)); } if (deviceType == DeviceType.NVIDIA) { return(Parse(MiningPairs, _eqm_CUDA_Options)); } } else if (minerPath == MinerPaths.ClaymoreZcashMiner) { return(Parse(MiningPairs, _ClaymoreZcash_Options)); } } else if (algorithmType == AlgorithmType.DaggerHashimoto) // ethminer dagger // use if missing compute device for correct mapping // init fakes workaround { var cdevs_mappings = new List <MiningPair>(); { int id = -1; var fakeAlgo = new Algorithm(AlgorithmType.DaggerHashimoto, "daggerhashimoto"); foreach (var pair in MiningPairs) { while (++id != pair.Device.ID) { var fakeCdev = new ComputeDevice(id); cdevs_mappings.Add(new MiningPair(fakeCdev, fakeAlgo)); } cdevs_mappings.Add(pair); } } if (deviceType == DeviceType.NVIDIA) { return(Parse(cdevs_mappings, _cudaEthminerOptions)); } else if (deviceType == DeviceType.AMD) { return(Parse(cdevs_mappings, _oclEthminerOptions)); } } else if (deviceCheckSkip == false) { // parse for device if (deviceType == DeviceType.CPU) { CheckAndSetCPUPairs(MiningPairs); return(Parse(MiningPairs, _cpuminerOptions)); } else if (deviceType == DeviceType.NVIDIA) { if (algorithmType != AlgorithmType.CryptoNight) { return(Parse(MiningPairs, _ccimerOptions)); } else if (algorithmType == AlgorithmType.CryptoNight) { // check if any device is SM21 or SM3.x if yes return empty for stability reasons foreach (var pair in MiningPairs) { var groupType = pair.Device.DeviceGroupType; if (groupType == DeviceGroupType.NVIDIA_2_1 || groupType == DeviceGroupType.NVIDIA_3_x) { return(""); } } return(Parse(MiningPairs, _ccimerCryptoNightOptions, true)); } } else if (deviceType == DeviceType.AMD) { // rawIntensity overrides xintensity, xintensity overrides intensity var sgminer_intensities = new List <MinerOption>() { new MinerOption(MinerOptionType.Intensity, "-I", "--intensity", "d", MinerOptionFlagType.MultiParam, ","), // default is "d" check if -1 works new MinerOption(MinerOptionType.Xintensity, "-X", "--xintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none new MinerOption(MinerOptionType.Rawintensity, "", "--rawintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none }; var contains_intensity = new Dictionary <MinerOptionType, bool>() { { MinerOptionType.Intensity, false }, { MinerOptionType.Xintensity, false }, { MinerOptionType.Rawintensity, false }, }; // check intensity and xintensity, the latter overrides so change accordingly foreach (var cDev in MiningPairs) { foreach (var intensityOption in sgminer_intensities) { if (!string.IsNullOrEmpty(intensityOption.ShortName) && cDev.CurrentExtraLaunchParameters.Contains(intensityOption.ShortName)) { cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace(intensityOption.ShortName, intensityOption.LongName); contains_intensity[intensityOption.Type] = true; } if (cDev.CurrentExtraLaunchParameters.Contains(intensityOption.LongName)) { contains_intensity[intensityOption.Type] = true; } } } // replace if (contains_intensity[MinerOptionType.Intensity] && contains_intensity[MinerOptionType.Xintensity]) { LogParser("Sgminer replacing --intensity with --xintensity"); foreach (var cDev in MiningPairs) { cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--intensity", "--xintensity"); } } if (contains_intensity[MinerOptionType.Xintensity] && contains_intensity[MinerOptionType.Rawintensity]) { LogParser("Sgminer replacing --xintensity with --rawintensity"); foreach (var cDev in MiningPairs) { cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--xintensity", "--rawintensity"); } } List <MinerOption> sgminerOptionsNew = new List <MinerOption>(); string temperatureControl = ""; // temp control and parse if (ConfigManager.GeneralConfig.DisableAMDTempControl) { LogParser("DisableAMDTempControl is TRUE, temp control parameters will be ignored"); } else { LogParser("Sgminer parsing temperature control parameters"); temperatureControl = Parse(MiningPairs, _sgminerTemperatureOptions, true, _sgminerOptions); } LogParser("Sgminer parsing default parameters"); string returnStr = String.Format("{0} {1}", Parse(MiningPairs, _sgminerOptions, false, _sgminerTemperatureOptions), temperatureControl); LogParser("Sgminer extra launch parameters merged: " + returnStr); return(returnStr); } } return(""); }
public static Tuple <ComputeDevice, DeviceMiningStatus> getDeviceMiningStatus(ComputeDevice device) { DeviceMiningStatus status = DeviceMiningStatus.CanMine; if (device == null) // C# is null happy { status = DeviceMiningStatus.DeviceNull; } else if (device.Enabled == false) { status = DeviceMiningStatus.Disabled; } else { bool hasEnabledAlgo = false; foreach (Algorithm algo in device.GetAlgorithmSettings()) { hasEnabledAlgo |= IsAlgoMiningCapable(algo) && MinerPaths.IsValidMinerPath(algo.MinerBinaryPath); } if (hasEnabledAlgo == false) { status = DeviceMiningStatus.NoEnabledAlgorithms; } } return(new Tuple <ComputeDevice, DeviceMiningStatus>(device, status)); }
void NextBenchmark() { if (_bechmarkCurrentIndex > -1) { StepUpBenchmarkStepProgress(); } ++_bechmarkCurrentIndex; if (_bechmarkCurrentIndex >= _benchmarkAlgorithmsCount) { EndBenchmark(); return; } Tuple <ComputeDevice, Queue <Algorithm> > currentDeviceAlgosTuple; Queue <Algorithm> algorithmBenchmarkQueue; while (_benchmarkDevicesAlgorithmQueue.Count > 0) { currentDeviceAlgosTuple = _benchmarkDevicesAlgorithmQueue[0]; _currentDevice = currentDeviceAlgosTuple.Item1; algorithmBenchmarkQueue = currentDeviceAlgosTuple.Item2; if (algorithmBenchmarkQueue.Count != 0) { _currentAlgorithm = algorithmBenchmarkQueue.Dequeue(); break; } else { _benchmarkDevicesAlgorithmQueue.RemoveAt(0); } } if (_currentDevice != null && _currentAlgorithm != null) { _currentMiner = MinerFactory.CreateMiner(_currentDevice, _currentAlgorithm); if (_currentAlgorithm.MinerBaseType == MinerBaseType.XmrStackCPU && _currentAlgorithm.NiceHashID == AlgorithmType.CryptoNight && string.IsNullOrEmpty(_currentAlgorithm.ExtraLaunchParameters) && _currentAlgorithm.ExtraLaunchParameters.Contains("enable_ht=true") == false) { __CPUBenchmarkStatus = new CPUBenchmarkStatus(Globals.ThreadsPerCPU); _currentAlgorithm.LessThreads = __CPUBenchmarkStatus.LessTreads; } else { __CPUBenchmarkStatus = null; } if (_currentAlgorithm.MinerBaseType == MinerBaseType.Claymore && _currentAlgorithm.NiceHashID == AlgorithmType.Equihash && _currentAlgorithm.ExtraLaunchParameters != null && !_currentAlgorithm.ExtraLaunchParameters.Contains("-asm")) { __ClaymoreZcashStatus = new ClaymoreZcashStatus(_currentAlgorithm.ExtraLaunchParameters); _currentAlgorithm.ExtraLaunchParameters = __ClaymoreZcashStatus.GetTestExtraParams(); } else { __ClaymoreZcashStatus = null; } } if (_currentMiner != null && _currentAlgorithm != null) { _benchmarkMiners.Add(_currentMiner); CurrentAlgoName = AlgorithmNiceHashNames.GetName(_currentAlgorithm.NiceHashID); _currentMiner.InitBenchmarkSetup(new MiningPair(_currentDevice, _currentAlgorithm)); var time = ConfigManager.GeneralConfig.BenchmarkTimeLimits .GetBenchamrktime(benchmarkOptions1.PerformanceType, _currentDevice.DeviceGroupType); //currentConfig.TimeLimit = time; if (__CPUBenchmarkStatus != null) { __CPUBenchmarkStatus.Time = time; } if (__ClaymoreZcashStatus != null) { __ClaymoreZcashStatus.Time = time; } // dagger about 4 minutes var showWaitTime = _currentAlgorithm.NiceHashID == AlgorithmType.DaggerHashimoto ? 4 * 60 : time; dotCount = 0; _benchmarkingTimer.Start(); _currentMiner.BenchmarkStart(time, this); algorithmsListView1.SetSpeedStatus(_currentDevice, _currentAlgorithm, getDotsWaitString()); } else { NextBenchmark(); } }
public GraphicsInterop(IGraphicsContext context, ComputeDevice device) { var os = Environment.OSVersion.Platform; ComputeContextProperty platformDependantCcp; switch (os) { case PlatformID.Unix: platformDependantCcp = GetUnixCcp(); break; case PlatformID.MacOSX: platformDependantCcp = GetMacCcp(context); break; default: platformDependantCcp = GetWindowsCcp(); break; } var glHandle = ((IGraphicsContextInternal)context).Context.Handle; var p1 = new ComputeContextProperty(ComputeContextPropertyName.Platform, device.Platform.Handle.Value); var p2 = new ComputeContextProperty(ComputeContextPropertyName.CL_GL_CONTEXT_KHR, glHandle); var cpl = new ComputeContextPropertyList(new[] { p1, p2, platformDependantCcp }); _context = new ComputeContext(ComputeDeviceTypes.Gpu, cpl, null, IntPtr.Zero); _queue = new ComputeCommandQueue(Context, device, ComputeCommandQueueFlags.None); GL.ClearColor(0f, 0f, 1f, 1f); GL.MatrixMode(MatrixMode.Projection); GL.LoadIdentity(); GL.Ortho(0, 1.0f, 0, 1.0f, -1.0f, 1.0f); GL.MatrixMode(MatrixMode.Modelview); GL.LoadIdentity(); GL.GenBuffers(1, out _pub); GL.Enable(EnableCap.Texture2D); _texture = GL.GenTexture(); }
// we don't want to group CPU devices private bool IsGroupBinaryAndAlgorithmSame(ComputeDevice a, ComputeDevice b) { return(IsNotCpuGroups(a, b) && IsAlgorithmSettingsSame(a.MostProfitableAlgorithm, b.MostProfitableAlgorithm) && IsSameBinPath(a, b)); }
override unsafe protected void MinerThread() { ComputeProgram program = null; try { Random r = new Random(); ComputeDevice computeDevice = OpenCLDevice.GetComputeDevice(); UInt32[] ethashOutput = new UInt32[256]; byte[] ethashHeaderhash = new byte[32]; MarkAsAlive(); MainForm.Logger("Miner thread for Device #" + DeviceIndex + " started."); program = BuildProgram("ethash_pascal", mEthashLocalWorkSizeArray[0], "-O1", "", ""); MemoryUsage = 256; MemoryUsage += 32; MemoryUsage += sPascalInputSize; MemoryUsage += sPascalOutputSize; MemoryUsage += sPascalMidstateSize; using (var searchKernel = program.CreateKernel("search")) using (var DAGKernel = program.CreateKernel("GenerateDAG")) using (var ethashOutputBuffer = new ComputeBuffer <UInt32>(Context, ComputeMemoryFlags.ReadWrite, 256)) using (var ethashHeaderBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadOnly, 32)) using (var pascalInputBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadOnly, sPascalInputSize)) using (var pascalOutputBuffer = new ComputeBuffer <UInt32>(Context, ComputeMemoryFlags.ReadWrite, sPascalOutputSize)) using (var pascalMidstateBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadOnly, sPascalMidstateSize)) fixed(UInt32 *ethashOutputPtr = ethashOutput) fixed(byte *ethashHeaderhashPtr = ethashHeaderhash) fixed(byte *pascalMidstatePtr = mPascalMidstate) fixed(byte *pascalInputPtr = mPascalInput) fixed(UInt32 * pascalOutputPtr = mPascalOutput) while (!Stopped) { ComputeBuffer <byte> ethashDAGBuffer = null; MarkAsAlive(); try { int ethashEpoch = -1; long ethashDAGSize = 0; searchKernel.SetMemoryArgument(7 + 0, pascalInputBuffer); searchKernel.SetMemoryArgument(7 + 1, pascalOutputBuffer); searchKernel.SetMemoryArgument(7 + 4, pascalMidstateBuffer); searchKernel.SetValueArgument <UInt32>(7 + 5, mPascalRatio); // Wait for the first job to arrive. int elapsedTime = 0; while ((PrimaryStratum == null || PrimaryStratum.GetJob() == null || SecondaryStratum == null || SecondaryStratum.GetJob() == null) && elapsedTime < Parameters.TimeoutForFirstJobInMilliseconds && !Stopped) { Thread.Sleep(100); elapsedTime += 100; } if (PrimaryStratum == null || PrimaryStratum.GetJob() == null || SecondaryStratum == null || SecondaryStratum.GetJob() == null) { throw new TimeoutException("Stratum server failed to send a new job."); } System.Diagnostics.Stopwatch consoleUpdateStopwatch = new System.Diagnostics.Stopwatch(); EthashStratum.Work ethashWork; EthashStratum.Job ethashJob; PascalStratum.Work pascalWork; PascalStratum.Job pascalJob; while (!Stopped && (ethashWork = PrimaryStratum.GetWork()) != null && (ethashJob = ethashWork.GetJob()) != null && (pascalWork = SecondaryStratum.GetWork()) != null && (pascalJob = pascalWork.Job) != null) { MarkAsAlive(); String ethashPoolExtranonce = PrimaryStratum.PoolExtranonce; byte[] ethashExtranonceByteArray = Utilities.StringToByteArray(ethashPoolExtranonce); byte ethashLocalExtranonce = (byte)ethashWork.LocalExtranonce; UInt64 ethashStartNonce = (UInt64)ethashLocalExtranonce << (8 * (7 - ethashExtranonceByteArray.Length)); for (int i = 0; i < ethashExtranonceByteArray.Length; ++i) { ethashStartNonce |= (UInt64)ethashExtranonceByteArray[i] << (8 * (7 - i)); } ethashStartNonce += (ulong)r.Next(0, int.MaxValue) & (0xfffffffffffffffful >> (ethashExtranonceByteArray.Length * 8 + 8)); String ethashJobID = ethashJob.ID; String ethashSeedhash = ethashJob.Seedhash; double ethashDifficulty = PrimaryStratum.Difficulty; Buffer.BlockCopy(Utilities.StringToByteArray(ethashWork.GetJob().Headerhash), 0, ethashHeaderhash, 0, 32); Queue.Write <byte>(ethashHeaderBuffer, true, 0, 32, (IntPtr)ethashHeaderhashPtr, null); Array.Copy(pascalWork.Blob, mPascalInput, sPascalInputSize); CalculatePascalMidState(); Queue.Write <byte>(pascalMidstateBuffer, true, 0, sPascalMidstateSize, (IntPtr)pascalMidstatePtr, null); UInt32 pascalStartNonce = (UInt32)(r.Next(0, int.MaxValue)); UInt64 PascalTarget = (UInt64)((double)0xffff0000UL / SecondaryStratum.Difficulty); searchKernel.SetValueArgument <UInt64>(7 + 3, PascalTarget); Queue.Write <byte>(pascalInputBuffer, true, 0, sPascalInputSize, (IntPtr)pascalInputPtr, null); if (ethashEpoch != ethashWork.GetJob().Epoch) { if (ethashDAGBuffer != null) { MemoryUsage -= ethashDAGBuffer.Size; ethashDAGBuffer.Dispose(); ethashDAGBuffer = null; } ethashEpoch = ethashWork.GetJob().Epoch; DAGCache cache = new DAGCache(ethashEpoch, ethashWork.GetJob().Seedhash); ethashDAGSize = Utilities.GetDAGSize(ethashEpoch); System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); mEthashGlobalWorkSizeArray[0] = ethashDAGSize / 64; mEthashGlobalWorkSizeArray[0] /= 8; if (mEthashGlobalWorkSizeArray[0] % mEthashLocalWorkSizeArray[0] > 0) { mEthashGlobalWorkSizeArray[0] += mEthashLocalWorkSizeArray[0] - mEthashGlobalWorkSizeArray[0] % mEthashLocalWorkSizeArray[0]; } ComputeBuffer <byte> DAGCacheBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadOnly, cache.GetData().Length); MemoryUsage += DAGCacheBuffer.Size; fixed(byte *p = cache.GetData()) Queue.Write <byte>(DAGCacheBuffer, true, 0, cache.GetData().Length, (IntPtr)p, null); ethashDAGBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, mEthashGlobalWorkSizeArray[0] * 8 * 64 /* ethashDAGSize */); // With this, we can remove a conditional statement in the DAG kernel. MemoryUsage += ethashDAGBuffer.Size; DAGKernel.SetValueArgument <UInt32>(0, 0); DAGKernel.SetMemoryArgument(1, DAGCacheBuffer); DAGKernel.SetMemoryArgument(2, ethashDAGBuffer); DAGKernel.SetValueArgument <UInt32>(3, (UInt32)cache.GetData().Length / 64); DAGKernel.SetValueArgument <UInt32>(4, 0xffffffffu); for (long start = 0; start < ethashDAGSize / 64; start += mEthashGlobalWorkSizeArray[0]) { mEthashGlobalWorkOffsetArray[0] = start; Queue.Execute(DAGKernel, mEthashGlobalWorkOffsetArray, mEthashGlobalWorkSizeArray, mEthashLocalWorkSizeArray, null); Queue.Finish(); if (Stopped || PrimaryStratum.GetJob() == null || !PrimaryStratum.GetJob().ID.Equals(ethashJobID)) { break; } } DAGCacheBuffer.Dispose(); MemoryUsage -= DAGCacheBuffer.Size; if (Stopped || PrimaryStratum.GetJob() == null || !PrimaryStratum.GetJob().ID.Equals(ethashJobID)) { break; } sw.Stop(); MainForm.Logger("Generated DAG for Epoch #" + ethashEpoch + " (" + (long)sw.Elapsed.TotalMilliseconds + "ms)."); } consoleUpdateStopwatch.Start(); while (!Stopped && PrimaryStratum.GetJob().ID.Equals(ethashJobID) && PrimaryStratum.PoolExtranonce.Equals(ethashPoolExtranonce) && SecondaryStratum.GetJob().Equals(pascalJob)) { System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); MarkAsAlive(); // Get a new local extranonce if necessary. if ((ethashStartNonce & (0xfffffffffffffffful >> (ethashExtranonceByteArray.Length * 8 + 8)) + (ulong)mEthashGlobalWorkSizeArray[0] * 3 / 4) >= ((ulong)0x1 << (64 - (ethashExtranonceByteArray.Length * 8 + 8)))) { break; } if (0xffffffffu - pascalStartNonce < (UInt32)mEthashGlobalWorkSizeArray[0] * mPascalRatio) { break; } UInt64 target = (UInt64)((double)0xffff0000U / ethashDifficulty); searchKernel.SetMemoryArgument(0, ethashOutputBuffer); // g_output searchKernel.SetMemoryArgument(1, ethashHeaderBuffer); // g_header searchKernel.SetMemoryArgument(2, ethashDAGBuffer); // _g_dag searchKernel.SetValueArgument <UInt32>(3, (UInt32)(ethashDAGSize / 128)); // DAG_SIZE searchKernel.SetValueArgument <UInt64>(4, ethashStartNonce); // start_nonce searchKernel.SetValueArgument <UInt64>(5, target); // target searchKernel.SetValueArgument <UInt32>(6, 0xffffffffu); // isolate searchKernel.SetValueArgument <UInt32>(7 + 2, pascalStartNonce); ethashOutput[255] = 0; // ethashOutput[255] is used as an atomic counter. Queue.Write <UInt32>(ethashOutputBuffer, true, 0, 256, (IntPtr)ethashOutputPtr, null); mEthashGlobalWorkOffsetArray[0] = 0; mPascalOutput[255] = 0; // mPascalOutput[255] is used as an atomic counter. Queue.Write <UInt32>(pascalOutputBuffer, true, 0, sPascalOutputSize, (IntPtr)pascalOutputPtr, null); Queue.Execute(searchKernel, mEthashGlobalWorkOffsetArray, mEthashGlobalWorkSizeArray, mEthashLocalWorkSizeArray, null); Queue.Read <UInt32>(ethashOutputBuffer, true, 0, 256, (IntPtr)ethashOutputPtr, null); if (PrimaryStratum.GetJob() != null && PrimaryStratum.GetJob().ID.Equals(ethashJobID)) { for (int i = 0; i < ethashOutput[255]; ++i) { PrimaryStratum.Submit(Device, ethashWork.GetJob(), ethashStartNonce + (UInt64)ethashOutput[i]); } } ethashStartNonce += (UInt64)mEthashGlobalWorkSizeArray[0] * 3 / 4; Queue.Read <UInt32>(pascalOutputBuffer, true, 0, sPascalOutputSize, (IntPtr)pascalOutputPtr, null); if (SecondaryStratum.GetJob() != null && SecondaryStratum.GetJob().Equals(pascalJob)) { for (int i = 0; i < mPascalOutput[255]; ++i) { SecondaryStratum.Submit(Device, pascalWork, mPascalOutput[i]); } } pascalStartNonce += (UInt32)mEthashGlobalWorkSizeArray[0] * mPascalRatio; sw.Stop(); Speed = ((double)mEthashGlobalWorkSizeArray[0]) / sw.Elapsed.TotalSeconds * 0.75; Device.TotalHashesPrimaryAlgorithm += (double)mEthashGlobalWorkSizeArray[0] * 0.75; SpeedSecondaryAlgorithm = ((double)mEthashGlobalWorkSizeArray[0]) / sw.Elapsed.TotalSeconds * mPascalRatio; Device.TotalHashesSecondaryAlgorithm += (double)mEthashGlobalWorkSizeArray[0] * mPascalRatio; if (consoleUpdateStopwatch.ElapsedMilliseconds >= 10 * 1000) { MainForm.Logger("Device #" + DeviceIndex + ": " + String.Format("{0:N2} Mh/s (Ethash), ", Speed / (1000000)) + String.Format("{0:N2} Mh/s (Pascal)", SpeedSecondaryAlgorithm / (1000000))); consoleUpdateStopwatch.Restart(); } } } } catch (Exception ex) { MainForm.Logger("Exception in miner thread: " + ex.Message + ex.StackTrace); Speed = 0; if (UnrecoverableException.IsUnrecoverableException(ex)) { this.UnrecoverableException = new UnrecoverableException(ex, Device); Stop(); } else { MainForm.Logger("Restarting miner thread..."); System.Threading.Thread.Sleep(Parameters.WaitTimeForRestartingMinerThreadInMilliseconds); } } finally { if (ethashDAGBuffer != null) { MemoryUsage -= ethashDAGBuffer.Size; ethashDAGBuffer.Dispose(); ethashDAGBuffer = null; } } } } catch (UnrecoverableException ex) { this.UnrecoverableException = ex; } catch (Exception ex) { this.UnrecoverableException = new UnrecoverableException(ex, Device); } finally { MarkAsDone(); MemoryUsage = 0; if (program != null) { program.Dispose(); } program = null; } }
void NextBenchmark() { if (_bechmarkCurrentIndex > -1) { StepUpBenchmarkStepProgress(); } ++_bechmarkCurrentIndex; if (_bechmarkCurrentIndex >= _benchmarkAlgorithmsCount) { EndBenchmark(); return; } Tuple <ComputeDevice, Queue <Algorithm> > currentDeviceAlgosTuple; Queue <Algorithm> algorithmBenchmarkQueue; while (_benchmarkDevicesAlgorithmQueue.Count > 0) { currentDeviceAlgosTuple = _benchmarkDevicesAlgorithmQueue[0]; _currentDevice = currentDeviceAlgosTuple.Item1; algorithmBenchmarkQueue = currentDeviceAlgosTuple.Item2; if (algorithmBenchmarkQueue.Count != 0) { _currentAlgorithm = algorithmBenchmarkQueue.Dequeue(); break; } else { _benchmarkDevicesAlgorithmQueue.RemoveAt(0); } } var currentConfig = _currentDevice.DeviceBenchmarkConfig; if (_currentDevice.DeviceGroupType == DeviceGroupType.CPU) { _currentMiner = MinersManager.GetCpuMiner(_currentDevice.Group); } else { _currentMiner = MinersManager.CreateMiner(currentConfig.DeviceGroupType, _currentAlgorithm.NiceHashID); } if (_currentMiner != null && _currentAlgorithm != null) { _benchmarkMiners.Add(_currentMiner); CurrentAlgoName = AlgorithmNiceHashNames.GetName(_currentAlgorithm.NiceHashID); // this has no effect for CPU miners _currentMiner.SetCDevs(new string[] { _currentDevice.UUID }); var time = ConfigManager.Instance.GeneralConfig.BenchmarkTimeLimits .GetBenchamrktime(benchmarkOptions1.PerformanceType, _currentDevice.DeviceGroupType); //currentConfig.TimeLimit = time; // dagger about 4 minutes var showWaitTime = _currentAlgorithm.NiceHashID == AlgorithmType.DaggerHashimoto ? 4 * 60 : time; dotCount = 0; _benchmarkingTimer.Start(); _currentMiner.BenchmarkStart(_currentDevice, _currentAlgorithm, time, this); algorithmsListView1.SetSpeedStatus(_currentDevice, _currentAlgorithm.NiceHashID, getDotsWaitString()); } else { NextBenchmark(); } }
internal static Task StopBenchmarForDevice(ComputeDevice device) { return(BenchmarkingComputeDeviceHandler.StopBenchmarkingDevice(device)); }
/// <summary> /// Attempts to initialize OpenCL for the selected GPU. /// </summary> internal void InitializeOpenCL() { // only initialize once if (clKernel != null) return; // unused memory so Cloo doesn't break with a null ptr var userDataPtr = Marshal.AllocCoTaskMem(512); try { clDevice = Gpu.CLDevice; // context we'll be working underneath clContext = new ComputeContext( new[] { clDevice }, new ComputeContextPropertyList(clDevice.Platform), (p1, p2, p3, p4) => { }, userDataPtr); // queue to control device clQueue = new ComputeCommandQueue(clContext, clDevice, ComputeCommandQueueFlags.None); // buffers to store kernel output clBuffer0 = new ComputeBuffer<uint>(clContext, ComputeMemoryFlags.ReadOnly, 16); clBuffer1 = new ComputeBuffer<uint>(clContext, ComputeMemoryFlags.ReadOnly, 16); // obtain the program clProgram = new ComputeProgram(clContext, Gpu.GetSource()); var b = new StringBuilder(); if (Gpu.WorkSize > 0) b.Append(" -D WORKSIZE=").Append(Gpu.WorkSize); if (Gpu.HasBitAlign) b.Append(" -D BITALIGN"); if (Gpu.HasBfiInt) b.Append(" -D BFIINT"); try { // build kernel for device clProgram.Build(new[] { clDevice }, b.ToString(), (p1, p2) => { }, userDataPtr); } catch (ComputeException) { throw new Exception(clProgram.GetBuildLog(clDevice)); } clKernel = clProgram.CreateKernel("search"); } finally { Marshal.FreeCoTaskMem(userDataPtr); } }
private void DeviceCombox_SelectedIndexChanged(object sender, EventArgs e) { var comboBox = sender as ComboBox; if (comboBox == null) return; var selectedDevice = (ComputeDevice) comboBox.SelectedItem; Console.WriteLine("Selected device : " + selectedDevice.Name); _selectedComputePlatform = (ComputePlatform)PlatformCombox.SelectedItem; _selectedComputeDevice = (ComputeDevice)DeviceCombox.SelectedItem; }
private static Dictionary <MinerBaseType, List <Algorithm> > CreateForDevice(ComputeDevice device) { if (device == null) { return(null); } var algoSettings = CreateDefaultsForGroup(device.DeviceGroupType); if (algoSettings == null) { return(null); } if (device.DeviceType == DeviceType.AMD) { // sgminer stuff if (algoSettings.ContainsKey(MinerBaseType.sgminer)) { var sgminerAlgos = algoSettings[MinerBaseType.sgminer]; var lyra2REv2Index = sgminerAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.Lyra2REv2); //var neoScryptIndex = sgminerAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.NeoScrypt); var cryptoNightIndex = sgminerAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.CryptoNight); // Check for optimized version if (lyra2REv2Index > -1) { sgminerAlgos[lyra2REv2Index].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 64 --gpu-threads 2"; } /* * if (!device.Codename.Contains("Tahiti") && neoScryptIndex > -1) * { * sgminerAlgos[neoScryptIndex].ExtraLaunchParameters = * AmdGpuDevice.DefaultParam + * "--nfactor 10 --xintensity 2 --thread-concurrency 8192 --worksize 64 --gpu-threads 2"; * Helpers.ConsolePrint("ComputeDevice", * "The GPU detected (" + device.Codename + * ") is not Tahiti. Changing default gpu-threads to 2."); * } */ if (cryptoNightIndex > -1) { if (device.Codename.Contains("Hawaii")) { sgminerAlgos[cryptoNightIndex].ExtraLaunchParameters = "--rawintensity 640 -w 8 -g 2"; } else if (device.Name.Contains("Vega")) { sgminerAlgos[cryptoNightIndex].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + " --rawintensity 1850 -w 8 -g 2"; } } } if (algoSettings.ContainsKey(MinerBaseType.XmrigAMD)) { var XmrigAMDAlgos = algoSettings[MinerBaseType.XmrigAMD]; int xmrigCryptoNightV7_Index = XmrigAMDAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.CryptoNightV7); int xmrigCryptoNightV8_Index = XmrigAMDAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.CryptoNightV8); //--opencl-launch= XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=640"; XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=640"; if (xmrigCryptoNightV7_Index > -1) { if (device.Codename.Contains("gfx804")) //rx550 { XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=512"; XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=512"; } if (device.Codename.Contains("Pitcairn")) //r7-370 { XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1024"; XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1024"; } if (device.Codename.Contains("Baffin")) //rx460/560 { XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1024"; XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1024"; } if (device.Codename.Contains("Ellesmere")) //rx570/580 { XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1024"; XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1024"; } if (device.Codename.Contains("Hawaii")) { XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1024"; XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1024"; } else if (device.Name.Contains("Vega")) { XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1920"; XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1920"; } } } if (algoSettings.ContainsKey(MinerBaseType.mkxminer)) { var mkxminerAlgos = algoSettings[MinerBaseType.mkxminer]; int mkxminer_Index = mkxminerAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.Lyra2z); //--opencl-launch= //mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " "; if (mkxminer_Index > -1) { if (device.Codename.Contains("gfx804")) //rx550 { mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 21"; } if (device.Codename.Contains("Pitcairn")) //r7-370 { mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 21"; } if (device.Codename.Contains("Baffin")) //rx460/560 { mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 22"; } if (device.Codename.Contains("Ellesmere")) //rx570/580 { mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 23"; } if (device.Codename.Contains("Hawaii")) { mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 22";; } else if (device.Name.Contains("Vega")) { mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 24"; } } } // Ellesmere, Polaris // Ellesmere sgminer workaround, keep this until sgminer is fixed to work with Ellesmere if (device.Codename.Contains("Ellesmere") || device.InfSection.ToLower().Contains("polaris")) { foreach (var algosInMiner in algoSettings) { foreach (var algo in algosInMiner.Value) { // disable all algos in list if (algo.NiceHashID == AlgorithmType.Decred || algo.NiceHashID == AlgorithmType.Lbry) { algo.Enabled = false; } } } } // non sgminer optimizations if (algoSettings.ContainsKey(MinerBaseType.Claymore_old) && algoSettings.ContainsKey(MinerBaseType.Claymore)) { var claymoreOldAlgos = algoSettings[MinerBaseType.Claymore_old]; var cryptoNightOldIndex = claymoreOldAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.CryptoNight); var claymoreNewAlgos = algoSettings[MinerBaseType.Claymore]; var cryptoNightNewIndex = claymoreNewAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.CryptoNight); if (cryptoNightOldIndex > -1 && cryptoNightNewIndex > -1) { //string regex_a_3 = "[5|6][0-9][0-9][0-9]"; var a4 = new List <string> { "270", "270x", "280", "280x", "290", "290x", "370", "380", "390", "470", "480" }; foreach (var namePart in a4) { if (!device.Name.Contains(namePart)) { continue; } claymoreOldAlgos[cryptoNightOldIndex].ExtraLaunchParameters = "-a 4"; break; } var old = new List <string> { "Verde", "Oland", "Bonaire" }; foreach (var codeName in old) { var isOld = device.Codename.Contains(codeName); claymoreOldAlgos[cryptoNightOldIndex].Enabled = isOld; claymoreNewAlgos[cryptoNightNewIndex].Enabled = !isOld; } } } // drivers algos issue if (device.DriverDisableAlgos) { algoSettings = FilterMinerAlgos(algoSettings, new List <AlgorithmType> { // AlgorithmType.NeoScrypt, // AlgorithmType.Lyra2REv2 }); } // disable another gpu //Helpers.ConsolePrint("GPU device", "Name: "+device.Name); if (algoSettings.ContainsKey(MinerBaseType.CastXMR) && (!device.Name.Contains("470") && !device.Name.Contains("480") && !device.Name.Contains("570") && !device.Name.Contains("580") && !device.Name.Contains("Vega")) ) { algoSettings = FilterMinerBaseTypes(algoSettings, new List <MinerBaseType> { MinerBaseType.CastXMR }); } // disable by default { var minerBases = new List <MinerBaseType> { MinerBaseType.ethminer, MinerBaseType.OptiminerAMD }; foreach (var minerKey in minerBases) { if (!algoSettings.ContainsKey(minerKey)) { continue; } foreach (var algo in algoSettings[minerKey]) { algo.Enabled = false; } } if (algoSettings.ContainsKey(MinerBaseType.sgminer)) { foreach (var algo in algoSettings[MinerBaseType.sgminer]) { if (algo.NiceHashID == AlgorithmType.DaggerHashimoto) { algo.Enabled = false; } } } //if (algoSettings.ContainsKey(MinerBaseType.Claymore)) { // foreach (var algo in algoSettings[MinerBaseType.Claymore]) { // if (algo.NiceHashID == AlgorithmType.CryptoNight) { // algo.Enabled = false; // } // } //} } } // END AMD case // check if it is Etherum capable if (device.IsEtherumCapale == false) { algoSettings = FilterMinerAlgos(algoSettings, new List <AlgorithmType> { AlgorithmType.DaggerHashimoto }); } if (algoSettings.ContainsKey(MinerBaseType.ccminer_alexis)) { foreach (var unstableAlgo in algoSettings[MinerBaseType.ccminer_alexis]) { unstableAlgo.Enabled = false; } } if (algoSettings.ContainsKey(MinerBaseType.experimental)) { foreach (var unstableAlgo in algoSettings[MinerBaseType.experimental]) { unstableAlgo.Enabled = false; } } // This is not needed anymore after excavator v1.1.4a //if (device.IsSM50() && algoSettings.ContainsKey(MinerBaseType.excavator)) { // int Equihash_index = algoSettings[MinerBaseType.excavator].FindIndex((algo) => algo.NiceHashID == AlgorithmType.Equihash); // if (Equihash_index > -1) { // // -c1 1 needed for SM50 to work ATM // algoSettings[MinerBaseType.excavator][Equihash_index].ExtraLaunchParameters = "-c1 1"; // } //} // NhEqMiner exceptions scope { const MinerBaseType minerBaseKey = MinerBaseType.nheqminer; if (algoSettings.ContainsKey(minerBaseKey) && device.Name.Contains("GTX") && (device.Name.Contains("560") || device.Name.Contains("650") || device.Name.Contains("680") || device.Name.Contains("770")) ) { algoSettings = FilterMinerBaseTypes(algoSettings, new List <MinerBaseType> { minerBaseKey }); } } return(algoSettings); }
public void AttachToDevice(object device) { this.computeDevice = device as ComputeDevice ?? throw new ArgumentException($"{nameof(ComputeDevice)} required", nameof(device)); InitComputeKernel(); }
public static object[] GetDeviceRowData(ComputeDevice d) { object[] rowData = { d.Enabled, d.GetFullName() }; return(rowData); }
public OpenClData([NotNull] ComputeContext context, [NotNull] ComputeDevice device, bool failed) { Context = context; Device = device; InitFailed = failed; }
internal static void SetCurrentStatus(ComputeDevice dev, AlgorithmContainer algo, string status) { //var args = new AlgoStatusEventArgs(dev, algo, status); // TODO append to NotificationInfo instance //OnAlgoStatusUpdate?.Invoke(null, args); }
/// <summary> /// Gets a read-only collection of available <see cref="ComputeDevice"/>s on the <see cref="ComputePlatform"/>. /// </summary> /// <returns> A read-only collection of the available <see cref="ComputeDevice"/>s on the <see cref="ComputePlatform"/>. </returns> /// <remarks> This method resets the <c>ComputePlatform.Devices</c>. This is useful if one or more of them become unavailable (<c>ComputeDevice.Available</c> is <c>false</c>) after a <see cref="ComputeContext"/> and <see cref="ComputeCommandQueue"/>s that use the <see cref="ComputeDevice"/> have been created and commands have been queued to them. Further calls will trigger an <c>OutOfResourcesComputeException</c> until this method is executed. You will also need to recreate any <see cref="ComputeResource"/> that was created on the no longer available <see cref="ComputeDevice"/>. </remarks> public ReadOnlyCollection<ComputeDevice> QueryDevices() { int handlesLength = 0; ComputeErrorCode error = CLInterface.CL12.GetDeviceIDs(Handle, ComputeDeviceTypes.All, 0, null, out handlesLength); ComputeException.ThrowOnError(error); CLDeviceHandle[] handles = new CLDeviceHandle[handlesLength]; error = CLInterface.CL12.GetDeviceIDs(Handle, ComputeDeviceTypes.All, handlesLength, handles, out handlesLength); ComputeException.ThrowOnError(error); ComputeDevice[] devices = new ComputeDevice[handlesLength]; for (int i = 0; i < handlesLength; i++) devices[i] = new ComputeDevice(this, handles[i]); this.devices = new ReadOnlyCollection<ComputeDevice>(devices); return this.devices; }
/// <summary> /// Creates a cloo compute device from base type /// </summary> /// <param name="baseDevice">base compute device</param> /// <returns>cloo compute device</returns> /// <exception cref="ArgumentNullException">baseDevice</exception> /// <exception cref="ArgumentException">Compute device not found, maybe you need to call ClooDevice.UpdateAllDevices()</exception> public static ClooDevice FromBaseDevice(ComputeDevice baseDevice) { if (baseDevice == null) throw new ArgumentNullException("baseDevice"); ClooDevice clooDevice; if (_devicesByHandle.TryGetValue(baseDevice.Handle, out clooDevice)) return clooDevice; throw new ArgumentException("Compute device not found, maybe you need to call ClooDevice.UpdateAllDevices()", "baseDevice"); }
private bool IsNotCpuGroups(ComputeDevice a, ComputeDevice b) { return(a.DeviceGroupType != DeviceGroupType.CPU && b.DeviceGroupType != DeviceGroupType.CPU); }
private static bool IsNvidiaDevice(ComputeDevice a) { return(a.DeviceType == DeviceType.NVIDIA); }
public void Start(IMinerContext context) { string code; var kernelRes = Assembly.GetExecutingAssembly().GetManifestResourceStream("BitMaker.Miner.Cloo.Miner.cl"); using (var rdr = new StreamReader(kernelRes)) code = clProgramSource; var platform = ComputePlatform.Platforms[0]; var properties = new ComputeContextPropertyList(platform); device = platform.Devices[0]; ccontext = new ComputeContext(platform.Devices, properties, null, IntPtr.Zero); program = new ComputeProgram(ccontext, clProgramSource); program.Build(null, null, notify, IntPtr.Zero); }
// group only first CPU split private static bool IsEquihashAnd_CPU_nheqminer(ComputeDevice a) { return(a.DeviceType != DeviceType.CPU || // if not cpu then ignore case always good a.ID == 0); // if CPU ID must be 0 }
public Form_Settings() { InitializeComponent(); ApplicationStateManager.SubscribeStateDisplayer(this); Icon = Properties.Resources.logo; this.TopMost = ConfigManager.GeneralConfig.GUIWindowsAlwaysOnTop; // backup settings ConfigManager.CreateBackup(); // Initialize tabs InitializeGeneralTab(); // initialization calls InitializeDevicesTab(); // link algorithm list with algorithm settings control algorithmSettingsControl1.Enabled = false; algorithmsListView1.ComunicationInterface = algorithmSettingsControl1; //algorithmsListView1.RemoveRatioRates(); // set first device selected { if (AvailableDevices.Devices.Count > 0) { _selectedComputeDevice = AvailableDevices.Devices[0]; algorithmsListView1.SetAlgorithms(_selectedComputeDevice, _selectedComputeDevice.Enabled); groupBoxAlgorithmSettings.Text = string.Format(Tr("Algorithm settings for {0} :"), _selectedComputeDevice.Name); } checkBox_DebugConsole.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.DebugConsole)); checkBox_AutoStartMining.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.AutoStartMining)); checkBox_HideMiningWindows.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.HideMiningWindows)); checkBox_MinimizeToTray.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.MinimizeToTray)); checkBox_AutoScaleBTCValues.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.AutoScaleBTCValues), false, DataSourceUpdateMode.OnPropertyChanged); checkBox_ShowDriverVersionWarning.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.ShowDriverVersionWarning)); checkBox_DisableWindowsErrorReporting.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.DisableWindowsErrorReporting)); checkBox_ShowInternetConnectionWarning.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.ShowInternetConnectionWarning)); checkBox_NVIDIAP0State.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.NVIDIAP0State)); checkBox_LogToFile.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.LogToFile)); checkBox_AllowMultipleInstances.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.AllowMultipleInstances)); checkBox_WindowAlwaysOnTop.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.GUIWindowsAlwaysOnTop)); checkBox_MinimizeMiningWindows.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.MinimizeMiningWindows)); checkBox_RunScriptOnCUDA_GPU_Lost.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.RunScriptOnCUDA_GPU_Lost)); checkBox_RunAtStartup.DataBindings.Add("Checked", ConfigManager.RunAtStartup, nameof(ConfigManager.RunAtStartup.Enabled)); checkBox_ShowGPUPCIeBusIDs.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.ShowGPUPCIeBusIDs)); checkBox_MineRegardlessOfProfit.DataBindings.Add("Checked", MiningProfitSettings.Instance, nameof(MiningProfitSettings.MineRegardlessOfProfit), false, DataSourceUpdateMode.OnPropertyChanged); textBox_MinProfit.DataBindings.Add("Enabled", MiningProfitSettings.Instance, nameof(MiningProfitSettings.IsMinimumProfitProfitEnabled), false, DataSourceUpdateMode.OnPropertyChanged); checkBox_DisableDeviceStatusMonitoring.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.DisableDeviceStatusMonitoring)); #if TESTNET || TESTNETDEV || PRODUCTION_NEW checkBox_DisableDevicePowerModeSettings.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.DisableDevicePowerModeSettings)); #else checkBox_DisableDevicePowerModeSettings.Enabled = false; checkBox_DisableDevicePowerModeSettings.Checked = true; checkBox_DisableDevicePowerModeSettings.Visible = false; pictureBox_DisableDevicePowerModeSettings.Visible = false; groupBoxDeviceMonitoring.Height = (int)(groupBoxDeviceMonitoring.Height * 0.7); #endif // idle mining checkBox_IdleWhenNoInternetAccess.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.IdleWhenNoInternetAccess)); checkBox_StartMiningWhenIdle.DataBindings.Add("Checked", ConfigManager.IdleMiningSettings, nameof(ConfigManager.IdleMiningSettings.StartMiningWhenIdle), false, DataSourceUpdateMode.OnPropertyChanged); comboBox_IdleType.DataBindings.Add("Enabled", ConfigManager.IdleMiningSettings, nameof(ConfigManager.IdleMiningSettings.StartMiningWhenIdle), false, DataSourceUpdateMode.OnPropertyChanged); comboBox_IdleType.DataBindings.Add("SelectedIndex", ConfigManager.IdleMiningSettings, nameof(ConfigManager.IdleMiningSettings.IdleCheckTypeIndex), false, DataSourceUpdateMode.OnPropertyChanged); textBox_MinIdleSeconds.DataBindings.Add("Enabled", ConfigManager.IdleMiningSettings, nameof(ConfigManager.IdleMiningSettings.IsIdleCheckTypeInputTimeout), false, DataSourceUpdateMode.OnPropertyChanged); // comboBox indexes comboBox_Language.DataBindings.Add("SelectedIndex", ConfigManager.TranslationsSettings, nameof(ConfigManager.TranslationsSettings.LanguageIndex), false, DataSourceUpdateMode.OnPropertyChanged); // IFTTT textbox checkBox_UseIFTTT.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.UseIFTTT), false, DataSourceUpdateMode.OnPropertyChanged); textBox_IFTTTKey.DataBindings.Add("Enabled", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.UseIFTTT), false, DataSourceUpdateMode.OnPropertyChanged); textBox_IFTTTKey.DataBindings.Add("Text", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.IFTTTKey), false, DataSourceUpdateMode.OnPropertyChanged); checkBox_RunEthlargement.DataBindings.Add("Checked", ThirdPartyMinerSettings.Instance, nameof(ThirdPartyMinerSettings.Instance.UseEthlargement), false, DataSourceUpdateMode.OnPropertyChanged); checkBox_RunEthlargement.DataBindings.Add("Enabled", ThirdPartyMinerSettings.Instance, nameof(ThirdPartyMinerSettings.Instance.CanUseEthlargement), false, DataSourceUpdateMode.OnPropertyChanged); checkBox_Use3rdPartyMiners.CheckedChanged += CheckBox_Use3rdPartyMiners_CheckedChanged; //checkBox_RunEthlargement.CheckedChanged += CheckBox_RunEthlargement_CheckedChanged; // At the very end set to true _isInitFinished = true; FormHelpers.TranslateFormControls(this); }
// eqm private static bool IsEquihashAnd_eqm(ComputeDevice a, ComputeDevice b) { return(a.MostProfitableAlgorithm.NiceHashID == AlgorithmType.Equihash && a.MostProfitableAlgorithm.NiceHashID == b.MostProfitableAlgorithm.NiceHashID); }
public static void CreateFailedBenchmarksInfo(ComputeDevice device) { var notification = new Notification(NotificationsType.Info, NotificationsGroup.FailedBenchmarks, Tr("Failed benchmarks"), Tr("Some benchmarks for {0} failed to execute. Check benchmark tab for more info.", device.Name)); NotificationsManager.Instance.AddNotificationToList(notification); }
private static bool IsEquihashDevice_eqm(ComputeDevice a) { return(IsEquihashCPU_eqm(a) || IsEquihashNVIDIA_eqm(a)); }
override unsafe protected void MinerThread() { Messenger.Default.Register <StopMinerThreadsMessage>(this, msg => { ThreadPool.QueueUserWorkItem(delegate { Messenger.Default.Unregister(this); this.Dispose(); }); }); Random r = new Random(); ComputeDevice computeDevice = OpenCLDevice.ComputeDevice; ComputeProgram program; var GCN1 = computeDevice.Name.Equals("Capeverde") || computeDevice.Name.Equals("Hainan") || computeDevice.Name.Equals("Oland") || computeDevice.Name.Equals("Pitcairn") || computeDevice.Name.Equals("Tahiti"); string programName = String.Empty; if (_coin == null) { Messenger.Default.Send <MinerOutputMessage>(new MinerOutputMessage() { OutputText = $"Invalid coin! Device #{DeviceIndex} {_stratum.ActiveClient.Pool.CoinType}" }); Dispose(); return; } int?algo = Utils.MigrateAlgorithm(_stratum.ActiveClient.Pool.Algorithm); if (algo == null) { algo = _coin.Algorithm; } switch (algo) { case (int)Consts.SupportedAlgos.CryptoNight: case (int)Consts.SupportedAlgos.CryptoNight_V7: programName = "cryptonight"; scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 21) * globalWorkSizeA[0]); break; case (int)Consts.SupportedAlgos.CryptoNight_V8: programName = "cryptonightV8"; scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 21) * globalWorkSizeA[0]); break; case (int)Consts.SupportedAlgos.CryptoNight_Heavy: programName = "cryptonightHeavy"; scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 22) * globalWorkSizeA[0]); break; case (int)Consts.SupportedAlgos.CryptoNight_Lite: case (int)Consts.SupportedAlgos.CryptoNight_Lite_V7: programName = "cryptonightLite"; scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 20) * globalWorkSizeA[0]); break; case (int)Consts.SupportedAlgos.CryptoNight_BitTube_V2: programName = "cryptonightIpbc"; scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 20) * globalWorkSizeA[0]); break; case (int)Consts.SupportedAlgos.CryptoNight_Fast: programName = "cryptonightFast"; scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 21) * globalWorkSizeA[0]); break; } string algorithmBuildParameters = $@" -I Miners\Kernel -DWORKSIZE={localWorkSizeA[0]} -DSTRIDED_INDEX=1 -DMEMORY_CHUNK_SIZE=2"; program = BuildProgram(programName, localWorkSizeA[0], $"{algorithmBuildParameters} -O5" + (GCN1 ? " -legacy" : ""), algorithmBuildParameters, algorithmBuildParameters); if (program == null) { Messenger.Default.Send <MinerOutputMessage>(new MinerOutputMessage() { OutputText = $"Faild to build/load opencl kernel! Device #{DeviceIndex} {AlgorithmName}" }); Dispose(); return; } searchKernel0 = program.CreateKernel("search"); searchKernel1 = program.CreateKernel("search1"); searchKernel2 = program.CreateKernel("search2"); searchKernel3 = program.CreateKernel("search3"); fixed(long *globalWorkOffsetAPtr = globalWorkOffsetA) fixed(long *globalWorkOffsetBPtr = globalWorkOffsetB) fixed(long *globalWorkSizeAPtr = globalWorkSizeA) fixed(long *globalWorkSizeBPtr = globalWorkSizeB) fixed(long *localWorkSizeAPtr = localWorkSizeA) fixed(long *localWorkSizeBPtr = localWorkSizeB) fixed(Int32 * terminatePtr = terminate) fixed(byte *inputPtr = input) fixed(UInt32 * outputPtr = output) { while (!Stopped) { try { searchKernel0.SetMemoryArgument(0, inputBuffer); searchKernel0.SetMemoryArgument(1, scratchpadsBuffer); searchKernel0.SetMemoryArgument(2, statesBuffer); searchKernel1.SetMemoryArgument(0, scratchpadsBuffer); searchKernel1.SetMemoryArgument(1, statesBuffer); searchKernel1.SetMemoryArgument(2, terminateBuffer); searchKernel1.SetMemoryArgument(4, inputBuffer); searchKernel2.SetMemoryArgument(0, scratchpadsBuffer); searchKernel2.SetMemoryArgument(1, statesBuffer); searchKernel3.SetMemoryArgument(0, statesBuffer); searchKernel3.SetMemoryArgument(1, outputBuffer); // Wait for the first job to arrive. int elapsedTime = 0; while ((_stratum == null || _stratum.GetJob() == null) && elapsedTime < 60000 && !Stopped) { Thread.Sleep(100); elapsedTime += 100; } if (_stratum == null || _stratum.GetJob() == null) { throw new TimeoutException("Stratum server failed to send a new job."); } Stopwatch consoleUpdateStopwatch = new Stopwatch(); CryptoNightStratum.Work work; var events = new CryptoComputeEventList(); while (!Stopped && (work = _stratum.GetWork()) != null) { var job = work.GetJob(); Array.Copy(job.Blob, input, job.Blob.Length); input[job.Blob.Length] = 0x01; Array.Clear(input, job.Blob.Length + 1, input.Length - (job.Blob.Length + 1)); byte localExtranonce = (byte)work.LocalExtranonce; UInt32 startNonce; if (NiceHashMode) { startNonce = ((UInt32)input[42] << (8 * 3)) | ((UInt32)localExtranonce << (8 * 2)) | (UInt32)(r.Next(0, int.MaxValue) & (0x0000ffffu)); } else { startNonce = ((UInt32)localExtranonce << (8 * 3)) | (UInt32)(r.Next(0, int.MaxValue) & (0x00ffffffu)); } if ((_stratum.ActiveClient.Pool.Algorithm != null && (Utils.MigrateAlgorithm(_stratum.ActiveClient.Pool.Algorithm) == (int)Consts.SupportedAlgos.CryptoNight || Utils.MigrateAlgorithm(_stratum.ActiveClient.Pool.Algorithm) == (int)Consts.SupportedAlgos.CryptoNight_Lite)) || (_stratum.ActiveClient.Pool.Algorithm == null && (_coin.Algorithm == (int)Consts.SupportedAlgos.CryptoNight || _coin.Algorithm == (int)Consts.SupportedAlgos.CryptoNight_Lite))) { searchKernel0.SetValueArgument <uint>(3, 0); searchKernel1.SetValueArgument <uint>(3, 0); searchKernel2.SetValueArgument <uint>(2, 0); } else if ((_stratum.ActiveClient.Pool.Algorithm != null && Consts.V7Coins.Any(x => (int)x == Utils.MigrateAlgorithm(_stratum.ActiveClient.Pool.Algorithm))) || (_stratum.ActiveClient.Pool.Algorithm == null && Consts.V7Coins.Any(x => (int)x == _coin.Algorithm))) { searchKernel0.SetValueArgument <uint>(3, 7); searchKernel1.SetValueArgument <uint>(3, 7); searchKernel2.SetValueArgument <uint>(2, 7); } else { searchKernel0.SetValueArgument <uint>(3, (uint)job.Variant); searchKernel1.SetValueArgument <uint>(3, (uint)job.Variant); searchKernel2.SetValueArgument <uint>(2, (uint)job.Variant); } searchKernel3.SetValueArgument <UInt32>(2, job.Target); Queue.Write <byte>(inputBuffer, false, 0, input.Length, (IntPtr)inputPtr, events); Queue.Flush(); events.Wait(); events.Clear(); consoleUpdateStopwatch.Start(); while (!Stopped && _stratum.GetJob().Equals(job)) { globalWorkOffsetA[0] = globalWorkOffsetB[0] = startNonce; if (NiceHashMode) { if ((startNonce & 0xffff) + (UInt32)globalWorkSizeA[0] >= 0x10000) { break; } } else { if ((startNonce & 0xffffff) + (UInt32)globalWorkSizeA[0] >= 0x1000000) { break; } } Stopwatch sw = new Stopwatch(); sw.Start(); output[255] = 0; // output[255] is used as an atomic counter. Queue.Write <UInt32>(outputBuffer, false, 0, outputSize, (IntPtr)outputPtr, events); Queue.Flush(); events.Wait(); events.Clear(); terminate[0] = 0; Queue.Write <Int32>(terminateBuffer, false, 0, 1, (IntPtr)terminatePtr, events); Queue.Flush(); events.Wait(); events.Clear(); Queue.Execute(searchKernel0, globalWorkOffsetA, globalWorkSizeA, localWorkSizeA, events); Queue.Flush(); events.Wait(); events.Clear(); if (Stopped) { break; } Queue.Execute(searchKernel1, globalWorkOffsetB, globalWorkSizeB, localWorkSizeB, events); Queue.Flush(); events.Wait(); events.Clear(); if (Stopped) { break; } Queue.Execute(searchKernel2, globalWorkOffsetA, globalWorkSizeA, localWorkSizeA, events); Queue.Flush(); events.Wait(); events.Clear(); if (Stopped) { break; } Queue.Execute(searchKernel3, globalWorkOffsetB, globalWorkSizeB, localWorkSizeB, events); Queue.Flush(); events.Wait(); events.Clear(); if (Stopped) { break; } Queue.Read <UInt32>(outputBuffer, true, 0, outputSize, (IntPtr)outputPtr, events); Queue.Flush(); events.Wait(); events.Clear(); if (output[0xFF] > 0xFF) { output[0xFF] = 0xFF; } if (_stratum.GetJob().Equals(job)) { for (int i = 0; i < output[0xFF]; ++i) { String result = ""; for (int j = 0; j < 8; ++j) { UInt32 word = output[256 + i * 8 + j]; result += String.Format("{0:x2}{1:x2}{2:x2}{3:x2}", ((word >> 0) & 0xff), ((word >> 8) & 0xff), ((word >> 16) & 0xff), ((word >> 24) & 0xff)); } _stratum.Submit(Device, job, output[i], result); } } startNonce += (UInt32)globalWorkSizeA[0]; sw.Stop(); Speed = globalWorkSizeA[0] / sw.Elapsed.TotalSeconds; if (consoleUpdateStopwatch.ElapsedMilliseconds >= 10 * 1000) { //Messenger.Default.Send<MinerOutputMessage>(new MinerOutputMessage() { OutputText = $"Device #{DeviceIndex} (CryptoNight): {Speed:N2} h/s" }); consoleUpdateStopwatch.Restart(); } } } } catch (Exception ex) { Messenger.Default.Send <MinerOutputMessage>(new MinerOutputMessage() { OutputText = $"Compute error! Device #{DeviceIndex} (CryptoNight)" }); } Speed = 0; if (!Stopped) { Thread.Sleep(5000); } } } }
private static bool IsEquihashCPU_eqm(ComputeDevice a) { return(MinersManager.EquihashCPU_USE_eqm() && a.DeviceType == DeviceType.CPU); }
private BenchmarkingComputeDeviceHandler(ComputeDevice device) { Device = device; }
private static bool IsEquihashNVIDIA_eqm(ComputeDevice a) { return(a.DeviceGroupType == DeviceGroupType.NVIDIA_5_x || a.DeviceGroupType == DeviceGroupType.NVIDIA_6_x); }
public static string ParseForMiningPairs(List <MiningPair> MiningPairs, DeviceType deviceType, bool showLog = true) { _showLog = showLog; MinerBaseType minerBaseType = MinerBaseType.NONE; AlgorithmType algorithmType = AlgorithmType.NONE; if (MiningPairs.Count > 0) { var algo = MiningPairs[0].Algorithm; if (algo != null) { algorithmType = algo.NiceHashID; minerBaseType = algo.MinerBaseType; } } MinerType minerType = GetMinerType(deviceType, minerBaseType, algorithmType); MinerOptionPackage minerOptionPackage = ExtraLaunchParameters.GetMinerOptionPackageForMinerType(minerType); List <MiningPair> setMiningPairs = MiningPairs.ConvertAll((mp) => mp); // handle exceptions and package parsing // CPU exception if (deviceType == DeviceType.CPU && minerType != MinerType.Xmrig) { CheckAndSetCPUPairs(setMiningPairs); } // ethminer exception if (MinerType.ethminer_OCL == minerType || MinerType.ethminer_CUDA == minerType) { // use if missing compute device for correct mapping // init fakes workaround var cdevs_mappings = new List <MiningPair>(); { int id = -1; var fakeAlgo = new Algorithm(MinerBaseType.ethminer, AlgorithmType.DaggerHashimoto, "daggerhashimoto"); foreach (var pair in setMiningPairs) { while (++id != pair.Device.ID) { var fakeCdev = new ComputeDevice(id); cdevs_mappings.Add(new MiningPair(fakeCdev, fakeAlgo)); } cdevs_mappings.Add(pair); } } // reset setMiningPairs setMiningPairs = cdevs_mappings; } // sgminer exception handle intensity types if (MinerType.sgminer == minerType) { // rawIntensity overrides xintensity, xintensity overrides intensity var sgminer_intensities = new List <MinerOption>() { new MinerOption("Intensity", "-I", "--intensity", "d", MinerOptionFlagType.MultiParam, ","), // default is "d" check if -1 works new MinerOption("Xintensity", "-X", "--xintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none new MinerOption("Rawintensity", "", "--rawintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none }; var contains_intensity = new Dictionary <MinerOptionType, bool>() { { "Intensity", false }, { "Xintensity", false }, { "Rawintensity", false }, }; // check intensity and xintensity, the latter overrides so change accordingly foreach (var cDev in setMiningPairs) { foreach (var intensityOption in sgminer_intensities) { if (!string.IsNullOrEmpty(intensityOption.ShortName) && cDev.CurrentExtraLaunchParameters.Contains(intensityOption.ShortName)) { cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace(intensityOption.ShortName, intensityOption.LongName); contains_intensity[intensityOption.Type] = true; } if (cDev.CurrentExtraLaunchParameters.Contains(intensityOption.LongName)) { contains_intensity[intensityOption.Type] = true; } } } // replace if (contains_intensity["Intensity"] && contains_intensity["Xintensity"]) { LogParser("Sgminer replacing --intensity with --xintensity"); foreach (var cDev in setMiningPairs) { cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--intensity", "--xintensity"); } } if (contains_intensity["Xintensity"] && contains_intensity["Rawintensity"]) { LogParser("Sgminer replacing --xintensity with --rawintensity"); foreach (var cDev in setMiningPairs) { cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--xintensity", "--rawintensity"); } } } string ret = ""; string general = Parse(setMiningPairs, minerOptionPackage.GeneralOptions, false, minerOptionPackage.TemperatureOptions); // temp control and parse if (ConfigManager.GeneralConfig.DisableAMDTempControl) { LogParser("DisableAMDTempControl is TRUE, temp control parameters will be ignored"); ret = general; } else { LogParser("AMD parsing temperature control parameters"); // temp = Parse(setMiningPairs, minerOptionPackage.TemperatureOptions, true, minerOptionPackage.GeneralOptions); string temp = Parse(setMiningPairs, minerOptionPackage.TemperatureOptions, false, minerOptionPackage.GeneralOptions); ret = general + " " + temp; } return(ret); }
/// <summary> /// Gets the build log of the <see cref="ComputeProgram"/> for a specified <see cref="ComputeDevice"/>. /// </summary> /// <param name="device"> The <see cref="ComputeDevice"/> building the <see cref="ComputeProgram"/>. Must be one of <see cref="ComputeProgram.Devices"/>. </param> /// <returns> The build log of the <see cref="ComputeProgram"/> for <paramref name="device"/>. </returns> public string GetBuildLog(ComputeDevice device) { unsafe { return GetStringInfo<ComputeProgramBuildInfo>( device, ComputeProgramBuildInfo.BuildLog, CL10.GetProgramBuildInfo); } }
/** * InitAlgorithmsMinerPaths gets and sets miner paths */ public static List <Algorithm> GetAndInitAlgorithmsMinerPaths(List <Algorithm> algos, ComputeDevice computeDevice /*, Options: MinerPathsConfig*/) { var retAlgos = algos.FindAll((a) => a != null).ConvertAll((a) => { a.MinerBinaryPath = GetPathFor(computeDevice, a /*, Options*/); return(a); }); return(retAlgos); }
/// <summary> /// Gets the build log of the <see cref="ComputeProgram"/> for a specified <see cref="ComputeDevice"/>. /// </summary> /// <param name="device"> The <see cref="ComputeDevice"/> building the <see cref="ComputeProgram"/>. Must be one of <see cref="ComputeProgram.Devices"/>. </param> /// <returns> The build log of the <see cref="ComputeProgram"/> for <paramref name="device"/>. </returns> public string GetBuildLog(ComputeDevice device) { return GetStringInfo<CLProgramHandle, CLDeviceHandle, ComputeProgramBuildInfo>(Handle, device.Handle, ComputeProgramBuildInfo.BuildLog, CLInterface.CL10.GetProgramBuildInfo); }
public MiningPair(ComputeDevice d, Algorithm a) { Device = d; Algorithm = a; CurrentExtraLaunchParameters = Algorithm.ExtraLaunchParameters; }
/// <summary> /// Gets a read-only collection of available <c>ComputeDevice</c>s on the <c>ComputePlatform</c>. /// </summary> /// <returns> A read-only collection of the available <c>ComputeDevice</c>s on the <c>ComputePlatform</c>. </returns> /// <remarks> This method resets the <c>ComputePlatform.Devices</c>. This is useful if one or more of them become unavailable (<c>ComputeDevice.Available</c> is <c>false</c>) after a <c>ComputeContext</c> and <c>ComputeCommandQueue</c>s that use the <c>ComputeDevice</c> have been created and commands have been queued to them. Further calls will trigger an <c>OutOfResourcesComputeException</c> until this method is executed. You will also need to recreate any <c>ComputeResource</c> that was created on the no longer available <c>ComputeDevice</c>. </remarks> public ReadOnlyCollection<ComputeDevice> QueryDevices() { unsafe { int handlesLength = 0; ComputeErrorCode error = CL10.GetDeviceIDs(Handle, ComputeDeviceTypes.All, 0, null, &handlesLength); ComputeException.ThrowOnError(error); IntPtr[] handles = new IntPtr[handlesLength]; fixed (IntPtr* devicesPtr = handles) { error = CL10.GetDeviceIDs(Handle, ComputeDeviceTypes.All, handlesLength, devicesPtr, null); ComputeException.ThrowOnError(error); } ComputeDevice[] devices = new ComputeDevice[handlesLength]; for (int i = 0; i < handlesLength; i++) devices[i] = new ComputeDevice(this, handles[i]); this.devices = new ReadOnlyCollection<ComputeDevice>(devices); return this.devices; } }
/// <summary> /// Attempts to initialize OpenCL for the selected GPU. /// </summary> private void InitializeOpenCL() { // only initialize once if (clKernel != null) return; // select the device we've been instructed to use clDevice = ComputePlatform.Platforms .SelectMany(i => i.Devices) .SingleOrDefault(i => i.Handle.Value == Gpu.CLDeviceHandle.Value); // context we'll be working underneath clContext = new ComputeContext(new ComputeDevice[] { clDevice }, new ComputeContextPropertyList(clDevice.Platform), null, IntPtr.Zero); // queue to control device clQueue = new ComputeCommandQueue(clContext, clDevice, ComputeCommandQueueFlags.None); // buffers to store kernel output clBuffer0 = new ComputeBuffer<uint>(clContext, ComputeMemoryFlags.ReadOnly, 16); clBuffer1 = new ComputeBuffer<uint>(clContext, ComputeMemoryFlags.ReadOnly, 16); // kernel code string kernelCode; using (var rdr = new StreamReader(GetType().Assembly.GetManifestResourceStream("BitMaker.Miner.Gpu.DiabloMiner.cl"))) kernelCode = rdr.ReadToEnd(); clProgram = new ComputeProgram(clContext, kernelCode); try { // build kernel for device clProgram.Build(new ComputeDevice[] { clDevice }, "-D WORKSIZE=" + clDevice.MaxWorkGroupSize, null, IntPtr.Zero); } catch (ComputeException) { throw new Exception(clProgram.GetBuildLog(clDevice)); } clKernel = clProgram.CreateKernel("search"); }
public CLCommandQueue(CLContext context, ComputeDevice device, ComputeCommandQueueFlags flags) { _context = context; _comQueue = new ComputeCommandQueue(context._comContext, device, flags); }
/// <summary> /// Gets the <see cref="ComputeProgramBuildStatus"/> of the <see cref="ComputeProgram"/> for a specified <see cref="ComputeDevice"/>. /// </summary> /// <param name="device"> The <see cref="ComputeDevice"/> building the <see cref="ComputeProgram"/>. Must be one of <see cref="ComputeProgram.Devices"/>. </param> /// <returns> The <see cref="ComputeProgramBuildStatus"/> of the <see cref="ComputeProgram"/> for <paramref name="device"/>. </returns> public ComputeProgramBuildStatus GetBuildStatus(ComputeDevice device) { unsafe { return (ComputeProgramBuildStatus)GetInfo<ComputeProgramBuildInfo, uint>( device, ComputeProgramBuildInfo.Status, CL10.GetProgramBuildInfo); } }
/// <summary> /// Entry point for a standard work thread. /// </summary> private void WorkThread() { InitializeOpenCL(); try { // continue working until canceled while (!cts.IsCancellationRequested) Work(Context.GetWork(this, GetType().Name)); } catch (OperationCanceledException) { // ignore } clQueue.Finish(); clKernel.Dispose(); clKernel = null; clBuffer0.Dispose(); clBuffer0 = null; clBuffer1.Dispose(); clBuffer1 = null; clQueue.Dispose(); clQueue = null; clDevice = null; clProgram.Dispose(); clProgram = null; clContext.Dispose(); clContext = null; }
/// <summary> /// Gets the <see cref="ComputeProgramBuildStatus"/> of the <see cref="ComputeProgram"/> for a specified <see cref="ComputeDevice"/>. /// </summary> /// <param name="device"> The <see cref="ComputeDevice"/> building the <see cref="ComputeProgram"/>. Must be one of <see cref="ComputeProgram.Devices"/>. </param> /// <returns> The <see cref="ComputeProgramBuildStatus"/> of the <see cref="ComputeProgram"/> for <paramref name="device"/>. </returns> public ComputeProgramBuildStatus GetBuildStatus(ComputeDevice device) { return (ComputeProgramBuildStatus)GetInfo<CLProgramHandle, CLDeviceHandle, ComputeProgramBuildInfo, uint>(Handle, device.Handle, ComputeProgramBuildInfo.Status, CLInterface.CL10.GetProgramBuildInfo); }
public static string ParseForCDevs(List <ComputeDevice> CDevs, AlgorithmType algorithmType, DeviceType deviceType, string minerPath = "", bool showLog = true) { _showLog = showLog; // init cdevs extra launch parameters foreach (var cDev in CDevs) { cDev.CurrentExtraLaunchParameters = cDev.MostProfitableAlgorithm.ExtraLaunchParameters; } // parse for nheqminer if (algorithmType == AlgorithmType.Equihash) { // nheqminer if (minerPath == MinerPaths.nheqminer) { if (deviceType == DeviceType.CPU) { foreach (var cDev in CDevs) { // extra thread check if (cDev.CurrentExtraLaunchParameters.Contains("-t")) { // nothing } else // add threads params mandatory { cDev.CurrentExtraLaunchParameters += " -t " + GetThreads(cDev.Threads, cDev.MostProfitableAlgorithm.LessThreads).ToString(); } } return(Parse(CDevs, _nheqminer_CPU_Options)); } if (deviceType == DeviceType.NVIDIA) { return(Parse(CDevs, _nheqminer_CUDA_Options)); } if (deviceType == DeviceType.AMD) { return(Parse(CDevs, _nheqminer_AMD_Options)); } } else if (minerPath == MinerPaths.eqm) { if (deviceType == DeviceType.CPU) { foreach (var cDev in CDevs) { // extra thread check if (cDev.CurrentExtraLaunchParameters.Contains("-t")) { // nothing } else // add threads params mandatory { cDev.CurrentExtraLaunchParameters += " -t " + GetThreads(cDev.Threads, cDev.MostProfitableAlgorithm.LessThreads).ToString(); } // use only first CPU dev break; } return(Parse(CDevs, _eqm_CPU_Options)); } if (deviceType == DeviceType.NVIDIA) { return(Parse(CDevs, _eqm_CUDA_Options)); } } } // parse for device if (deviceType == DeviceType.NVIDIA) { if (algorithmType != AlgorithmType.DaggerHashimoto && algorithmType != AlgorithmType.CryptoNight) { return(Parse(CDevs, _ccimerOptions)); } else if (algorithmType == AlgorithmType.CryptoNight) { // check if any device is SM21 or SM3.x if yes return empty for stability reasons foreach (var cDev in CDevs) { if (cDev.DeviceGroupType == DeviceGroupType.NVIDIA_2_1 || cDev.DeviceGroupType == DeviceGroupType.NVIDIA_3_x) { return(""); } } return(Parse(CDevs, _ccimerCryptoNightOptions, true)); } else // ethminer dagger // use if missing compute device for correct mapping { int id = -1; var cdevs_mappings = new List <ComputeDevice>(); foreach (var cDev in CDevs) { while (++id != cDev.ID) { var fakeCdev = new ComputeDevice(id, "", "", ""); fakeCdev.CurrentExtraLaunchParameters = ""; // empty cdevs_mappings.Add(fakeCdev); } cdevs_mappings.Add(cDev); } return(Parse(cdevs_mappings, _cudaEthminerOptions)); } } else if (deviceType == DeviceType.AMD) { if (algorithmType != AlgorithmType.DaggerHashimoto) { // rawIntensity overrides xintensity, xintensity overrides intensity var sgminer_intensities = new List <MinerOption>() { new MinerOption(MinerOptionType.Intensity, "-I", "--intensity", "d", MinerOptionFlagType.MultiParam, ","), // default is "d" check if -1 works new MinerOption(MinerOptionType.Xintensity, "-X", "--xintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none new MinerOption(MinerOptionType.Rawintensity, "", "--rawintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none }; var contains_intensity = new Dictionary <MinerOptionType, bool>() { { MinerOptionType.Intensity, false }, { MinerOptionType.Xintensity, false }, { MinerOptionType.Rawintensity, false }, }; // check intensity and xintensity, the latter overrides so change accordingly foreach (var cDev in CDevs) { foreach (var intensityOption in sgminer_intensities) { if (!string.IsNullOrEmpty(intensityOption.ShortName) && cDev.CurrentExtraLaunchParameters.Contains(intensityOption.ShortName)) { cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace(intensityOption.ShortName, intensityOption.LongName); contains_intensity[intensityOption.Type] = true; } if (cDev.CurrentExtraLaunchParameters.Contains(intensityOption.LongName)) { contains_intensity[intensityOption.Type] = true; } } } // replace if (contains_intensity[MinerOptionType.Intensity] && contains_intensity[MinerOptionType.Xintensity]) { LogParser("Sgminer replacing --intensity with --xintensity"); foreach (var cDev in CDevs) { cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--intensity", "--xintensity"); } } if (contains_intensity[MinerOptionType.Xintensity] && contains_intensity[MinerOptionType.Rawintensity]) { LogParser("Sgminer replacing --xintensity with --rawintensity"); foreach (var cDev in CDevs) { cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--xintensity", "--rawintensity"); } } List <MinerOption> sgminerOptionsNew = new List <MinerOption>(); string temperatureControl = ""; // temp control and parse if (ConfigManager.Instance.GeneralConfig.DisableAMDTempControl) { LogParser("DisableAMDTempControl is TRUE, temp control parameters will be ignored"); } else { LogParser("Sgminer parsing temperature control parameters"); temperatureControl = Parse(CDevs, _sgminerTemperatureOptions, true, _sgminerOptions); } LogParser("Sgminer parsing default parameters"); string returnStr = String.Format("{0} {1}", Parse(CDevs, _sgminerOptions, false, _sgminerTemperatureOptions), temperatureControl); LogParser("Sgminer extra launch parameters merged: " + returnStr); return(returnStr); } else // ethminer dagger // use if missing compute device for correct mapping { int id = -1; var cdevs_mappings = new List <ComputeDevice>(); foreach (var cDev in CDevs) { while (++id != cDev.ID) { var fakeCdev = new ComputeDevice(id, "", "", ""); fakeCdev.CurrentExtraLaunchParameters = ""; // empty cdevs_mappings.Add(fakeCdev); } cdevs_mappings.Add(cDev); } return(Parse(cdevs_mappings, _oclEthminerOptions)); } } else if (deviceType == DeviceType.CPU) { foreach (var cDev in CDevs) { // extra thread check if (cDev.CurrentExtraLaunchParameters.Contains("--threads=") || cDev.CurrentExtraLaunchParameters.Contains("-t")) { // nothing } else // add threads params mandatory { cDev.CurrentExtraLaunchParameters += " --threads=" + GetThreads(cDev.Threads, cDev.MostProfitableAlgorithm.LessThreads).ToString(); } } return(Parse(CDevs, _cpuminerOptions)); } return(""); }
private void StoreState() { platformBackup = platformComboBox.SelectedIndex; devicesBackup = new bool[deviceCheckList.Items.Count]; for (int i = 0; i < devicesBackup.Length; i++) { devicesBackup[i] = false; if (deviceCheckList.GetItemChecked(i)) devicesBackup[i] = true; } optionsBackup = optionsTextBox.Text; Platform = ComputePlatform.Platforms[platformComboBox.SelectedIndex]; Devices = new ComputeDevice[deviceCheckList.CheckedItems.Count]; int k = 0; for (int i = 0; k < Devices.Length && i < Platform.Devices.Count; i++) if (deviceCheckList.GetItemChecked(i)) Devices[k++] = Platform.Devices[i]; Options = optionsTextBox.Text; }
PerDeviceProifitDictionary GetEnabledDeviceProifitDictionary(PerDeviceSpeedDictionary speedDict, Dictionary <AlgorithmType, NiceHashSMA> NiceHashData) { PerDeviceProifitDictionary profitDict = new PerDeviceProifitDictionary(); // log stuff int MAX_NAME_LEN = "daggerhashimoto".Length; int MAX_SPEED_LEN = 15; StringBuilder stringBuilderFull = new StringBuilder(); stringBuilderFull.AppendLine("Current device profits:"); foreach (var nameBenchKvp in speedDict) { var deviceUUID = nameBenchKvp.Key; var curDevProfits = new Dictionary <AlgorithmType, double>(); StringBuilder stringBuilderDevice = new StringBuilder(); stringBuilderDevice.AppendLine(String.Format("\tProfits for {0} ({1}):", deviceUUID, ComputeDevice.GetNameForUUID(deviceUUID))); AlgorithmType mostProfitKey = AlgorithmType.NONE; double mostProfitAlgoVal = -1; foreach (var algoSpeedKvp in nameBenchKvp.Value) { // Log stuff and calculation string name = AlgorithmNiceHashNames.GetName(algoSpeedKvp.Key); int namePreatyCount = MAX_NAME_LEN - name.Length; if (namePreatyCount <= 0) { namePreatyCount = 1; } string namePreaty = name + new String(' ', namePreatyCount); bool isEnabled = algoSpeedKvp.Value > 0; double nhmSMADataVal = NiceHashData[algoSpeedKvp.Key].paying; // TODO what is the constant at the end? double algoProfit = algoSpeedKvp.Value * nhmSMADataVal * 0.000000001; // calculate if (isEnabled) { curDevProfits.Add(algoSpeedKvp.Key, algoProfit); if (mostProfitAlgoVal < algoProfit) { mostProfitKey = algoSpeedKvp.Key; mostProfitAlgoVal = algoProfit; } } else { // if disabled make unprofitable curDevProfits.Add(algoSpeedKvp.Key, -1000000); algoProfit *= -1; // make bigger then 0 for logging reasons } // log stuff string speedStr = algoSpeedKvp.Value.ToString("F3"); int speedStrCount = MAX_SPEED_LEN - speedStr.Length; if (speedStrCount <= 0) { speedStrCount = 1; } string speedPreaty = new String(' ', speedStrCount) + speedStr; stringBuilderDevice.AppendLine(String.Format("\t\t{0}\t:\tPROFIT = {1} ({2}, SPEED = {3}, NHSMA = {4})", namePreaty, // Name algoProfit.ToString(DOUBLE_FORMAT), // Profit isEnabled ? "ENABLED " : "DISABLED", // ENABLED/DISABLED speedPreaty, // Speed nhmSMADataVal.ToString(DOUBLE_FORMAT) // NiceHashData )); } // add profits profitDict.Add(deviceUUID, curDevProfits); // log stuff stringBuilderDevice.AppendLine(String.Format("\t\tMOST PROFITABLE (ENABLED) ALGO: {0}, PROFIT: {1}", AlgorithmNiceHashNames.GetName(mostProfitKey), mostProfitAlgoVal.ToString(DOUBLE_FORMAT))); stringBuilderFull.AppendLine(stringBuilderDevice.ToString()); } Helpers.ConsolePrint(TAG, stringBuilderFull.ToString()); return(profitDict); }