private static void LogMiningNonMiningStatuses(List <MiningDevice> enabledDevices, List <Tuple <ComputeDevice, DeviceMiningStatus> > disabledDevicesStatuses) { // print statuses if (disabledDevicesStatuses.Count > 0) { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.AppendLine(""); stringBuilder.AppendLine("Disabled Devices:"); foreach (var deviceStatus in disabledDevicesStatuses) { stringBuilder.AppendLine("\t" + GetDisabledDeviceStatusString(deviceStatus)); } Helpers.ConsolePrint(TAG, stringBuilder.ToString()); } if (enabledDevices.Count > 0) { // print enabled StringBuilder stringBuilder = new StringBuilder(); stringBuilder.AppendLine(""); stringBuilder.AppendLine("Enabled Devices for Mining session:"); foreach (var miningDevice in enabledDevices) { var device = miningDevice.Device; stringBuilder.AppendLine(String.Format("\tENABLED ({0})", device.GetFullName())); foreach (var algo in device.DeviceBenchmarkConfig.AlgorithmSettings.Values) { var isEnabled = IsAlgoMiningCapable(algo) && IsValidMinerPath(device, algo); stringBuilder.AppendLine(String.Format("\t\tALGORITHM {0} ({1})", isEnabled ? "ENABLED " : "DISABLED", // ENABLED/DISABLED AlgorithmNiceHashNames.GetName(algo.NiceHashID))); } } Helpers.ConsolePrint(TAG, stringBuilder.ToString()); } }
public void MinerStatsCheck(Dictionary <AlgorithmType, NiceHashSMA> NiceHashData) { double CurrentProfit = 0.0d; _mainFormRatesComunication.ClearRates(_currentAllGroupedDevices.Count); foreach (var group in _currentAllGroupedDevices) { var groupMiners = _groupedDevicesMiners[CalcGroupedDevicesKey(group)]; Miner m = groupMiners.CurrentWorkingMiner; // skip if not running if (!m.IsRunning) { continue; } APIData AD = m.GetSummary(); if (AD == null) { Helpers.ConsolePrint(m.MinerTAG(), "GetSummary returned null.."); } // set rates if (NiceHashData != null && AD != null) { m.CurrentRate = NiceHashData[AD.AlgorithmID].paying * AD.Speed * 0.000000001; } else { m.CurrentRate = 0; // set empty AD = new APIData() { AlgorithmID = m.CurrentAlgorithmType, AlgorithmName = AlgorithmNiceHashNames.GetName(m.CurrentAlgorithmType), Speed = 0.0d }; } CurrentProfit += m.CurrentRate; // Update GUI _mainFormRatesComunication.AddRateInfo(m.MinerTAG(), groupMiners.DevicesInfoString, AD, m.CurrentRate, m.IsAPIReadException); } // check if profitabile if (CheckStatus && !IsMiningRegardlesOfProfit) { CheckStatus = false; if (IsProfitable) { // check current profit CheckIfShouldMine(CurrentProfit, true); } else if (!IsProfitable) { // recalculate and switch SwichMostProfitableGroupUpMethod(NiceHashData, true); } } }
public void CalculateProfits(Dictionary <AlgorithmType, double> profits) { // save last state PrevProfitableAlgorithmType = MostProfitableAlgorithmType; PrevProfitableMinerBaseType = MostProfitableMinerBaseType; // assume none is profitable MostProfitableAlgorithmType = AlgorithmType.NONE; MostProfitableMinerBaseType = MinerBaseType.NONE; // calculate new profits foreach (var algo in Algorithms) { var key = algo.NiceHashID; var secondaryKey = algo.SecondaryNiceHashID; if (profits.TryGetValue(key, out var paying)) { algo.CurNhmSmaDataVal = paying; algo.CurrentProfit = algo.CurNhmSmaDataVal * algo.AvaragedSpeed * 0.000000001; if (profits.TryGetValue(secondaryKey, out var secPaying)) { algo.SecondaryCurNhmSmaDataVal = secPaying; algo.CurrentProfit += algo.SecondaryCurNhmSmaDataVal * algo.SecondaryAveragedSpeed * 0.000000001; } } else { algo.CurrentProfit = 0; } } // find max paying value and save key double maxProfit = 0; foreach (var algo in Algorithms) { if (maxProfit < algo.CurrentProfit) { maxProfit = algo.CurrentProfit; MostProfitableAlgorithmType = algo.DualNiceHashID(); MostProfitableMinerBaseType = algo.MinerBaseType; } } #if (SWITCH_TESTING) var devName = Device.GetFullName(); // set new most profit if (Algorithms.ContainsKey(testingAlgos[next])) { MostProfitableKey = testingAlgos[next]; } else if (ForceNone) { MostProfitableKey = AlgorithmType.NONE; } var mostProfitKeyName = AlgorithmNiceHashNames.GetName(MostProfitableKey); Helpers.ConsolePrint("SWITCH_TESTING", String.Format("Setting device {0} to {1}", devName, mostProfitKeyName)); #endif }
public static void SetNextTest() { ++next; if (next >= testingAlgos.Count) { next = 0; } var mostProfitKeyName = AlgorithmNiceHashNames.GetName(testingAlgos[next]); Helpers.ConsolePrint("SWITCH_TESTING", String.Format("Setting most MostProfitKey to {0}", mostProfitKeyName)); }
public void ShouldReturnNameForValid() { var expected = new Dictionary <AlgorithmType, string> { { AlgorithmType.Blake2s, "Blake2s" }, { AlgorithmType.CryptoNightV8, "CryptoNightV8" } }; foreach (var key in expected.Keys) { Assert.AreEqual(expected[key], AlgorithmNiceHashNames.GetName(key)); } }
public Algorithm(MinerBaseType minerBaseType, AlgorithmType niceHashID, string minerName = "", bool enabled = true) { NiceHashID = niceHashID; AlgorithmName = AlgorithmNiceHashNames.GetName(NiceHashID); MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType); AlgorithmStringID = MinerBaseTypeName + "_" + AlgorithmName; MinerBaseType = minerBaseType; MinerName = minerName; ExtraLaunchParameters = ""; LessThreads = 0; Enabled = enabled; BenchmarkStatus = ""; }
public void CalculateProfits(Dictionary <AlgorithmType, NiceHashSMA> NiceHashData) { // assume none is profitable MostProfitableKey = AlgorithmType.NONE; // calculate new profits foreach (var miningAlgo in Algorithms) { AlgorithmType key = miningAlgo.Key; MiningAlgorithm algo = miningAlgo.Value; if (NiceHashData.ContainsKey(key)) { algo.CurNhmSMADataVal = NiceHashData[key].paying; algo.CurrentProfit = algo.CurNhmSMADataVal * algo.AvaragedSpeed * 0.000000001; } else { algo.CurrentProfit = 0; } } // find max paying value and save key double maxProfit = 0; foreach (var miningAlgo in Algorithms) { AlgorithmType key = miningAlgo.Key; MiningAlgorithm algo = miningAlgo.Value; if (maxProfit < algo.CurrentProfit) { maxProfit = algo.CurrentProfit; MostProfitableKey = key; } } #if (SWITCH_TESTING) var devName = Device.GetFullName(); // set new most profit if (Algorithms.ContainsKey(testingAlgos[next])) { MostProfitableKey = testingAlgos[next]; } else if (ForceNone) { MostProfitableKey = AlgorithmType.NONE; } var mostProfitKeyName = AlgorithmNiceHashNames.GetName(MostProfitableKey); Helpers.ConsolePrint("SWITCH_TESTING", String.Format("Setting device {0} to {1}", devName, mostProfitKeyName)); #endif }
public Algorithm(MinerBaseType minerBaseType, AlgorithmType niceHashID, string minerName) { NiceHashID = niceHashID; AlgorithmName = AlgorithmNiceHashNames.GetName(NiceHashID); MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType); AlgorithmStringID = MinerBaseTypeName + "_" + AlgorithmName; MinerBaseType = minerBaseType; MinerName = minerName; ExtraLaunchParameters = ""; LessThreads = 0; Enabled = !(NiceHashID == AlgorithmType.Nist5 || (NiceHashID == AlgorithmType.NeoScrypt && minerBaseType == MinerBaseType.sgminer)); BenchmarkStatus = ""; }
public void CalculateProfits(Dictionary <AlgorithmType, double> profits) { // save last state PrevProfitableAlgorithmType = MostProfitableAlgorithmType; PrevProfitableMinerBaseType = MostProfitableMinerBaseType; // assume none is profitable MostProfitableAlgorithmType = AlgorithmType.NONE; MostProfitableMinerBaseType = MinerBaseType.NONE; // calculate new profits foreach (var algo in Algorithms) { algo.UpdateCurProfit(profits); } // find max paying value and save key double maxProfit = 0; foreach (var algo in Algorithms) { if (maxProfit < algo.CurrentProfit) { maxProfit = algo.CurrentProfit; MostProfitableAlgorithmType = algo.DualNiceHashID; MostProfitableMinerBaseType = algo.MinerBaseType; } } #if (SWITCH_TESTING) var devName = Device.GetFullName(); // set new most profit if (Algorithms.ContainsKey(testingAlgos[next])) { MostProfitableKey = testingAlgos[next]; } else if (ForceNone) { MostProfitableKey = AlgorithmType.NONE; } var mostProfitKeyName = AlgorithmNiceHashNames.GetName(MostProfitableKey); Helpers.ConsolePrint("SWITCH_TESTING", String.Format("Setting device {0} to {1}", devName, mostProfitKeyName)); #endif }
public void MinerStatsCheck(Dictionary <AlgorithmType, NiceHashSMA> NiceHashData) { _mainFormRatesComunication.ClearRates(_currentAllGroupedDevices.Count); foreach (var group in _currentAllGroupedDevices) { var groupMiners = _groupedDevicesMiners[CalcGroupedDevicesKey(group)]; Miner m = groupMiners.CurrentWorkingMiner; // skip if not running if (!m.IsRunning) { continue; } APIData AD = m.GetSummary(); if (AD == null) { Helpers.ConsolePrint(m.MinerTAG(), "GetSummary returned null.."); } // set rates if (NiceHashData != null && AD != null) { m.CurrentRate = NiceHashData[AD.AlgorithmID].paying * AD.Speed * 0.000000001; } else { m.CurrentRate = 0; // set empty AD = new APIData() { AlgorithmID = m.CurrentAlgorithmType, AlgorithmName = AlgorithmNiceHashNames.GetName(m.CurrentAlgorithmType), Speed = 0.0d }; } // Update GUI _mainFormRatesComunication.AddRateInfo(m.MinerTAG(), groupMiners.DevicesInfoString, AD, m.CurrentRate, m.IsAPIReadException); } }
public void SetNext(ref PerDeviceProifitDictionary devProfits, List <ComputeDevice> enabledDevices) { foreach (var cDev in enabledDevices) { var devUUID = cDev.UUID; var curStepCheckIndex = _curStepCheck[devUUID]; var _mostProfitKey = _allAvaliableAlgoKeys[devUUID][curStepCheckIndex]; var mostProfitKeyName = AlgorithmNiceHashNames.GetName(_mostProfitKey); Helpers.ConsolePrint(TAG, String.Format("Setting most MostProfitKey to {0}", mostProfitKeyName)); // set new most profit Helpers.ConsolePrint(TAG, String.Format("Setting device {0} to {1}", devUUID, mostProfitKeyName)); devProfits[devUUID][_mostProfitKey] = MOST_PROFIT_REPLACE_VAL; ++curStepCheckIndex; if (curStepCheckIndex >= _allAvaliableAlgoKeys[devUUID].Count) { curStepCheckIndex = 0; } _curStepCheck[devUUID] = curStepCheckIndex; } }
public Algorithm(MinerBaseType minerBaseType, AlgorithmType niceHashID, string minerName) { NiceHashID = niceHashID; AlgorithmName = AlgorithmNiceHashNames.GetName(NiceHashID); MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType); AlgorithmStringID = MinerBaseTypeName + "_" + AlgorithmName; MinerBaseType = minerBaseType; MinerName = minerName; ExtraLaunchParameters = ""; LessThreads = 0; Enabled = !(NiceHashID == AlgorithmType.Nist5 || (NiceHashID == AlgorithmType.NeoScrypt && minerBaseType == MinerBaseType.sgminer)); Enabled = !(NiceHashID == AlgorithmType.CryptoNightV7) && minerBaseType == MinerBaseType.XmrigAMD; Enabled = !(NiceHashID == AlgorithmType.CryptoNightV8) && minerBaseType == MinerBaseType.XmrigAMD; Enabled = !(NiceHashID == AlgorithmType.CryptoNightV8) && minerBaseType == MinerBaseType.SRBMiner; Enabled = !(NiceHashID == AlgorithmType.CryptoNightHeavy) && minerBaseType == MinerBaseType.SRBMiner; Enabled = !(NiceHashID == AlgorithmType.Lyra2REv2) && minerBaseType == MinerBaseType.mkxminer; BenchmarkStatus = ""; }
public void ShouldReturnNotFoundForInvalid() { var x = AlgorithmNiceHashNames.GetName((AlgorithmType)100); Assert.AreEqual("NameNotFound type not supported", x); }
public MiningSession(List <ComputeDevice> devices, IMainFormRatesComunication mainFormRatesComunication, string miningLocation, string worker, string btcAdress) { // init fixed _mainFormRatesComunication = mainFormRatesComunication; _miningLocation = miningLocation; if (worker.Length > 0) { _workerBtcStringWorker = btcAdress + "." + worker; } else { _workerBtcStringWorker = btcAdress; } // initial settup { // used for logging List <Tuple <ComputeDevice, DeviceMiningStatus> > disabledDevicesStatuses = new List <Tuple <ComputeDevice, DeviceMiningStatus> >(); // logging and settup List <ComputeDevice> enabledDevices = new List <ComputeDevice>(); // get enabled devices { // check passed devices statuses List <Tuple <ComputeDevice, DeviceMiningStatus> > devicesStatuses = new List <Tuple <ComputeDevice, DeviceMiningStatus> >(); foreach (var device in devices) { devicesStatuses.Add(getDeviceMiningStatus(device)); } // sort device statuses foreach (var deviceStatus in devicesStatuses) { if (deviceStatus.Item2 == DeviceMiningStatus.CanMine) { enabledDevices.Add(deviceStatus.Item1); } else { disabledDevicesStatuses.Add(deviceStatus); } } } // print statuses if (disabledDevicesStatuses.Count > 0) { Helpers.ConsolePrint(TAG, "Disabled Devices:"); foreach (var deviceStatus in disabledDevicesStatuses) { ComputeDevice device = deviceStatus.Item1; DeviceMiningStatus status = deviceStatus.Item2; if (status == DeviceMiningStatus.DeviceNull) { Helpers.ConsolePrint(TAG, "Critical Device is NULL"); } else if (status == DeviceMiningStatus.Disabled) { Helpers.ConsolePrint(TAG, String.Format("DISABLED ({0})", device.GetFullName())); } else if (status == DeviceMiningStatus.NoEnabledAlgorithms) { Helpers.ConsolePrint(TAG, String.Format("No Enabled Algorithms ({0})", device.GetFullName())); } } } if (enabledDevices.Count > 0) { // print enabled Helpers.ConsolePrint(TAG, "Enabled Devices for Mining session:"); foreach (var device in enabledDevices) { Helpers.ConsolePrint(TAG, String.Format("ENABLED ({0})", device.GetFullName())); foreach (var algo in device.DeviceBenchmarkConfig.AlgorithmSettings.Values) { var isEnabled = IsAlgoMiningCapable(algo); Helpers.ConsolePrint(TAG, String.Format("\t\tALGORITHM {0} ({1})", isEnabled ? "ENABLED " : "DISABLED", // ENABLED/DISABLED AlgorithmNiceHashNames.GetName(algo.NiceHashID))); } } // settup mining devices foreach (var device in enabledDevices) { _miningDevices.Add(new MiningDevice(device)); } } } if (_miningDevices.Count > 0) { // calculate avarage speeds, to ensure mining stability // device name, algo key, algos refs list Dictionary <string, Dictionary <AlgorithmType, List <MiningAlgorithm> > > avarager = new Dictionary <string, Dictionary <AlgorithmType, List <MiningAlgorithm> > >(); // init empty avarager foreach (var device in _miningDevices) { string devName = device.Device.Name; avarager[devName] = new Dictionary <AlgorithmType, List <MiningAlgorithm> >(); foreach (var key in AlgorithmNiceHashNames.GetAllAvaliableTypes()) { avarager[devName][key] = new List <MiningAlgorithm>(); } } // fill avarager foreach (var device in _miningDevices) { string devName = device.Device.Name; foreach (var kvp in device.Algorithms) { var key = kvp.Key; MiningAlgorithm algo = kvp.Value; avarager[devName][key].Add(algo); } } // calculate avarages foreach (var devDict in avarager.Values) { foreach (List <MiningAlgorithm> miningAlgosList in devDict.Values) { // if list not empty calculate avarage if (miningAlgosList.Count > 0) { // calculate avarage double sum = 0; foreach (var algo in miningAlgosList) { sum += algo.AvaragedSpeed; } double avarageSpeed = sum / miningAlgosList.Count; // set avarage foreach (var algo in miningAlgosList) { algo.AvaragedSpeed = avarageSpeed; } } } } } // init timer stuff _preventSleepTimer = new Timer(); _preventSleepTimer.Elapsed += PreventSleepTimer_Tick; // sleep time is minimal 1 minute _preventSleepTimer.Interval = 20 * 1000; // leave this interval, it works // set internet checking _internetCheckTimer = new Timer(); _internetCheckTimer.Elapsed += InternetCheckTimer_Tick; _internetCheckTimer.Interval = 1000 * 30 * 1; // every minute or 5?? // 1000 * 60 * 1 _miningStatusCheckTimer = new Timer(); _miningStatusCheckTimer.Elapsed += MiningStatusCheckTimer_Tick; _miningStatusCheckTimer.Interval = 1000 * 30; // assume profitable IsProfitable = true; // assume we have internet IsConnectedToInternet = true; if (IsMiningEnabled) { _preventSleepTimer.Start(); _internetCheckTimer.Start(); _miningStatusCheckTimer.Start(); } IsMiningRegardlesOfProfit = ConfigManager.Instance.GeneralConfig.MinimumProfit == 0; }
public void SwichMostProfitableGroupUpMethod(Dictionary <AlgorithmType, NiceHashSMA> NiceHashData, bool log = true) { List <MiningDevice> profitableDevices = new List <MiningDevice>(); double CurrentProfit = 0.0d; foreach (var device in _miningDevices) { // calculate profits device.CalculateProfits(NiceHashData); // check if device has profitable algo if (device.MostProfitableKey != AlgorithmType.NONE) { profitableDevices.Add(device); CurrentProfit += device.GetCurrentMostProfitValue; device.Device.MostProfitableAlgorithm = device.Algorithms[device.MostProfitableKey].algoRef; } } // print profit statuses if (log) { StringBuilder stringBuilderFull = new StringBuilder(); stringBuilderFull.AppendLine("Current device profits:"); foreach (var device in _miningDevices) { StringBuilder stringBuilderDevice = new StringBuilder(); stringBuilderDevice.AppendLine(String.Format("\tProfits for {0} ({1}):", device.Device.UUID, device.Device.Name)); foreach (var algo in device.Algorithms) { stringBuilderDevice.AppendLine(String.Format("\t\tPROFIT = {0}\t(SPEED = {1}\t\t| NHSMA = {2})\t[{3}]", algo.Value.CurrentProfit.ToString(DOUBLE_FORMAT), // Profit algo.Value.AvaragedSpeed, // Speed algo.Value.CurNhmSMADataVal, // NiceHashData AlgorithmNiceHashNames.GetName(algo.Key) // Name )); } // most profitable stringBuilderDevice.AppendLine(String.Format("\t\tMOST PROFITABLE ALGO: {0}, PROFIT: {1}", AlgorithmNiceHashNames.GetName(device.MostProfitableKey), device.GetCurrentMostProfitValue.ToString(DOUBLE_FORMAT))); stringBuilderFull.AppendLine(stringBuilderDevice.ToString()); } Helpers.ConsolePrint(TAG, stringBuilderFull.ToString()); } // check if should mine if (CheckIfShouldMine(CurrentProfit, log) == false) { return; } // group devices with same supported algorithms _previousAllGroupedDevices = _currentAllGroupedDevices; _currentAllGroupedDevices = new List <SortedSet <string> >(); Dictionary <GroupedDevices, Algorithm> newGroupAndAlgorithm = new Dictionary <GroupedDevices, Algorithm>(); for (int first = 0; first < profitableDevices.Count; ++first) { var firstDev = profitableDevices[first].Device; // skip if no algorithm is profitable if (firstDev.MostProfitableAlgorithm == null) { if (log) { Helpers.ConsolePrint("SwichMostProfitableGroupUpMethod", String.Format("Device {0}, MostProfitableAlgorithm == null", firstDev.Name)); } continue; } // check if is in group bool isInGroup = false; foreach (var groupedDevices in _currentAllGroupedDevices) { if (groupedDevices.Contains(firstDev.UUID)) { isInGroup = true; break; } } if (isInGroup) { continue; } var newGroup = new GroupedDevices(); newGroup.Add(firstDev.UUID); for (int second = first + 1; second < profitableDevices.Count; ++second) { var secondDev = profitableDevices[second].Device; // first check if second device has profitable algorithm if (secondDev.MostProfitableAlgorithm != null) { // check if we should group if (GroupingLogic.IsEquihashGroupLogic(firstDev, secondDev) || GroupingLogic.IsDaggerAndSameComputePlatform(firstDev, secondDev) || GroupingLogic.IsGroupBinaryAndAlgorithmSame(firstDev, secondDev)) { newGroup.Add(secondDev.UUID); } } } _currentAllGroupedDevices.Add(newGroup); newGroupAndAlgorithm.Add(newGroup, firstDev.MostProfitableAlgorithm); } // stop groupes that aren't in current group devices foreach (var curPrevGroup in _previousAllGroupedDevices) { var curPrevGroupKey = CalcGroupedDevicesKey(curPrevGroup); bool contains = false; foreach (var curCheckGroup in _currentAllGroupedDevices) { var curCheckGroupKey = CalcGroupedDevicesKey(curCheckGroup); if (curPrevGroupKey == curCheckGroupKey) { contains = true; break; } } if (!contains) { _groupedDevicesMiners[curPrevGroupKey].Stop(); } } // switch to newGroupAndAlgorithm most profitable algorithm foreach (var kvpGroupAlgorithm in newGroupAndAlgorithm) { var group = kvpGroupAlgorithm.Key; var algorithm = kvpGroupAlgorithm.Value; GroupMiners currentGroupMiners; // try find if it doesn't exist create new string groupStringKey = CalcGroupedDevicesKey(group); if (!_groupedDevicesMiners.TryGetValue(groupStringKey, out currentGroupMiners)) { currentGroupMiners = new GroupMiners(group); _groupedDevicesMiners.Add(groupStringKey, currentGroupMiners); } currentGroupMiners.StartAlgorihtm(algorithm, _miningLocation, _workerBtcStringWorker); } // stats quick fix code if (_currentAllGroupedDevices.Count != _previousAllGroupedDevices.Count) { MinerStatsCheck(NiceHashData); } }
private void NextBenchmark() { if (_bechmarkCurrentIndex > -1) { StepUpBenchmarkStepProgress(); } ++_bechmarkCurrentIndex; if (_bechmarkCurrentIndex >= _benchmarkAlgorithmsCount) { EndBenchmark(); return; } while (_benchmarkDevicesAlgorithmQueue.Count > 0) { var currentDeviceAlgosTuple = _benchmarkDevicesAlgorithmQueue[0]; _currentDevice = currentDeviceAlgosTuple.Item1; var algorithmBenchmarkQueue = currentDeviceAlgosTuple.Item2; if (algorithmBenchmarkQueue.Count != 0) { _currentAlgorithm = algorithmBenchmarkQueue.Dequeue(); break; } _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)); if (_currentDevice != null) { 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 void SwichMostProfitableGroupUpMethod(Dictionary <AlgorithmType, NiceHashSMA> NiceHashData, bool log = true) { #if (SWITCH_TESTING) MiningDevice.SetNextTest(); #endif List <MiningPair> profitableDevices = new List <MiningPair>(); double CurrentProfit = 0.0d; foreach (var device in _miningDevices) { // calculate profits device.CalculateProfits(NiceHashData); // check if device has profitable algo if (device.HasProfitableAlgo()) { profitableDevices.Add(device.GetMostProfitablePair()); CurrentProfit += device.GetCurrentMostProfitValue; } } // print profit statuses if (log) { StringBuilder stringBuilderFull = new StringBuilder(); stringBuilderFull.AppendLine("Current device profits:"); foreach (var device in _miningDevices) { StringBuilder stringBuilderDevice = new StringBuilder(); stringBuilderDevice.AppendLine(String.Format("\tProfits for {0} ({1}):", device.Device.UUID, device.Device.Name)); foreach (var algo in device.Algorithms) { stringBuilderDevice.AppendLine(String.Format("\t\tPROFIT = {0}\t(SPEED = {1}\t\t| NHSMA = {2})\t[{3}]", algo.Value.CurrentProfit.ToString(DOUBLE_FORMAT), // Profit algo.Value.AvaragedSpeed, // Speed algo.Value.CurNhmSMADataVal, // NiceHashData AlgorithmNiceHashNames.GetName(algo.Key) // Name )); } // most profitable stringBuilderDevice.AppendLine(String.Format("\t\tMOST PROFITABLE ALGO: {0}, PROFIT: {1}", AlgorithmNiceHashNames.GetName(device.MostProfitableKey), device.GetCurrentMostProfitValue.ToString(DOUBLE_FORMAT))); stringBuilderFull.AppendLine(stringBuilderDevice.ToString()); } Helpers.ConsolePrint(TAG, stringBuilderFull.ToString()); } // check if should mine if (CheckIfShouldMine(CurrentProfit, log) == false) { return; } Dictionary <string, List <MiningPair> > newGroupedMiningPairs = new Dictionary <string, List <MiningPair> >(); // group devices with same supported algorithms { var currentGroupedDevices = new List <GroupedDevices>(); for (int first = 0; first < profitableDevices.Count; ++first) { var firstDev = profitableDevices[first].Device; // check if is in group bool isInGroup = false; foreach (var groupedDevices in currentGroupedDevices) { if (groupedDevices.Contains(firstDev.UUID)) { isInGroup = true; break; } } // if device is not in any group create new group and check if other device should group if (isInGroup == false) { var newGroup = new GroupedDevices(); var miningPairs = new List <MiningPair>() { profitableDevices[first] }; newGroup.Add(firstDev.UUID); for (int second = first + 1; second < profitableDevices.Count; ++second) { // check if we should group var firstPair = profitableDevices[first]; var secondPair = profitableDevices[second]; if (GroupingLogic.ShouldGroup(firstPair, secondPair)) { var secondDev = profitableDevices[second].Device; newGroup.Add(secondDev.UUID); miningPairs.Add(profitableDevices[second]); } } currentGroupedDevices.Add(newGroup); newGroupedMiningPairs[CalcGroupedDevicesKey(newGroup)] = miningPairs; } } } //bool IsMinerStatsCheckUpdate = false; { // check which groupMiners should be stopped and which ones should be started and which to keep running Dictionary <string, GroupMiner> toStopGroupMiners = new Dictionary <string, GroupMiner>(); Dictionary <string, GroupMiner> toRunNewGroupMiners = new Dictionary <string, GroupMiner>(); // check what to stop/update foreach (string runningGroupKey in _runningGroupMiners.Keys) { if (newGroupedMiningPairs.ContainsKey(runningGroupKey) == false) { // runningGroupKey not in new group definately needs to be stopped and removed from curently running toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; } else { // runningGroupKey is contained but needs to check if mining algorithm is changed var miningPairs = newGroupedMiningPairs[runningGroupKey]; var newAlgoType = GetMinerPairAlgorithmType(miningPairs); if (newAlgoType != AlgorithmType.NONE && newAlgoType != AlgorithmType.INVALID) { // if algoType valid and different from currently running update if (newAlgoType != _runningGroupMiners[runningGroupKey].AlgorithmType) { // remove current one and schedule to stop mining toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; // create new one TODO check if DaggerHashimoto GroupMiner newGroupMiner = null; if (newAlgoType == AlgorithmType.DaggerHashimoto) { if (_ethminerNVIDIAPaused != null && _ethminerNVIDIAPaused.Key == runningGroupKey) { newGroupMiner = _ethminerNVIDIAPaused; } if (_ethminerAMDPaused != null && _ethminerAMDPaused.Key == runningGroupKey) { newGroupMiner = _ethminerAMDPaused; } } if (newGroupMiner == null) { newGroupMiner = new GroupMiner(miningPairs, runningGroupKey); } toRunNewGroupMiners[runningGroupKey] = newGroupMiner; } } } } // check brand new foreach (var kvp in newGroupedMiningPairs) { var key = kvp.Key; var miningPairs = kvp.Value; if (_runningGroupMiners.ContainsKey(key) == false) { GroupMiner newGroupMiner = new GroupMiner(miningPairs, key); toRunNewGroupMiners[key] = newGroupMiner; } } // stop old miners foreach (var toStop in toStopGroupMiners.Values) { toStop.Stop(); _runningGroupMiners.Remove(toStop.Key); // TODO check if daggerHashimoto and save if (toStop.AlgorithmType == AlgorithmType.DaggerHashimoto) { if (toStop.DeviceType == DeviceType.NVIDIA) { _ethminerNVIDIAPaused = toStop; } else if (toStop.DeviceType == DeviceType.AMD) { _ethminerAMDPaused = toStop; } } } // start new miners foreach (var toStart in toRunNewGroupMiners.Values) { toStart.Start(_miningLocation, _btcAdress, _worker); _runningGroupMiners[toStart.Key] = toStart; } } // stats quick fix code //if (_currentAllGroupedDevices.Count != _previousAllGroupedDevices.Count) { MinerStatsCheck(NiceHashData); //} }
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); }
void NextBenchmark() { ++_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.ClaymoreAMD && _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(BenchmarkPerformanceType.Quick, _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); } else { NextBenchmark(); } }
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 = MinersManager.CreateMiner(_currentDevice, _currentAlgorithm); if (_currentDevice.DeviceType == DeviceType.CPU && string.IsNullOrEmpty(_currentAlgorithm.ExtraLaunchParameters)) { __CPUBenchmarkStatus = new CPUBenchmarkStatus(); _currentAlgorithm.LessThreads = __CPUBenchmarkStatus.LessTreads; } else { __CPUBenchmarkStatus = 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; } // 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.NiceHashID, getDotsWaitString()); } else { NextBenchmark(); } }
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(); } }