private async Task BenchmarkAlgorithm(Algorithm algo)
{
BenchmarkManager.AddToStatusCheck(Device, algo);
if (algo is PluginAlgorithm pAlgo)
{
await BenchmarkPluginAlgorithm(pAlgo);
}
}
private async Task BenchmarkAlgorithm(Algorithm algo)
{
var currentMiner = MinerFactory.CreateMinerForBenchmark(algo);
if (currentMiner == null)
{
return;
}
BenchmarkManager.AddToStatusCheck(Device, algo);
if (algo is PluginAlgorithm pAlgo)
{
await BenchmarkPluginAlgorithm(pAlgo);
}
}
private async Task BenchmarkAlgorithm(AlgorithmContainer algo)
{
BenchmarkManager.AddToStatusCheck(Device, algo);
var plugin = algo.PluginContainer;
var miner = plugin.CreateMiner();
var miningPair = new MinerPlugin.MiningPair
{
Device = Device.BaseDevice,
Algorithm = algo.Algorithm
};
// check ethlargement
var miningPairs = new List <MinerPlugin.MiningPair> {
miningPair
};
EthlargementIntegratedPlugin.Instance.Start(miningPairs);
miner.InitMiningPairs(miningPairs);
// fill service since the benchmark might be online. DemoUser.BTC must be used
miner.InitMiningLocationAndUsername(StratumService.SelectedServiceLocation, DemoUser.BTC);
_powerHelper.Start();
var result = await miner.StartBenchmark(_stopBenchmark.Token, _performanceType);
//EthlargementIntegratedPlugin.Instance.Stop(miningPairs); // TODO check stopping
var power = _powerHelper.Stop();
if (result.Success || result.AlgorithmTypeSpeeds?.Count > 0)
{
var ids = result.AlgorithmTypeSpeeds.Select(ats => ats.AlgorithmType).ToList();
var speeds = result.AlgorithmTypeSpeeds.Select(ats => ats.Speed).ToList();
algo.Speeds = speeds;
algo.PowerUsage = power;
// set status to empty string it will return speed
algo.ClearBenchmarkPending();
BenchmarkManager.SetCurrentStatus(Device, algo, "");
}
else
{
// add new failed list
_benchmarkFailedAlgo.Add(algo.AlgorithmName);
BenchmarkManager.SetCurrentStatus(Device, algo, result.ErrorMessage);
}
}
private async Task Benchmark()
{
AlgorithmContainer currentAlgorithm = null;
while (_benchmarkAlgorithmQueue.Count > 0)
{
try
{
if (_stopBenchmark.IsCancellationRequested)
{
break;
}
currentAlgorithm = _benchmarkAlgorithmQueue.Dequeue();
BenchmarkManager.AddToStatusCheck(Device, currentAlgorithm);
await BenchmarkAlgorithm(currentAlgorithm);
await Task.Delay(ConfigManager.GeneralConfig.MinerRestartDelayMS);
if (_stopBenchmark.IsCancellationRequested)
{
break;
}
currentAlgorithm.IsReBenchmark = false;
BenchmarkManager.StepUpBenchmarkStepProgress();
ConfigManager.CommitBenchmarksForDevice(Device);
}
catch (Exception e)
{
Logger.Error("BenchmarkHandler", $"Exception occurred in benchmark task: {e.Message}");
}
}
currentAlgorithm?.ClearBenchmarkPending();
var cancel = _stopBenchmark.IsCancellationRequested;
// don't show unbenchmarked algos if user canceled
var showFailed = _benchmarkFailedAlgo.Count > 0 && !cancel;
var startMining = _startMiningAfterBenchmark && !cancel;
BenchmarkManager.EndBenchmarkForDevice(Device, showFailed, startMining);
}
