Пример #1
0
 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);
     }
 }
Пример #2
0
        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();
                    }
                }
            }
        }
Пример #3
0
        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);

            //}
        }
Пример #4
0
        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();
        }
Пример #5
0
        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);

            //}
        }