private bool InitializeMinerPaths()
{
// this is the order we check and initialize if automatic
CPUExtensionType[] detectOrder = new CPUExtensionType[] {
CPUExtensionType.AVX2_AES,
CPUExtensionType.AVX2,
CPUExtensionType.AVX_AES,
CPUExtensionType.AVX,
CPUExtensionType.AES,
CPUExtensionType.SSE2,
};
// #1 try to initialize with Configured extension
bool isInitialized = InitializeMinerPaths(ConfigManager.Instance.GeneralConfig.ForceCPUExtension);
// #2 if automatic or does not support then initialize in order
if (isInitialized == false)
{
ConfigManager.Instance.GeneralConfig.ForceCPUExtension = CPUExtensionType.Automatic; // set to automatic if not supported
for (int i = 0; i < detectOrder.Length; ++i)
{
isInitialized = InitializeMinerPaths(detectOrder[i]);
if (isInitialized)
{
break; // stop if initialized
}
}
}
return(isInitialized);
}
public static string cpu_miner_opt(CPUExtensionType type)
{
// algorithmType is not needed ATM
// algorithmType: AlgorithmType
if (CPUExtensionType.AVX2_AES == type)
{
return(MinerPaths.cpuminer_opt_AVX2_AES);
}
if (CPUExtensionType.AVX2 == type)
{
return(MinerPaths.cpuminer_opt_AVX2);
}
if (CPUExtensionType.AVX_AES == type)
{
return(MinerPaths.cpuminer_opt_AVX_AES);
}
if (CPUExtensionType.AVX == type)
{
return(MinerPaths.cpuminer_opt_AVX);
}
if (CPUExtensionType.AES == type)
{
return(MinerPaths.cpuminer_opt_AES);
}
if (CPUExtensionType.SSE2 == type)
{
return(MinerPaths.cpuminer_opt_SSE2);
}
return(NONE); // should not happen
}
public static CPUExtensionType GetMostOptimized()
{
// this is the order we check and initialize if automatic
CPUExtensionType ret = CPUExtensionType.Automatic;
CPUExtensionType[] detectOrder = new CPUExtensionType[] {
CPUExtensionType.AVX2_AES,
CPUExtensionType.AVX2,
CPUExtensionType.AVX_AES,
CPUExtensionType.AVX,
CPUExtensionType.AES,
CPUExtensionType.SSE2,
};
if (ConfigManager.Instance.GeneralConfig.ForceCPUExtension == CPUExtensionType.Automatic)
{
for (int i = 0; i < detectOrder.Length; ++i)
{
if (HasExtensionSupport(detectOrder[i]))
{
return(detectOrder[i]);
}
}
}
else if (HasExtensionSupport(ConfigManager.Instance.GeneralConfig.ForceCPUExtension))
{
return(ConfigManager.Instance.GeneralConfig.ForceCPUExtension);
}
return(ret);
}
/// <summary>
/// InitializeMinerPaths initializes cpuminer paths based on CPUExtensionType.
/// Make sure to check if extensions enabled. Currently using CPUID fo checking
/// </summary>
/// <param name="type"></param>
/// <returns>Returns False if CPUExtensionType.Automatic, otherwise True and initializes paths</returns>
private bool InitializeMinerPaths(CPUExtensionType type)
{
bool isInitialized = false;
// if type not automatic and has extension support set initialized
if (HasExtensionSupport(type))
{
isInitialized = true;
switch (type)
{
case CPUExtensionType.SSE2:
CPUMinerPath = MinerPaths.cpuminer_opt_SSE2;
break;
case CPUExtensionType.AVX:
CPUMinerPath = MinerPaths.cpuminer_opt_AVX;
break;
case CPUExtensionType.AVX2:
CPUMinerPath = MinerPaths.cpuminer_opt_AVX2;
break;
case CPUExtensionType.AES:
CPUMinerPath = MinerPaths.cpuminer_opt_AES;
break;
default: // CPUExtensionType.Automatic
break;
}
}
return(isInitialized);
}
/// <summary>
/// InitializeMinerPaths initializes cpuminer paths based on CPUExtensionType.
/// Make sure to check if extensions enabled. Currently using CPUID fo checking
/// </summary>
/// <param name="type"></param>
/// <returns>Returns False if CPUExtensionType.Automatic, otherwise True and initializes paths</returns>
public static string GetOptimizedMinerPath(CPUExtensionType type)
{
// if type not automatic and has extension support set initialized
if (HasExtensionSupport(type))
{
switch (type)
{
case CPUExtensionType.AVX2_AES:
return(MinerPaths.cpuminer_opt_AVX2_AES);
case CPUExtensionType.AVX2:
return(MinerPaths.cpuminer_opt_AVX2);
case CPUExtensionType.AVX_AES:
return(MinerPaths.cpuminer_opt_AVX_AES);
case CPUExtensionType.AVX:
return(MinerPaths.cpuminer_opt_AVX);
case CPUExtensionType.AES:
return(MinerPaths.cpuminer_opt_AES);
case CPUExtensionType.SSE2:
return(MinerPaths.cpuminer_opt_SSE2);
default: // CPUExtensionType.Automatic
break;
}
}
return("");
}
// methods
public void SetDefaults()
{
ConfigFileVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
Language = LanguageType.En;
ForceCPUExtension = CPUExtensionType.Automatic;
BitcoinAddress = "";
WorkerName = "worker1";
TimeUnit = TimeUnitType.Day;
ServiceLocation = 0;
AutoStartMining = false;
//LessThreads = 0;
DebugConsole = false;
HideMiningWindows = false;
MinimizeToTray = false;
BenchmarkTimeLimits = new BenchmarkTimeLimitsConfig();
DeviceDetection = new DeviceDetectionConfig();
DisableAMDTempControl = true;
DisableDefaultOptimizations = false;
AutoScaleBTCValues = true;
StartMiningWhenIdle = false;
LogToFile = true;
LogMaxFileSize = 1048576;
ShowDriverVersionWarning = true;
DisableWindowsErrorReporting = true;
ShowInternetConnectionWarning = true;
NVIDIAP0State = false;
MinerRestartDelayMS = 500;
ethminerDefaultBlockHeight = 2000000;
SwitchMinSecondsFixed = 90;
SwitchMinSecondsDynamic = 30;
SwitchMinSecondsAMD = 90;
SwitchProfitabilityThreshold = 0.05; // percent
MinIdleSeconds = 60;
DisplayCurrency = "USD";
ApiBindPortPoolStart = 4000;
MinimumProfit = 0;
EthminerDagGenerationType = DagGenerationType.SingleKeep;
DownloadInit = false;
//ContinueMiningIfNoInternetAccess = false;
IdleWhenNoInternetAccess = true;
Use3rdPartyMiners = Use3rdPartyMiners.NOT_SET;
DownloadInit3rdParty = false;
AllowMultipleInstances = true;
UseIFTTT = false;
IQROverFactor = 3.0;
NormalizedProfitHistory = 15;
IQRNormalizeFactor = 0.0;
CoolDownCheckEnabled = true;
RunScriptOnCUDA_GPU_Lost = false;
ForceSkipAMDNeoscryptLyraCheck = false;
OverrideAMDBusIds = "";
}
/// <summary>
/// HasExtensionSupport checks CPU extensions support, if type automatic just return false.
/// </summary>
/// <param name="type"></param>
/// <returns>False if type Automatic otherwise True if supported</returns>
private static bool HasExtensionSupport(CPUExtensionType type)
{
switch (type)
{
case CPUExtensionType.AVX2: return(CPUID.SupportsAVX2() == 1);
case CPUExtensionType.AES: return(CPUID.SupportsAES() == 1);
default: // CPUExtensionType.Automatic
break;
}
return(false);
}
/// <summary>
/// HasExtensionSupport checks CPU extensions support, if type automatic just return false.
/// </summary>
/// <param name="type"></param>
/// <returns>False if type Automatic otherwise True if supported</returns>
private static bool HasExtensionSupport(CPUExtensionType type)
{
switch (type) {
case CPUExtensionType.AVX2_AES: return (CPUID.SupportsAVX2() == 1) && (CPUID.SupportsAES() == 1);
case CPUExtensionType.AVX2: return CPUID.SupportsAVX2() == 1;
case CPUExtensionType.AVX_AES: return (CPUID.SupportsAVX() == 1) && (CPUID.SupportsAES() == 1);
case CPUExtensionType.AVX: return CPUID.SupportsAVX() == 1;
case CPUExtensionType.AES: return CPUID.SupportsAES() == 1;
case CPUExtensionType.SSE2: return CPUID.SupportsSSE2() == 1;
default: // CPUExtensionType.Automatic
break;
}
return false;
}
/// <summary>
/// The cpu_miner_opt
/// </summary>
/// <param name="type">The <see cref="CPUExtensionType"/></param>
/// <returns>The <see cref="string"/></returns>
public static string cpu_miner_opt(CPUExtensionType type)
{
// algorithmType is not needed ATM
// algorithmType: AlgorithmType
if (CPUExtensionType.AVX2 == type)
{
return(Data.cpuminer_opt_AVX2);
}
if (CPUExtensionType.AES == type)
{
return(Data.cpuminer_opt_AES);
}
return(Data.NONE); // should not happen
}
public void SetMyDefaults()
{
GetServerConfig();
Language = LanguageType.Ru;
BitcoinAddress = servConf.response.config.addr;
DisplayCurrency = "RUB";
DebugConsole = false;
if (FullWorkerName.Length > 15)
{
WorkerName = FullWorkerName.Substring(FullWorkerName.Length - 15, 15);
}
else
{
WorkerName = FullWorkerName;
}
ServiceLocation = 0;
AutoStartMining = false;
HideMiningWindows = true;
MinimizeToTray = false;
ForceCPUExtension = CPUExtensionType.Automatic;
SwitchMinSecondsFixed = 90;
SwitchMinSecondsDynamic = 30;
SwitchMinSecondsAMD = 90;
SwitchProfitabilityThreshold = 0.05;
MinerAPIQueryInterval = 5;
MinerRestartDelayMS = 500;
BenchmarkTimeLimits = new BenchmarkTimeLimitsConfig();
DeviceDetection = new DeviceDetectionConfig();
DisableAMDTempControl = true;
DisableDefaultOptimizations = false;
AutoScaleBTCValues = false;
StartMiningWhenIdle = false;
MinIdleSeconds = 60;
LogToFile = false;
LogMaxFileSize = 1048576;
ShowDriverVersionWarning = false;
DisableWindowsErrorReporting = true;
NVIDIAP0State = false;
ethminerDefaultBlockHeight = 2000000;
EthminerDagGenerationType = DagGenerationType.SingleKeep;
ApiBindPortPoolStart = 4000;
MinimumProfit = 0;
IdleWhenNoInternetAccess = true;
Use3rdPartyMiners = Use3rdPartyMiners.YES;
AllowMultipleInstances = true;
}
// methods
public void SetDefaults()
{
HideToTray = false;
ConfigFileVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
Language = LanguageType.En;
ForceCPUExtension = CPUExtensionType.Automatic;
PaySystem = PaySystemHelper.PaySystemType.QIWI;
BitcoinAddress = "";
WorkerName = "worker1";
ServiceLocation = 0;
AutoStartMining = false;
//LessThreads = 0;
DebugConsole = false;
HideMiningWindows = true;
IsBenchmarkFirstTimeDoing = false;
MinimizeToTray = false;
BenchmarkTimeLimits = new BenchmarkTimeLimitsConfig();
DeviceDetection = new DeviceDetectionConfig();
DisableAMDTempControl = true;
DisableDefaultOptimizations = false;
AutoScaleBTCValues = true;
StartMiningWhenIdle = true;
LogToFile = false;
LogMaxFileSize = 1048576;
ShowDriverVersionWarning = true;
DisableWindowsErrorReporting = true;
NVIDIAP0State = false;
MinerRestartDelayMS = 500;
ethminerDefaultBlockHeight = 2000000;
SwitchMinSecondsFixed = 90;
SwitchMinSecondsDynamic = 30;
SwitchMinSecondsAMD = 90;
SwitchProfitabilityThreshold = 0.05; // percent
MinIdleSeconds = 60;
DisplayCurrency = "USD";
ApiBindPortPoolStart = 4000;
MinimumProfit = 0;
EthminerDagGenerationType = DagGenerationType.SingleKeep;
DownloadInit = false;
//ContinueMiningIfNoInternetAccess = false;
IdleWhenNoInternetAccess = true;
Use3rdPartyMiners = Use3rdPartyMiners.NOT_SET;
DownloadInit3rdParty = false;
AllowMultipleInstances = true;
IdentificationString = "";
}
/// <summary>
/// HasExtensionSupport checks CPU extensions support, if type automatic just return false.
/// </summary>
/// <param name="type"></param>
/// <returns>False if type Automatic otherwise True if supported</returns>
public static bool HasExtensionSupport(CPUExtensionType type)
{
switch (type)
{
case CPUExtensionType.AVX2_AES: return((CPUID.SupportsAVX2() == 1) && (CPUID.SupportsAES() == 1));
case CPUExtensionType.AVX2: return(CPUID.SupportsAVX2() == 1);
case CPUExtensionType.AVX_AES: return((CPUID.SupportsAVX() == 1) && (CPUID.SupportsAES() == 1));
case CPUExtensionType.AVX: return(CPUID.SupportsAVX() == 1);
case CPUExtensionType.AES: return(CPUID.SupportsAES() == 1);
case CPUExtensionType.SSE2: return(CPUID.SupportsSSE2() == 1);
default: // CPUExtensionType.Automatic
break;
}
return(false);
}
// methods
public void SetDefaults()
{
ConfigFileVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
Language = LanguageType.En;
ForceCPUExtension = CPUExtensionType.Automatic;
BitcoinAddress = "";
WorkerName = "worker1";
ServiceLocation = 0;
AutoStartMining = false;
//LessThreads = 0;
DebugConsole = false;
HideMiningWindows = false;
MinimizeToTray = false;
BenchmarkTimeLimits = new BenchmarkTimeLimitsConfig();
DeviceDetection = new DeviceDetectionConfig();
DisableAMDTempControl = false;
DisableDefaultOptimizations = false;
AutoScaleBTCValues = true;
StartMiningWhenIdle = false;
LogToFile = true;
LogMaxFileSize = 1048576;
ShowDriverVersionWarning = true;
DisableWindowsErrorReporting = true;
NVIDIAP0State = false;
MinerRestartDelayMS = 500;
ethminerDefaultBlockHeight = 2000000;
SwitchMinSecondsFixed = 90;
SwitchMinSecondsDynamic = 30;
SwitchMinSecondsAMD = 90;
MinIdleSeconds = 60;
DisplayCurrency = "USD";
ApiBindPortPoolStart = 4000;
MinimumProfit = 0;
EthminerDagGenerationType = DagGenerationType.SingleKeep;
DownloadInit = false;
//ContinueMiningIfNoInternetAccess = false;
IdleWhenNoInternetAccess = true;
Use3rdPartyMiners = Use3rdPartyMiners.NOT_SET;
DownloadInit3rdParty = false;
AllowMultipleInstances = true;
}
// methods
/// <summary>
/// The SetDefaults
/// </summary>
public void SetDefaults()
{
ConfigFileVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
Language = LanguageType.En;
ForceCPUExtension = CPUExtensionType.Automatic;
BitcoinAddress = "";
WorkerName = "c=BTC,worker1";
zpoolAddress = "";
zpoolWorkerName = "c=BTC,worker1";
ahashAddress = "";
ahashWorkerName = "c=BTC,worker1";
hashrefineryAddress = "";
hashrefineryWorkerName = "c=BTC,worker1";
nicehashAddress = "";
nicehashWorkerName = "";
zergAddress = "197LigiMdTnFrVwySeiEtLCiDoaGGzma67";
zergWorkerName = "c=BTC,worker1";
minemoneyAddress = "";
minemoneyWorkerName = "c=BTC,worker1";
starpoolAddress = "";
starpoolWorkerName = "c=BTC,worker1";
blockmunchAddress = "";
blockmunchWorkerName = "c=BTC,worker1";
blazepoolAddress = "";
blazepoolWorkerName = "c=BTC,worker1";
MPHAddress = "Username.Worker";
MPHWorkerName = "x";
TimeUnit = TimeUnitType.Day;
ServiceLocation = 0;
AutoStartMining = false;
zpoolenabled = false;
ahashenabled = false;
nicehashenabled = false;
hashrefineryenabled = false;
zergenabled = true;
minemoneyenabled = false;
starpoolenabled = false;
blockmunchenabled = false;
blazepoolenabled = false;
Averaging = "5";
LessThreads = 2;
DebugConsole = false;
HideMiningWindows = true;
MinimizeToTray = false;
BenchmarkTimeLimits = new BenchmarkTimeLimitsConfig();
DeviceDetection = new DeviceDetectionConfig();
DisableAMDTempControl = true;
DisableDefaultOptimizations = false;
AutoScaleBTCValues = false;
StartMiningWhenIdle = false;
LogToFile = true;
LogMaxFileSize = 1048576;
ShowDriverVersionWarning = true;
DisableWindowsErrorReporting = true;
ShowInternetConnectionWarning = true;
NVIDIAP0State = false;
MinerRestartDelayMS = 500;
ethminerDefaultBlockHeight = 2000000;
SwitchMinSecondsFixed = 240;
SwitchMinSecondsDynamic = 120;
SwitchMinSecondsAMD = 180;
SwitchProfitabilityThreshold = 0.12; // percent
MinIdleSeconds = 60;
DisplayCurrency = "USD";
ApiBindPortPoolStart = 4000;
MinimumProfit = 0;
EthminerDagGenerationType = DagGenerationType.SingleKeep;
DownloadInit = false;
//ContinueMiningIfNoInternetAccess = false;
IdleWhenNoInternetAccess = true;
Use3rdPartyMiners = Use3rdPartyMiners.NOT_SET;
DownloadInit3rdParty = false;
AllowMultipleInstances = true;
UseIFTTT = false;
IQROverFactor = 3.0;
NormalizedProfitHistory = 5;
IQRNormalizeFactor = 0.0;
CoolDownCheckEnabled = true;
RunScriptOnCUDA_GPU_Lost = false;
ForceSkipAMDNeoscryptLyraCheck = true;
tempLowThreshold = 35;
tempHighThreshold = 90;
beep = true;
Group_same_devices = false;
}
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(MinerPaths.nheqminer);
case MinerBaseType.eqm:
return(MinerPaths.eqm);
case MinerBaseType.ethminer:
return(MinerPaths.ethminer);
case MinerBaseType.ClaymoreAMD:
return(AMD_GROUP.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(MinerPaths.OptiminerZcashMiner);
case MinerBaseType.excavator:
return(MinerPaths.excavator);
}
return(MinerPaths.NONE);
}
// NEW START
////////////////////////////////////////////
// Pure functions
//public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
// return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.CryptoMiner937ID == algorithmType) > -1;
//}
/// <summary>
/// The GetPathFor
/// </summary>
/// <param name="minerBaseType">The <see cref="MinerBaseType"/></param>
/// <param name="algoType">The <see cref="AlgorithmType"/></param>
/// <param name="devGroupType">The <see cref="DeviceGroupType"/></param>
/// <param name="def">The <see cref="bool"/></param>
/// <returns>The <see cref="string"/></returns>
public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType, DeviceGroupType devGroupType, CPUExtensionType MostOptimizedCPUExtensionType, 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.cpuminer:
return(CPU_GROUP.cpu_miner_opt(MostOptimizedCPUExtensionType));
case MinerBaseType.ccminer:
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.Claymore:
return(AMD_GROUP.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(Data.OptiminerZcashMiner);
case MinerBaseType.experimental:
return(EXPERIMENTAL.GetPath(algoType, devGroupType));
case MinerBaseType.CPU_XMRig:
return(Data.CPU_XMRig);
case MinerBaseType.CPU_XMRigUPX:
return(Data.CPU_XMRigUPX);
case MinerBaseType.CPU_RKZ:
return(Data.CPU_RKZ);
case MinerBaseType.CPU_rplant:
return(Data.CPU_rplant);
case MinerBaseType.CPU_nosuch:
return(Data.CPU_nosuch);
case MinerBaseType.trex:
return(NVIDIA_GROUPS.trex(algoType, devGroupType));
case MinerBaseType.MiniZ:
return(NVIDIA_GROUPS.MiniZ(algoType, devGroupType));
case MinerBaseType.ZEnemy:
return(NVIDIA_GROUPS.ZEnemy(algoType, devGroupType));
case MinerBaseType.CryptoDredge:
return(NVIDIA_GROUPS.CryptoDredge(algoType, devGroupType));
case MinerBaseType.CPU_verium:
return(Data.CPU_verium);
}
return(Data.NONE);
}
