public Algorithm GetAlgorithm(MinerBaseType minerBaseType, AlgorithmType algorithmType,
AlgorithmType secondaryAlgorithmType)
{
var toSetIndex = AlgorithmSettings.FindIndex(a =>
a.NiceHashID == algorithmType && a.MinerBaseType == minerBaseType &&
a.SecondaryNiceHashID == secondaryAlgorithmType);
return(toSetIndex > -1 ? AlgorithmSettings[toSetIndex] : null);
}
public Algorithm GetAlgorithm(MinerBaseType MinerBaseType, AlgorithmType AlgorithmType, AlgorithmType SecondaryAlgorithmType)
{
int toSetIndex = this.AlgorithmSettings.FindIndex((a) => a.NiceHashID == AlgorithmType && a.MinerBaseType == MinerBaseType && a.SecondaryNiceHashID == SecondaryAlgorithmType);
if (toSetIndex > -1)
{
return(this.AlgorithmSettings[toSetIndex]);
}
return(null);
}
/// <summary>
/// The GetAlgorithm
/// </summary>
/// <param name="MinerBaseType">The <see cref="MinerBaseType"/></param>
/// <param name="AlgorithmType">The <see cref="AlgorithmType"/></param>
/// <param name="SecondaryAlgorithmType">The <see cref="AlgorithmType"/></param>
/// <returns>The <see cref="Algorithm"/></returns>
public Algorithm GetAlgorithm(MinerBaseType MinerBaseType, AlgorithmType AlgorithmType, AlgorithmType SecondaryAlgorithmType)
{
int toSetIndex = AlgorithmSettings.FindIndex((a) => a.CryptoMiner937ID == AlgorithmType && a.MinerBaseType == MinerBaseType && a.SecondaryCryptoMiner937ID == SecondaryAlgorithmType);
if (toSetIndex > -1)
{
return(AlgorithmSettings[toSetIndex]);
}
return(null);
}
private static MinerType GetMinerType(DeviceType deviceType, MinerBaseType minerBaseType, AlgorithmType algorithmType)
{
//if (MinerBaseType.cpuminer == minerBaseType) {
// return MinerType.cpuminer_opt;
//}
switch (minerBaseType)
{
case MinerBaseType.sgminer:
return(MinerType.sgminer);
case MinerBaseType.ccminer:
case MinerBaseType.ccminer_alexis:
return(MinerType.ccminer);
case MinerBaseType.Claymore:
switch (algorithmType)
{
case AlgorithmType.DaggerHashimoto:
return(MinerType.ClaymoreDual);
}
break;
case MinerBaseType.ethminer:
if (DeviceType.AMD == deviceType)
{
return(MinerType.ethminer_OCL);
}
if (DeviceType.NVIDIA == deviceType)
{
return(MinerType.ethminer_CUDA);
}
break;
case MinerBaseType.EWBF:
return(MinerType.EWBF);
case MinerBaseType.trex:
return(MinerType.trex);
case MinerBaseType.Phoenix:
return(MinerType.Phoenix);
case MinerBaseType.GMiner:
return(MinerType.GMiner);
case MinerBaseType.BMiner:
return(MinerType.BMiner);
case MinerBaseType.TTMiner:
return(MinerType.TTMiner);
}
return(MinerType.NONE);
}
public TRex(HardwareType hardwareType, MinerBaseType minerBaseType) : base("TRex", hardwareType, minerBaseType)
{
string versionedDirectory = "";
MinerFileName = "t-rex.exe";
versionedDirectory = "t-rex-0.11.0-win-cuda10.0";
MinerWorkingDirectory = Path.Combine(Utils.Core.GetBaseMinersDir(), versionedDirectory);
ApiPort = 4067;
HostName = "127.0.0.1";
}
public CCMinerForkNanashi(HardwareType hardwareType, MinerBaseType minerBaseType, HardwareMonitor hardwareMonitor) : base(hardwareType, minerBaseType, hardwareMonitor, false)
{
string versionedDirectory = "";
MinerFileName = "ccminer.exe";
versionedDirectory = "ccminer-2.2-mod-r2";
MinerWorkingDirectory = Path.Combine(Utils.Core.GetBaseMinersDir(), versionedDirectory);
ApiPort = 4093;
HostName = "127.0.0.1";
}
public WildRig(HardwareType hardwareType, MinerBaseType minerBaseType) : base("WildRig", hardwareType, minerBaseType)
{
string versionedDirectory = "";
MinerFileName = "wildrig.exe";
versionedDirectory = "wildrig-multi-0.13.4-beta";
MinerWorkingDirectory = Path.Combine(Utils.Core.GetBaseMinersDir(), versionedDirectory);
ApiPort = 2883;
HostName = "127.0.0.1";
}
public XMRig(HardwareType hardwareType, MinerBaseType minerBaseType) : base("XMRig", hardwareType, minerBaseType)
{
string versionedDirectory = "";
MinerFileName = "xmrig-notls.exe";
versionedDirectory = "xmrig-2.14.4";
MinerWorkingDirectory = Path.Combine(Utils.Core.GetBaseMinersDir(), versionedDirectory);
ApiPort = 8080;
HostName = "127.0.0.1";
}
// NEW START
////////////////////////////////////////////
// Pure functions
//public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
// return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
//}
public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType, DeviceGroupType devGroupType, bool def = false)
{
if (!def & configurableMiners.Contains(minerBaseType))
{
// Override with internals
var path = minerPathPackages.Find(p => p.DeviceType == devGroupType)
.MinerTypes.Find(p => p.Type == minerBaseType)
.Algorithms.Find(p => p.Algorithm == algoType);
if (path != null)
{
return(path.Path);
}
}
switch (minerBaseType)
{
case MinerBaseType.ccminer:
return(NVIDIA_GROUPS.ccminer_path(algoType, devGroupType));
case MinerBaseType.sgminer:
return(AMD_GROUP.sgminer_path(algoType));
case MinerBaseType.nheqminer:
return(Data.nheqminer);
case MinerBaseType.ethminer:
return(Data.ethminer);
case MinerBaseType.Claymore:
return(AMD_GROUP.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(Data.OptiminerZcashMiner);
case MinerBaseType.excavator:
return(Data.excavator);
case MinerBaseType.XmrStackCPU:
return(Data.XmrStackCPUMiner);
case MinerBaseType.ccminer_alexis:
return(NVIDIA_GROUPS.ccminer_unstable_path(algoType, devGroupType));
case MinerBaseType.experimental:
return(EXPERIMENTAL.GetPath(algoType, devGroupType));
case MinerBaseType.EWBF:
return(Data.EWBF);
case MinerBaseType.Prospector:
return(Data.prospector);
}
return(Data.NONE);
}
public CryptoDredge(HardwareType hardwareType, MinerBaseType minerBaseType) : base("Ccminer", hardwareType, minerBaseType, true)
{
string versionedDirectory = "";
MinerFileName = "CryptoDredge.exe";
versionedDirectory = "CryptoDredge_0.16.1";
MinerWorkingDirectory = Path.Combine(Utils.Core.GetBaseMinersDir(), versionedDirectory);
ApiPort = 4068;
HostName = "127.0.0.1";
}
public Algorithm(MinerBaseType minerBaseType, AlgorithmType niceHashID, string minerName = "", bool enabled = true)
{
NiceHashID = niceHashID;
AlgorithmName = AlgorithmNiceHashNames.GetName(NiceHashID);
MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType);
AlgorithmStringID = MinerBaseTypeName + "_" + AlgorithmName;
MinerBaseType = minerBaseType;
MinerName = minerName;
ExtraLaunchParameters = "";
LessThreads = 0;
Enabled = enabled;
BenchmarkStatus = "";
}
public static List <int> GetPortsListFor(MinerBaseType minerBaseType, string path, AlgorithmType algorithmType)
{
if (_minerReservedPorts != null && _minerReservedPorts.ContainsKey(minerBaseType) &&
(_minerReservedPorts[minerBaseType] != null && _minerReservedPorts[minerBaseType].ContainsKey(path)) &&
(_minerReservedPorts[minerBaseType][path] != null &&
_minerReservedPorts[minerBaseType][path].ContainsKey(algorithmType) &&
_minerReservedPorts[minerBaseType][path][algorithmType] != null))
{
return(_minerReservedPorts[minerBaseType][path][algorithmType]);
}
return(new List <int>());
}
public static List<int> GetPortsListFor(MinerBaseType minerBaseType, string path, AlgorithmType algorithmType)
{
// if (_minerReservedPorts != null && _minerReservedPorts.ContainsKey(minerBaseType) &&
// (_minerReservedPorts[minerBaseType] != null && _minerReservedPorts[minerBaseType].ContainsKey(path)) &&
// (_minerReservedPorts[minerBaseType][path] != null &&
// _minerReservedPorts[minerBaseType][path].ContainsKey(algorithmType) &&
// _minerReservedPorts[minerBaseType][path][algorithmType] != null))
// {
// return _minerReservedPorts[minerBaseType][path][algorithmType];
// }
return new List<int>();
}
public Algorithm(MinerBaseType minerBaseType, AlgorithmType niceHashID, string minerName)
{
this.AlgorithmName = AlgorithmNiceHashNames.GetName(niceHashID);
this.MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType);
this.AlgorithmStringID = this.MinerBaseTypeName + "_" + this.AlgorithmName;
MinerBaseType = minerBaseType;
NiceHashID = niceHashID;
MinerName = minerName;
BenchmarkSpeed = 0.0d;
ExtraLaunchParameters = "";
LessThreads = 0;
Enabled = true;
BenchmarkStatus = "";
}
public Algorithm(MinerBaseType minerBaseType, AlgorithmType niceHashID, string minerName)
{
NiceHashID = niceHashID;
AlgorithmName = AlgorithmNiceHashNames.GetName(NiceHashID);
MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType);
AlgorithmStringID = MinerBaseTypeName + "_" + AlgorithmName;
MinerBaseType = minerBaseType;
MinerName = minerName;
ExtraLaunchParameters = "";
LessThreads = 0;
Enabled = !(NiceHashID == AlgorithmType.Nist5 ||
(NiceHashID == AlgorithmType.NeoScrypt && minerBaseType == MinerBaseType.sgminer));
BenchmarkStatus = "";
}
public static bool IsEquihashGroupLogic(MinerBaseType minerBase, MiningPair a, MiningPair b)
{
// eqm
if (MinerBaseType.eqm == minerBase)
{
return(Is_eqm(a, b));
}
// nheqmnier
else if (MinerBaseType.nheqminer == minerBase)
{
return(Is_nheqminer(a, b));
}
else if (MinerBaseType.ClaymoreAMD == minerBase || MinerBaseType.OptiminerAMD == minerBase)
{
return(true);
}
return(false);
}
public Algorithm(MinerBaseType minerBaseType, AlgorithmType niceHashID, string minerName, AlgorithmType secondaryNiceHashID = AlgorithmType.NONE)
{
NiceHashID = niceHashID;
SecondaryNiceHashID = secondaryNiceHashID;
this.AlgorithmName = AlgorithmNiceHashNames.GetName(DualNiceHashID());
this.MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType);
this.AlgorithmStringID = this.MinerBaseTypeName + "_" + this.AlgorithmName;
MinerBaseType = minerBaseType;
MinerName = minerName;
BenchmarkSpeed = 0.0d;
SecondaryBenchmarkSpeed = 0.0d;
ExtraLaunchParameters = "";
LessThreads = 0;
Enabled = !(NiceHashID == AlgorithmType.Nist5);
BenchmarkStatus = "";
}
public Ccminer(HardwareType hardwareType, MinerBaseType minerBaseType, bool is64Bit) : base("Ccminer", hardwareType, minerBaseType, is64Bit)
{
string versionedDirectory = "";
if (is64Bit)
{
MinerFileName = "ccminer.exe";
versionedDirectory = "ccminer-lyra3";
}
else
{
MinerFileName = "ccminer.exe";
versionedDirectory = "ccminer-lyra3";
}
MinerWorkingDirectory = Path.Combine(Utils.Core.GetBaseMinersDir(), versionedDirectory);
ApiPort = 4068;
HostName = "127.0.0.1";
}
// NEW START
////////////////////////////////////////////
// Pure functions
//public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
// return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
//}
public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType, DeviceGroupType devGroupType)
{
switch (minerBaseType)
{
case MinerBaseType.ccminer:
return(NVIDIA_GROUPS.ccminer_path(algoType, devGroupType));
case MinerBaseType.sgminer:
return(AMD_GROUP.sgminer_path(algoType));
case MinerBaseType.nheqminer:
return(Data.nheqminer);
case MinerBaseType.ethminer:
return(Data.ethminer);
case MinerBaseType.Claymore:
return(AMD_GROUP.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(Data.OptiminerZcashMiner);
case MinerBaseType.excavator:
return(Data.excavator);
case MinerBaseType.XmrStackCPU:
return(Data.XmrStackCPUMiner);
case MinerBaseType.ccminer_alexis:
return(NVIDIA_GROUPS.ccminer_unstable_path(algoType, devGroupType));
case MinerBaseType.experimental:
return(EXPERIMENTAL.GetPath(algoType, devGroupType));
case MinerBaseType.EWBF:
return(Data.EWBF);
case MinerBaseType.Prospector:
return(Data.prospector);
}
return(Data.NONE);
}
/// <summary>
/// Initializes a new instance of the <see cref="Algorithm"/> class.
/// </summary>
/// <param name="minerBaseType">The <see cref="MinerBaseType"/></param>
/// <param name="cryptominer937ID">The <see cref="AlgorithmType"/></param>
/// <param name="minerName">The <see cref="string"/></param>
/// <param name="secondaryCryptoMiner937ID">The <see cref="AlgorithmType"/></param>
public Algorithm(MinerBaseType minerBaseType, AlgorithmType cryptominer937ID, string minerName, AlgorithmType secondaryCryptoMiner937ID = AlgorithmType.NONE)
{
CryptoMiner937ID = cryptominer937ID;
SecondaryCryptoMiner937ID = secondaryCryptoMiner937ID;
AlgorithmName = AlgorithmCryptoMiner937Names.GetName(DualCryptoMiner937ID());
MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType);
AlgorithmStringID = MinerBaseTypeName + "_" + AlgorithmName;
MinerBaseType = minerBaseType;
MinerName = minerName;
BenchmarkSpeed = 0.0d;
SecondaryBenchmarkSpeed = 0.0d;
ExtraLaunchParameters = "";
LessThreads = 1;
Enabled = !(CryptoMiner937ID == AlgorithmType.Nist5 || CryptoMiner937ID == AlgorithmType.Skein || CryptoMiner937ID == AlgorithmType.Blake2s || CryptoMiner937ID == AlgorithmType.Xevan || CryptoMiner937ID == AlgorithmType.Tribus || CryptoMiner937ID == AlgorithmType.Phi || CryptoMiner937ID == AlgorithmType.Hsr || CryptoMiner937ID == AlgorithmType.Bitcore) && minerBaseType == MinerBaseType.sgminer;
Enabled = !(CryptoMiner937ID == AlgorithmType.cryptonight) || (CryptoMiner937ID == AlgorithmType.Keccak) && minerBaseType == MinerBaseType.GatelessGate;
//Enabled = !(CryptoMiner937ID == AlgorithmType.Lyra2REv2) && minerBaseType == MinerBaseType.mkxminer;
BenchmarkStatus = "";
}
public Algorithm(MinerBaseType minerBaseType, AlgorithmType niceHashID, string minerName, AlgorithmType secondaryNiceHashID = AlgorithmType.NONE)
{
NiceHashID = niceHashID;
SecondaryNiceHashID = secondaryNiceHashID;
this.AlgorithmName = AlgorithmNiceHashNames.GetName(DualNiceHashID());
this.MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType);
this.AlgorithmStringID = this.MinerBaseTypeName + "_" + this.AlgorithmName;
MinerBaseType = minerBaseType;
MinerName = minerName;
BenchmarkSpeed = 0.0d;
SecondaryBenchmarkSpeed = 0.0d;
ExtraLaunchParameters = "";
LessThreads = 0;
Enabled = !(NiceHashID == AlgorithmType.Nist5 || NiceHashID == AlgorithmType.Skein || NiceHashID == AlgorithmType.Blake2s || NiceHashID == AlgorithmType.Xevan || NiceHashID == AlgorithmType.Tribus || NiceHashID == AlgorithmType.Veltor || NiceHashID == AlgorithmType.Phi || NiceHashID == AlgorithmType.Hsr || NiceHashID == AlgorithmType.Bitcore) && minerBaseType == MinerBaseType.sgminer;
Enabled = !(NiceHashID == AlgorithmType.CryptoNight) || (NiceHashID == AlgorithmType.Keccak) && minerBaseType == MinerBaseType.GatelessGate;
//Enabled = !(NiceHashID == AlgorithmType.Lyra2REv2) && minerBaseType == MinerBaseType.mkxminer;
BenchmarkStatus = "";
}
public Algorithm(MinerBaseType minerBaseType, AlgorithmType niceHashID, string minerName)
{
NiceHashID = niceHashID;
AlgorithmName = AlgorithmNiceHashNames.GetName(NiceHashID);
MinerBaseTypeName = Enum.GetName(typeof(MinerBaseType), minerBaseType);
AlgorithmStringID = MinerBaseTypeName + "_" + AlgorithmName;
MinerBaseType = minerBaseType;
MinerName = minerName;
ExtraLaunchParameters = "";
LessThreads = 0;
Enabled = !(NiceHashID == AlgorithmType.Nist5 ||
(NiceHashID == AlgorithmType.NeoScrypt && minerBaseType == MinerBaseType.sgminer));
Enabled = !(NiceHashID == AlgorithmType.CryptoNightV7) && minerBaseType == MinerBaseType.XmrigAMD;
Enabled = !(NiceHashID == AlgorithmType.CryptoNightV8) && minerBaseType == MinerBaseType.XmrigAMD;
Enabled = !(NiceHashID == AlgorithmType.CryptoNightV8) && minerBaseType == MinerBaseType.SRBMiner;
Enabled = !(NiceHashID == AlgorithmType.CryptoNightHeavy) && minerBaseType == MinerBaseType.SRBMiner;
Enabled = !(NiceHashID == AlgorithmType.Lyra2REv2) && minerBaseType == MinerBaseType.mkxminer;
BenchmarkStatus = "";
}
public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType, DeviceGroupType devGroupType, string devCodenameAMD, bool isOptimizedAMD, CPUExtensionType MostOptimizedCPUExtensionType)
{
switch (minerBaseType)
{
case MinerBaseType.cpuminer:
return(CPU_GROUP.cpu_miner_opt(MostOptimizedCPUExtensionType));
case MinerBaseType.ccminer:
return(NVIDIA_GROUPS.ccminer_path(algoType, devGroupType));
case MinerBaseType.sgminer:
return(AMD_GROUP.sgminer_path(algoType, devCodenameAMD, isOptimizedAMD));
case MinerBaseType.nheqminer:
return(Data.nheqminer);
case MinerBaseType.eqm:
return(Data.eqm);
case MinerBaseType.ethminer:
return(Data.ethminer);
case MinerBaseType.ClaymoreAMD:
return(AMD_GROUP.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(Data.OptiminerZcashMiner);
case MinerBaseType.excavator:
return(Data.excavator);
case MinerBaseType.XmrStackCPU:
return(Data.XmrStackCPUMiner);
case MinerBaseType.ccminer_alexis:
return(NVIDIA_GROUPS.ccminer_unstable_path(algoType, devGroupType));
}
return(Data.NONE);
}
// NEW START
////////////////////////////////////////////
// Pure functions
//public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
// return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
//}
public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType,
DeviceGroupType devGroupType, bool def = false)
{
if (!def & ConfigurableMiners.Contains(minerBaseType))
{
// Override with internals
var path = MinerPathPackages.Find(p => p.DeviceType == devGroupType)
.MinerTypes.Find(p => p.Type == minerBaseType)
.Algorithms.Find(p => p.Algorithm == algoType);
if (path != null)
{
if (File.Exists(path.Path))
{
return(path.Path);
}
Helpers.ConsolePrint("PATHS", $"Path {path.Path} not found, using defaults");
}
}
// Temp workaround
if (minerBaseType == MinerBaseType.XmrStak && algoType == AlgorithmType.CryptoNightHeavy)
{
return(Data.XmrStakHeavy);
}
switch (minerBaseType)
{
case MinerBaseType.ccminer:
return(NvidiaGroups.Ccminer_path(algoType, devGroupType));
case MinerBaseType.sgminer:
return(AmdGroup.SgminerPath(algoType));
case MinerBaseType.nheqminer:
return(Data.NhEqMiner);
case MinerBaseType.ethminer:
return(Data.Ethminer);
case MinerBaseType.Claymore:
return(AmdGroup.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(Data.OptiminerZcashMiner);
//case MinerBaseType.excavator:
// return Data.Excavator;
case MinerBaseType.XmrStak:
return(Data.XmrStak);
case MinerBaseType.ccminer_alexis:
return(NvidiaGroups.CcminerUnstablePath(algoType, devGroupType));
case MinerBaseType.experimental:
return(Experimental.GetPath(algoType, devGroupType));
case MinerBaseType.EWBF:
return(Data.Ewbf);
case MinerBaseType.Prospector:
return(Data.Prospector);
case MinerBaseType.Xmrig:
return(Data.Xmrig);
case MinerBaseType.dtsm:
return(Data.Dtsm);
case MinerBaseType.cpuminer:
return(Data.CpuMiner);
}
return(Data.None);
}
public MinerTypePath(MinerBaseType type, List <MinerPath> paths)
{
Type = type;
Algorithms = paths;
Name = type.ToString();
}
private static MinerType GetMinerType(DeviceType deviceType, MinerBaseType minerBaseType, AlgorithmType algorithmType)
{
//if (MinerBaseType.cpuminer == minerBaseType) {
// return MinerType.cpuminer_opt;
//}
switch (minerBaseType)
{
case MinerBaseType.OptiminerAMD:
return MinerType.OptiminerZcash;
case MinerBaseType.sgminer:
return MinerType.sgminer;
case MinerBaseType.ccminer:
case MinerBaseType.ccminer_alexis:
case MinerBaseType.experimental:
if (AlgorithmType.CryptoNight == algorithmType)
{
return MinerType.ccminer_CryptoNight;
}
return MinerType.ccminer;
case MinerBaseType.Claymore:
switch (algorithmType)
{
case AlgorithmType.CryptoNight:
return MinerType.ClaymoreCryptoNight;
case AlgorithmType.Equihash:
return MinerType.ClaymoreZcash;
case AlgorithmType.DaggerHashimoto:
return MinerType.ClaymoreDual;
}
break;
case MinerBaseType.Claymore_old:
if (AlgorithmType.CryptoNight == algorithmType)
{
return MinerType.ClaymoreCryptoNight;
}
break;
case MinerBaseType.ethminer:
if (DeviceType.AMD == deviceType)
{
return MinerType.ethminer_OCL;
}
if (DeviceType.NVIDIA == deviceType)
{
return MinerType.ethminer_CUDA;
}
break;
case MinerBaseType.nheqminer:
switch (deviceType)
{
case DeviceType.CPU:
return MinerType.nheqminer_CPU;
case DeviceType.AMD:
return MinerType.nheqminer_AMD;
case DeviceType.NVIDIA:
return MinerType.nheqminer_CUDA;
}
break;
case MinerBaseType.eqm:
if (DeviceType.CPU == deviceType)
{
return MinerType.eqm_CPU;
}
if (DeviceType.NVIDIA == deviceType)
{
return MinerType.eqm_CUDA;
}
break;
//case MinerBaseType.excavator:
// return MinerType.excavator;
case MinerBaseType.EWBF:
return MinerType.EWBF;
case MinerBaseType.Xmrig:
return MinerType.Xmrig;
case MinerBaseType.dtsm:
return MinerType.dtsm;
}
return MinerType.NONE;
}
private static Dictionary <MinerBaseType, List <Algorithm> > CreateForDevice(ComputeDevice device)
{
if (device == null)
{
return(null);
}
var algoSettings = CreateDefaultsForGroup(device.DeviceGroupType);
if (algoSettings == null)
{
return(null);
}
if (device.DeviceType == DeviceType.AMD)
{
// sgminer stuff
if (algoSettings.ContainsKey(MinerBaseType.sgminer))
{
var sgminerAlgos = algoSettings[MinerBaseType.sgminer];
var lyra2REv2Index = sgminerAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.Lyra2REv2);
var neoScryptIndex = sgminerAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.NeoScrypt);
var cryptoNightIndex = sgminerAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.CryptoNight);
// Check for optimized version
if (lyra2REv2Index > -1)
{
sgminerAlgos[lyra2REv2Index].ExtraLaunchParameters =
AmdGpuDevice.DefaultParam +
"--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 64 --gpu-threads 2";
}
if (!device.Codename.Contains("Tahiti") && neoScryptIndex > -1)
{
sgminerAlgos[neoScryptIndex].ExtraLaunchParameters =
AmdGpuDevice.DefaultParam +
"--nfactor 10 --xintensity 2 --thread-concurrency 8192 --worksize 64 --gpu-threads 2";
Helpers.ConsolePrint("ComputeDevice",
"The GPU detected (" + device.Codename +
") is not Tahiti. Changing default gpu-threads to 2.");
}
if (cryptoNightIndex > -1)
{
if (device.Codename.Contains("Hawaii"))
{
sgminerAlgos[cryptoNightIndex].ExtraLaunchParameters = "--rawintensity 640 -w 8 -g 2";
}
else if (device.Name.Contains("Vega"))
{
sgminerAlgos[cryptoNightIndex].ExtraLaunchParameters =
AmdGpuDevice.DefaultParam + " --rawintensity 1850 -w 8 -g 2";
}
}
}
// Ellesmere, Polaris
// Ellesmere sgminer workaround, keep this until sgminer is fixed to work with Ellesmere
if (device.Codename.Contains("Ellesmere") || device.InfSection.ToLower().Contains("polaris"))
{
foreach (var algosInMiner in algoSettings)
{
foreach (var algo in algosInMiner.Value)
{
// disable all algos in list
if (algo.NiceHashID == AlgorithmType.Decred || algo.NiceHashID == AlgorithmType.Lbry)
{
algo.Enabled = false;
}
}
}
}
// non sgminer optimizations
if (algoSettings.ContainsKey(MinerBaseType.Claymore_old) &&
algoSettings.ContainsKey(MinerBaseType.Claymore))
{
var claymoreOldAlgos = algoSettings[MinerBaseType.Claymore_old];
var cryptoNightOldIndex =
claymoreOldAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.CryptoNight);
var claymoreNewAlgos = algoSettings[MinerBaseType.Claymore];
var cryptoNightNewIndex =
claymoreNewAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.CryptoNight);
if (cryptoNightOldIndex > -1 && cryptoNightNewIndex > -1)
{
//string regex_a_3 = "[5|6][0-9][0-9][0-9]";
var a4 = new List <string>
{
"270",
"270x",
"280",
"280x",
"290",
"290x",
"370",
"380",
"390",
"470",
"480"
};
foreach (var namePart in a4)
{
if (!device.Name.Contains(namePart))
{
continue;
}
claymoreOldAlgos[cryptoNightOldIndex].ExtraLaunchParameters = "-a 4";
break;
}
var old = new List <string>
{
"Verde",
"Oland",
"Bonaire"
};
foreach (var codeName in old)
{
var isOld = device.Codename.Contains(codeName);
claymoreOldAlgos[cryptoNightOldIndex].Enabled = isOld;
claymoreNewAlgos[cryptoNightNewIndex].Enabled = !isOld;
}
}
}
// drivers algos issue
if (device.DriverDisableAlgos)
{
algoSettings = FilterMinerAlgos(algoSettings, new List <AlgorithmType>
{
AlgorithmType.NeoScrypt,
AlgorithmType.Lyra2REv2
});
}
// disable by default
{
var minerBases = new List <MinerBaseType>
{
MinerBaseType.ethminer,
MinerBaseType.OptiminerAMD
};
foreach (var minerKey in minerBases)
{
if (!algoSettings.ContainsKey(minerKey))
{
continue;
}
foreach (var algo in algoSettings[minerKey])
{
algo.Enabled = false;
}
}
if (algoSettings.ContainsKey(MinerBaseType.sgminer))
{
foreach (var algo in algoSettings[MinerBaseType.sgminer])
{
if (algo.NiceHashID == AlgorithmType.DaggerHashimoto)
{
algo.Enabled = false;
}
}
}
//if (algoSettings.ContainsKey(MinerBaseType.Claymore)) {
// foreach (var algo in algoSettings[MinerBaseType.Claymore]) {
// if (algo.NiceHashID == AlgorithmType.CryptoNight) {
// algo.Enabled = false;
// }
// }
//}
}
} // END AMD case
// check if it is Etherum capable
if (device.IsEtherumCapale == false)
{
algoSettings = FilterMinerAlgos(algoSettings, new List <AlgorithmType>
{
AlgorithmType.DaggerHashimoto
});
}
if (algoSettings.ContainsKey(MinerBaseType.ccminer_alexis))
{
foreach (var unstableAlgo in algoSettings[MinerBaseType.ccminer_alexis])
{
unstableAlgo.Enabled = false;
}
}
if (algoSettings.ContainsKey(MinerBaseType.experimental))
{
foreach (var unstableAlgo in algoSettings[MinerBaseType.experimental])
{
unstableAlgo.Enabled = false;
}
}
// This is not needed anymore after excavator v1.1.4a
//if (device.IsSM50() && algoSettings.ContainsKey(MinerBaseType.excavator)) {
// int Equihash_index = algoSettings[MinerBaseType.excavator].FindIndex((algo) => algo.NiceHashID == AlgorithmType.Equihash);
// if (Equihash_index > -1) {
// // -c1 1 needed for SM50 to work ATM
// algoSettings[MinerBaseType.excavator][Equihash_index].ExtraLaunchParameters = "-c1 1";
// }
//}
// NhEqMiner exceptions scope
{
const MinerBaseType minerBaseKey = MinerBaseType.nheqminer;
if (algoSettings.ContainsKey(minerBaseKey) && device.Name.Contains("GTX") &&
(device.Name.Contains("560") || device.Name.Contains("650") || device.Name.Contains("680") ||
device.Name.Contains("770"))
)
{
algoSettings = FilterMinerBaseTypes(algoSettings, new List <MinerBaseType>
{
minerBaseKey
});
}
}
return(algoSettings);
}
// NEW START
////////////////////////////////////////////
// Pure functions
//public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
// return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
//}
public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType, DeviceGroupType devGroupType, bool def = false)
{
if (!def & configurableMiners.Contains(minerBaseType))
{
// Override with internals
var path = minerPathPackages.Find(p => p.DeviceType == devGroupType)
.MinerTypes.Find(p => p.Type == minerBaseType)
.Algorithms.Find(p => p.Algorithm == algoType);
if (path != null)
{
if (File.Exists(path.Path))
{
return(path.Path);
}
else
{
Helpers.ConsolePrint("PATHS", String.Format("Path {0} not found, using defaults", path.Path));
}
}
}
switch (minerBaseType)
{
case MinerBaseType.ccminer:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.ccminer_22:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.ccminer_alexis_hsr:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.ccminer_alexis78:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.ccminer_klaust818:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.ccminer_palgin:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.ccminer_polytimos:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.ccminer_skunkkrnlx:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.ccminer_xevan:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.ccminer_tpruvot2:
return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));
case MinerBaseType.sgminer:
return(AMD_GROUP.Sgminer_path(algoType));
case MinerBaseType.GatelessGate:
return(AMD_GROUP.Glg_path(algoType));
case MinerBaseType.nheqminer:
return(Data.nheqminer);
case MinerBaseType.ethminer:
return(Data.ethminer);
case MinerBaseType.Claymore:
return(AMD_GROUP.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(Data.OptiminerZcashMiner);
case MinerBaseType.excavator:
return(Data.excavator);
case MinerBaseType.XmrStackCPU:
return(Data.XmrStackCPUMiner);
case MinerBaseType.ccminer_alexis:
return(NVIDIA_GROUPS.Ccminer_unstable_path(algoType, devGroupType));
case MinerBaseType.experimental:
return(EXPERIMENTAL.GetPath(algoType, devGroupType));
case MinerBaseType.EWBF:
return(Data.EWBF);
case MinerBaseType.DSTM:
return(Data.DSTM);
case MinerBaseType.Prospector:
return(Data.prospector);
case MinerBaseType.Xmrig:
return(Data.Xmrig);
case MinerBaseType.XmrStakAMD:
return(Data.XmrStakAMD);
case MinerBaseType.Claymore_old:
return(Data.ClaymoreCryptoNightMiner_old);
case MinerBaseType.hsrneoscrypt:
return(NVIDIA_GROUPS.Hsrneoscrypt_path(algoType, devGroupType));
//case MinerBaseType.mkxminer:
//return Data.mkxminer;
}
return(Data.NONE);
}
// NEW START
////////////////////////////////////////////
// Pure functions
//public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
// return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
//}
public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType,
DeviceGroupType devGroupType, bool def = false)
{
if (!def & ConfigurableMiners.Contains(minerBaseType))
{
// Override with internals
var path = MinerPathPackages.Find(p => p.DeviceType == devGroupType)
.MinerTypes.Find(p => p.Type == minerBaseType)
.Algorithms.Find(p => p.Algorithm == algoType);
if (path != null)
{
if (File.Exists(path.Path))
{
return(path.Path);
}
Helpers.ConsolePrint("PATHS", $"Path {path.Path} not found, using defaults");
}
}
// Temp workaround
if (minerBaseType == MinerBaseType.XmrStak && algoType == AlgorithmType.CryptoNightHeavy)
{
return(Data.XmrStakHeavy);
}
if (minerBaseType == MinerBaseType.CryptoDredge && algoType == AlgorithmType.CryptoNightV8)
{
// return NvidiaGroups.CryptoDredgeV8(algoType, devGroupType);
return(Data.CryptoDredge);
}
switch (minerBaseType)
{
case MinerBaseType.ccminer:
return(NvidiaGroups.Ccminer_path(algoType, devGroupType));
case MinerBaseType.sgminer:
return(AmdGroup.SgminerPath(algoType));
case MinerBaseType.nheqminer:
return(Data.NhEqMiner);
case MinerBaseType.ethminer:
return(Data.Ethminer);
case MinerBaseType.Claymore:
return(AmdGroup.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(Data.OptiminerZcashMiner);
//case MinerBaseType.excavator:
// return Data.Excavator;
case MinerBaseType.XmrStak:
return(Data.XmrStak);
case MinerBaseType.ccminer_alexis:
return(NvidiaGroups.CcminerUnstablePath(algoType, devGroupType));
case MinerBaseType.experimental:
return(Experimental.GetPath(algoType, devGroupType));
case MinerBaseType.EWBF:
return(Data.Ewbf);
case MinerBaseType.Prospector:
return(Data.Prospector);
case MinerBaseType.Xmrig:
return(Data.Xmrig);
case MinerBaseType.XmrigAMD:
return(Data.XmrigAMD);
case MinerBaseType.SRBMiner:
return(Data.SRBMiner);
case MinerBaseType.dstm:
return(Data.Dstm);
case MinerBaseType.cpuminer:
return(Data.CpuMiner);
case MinerBaseType.CastXMR:
return(Data.CastXMR);
case MinerBaseType.lyclMiner:
return(Data.lyclMiner);
case MinerBaseType.hsrneoscrypt:
return(NvidiaGroups.hsrneoscrypt_path(algoType, devGroupType));
case MinerBaseType.CryptoDredge:
return(NvidiaGroups.CryptoDredge(algoType, devGroupType));
case MinerBaseType.ZEnemy:
return(NvidiaGroups.ZEnemy(algoType, devGroupType));
case MinerBaseType.trex:
return(NvidiaGroups.trex(algoType, devGroupType));
case MinerBaseType.mkxminer:
return(Data.mkxminer);
case MinerBaseType.teamredminer:
return(Data.teamredminer);
case MinerBaseType.Phoenix:
return(Data.Phoenix);
case MinerBaseType.GMiner:
return(Data.GMiner);
case MinerBaseType.lolMiner:
return(Data.lolMiner);
case MinerBaseType.WildRig:
return(Data.WildRig);
case MinerBaseType.lolMinerBEAM:
return(Data.lolMinerBEAM);
case MinerBaseType.Bminer:
return(Data.Bminer);
case MinerBaseType.TTMiner:
return(Data.TTMiner);
case MinerBaseType.XmrigNVIDIA:
return(Data.XmrigNVIDIA);
case MinerBaseType.NBMiner:
return(Data.NBMiner);
case MinerBaseType.miniZ:
return(Data.miniZ);
}
return(Data.None);
}
public static Miner CreateMiner(DeviceType deviceType, AlgorithmType algorithmType, MinerBaseType minerBaseType)
{
switch (minerBaseType)
{
case MinerBaseType.ccminer:
return(new ccminer());
case MinerBaseType.sgminer:
return(new sgminer());
case MinerBaseType.nheqminer:
return(new nheqminer());
case MinerBaseType.ethminer:
return(CreateEthminer(deviceType));
case MinerBaseType.ClaymoreAMD:
return(CreateClaymore(algorithmType));
case MinerBaseType.OptiminerAMD:
return(new OptiminerZcashMiner());
case MinerBaseType.excavator:
return(new excavator());
case MinerBaseType.XmrStackCPU:
return(new XmrStackCPUMiner());
case MinerBaseType.ccminer_alexis:
return(new ccminer());
case MinerBaseType.experimental:
return(CreateExperimental(deviceType, algorithmType));
}
return(null);
}
