// new decoupled benchmarking routines
#region Decoupled benchmarking routines
protected override string BenchmarkCreateCommandLine(Algorithm algorithm, int time)
{
string CommandLine;
string url = Globals.GetLocationURL(algorithm.NiceHashID, Globals.MiningLocation[ConfigManager.GeneralConfig.ServiceLocation], this.ConectionType);
// demo for benchmark
string username = Globals.DemoUser;
if (ConfigManager.GeneralConfig.WorkerName.Length > 0)
{
username += "." + ConfigManager.GeneralConfig.WorkerName.Trim();
}
// cd to the cgminer for the process bins
CommandLine = " /C \"cd /d " + WorkingDirectory + " && sgminer.exe " +
" --gpu-platform " + GPUPlatformNumber +
" -k " + algorithm.MinerName +
" --url=" + url +
" --userpass="******" -p Benchmark " +
" --sched-stop " + DateTime.Now.AddSeconds(time).ToString("HH:mm") +
" -T --log 10 --log-file dump.txt" +
" " +
ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.AMD) +
" --device ";
CommandLine += GetDevicesCommandString();
CommandLine += " && del dump.txt\"";
return(CommandLine);
}
protected override void Init()
{
var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs);
_algorithmType = singleType.Item1;
bool ok = singleType.Item2;
if (!ok)
{
Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!");
throw new InvalidOperationException("Invalid mining initialization");
}
// all good continue on
// init command line params parts
var orderedMiningPairs = _miningPairs.ToList();
orderedMiningPairs.Sort((a, b) => a.Device.ID.CompareTo(b.Device.ID));
_devices = string.Join(",", orderedMiningPairs.Select(p => p.Device.ID));
if (MinerOptionsPackage != null)
{
var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions;
var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults);
var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults);
_extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim();
}
}
// new decoupled benchmarking routines
/// <summary>
/// The BenchmarkCreateCommandLine
/// </summary>
/// <param name="algorithm">The <see cref="Algorithm"/></param>
/// <param name="time">The <see cref="int"/></param>
/// <returns>The <see cref="string"/></returns>
protected override string BenchmarkCreateCommandLine(Algorithm algorithm, int time)
{
string url = Globals.GetLocationURL(algorithm.CryptoMiner937ID, Globals.MiningLocation[ConfigManager.GeneralConfig.ServiceLocation], ConectionType);
string username = Globals.DemoUser;
if (ConfigManager.GeneralConfig.WorkerName.Length > 0)
{
username += "." + ConfigManager.GeneralConfig.WorkerName.Trim();
}
string CommandLine = " --url=" + url +
" --user="******" -p c=BTC,Benchmark,m=party.NPlusMiner " +
ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.NVIDIA) +
" --devices ";
CommandLine += GetDevicesCommandString();
Helpers.ConsolePrint(MinerTAG(), CommandLine);
return(CommandLine);
}
public override void Start(string url, string btcAdress, string worker)
{
if (!IsInit)
{
Helpers.ConsolePrint(MinerTAG(), "MiningSetup is not initialized exiting Start()");
return;
}
string username = GetUsername(btcAdress, worker);
LastCommandLine = " --gpu-platform " + GPUPlatformNumber +
" -k " + MiningSetup.MinerName +
" --url=" + url +
" --userpass="******":" + worker + " " +
" -p " + worker +
" --api-listen" +
" --api-port=" + APIPort.ToString() +
" " +
ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.AMD) +
" --device ";
LastCommandLine += GetDevicesCommandString();
ProcessHandle = _Start();
}
protected override void Init()
{
var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs);
_algorithmType = singleType.Item1;
bool ok = singleType.Item2;
if (!ok)
{
Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!");
throw new InvalidOperationException("Invalid mining initialization");
}
// Order pairs and parse ELP
var orderedMiningPairs = _miningPairs.ToList();
_devices = string.Join(",", _miningPairs.Select(p => _mappedIDs[p.Device.UUID]));
if (MinerOptionsPackage != null)
{
var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions;
var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults);
var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults);
_extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim();
}
}
protected override void Init()
{
var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs);
_algorithmFirstType = singleType.Item1;
bool ok = singleType.Item2;
if (!ok)
{
Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!");
throw new InvalidOperationException("Invalid mining initialization");
}
var dualType = MinerToolkit.GetAlgorithmDualType(_miningPairs);
_algorithmSecondType = dualType.Item1;
ok = dualType.Item2;
if (!ok)
{
_algorithmSecondType = AlgorithmType.NONE;
}
// all good continue on
_orderedMiningPairs = _miningPairs.ToList();
_orderedMiningPairs.Sort((a, b) => _mappedIDs[a.Device.UUID].CompareTo(_mappedIDs[b.Device.UUID]));
_devices = string.Join("", _orderedMiningPairs.Select(p => ClaymoreHelpers.GetClaymoreDeviceID(_mappedIDs[p.Device.UUID])));
if (MinerOptionsPackage != null)
{
var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions;
var generalParams = ExtraLaunchParametersParser.Parse(_orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults);
var temperatureParams = ExtraLaunchParametersParser.Parse(_orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults);
_extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim();
}
}
protected override void prepareConfigFile(string pool, string wallet)
{
if (this.MiningSetup.MiningPairs.Count > 0)
{
try {
bool IsHyperThreadingEnabled = this.MiningSetup.MiningPairs[0].CurrentExtraLaunchParameters.Contains("enable_ht=true");
int numTr = ExtraLaunchParametersParser.GetThreadsNumber(this.MiningSetup.MiningPairs[0]);
if (IsHyperThreadingEnabled)
{
numTr /= 2;
}
var config = new XmrStackCPUMinerConfig(numTr, pool, wallet, this.APIPort);
var no_prefetch = ExtraLaunchParametersParser.GetNoPrefetch(MiningSetup.MiningPairs[0]);
//config.Inti_cpu_threads_conf(false, false, true, ComputeDeviceManager.Avaliable.IsHyperThreadingEnabled);
config.Inti_cpu_threads_conf(false, no_prefetch, false, IsHyperThreadingEnabled);
var confJson = JObject.FromObject(config);
string writeStr = confJson.ToString();
int start = writeStr.IndexOf("{");
int end = writeStr.LastIndexOf("}");
writeStr = writeStr.Substring(start + 1, end - 1);
System.IO.File.WriteAllText(WorkingDirectory + GetConfigFileName(), writeStr);
} catch {
}
}
}
protected override void PrepareConfigFile(string pool, string wallet)
{
try
{
var config = new XmrStakAMDConfig(pool, wallet, APIPort);
var gpuConfigs = new List <XmrStakGPUSettings>();
foreach (var pair in MiningSetup.MiningPairs)
{
var intensities = ExtraLaunchParametersParser.GetIntensityStak(pair);
if (intensities.Count <= 0)
{
intensities.Add(1000);
}
gpuConfigs.AddRange(intensities.Select(intensity =>
new XmrStakGPUSettings(pair.Device.ID, intensity)));
}
config.Initialize_gpu_threads_conf(gpuConfigs);
var serializer = new JsonSerializer
{
TypeNameHandling = TypeNameHandling.All
};
var confJson = JObject.FromObject(config);
var writeStr = confJson.ToString();
var start = writeStr.IndexOf("{");
int end = writeStr.LastIndexOf("}");
writeStr = writeStr.Substring(start + 1, end - 1);
System.IO.File.WriteAllText(WorkingDirectory + GetConfigFileName(), writeStr);
}
catch { }
}
private void checkBox_AMD_DisableAMDTempControl_CheckedChanged(object sender, EventArgs e)
{
if (!_isInitFinished)
{
return;
}
// indicate there has been a change
IsChange = true;
ConfigManager.GeneralConfig.DisableAMDTempControl = checkBox_AMD_DisableAMDTempControl.Checked;
foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices)
{
if (cDev.DeviceType == DeviceType.AMD)
{
foreach (var algorithm in cDev.AlgorithmSettings)
{
if (algorithm.Key != AlgorithmType.DaggerHashimoto)
{
algorithm.Value.ExtraLaunchParameters += AmdGpuDevice.TemperatureParam;
algorithm.Value.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair(
new MiningPair(cDev, algorithm.Value), algorithm.Key, DeviceType.AMD, false);
}
}
}
}
}
public override void Start(string url, string btcAdress, string worker)
{
if (!IsInit)
{
Helpers.ConsolePrint(MinerTAG(), "MiningSetup is not initialized exiting Start()");
return;
}
string username = GetUsername(btcAdress, worker);
IsAPIReadException = MiningSetup.MinerPath == MinerPaths.Data.ccminer_cryptonight;
string algo = "";
string apiBind = "";
if (!IsAPIReadException)
{
algo = "--algo=" + MiningSetup.MinerName;
apiBind = " --api-bind=" + APIPort.ToString();
}
LastCommandLine = algo +
" --url=" + url +
//" --userpass="******":x " +
" --userpass="******":" + worker + " " +
apiBind + " " +
ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.NVIDIA) +
" --devices ";
LastCommandLine += GetDevicesCommandString();
ProcessHandle = _Start();
}
protected override void Init()
{
// check platform id
var openClAmdPlatformResult = MinerToolkit.GetOpenCLPlatformID(_miningPairs);
var openClAmdPlatformNum = openClAmdPlatformResult.Item1;
bool openClAmdPlatformNumUnique = openClAmdPlatformResult.Item2;
if (!openClAmdPlatformNumUnique)
{
Logger.Error(_logGroup, "Initialization of miner failed. Multiple OpenCLPlatform IDs found!");
throw new InvalidOperationException("Invalid mining initialization");
}
// all good continue on
// Order pairs and parse ELP
var miningPairsList = _miningPairs.ToList();
var deviceIds = miningPairsList.Select(pair => pair.Device.ID);
_devicesOnPlatform = $"--gpu-platform {openClAmdPlatformNum} -d {string.Join(",", deviceIds)}";
// if no MinerOptionsPackage fallback to defaults
if (MinerOptionsPackage == null)
{
var ignoreDefaults = SgminerOptionsPackage.DefaultMinerOptionsPackage.IgnoreDefaultValueOptions;
var generalParams = ExtraLaunchParametersParser.Parse(miningPairsList, SgminerOptionsPackage.DefaultMinerOptionsPackage.GeneralOptions, ignoreDefaults);
var temperatureParams = ExtraLaunchParametersParser.Parse(miningPairsList, SgminerOptionsPackage.DefaultMinerOptionsPackage.TemperatureOptions, ignoreDefaults);
_extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim();
}
}
// new decoupled benchmarking routines
#region Decoupled benchmarking routines
protected override string BenchmarkCreateCommandLine(Algorithm algorithm, int time)
{
return("--algo=" + algorithm.MinerName +
" --benchmark" +
ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.CPU) +
" --time-limit " + time.ToString());
}
protected override string GetBenchmarkCommandStringPart(Algorithm algorithm)
{
return(" --benchmark-warmup 40 --benchmark-trial 20"
+ " "
+ ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.NVIDIA)
+ " --cuda --cuda-devices ");
}
protected override string GetDevicesCommandString()
{
var deviceStringCommand = MiningSetup.MiningPairs.Aggregate(" --cuda_devices ",
(current, nvidiaPair) => current + (nvidiaPair.Device.ID + " "));
deviceStringCommand +=
" " + ExtraLaunchParametersParser.ParseForMiningSetup(MiningSetup, DeviceType.NVIDIA);
return(deviceStringCommand);
}
protected override string GetBenchmarkCommandStringPart(Algorithm algorithm)
{
return(" --opencl --opencl-platform " + GPUPlatformNumber
+ " "
+ ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.AMD)
+ " --benchmark-warmup 40 --benchmark-trial 20"
+ " --opencl-devices ");
}
protected override string GetStartCommandStringPart(string url, string username)
{
return(" --cuda"
+ " "
+ ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.NVIDIA)
+ " -S " + url.Substring(14)
+ " -O " + username + ":x "
+ " --api-port " + APIPort.ToString()
+ " --cuda-devices ");
}
protected override string GetStartCommandStringPart(string url, string username)
{
return(" --opencl --opencl-platform " + GPUPlatformNumber
+ " "
+ ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.AMD)
+ " -S " + url.Substring(14)
+ " -O " + username + ":x "
+ " --api-port " + APIPort.ToString()
+ " --opencl-devices ");
}
protected override string GetDevicesCommandString()
{
var extraParams = ExtraLaunchParametersParser.ParseForMiningSetup(MiningSetup, DeviceType.AMD);
var deviceStringCommand = " -c " + ComputeDeviceManager.Avaliable.AmdOpenCLPlatformNum;
deviceStringCommand += " ";
var ids = MiningSetup.MiningPairs.Select(mPair => "-d " + mPair.Device.ID.ToString()).ToList();
deviceStringCommand += string.Join(" ", ids);
return(deviceStringCommand + extraParams);
}
protected override string GetDevicesCommandString()
{
string deviceStringCommand = " --cuda_devices ";
foreach (var nvidia_pair in this.MiningSetup.MiningPairs)
{
deviceStringCommand += nvidia_pair.Device.ID + " ";
}
deviceStringCommand += " " + ExtraLaunchParametersParser.ParseForMiningSetup(MiningSetup, DeviceType.NVIDIA);
return(deviceStringCommand);
}
// This method now overridden in ClaymoreCryptoNightMiner
// Following logic for ClaymoreDual and ClaymoreZcash
protected override string GetDevicesCommandString()
{
// First by device type (AMD then NV), then by bus ID index
var sortedMinerPairs = MiningSetup.MiningPairs
.OrderByDescending(pair => pair.Device.DeviceType)
.ThenBy(pair => pair.Device.IDByBus)
.ToList();
string extraParams = ExtraLaunchParametersParser.ParseForMiningPairs(sortedMinerPairs, DeviceType.AMD);
List <string> ids = new List <string>();
int amdDeviceCount = ComputeDeviceManager.Query.AMD_Devices.Count;
Helpers.ConsolePrint("ClaymoreIndexing", String.Format("Found {0} AMD devices", amdDeviceCount));
foreach (var mPair in sortedMinerPairs)
{
var id = mPair.Device.IDByBus;
if (id < 0)
{
// should never happen
Helpers.ConsolePrint("ClaymoreIndexing", "ID by Bus too low: " + id.ToString() + " skipping device");
continue;
}
if (mPair.Device.DeviceType == DeviceType.NVIDIA)
{
Helpers.ConsolePrint("ClaymoreIndexing", "NVIDIA device increasing index by " + amdDeviceCount.ToString());
id += amdDeviceCount;
}
if (id > 9) // New >10 GPU support in CD9.8
{
if (id < 36) // CD supports 0-9 and a-z indexes, so 36 GPUs
{
char idchar = (char)(id + 87); // 10 = 97(a), 11 - 98(b), etc
ids.Add(idchar.ToString());
}
else
{
Helpers.ConsolePrint("ClaymoreIndexing", "ID " + id + " too high, ignoring");
}
}
else
{
ids.Add(id.ToString());
}
}
var deviceStringCommand = DeviceCommand(amdDeviceCount) + String.Join("", ids);
return(deviceStringCommand + extraParams);
}
private void checkBox_DisableDefaultOptimizations_CheckedChanged(object sender, EventArgs e)
{
if (!_isInitFinished)
{
return;
}
// indicate there has been a change
IsChange = true;
ConfigManager.GeneralConfig.DisableDefaultOptimizations = checkBox_DisableDefaultOptimizations.Checked;
if (ConfigManager.GeneralConfig.DisableDefaultOptimizations)
{
foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices)
{
foreach (var algorithm in cDev.AlgorithmSettings)
{
algorithm.Value.ExtraLaunchParameters = "";
if (cDev.DeviceType == DeviceType.AMD && algorithm.Key != AlgorithmType.DaggerHashimoto)
{
algorithm.Value.ExtraLaunchParameters += AmdGpuDevice.TemperatureParam;
algorithm.Value.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair(
new MiningPair(cDev, algorithm.Value), algorithm.Key, cDev.DeviceType, false);
}
}
}
}
else
{
foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices)
{
if (cDev.DeviceType == DeviceType.CPU)
{
continue; // cpu has no defaults
}
var deviceDefaultsAlgoSettings = GroupAlgorithms.CreateForDevice(cDev);
foreach (var defaultAlgoSettings in deviceDefaultsAlgoSettings)
{
var algorithmKey = defaultAlgoSettings.Key;
if (cDev.AlgorithmSettings.ContainsKey(algorithmKey))
{
var algorithm = cDev.AlgorithmSettings[algorithmKey];
algorithm.ExtraLaunchParameters = defaultAlgoSettings.Value.ExtraLaunchParameters;
algorithm.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair(
new MiningPair(cDev, algorithm), algorithmKey, cDev.DeviceType, false);
}
}
}
}
}
protected override void Init()
{
var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs);
_algorithmType = singleType.Item1;
bool ok = singleType.Item2;
if (!ok)
{
Logger.Error(_logGroup, "Initialization of miner failed. Algorithm not found!");
throw new InvalidOperationException("Invalid mining initialization");
}
// check platform id
var openClAmdPlatformResult = MinerToolkit.GetOpenCLPlatformID(_miningPairs);
var openClAmdPlatformNum = openClAmdPlatformResult.Item1;
bool openClAmdPlatformNumUnique = openClAmdPlatformResult.Item2;
if (!openClAmdPlatformNumUnique)
{
Logger.Error(_logGroup, "Initialization of miner failed. Multiple OpenCLPlatform IDs found!");
throw new InvalidOperationException("Invalid mining initialization");
}
// all good continue on
// Order pairs and parse ELP
var orderedMiningPairs = _miningPairs.ToList();
orderedMiningPairs.Sort((a, b) => a.Device.ID.CompareTo(b.Device.ID));
var deviceIds = orderedMiningPairs.Select(pair => pair.Device.ID);
_devicesOnPlatform = $"--gpu-platform {openClAmdPlatformNum} -d {string.Join(",", deviceIds)}";
if (MinerOptionsPackage != null)
{
var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions;
var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults);
var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults);
_extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim();
}
else // TODO this one is temp???
{
var ignoreDefaults = DefaultMinerOptionsPackage.IgnoreDefaultValueOptions;
var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, DefaultMinerOptionsPackage.GeneralOptions, ignoreDefaults);
var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, DefaultMinerOptionsPackage.TemperatureOptions, ignoreDefaults);
_extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim();
}
}
public virtual bool CanGroup(MiningPair a, MiningPair b)
{
var checkELPCompatibility = MinerOptionsPackage?.GroupMiningPairsOnlyWithCompatibleOptions ?? false;
var isSameAlgoType = MinerToolkit.IsSameAlgorithmType(a.Algorithm, b.Algorithm);
if (isSameAlgoType && checkELPCompatibility)
{
var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions;
var areGeneralOptionsCompatible = ExtraLaunchParametersParser.CheckIfCanGroup(a, b, MinerOptionsPackage.GeneralOptions, ignoreDefaults);
var areTemperatureOptionsCompatible = ExtraLaunchParametersParser.CheckIfCanGroup(a, b, MinerOptionsPackage.TemperatureOptions, ignoreDefaults);
return(areGeneralOptionsCompatible && areTemperatureOptionsCompatible);
}
return(isSameAlgoType);
}
private void checkBox_DisableDefaultOptimizations_CheckedChanged(object sender, EventArgs e)
{
if (!_isInitFinished)
{
return;
}
// indicate there has been a change
IsChange = true;
ConfigManager.GeneralConfig.DisableDefaultOptimizations = checkBox_DisableDefaultOptimizations.Checked;
if (ConfigManager.GeneralConfig.DisableDefaultOptimizations)
{
foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices)
{
foreach (var algorithm in cDev.GetAlgorithmSettings())
{
algorithm.ExtraLaunchParameters = "";
if (cDev.DeviceType == DeviceType.AMD && algorithm.NiceHashID != AlgorithmType.DaggerHashimoto)
{
algorithm.ExtraLaunchParameters += AmdGpuDevice.TemperatureParam;
algorithm.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair(
new MiningPair(cDev, algorithm), algorithm.NiceHashID, cDev.DeviceType, false);
}
}
}
}
else
{
foreach (var cDev in ComputeDeviceManager.Avaliable.AllAvaliableDevices)
{
if (cDev.DeviceType == DeviceType.CPU)
{
continue; // cpu has no defaults
}
var deviceDefaultsAlgoSettings = GroupAlgorithms.CreateForDeviceList(cDev);
foreach (var defaultAlgoSettings in deviceDefaultsAlgoSettings)
{
var toSetAlgo = cDev.GetAlgorithm(defaultAlgoSettings.MinerBaseType, defaultAlgoSettings.NiceHashID);
if (toSetAlgo != null)
{
toSetAlgo.ExtraLaunchParameters = defaultAlgoSettings.ExtraLaunchParameters;
toSetAlgo.ExtraLaunchParameters = ExtraLaunchParametersParser.ParseForMiningPair(
new MiningPair(cDev, toSetAlgo), toSetAlgo.NiceHashID, cDev.DeviceType, false);
}
}
}
}
}
protected override string GetDevicesCommandString()
{
string extraParams = ExtraLaunchParametersParser.ParseForMiningSetup(MiningSetup, DeviceType.AMD);
string deviceStringCommand = " -c " + ComputeDeviceManager.Avaliable.AMDOpenCLPlatformNum;
deviceStringCommand += " ";
List <string> ids = new List <string>();
foreach (var mPair in MiningSetup.MiningPairs)
{
ids.Add("-d " + mPair.Device.ID.ToString());
}
deviceStringCommand += String.Join(" ", ids);
return(deviceStringCommand + extraParams);
}
public override void InitMiningPairs(IEnumerable <MiningPair> miningPairs)
{
// now should be ordered
_miningPairs = GetSortedMiningPairs(miningPairs);
//// update log group
try
{
var devs = _miningPairs.Select(pair => $"{pair.Device.DeviceType}:{pair.Device.ID}");
var devsTag = $"devs({string.Join(",", devs)})";
var algo = _miningPairs.First().Algorithm.AlgorithmName;
var algoTag = $"algo({algo})";
_logGroup = $"{_baseTag}-{algoTag}-{devsTag}";
}
catch (Exception e)
{
Logger.Error(_logGroup, $"Error while setting _logGroup: {e.Message}");
}
// init algo, ELP and finally miner specific init
// init algo
var(first, second, ok) = MinerToolkit.GetFirstAndSecondAlgorithmType(_miningPairs);
_algorithmType = first;
_algorithmSecondType = second;
if (!ok)
{
Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!");
throw new InvalidOperationException("Invalid mining initialization");
}
// init ELP, _miningPairs are ordered and ELP parsing keeps ordering
if (MinerOptionsPackage != null)
{
var miningPairsList = _miningPairs.ToList();
var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions;
var firstPair = miningPairsList.FirstOrDefault();
var optionsWithoutLHR = MinerOptionsPackage.GeneralOptions.Where(opt => !opt.ID.Contains("lolMiner_mode")).ToList();
var optionsWithLHR = MinerOptionsPackage.GeneralOptions.Where(opt => opt.ID.Contains("lolMiner_mode")).ToList();
var generalParamsWithoutLHR = ExtraLaunchParametersParser.Parse(miningPairsList, optionsWithoutLHR, ignoreDefaults);
var isDagger = firstPair.Algorithm.FirstAlgorithmType == AlgorithmType.DaggerHashimoto;
var generalParamsWithLHR = ExtraLaunchParametersParser.Parse(miningPairsList, optionsWithLHR, !isDagger);
var modeOptions = ResolveDeviceMode(miningPairsList, generalParamsWithLHR);
var generalParams = generalParamsWithoutLHR + (isDagger ? modeOptions : "");
var temperatureParams = ExtraLaunchParametersParser.Parse(miningPairsList, MinerOptionsPackage.TemperatureOptions, ignoreDefaults);
_extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim();
}
// miner specific init
Init();
}
protected override void Init()
{
var singleType = MinerToolkit.GetAlgorithmSingleType(_miningPairs);
_algorithmType = singleType.Item1;
bool ok = singleType.Item2;
if (!ok)
{
Logger.Info(_logGroup, "Initialization of miner failed. Algorithm not found!");
throw new InvalidOperationException("Invalid mining initialization");
}
// all good continue on
// Order pairs and parse ELP
var orderedMiningPairs = _miningPairs.ToList();
orderedMiningPairs.Sort((a, b) => a.Device.ID.CompareTo(b.Device.ID));
_devices = string.Join(",", orderedMiningPairs.Select(p => p.Device.ID));
var openClAmdPlatformResult = MinerToolkit.GetOpenCLPlatformID(_miningPairs);
_openClAmdPlatformNum = openClAmdPlatformResult.Item1;
bool openClAmdPlatformNumUnique = openClAmdPlatformResult.Item2;
if (!openClAmdPlatformNumUnique)
{
Logger.Error(_logGroup, "Initialization of miner failed. Multiple OpenCLPlatform IDs found!");
throw new InvalidOperationException("Invalid mining initialization");
}
for (int i = 0; i < orderedMiningPairs.Count; i++)
{
_initOrderMirrorApiOrderUUIDs[i] = orderedMiningPairs[i].Device.UUID;
}
if (MinerOptionsPackage != null)
{
var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions;
var generalParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.GeneralOptions, ignoreDefaults);
var temperatureParams = ExtraLaunchParametersParser.Parse(orderedMiningPairs, MinerOptionsPackage.TemperatureOptions, ignoreDefaults);
_extraLaunchParameters = $"{generalParams} {temperatureParams}".Trim();
}
}
public override void Start(string url, string btcAdress, string worker)
{
if (!IsInit)
{
Helpers.ConsolePrint(MinerTAG(), "MiningSetup is not initialized exiting Start()");
return;
}
string username = GetUsername(btcAdress, worker);
LastCommandLine = "--algo=" + MiningSetup.MinerName +
" --url=" + url +
" --userpass="******":x " +
ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.CPU) +
" --api-bind=" + APIPort.ToString();
ProcessHandle = _Start();
}
// new decoupled benchmarking routines
/// <summary>
/// The BenchmarkCreateCommandLine
/// </summary>
/// <param name="algorithm">The <see cref="Algorithm"/></param>
/// <param name="time">The <see cref="int"/></param>
/// <returns>The <see cref="string"/></returns>
protected override string BenchmarkCreateCommandLine(Algorithm algorithm, int time)
{
string timeLimit = (BenchmarkException) ? "" : " --time-limit " + time.ToString();
string CommandLine = " --algo=" + algorithm.MinerName +
" --benchmark" +
timeLimit + " " +
ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.NVIDIA) +
" --devices ";
CommandLine += GetDevicesCommandString();
// cryptonight exception helper variables
_cryptonightTotalCount = BenchmarkTimeInSeconds / _cryptonightTotalDelim;
_cryptonightTotal = 0.0d;
return(CommandLine);
}
public override void Start(string url, string btcAdress, string worker)
{
if (!IsInit)
{
Helpers.ConsolePrint(MinerTAG(), "MiningSetup is not initialized exiting Start()");
return;
}
string username = GetUsername(btcAdress, worker);
LastCommandLine = " --url " + url +
" --user " + btcAdress +
" -p " + worker + "-I 23 " +
ExtraLaunchParametersParser.ParseForMiningSetup(
MiningSetup,
DeviceType.AMD) +
" --device ";
LastCommandLine += GetDevicesCommandString();
ProcessHandle = _Start();
}
