//TODO fix constructor to not include 3rd party handles + refactor inside interface device info (lookup fans speed/temps/...)
public CudaComputeDevice(CudaDevice cudaDevice, DeviceGroupType group, int gpuCount,
NvPhysicalGpuHandle nvHandle, nvmlDevice nvmlHandle)
: base((int)cudaDevice.DeviceID,
cudaDevice.GetName(),
true,
group,
DeviceType.NVIDIA,
string.Format(Translations.Tr("GPU#{0}"), gpuCount),
cudaDevice.DeviceGlobalMemory)
{
BusID = cudaDevice.pciBusID;
SMMajor = cudaDevice.SM_major;
SMMinor = cudaDevice.SM_minor;
Uuid = cudaDevice.UUID;
AlgorithmSettings = DefaultAlgorithms.GetAlgorithmsForDevice(this);
Index = ID + AvailableDevices.AvailCpus; // increment by CPU count
_nvHandle = nvHandle;
_nvmlDevice = nvmlHandle;
ShouldRunEthlargement = cudaDevice.DeviceName.Contains("1080") || cudaDevice.DeviceName.Contains("Titan Xp");
// plugin device
var bd = new BaseDevice(DeviceType.NVIDIA, cudaDevice.UUID, cudaDevice.GetName(), (int)cudaDevice.DeviceID);
PluginDevice = new CUDADevice(bd, cudaDevice.pciBusID, cudaDevice.DeviceGlobalMemory, cudaDevice.SM_major, cudaDevice.SM_minor);
}
public CpuComputeDevice(int id, string group, string name, int threads, ulong affinityMask, int cpuCount)
: base(id,
name,
true,
DeviceGroupType.CPU,
DeviceType.CPU,
string.Format(Translations.Tr("CPU#{0}"), cpuCount),
0)
{
Threads = threads;
AffinityMask = affinityMask;
var uuid = GetUuid(ID, GroupNames.GetGroupName(DeviceGroupType, ID), Name, DeviceGroupType);
Uuid = uuid;
AlgorithmSettings = DefaultAlgorithms.GetAlgorithmsForDevice(this);
Index = ID; // Don't increment for CPU
_cpuCounter = new PerformanceCounter
{
CategoryName = "Processor",
CounterName = "% Processor Time",
InstanceName = "_Total"
};
// plugin device
var bd = new BaseDevice(DeviceType.CPU, uuid, name, ID); // TODO UUID
PluginDevice = new CPUDevice(bd, threads, true, affinityMask); // TODO hyperthreading
}
public void XmrStakAlgorithmsForDevice_Tests()
{
var cpuDevice = new CpuComputeDevice(0, "grp", "intel i7-8700k", 16, 0, 0);
var algorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cpuDevice);
Assert.AreEqual(3, algorithms.Count);
foreach (var algorithm in algorithms) //check miner base type
{
Assert.AreEqual(MinerBaseType.XmrStak, algorithm.MinerBaseType);
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.CryptoNightHeavy,
AlgorithmType.CryptoNightV8,
AlgorithmType.CryptoNightR,
};
foreach (var secondaryAlgorithm in secondaryList) //check to see if all algorithms from secondary list are in algorithms
{
var algo = new Algorithm(MinerBaseType.XmrStak, secondaryAlgorithm);
Assert.IsTrue(algorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
}
//TODO fix constructor to not include 3rd party handles + refactor inside interface device info (lookup fans speed/temps/...)
public CudaComputeDevice(CudaDevice cudaDevice, DeviceGroupType group, int gpuCount,
NvPhysicalGpuHandle nvHandle, nvmlDevice nvmlHandle)
: base((int)cudaDevice.DeviceID,
cudaDevice.GetName(),
true,
group,
DeviceType.NVIDIA,
string.Format(Translations.Tr("GPU#{0}"), gpuCount),
cudaDevice.DeviceGlobalMemory)
{
BusID = cudaDevice.pciBusID;
SMMajor = cudaDevice.SM_major;
SMMinor = cudaDevice.SM_minor;
// if no nvml loaded fallback ID
if (string.IsNullOrEmpty(cudaDevice.UUID))
{
Uuid = GetUuid(ID, GroupNames.GetGroupName(DeviceGroupType, ID), Name, DeviceGroupType);
}
else
{
Uuid = cudaDevice.UUID;
}
AlgorithmSettings = DefaultAlgorithms.GetAlgorithmsForDevice(this);
Index = ID + AvailableDevices.AvailCpus; // increment by CPU count
_nvHandle = nvHandle;
_nvmlDevice = nvmlHandle;
ShouldRunEthlargement = cudaDevice.DeviceName.Contains("1080") || cudaDevice.DeviceName.Contains("Titan Xp");
}
public AmdComputeDevice(AmdGpuDevice amdDevice, int gpuCount, bool isDetectionFallback, int adl2Index)
: base(amdDevice.DeviceID,
amdDevice.DeviceName,
true,
DeviceGroupType.AMD_OpenCL,
DeviceType.AMD,
string.Format(Translations.Tr("GPU#{0}"), gpuCount),
amdDevice.DeviceGlobalMemory)
{
Uuid = isDetectionFallback
? GetUuid(ID, GroupNames.GetGroupName(DeviceGroupType, ID), Name, DeviceGroupType)
: amdDevice.Uuid;
BusID = amdDevice.BusID;
Codename = amdDevice.Codename;
InfSection = amdDevice.InfSection;
AlgorithmSettings = DefaultAlgorithms.GetAlgorithmsForDevice(this);
DriverDisableAlgos = amdDevice.DriverDisableAlgos;
Index = ID + AvailableDevices.AvailCpus + AvailableDevices.AvailNVGpus;
_adapterIndex = amdDevice.Adl1Index;
ADL.ADL2_Main_Control_Create?.Invoke(ADL.ADL_Main_Memory_Alloc, 0, ref _adlContext);
_adapterIndex2 = adl2Index;
// plugin device
var bd = new BaseDevice(DeviceType.AMD, Uuid, Name, ID);
PluginDevice = new AMDDevice(bd, amdDevice.BusID, amdDevice.DeviceGlobalMemory, Codename, InfSection);
}
public void NBMinerAlgorithmsForDevice_tests()
{
var cudaDev = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
List <Algorithm> nbminerAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.NBMiner)
{
nbminerAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.GrinCuckaroo29,
AlgorithmType.GrinCuckatoo31,
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.NBMiner, primaryAlgorithm);
Assert.IsTrue(nbminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(2, nbminerAlgorithms.Count);
foreach (var algo in nbminerAlgorithms)
{
Assert.IsTrue(algo.Enabled);
}
nbminerAlgorithms.Clear(); //low major
cudaDev = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.NBMiner)
{
nbminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, nbminerAlgorithms.Count);
nbminerAlgorithms.Clear(); //low ram
cudaDev = cudaComputeDevLowRam();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.NBMiner)
{
nbminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, nbminerAlgorithms.Count);
}
public void ClaymoreDualAlgorithmsForDevice_Tests()
{
var device = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(device);
List <Algorithm> claymoreAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.Claymore)
{
claymoreAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.NONE,
AlgorithmType.Decred,
AlgorithmType.Blake2s,
AlgorithmType.Keccak,
};
foreach (var secondaryAlgorithm in secondaryList) //check to see if all algorithms from secondary list are in algorithms (dual with dager)
{
var algo = new Algorithm(MinerBaseType.Claymore, secondaryAlgorithm);
Assert.IsTrue(claymoreAlgorithms.Any(a => algo.NiceHashID == a.SecondaryNiceHashID));
}
foreach (var algorithm in claymoreAlgorithms)
{
if (algorithm.SecondaryNiceHashID == AlgorithmType.NONE) //check that all duals are disabled by default
{
Assert.IsTrue(algorithm.Enabled);
}
else
{
Assert.IsFalse(algorithm.Enabled);
}
}
claymoreAlgorithms.Clear();
device = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(device);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.Claymore)
{
claymoreAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, claymoreAlgorithms.Count);
}
public void ethminerAlgorithmsForDevice_tests()
{
var cudaDev = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
List <Algorithm> ethminerAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.ethminer)
{
ethminerAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.DaggerHashimoto,
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.ethminer, primaryAlgorithm);
Assert.IsTrue(ethminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(1, ethminerAlgorithms.Count);
Assert.IsFalse(ethminerAlgorithms[0].Enabled);
ethminerAlgorithms.Clear(); //low major
cudaDev = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.ethminer)
{
ethminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, ethminerAlgorithms.Count);
ethminerAlgorithms.Clear(); //750 ti
cudaDev = cudaComputeDev750Ti();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.ethminer)
{
ethminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, ethminerAlgorithms.Count);
}
public void TTMinerAlgorithmsForDevice_tests()
{
var cudaDev = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
List <Algorithm> ttminerAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.TTMiner)
{
ttminerAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.MTP,
AlgorithmType.Lyra2REv3,
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.TTMiner, primaryAlgorithm);
Assert.IsTrue(ttminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(2, ttminerAlgorithms.Count);
foreach (var algo in ttminerAlgorithms)
{
Assert.IsFalse(algo.Enabled);
}
ttminerAlgorithms.Clear(); //low major
cudaDev = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.TTMiner)
{
ttminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, ttminerAlgorithms.Count);
}
public void ProspectorAlgorithmsForDevice_tests()
{
var openCLDevice = amdComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(openCLDevice);
List <Algorithm> prospectorAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.Prospector)
{
prospectorAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.Skunk,
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.Prospector, primaryAlgorithm);
Assert.IsTrue(prospectorAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(1, prospectorAlgorithms.Count);
Assert.IsFalse(prospectorAlgorithms[0].Enabled);
prospectorAlgorithms.Clear(); //cuda device
var cudaDevice = cudaComputeDev();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDevice);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.Prospector)
{
prospectorAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, prospectorAlgorithms.Count);
}
public void trexAlgorithmsForDevice_tests()
{
var cudaDev = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
List <Algorithm> trexAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.trex)
{
trexAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.Skunk,
AlgorithmType.X16R,
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.trex, primaryAlgorithm);
Assert.IsTrue(trexAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(2, trexAlgorithms.Count);
trexAlgorithms.Clear(); //low major
cudaDev = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.trex)
{
trexAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, trexAlgorithms.Count);
}
public void EWBFAlgorithmsForDevice_tests()
{
var cudaDev = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
List <Algorithm> ewbfAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.EWBF)
{
ewbfAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.ZHash,
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.EWBF, primaryAlgorithm);
Assert.IsTrue(ewbfAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(1, ewbfAlgorithms.Count);
Assert.IsTrue(ewbfAlgorithms[0].Enabled);
ewbfAlgorithms.Clear(); //low major
cudaDev = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.EWBF)
{
ewbfAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, ewbfAlgorithms.Count);
}
public void SetAlgorithmDeviceConfig(DeviceBenchmarkConfig config)
{
if (config != null && config.DeviceUUID == Uuid && config.AlgorithmSettings != null)
{
AlgorithmSettings = DefaultAlgorithms.GetAlgorithmsForDevice(this);
foreach (var conf in config.AlgorithmSettings)
{
var setAlgo = GetAlgorithm(conf.MinerBaseType, conf.NiceHashID, conf.SecondaryNiceHashID);
if (setAlgo != null)
{
setAlgo.BenchmarkSpeed = conf.BenchmarkSpeed;
setAlgo.ExtraLaunchParameters = conf.ExtraLaunchParameters;
setAlgo.Enabled = conf.Enabled;
setAlgo.LessThreads = conf.LessThreads;
setAlgo.PowerUsage = conf.PowerUsage;
if (setAlgo is DualAlgorithm dualSA)
{
dualSA.SecondaryBenchmarkSpeed = conf.SecondaryBenchmarkSpeed;
var dualConf = config.DualAlgorithmSettings?.Find(a =>
a.SecondaryNiceHashID == dualSA.SecondaryNiceHashID);
if (dualConf != null)
{
dualConf.FixSettingsBounds();
dualSA.IntensitySpeeds = dualConf.IntensitySpeeds;
dualSA.SecondaryIntensitySpeeds = dualConf.SecondaryIntensitySpeeds;
dualSA.TuningEnabled = dualConf.TuningEnabled;
dualSA.TuningStart = dualConf.TuningStart;
dualSA.TuningEnd = dualConf.TuningEnd;
dualSA.TuningInterval = dualConf.TuningInterval;
dualSA.IntensityPowers = dualConf.IntensityPowers;
dualSA.UseIntensityPowers = dualConf.UseIntensityPowers;
}
}
}
}
}
}
public void PhoenixAlgorithmsForDevice_Tests()
{
var device = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(device);
List <Algorithm> phoenixAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.Phoenix)
{
phoenixAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.DaggerHashimoto,
};
foreach (var secondaryAlgorithm in secondaryList) //check to see if all algorithms from secondary list are in algorithms (dual with dager)
{
var algo = new Algorithm(MinerBaseType.Phoenix, secondaryAlgorithm);
Assert.IsTrue(phoenixAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
phoenixAlgorithms.Clear();
device = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(device);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.Phoenix)
{
phoenixAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, phoenixAlgorithms.Count);
}
public void ccminerAlgorithmsForDevice_tests()
{
var cudaDev = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
List <Algorithm> ccminerAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.ccminer || algorithm.MinerBaseType == MinerBaseType.ccminer_alexis)
{
ccminerAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.NeoScrypt,
AlgorithmType.Blake2s,
AlgorithmType.Keccak,
AlgorithmType.Skunk,
AlgorithmType.X16R,
AlgorithmType.Lyra2REv3,
AlgorithmType.MTP,
AlgorithmType.Keccak, //ccminer_alexis
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.ccminer, primaryAlgorithm);
Assert.IsTrue(ccminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(8, ccminerAlgorithms.Count);
ccminerAlgorithms.Clear(); //major number = 3
cudaDev = cudaComputeDev3Major();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.ccminer || algorithm.MinerBaseType == MinerBaseType.ccminer_alexis)
{
ccminerAlgorithms.Add(algorithm);
}
}
secondaryList = new List <AlgorithmType>
{
AlgorithmType.Blake2s,
AlgorithmType.Keccak,
AlgorithmType.Skunk,
AlgorithmType.X16R,
AlgorithmType.MTP,
AlgorithmType.Keccak, //ccminer_alexis
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.ccminer, primaryAlgorithm);
Assert.IsTrue(ccminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(6, ccminerAlgorithms.Count);
ccminerAlgorithms.Clear(); //low major
cudaDev = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.ccminer || algorithm.MinerBaseType == MinerBaseType.ccminer_alexis)
{
ccminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, ccminerAlgorithms.Count);
}
public void sgminerAlgorithmsForDevice_tests()
{
var openCLDevice = amdComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(openCLDevice);
List <Algorithm> sgminerAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.sgminer)
{
sgminerAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.NeoScrypt,
AlgorithmType.Pascal,
AlgorithmType.Keccak,
AlgorithmType.DaggerHashimoto,
AlgorithmType.X16R,
};
foreach (var secondaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.sgminer, secondaryAlgorithm);
Assert.IsTrue(sgminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(5, sgminerAlgorithms.Count);
sgminerAlgorithms.Clear(); //amd gpu ram too low
openCLDevice = amdComputeDevLowRAM();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(openCLDevice);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.sgminer)
{
sgminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(4, sgminerAlgorithms.Count);
sgminerAlgorithms.Clear(); //bad amd drivers
openCLDevice = amdComputeDevDriverDisabled();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(openCLDevice);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.sgminer)
{
sgminerAlgorithms.Add(algorithm);
}
}
secondaryList = new List <AlgorithmType>
{
AlgorithmType.Pascal,
AlgorithmType.Keccak,
AlgorithmType.DaggerHashimoto,
AlgorithmType.X16R,
};
foreach (var secondaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.sgminer, secondaryAlgorithm);
Assert.IsTrue(sgminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(4, sgminerAlgorithms.Count);
sgminerAlgorithms.Clear(); //cuda device
var cudaDevice = cudaComputeDev();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDevice);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.sgminer)
{
sgminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, sgminerAlgorithms.Count);
}
public void BMinerAlgorithmsForDevice_tests()
{
var cudaDev = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
List <Algorithm> bminerAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.BMiner)
{
bminerAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.ZHash,
AlgorithmType.DaggerHashimoto,
AlgorithmType.Beam,
AlgorithmType.GrinCuckaroo29,
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.BMiner, primaryAlgorithm);
Assert.IsTrue(bminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(4, bminerAlgorithms.Count);
foreach (var algo in bminerAlgorithms)
{
Assert.IsFalse(algo.Enabled);
}
bminerAlgorithms.Clear(); //low ram
cudaDev = cudaComputeDevLowRam();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.BMiner)
{
bminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(1, bminerAlgorithms.Count);
Assert.AreEqual(AlgorithmType.ZHash, bminerAlgorithms[0].NiceHashID);
bminerAlgorithms.Clear(); //low major
cudaDev = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDev);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.BMiner)
{
bminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, bminerAlgorithms.Count);
bminerAlgorithms.Clear(); //amd device
var openCLDevice = amdComputeDev();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(openCLDevice);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.BMiner)
{
bminerAlgorithms.Add(algorithm);
}
}
secondaryList = new List <AlgorithmType>
{
AlgorithmType.Beam,
};
foreach (var primaryAlgorithm in secondaryList)
{
var algo = new Algorithm(MinerBaseType.BMiner, primaryAlgorithm);
Assert.IsTrue(bminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
Assert.AreEqual(1, bminerAlgorithms.Count);
Assert.AreEqual(AlgorithmType.Beam, bminerAlgorithms[0].NiceHashID);
bminerAlgorithms.Clear(); //amd low gcn
openCLDevice = amdComputeDevLowGCN();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(openCLDevice);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.BMiner)
{
bminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, bminerAlgorithms.Count);
}
public void GMinerAlgorithmsForDevice_Tests()
{
var cudaDevice = cudaComputeDev();
var allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDevice);
List <Algorithm> gminerAlgorithms = new List <Algorithm>();
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.GMiner)
{
gminerAlgorithms.Add(algorithm);
}
}
var secondaryList = new List <AlgorithmType>
{
AlgorithmType.ZHash,
AlgorithmType.Beam,
AlgorithmType.GrinCuckaroo29,
};
foreach (var secondaryAlgorithm in secondaryList) //check to see if all algorithms from secondary list are in algorithms (dual with dager)
{
var algo = new Algorithm(MinerBaseType.GMiner, secondaryAlgorithm);
Assert.IsTrue(gminerAlgorithms.Any(a => algo.NiceHashID == a.NiceHashID));
}
gminerAlgorithms.Clear();
cudaDevice = cudaComputeDevLowMajor();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(cudaDevice);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.GMiner)
{
gminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, gminerAlgorithms.Count);
gminerAlgorithms.Clear(); //amd vega device
var openCLDevice = amdComputeDev();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(openCLDevice);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.GMiner)
{
gminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(1, gminerAlgorithms.Count);
Assert.AreEqual(AlgorithmType.Beam, gminerAlgorithms[0].NiceHashID);
gminerAlgorithms.Clear(); //amd GCN too low
openCLDevice = amdComputeDevLowGCN();
allAlgorithms = DefaultAlgorithms.GetAlgorithmsForDevice(openCLDevice);
foreach (var algorithm in allAlgorithms)
{
if (algorithm.MinerBaseType == MinerBaseType.GMiner)
{
gminerAlgorithms.Add(algorithm);
}
}
Assert.AreEqual(0, gminerAlgorithms.Count);
}
