private void NetworkInterface_OnStopSolvingCurrentChallenge(NetworkInterface.INetworkInterface sender, bool stopSolving = true)
{
if (stopSolving)
{
if (m_isCurrentChallengeStopSolving)
{
return;
}
m_isCurrentChallengeStopSolving = true;
foreach (var device in Devices)
{
device.IsPause = true;
}
PrintMessage(string.Empty, string.Empty, -1, "Info", "Mining temporary paused until new challenge receive...");
}
else if (m_isCurrentChallengeStopSolving)
{
PrintMessage(string.Empty, string.Empty, -1, "Info", "Resume mining...");
m_isCurrentChallengeStopSolving = false;
foreach (var device in Devices)
{
device.IsPause = false;
}
}
}
public CPU(NetworkInterface.INetworkInterface networkInterface, Device[] devices, bool isSubmitStale, int pauseOnFailedScans)
{
try
{
Devices = devices;
NetworkInterface = networkInterface;
m_pauseOnFailedScan = pauseOnFailedScans;
m_failedScanCount = 0;
var devicesStr = string.Empty;
foreach (var device in Devices)
{
if (!device.AllowDevice)
{
continue;
}
if (!string.IsNullOrEmpty(devicesStr))
{
devicesStr += ',';
}
devicesStr += device.DeviceID.ToString("X64");
}
NetworkInterface.OnGetTotalHashrate += NetworkInterface_OnGetTotalHashrate;
m_instance = Solver.GetInstance(new StringBuilder(devicesStr));
unsafe
{
m_GetSolutionTemplateCallback = Solver.SetOnGetSolutionTemplateHandler(m_instance, Work.GetSolutionTemplate);
m_GetKingAddressCallback = Solver.SetOnGetKingAddressHandler(m_instance, Work.GetKingAddress);
}
m_GetWorkPositionCallback = Solver.SetOnGetWorkPositionHandler(m_instance, Work.GetPosition);
m_ResetWorkPositionCallback = Solver.SetOnResetWorkPositionHandler(m_instance, Work.ResetPosition);
m_IncrementWorkPositionCallback = Solver.SetOnIncrementWorkPositionHandler(m_instance, Work.IncrementPosition);
m_MessageCallback = Solver.SetOnMessageHandler(m_instance, m_instance_OnMessage);
m_SolutionCallback = Solver.SetOnSolutionHandler(m_instance, m_instance_OnSolution);
NetworkInterface.OnGetMiningParameterStatus += NetworkInterface_OnGetMiningParameterStatus;
NetworkInterface.OnNewMessagePrefix += NetworkInterface_OnNewMessagePrefix;
NetworkInterface.OnNewTarget += NetworkInterface_OnNewTarget;
networkInterface.OnStopSolvingCurrentChallenge += NetworkInterface_OnStopSolvingCurrentChallenge;
Solver.SetSubmitStale(m_instance, isSubmitStale);
if (string.IsNullOrWhiteSpace(devicesStr))
{
Program.Print("[INFO] No CPU assigned.");
return;
}
}
catch (Exception ex)
{
Program.Print(string.Format("[ERROR] {0}", ex.Message));
}
}
public OpenCL(NetworkInterface.INetworkInterface networkInterface, Device[] devices, bool isSubmitStale, int pauseOnFailedScans)
{
try
{
Devices = devices;
NetworkInterface = networkInterface;
m_pauseOnFailedScan = pauseOnFailedScans;
m_failedScanCount = 0;
HasMonitoringAPI = Solver.foundAdlApi();
if (!HasMonitoringAPI)
{
Program.Print("[WARN] ADL library not found.");
}
unsafe
{
Solver = new Solver()
{
OnGetKingAddressHandler = Work.GetKingAddress,
OnGetSolutionTemplateHandler = Work.GetSolutionTemplate,
OnGetWorkPositionHandler = Work.GetPosition,
OnResetWorkPositionHandler = Work.ResetPosition,
OnIncrementWorkPositionHandler = Work.IncrementPosition,
OnMessageHandler = m_openCLSolver_OnMessage,
OnSolutionHandler = m_openCLSolver_OnSolution
};
}
NetworkInterface.OnGetMiningParameterStatusEvent += NetworkInterface_OnGetMiningParameterStatusEvent;
NetworkInterface.OnNewMessagePrefixEvent += NetworkInterface_OnNewMessagePrefixEvent;
NetworkInterface.OnNewTargetEvent += NetworkInterface_OnNewTargetEvent;
Solver.setSubmitStale(isSubmitStale);
if (devices.All(d => d.DeviceID == -1))
{
Program.Print("[INFO] OpenCL device not set.");
return;
}
for (int i = 0; i < Devices.Length; i++)
{
if (Devices[i].DeviceID > -1)
{
Solver.assignDevice(Devices[i].Platform, Devices[i].DeviceID, ref Devices[i].Intensity);
Devices[i].Name = Solver.getDeviceName(Devices[i].Platform, Devices[i].DeviceID);
}
}
}
catch (Exception ex)
{
Program.Print(string.Format("[ERROR] {0}", ex.Message));
}
}
public CPU(NetworkInterface.INetworkInterface networkInterface, Device[] devices, bool isSubmitStale, int pauseOnFailedScans)
{
try
{
Devices = devices;
NetworkInterface = networkInterface;
m_pauseOnFailedScan = pauseOnFailedScans;
m_failedScanCount = 0;
var devicesStr = string.Empty;
foreach (var device in Devices)
{
if (device.DeviceID < 0)
{
continue;
}
if (!string.IsNullOrEmpty(devicesStr))
{
devicesStr += ',';
}
devicesStr += device.DeviceID.ToString("X64");
}
unsafe
{
Solver = new Solver(devicesStr)
{
OnGetKingAddressHandler = Work.GetKingAddress,
OnGetSolutionTemplateHandler = Work.GetSolutionTemplate,
OnGetWorkPositionHandler = Work.GetPosition,
OnResetWorkPositionHandler = Work.ResetPosition,
OnIncrementWorkPositionHandler = Work.IncrementPosition,
OnMessageHandler = m_cpuSolver_OnMessage,
OnSolutionHandler = m_cpuSolver_OnSolution
};
}
NetworkInterface.OnGetMiningParameterStatusEvent += NetworkInterface_OnGetMiningParameterStatusEvent;
NetworkInterface.OnNewMessagePrefixEvent += NetworkInterface_OnNewMessagePrefixEvent;
NetworkInterface.OnNewTargetEvent += NetworkInterface_OnNewTargetEvent;
Solver.setSubmitStale(isSubmitStale);
if (string.IsNullOrWhiteSpace(devicesStr))
{
Program.Print("[INFO] No CPU assigned.");
return;
}
}
catch (Exception ex)
{
Program.Print(string.Format("[ERROR] {0}", ex.Message));
}
}
private void NetworkInterface_OnNewTargetEvent(NetworkInterface.INetworkInterface sender, string target)
{
try
{
if (m_instance != null && m_instance.ToInt64() != 0)
{
Solver.UpdateTarget(m_instance, new StringBuilder(target));
}
}
catch (Exception ex)
{
Program.Print(string.Format("OpenCL [ERROR] {0}", ex.Message));
}
}
private void NetworkInterface_OnNewTargetEvent(NetworkInterface.INetworkInterface sender, string target)
{
try
{
if (Solver != null)
{
Solver.updateTarget(target);
}
}
catch (Exception ex)
{
Program.Print(string.Format("[ERROR] {0}", ex.Message));
}
}
private void NetworkInterface_OnGetTotalHashrate(NetworkInterface.INetworkInterface sender, ref ulong totalHashrate)
{
try
{
var hashrate = 0ul;
Solver.GetTotalHashRate(m_instance, ref hashrate);
totalHashrate += hashrate;
}
catch (Exception ex)
{
Program.Print(string.Format("OpenCL [ERROR] {0}", ex.Message));
}
}
private void NetworkInterface_OnNewMessagePrefixEvent(NetworkInterface.INetworkInterface sender, string messagePrefix)
{
try
{
if (m_instance != null && m_instance.ToInt64() != 0)
{
Solver.UpdatePrefix(m_instance, new StringBuilder(messagePrefix));
}
}
catch (Exception ex)
{
Program.Print(string.Format("[ERROR] {0}", ex.Message));
}
}
private void NetworkInterface_OnGetMiningParameterStatus(NetworkInterface.INetworkInterface sender, bool success)
{
try
{
if (UnmanagedInstance != null && UnmanagedInstance.ToInt64() != 0)
{
if (success)
{
var isPause = Devices.All(d => d.IsPause);
if (m_isCurrentChallengeStopSolving)
{
isPause = true;
}
else if (isPause)
{
if (m_failedScanCount > m_pauseOnFailedScan)
{
m_failedScanCount = 0;
}
isPause = false;
}
foreach (var device in Devices)
{
device.IsPause = isPause;
}
}
else
{
m_failedScanCount++;
var isMining = Devices.Any(d => d.IsMining);
if (m_failedScanCount > m_pauseOnFailedScan && IsMining)
{
foreach (var device in Devices)
{
device.IsPause = true;
}
}
}
}
}
catch (Exception ex)
{
PrintMessage(string.Empty, string.Empty, -1, "Error", ex.Message);
}
}
public CPU(NetworkInterface.INetworkInterface networkInterface, Device.CPU devices, bool isSubmitStale, int pauseOnFailedScans)
: base(networkInterface, new Device.DeviceBase[] { devices }, isSubmitStale, pauseOnFailedScans)
{
try
{
HasMonitoringAPI = false;
UnmanagedInstance = Helper.CPU.Solver.GetInstance();
AssignDevices();
}
catch (Exception ex)
{
PrintMessage("CPU", string.Empty, -1, "Error", ex.Message);
}
}
private void NetworkInterface_OnGetMiningParameterStatusEvent(NetworkInterface.INetworkInterface sender,
bool success, NetworkInterface.MiningParameters miningParameters)
{
try
{
if (m_instance != null && m_instance.ToInt64() != 0)
{
if (success)
{
var isPause = false;
Solver.IsPaused(m_instance, ref isPause);
if (!NetworkInterface.IsPool &&
((NetworkInterface.Web3Interface)NetworkInterface).IsChallengedSubmitted(miningParameters.ChallengeNumberByte32String))
{
isPause = true;
}
else if (isPause)
{
if (m_failedScanCount > m_pauseOnFailedScan)
{
m_failedScanCount = 0;
}
isPause = false;
}
Solver.PauseFinding(m_instance, isPause);
}
else
{
m_failedScanCount += 1;
var isMining = false;
Solver.IsMining(m_instance, ref isMining);
if (m_failedScanCount > m_pauseOnFailedScan && IsMining)
{
Solver.PauseFinding(m_instance, true);
}
}
}
}
catch (Exception ex)
{
Program.Print(string.Format("[ERROR] {0}", ex.Message));
}
}
public MinerBase(NetworkInterface.INetworkInterface networkInterface, Device.DeviceBase[] devices, bool isSubmitStale, int pauseOnFailedScans)
{
m_failedScanCount = 0;
m_pauseOnFailedScan = pauseOnFailedScans;
m_isSubmitStale = isSubmitStale;
NetworkInterface = networkInterface;
Devices = devices;
m_ChallengeBytes = (byte[])Array.CreateInstance(typeof(byte), UINT256_LENGTH);
m_AddressBytes = (byte[])Array.CreateInstance(typeof(byte), ADDRESS_LENGTH);
NetworkInterface.OnGetTotalHashrate += NetworkInterface_OnGetTotalHashrate;
NetworkInterface.OnGetMiningParameterStatus += NetworkInterface_OnGetMiningParameterStatus;
NetworkInterface.OnNewChallenge += NetworkInterface_OnNewChallenge;
NetworkInterface.OnNewTarget += NetworkInterface_OnNewTarget;
NetworkInterface.OnStopSolvingCurrentChallenge += NetworkInterface_OnStopSolvingCurrentChallenge;
}
private void NetworkInterface_OnGetMiningParameterStatus(NetworkInterface.INetworkInterface sender, bool success, NetworkInterface.MiningParameters miningParameters)
{
try
{
if (m_instance != null && m_instance.ToInt64() != 0)
{
if (success)
{
var isPause = false;
Solver.IsPaused(m_instance, ref isPause);
if (m_isCurrentChallengeStopSolving)
{
isPause = true;
}
else if (isPause)
{
if (m_failedScanCount > m_pauseOnFailedScan)
{
m_failedScanCount = 0;
}
isPause = false;
}
Solver.PauseFinding(m_instance, isPause);
}
else
{
m_failedScanCount += 1;
var isMining = false;
Solver.IsMining(m_instance, ref isMining);
if (m_failedScanCount > m_pauseOnFailedScan && IsMining)
{
Solver.PauseFinding(m_instance, true);
}
}
}
}
catch (Exception ex)
{
Program.Print(string.Format("OpenCL [ERROR] {0}", ex.Message));
}
}
private void NetworkInterface_OnNewChallenge(NetworkInterface.INetworkInterface sender, byte[] challenge, string address)
{
try
{
if (UnmanagedInstance != null && UnmanagedInstance.ToInt64() != 0)
{
for (var i = 0; i < challenge.Length; i++)
{
m_ChallengeBytes[i] = challenge[i];
}
m_AddressString = address;
// some pools provide invalid checksum address
Utils.Numerics.AddressStringToByte20Array(address, ref m_AddressBytes, isChecksum: false);
m_SolutionTemplateBytes = Work.SolutionTemplate;
m_MidStateBytes = Helper.CPU.GetMidState(m_ChallengeBytes, m_AddressBytes, m_SolutionTemplateBytes);
foreach (var device in Devices)
{
Array.ConstrainedCopy(m_ChallengeBytes, 0, device.Message, 0, UINT256_LENGTH);
Array.ConstrainedCopy(m_AddressBytes, 0, device.Message, UINT256_LENGTH, ADDRESS_LENGTH);
Array.ConstrainedCopy(m_SolutionTemplateBytes, 0, device.Message, UINT256_LENGTH + ADDRESS_LENGTH, UINT256_LENGTH);
Array.Copy(m_ChallengeBytes, device.Challenge, UINT256_LENGTH);
Array.Copy(m_MidStateBytes, device.MidState, SPONGE_LENGTH);
device.HasNewChallenge = true;
}
if (m_isCurrentChallengeStopSolving)
{
foreach (var device in Devices)
{
device.IsPause = false;
}
m_isCurrentChallengeStopSolving = false;
}
}
}
catch (Exception ex)
{
PrintMessage(string.Empty, string.Empty, -1, "Error", ex.Message);
}
}
public OpenCL(NetworkInterface.INetworkInterface networkInterface, Device.OpenCL[] intelDevices, Device.OpenCL[] amdDevices, bool isSubmitStale, int pauseOnFailedScans)
: base(networkInterface, amdDevices.Union(intelDevices).ToArray(), isSubmitStale, pauseOnFailedScans)
{
try
{
NetworkInterface = networkInterface;
m_pauseOnFailedScan = pauseOnFailedScans;
m_failedScanCount = 0;
var hasADL_API = false;
Helper.OpenCL.Solver.FoundADL_API(ref hasADL_API);
if (!hasADL_API)
{
Program.Print("OpenCL [WARN] ADL library not found.");
}
if (!hasADL_API && RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
UseLinuxQuery = API.AmdLinuxQuery.QuerySuccess();
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && !UseLinuxQuery)
{
Program.Print("OpenCL [WARN] Unable to find AMD devices in Linux kernel.");
}
HasMonitoringAPI = hasADL_API || UseLinuxQuery;
if (!HasMonitoringAPI)
{
Program.Print("OpenCL [WARN] GPU monitoring not available.");
}
UnmanagedInstance = Helper.OpenCL.Solver.GetInstance();
AssignDevices();
}
catch (Exception ex)
{
Program.Print(string.Format("OpenCL [ERROR] {0}", ex.Message));
}
}
private void NetworkInterface_OnNewMessagePrefix(NetworkInterface.INetworkInterface sender, string messagePrefix)
{
try
{
if (m_instance != null && m_instance.ToInt64() != 0)
{
Solver.UpdatePrefix(m_instance, new StringBuilder(messagePrefix));
if (m_isCurrentChallengeStopSolving)
{
Solver.PauseFinding(m_instance, false);
m_isCurrentChallengeStopSolving = false;
}
}
}
catch (Exception ex)
{
Program.Print(string.Format("OpenCL [ERROR] {0}", ex.Message));
}
}
private void NetworkInterface_OnNewTarget(NetworkInterface.INetworkInterface sender, HexBigInteger target)
{
try
{
var targetBytes = Utils.Numerics.FilterByte32Array(target.Value.ToByteArray(isUnsigned: true, isBigEndian: true));
var high64Bytes = targetBytes.Take(UINT64_LENGTH).Reverse().ToArray();
m_Target = target;
m_High64Target = BitConverter.ToUInt64(high64Bytes);
foreach (var device in Devices)
{
Array.Copy(targetBytes, device.Target, UINT256_LENGTH);
device.High64Target[0] = m_High64Target;
device.HasNewTarget = true;
}
}
catch (Exception ex)
{
PrintMessage(string.Empty, string.Empty, -1, "Error", ex.Message);
}
}
public CUDA(NetworkInterface.INetworkInterface networkInterface, Device.CUDA[] cudaDevices, bool isSubmitStale, int pauseOnFailedScans)
: base(networkInterface, cudaDevices, isSubmitStale, pauseOnFailedScans)
{
try
{
var hasNvAPI64 = false;
Helper.CUDA.Solver.FoundNvAPI64(ref hasNvAPI64);
if (!hasNvAPI64)
{
PrintMessage("CUDA", string.Empty, -1, "Warn", "NvAPI64 library not found.");
}
var foundNvSMI = API.NvSMI.FoundNvSMI();
if (!foundNvSMI)
{
PrintMessage("CUDA", string.Empty, -1, "Warn", "NvSMI library not found.");
}
UseNvSMI = !hasNvAPI64 && foundNvSMI;
HasMonitoringAPI = hasNvAPI64 | UseNvSMI;
if (!HasMonitoringAPI)
{
PrintMessage("CUDA", string.Empty, -1, "Warn", "GPU monitoring not available.");
}
UnmanagedInstance = Helper.CUDA.Solver.GetInstance();
AssignDevices();
}
catch (Exception ex)
{
PrintMessage("CUDA", string.Empty, -1, "Error", ex.Message);
}
}
protected void NetworkInterface_OnGetTotalHashrate(NetworkInterface.INetworkInterface sender, ref ulong totalHashrate)
{
totalHashrate += GetTotalHashrate();
}
private void NetworkInterface_OnStopSolvingCurrentChallenge(NetworkInterface.INetworkInterface sender, string currentTarget)
{
m_isCurrentChallengeStopSolving = true;
Solver.PauseFinding(m_instance, true);
}
public OpenCL(NetworkInterface.INetworkInterface networkInterface,
Device[] intelDevices, Device[] amdDevices, bool isSubmitStale, int pauseOnFailedScans)
{
try
{
NetworkInterface = networkInterface;
m_pauseOnFailedScan = pauseOnFailedScans;
m_failedScanCount = 0;
var hasADL_API = false;
Solver.FoundADL_API(ref hasADL_API);
if (!hasADL_API)
{
Program.Print("OpenCL [WARN] ADL library not found.");
}
if (!hasADL_API && RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
UseLinuxQuery = API.AmdLinuxQuery.QuerySuccess();
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && !UseLinuxQuery)
{
Program.Print("OpenCL [WARN] Unable to find AMD devices in Linux kernel.");
}
HasMonitoringAPI = hasADL_API || UseLinuxQuery;
NetworkInterface.OnGetTotalHashrate += NetworkInterface_OnGetTotalHashrate;
if (!HasMonitoringAPI)
{
Program.Print("OpenCL [WARN] GPU monitoring not available.");
}
m_instance = Solver.GetInstance();
unsafe
{
m_GetSolutionTemplateCallback = Solver.SetOnGetSolutionTemplateHandler(m_instance, Work.GetSolutionTemplate);
m_GetKingAddressCallback = Solver.SetOnGetKingAddressHandler(m_instance, Work.GetKingAddress);
}
m_GetWorkPositionCallback = Solver.SetOnGetWorkPositionHandler(m_instance, Work.GetPosition);
m_ResetWorkPositionCallback = Solver.SetOnResetWorkPositionHandler(m_instance, Work.ResetPosition);
m_IncrementWorkPositionCallback = Solver.SetOnIncrementWorkPositionHandler(m_instance, Work.IncrementPosition);
m_MessageCallback = Solver.SetOnMessageHandler(m_instance, m_instance_OnMessage);
m_SolutionCallback = Solver.SetOnSolutionHandler(m_instance, m_instance_OnSolution);
NetworkInterface.OnGetMiningParameterStatusEvent += NetworkInterface_OnGetMiningParameterStatusEvent;
NetworkInterface.OnNewMessagePrefixEvent += NetworkInterface_OnNewMessagePrefixEvent;
NetworkInterface.OnNewTargetEvent += NetworkInterface_OnNewTargetEvent;
Solver.SetSubmitStale(m_instance, isSubmitStale);
if ((!Program.AllowIntel && !Program.AllowAMD) || (intelDevices.All(d => !d.AllowDevice) && amdDevices.All(d => !d.AllowDevice)))
{
Program.Print("OpenCL [INFO] Device not set.");
return;
}
var deviceName = new StringBuilder(256);
var deviceNameSize = 0ul;
if (Program.AllowIntel)
{
for (int i = 0; i < intelDevices.Length; i++)
{
if (intelDevices[i].AllowDevice)
{
Solver.AssignDevice(m_instance, new StringBuilder(intelDevices[i].Platform), intelDevices[i].DeviceID,
ref intelDevices[i].Intensity, ref intelDevices[i].PciBusID, deviceName, ref deviceNameSize);
}
}
}
if (Program.AllowAMD)
{
for (int i = 0; i < amdDevices.Length; i++)
{
if (amdDevices[i].AllowDevice)
{
deviceName.Clear();
Solver.AssignDevice(m_instance, new StringBuilder(amdDevices[i].Platform), amdDevices[i].DeviceID,
ref amdDevices[i].Intensity, ref amdDevices[i].PciBusID, deviceName, ref deviceNameSize);
if (!UseLinuxQuery)
{
amdDevices[i].Name = deviceName.ToString();
}
else
{
amdDevices[i].Name = API.AmdLinuxQuery.GetDeviceRealName(amdDevices[i].PciBusID, deviceName.ToString());
Program.Print(string.Format("{0} (OpenCL) ID: {1} [INFO] Assigned OpenCL device ({2})",
amdDevices[i].Platform, amdDevices[i].DeviceID, amdDevices[i].Name));
}
}
}
}
if (Program.AllowIntel && Program.AllowAMD)
{
Devices = intelDevices.Union(amdDevices).ToArray();
}
else if (Program.AllowIntel)
{
Devices = intelDevices;
}
else if (Program.AllowAMD)
{
Devices = amdDevices;
}
}
catch (Exception ex)
{
Program.Print(string.Format("OpenCL [ERROR] {0}", ex.Message));
}
}
public CUDA(NetworkInterface.INetworkInterface networkInterface, Device[] cudaDevices, bool isSubmitStale, int pauseOnFailedScans)
{
try
{
Devices = cudaDevices;
NetworkInterface = networkInterface;
m_pauseOnFailedScan = pauseOnFailedScans;
m_failedScanCount = 0;
var hasNvAPI64 = false;
Solver.FoundNvAPI64(ref hasNvAPI64);
if (!hasNvAPI64)
{
Program.Print("CUDA [WARN] NvAPI64 library not found.");
}
var foundNvSMI = API.NvSMI.FoundNvSMI();
if (!foundNvSMI)
{
Program.Print("CUDA [WARN] NvSMI not found.");
}
UseNvSMI = !hasNvAPI64 && foundNvSMI;
HasMonitoringAPI = hasNvAPI64 | UseNvSMI;
if (!HasMonitoringAPI)
{
Program.Print("CUDA [WARN] GPU monitoring not available.");
}
NetworkInterface.OnGetTotalHashrate += NetworkInterface_OnGetTotalHashrate;
m_instance = Solver.GetInstance();
unsafe
{
m_GetSolutionTemplateCallback = Solver.SetOnGetSolutionTemplateHandler(m_instance, Work.GetSolutionTemplate);
m_GetKingAddressCallback = Solver.SetOnGetKingAddressHandler(m_instance, Work.GetKingAddress);
}
m_GetWorkPositionCallback = Solver.SetOnGetWorkPositionHandler(m_instance, Work.GetPosition);
m_ResetWorkPositionCallback = Solver.SetOnResetWorkPositionHandler(m_instance, Work.ResetPosition);
m_IncrementWorkPositionCallback = Solver.SetOnIncrementWorkPositionHandler(m_instance, Work.IncrementPosition);
m_MessageCallback = Solver.SetOnMessageHandler(m_instance, m_instance_OnMessage);
m_SolutionCallback = Solver.SetOnSolutionHandler(m_instance, m_instance_OnSolution);
NetworkInterface.OnGetMiningParameterStatusEvent += NetworkInterface_OnGetMiningParameterStatusEvent;
NetworkInterface.OnNewMessagePrefixEvent += NetworkInterface_OnNewMessagePrefixEvent;
NetworkInterface.OnNewTargetEvent += NetworkInterface_OnNewTargetEvent;
Solver.SetSubmitStale(m_instance, isSubmitStale);
if (!Program.AllowCUDA || cudaDevices.All(d => !d.AllowDevice))
{
Program.Print("[INFO] CUDA device not set.");
return;
}
for (int i = 0; i < Devices.Length; i++)
{
if (Devices[i].AllowDevice)
{
Solver.AssignDevice(m_instance, Devices[i].DeviceID, ref Devices[i].PciBusID, ref Devices[i].Intensity);
}
}
}
catch (Exception ex)
{
Program.Print(string.Format("[ERROR] {0}", ex.Message));
}
}
