public static void Init()
{
ExtraLaunchParameters.InitializePackages();
MinerPaths.InitializePackages();
InitMinerReservedPortsFile();
InitMinerSystemVariablesFile();
}
public List <Algorithm> GetAlgorithmSettings()
{
// hello state
var algos = GetAlgorithmSettingsThirdParty(ConfigManager.GeneralConfig.Use3rdPartyMiners);
var retAlgos = MinerPaths.GetAndInitAlgorithmsMinerPaths(algos, this);
;
// NVIDIA
if (DeviceGroupType == DeviceGroupType.NVIDIA_5_x || DeviceGroupType == DeviceGroupType.NVIDIA_6_x)
{
retAlgos = retAlgos.FindAll(a => a.MinerBaseType != MinerBaseType.nheqminer);
}
else if (DeviceType == DeviceType.NVIDIA)
{
retAlgos = retAlgos.FindAll(a => a.MinerBaseType != MinerBaseType.eqm);
}
// sort by algo
retAlgos.Sort((a_1, a_2) => (a_1.NiceHashID - a_2.NiceHashID) != 0
? (a_1.NiceHashID - a_2.NiceHashID)
: ((a_1.MinerBaseType - a_2.MinerBaseType) != 0
? (a_1.MinerBaseType - a_2.MinerBaseType)
: (a_1.SecondaryNiceHashID - a_2.SecondaryNiceHashID)));
return(retAlgos);
}
public List <Algorithm> GetAlgorithmSettings()
{
// hello state
var algos = GetAlgorithmSettingsThirdParty(ConfigManager.GeneralConfig.Use3rdPartyMiners);
var retAlgos = MinerPaths.GetAndInitAlgorithmsMinerPaths(algos, this);;
// additional filters
// CPU
if (this.DeviceType == DeviceType.CPU && MinersManager.EquihashCPU_USE_eqm())
{
retAlgos = retAlgos.FindAll((a) => a.MinerBaseType != MinerBaseType.nheqminer);
}
else if (this.DeviceType == DeviceType.CPU)
{
retAlgos = retAlgos.FindAll((a) => a.MinerBaseType != MinerBaseType.eqm);
}
// NVIDIA
if (this.DeviceGroupType == DeviceGroupType.NVIDIA_5_x || this.DeviceGroupType == DeviceGroupType.NVIDIA_6_x)
{
retAlgos = retAlgos.FindAll((a) => a.MinerBaseType != MinerBaseType.nheqminer);
}
else if (this.DeviceType == DeviceType.NVIDIA)
{
retAlgos = retAlgos.FindAll((a) => a.MinerBaseType != MinerBaseType.eqm);
}
// sort by miner and algo
retAlgos.Sort((a_1, a_2) => (a_1.MinerBaseType - a_2.MinerBaseType) != 0 ? (a_1.MinerBaseType - a_2.MinerBaseType) : (a_1.NiceHashID - a_2.NiceHashID));
return(retAlgos);
}
public static string ParseForMiningPair(MiningPair miningPair, AlgorithmType algorithmType, DeviceType deviceType, bool showLog = true)
{
return(ParseForMiningPairs(
new List <MiningPair>()
{
miningPair
},
algorithmType, deviceType,
MinerPaths.GetOptimizedMinerPath(miningPair), showLog));
}
public List <Algorithm> GetAlgorithmSettings()
{
// hello state
var algos = GetAlgorithmSettingsThirdParty(ConfigManager.GeneralConfig.Use3rdPartyMiners);
var retAlgos = MinerPaths.GetAndInitAlgorithmsMinerPaths(algos, this);
// sort by algo
retAlgos.Sort((a_1, a_2) => (a_1.NiceHashID - a_2.NiceHashID) != 0
? (a_1.NiceHashID - a_2.NiceHashID)
: ((a_1.MinerBaseType - a_2.MinerBaseType) != 0
? (a_1.MinerBaseType - a_2.MinerBaseType)
: (a_1.SecondaryNiceHashID - a_2.SecondaryNiceHashID)));
return(retAlgos);
}
/// <summary>
/// The GetAlgorithmSettings
/// </summary>
/// <returns>The <see cref="List{Algorithm}"/></returns>
public List <Algorithm> GetAlgorithmSettings()
{
// hello state
var algos = GetAlgorithmSettingsThirdParty(ConfigManager.GeneralConfig.Use3rdPartyMiners);
var retAlgos = MinerPaths.GetAndInitAlgorithmsMinerPaths(algos, this);;
// NVIDIA
if (DeviceGroupType == DeviceGroupType.NVIDIA_5_x || DeviceGroupType == DeviceGroupType.NVIDIA_6_x)
{
}
else if (DeviceType == DeviceType.NVIDIA)
{
}
// sort by algo
retAlgos.Sort((a_1, a_2) => (a_1.CryptoMiner937ID - a_2.CryptoMiner937ID) != 0 ? (a_1.CryptoMiner937ID - a_2.CryptoMiner937ID) : (a_1.MinerBaseType - a_2.MinerBaseType));
return(retAlgos);
}
private async void FormShown(object sender, EventArgs e)
{
MinerPaths.InitializePackages();
ConfigManager.GeneralConfig.Use3rdPartyMiners = Use3rdPartyMiners.YES;
await ComputeDeviceManager.QueryDevicesAsync();
var devices = AvailableDevices.Devices;
foreach (var device in devices)
{
dgv_devices.Rows.Add(GetDeviceRowData(device));
var newRow = dgv_devices.Rows[dgv_devices.Rows.Count - 1];
newRow.Tag = device;
}
// disable/enable all by default
foreach (var device in devices)
{
foreach (var algo in device.GetAlgorithmSettings())
{
algo.Enabled = true;
}
}
}
// TODO remove somehow
/// <summary>
/// GetOptimizedMinerPath returns optimized miner path based on algorithm type and device codename.
/// Device codename is a quickfix for sgminer, other miners don't use it
/// </summary>
/// <param name="algorithmType">determines what miner path to return</param>
/// <param name="devCodename">sgminer extra</param>
/// <param name="isOptimized">sgminer extra</param>
/// <returns></returns>
protected string GetOptimizedMinerPath(AlgorithmType algorithmType, string devCodename = "", bool isOptimized = true)
{
return(MinerPaths.GetOptimizedMinerPath(algorithmType, DeviceType, DeviceGroupType, devCodename, isOptimized));
}
public static void InitMinerReservedPortsFile()
{
MinerReservedPortsFile file = new MinerReservedPortsFile();
MinerReservedPorts = new Dictionary <MinerBaseType, Dictionary <string, Dictionary <AlgorithmType, List <int> > > >();
if (file.IsFileExists())
{
var read = file.ReadFile();
if (read != null)
{
MinerReservedPorts = read;
}
}
try {
for (MinerBaseType type = (MinerBaseType.NONE + 1); type < MinerBaseType.END; ++type)
{
if (MinerReservedPorts.ContainsKey(type) == false)
{
MinerReservedPorts[type] = new Dictionary <string, Dictionary <AlgorithmType, List <int> > >();
}
}
for (DeviceGroupType devGroupType = (DeviceGroupType.NONE + 1); devGroupType < DeviceGroupType.LAST; ++devGroupType)
{
var minerAlgosForGroup = GroupAlgorithms.CreateDefaultsForGroup(devGroupType);
if (minerAlgosForGroup != null)
{
foreach (var mbaseKvp in minerAlgosForGroup)
{
MinerBaseType minerBaseType = mbaseKvp.Key;
if (MinerReservedPorts.ContainsKey(minerBaseType))
{
var algos = mbaseKvp.Value;
foreach (var algo in algos)
{
var algoType = algo.NiceHashID;
var path = MinerPaths.GetPathFor(minerBaseType, algoType, devGroupType);
var isPathValid = path != MinerPaths.Data.NONE;
if (isPathValid && MinerReservedPorts[minerBaseType].ContainsKey(path) == false)
{
MinerReservedPorts[minerBaseType][path] = new Dictionary <AlgorithmType, List <int> >();
}
if (isPathValid && MinerReservedPorts[minerBaseType][path] != null && MinerReservedPorts[minerBaseType][path].ContainsKey(algoType) == false)
{
MinerReservedPorts[minerBaseType][path][algoType] = new List <int>();
}
}
}
}
}
}
file.Commit(MinerReservedPorts);
// set all reserved
foreach (var paths in MinerReservedPorts.Values)
{
foreach (var algos in paths.Values)
{
foreach (var ports in algos.Values)
{
foreach (int port in ports)
{
AllReservedPorts.Add(port);
}
}
}
}
} catch {
}
}
