public void StopAllMinersNonProfitable() { if (_runningGroupMiners != null) { foreach (var groupMiner in _runningGroupMiners.Values) { groupMiner.End(); } _runningGroupMiners = new Dictionary <string, GroupMiner>(); } if (_ethminerNVIDIAPaused != null) { _ethminerNVIDIAPaused.End(); _ethminerNVIDIAPaused = null; } if (_ethminerAMDPaused != null) { _ethminerAMDPaused.End(); _ethminerAMDPaused = null; } if (_mainFormRatesComunication != null) { _mainFormRatesComunication.ClearRates(-1); } }
public void StopAllMiners() { if (_runningGroupMiners != null) { foreach (var groupMiner in _runningGroupMiners.Values) { groupMiner.End(); } _runningGroupMiners = new Dictionary <string, GroupMiner>(); } if (_ethminerNVIDIAPaused != null) { _ethminerNVIDIAPaused.End(); _ethminerNVIDIAPaused = null; } if (_ethminerAMDPaused != null) { _ethminerAMDPaused.End(); _ethminerAMDPaused = null; } if (_mainFormRatesComunication != null) { _mainFormRatesComunication.ClearRatesALL(); } // restroe/enable sleep _preventSleepTimer.Stop(); _internetCheckTimer.Stop(); //_checkWorkerStats.Stop(); Helpers.AllowMonitorPowerdownAndSleep(); // delete generated bin files // check for bins files var dirInfo = new DirectoryInfo(MinerPaths.Data.nheqminer.Replace("nheqminer.exe", "")); var DONT_DELETE = "equiw200k9.bin"; var deleteContains = "equiw200k9"; var alwaysDeleteContains2 = "silentarmy_gpu"; if (dirInfo != null && dirInfo.Exists) { foreach (FileInfo file in dirInfo.GetFiles()) { if (file.Name != DONT_DELETE && file.Name.Contains(deleteContains)) { file.Delete(); } if (file.Name.Contains(alwaysDeleteContains2)) { file.Delete(); } } } }
public async Task SwichMostProfitableGroupUpMethod(Dictionary <AlgorithmType, NiceHashSMA> NiceHashData, bool log = true) { #if (SWITCH_TESTING) MiningDevice.SetNextTest(); #endif List <MiningPair> profitableDevices = new List <MiningPair>(); double CurrentProfit = 0.0d; double PrevStateProfit = 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; PrevStateProfit += device.GetPrevMostProfitValue; } } // 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.GetFullName())); foreach (var algo in device.Algorithms) { stringBuilderDevice.AppendLine(String.Format("\t\tPROFIT = {0}\t(SPEED = {1}\t\t| NHSMA = {2})\t[{3}]", algo.CurrentProfit.ToString(DOUBLE_FORMAT), // Profit algo.AvaragedSpeed + (algo.IsDual() ? "/" + algo.SecondaryAveragedSpeed : ""), // Speed algo.CurNhmSMADataVal + (algo.IsDual() ? "/" + algo.SecondaryCurNhmSMADataVal : ""), // NiceHashData algo.AlgorithmStringID // Name )); } // most profitable stringBuilderDevice.AppendLine(String.Format("\t\tMOST PROFITABLE ALGO: {0}, PROFIT: {1}", device.GetMostProfitableString(), device.GetCurrentMostProfitValue.ToString(DOUBLE_FORMAT))); stringBuilderFull.AppendLine(stringBuilderDevice.ToString()); } Helpers.ConsolePrint(TAG, stringBuilderFull.ToString()); } // check if should mine // Only check if profitable inside this method when getting SMA data, cheching during mining is not reliable if (CheckIfShouldMine(CurrentProfit, log) == false) { foreach (var device in _miningDevices) { device.SetNotMining(); } return; } // check profit threshold Helpers.ConsolePrint(TAG, String.Format("PrevStateProfit {0}, CurrentProfit {1}", PrevStateProfit, CurrentProfit)); if (PrevStateProfit > 0 && CurrentProfit > 0) { double a = Math.Max(PrevStateProfit, CurrentProfit); double b = Math.Min(PrevStateProfit, CurrentProfit); //double percDiff = Math.Abs((PrevStateProfit / CurrentProfit) - 1); double percDiff = ((a - b)) / b; if (percDiff < ConfigManager.GeneralConfig.SwitchProfitabilityThreshold) { // don't switch Helpers.ConsolePrint(TAG, String.Format("Will NOT switch profit diff is {0}, current threshold {1}", percDiff, ConfigManager.GeneralConfig.SwitchProfitabilityThreshold)); // RESTORE OLD PROFITS STATE foreach (var device in _miningDevices) { device.RestoreOldProfitsState(); } if (!Miner.SHOULD_START_DONATING) { return; } } else { Helpers.ConsolePrint(TAG, String.Format("Will SWITCH profit diff is {0}, current threshold {1}", percDiff, ConfigManager.GeneralConfig.SwitchProfitabilityThreshold)); } } // group new miners 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>(); Dictionary <string, GroupMiner> noChangeGroupMiners = 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]; } // If we need to start donating, stop everything else if (!Miner.IS_DONATING && Miner.SHOULD_START_DONATING) { toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; var miningPairs = newGroupedMiningPairs[runningGroupKey]; var newAlgoType = GetMinerPairAlgorithmType(miningPairs); 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; Miner.IS_DONATING = true; } else if (Miner.IS_DONATING && Miner.SHOULD_STOP_DONATING) { toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; var miningPairs = newGroupedMiningPairs[runningGroupKey]; var newAlgoType = GetMinerPairAlgorithmType(miningPairs); 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; Miner.DonationStart = Miner.DonationStart.Add(Miner.DonateEvery); Miner.IS_DONATING = false; } 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].DualAlgorithmType) { // 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; } else { noChangeGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; } } } } // 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; } } if ((toStopGroupMiners.Values.Count > 0) || (toRunNewGroupMiners.Values.Count > 0)) { StringBuilder stringBuilderPreviousAlgo = new StringBuilder(); StringBuilder stringBuilderCurrentAlgo = new StringBuilder(); StringBuilder stringBuilderNoChangeAlgo = new StringBuilder(); // stop old miners foreach (var toStop in toStopGroupMiners.Values) { stringBuilderPreviousAlgo.Append(String.Format("{0}: {1}, ", toStop.DevicesInfoString, toStop.AlgorithmType)); 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) { stringBuilderCurrentAlgo.Append(String.Format("{0}: {1}, ", toStart.DevicesInfoString, toStart.AlgorithmType)); toStart.Start(_miningLocation, _btcAdress, _worker); _runningGroupMiners[toStart.Key] = toStart; } // which miners dosen't change foreach (var noChange in noChangeGroupMiners.Values) { stringBuilderNoChangeAlgo.Append(String.Format("{0}: {1}, ", noChange.DevicesInfoString, noChange.AlgorithmType)); } if (stringBuilderPreviousAlgo.Length > 0) { Helpers.ConsolePrint(TAG, String.Format("Stop Mining: {0}", stringBuilderPreviousAlgo.ToString())); } if (stringBuilderCurrentAlgo.Length > 0) { Helpers.ConsolePrint(TAG, String.Format("Now Mining : {0}", stringBuilderCurrentAlgo.ToString())); } if (stringBuilderNoChangeAlgo.Length > 0) { Helpers.ConsolePrint(TAG, String.Format("No change : {0}", stringBuilderNoChangeAlgo.ToString())); } } } // stats quick fix code //if (_currentAllGroupedDevices.Count != _previousAllGroupedDevices.Count) { await MinerStatsCheck(NiceHashData); //} }
private void SwichMostProfitableGroupUpMethod(object sender, SmaUpdateEventArgs e) { #if (SWITCH_TESTING) MiningDevice.SetNextTest(); #endif var profitableDevices = new List <MiningPair>(); var currentProfit = 0.0d; var prevStateProfit = 0.0d; foreach (var device in _miningDevices) { // calculate profits device.CalculateProfits(e.NormalizedProfits); // check if device has profitable algo if (device.HasProfitableAlgo()) { profitableDevices.Add(device.GetMostProfitablePair()); currentProfit += device.GetCurrentMostProfitValue; prevStateProfit += device.GetPrevMostProfitValue; } } var stringBuilderFull = new StringBuilder(); stringBuilderFull.AppendLine("Current device profits:"); foreach (var device in _miningDevices) { var stringBuilderDevice = new StringBuilder(); stringBuilderDevice.AppendLine($"\tProfits for {device.Device.Uuid} ({device.Device.GetFullName()}):"); foreach (var algo in device.Algorithms) { stringBuilderDevice.AppendLine( $"\t\tPROFIT = {algo.CurrentProfit.ToString(DoubleFormat)}" + $"\t(SPEED = {algo.AvaragedSpeed:e5}" + $"\t\t| NHSMA = {algo.CurNhmSmaDataVal:e5})" + $"\t[{algo.AlgorithmStringID}]" ); if (algo is DualAlgorithm dualAlg) { stringBuilderDevice.AppendLine( $"\t\t\t\t\t Secondary:\t\t {dualAlg.SecondaryAveragedSpeed:e5}" + $"\t\t\t\t {dualAlg.SecondaryCurNhmSmaDataVal:e5}" ); } } // most profitable stringBuilderDevice.AppendLine( $"\t\tMOST PROFITABLE ALGO: {device.GetMostProfitableString()}, PROFIT: {device.GetCurrentMostProfitValue.ToString(DoubleFormat)}"); stringBuilderFull.AppendLine(stringBuilderDevice.ToString()); } Helpers.ConsolePrint(Tag, stringBuilderFull.ToString()); // check if should mine // Only check if profitable inside this method when getting SMA data, cheching during mining is not reliable if (CheckIfShouldMine(currentProfit) == false) { foreach (var device in _miningDevices) { device.SetNotMining(); } return; } // check profit threshold Helpers.ConsolePrint(Tag, $"PrevStateProfit {prevStateProfit}, CurrentProfit {currentProfit}"); if (prevStateProfit > 0 && currentProfit > 0) { var a = Math.Max(prevStateProfit, currentProfit); var b = Math.Min(prevStateProfit, currentProfit); //double percDiff = Math.Abs((PrevStateProfit / CurrentProfit) - 1); var percDiff = ((a - b)) / b; if (percDiff < ConfigManager.GeneralConfig.SwitchProfitabilityThreshold) { // don't switch Helpers.ConsolePrint(Tag, $"Will NOT switch profit diff is {percDiff}, current threshold {ConfigManager.GeneralConfig.SwitchProfitabilityThreshold}"); // RESTORE OLD PROFITS STATE foreach (var device in _miningDevices) { device.RestoreOldProfitsState(); } return; } Helpers.ConsolePrint(Tag, $"Will SWITCH profit diff is {percDiff}, current threshold {ConfigManager.GeneralConfig.SwitchProfitabilityThreshold}"); } // group new miners var newGroupedMiningPairs = new Dictionary <string, List <MiningPair> >(); // group devices with same supported algorithms { var currentGroupedDevices = new List <GroupedDevices>(); for (var first = 0; first < profitableDevices.Count; ++first) { var firstDev = profitableDevices[first].Device; // check if is in group var isInGroup = currentGroupedDevices.Any(groupedDevices => groupedDevices.Contains(firstDev.Uuid)); // 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 (var 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 var toStopGroupMiners = new Dictionary <string, GroupMiner>(); var toRunNewGroupMiners = new Dictionary <string, GroupMiner>(); var noChangeGroupMiners = new Dictionary <string, GroupMiner>(); // check what to stop/update foreach (var 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) { // Check if dcri optimal value has changed var dcriChanged = false; foreach (var mPair in _runningGroupMiners[runningGroupKey].Miner.MiningSetup.MiningPairs) { if (mPair.Algorithm is DualAlgorithm algo && algo.TuningEnabled && algo.MostProfitableIntensity != algo.CurrentIntensity) { dcriChanged = true; break; } } // if algoType valid and different from currently running update if (newAlgoType != _runningGroupMiners[runningGroupKey].DualAlgorithmType || dcriChanged) { // 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; } else { noChangeGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; } } } } // check brand new foreach (var kvp in newGroupedMiningPairs) { var key = kvp.Key; var miningPairs = kvp.Value; if (_runningGroupMiners.ContainsKey(key) == false) { var newGroupMiner = new GroupMiner(miningPairs, key); toRunNewGroupMiners[key] = newGroupMiner; } } if ((toStopGroupMiners.Values.Count > 0) || (toRunNewGroupMiners.Values.Count > 0)) { var stringBuilderPreviousAlgo = new StringBuilder(); var stringBuilderCurrentAlgo = new StringBuilder(); var stringBuilderNoChangeAlgo = new StringBuilder(); // stop old miners foreach (var toStop in toStopGroupMiners.Values) { stringBuilderPreviousAlgo.Append($"{toStop.DevicesInfoString}: {toStop.AlgorithmType}, "); 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) { stringBuilderCurrentAlgo.Append($"{toStart.DevicesInfoString}: {toStart.AlgorithmType}, "); toStart.Start(_miningLocation, _btcAdress, _worker); _runningGroupMiners[toStart.Key] = toStart; } // which miners dosen't change foreach (var noChange in noChangeGroupMiners.Values) { stringBuilderNoChangeAlgo.Append($"{noChange.DevicesInfoString}: {noChange.AlgorithmType}, "); } if (stringBuilderPreviousAlgo.Length > 0) { Helpers.ConsolePrint(Tag, $"Stop Mining: {stringBuilderPreviousAlgo}"); } if (stringBuilderCurrentAlgo.Length > 0) { Helpers.ConsolePrint(Tag, $"Now Mining : {stringBuilderCurrentAlgo}"); } if (stringBuilderNoChangeAlgo.Length > 0) { Helpers.ConsolePrint(Tag, $"No change : {stringBuilderNoChangeAlgo}"); } } } // stats quick fix code //if (_currentAllGroupedDevices.Count != _previousAllGroupedDevices.Count) { //await MinerStatsCheck(); //} _mainFormRatesComunication?.ForceMinerStatsUpdate(); }
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); //} }
public async Task SwichMostProfitableGroupUpMethod(Dictionary <AlgorithmType, CryptoMiner937API> CryptoMiner937Data, bool log = false) { #if (SWITCH_TESTING) MiningDevice.SetNextTest(); #endif List <MiningPair> profitableDevices = new List <MiningPair>(); double CurrentProfit = 0.0d; double PrevStateProfit = 0.0d; foreach (var device in _miningDevices) { // calculate profits device.CalculateProfits(CryptoMiner937Data); // check if device has profitable algo if (device.HasProfitableAlgo()) { profitableDevices.Add(device.GetMostProfitablePair()); CurrentProfit += device.GetCurrentMostProfitValue; PrevStateProfit += device.GetPrevMostProfitValue; } } // 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.GetFullName())); foreach (var algo in device.Algorithms) { stringBuilderDevice.AppendLine(String.Format("\t\tPROFIT = {0}\t(SPEED = {1}\t\t| NHSMA = {2})\t[{3}]", algo.CurrentProfit.ToString(DOUBLE_FORMAT), // Profit algo.AvaragedSpeed + (algo.IsDual() ? "/" + algo.SecondaryAveragedSpeed : ""), // Speed algo.CurNhmSMADataVal + (algo.IsDual() ? "/" + algo.SecondaryCurNhmSMADataVal : ""), // CryptoMiner937Data algo.AlgorithmStringID // Name )); } // most profitable stringBuilderDevice.AppendLine(String.Format("\t\tMOST PROFITABLE ALGO: {0}, PROFIT: {1}", device.GetMostProfitableString(), device.GetCurrentMostProfitValue.ToString(DOUBLE_FORMAT))); stringBuilderFull.AppendLine(stringBuilderDevice.ToString()); } Helpers.ConsolePrint(TAG, stringBuilderFull.ToString()); } // check if should mine // Only check if profitable inside this method when getting SMA data, cheching during mining is not reliable if (CheckIfShouldMine(CurrentProfit, log) == false) { foreach (var device in _miningDevices) { device.SetNotMining(); } return; } // check profit threshold Helpers.ConsolePrint(TAG, String.Format("PrevStateProfit {0}, CurrentProfit {1}", PrevStateProfit, CurrentProfit)); if (PrevStateProfit > 0 && CurrentProfit > 0) { double a = Math.Max(PrevStateProfit, CurrentProfit); double b = Math.Min(PrevStateProfit, CurrentProfit); //double percDiff = Math.Abs((PrevStateProfit / CurrentProfit) - 1); double percDiff = ((a - b)) / b; if (percDiff < ConfigManager.GeneralConfig.SwitchProfitabilityThreshold) { // don't switch //Helpers.ConsolePrint(TAG, String.Format("Will NOT switch profit diff is {0}, current threshold {1}", percDiff, ConfigManager.GeneralConfig.SwitchProfitabilityThreshold)); // RESTORE OLD PROFITS STATE foreach (var device in _miningDevices) { device.RestoreOldProfitsState(); } if (!SHOULD_START_DONATING) { return; } } else { Helpers.ConsolePrint(TAG, String.Format("Will SWITCH profit diff is {0}, current threshold {1}", percDiff, ConfigManager.GeneralConfig.SwitchProfitabilityThreshold)); } } Helpers.ConsolePrint("Monitoring", "If enabled here I would submit Monitoring data to the server"); if (ConfigManager.GeneralConfig.monitoring == true) { //Run monitoring command here var monversion = "Hash-Kings Miner V" + Application.ProductVersion; #pragma warning disable CS0219 // The variable 'monstatus' is assigned but its value is never used var monstatus = "Running"; #pragma warning restore CS0219 // The variable 'monstatus' is assigned but its value is never used #pragma warning disable CS0219 // The variable 'monrunningminers' is assigned but its value is never used var monrunningminers = "" /*Runningminers go here*/; #pragma warning restore CS0219 // The variable 'monrunningminers' is assigned but its value is never used var monserver = ConfigManager.GeneralConfig.MonServerurl + "/api/report.php"; var request = (HttpWebRequest)WebRequest.Create(monserver); var postData = ""; /* fetch last command line for each miner * Do this for each mining group*/ foreach (var cdev in ComputeDeviceManager.Avaliable.AllAvaliableDevices) { if (cdev.Enabled) { postData += "Name" + Uri.EscapeDataString("Miner Name"); postData += "Path" + Uri.EscapeDataString("miner Path goes here"); postData += "Type" + Uri.EscapeDataString("Type of card EX. AMD"); postData += "Algorithm" + Uri.EscapeDataString("Current mining Algorithm"); postData += "Pool" + Uri.EscapeDataString("Pool Goes Here"); postData += "CurrentSpeed" + Uri.EscapeDataString("Actual hashrate goes here"); postData += "EstimatedSpeed" + Uri.EscapeDataString("Benchmark hashrate Goes Here"); postData += "Profit" + Uri.EscapeDataString("group profitability goes here"); } ; } /* * * Convert above data to Json * Fetch Profit to Variable * $Profit = [string]([Math]::Round(($data | Measure-Object Profit -Sum).Sum, 8)) * Send the request * $Body = @{user = $Config.MonitoringUser; worker = $Config.WorkerName; version = $Version; status = $Status; profit = $Profit; data = $DataJSON} * Try { * $Response = Invoke-RestMethod -Uri "$($Config.MonitoringServer)/api/report.php" -Method Post -Body $Body -UseBasicParsing -TimeoutSec 10 -ErrorAction Stop * Helpers.ConsolePrint("Monitoring", "Reporting status to server..." + $Server responce here" * } * Catch { * Helpers.ConsolePrint("Monitoring", "Unable to send status to " monserver}*/ var data = Encoding.ASCII.GetBytes(postData); request.Method = "POST"; request.ContentType = "application/x-www-form-urlencoded"; request.ContentLength = data.Length; using (var stream = request.GetRequestStream()) { stream.Write(data, 0, data.Length); } var response = (HttpWebResponse)request.GetResponse(); var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd(); } // group new miners 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>(); Dictionary <string, GroupMiner> noChangeGroupMiners = new Dictionary <string, GroupMiner>(); if (MiningSession.SHOULD_START_DONATING) { MiningSession.IS_DONATING = true; } // check what to stop/update int count = _runningGroupMiners.Keys.Count; int it = 0; // + " Mining For : " +(MiningSession.DONATION_SESSION ? "Developer" : "User") foreach (string runningGroupKey in _runningGroupMiners.Keys) { it++; if (newGroupedMiningPairs.ContainsKey(runningGroupKey) == false) { // runningGroupKey not in new group definately needs to be stopped and removed from curently running toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; } // If we need to start donating, stop everything else if (MiningSession.IS_DONATING && !MiningSession.DONATION_SESSION) { if (it == count) { MiningSession.DONATION_SESSION = true; } toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; Helpers.ConsolePrint(TAG, "STARTING - DEV_FEE - Mining Dev-Fee for 24 Minutes."); var miningPairs = newGroupedMiningPairs[runningGroupKey]; var newAlgoType = GetMinerPairAlgorithmType(miningPairs); 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; } else if (MiningSession.IS_DONATING && MiningSession.DONATION_SESSION && MiningSession.SHOULD_STOP_DONATING) { if (it == count) { MiningSession.DONATION_SESSION = false; MiningSession.IS_DONATING = false; MiningSession.DonationStart = MiningSession.DonationStart.Add(MiningSession.DonateEvery); } toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; Helpers.ConsolePrint(TAG, "STOPPING - DEV_FEE - Next Dev-Fee Mining will start in 24 Hours."); var miningPairs = newGroupedMiningPairs[runningGroupKey]; var newAlgoType = GetMinerPairAlgorithmType(miningPairs); 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; } else { MiningSession.DONATION_SESSION = false; MiningSession.IS_DONATING = false; // 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].DualAlgorithmType) { // 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; } else { noChangeGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey]; } } } } // 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; } } if ((toStopGroupMiners.Values.Count > 0) || (toRunNewGroupMiners.Values.Count > 0)) { StringBuilder stringBuilderPreviousAlgo = new StringBuilder(); StringBuilder stringBuilderCurrentAlgo = new StringBuilder(); StringBuilder stringBuilderNoChangeAlgo = new StringBuilder(); // stop old miners foreach (var toStop in toStopGroupMiners.Values) { stringBuilderPreviousAlgo.Append(String.Format("{0}: {1}, ", toStop.DevicesInfoString, toStop.AlgorithmType)); 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) { stringBuilderCurrentAlgo.Append(String.Format("{0}: {1}, ", toStart.DevicesInfoString, toStart.AlgorithmType)); toStart.Start(_miningLocation, _btcAddress, _worker); _runningGroupMiners[toStart.Key] = toStart; } // which miners dosen't change foreach (var noChange in noChangeGroupMiners.Values) { stringBuilderNoChangeAlgo.Append(String.Format("{0}: {1}, ", noChange.DevicesInfoString, noChange.AlgorithmType)); } if (stringBuilderPreviousAlgo.Length > 0) { Helpers.ConsolePrint(TAG, String.Format("Stop Mining: {0}", stringBuilderPreviousAlgo.ToString())); } if (stringBuilderCurrentAlgo.Length > 0) { Helpers.ConsolePrint(TAG, String.Format("Now Mining : {0}", stringBuilderCurrentAlgo.ToString())); } if (stringBuilderNoChangeAlgo.Length > 0) { Helpers.ConsolePrint(TAG, String.Format("No change : {0}", stringBuilderNoChangeAlgo.ToString())); } } } // stats quick fix code //if (_currentAllGroupedDevices.Count != _previousAllGroupedDevices.Count) { await MinerStatsCheck(CryptoMiner937Data); //} }