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();
}
}
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 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);
_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();
}
}
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 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 virtual 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 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");
}
// init ELP, _miningPairs are ordered and ELP parsing keeps ordering
if (MinerOptionsPackage != null)
{
var miningPairsList = _miningPairs.ToList();
var ignoreDefaults = MinerOptionsPackage.IgnoreDefaultValueOptions;
var generalParams = ExtraLaunchParametersParser.Parse(miningPairsList, MinerOptionsPackage.GeneralOptions, ignoreDefaults);
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)
{
throw new InvalidOperationException("Invalid mining initialization");
}
var orderedMiningPairs = _miningPairs.ToList();
orderedMiningPairs.Sort((a, b) => a.Device.ID.CompareTo(b.Device.ID));
//TODO this must be implemented
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 void Parse_Test()
{
var device1 = new BaseDevice(DeviceType.NVIDIA, "GPU-device1", "MSI GeForce GTX 1070 Ti", 0);
var device2 = new BaseDevice(DeviceType.NVIDIA, "GPU-device2", "MSI GeForce GTX 1060 6GB", 1);
var algorithm1 = new Algorithm("BMiner", AlgorithmType.GrinCuckaroo29);
var algorithm2 = new Algorithm("BMiner", AlgorithmType.GrinCuckaroo29);
var options = new List <MinerOption>
{
new MinerOption
{
Type = MinerOptionType.OptionIsParameter,
ID = "optionParameter",
ShortName = "-nofee"
},
new MinerOption
{
Type = MinerOptionType.OptionWithSingleParameter,
ID = "singleParam",
ShortName = "-intensity",
DefaultValue = "6"
},
new MinerOption
{
Type = MinerOptionType.OptionWithMultipleParameters,
ID = "multiParam",
ShortName = "--multi-intensity",
DefaultValue = "-1",
Delimiter = ","
},
new MinerOption
{
Type = MinerOptionType.OptionWithMultipleParameters,
ID = "multiParam_EqSign",
ShortName = "--multi-power=",
DefaultValue = "-1",
Delimiter = ","
},
};
//option is param
algorithm1.ExtraLaunchParameters = "-nofee";
var pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
var miningPairs = new List <MiningPair>()
{
pair1
};
var ret = ExtraLaunchParametersParser.Parse(miningPairs, options);
var exp = " -nofee";
Assert.AreEqual(ret, exp);
// Single param
algorithm1.ExtraLaunchParameters = "-intensity 10";
pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
miningPairs = new List <MiningPair>()
{
pair1
};
ret = ExtraLaunchParametersParser.Parse(miningPairs, options);
exp = " -intensity 10";
Assert.AreEqual(ret, exp);
algorithm1.ExtraLaunchParameters = "-intensity 10 11";
pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
miningPairs = new List <MiningPair>()
{
pair1
};
ret = ExtraLaunchParametersParser.Parse(miningPairs, options);
exp = " -intensity 10";
Assert.AreEqual(ret, exp);
// Multi param
algorithm1.ExtraLaunchParameters = "--multi-intensity 10,11";
pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
miningPairs = new List <MiningPair>()
{
pair1
};
ret = ExtraLaunchParametersParser.Parse(miningPairs, options);
exp = " --multi-intensity 10,11";
Assert.AreEqual(ret, exp);
// multi param, equal sign
algorithm1.ExtraLaunchParameters = "--multi-power=10,11";
pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
miningPairs = new List <MiningPair>()
{
pair1
};
ret = ExtraLaunchParametersParser.Parse(miningPairs, options);
exp = " --multi-power=10,11";
Assert.AreEqual(ret, exp);
//multi param, 1 value
algorithm1.ExtraLaunchParameters = "--multi-intensity 15";
pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
miningPairs = new List <MiningPair>()
{
pair1
};
ret = ExtraLaunchParametersParser.Parse(miningPairs, options);
exp = " --multi-intensity 15";
Assert.AreEqual(ret, exp);
//multi param, 1 value others default
algorithm1.ExtraLaunchParameters = "--multi-intensity 15";
pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
miningPairs = new List <MiningPair>()
{
pair1
};
ret = ExtraLaunchParametersParser.Parse(miningPairs, options);
exp = " --multi-intensity 15";
Assert.AreEqual(ret, exp);
//multi param, no value
algorithm1.ExtraLaunchParameters = "--multi-intensity";
pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
miningPairs = new List <MiningPair>()
{
pair1
};
ret = ExtraLaunchParametersParser.Parse(miningPairs, options);
exp = "";
Assert.AreEqual(ret, exp);
//multi param, 1value, other devices default
algorithm1.ExtraLaunchParameters = "--multi-intensity 15";
pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
var pair2 = new MiningPair
{
Device = device2,
Algorithm = algorithm2
};
miningPairs = new List <MiningPair>()
{
pair1, pair2
};
ret = ExtraLaunchParametersParser.Parse(miningPairs, options);
exp = " --multi-intensity 15,-1";
Assert.AreEqual(ret, exp);
//default values
algorithm1.ExtraLaunchParameters = "";
pair1 = new MiningPair
{
Device = device1,
Algorithm = algorithm1
};
miningPairs = new List <MiningPair>()
{
pair1
};
ret = ExtraLaunchParametersParser.Parse(miningPairs, options, true);
exp = " -nofee -intensity 6 --multi-intensity -1 --multi-power=-1";
Assert.AreEqual(ret, exp);
}
