// new decoupled benchmarking routines #region Decoupled benchmarking routines protected override string BenchmarkCreateCommandLine(Algorithm algorithm, int time) { string CommandLine; string url = Globals.GetLocationURL(algorithm.NiceHashID, Globals.MiningLocation[ConfigManager.GeneralConfig.ServiceLocation], this.ConectionType); // demo for benchmark string username = Globals.DemoUser; if (ConfigManager.GeneralConfig.WorkerName.Length > 0) { username += "." + ConfigManager.GeneralConfig.WorkerName.Trim(); } // cd to the cgminer for the process bins CommandLine = " /C \"cd /d " + WorkingDirectory + " && sgminer.exe " + " --gpu-platform " + GPUPlatformNumber + " -k " + algorithm.MinerName + " --url=" + url + " --userpass="******" -p Benchmark " + " --sched-stop " + DateTime.Now.AddSeconds(time).ToString("HH:mm") + " -T --log 10 --log-file dump.txt" + " " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.AMD) + " --device "; CommandLine += GetDevicesCommandString(); CommandLine += " && del dump.txt\""; return(CommandLine); }
protected override void Init() { var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs); _algorithmType = singleType.Item1; bool ok = singleType.Item2; if (!ok) { Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!"); throw new InvalidOperationException("Invalid mining initialization"); } // all good continue on // init command line params parts var orderedMiningPairs = _miningPairs.ToList(); orderedMiningPairs.Sort((a, b) => a.Device.ID.CompareTo(b.Device.ID)); _devices = string.Join(",", orderedMiningPairs.Select(p => p.Device.ID)); if (MinerOptionsPackage != null) { var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions; var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults); var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults); _extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim(); } }
// new decoupled benchmarking routines /// <summary> /// The BenchmarkCreateCommandLine /// </summary> /// <param name="algorithm">The <see cref="Algorithm"/></param> /// <param name="time">The <see cref="int"/></param> /// <returns>The <see cref="string"/></returns> protected override string BenchmarkCreateCommandLine(Algorithm algorithm, int time) { string url = Globals.GetLocationURL(algorithm.CryptoMiner937ID, Globals.MiningLocation[ConfigManager.GeneralConfig.ServiceLocation], ConectionType); string username = Globals.DemoUser; if (ConfigManager.GeneralConfig.WorkerName.Length > 0) { username += "." + ConfigManager.GeneralConfig.WorkerName.Trim(); } string CommandLine = " --url=" + url + " --user="******" -p c=BTC,Benchmark,m=party.NPlusMiner " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.NVIDIA) + " --devices "; CommandLine += GetDevicesCommandString(); Helpers.ConsolePrint(MinerTAG(), CommandLine); return(CommandLine); }
public override void Start(string url, string btcAdress, string worker) { if (!IsInit) { Helpers.ConsolePrint(MinerTAG(), "MiningSetup is not initialized exiting Start()"); return; } string username = GetUsername(btcAdress, worker); LastCommandLine = " --gpu-platform " + GPUPlatformNumber + " -k " + MiningSetup.MinerName + " --url=" + url + " --userpass="******":" + worker + " " + " -p " + worker + " --api-listen" + " --api-port=" + APIPort.ToString() + " " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.AMD) + " --device "; LastCommandLine += GetDevicesCommandString(); ProcessHandle = _Start(); }
protected override void Init() { var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs); _algorithmType = singleType.Item1; bool ok = singleType.Item2; if (!ok) { Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!"); throw new InvalidOperationException("Invalid mining initialization"); } // Order pairs and parse ELP var orderedMiningPairs = _miningPairs.ToList(); _devices = string.Join(",", _miningPairs.Select(p => _mappedIDs[p.Device.UUID])); if (MinerOptionsPackage != null) { var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions; var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults); var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults); _extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim(); } }
protected override void Init() { var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs); _algorithmFirstType = singleType.Item1; bool ok = singleType.Item2; if (!ok) { Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!"); throw new InvalidOperationException("Invalid mining initialization"); } var dualType = MinerToolkit.GetAlgorithmDualType(_miningPairs); _algorithmSecondType = dualType.Item1; ok = dualType.Item2; if (!ok) { _algorithmSecondType = AlgorithmType.NONE; } // all good continue on _orderedMiningPairs = _miningPairs.ToList(); _orderedMiningPairs.Sort((a, b) => _mappedIDs[a.Device.UUID].CompareTo(_mappedIDs[b.Device.UUID])); _devices = string.Join("", _orderedMiningPairs.Select(p => ClaymoreHelpers.GetClaymoreDeviceID(_mappedIDs[p.Device.UUID]))); if (MinerOptionsPackage != null) { var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions; var generalParams = ExtraLaunchParametersParser.Parse(_orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults); var temperatureParams = ExtraLaunchParametersParser.Parse(_orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults); _extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim(); } }
protected override void prepareConfigFile(string pool, string wallet) { if (this.MiningSetup.MiningPairs.Count > 0) { try { bool IsHyperThreadingEnabled = this.MiningSetup.MiningPairs[0].CurrentExtraLaunchParameters.Contains("enable_ht=true"); int numTr = ExtraLaunchParametersParser.GetThreadsNumber(this.MiningSetup.MiningPairs[0]); if (IsHyperThreadingEnabled) { numTr /= 2; } var config = new XmrStackCPUMinerConfig(numTr, pool, wallet, this.APIPort); var no_prefetch = ExtraLaunchParametersParser.GetNoPrefetch(MiningSetup.MiningPairs[0]); //config.Inti_cpu_threads_conf(false, false, true, ComputeDeviceManager.Avaliable.IsHyperThreadingEnabled); config.Inti_cpu_threads_conf(false, no_prefetch, false, IsHyperThreadingEnabled); var confJson = JObject.FromObject(config); string writeStr = confJson.ToString(); int start = writeStr.IndexOf("{"); int end = writeStr.LastIndexOf("}"); writeStr = writeStr.Substring(start + 1, end - 1); System.IO.File.WriteAllText(WorkingDirectory + GetConfigFileName(), writeStr); } catch { } } }
protected override void PrepareConfigFile(string pool, string wallet) { try { var config = new XmrStakAMDConfig(pool, wallet, APIPort); var gpuConfigs = new List <XmrStakGPUSettings>(); foreach (var pair in MiningSetup.MiningPairs) { var intensities = ExtraLaunchParametersParser.GetIntensityStak(pair); if (intensities.Count <= 0) { intensities.Add(1000); } gpuConfigs.AddRange(intensities.Select(intensity => new XmrStakGPUSettings(pair.Device.ID, intensity))); } config.Initialize_gpu_threads_conf(gpuConfigs); var serializer = new JsonSerializer { TypeNameHandling = TypeNameHandling.All }; var confJson = JObject.FromObject(config); var writeStr = confJson.ToString(); var start = writeStr.IndexOf("{"); int end = writeStr.LastIndexOf("}"); writeStr = writeStr.Substring(start + 1, end - 1); System.IO.File.WriteAllText(WorkingDirectory + GetConfigFileName(), writeStr); } catch { } }
private void checkBox_AMD_DisableAMDTempControl_CheckedChanged(object sender, EventArgs e) { if (!_isInitFinished) { return; } // indicate there has been a change IsChange = true; ConfigManager.GeneralConfig.DisableAMDTempControl = checkBox_AMD_DisableAMDTempControl.Checked; foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices) { if (cDev.DeviceType == DeviceType.AMD) { foreach (var algorithm in cDev.AlgorithmSettings) { if (algorithm.Key != AlgorithmType.DaggerHashimoto) { algorithm.Value.ExtraLaunchParameters += AmdGpuDevice.TemperatureParam; algorithm.Value.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair( new MiningPair(cDev, algorithm.Value), algorithm.Key, DeviceType.AMD, false); } } } } }
public override void Start(string url, string btcAdress, string worker) { if (!IsInit) { Helpers.ConsolePrint(MinerTAG(), "MiningSetup is not initialized exiting Start()"); return; } string username = GetUsername(btcAdress, worker); IsAPIReadException = MiningSetup.MinerPath == MinerPaths.Data.ccminer_cryptonight; string algo = ""; string apiBind = ""; if (!IsAPIReadException) { algo = "--algo=" + MiningSetup.MinerName; apiBind = " --api-bind=" + APIPort.ToString(); } LastCommandLine = algo + " --url=" + url + //" --userpass="******":x " + " --userpass="******":" + worker + " " + apiBind + " " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.NVIDIA) + " --devices "; LastCommandLine += GetDevicesCommandString(); ProcessHandle = _Start(); }
protected override void Init() { // check platform id var openClAmdPlatformResult = MinerToolkit.GetOpenCLPlatformID(_miningPairs); var openClAmdPlatformNum = openClAmdPlatformResult.Item1; bool openClAmdPlatformNumUnique = openClAmdPlatformResult.Item2; if (!openClAmdPlatformNumUnique) { Logger.Error(_logGroup, "Initialization of miner failed. Multiple OpenCLPlatform IDs found!"); throw new InvalidOperationException("Invalid mining initialization"); } // all good continue on // Order pairs and parse ELP var miningPairsList = _miningPairs.ToList(); var deviceIds = miningPairsList.Select(pair => pair.Device.ID); _devicesOnPlatform = $"--gpu-platform {openClAmdPlatformNum} -d {string.Join(",", deviceIds)}"; // if no MinerOptionsPackage fallback to defaults if (MinerOptionsPackage == null) { var ignoreDefaults = SgminerOptionsPackage.DefaultMinerOptionsPackage.IgnoreDefaultValueOptions; var generalParams = ExtraLaunchParametersParser.Parse(miningPairsList, SgminerOptionsPackage.DefaultMinerOptionsPackage.GeneralOptions, ignoreDefaults); var temperatureParams = ExtraLaunchParametersParser.Parse(miningPairsList, SgminerOptionsPackage.DefaultMinerOptionsPackage.TemperatureOptions, ignoreDefaults); _extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim(); } }
// new decoupled benchmarking routines #region Decoupled benchmarking routines protected override string BenchmarkCreateCommandLine(Algorithm algorithm, int time) { return("--algo=" + algorithm.MinerName + " --benchmark" + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.CPU) + " --time-limit " + time.ToString()); }
protected override string GetBenchmarkCommandStringPart(Algorithm algorithm) { return(" --benchmark-warmup 40 --benchmark-trial 20" + " " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.NVIDIA) + " --cuda --cuda-devices "); }
protected override string GetDevicesCommandString() { var deviceStringCommand = MiningSetup.MiningPairs.Aggregate(" --cuda_devices ", (current, nvidiaPair) => current + (nvidiaPair.Device.ID + " ")); deviceStringCommand += " " + ExtraLaunchParametersParser.ParseForMiningSetup(MiningSetup, DeviceType.NVIDIA); return(deviceStringCommand); }
protected override string GetBenchmarkCommandStringPart(Algorithm algorithm) { return(" --opencl --opencl-platform " + GPUPlatformNumber + " " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.AMD) + " --benchmark-warmup 40 --benchmark-trial 20" + " --opencl-devices "); }
protected override string GetStartCommandStringPart(string url, string username) { return(" --cuda" + " " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.NVIDIA) + " -S " + url.Substring(14) + " -O " + username + ":x " + " --api-port " + APIPort.ToString() + " --cuda-devices "); }
protected override string GetStartCommandStringPart(string url, string username) { return(" --opencl --opencl-platform " + GPUPlatformNumber + " " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.AMD) + " -S " + url.Substring(14) + " -O " + username + ":x " + " --api-port " + APIPort.ToString() + " --opencl-devices "); }
protected override string GetDevicesCommandString() { var extraParams = ExtraLaunchParametersParser.ParseForMiningSetup(MiningSetup, DeviceType.AMD); var deviceStringCommand = " -c " + ComputeDeviceManager.Avaliable.AmdOpenCLPlatformNum; deviceStringCommand += " "; var ids = MiningSetup.MiningPairs.Select(mPair => "-d " + mPair.Device.ID.ToString()).ToList(); deviceStringCommand += string.Join(" ", ids); return(deviceStringCommand + extraParams); }
protected override string GetDevicesCommandString() { string deviceStringCommand = " --cuda_devices "; foreach (var nvidia_pair in this.MiningSetup.MiningPairs) { deviceStringCommand += nvidia_pair.Device.ID + " "; } deviceStringCommand += " " + ExtraLaunchParametersParser.ParseForMiningSetup(MiningSetup, DeviceType.NVIDIA); return(deviceStringCommand); }
// This method now overridden in ClaymoreCryptoNightMiner // Following logic for ClaymoreDual and ClaymoreZcash protected override string GetDevicesCommandString() { // First by device type (AMD then NV), then by bus ID index var sortedMinerPairs = MiningSetup.MiningPairs .OrderByDescending(pair => pair.Device.DeviceType) .ThenBy(pair => pair.Device.IDByBus) .ToList(); string extraParams = ExtraLaunchParametersParser.ParseForMiningPairs(sortedMinerPairs, DeviceType.AMD); List <string> ids = new List <string>(); int amdDeviceCount = ComputeDeviceManager.Query.AMD_Devices.Count; Helpers.ConsolePrint("ClaymoreIndexing", String.Format("Found {0} AMD devices", amdDeviceCount)); foreach (var mPair in sortedMinerPairs) { var id = mPair.Device.IDByBus; if (id < 0) { // should never happen Helpers.ConsolePrint("ClaymoreIndexing", "ID by Bus too low: " + id.ToString() + " skipping device"); continue; } if (mPair.Device.DeviceType == DeviceType.NVIDIA) { Helpers.ConsolePrint("ClaymoreIndexing", "NVIDIA device increasing index by " + amdDeviceCount.ToString()); id += amdDeviceCount; } if (id > 9) // New >10 GPU support in CD9.8 { if (id < 36) // CD supports 0-9 and a-z indexes, so 36 GPUs { char idchar = (char)(id + 87); // 10 = 97(a), 11 - 98(b), etc ids.Add(idchar.ToString()); } else { Helpers.ConsolePrint("ClaymoreIndexing", "ID " + id + " too high, ignoring"); } } else { ids.Add(id.ToString()); } } var deviceStringCommand = DeviceCommand(amdDeviceCount) + String.Join("", ids); return(deviceStringCommand + extraParams); }
private void checkBox_DisableDefaultOptimizations_CheckedChanged(object sender, EventArgs e) { if (!_isInitFinished) { return; } // indicate there has been a change IsChange = true; ConfigManager.GeneralConfig.DisableDefaultOptimizations = checkBox_DisableDefaultOptimizations.Checked; if (ConfigManager.GeneralConfig.DisableDefaultOptimizations) { foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices) { foreach (var algorithm in cDev.AlgorithmSettings) { algorithm.Value.ExtraLaunchParameters = ""; if (cDev.DeviceType == DeviceType.AMD && algorithm.Key != AlgorithmType.DaggerHashimoto) { algorithm.Value.ExtraLaunchParameters += AmdGpuDevice.TemperatureParam; algorithm.Value.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair( new MiningPair(cDev, algorithm.Value), algorithm.Key, cDev.DeviceType, false); } } } } else { foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices) { if (cDev.DeviceType == DeviceType.CPU) { continue; // cpu has no defaults } var deviceDefaultsAlgoSettings = GroupAlgorithms.CreateForDevice(cDev); foreach (var defaultAlgoSettings in deviceDefaultsAlgoSettings) { var algorithmKey = defaultAlgoSettings.Key; if (cDev.AlgorithmSettings.ContainsKey(algorithmKey)) { var algorithm = cDev.AlgorithmSettings[algorithmKey]; algorithm.ExtraLaunchParameters = defaultAlgoSettings.Value.ExtraLaunchParameters; algorithm.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair( new MiningPair(cDev, algorithm), algorithmKey, cDev.DeviceType, false); } } } } }
protected override void Init() { var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs); _algorithmType = singleType.Item1; bool ok = singleType.Item2; if (!ok) { Logger.Error(_logGroup, "Initialization of miner failed. Algorithm not found!"); throw new InvalidOperationException("Invalid mining initialization"); } // check platform id var openClAmdPlatformResult = MinerToolkit.GetOpenCLPlatformID(_miningPairs); var openClAmdPlatformNum = openClAmdPlatformResult.Item1; bool openClAmdPlatformNumUnique = openClAmdPlatformResult.Item2; if (!openClAmdPlatformNumUnique) { Logger.Error(_logGroup, "Initialization of miner failed. Multiple OpenCLPlatform IDs found!"); throw new InvalidOperationException("Invalid mining initialization"); } // all good continue on // Order pairs and parse ELP var orderedMiningPairs = _miningPairs.ToList(); orderedMiningPairs.Sort((a, b) => a.Device.ID.CompareTo(b.Device.ID)); var deviceIds = orderedMiningPairs.Select(pair => pair.Device.ID); _devicesOnPlatform = $"--gpu-platform {openClAmdPlatformNum} -d {string.Join(",", deviceIds)}"; if (MinerOptionsPackage != null) { var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions; var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults); var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults); _extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim(); } else // TODO this one is temp??? { var ignoreDefaults = DefaultMinerOptionsPackage.IgnoreDefaultValueOptions; var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, DefaultMinerOptionsPackage.GeneralOptions, ignoreDefaults); var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, DefaultMinerOptionsPackage.TemperatureOptions, ignoreDefaults); _extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim(); } }
public virtual bool CanGroup(MiningPair a, MiningPair b) { var checkELPCompatibility = MinerOptionsPackage?.GroupMiningPairsOnlyWithCompatibleOptions ?? false; var isSameAlgoType = MinerToolkit.IsSameAlgorithmType(a.Algorithm, b.Algorithm); if (isSameAlgoType && checkELPCompatibility) { var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions; var areGeneralOptionsCompatible = ExtraLaunchParametersParser.CheckIfCanGroup(a, b, MinerOptionsPackage.GeneralOptions, ignoreDefaults); var areTemperatureOptionsCompatible = ExtraLaunchParametersParser.CheckIfCanGroup(a, b, MinerOptionsPackage.TemperatureOptions, ignoreDefaults); return(areGeneralOptionsCompatible && areTemperatureOptionsCompatible); } return(isSameAlgoType); }
private void checkBox_DisableDefaultOptimizations_CheckedChanged(object sender, EventArgs e) { if (!_isInitFinished) { return; } // indicate there has been a change IsChange = true; ConfigManager.GeneralConfig.DisableDefaultOptimizations = checkBox_DisableDefaultOptimizations.Checked; if (ConfigManager.GeneralConfig.DisableDefaultOptimizations) { foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices) { foreach (var algorithm in cDev.GetAlgorithmSettings()) { algorithm.ExtraLaunchParameters = ""; if (cDev.DeviceType == DeviceType.AMD && algorithm.NiceHashID != AlgorithmType.DaggerHashimoto) { algorithm.ExtraLaunchParameters += AmdGpuDevice.TemperatureParam; algorithm.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair( new MiningPair(cDev, algorithm), algorithm.NiceHashID, cDev.DeviceType, false); } } } } else { foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices) { if (cDev.DeviceType == DeviceType.CPU) { continue; // cpu has no defaults } var deviceDefaultsAlgoSettings = GroupAlgorithms.CreateForDeviceList(cDev); foreach (var defaultAlgoSettings in deviceDefaultsAlgoSettings) { var toSetAlgo = cDev.GetAlgorithm(defaultAlgoSettings.MinerBaseType, defaultAlgoSettings.NiceHashID); if (toSetAlgo != null) { toSetAlgo.ExtraLaunchParameters = defaultAlgoSettings.ExtraLaunchParameters; toSetAlgo.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair( new MiningPair(cDev, toSetAlgo), toSetAlgo.NiceHashID, cDev.DeviceType, false); } } } } }
protected override string GetDevicesCommandString() { string extraParams = ExtraLaunchParametersParser.ParseForMiningSetup(MiningSetup, DeviceType.AMD); string deviceStringCommand = " -c " + ComputeDeviceManager.Avaliable.AMDOpenCLPlatformNum; deviceStringCommand += " "; List <string> ids = new List <string>(); foreach (var mPair in MiningSetup.MiningPairs) { ids.Add("-d " + mPair.Device.ID.ToString()); } deviceStringCommand += String.Join(" ", ids); return(deviceStringCommand + extraParams); }
public override void InitMiningPairs(IEnumerable <MiningPair> miningPairs) { // now should be ordered _miningPairs = GetSortedMiningPairs(miningPairs); //// update log group try { var devs = _miningPairs.Select(pair => $"{pair.Device.DeviceType}:{pair.Device.ID}"); var devsTag = $"devs({string.Join(",", devs)})"; var algo = _miningPairs.First().Algorithm.AlgorithmName; var algoTag = $"algo({algo})"; _logGroup = $"{_baseTag}-{algoTag}-{devsTag}"; } catch (Exception e) { Logger.Error(_logGroup, $"Error while setting _logGroup: {e.Message}"); } // init algo, ELP and finally miner specific init // init algo var(first, second, ok) = MinerToolkit.GetFirstAndSecondAlgorithmType(_miningPairs); _algorithmType = first; _algorithmSecondType = second; if (!ok) { Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!"); throw new InvalidOperationException("Invalid mining initialization"); } // init ELP, _miningPairs are ordered and ELP parsing keeps ordering if (MinerOptionsPackage != null) { var miningPairsList = _miningPairs.ToList(); var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions; var firstPair = miningPairsList.FirstOrDefault(); var optionsWithoutLHR = MinerOptionsPackage.GeneralOptions.Where(opt => !opt.ID.Contains("lolMiner_mode")).ToList(); var optionsWithLHR = MinerOptionsPackage.GeneralOptions.Where(opt => opt.ID.Contains("lolMiner_mode")).ToList(); var generalParamsWithoutLHR = ExtraLaunchParametersParser.Parse(miningPairsList, optionsWithoutLHR, ignoreDefaults); var isDagger = firstPair.Algorithm.FirstAlgorithmType == AlgorithmType.DaggerHashimoto; var generalParamsWithLHR = ExtraLaunchParametersParser.Parse(miningPairsList, optionsWithLHR, !isDagger); var modeOptions = ResolveDeviceMode(miningPairsList, generalParamsWithLHR); var generalParams = generalParamsWithoutLHR + (isDagger ? modeOptions : ""); var temperatureParams = ExtraLaunchParametersParser.Parse(miningPairsList, MinerOptionsPackage.TemperatureOptions, ignoreDefaults); _extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim(); } // miner specific init Init(); }
protected override void Init() { var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs); _algorithmType = singleType.Item1; bool ok = singleType.Item2; if (!ok) { Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!"); throw new InvalidOperationException("Invalid mining initialization"); } // all good continue on // Order pairs and parse ELP var orderedMiningPairs = _miningPairs.ToList(); orderedMiningPairs.Sort((a, b) => a.Device.ID.CompareTo(b.Device.ID)); _devices = string.Join(",", orderedMiningPairs.Select(p => p.Device.ID)); var openClAmdPlatformResult = MinerToolkit.GetOpenCLPlatformID(_miningPairs); _openClAmdPlatformNum = openClAmdPlatformResult.Item1; bool openClAmdPlatformNumUnique = openClAmdPlatformResult.Item2; if (!openClAmdPlatformNumUnique) { Logger.Error(_logGroup, "Initialization of miner failed. Multiple OpenCLPlatform IDs found!"); throw new InvalidOperationException("Invalid mining initialization"); } for (int i = 0; i < orderedMiningPairs.Count; i++) { _initOrderMirrorApiOrderUUIDs[i] = orderedMiningPairs[i].Device.UUID; } if (MinerOptionsPackage != null) { var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions; var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults); var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults); _extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim(); } }
public override void Start(string url, string btcAdress, string worker) { if (!IsInit) { Helpers.ConsolePrint(MinerTAG(), "MiningSetup is not initialized exiting Start()"); return; } string username = GetUsername(btcAdress, worker); LastCommandLine = "--algo=" + MiningSetup.MinerName + " --url=" + url + " --userpass="******":x " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.CPU) + " --api-bind=" + APIPort.ToString(); ProcessHandle = _Start(); }
// new decoupled benchmarking routines /// <summary> /// The BenchmarkCreateCommandLine /// </summary> /// <param name="algorithm">The <see cref="Algorithm"/></param> /// <param name="time">The <see cref="int"/></param> /// <returns>The <see cref="string"/></returns> protected override string BenchmarkCreateCommandLine(Algorithm algorithm, int time) { string timeLimit = (BenchmarkException) ? "" : " --time-limit " + time.ToString(); string CommandLine = " --algo=" + algorithm.MinerName + " --benchmark" + timeLimit + " " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.NVIDIA) + " --devices "; CommandLine += GetDevicesCommandString(); // cryptonight exception helper variables _cryptonightTotalCount = BenchmarkTimeInSeconds / _cryptonightTotalDelim; _cryptonightTotal = 0.0d; return(CommandLine); }
public override void Start(string url, string btcAdress, string worker) { if (!IsInit) { Helpers.ConsolePrint(MinerTAG(), "MiningSetup is not initialized exiting Start()"); return; } string username = GetUsername(btcAdress, worker); LastCommandLine = " --url " + url + " --user " + btcAdress + " -p " + worker + "-I 23 " + ExtraLaunchParametersParser.ParseForMiningSetup( MiningSetup, DeviceType.AMD) + " --device "; LastCommandLine += GetDevicesCommandString(); ProcessHandle = _Start(); }