private static void TestRDTSCP()
{
if (!CPUID.ISSupported(CPUID.CPUIDFeature.InvariantTSC))
{
Console.WriteLine("Invariant TSC is not supported, RDTSC isn't reliable as a wall clock");
}
const int LOOP = 1000000;
var sw = Stopwatch.StartNew();
var start = Intrinsincs.RDTSCP();
for (var i = 0; i < LOOP; i++)
{
Intrinsincs.RDTSCP();
}
var end = Intrinsincs.RDTSCP();
sw.Stop();
Console.WriteLine("SW: {0}ms", sw.ElapsedMilliseconds);
Console.WriteLine("RDTSCP: {0}ms", (end - start) / MHZ);
Console.WriteLine("RDTSCP: {0}cycles", (end - start) / LOOP);
}
private string GetCryptoPassword()
{
string passwd = Server.GlobalInstance.TokenCryptPassword;
if (string.IsNullOrEmpty(passwd))
{
if (!string.IsNullOrEmpty(cryptoPasswd))
{
return(cryptoPasswd);
}
string cpuId = CPUID.GetCPUIdentifier();
string guid = Guid.ToString().Replace("-", "");
string str = CreateContentString();
byte[] sha256 = Encoding.ASCII.GetBytes(str);
int lenght = sha256.Length;
string random = new Random(lenght).Next().ToString();
cryptoPasswd = $"{cpuId}{guid}{random}";
return(cryptoPasswd);
}
else
{
return(passwd);
}
}
static public void Main(string[] args)
{
Intrinsincs.Init();
TestCPUID();
TestBSWAP32();
//TestBSWAP64();
TestBSF16();
TestBSF32();
TestBSF64();
TestBSR16();
TestBSR32();
TestBSR64();
if (CPUID.ISSupported(CPUID.CPUIDFeature.POPCNT))
{
TestPOPCNT16();
TestPOPCNT32();
TestPOPCNT64();
}
else
{
Console.WriteLine("POPCNT not supported, skipping");
}
TestRDTSC();
if (CPUID.ISSupported(CPUID.CPUIDFeature.RDTSCP))
{
TestRDTSCP();
}
else
{
Console.WriteLine("RDTSCP not supported, skipping");
}
}
private static CPUID[][] GroupThreadsByCore(IEnumerable <CPUID> threads)
{
SortedDictionary <uint, List <CPUID> > cores =
new SortedDictionary <uint, List <CPUID> >();
foreach (CPUID thread in threads)
{
List <CPUID> coreList;
cores.TryGetValue(thread.CoreId, out coreList);
if (coreList == null)
{
coreList = new List <CPUID>();
cores.Add(thread.CoreId, coreList);
}
coreList.Add(thread);
}
CPUID[][] coreThreads = new CPUID[cores.Count][];
int index = 0;
foreach (List <CPUID> list in cores.Values)
{
coreThreads[index] = list.ToArray();
index++;
}
return(coreThreads);
}
// CPU aff set from NHM
protected override NiceHashProcess _Start()
{
NiceHashProcess P = base._Start();
if (CPUs.Count > 0 && CPUs[0].AffinityMask != 0 && P != null)
{
CPUID.AdjustAffinity(P.Id, CPUs[0].AffinityMask);
}
return(P);
}
protected override Process BenchmarkStartProcess(string CommandLine)
{
Process BenchmarkHandle = base.BenchmarkStartProcess(CommandLine);
if (CDevs[0].AffinityMask != 0 && BenchmarkHandle != null)
{
CPUID.AdjustAffinity(BenchmarkHandle.Id, CDevs[0].AffinityMask);
}
return(BenchmarkHandle);
}
public Monitor(Hardware h)
{
hw = h;
Program.log.add("Monitor: ");
cpuid = new CPUID();
if (!cpuid.ok)
{
Application.Exit();
}
Program.log.add_line("ok");
}
protected override Process BenchmarkStartProcess(string CommandLine)
{
Process BenchmarkHandle = base.BenchmarkStartProcess(CommandLine);
var AffinityMask = MiningSetup.MiningPairs[0].Device.AffinityMask;
if (AffinityMask != 0 && BenchmarkHandle != null)
{
CPUID.AdjustAffinity(BenchmarkHandle.Id, AffinityMask);
}
return(BenchmarkHandle);
}
protected override NiceHashProcess _Start()
{
NiceHashProcess P = base._Start();
var AffinityMask = MiningSetup.MiningPairs[0].Device.AffinityMask;
if (AffinityMask != 0 && P != null)
{
CPUID.AdjustAffinity(P.Id, AffinityMask);
}
return(P);
}
/// <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);
}
// CPU aff set from NHM
/// <summary>
/// The _Start
/// </summary>
/// <returns>The <see cref="HashKingsProcess"/></returns>
protected override HashKingsProcess _Start()
{
HashKingsProcess P = base._Start();
if (CPU_Setup.IsInit && P != null)
{
var AffinityMask = CPU_Setup.MiningPairs[0].Device.AffinityMask;
if (AffinityMask != 0)
{
CPUID.AdjustAffinity(P.Id, AffinityMask);
}
}
return(P);
}
public cpuminer(int id, int threads, ulong affinity)
: base(DeviceType.CPU, "CPU" + id.ToString())
{
Threads = threads;
AffinityMask = affinity;
bool isInitialized = InitializeMinerPaths();
// if our CPU is supported add it to devices
// TODO if Miner and ComputeDevice decoupling redo this this is going to be at detecting CPUs
if (isInitialized)
{
CDevs.Add(new ComputeDevice(0, MinerDeviceName, CPUID.GetCPUName().Trim(), Threads, true));
}
}
private void QueryCPUs()
{
Helpers.ConsolePrint(TAG, "QueryCPUs START");
// get all CPUs
CPUs = CPUID.GetPhysicalProcessorCount();
// get all cores (including virtual - HT can benefit mining)
int ThreadsPerCPU = CPUID.GetVirtualCoresCount() / CPUs;
if (!Helpers.InternalCheckIsWow64())
{
MessageBox.Show(International.GetText("Form_Main_msgbox_CPUMining64bitMsg"),
International.GetText("Warning_with_Exclamation"),
MessageBoxButtons.OK, MessageBoxIcon.Warning);
CPUs = 0;
}
if (ThreadsPerCPU * CPUs > 64)
{
MessageBox.Show(International.GetText("Form_Main_msgbox_CPUMining64CoresMsg"),
International.GetText("Warning_with_Exclamation"),
MessageBoxButtons.OK, MessageBoxIcon.Warning);
CPUs = 0;
}
// TODO important move this to settings
int ThreadsPerCPUMask = ThreadsPerCPU;
Globals.ThreadsPerCPU = ThreadsPerCPU;
if (cpuminer.InitializeMinerPaths())
{
if (CPUs == 1)
{
new ComputeDevice(0, "CPU0", CPUID.GetCPUName().Trim(), ThreadsPerCPU, (ulong)0, true);
//MinersManager.Instance.AddCpuMiner(new cpuminer(0, ThreadsPerCPU, 0), 0, CPUID.GetCPUName().Trim());
}
else
{
for (int i = 0; i < CPUs; i++)
{
new ComputeDevice(0, "CPU" + i, CPUID.GetCPUName().Trim(), ThreadsPerCPU, CPUID.CreateAffinityMask(i, ThreadsPerCPUMask), true);
}
}
}
Helpers.ConsolePrint(TAG, "QueryCPUs END");
}
/// <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);
}
private static CPUID[][] GetProcessorThreads()
{
List <CPUID> threads = new List <CPUID>();
for (int i = 0; i < 64; i++)
{
try
{
threads.Add(new CPUID(i));
}
catch (ArgumentOutOfRangeException) { }
}
SortedDictionary <uint, List <CPUID> > processors =
new SortedDictionary <uint, List <CPUID> >();
foreach (CPUID thread in threads)
{
List <CPUID> list;
processors.TryGetValue(thread.ProcessorId, out list);
if (list == null)
{
list = new List <CPUID>();
processors.Add(thread.ProcessorId, list);
}
list.Add(thread);
}
CPUID[][] processorThreads = new CPUID[processors.Count][];
int index = 0;
foreach (List <CPUID> list in processors.Values)
{
processorThreads[index] = list.ToArray();
index++;
}
return(processorThreads);
}
public AMDCPU(int processorIndex, CPUID[][] cpuid, ISettings settings)
: base(processorIndex, cpuid, settings)
{
}