private IEnumerable <Algorithm> GetSupportedAlgorithms(CUDADevice dev)
{
return(new List <Algorithm> {
new Algorithm(PluginUUID, AlgorithmType.MTP),
new Algorithm(PluginUUID, AlgorithmType.Lyra2REv3),
});
}
//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);
}
private IEnumerable <Algorithm> GetCUDASupportedAlgorithms(CUDADevice dev)
{
const ulong minZhashMem = 1879047230;
const ulong minBeamMem = 3113849695;
const ulong minGrin29Mem = 6012951136;
const ulong minGrin31Mem = 9UL << 30;
if (dev.GpuRam >= minZhashMem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.ZHash));
}
if (dev.GpuRam >= minBeamMem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.Beam));
}
if (dev.GpuRam >= minGrin29Mem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.GrinCuckaroo29));
}
if (dev.GpuRam >= minGrin31Mem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.GrinCuckatoo31));
}
}
private static bool IsCUDADeviceSupported(CUDADevice cudaDev)
{
if (cudaDev == null)
{
return(false);
}
// SM 5.2+
return(cudaDev.SM_major >= 6 || (cudaDev.SM_major == 5 && cudaDev.SM_minor > 0));
}
private IEnumerable <Algorithm> GetSupportedCUDAAlgorithms(CUDADevice dev)
{
const ulong minBeamMem = 4UL << 30;
if (dev.GpuRam >= minBeamMem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.Beam));
}
}
IReadOnlyList <Algorithm> GetSupportedAlgorithms(CUDADevice gpu)
{
var algorithms = new List <Algorithm>
{
new Algorithm(PluginUUID, AlgorithmType.ZHash),
};
var filteredAlgorithms = Filters.FilterInsufficientRamAlgorithmsList(gpu.GpuRam, algorithms);
return(filteredAlgorithms);
}
private IEnumerable <Algorithm> GetNvidiaSupportedAlgorithms(CUDADevice gpu)
{
var algorithms = new List <Algorithm>
{
new Algorithm(PluginUUID, AlgorithmType.CryptoNightR),
};
var filteredAlgorithms = Filters.FilterInsufficientRamAlgorithmsList(gpu.GpuRam, algorithms);
return(filteredAlgorithms);
}
private IEnumerable <Algorithm> GetSupportedAlgorithms(CUDADevice dev)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.Lyra2Z));
yield return(new Algorithm(PluginUUID, AlgorithmType.X16R));
yield return(new Algorithm(PluginUUID, AlgorithmType.MTP)
{
Enabled = false
});
}
private IEnumerable <Algorithm> GetSupportedAlgorithms(CUDADevice gpu)
{
var algorithms = PluginSupportedAlgorithms.GetSupportedAlgorithmsNVIDIA(PluginUUID);
if (PluginSupportedAlgorithms.UnsafeLimits(PluginUUID))
{
return(algorithms);
}
var filteredAlgorithms = Filters.FilterInsufficientRamAlgorithmsList(gpu.GpuRam, algorithms);
return(filteredAlgorithms);
}
private IEnumerable <Algorithm> GetSupportedAlgorithms(CUDADevice gpu)
{
var algorithms = new List <Algorithm>
{
new Algorithm(PluginUUID, AlgorithmType.GrinCuckatoo31),
new Algorithm(PluginUUID, AlgorithmType.CuckooCycle),
new Algorithm(PluginUUID, AlgorithmType.GrinCuckarood29),
};
var filteredAlgorithms = Filters.FilterInsufficientRamAlgorithmsList(gpu.GpuRam, algorithms);
return(filteredAlgorithms);
}
public void Number()
{
int deviceNumber = 1;
string deviceName = "Test Device (Number Test)";
bool isPreferred = false;
// Construct new CUDADevice object
CUDADevice cudaDevice = new CUDADevice(deviceNumber, deviceName, isPreferred);
// Ensure number property returns expected value
Assert.AreEqual(deviceNumber, cudaDevice.number);
}
public void IsPreferred()
{
int deviceNumber = 0;
string deviceName = "Test Device (IsPreferred Test)";
bool isPreferred = true;
// Construct new CUDADevice object
CUDADevice cudaDevice = new CUDADevice(deviceNumber, deviceName, isPreferred);
// Ensure name property returns expected value
Assert.AreEqual(isPreferred, cudaDevice.isPreferred);
}
public void FullConstructor()
{
int deviceNumber = 3;
string deviceName = "Test Device (Full Constructor Test)";
bool isPreferred = true;
// Construct new CUDADevice object
CUDADevice cudaDevice = new CUDADevice(deviceNumber, deviceName, isPreferred);
// Ensure CUDADevice object has expected data
Assert.AreEqual(deviceNumber, cudaDevice.number);
Assert.AreEqual(deviceName, cudaDevice.name);
Assert.AreEqual(isPreferred, cudaDevice.isPreferred);
}
IReadOnlyList <Algorithm> GetSupportedAlgorithms(CUDADevice gpu)
{
var algorithms = new List <Algorithm>
{
new Algorithm(PluginUUID, AlgorithmType.MTP)
{
Enabled = false
},
new Algorithm(PluginUUID, AlgorithmType.Lyra2REv3),
};
var filteredAlgorithms = Filters.FilterInsufficientRamAlgorithmsList(gpu.GpuRam, algorithms);
return(filteredAlgorithms);
}
private IEnumerable <Algorithm> GetSupportedAlgorithms(CUDADevice dev)
{
const ulong minGrin29Mem = 5UL << 30;
const ulong minGrin31Mem = 8UL << 30;
if (dev.GpuRam >= minGrin29Mem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.GrinCuckaroo29));
}
if (dev.GpuRam >= minGrin31Mem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.GrinCuckatoo31));
}
}
IReadOnlyList <Algorithm> GetCUDASupportedAlgorithms(CUDADevice gpu)
{
var algorithms = new List <Algorithm>
{
new Algorithm(PluginUUID, AlgorithmType.ZHash),
new Algorithm(PluginUUID, AlgorithmType.GrinCuckatoo31),
new Algorithm(PluginUUID, AlgorithmType.CuckooCycle)
{
Enabled = false
}, //~5% of invalid nonce shares,
new Algorithm(PluginUUID, AlgorithmType.GrinCuckarood29),
new Algorithm(PluginUUID, AlgorithmType.BeamV2),
};
var filteredAlgorithms = Filters.FilterInsufficientRamAlgorithmsList(gpu.GpuRam, algorithms);
return(filteredAlgorithms);
}
private IEnumerable <Algorithm> GetSupportedAlgorithms(CUDADevice dev)
{
const ulong minMem = 2UL << 30;
const ulong minMTPMem = 5UL << 30;
if (dev.GpuRam >= minMem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.Lyra2REv3));
yield return(new Algorithm(PluginUUID, AlgorithmType.X16R));
}
if (dev.GpuRam >= minMTPMem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.MTP)
{
Enabled = false
});
}
}
IReadOnlyList <Algorithm> GetSupportedAlgorithms(CUDADevice gpu)
{
//var algorithms = new List<Algorithm> { };
//// on btctalk ~1.63GB vram
//const ulong MinZHashMemory = 1879047230; // 1.75GB
//if (gpu.GpuRam > MinZHashMemory)
//{
// algorithms.Add(new Algorithm(PluginUUID, AlgorithmType.ZHash));
//}
//return algorithms;
var algorithms = new List <Algorithm>
{
new Algorithm(PluginUUID, AlgorithmType.ZHash),
};
var filteredAlgorithms = Filters.FilterInsufficientRamAlgorithmsList(gpu.GpuRam, algorithms);
return(filteredAlgorithms);
}
private Dictionary <BaseDevice, IReadOnlyList <Algorithm> > GetSupportedDevicesAndAlgorithms(IEnumerable <BaseDevice> devices)
{
bool isNVIDIADriverGreaterThanMinVersion() => CUDADevice.INSTALLED_NVIDIA_DRIVERS >= NVIDIA_Min_Version;
bool isSupportedGPU(BaseDevice gpu) =>
gpu switch
{
CUDADevice cuda => isNVIDIADriverGreaterThanMinVersion() && cuda.SM_major >= 6,
_ => gpu is AMDDevice,
};
if (!isNVIDIADriverGreaterThanMinVersion())
{
Logger.Error("ExcavatorPlugin", $"Insufficient NVIDIA driver version. Installed {CUDADevice.INSTALLED_NVIDIA_DRIVERS} Required {NVIDIA_Min_Version}");
}
return(devices
.Where(isSupportedGPU)
.Select(gpu => (gpu, algos: GetSupportedAlgorithmsForDevice(gpu)))
.Where(p => p.algos.Any())
.ToDictionary(p => p.gpu, p => p.algos));
}
private IEnumerable <Algorithm> GetSupportedAlgorithms(CUDADevice dev)
{
const ulong minMem = 2UL << 30;
const ulong minMTPMem = 5UL << 30;
if (dev.GpuRam >= minMem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.CryptoNightHeavy));
yield return(new Algorithm(PluginUUID, AlgorithmType.CryptoNightV8));
yield return(new Algorithm(PluginUUID, AlgorithmType.Lyra2REv3));
yield return(new Algorithm(PluginUUID, AlgorithmType.NeoScrypt));
yield return(new Algorithm(PluginUUID, AlgorithmType.X16R));
}
if (dev.GpuRam >= minMTPMem)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.MTP));
}
}
private IEnumerable <Algorithm> GetCUDASupportedAlgorithms(CUDADevice gpu)
{
var algorithms = new List <Algorithm>
{
new Algorithm(PluginUUID, AlgorithmType.ZHash)
{
Enabled = false
},
new Algorithm(PluginUUID, AlgorithmType.DaggerHashimoto)
{
Enabled = false
},
new Algorithm(PluginUUID, AlgorithmType.Beam)
{
Enabled = false
},
new Algorithm(PluginUUID, AlgorithmType.GrinCuckaroo29),
new Algorithm(PluginUUID, AlgorithmType.GrinCuckatoo31),
};
var filteredAlgorithms = Filters.FilterInsufficientRamAlgorithmsList(gpu.GpuRam, algorithms);
return(filteredAlgorithms);
}
private IEnumerable <Algorithm> GetSupportedAlgorithms(CUDADevice dev)
{
yield return(new Algorithm(PluginUUID, AlgorithmType.Skunk));
yield return(new Algorithm(PluginUUID, AlgorithmType.X16R));
}
