// 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 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);
}
