// TODO IMPLEMENT REMOVE
//public bool RemoveFromBenchmarking(params string[] removeKeys)
//{
// bool allRemoved = true;
// foreach (var key in removeKeys)
// {
// allRemoved &= _benchmarkAlgorithms.TryRemove(key, out var _);
// }
// return allRemoved;
//}
//// TODO on plugin updates update algorithms and stop benchmarking if the current active algorithm is in the update array
//public bool UpdateForBenchmarking(params AlgorithmContainer[] algorithmContainers)
//{
// throw new NotImplementedException();
// StopCurrentAlgorithmBenchmark();
//}
public async Task Benchmark()
{
bool showFailed = false;
bool startMining = false;
try
{
BenchmarkingHandlers.TryAdd(Device, this);
// whole benchmark scope
using (_stopBenchmark = CancellationTokenSource.CreateLinkedTokenSource(ApplicationStateManager.ExitApplication.Token))
{
// Until container is not empty
while (!_benchmarkAlgorithms.IsEmpty)
{
if (_stopBenchmark.IsCancellationRequested)
{
break;
}
// per algo benchmark scope
using (_stopCurrentAlgorithmBenchmark = CancellationTokenSource.CreateLinkedTokenSource(_stopBenchmark.Token))
{
try
{
// this will drain the container
await BenchmarkNextAlgorithm(_stopCurrentAlgorithmBenchmark.Token);
await Task.Delay(ConfigManager.GeneralConfig.MinerRestartDelayMS, _stopCurrentAlgorithmBenchmark.Token);
BenchmarkManager.StepUpBenchmarkStepProgress();
}
catch (Exception e)
{
Logger.Error("BenchmarkHandler", $"Exception occurred in benchmark task: {e.Message}");
}
}
}
AfterBenchmarkCleanup();
// TODO set device to stopped if not mining after benchmark
// TODO start mining after benchmark
var cancel = _stopBenchmark.IsCancellationRequested;
// don't show unbenchmarked algos if user canceled
showFailed = _benchmarkFailedAlgo.Count > 0 && !cancel;
startMining = StartMiningAfterBenchmark && !cancel;
}
}
finally
{
BenchmarkingHandlers.TryRemove(Device, out var _);
Device.State = DeviceState.Stopped;
BenchmarkManager.EndBenchmarkForDevice(Device, showFailed, startMining);
}
}
private async Task BenchmarkAlgorithm(AlgorithmContainer algo, CancellationToken stop)
{
using (var powerHelper = new PowerHelper(algo.ComputeDevice))
{
BenchmarkManager.AddToStatusCheck(algo.ComputeDevice, algo);
var plugin = algo.PluginContainer;
var miner = plugin.CreateMiner();
var miningPair = new MinerPlugin.MiningPair
{
Device = algo.ComputeDevice.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();
algo.ComputeDevice.State = DeviceState.Benchmarking;
var result = await miner.StartBenchmark(stop, 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
BenchmarkManager.SetCurrentStatus(algo.ComputeDevice, algo, "");
ConfigManager.CommitBenchmarksForDevice(algo.ComputeDevice);
}
else
{
// mark it as failed
algo.LastBenchmarkingFailed = true;
// add new failed list
_benchmarkFailedAlgo.Add(algo.AlgorithmName);
algo.SetError(result.ErrorMessage);
BenchmarkManager.SetCurrentStatus(algo.ComputeDevice, 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);
currentAlgorithm.InBenchmark = true;
await BenchmarkAlgorithm(currentAlgorithm);
currentAlgorithm.InBenchmark = false;
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);
}
private async Task BenchmarkNextAlgorithm(CancellationToken stop)
{
var nextAlgo = TakeNextAlgorithm();
if (nextAlgo == null)
{
Logger.Error("BenchmarkingComputeDeviceHandler.BenchmarkNextAlgorithm", $"TakeNextAlgorithm returned null");
return;
}
try
{
BenchmarkManager.AddToStatusCheck(nextAlgo.ComputeDevice, nextAlgo);
nextAlgo.InBenchmark = true;
await BenchmarkAlgorithm(nextAlgo, stop);
}
finally
{
nextAlgo.ClearBenchmarkPending();
nextAlgo.InBenchmark = false;
}
}
