public static (bool stopped, string failReason) StopDevice(ComputeDevice device, bool refreshStateChange = true) { // we can only start a device it is already stopped switch (device.State) { case DeviceState.Stopped: return(false, $"Device {device.Uuid} already stopped"); case DeviceState.Benchmarking: device.State = DeviceState.Stopped; BenchmarkManager.StopBenchmarForDevice(device); if (refreshStateChange) { NiceHashStats.StateChanged(); } return(true, ""); case DeviceState.Mining: device.State = DeviceState.Stopped; UpdateDevicesToMine(); if (refreshStateChange) { NiceHashStats.StateChanged(); } return(true, ""); default: return(false, $"Cannot handle state {device.State.ToString()} for device {device.Uuid}"); } }
public static (bool started, string failReason) StartDevice(ComputeDevice device, bool skipBenhcmakrk = false) { // we can only start a device it is already stopped if (device.State != DeviceState.Stopped && !skipBenhcmakrk) { return(false, "Device already started"); } var started = true; var failReason = ""; var isErrorState = !device.AnyAlgorithmEnabled(); var isAllZeroPayingState = device.AllEnabledAlgorithmsZeroPaying(); // check if device has any benchmakrs var needsBenchmark = device.AllEnabledAlgorithmsWithoutBenchmarks(); var needsReBenchmark = device.HasEnabledAlgorithmsWithReBenchmark(); if (isErrorState || isAllZeroPayingState) { device.State = DeviceState.Error; started = false; failReason = isAllZeroPayingState ? "No enabled algorithm is profitable" : "Cannot start a device with all disabled algoirhtms"; } else if (needsBenchmark && !skipBenhcmakrk) { device.State = DeviceState.Benchmarking; BenchmarkManager.StartBenchmarForDevice(device, new BenchmarkStartSettings { StartMiningAfterBenchmark = true, BenchmarkPerformanceType = BenchmarkPerformanceType.Standard, BenchmarkOption = BenchmarkOption.ZeroOnly }); } else if (needsReBenchmark && !skipBenhcmakrk) { device.State = DeviceState.Benchmarking; BenchmarkManager.StartBenchmarForDevice(device, new BenchmarkStartSettings { StartMiningAfterBenchmark = true, BenchmarkPerformanceType = BenchmarkPerformanceType.Standard, BenchmarkOption = BenchmarkOption.ReBecnhOnly }); } else { device.State = DeviceState.Mining; UpdateDevicesToMine(); } RefreshDeviceListView?.Invoke(null, null); NiceHashStats.StateChanged(); return(started, failReason); }
public static (bool stopped, string failReason) StopAllDevice() { var allDevs = AvailableDevices.Devices; // TODO when starting and stopping we are not taking Pending and Error states into account var devicesToStop = allDevs.Where(dev => dev.State == DeviceState.Mining || dev.State == DeviceState.Benchmarking); if (devicesToStop.Count() == 0) { return(false, "No new devices to stop"); } var devicesToStopBenchmarking = devicesToStop.Where(dev => dev.State == DeviceState.Benchmarking); if (devicesToStopBenchmarking.Count() > 0) { BenchmarkManager.StopBenchmarForDevices(devicesToStopBenchmarking); } var devicesToStopMining = devicesToStop.Where(dev => dev.State == DeviceState.Mining); if (devicesToStopMining.Count() > 0) { foreach (var stopDevice in devicesToStopMining) { stopDevice.State = DeviceState.Stopped; } UpdateDevicesToMine(); } // TODO for now no partial success so if one fails send back that everything fails var stopped = true; var failReason = ""; //// try to stop all //foreach (var dev in devicesToStop) { // var (success, msg) = StopDevice(dev, false); // if (!success) { // stopped = false; // failReason = msg; // } //} NiceHashStats.StateChanged(); StopMining(true); return(stopped, failReason); }
// TODO add check for any enabled algorithms public static (bool started, string failReason) StartAllAvailableDevices(bool isRpcCall = false) { var allDevs = AvailableDevices.Devices; var devicesToStart = allDevs.Where(dev => dev.State == DeviceState.Stopped); if (devicesToStart.Count() == 0) { return(false, "there are no new devices to start"); } // TODO for now no partial success so if one fails send back that everything fails var started = true; var failReason = ""; // TODO we have a BUG HERE if device enabled with all disabled algorithms var devicesToBenchmark = devicesToStart.Where(dev => dev.AllEnabledAlgorithmsWithoutBenchmarks() && dev.AnyAlgorithmEnabled()); var devicesToReBenchmark = devicesToStart.Where(dev => dev.HasEnabledAlgorithmsWithReBenchmark() && !devicesToBenchmark.Contains(dev)); foreach (var dev in devicesToBenchmark) { dev.State = DeviceState.Benchmarking; BenchmarkManager.StartBenchmarForDevice(dev, new BenchmarkStartSettings { StartMiningAfterBenchmark = true, BenchmarkPerformanceType = BenchmarkPerformanceType.Standard, BenchmarkOption = BenchmarkOption.ZeroOrReBenchOnly }); } foreach (var dev in devicesToReBenchmark) { dev.State = DeviceState.Benchmarking; BenchmarkManager.StartBenchmarForDevice(dev, new BenchmarkStartSettings { StartMiningAfterBenchmark = true, BenchmarkPerformanceType = BenchmarkPerformanceType.Standard, BenchmarkOption = BenchmarkOption.ReBecnhOnly }); } var devicesInErrorState = devicesToStart.Where(dev => !dev.AnyAlgorithmEnabled() || dev.AllEnabledAlgorithmsZeroPaying()).ToList(); var devicesInErrorStateUUIDs = devicesInErrorState.Select(dev => dev.Uuid); foreach (var dev in devicesInErrorState) { dev.State = DeviceState.Error; } // TODO check count var devicesToMine = devicesToStart.Where(dev => !dev.AllEnabledAlgorithmsWithoutBenchmarks() && !devicesInErrorStateUUIDs.Contains(dev.Uuid)).ToList(); foreach (var dev in devicesToMine) { dev.State = DeviceState.Mining; } UpdateDevicesToMine(); if (!isRpcCall) { NiceHashStats.StateChanged(); } RefreshDeviceListView?.Invoke(null, null); return(started, ""); }