public void SetCurrentlySelected(ListViewItem lvi, ComputeDevice computeDevice)
{
// should not happen ever
if (lvi == null) return;
_computeDevice = computeDevice;
var algorithm = lvi.Tag as Algorithm;
if (algorithm != null) {
_selected = true;
_currentlySelectedAlgorithm = algorithm;
_currentlySelectedLvi = lvi;
this.Enabled = lvi.Checked;
groupBoxSelectedAlgorithmSettings.Text = String.Format(International.GetText("AlgorithmsListView_GroupBox"),
algorithm.GetName()); ;
field_LessThreads.Enabled = _computeDevice.DeviceGroupType == DeviceGroupType.CPU;
if (field_LessThreads.Enabled) {
field_LessThreads.EntryText = algorithm.LessThreads.ToString();
}
fieldBoxBenchmarkSpeed.EntryText = ParseDoubleDefault(algorithm.BenchmarkSpeed);
richTextBoxExtraLaunchParameters.Text = ParseStringDefault(algorithm.ExtraLaunchParameters);
this.Update();
} else {
// TODO this should not be null
}
}
public MiningAlgorithm(ComputeDevice dev, Algorithm algo)
{
this.AlgoRef = algo;
// init speed that will be avaraged later
this.AvaragedSpeed = algo.BenchmarkSpeed;
this.MinerPath = MinerPaths.GetOptimizedMinerPath(dev, algo);
}
protected override string GetBenchmarkCommandStringPart(ComputeDevice benchmarkDevice, Algorithm algorithm)
{
return " --opencl --opencl-platform " + GPUPlatformNumber
+ " " + algorithm.ExtraLaunchParameters
+ " --benchmark-warmup 40 --benchmark-trial 20"
+ " --opencl-devices ";
}
// create miner creates new miners based on device type and algorithm/miner path
public static Miner CreateMiner(ComputeDevice device, Algorithm algorithm)
{
var minerPath = MinerPaths.GetOptimizedMinerPath(device, algorithm);
if (minerPath != MinerPaths.NONE) {
return CreateMiner(device.DeviceType, minerPath);
}
return null;
}
public MiningDevice(ComputeDevice device)
{
Device = device;
foreach (var kvp in Device.AlgorithmSettings) {
AlgorithmType key = kvp.Key;
Algorithm algo = kvp.Value;
bool isAlgoMiningCapable = GroupSetupUtils.IsAlgoMiningCapable(algo);
bool isValidMinerPath = GroupSetupUtils.IsValidMinerPath(device, algo);
if (isAlgoMiningCapable && isValidMinerPath) {
Algorithms[key] = new MiningAlgorithm(device, algo);
}
}
}
public static Tuple<ComputeDevice, DeviceMiningStatus> getDeviceMiningStatus(ComputeDevice device)
{
DeviceMiningStatus status = DeviceMiningStatus.CanMine;
if (device == null) { // C# is null happy
status = DeviceMiningStatus.DeviceNull;
} else if (device.Enabled == false) {
status = DeviceMiningStatus.Disabled;
} else {
bool hasEnabledAlgo = false;
foreach (Algorithm algo in device.AlgorithmSettings.Values) {
hasEnabledAlgo |= IsAlgoMiningCapable(algo) && IsValidMinerPath(device, algo);
}
if (hasEnabledAlgo == false) {
status = DeviceMiningStatus.NoEnabledAlgorithms;
}
}
return new Tuple<ComputeDevice, DeviceMiningStatus>(device, status);
}
public void SetCurrentlySelected(ListViewItem lvi, ComputeDevice computeDevice)
{
// should not happen ever
if (lvi == null) return;
_computeDevice = computeDevice;
var algorithm = lvi.Tag as Algorithm;
if (algorithm != null) {
_selected = true;
_currentlySelectedAlgorithm = algorithm;
_currentlySelectedLvi = lvi;
this.Enabled = lvi.Checked;
groupBoxSelectedAlgorithmSettings.Text = String.Format(International.GetText("AlgorithmsListView_GroupBox"),
algorithm.NiceHashName); ;
// no intensity for cpu miners and ccminer_cryptonight
fieldIntensity.Enabled = !(
_computeDevice.DeviceGroupType == DeviceGroupType.CPU
|| _computeDevice.DeviceGroupType == DeviceGroupType.AMD_OpenCL
|| _currentlySelectedAlgorithm.NiceHashID == AlgorithmType.CryptoNight
|| _currentlySelectedAlgorithm.NiceHashID == AlgorithmType.DaggerHashimoto);
if (fieldIntensity.Enabled) {
if (algorithm.Intensity == 0) {
fieldIntensity.EntryText = "0";
} else {
fieldIntensity.EntryText = algorithm.Intensity.ToString("F8");
}
} else {
fieldIntensity.EntryText = "";
}
field_LessThreads.Enabled = _computeDevice.DeviceGroupType == DeviceGroupType.CPU;
if (field_LessThreads.Enabled) {
field_LessThreads.EntryText = algorithm.LessThreads.ToString();
}
fieldBoxBenchmarkSpeed.EntryText = ParseDoubleDefault(algorithm.BenchmarkSpeed);
richTextBoxExtraLaunchParameters.Text = ParseStringDefault(algorithm.ExtraLaunchParameters);
this.Update();
} else {
// TODO this should not be null
}
}
public Form_Settings()
{
InitializeComponent();
this.Icon = NiceHashMiner.Properties.Resources.logo;
//ret = 1; // default
IsChange = false;
IsChangeSaved = false;
// backup settings
ConfigManager.CreateBackup();
// initialize form
InitializeFormTranslations();
// Initialize toolTip
InitializeToolTip();
// Initialize tabs
InitializeGeneralTab();
// initialization calls
InitializeDevicesTab();
// link algorithm list with algorithm settings control
algorithmSettingsControl1.Enabled = false;
algorithmsListView1.ComunicationInterface = algorithmSettingsControl1;
//algorithmsListView1.RemoveRatioRates();
// set first device selected {
if (ComputeDeviceManager.Avaliable.AllAvaliableDevices.Count > 0) {
_selectedComputeDevice = ComputeDeviceManager.Avaliable.AllAvaliableDevices[0];
algorithmsListView1.SetAlgorithms(_selectedComputeDevice, _selectedComputeDevice.Enabled);
groupBoxAlgorithmSettings.Text = String.Format(International.GetText("FormSettings_AlgorithmsSettings"), _selectedComputeDevice.Name);
}
// At the very end set to true
_isInitFinished = true;
}
private static Dictionary <MinerBaseType, List <Algorithm> > CreateForDevice(ComputeDevice device)
{
if (device != null)
{
var algoSettings = CreateDefaultsForGroup(device.DeviceGroupType);
if (algoSettings != null)
{
if (device.DeviceType == DeviceType.AMD)
{
// sgminer stuff
if (algoSettings.ContainsKey(MinerBaseType.sgminer))
{
var sgminerAlgos = algoSettings[MinerBaseType.sgminer];
int Lyra2REv2_Index = sgminerAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.Lyra2REv2);
int NeoScrypt_Index = sgminerAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.NeoScrypt);
int CryptoNight_Index = sgminerAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.CryptoNight);
// Check for optimized version
if (Lyra2REv2_Index > -1)
{
sgminerAlgos[Lyra2REv2_Index].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 64 --gpu-threads 2";
}
if (!device.Codename.Contains("Tahiti") && NeoScrypt_Index > -1)
{
sgminerAlgos[NeoScrypt_Index].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 (CryptoNight_Index > -1 && device.Name.Contains("Hawaii"))
{
sgminerAlgos[CryptoNight_Index].ExtraLaunchParameters = "--rawintensity 640 -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))
{
var ClaymoreAlgos = algoSettings[MinerBaseType.Claymore];
int CryptoNight_Index = ClaymoreAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.CryptoNight);
if (CryptoNight_Index > -1)
{
//string regex_a_3 = "[5|6][0-9][0-9][0-9]";
List <string> a_4 = new List <string>()
{
"270",
"270x",
"280",
"280x",
"290",
"290x",
"370",
"380",
"390",
"470",
"480"
};
foreach (var namePart in a_4)
{
if (device.Name.Contains(namePart))
{
ClaymoreAlgos[CryptoNight_Index].ExtraLaunchParameters = "-a 4";
break;
}
}
}
}
// 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))
{
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 unstable_algo in algoSettings[MinerBaseType.ccminer_alexis])
{
unstable_algo.Enabled = false;
}
}
if (algoSettings.ContainsKey(MinerBaseType.experimental))
{
foreach (var unstable_algo in algoSettings[MinerBaseType.experimental])
{
unstable_algo.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
});
}
}
} // END algoSettings != null
return(algoSettings);
}
return(null);
}
void NextBenchmark()
{
if (_bechmarkCurrentIndex > -1) {
StepUpBenchmarkStepProgress();
}
++_bechmarkCurrentIndex;
if (_bechmarkCurrentIndex >= _benchmarkAlgorithmsCount) {
EndBenchmark();
return;
}
Tuple<ComputeDevice, Queue<Algorithm>> currentDeviceAlgosTuple;
Queue<Algorithm> algorithmBenchmarkQueue;
while (_benchmarkDevicesAlgorithmQueue.Count > 0) {
currentDeviceAlgosTuple = _benchmarkDevicesAlgorithmQueue[0];
_currentDevice = currentDeviceAlgosTuple.Item1;
algorithmBenchmarkQueue = currentDeviceAlgosTuple.Item2;
if(algorithmBenchmarkQueue.Count != 0) {
_currentAlgorithm = algorithmBenchmarkQueue.Dequeue();
break;
} else {
_benchmarkDevicesAlgorithmQueue.RemoveAt(0);
}
}
if (_currentDevice != null && _currentAlgorithm != null) {
_currentMiner = MinersManager.CreateMiner(_currentDevice, _currentAlgorithm);
if(_currentDevice.DeviceType == DeviceType.CPU && string.IsNullOrEmpty(_currentAlgorithm.ExtraLaunchParameters)) {
__CPUBenchmarkStatus = new CPUBenchmarkStatus();
_currentAlgorithm.LessThreads = __CPUBenchmarkStatus.LessTreads;
} else {
__CPUBenchmarkStatus = null;
}
}
if (_currentMiner != null && _currentAlgorithm != null) {
_benchmarkMiners.Add(_currentMiner);
CurrentAlgoName = AlgorithmNiceHashNames.GetName(_currentAlgorithm.NiceHashID);
_currentMiner.InitBenchmarkSetup(new MiningPair(_currentDevice, _currentAlgorithm));
var time = ConfigManager.GeneralConfig.BenchmarkTimeLimits
.GetBenchamrktime(benchmarkOptions1.PerformanceType, _currentDevice.DeviceGroupType);
//currentConfig.TimeLimit = time;
if (__CPUBenchmarkStatus != null) {
__CPUBenchmarkStatus.Time = time;
}
// dagger about 4 minutes
var showWaitTime = _currentAlgorithm.NiceHashID == AlgorithmType.DaggerHashimoto ? 4 * 60 : time;
dotCount = 0;
_benchmarkingTimer.Start();
_currentMiner.BenchmarkStart(time, this);
algorithmsListView1.SetSpeedStatus(_currentDevice, _currentAlgorithm.NiceHashID,
getDotsWaitString());
} else {
NextBenchmark();
}
}
private void devicesListView1_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
{
algorithmSettingsControl1.Deselect();
// show algorithms
_selectedComputeDevice = ComputeDeviceManager.Avaliable.GetCurrentlySelectedComputeDevice(e.ItemIndex, ShowUniqueDeviceList);
algorithmsListView1.SetAlgorithms(_selectedComputeDevice, _selectedComputeDevice.Enabled);
groupBoxAlgorithmSettings.Text = String.Format(International.GetText("FormSettings_AlgorithmsSettings"), _selectedComputeDevice.Name);
}
internal static void AddDevice(ComputeDevice dev)
{
_devices.Add(dev);
}
protected override string BenchmarkCreateCommandLine(ComputeDevice benchmarkDevice, Algorithm algorithm, int time)
{
string CommandLine = GetBenchmarkCommandStringPart(benchmarkDevice, algorithm) + GetDevicesCommandString();
Ethereum.GetCurrentBlock(CurrentBlockString);
CommandLine += " --benchmark " + Ethereum.CurrentBlockNum;
return CommandLine;
}
public void AddDevice(ComputeDevice computeDevice)
{
_groupCount[computeDevice.DeviceGroupType]++;
}
public static Dictionary<AlgorithmType, Algorithm> CreateForDevice(ComputeDevice device)
{
if (device != null) {
var algoSettings = CreateDefaultsForGroup(device.DeviceGroupType);
if (algoSettings != null) {
if (device.DeviceType == DeviceType.AMD) {
// Check for optimized version
if (device.IsOptimizedVersion) {
if (algoSettings.ContainsKey(AlgorithmType.Qubit)) {
algoSettings[AlgorithmType.Qubit].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 1024 --thread-concurrency 0 --worksize 64 --gpu-threads 1" + AmdGpuDevice.TemperatureParam;
}
if (algoSettings.ContainsKey(AlgorithmType.Quark)) {
algoSettings[AlgorithmType.Quark].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 1024 --thread-concurrency 0 --worksize 64 --gpu-threads 1" + AmdGpuDevice.TemperatureParam;
}
if (algoSettings.ContainsKey(AlgorithmType.Lyra2REv2)) {
algoSettings[AlgorithmType.Lyra2REv2].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 512 --thread-concurrency 0 --worksize 64 --gpu-threads 1" + AmdGpuDevice.TemperatureParam;
}
} else {
// this is not the same as the constructor values?? check!
if (algoSettings.ContainsKey(AlgorithmType.Qubit)) {
algoSettings[AlgorithmType.Qubit].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 128 --gpu-threads 4" + AmdGpuDevice.TemperatureParam;
}
if (algoSettings.ContainsKey(AlgorithmType.Quark)) {
algoSettings[AlgorithmType.Quark].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 256 --gpu-threads 1" + AmdGpuDevice.TemperatureParam;
}
if (algoSettings.ContainsKey(AlgorithmType.Lyra2REv2)) {
algoSettings[AlgorithmType.Lyra2REv2].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 64 --gpu-threads 2" + AmdGpuDevice.TemperatureParam;
}
}
if (!device.Codename.Contains("Tahiti")) {
if (algoSettings.ContainsKey(AlgorithmType.NeoScrypt)) {
algoSettings[AlgorithmType.NeoScrypt].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 2 --thread-concurrency 8192 --worksize 64 --gpu-threads 2" + AmdGpuDevice.TemperatureParam;
Helpers.ConsolePrint("ComputeDevice", "The GPU detected (" + device.Codename + ") is not Tahiti. Changing default gpu-threads to 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")) && Globals.IsEllesmereSgminerIgnore) {
// remove all algos except equi and dagger
List<AlgorithmType> toRemove = new List<AlgorithmType>();
foreach (var key in algoSettings.Keys) {
if (AlgorithmType.DaggerHashimoto != key && AlgorithmType.Equihash != key) {
toRemove.Add(key);
}
}
// remove keys
foreach (var key in toRemove) {
algoSettings.Remove(key);
}
} else if ((device.Codename.Contains("Ellesmere") || device.InfSection.ToLower().Contains("polaris"))) {
if (algoSettings.ContainsKey(AlgorithmType.NeoScrypt)) {
algoSettings.Remove(AlgorithmType.NeoScrypt);
}
}
}
// check if it is Etherum capable
if (algoSettings.ContainsKey(AlgorithmType.DaggerHashimoto) && device.IsEtherumCapale == false) {
algoSettings.Remove(AlgorithmType.DaggerHashimoto);
}
//// also check for Equihash as it needs 2GB GPU
//if (algoSettings.ContainsKey(AlgorithmType.Equihash) && device.IsEtherumCapale == false) {
// algoSettings.Remove(AlgorithmType.Equihash);
//}
}
return algoSettings;
}
return null;
}
protected abstract string GetBenchmarkCommandStringPart(ComputeDevice benchmarkDevice, Algorithm algorithm);
private static string ParseForMiningPairs(List<MiningPair> MiningPairs, AlgorithmType algorithmType, DeviceType deviceType, string minerPath, bool showLog = true)
{
_showLog = showLog;
// parse for nheqminer
bool deviceCheckSkip = algorithmType == AlgorithmType.Equihash || algorithmType == AlgorithmType.DaggerHashimoto;
if (algorithmType == AlgorithmType.Equihash) {
// nheqminer
if (minerPath == MinerPaths.nheqminer) {
if (deviceType == DeviceType.CPU) {
CheckAndSetCPUPairs(MiningPairs);
return Parse(MiningPairs, _nheqminer_CPU_Options);
}
if (deviceType == DeviceType.NVIDIA) {
return Parse(MiningPairs, _nheqminer_CUDA_Options);
}
if (deviceType == DeviceType.AMD) {
return Parse(MiningPairs, _nheqminer_AMD_Options);
}
} else if (minerPath == MinerPaths.eqm) {
if (deviceType == DeviceType.CPU) {
CheckAndSetCPUPairs(MiningPairs);
return Parse(MiningPairs, _eqm_CPU_Options);
}
if (deviceType == DeviceType.NVIDIA) {
return Parse(MiningPairs, _eqm_CUDA_Options);
}
} else if (minerPath == MinerPaths.ClaymoreZcashMiner) {
return Parse(MiningPairs, _ClaymoreZcash_Options);
}
} else if (algorithmType == AlgorithmType.DaggerHashimoto) { // ethminer dagger
// use if missing compute device for correct mapping
// init fakes workaround
var cdevs_mappings = new List<MiningPair>();
{
int id = -1;
var fakeAlgo = new Algorithm(AlgorithmType.DaggerHashimoto, "daggerhashimoto");
foreach (var pair in MiningPairs) {
while (++id != pair.Device.ID) {
var fakeCdev = new ComputeDevice(id);
cdevs_mappings.Add(new MiningPair(fakeCdev, fakeAlgo));
}
cdevs_mappings.Add(pair);
}
}
if (deviceType == DeviceType.NVIDIA) {
return Parse(cdevs_mappings, _cudaEthminerOptions);
} else if (deviceType == DeviceType.AMD) {
return Parse(cdevs_mappings, _oclEthminerOptions);
}
} else if (deviceCheckSkip == false) {
// parse for device
if (deviceType == DeviceType.CPU) {
CheckAndSetCPUPairs(MiningPairs);
return Parse(MiningPairs, _cpuminerOptions);
} else if (deviceType == DeviceType.NVIDIA) {
if (algorithmType != AlgorithmType.CryptoNight) {
return Parse(MiningPairs, _ccimerOptions);
} else if (algorithmType == AlgorithmType.CryptoNight) {
// check if any device is SM21 or SM3.x if yes return empty for stability reasons
foreach (var pair in MiningPairs) {
var groupType = pair.Device.DeviceGroupType;
if (groupType == DeviceGroupType.NVIDIA_2_1 || groupType == DeviceGroupType.NVIDIA_3_x) {
return "";
}
}
return Parse(MiningPairs, _ccimerCryptoNightOptions, true);
}
} else if (deviceType == DeviceType.AMD) {
// rawIntensity overrides xintensity, xintensity overrides intensity
var sgminer_intensities = new List<MinerOption>() {
new MinerOption(MinerOptionType.Intensity, "-I", "--intensity", "d", MinerOptionFlagType.MultiParam, ","), // default is "d" check if -1 works
new MinerOption(MinerOptionType.Xintensity, "-X", "--xintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none
new MinerOption(MinerOptionType.Rawintensity, "", "--rawintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none
};
var contains_intensity = new Dictionary<MinerOptionType, bool>() {
{ MinerOptionType.Intensity, false },
{ MinerOptionType.Xintensity, false },
{ MinerOptionType.Rawintensity, false },
};
// check intensity and xintensity, the latter overrides so change accordingly
foreach (var cDev in MiningPairs) {
foreach (var intensityOption in sgminer_intensities) {
if (!string.IsNullOrEmpty(intensityOption.ShortName) && cDev.CurrentExtraLaunchParameters.Contains(intensityOption.ShortName)) {
cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace(intensityOption.ShortName, intensityOption.LongName);
contains_intensity[intensityOption.Type] = true;
}
if (cDev.CurrentExtraLaunchParameters.Contains(intensityOption.LongName)) {
contains_intensity[intensityOption.Type] = true;
}
}
}
// replace
if (contains_intensity[MinerOptionType.Intensity] && contains_intensity[MinerOptionType.Xintensity]) {
LogParser("Sgminer replacing --intensity with --xintensity");
foreach (var cDev in MiningPairs) {
cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--intensity", "--xintensity");
}
}
if (contains_intensity[MinerOptionType.Xintensity] && contains_intensity[MinerOptionType.Rawintensity]) {
LogParser("Sgminer replacing --xintensity with --rawintensity");
foreach (var cDev in MiningPairs) {
cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--xintensity", "--rawintensity");
}
}
List<MinerOption> sgminerOptionsNew = new List<MinerOption>();
string temperatureControl = "";
// temp control and parse
if (ConfigManager.GeneralConfig.DisableAMDTempControl) {
LogParser("DisableAMDTempControl is TRUE, temp control parameters will be ignored");
} else {
LogParser("Sgminer parsing temperature control parameters");
temperatureControl = Parse(MiningPairs, _sgminerTemperatureOptions, true, _sgminerOptions);
}
LogParser("Sgminer parsing default parameters");
string returnStr = String.Format("{0} {1}", Parse(MiningPairs, _sgminerOptions, false, _sgminerTemperatureOptions), temperatureControl);
LogParser("Sgminer extra launch parameters merged: " + returnStr);
return returnStr;
}
}
return "";
}
// benchmark settings
public void SetSpeedStatus(ComputeDevice computeDevice, AlgorithmType algorithmType, string status)
{
var algorithm = computeDevice.AlgorithmSettings[algorithmType];
algorithm.BenchmarkStatus = status;
// gui update only if same as selected
if (_computeDevice != null && computeDevice.UUID == _computeDevice.UUID) {
foreach (ListViewItem lvi in listViewAlgorithms.Items) {
Algorithm algo = lvi.Tag as Algorithm;
if (algo != null && algo.NiceHashID == algorithmType) {
// TODO handle numbers
lvi.SubItems[SPEED].Text = algorithm.BenchmarkSpeedString();
lvi.SubItems[RATE].Text = algorithm.CurPayingRate;
lvi.SubItems[RATIO].Text = algorithm.CurPayingRatio;
_listItemCheckColorSetter.LviSetColor(lvi);
break;
}
}
}
}
public void SetAlgorithms(ComputeDevice computeDevice, bool isEnabled)
{
_computeDevice = computeDevice;
listViewAlgorithms.BeginUpdate();
listViewAlgorithms.Items.Clear();
foreach (var alg in computeDevice.AlgorithmSettings) {
ListViewItem lvi = new ListViewItem();
ListViewItem.ListViewSubItem sub = lvi.SubItems.Add(alg.Value.GetName());
//sub.Tag = alg.Value;
lvi.SubItems.Add(alg.Value.BenchmarkSpeedString());
lvi.SubItems.Add(alg.Value.CurPayingRatio);
lvi.SubItems.Add(alg.Value.CurPayingRate);
lvi.Tag = alg.Value;
lvi.Checked = !alg.Value.Skip;
listViewAlgorithms.Items.Add(lvi);
}
listViewAlgorithms.EndUpdate();
this.Enabled = isEnabled;
}
public override void InitMiningSetup(MiningSetup miningSetup)
{
base.InitMiningSetup(miningSetup);
// now find the fastest for DAG generation
double fastestSpeed = double.MinValue;
foreach (var mPair in MiningSetup.MiningPairs) {
double compareSpeed = mPair.Algorithm.AvaragedSpeed;
if (fastestSpeed < compareSpeed) {
DaggerHashimotoGenerateDevice = mPair.Device;
fastestSpeed = compareSpeed;
}
}
}
public override void SetCDevs(string[] deviceUUIDs)
{
base.SetCDevs(deviceUUIDs);
// now find the fastest for DAG generation
double fastestSpeed = double.MinValue;
foreach (var cdev in CDevs) {
double compareSpeed = cdev.DeviceBenchmarkConfig.AlgorithmSettings[AlgorithmType.DaggerHashimoto].BenchmarkSpeed;
if (fastestSpeed < compareSpeed) {
DaggerHashimotoGenerateDevice = cdev;
fastestSpeed = compareSpeed;
}
}
}
public static Dictionary <MinerBaseType, List <Algorithm> > CreateForDevice(ComputeDevice device)
{
if (device != null)
{
var algoSettings = CreateDefaultsForGroup(device.DeviceGroupType);
if (algoSettings != null)
{
if (device.DeviceType == DeviceType.AMD)
{
// sgminer stuff
if (algoSettings.ContainsKey(MinerBaseType.sgminer))
{
var sgminerAlgos = algoSettings[MinerBaseType.sgminer];
int Lyra2REv2_Index = sgminerAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.Lyra2REv2);
int NeoScrypt_Index = sgminerAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.NeoScrypt);
int CryptoNight_Index = sgminerAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.CryptoNight);
// Check for optimized version
if (Lyra2REv2_Index > -1)
{
if (device.IsOptimizedVersion)
{
sgminerAlgos[Lyra2REv2_Index].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 512 --thread-concurrency 0 --worksize 64 --gpu-threads 1";
}
else
{
sgminerAlgos[Lyra2REv2_Index].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 64 --gpu-threads 2";
}
}
if (!device.Codename.Contains("Tahiti") && NeoScrypt_Index > -1)
{
sgminerAlgos[NeoScrypt_Index].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 (CryptoNight_Index > -1 && device.Name.Contains("Hawaii"))
{
sgminerAlgos[CryptoNight_Index].ExtraLaunchParameters = "--rawintensity 640 -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")) && Globals.IsEllesmereSgminerIgnore)
{
// remove all algos except equi and dagger
var ignoreRemove = new List <AlgorithmType> {
AlgorithmType.DaggerHashimoto, AlgorithmType.Equihash, AlgorithmType.CryptoNight, AlgorithmType.Pascal, AlgorithmType.X11Gost
};
var toRemove = GetKeysForMinerAlgosGroup(algoSettings).FindAll((algoType) => ignoreRemove.IndexOf(algoType) == -1);
algoSettings = FilterMinerAlgos(algoSettings, toRemove);
// remove all sgminer?
// algoSettings = FilterMinerBaseTypes(algoSettings, [MinerBaseType.sgminer]);
}
else if ((device.Codename.Contains("Ellesmere") || device.InfSection.ToLower().Contains("polaris")))
{
algoSettings = FilterMinerAlgos(algoSettings, new List <AlgorithmType> {
AlgorithmType.NeoScrypt
});
}
// check if 3rd party is enabled and allow 3rd party only algos
if (algoSettings.ContainsKey(MinerBaseType.ClaymoreAMD))
{
var ClaymoreAlgos = algoSettings[MinerBaseType.sgminer];
int CryptoNight_Index = ClaymoreAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.CryptoNight);
if (CryptoNight_Index > -1)
{
//string regex_a_3 = "[5|6][0-9][0-9][0-9]";
List <string> a_4 = new List <string>()
{
"270",
"270x",
"280",
"280x",
"290",
"290x",
"370",
"380",
"390",
"470",
"480"
};
foreach (var namePart in a_4)
{
if (device.Name.Contains(namePart))
{
ClaymoreAlgos[CryptoNight_Index].ExtraLaunchParameters = "-a 4";
break;
}
}
}
}
// 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))
{
foreach (var algo in algoSettings[minerKey])
{
algo.Enabled = false;
}
}
}
if (algoSettings.ContainsKey(MinerBaseType.ClaymoreAMD))
{
foreach (var algo in algoSettings[MinerBaseType.ClaymoreAMD])
{
if (algo.NiceHashID == AlgorithmType.CryptoNight)
{
algo.Enabled = false;
break;
}
}
}
}
} // 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.XmrStackCPU)) {
// algoSettings[MinerBaseType.XmrStackCPU][0].LessThreads = device.Threads / 2; // use half
//}
if (algoSettings.ContainsKey(MinerBaseType.ccminer_alexis))
{
foreach (var unstable_algo in algoSettings[MinerBaseType.ccminer_alexis])
{
unstable_algo.Enabled = false;
}
}
return(algoSettings);
}
return(null);
}
protected bool Equals(ComputeDevice other)
{
return(ID == other.ID && DeviceGroupType == other.DeviceGroupType && DeviceType == other.DeviceType);
}
public void CopyBenchmarkSettingsFrom(ComputeDevice copyBenchCDev)
{
foreach (var copyAlgSpeeds in copyBenchCDev.AlgorithmSettings) {
if (this.AlgorithmSettings.ContainsKey(copyAlgSpeeds.Key)) {
var setAlgo = this.AlgorithmSettings[copyAlgSpeeds.Key];
setAlgo.BenchmarkSpeed = copyAlgSpeeds.Value.BenchmarkSpeed;
setAlgo.ExtraLaunchParameters = copyAlgSpeeds.Value.ExtraLaunchParameters;
setAlgo.LessThreads = copyAlgSpeeds.Value.LessThreads;
}
}
}
public static bool IsValidMinerPath(ComputeDevice device, Algorithm algo)
{
return MinerPaths.NONE != MinerPaths.GetOptimizedMinerPath(device, algo);
}
protected override string BenchmarkCreateCommandLine(ComputeDevice benchmarkDevice, Algorithm algorithm, int time)
{
string timeLimit = algorithm.NiceHashID == AlgorithmType.CryptoNight ? "" : " --time-limit " + time.ToString();
string CommandLine = " --algo=" + algorithm.MinerName +
" --benchmark" +
timeLimit +
" " + algorithm.ExtraLaunchParameters +
" --devices ";
CommandLine += GetDevicesCommandString();
Path = GetOptimizedMinerPath(algorithm.NiceHashID);
// cryptonight exception helper variables
_cryptonightTotalCount = BenchmarkTimeInSeconds / _cryptonightTotalDelim;
_cryptonightTotal = 0.0d;
return CommandLine;
}
public MiningPair(ComputeDevice d, Algorithm a)
{
this.Device = d;
this.Algorithm = a;
this.CurrentExtraLaunchParameters = Algorithm.ExtraLaunchParameters;
}
public static Dictionary <AlgorithmType, Algorithm> CreateForDevice(ComputeDevice device)
{
if (device != null)
{
var algoSettings = CreateDefaultsForGroup(device.DeviceGroupType);
if (algoSettings != null)
{
if (device.DeviceType == DeviceType.AMD)
{
// Check for optimized version
if (device.IsOptimizedVersion)
{
if (algoSettings.ContainsKey(AlgorithmType.Qubit))
{
algoSettings[AlgorithmType.Qubit].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 1024 --thread-concurrency 0 --worksize 64 --gpu-threads 1" + AmdGpuDevice.TemperatureParam;
}
if (algoSettings.ContainsKey(AlgorithmType.Quark))
{
algoSettings[AlgorithmType.Quark].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 1024 --thread-concurrency 0 --worksize 64 --gpu-threads 1" + AmdGpuDevice.TemperatureParam;
}
if (algoSettings.ContainsKey(AlgorithmType.Lyra2REv2))
{
algoSettings[AlgorithmType.Lyra2REv2].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 512 --thread-concurrency 0 --worksize 64 --gpu-threads 1" + AmdGpuDevice.TemperatureParam;
}
}
else
{
// this is not the same as the constructor values?? check!
if (algoSettings.ContainsKey(AlgorithmType.Qubit))
{
algoSettings[AlgorithmType.Qubit].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 128 --gpu-threads 4" + AmdGpuDevice.TemperatureParam;
}
if (algoSettings.ContainsKey(AlgorithmType.Quark))
{
algoSettings[AlgorithmType.Quark].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 256 --gpu-threads 1" + AmdGpuDevice.TemperatureParam;
}
if (algoSettings.ContainsKey(AlgorithmType.Lyra2REv2))
{
algoSettings[AlgorithmType.Lyra2REv2].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 64 --gpu-threads 2" + AmdGpuDevice.TemperatureParam;
}
}
if (!device.Codename.Contains("Tahiti"))
{
if (algoSettings.ContainsKey(AlgorithmType.NeoScrypt))
{
algoSettings[AlgorithmType.NeoScrypt].ExtraLaunchParameters = AmdGpuDevice.DefaultParam + "--nfactor 10 --xintensity 2 --thread-concurrency 8192 --worksize 64 --gpu-threads 2" + AmdGpuDevice.TemperatureParam;
Helpers.ConsolePrint("ComputeDevice", "The GPU detected (" + device.Codename + ") is not Tahiti. Changing default gpu-threads to 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")) && Globals.IsEllesmereSgminerIgnore)
{
// remove all algos except equi and dagger
List <AlgorithmType> toRemove = new List <AlgorithmType>();
foreach (var key in algoSettings.Keys)
{
if (AlgorithmType.DaggerHashimoto != key && AlgorithmType.Equihash != key)
{
toRemove.Add(key);
}
}
// remove keys
foreach (var key in toRemove)
{
algoSettings.Remove(key);
}
}
else if ((device.Codename.Contains("Ellesmere") || device.InfSection.ToLower().Contains("polaris")))
{
if (algoSettings.ContainsKey(AlgorithmType.NeoScrypt))
{
algoSettings.Remove(AlgorithmType.NeoScrypt);
}
}
}
// check if it is Etherum capable
if (algoSettings.ContainsKey(AlgorithmType.DaggerHashimoto) && device.IsEtherumCapale == false)
{
algoSettings.Remove(AlgorithmType.DaggerHashimoto);
}
//// also check for Equihash as it needs 2GB GPU
//if (algoSettings.ContainsKey(AlgorithmType.Equihash) && device.IsEtherumCapale == false) {
// algoSettings.Remove(AlgorithmType.Equihash);
//}
}
return(algoSettings);
}
return(null);
}
