internal ProgramBuildLog(ComputeDevice computeDevice, string log)
{
Contract.Requires(computeDevice != null);
ComputeDevice = computeDevice;
Log = log;
}
public virtual void Initialize() {
platform = ComputePlatform.Platforms[0];
device = platform.Devices[0];
properties = new ComputeContextPropertyList(platform);
context = new ComputeContext(new[] { device }, properties, null, IntPtr.Zero);
program = new ComputeProgram(context, KernelSrc);
}
public RenderWindow(ComputeDevice device, Action<string> setStatusBar)
: base(GraphicsMode.Default, 0, 0, GraphicsContextFlags.ForwardCompatible)
{
_setStatusBar = setStatusBar;
_interop = new GraphicsInterop(Context, device);
_lastUpdate = DateTime.UtcNow;
ThreadPool.QueueUserWorkItem(DoTimerTick);
}
/// <summary>
/// Construct an OpenCL device.
/// </summary>
///
/// <param name="platform">The platform.</param>
/// <param name="device">The device.</param>
public EncogCLDevice(EncogCLPlatform platform,
ComputeDevice device)
{
this.platform = platform;
Enabled = true;
this.device = device;
Name = this.device.Name;
Vender = this.device.Vendor;
this.cpu = (this.device.Type == ComputeDeviceTypes.Cpu);
this.queue = new EncogCLQueue(this);
}
public static IGpuHelper CreateHelper(ComputePlatform platform, ComputeDevice device, FPType fptype)
{
ComputeContextPropertyList properties = new ComputeContextPropertyList(platform);
var context = new ComputeContext(new[] { device }, properties, null, IntPtr.Zero);
if (fptype == FPType.Single)
{
return new GpuHelper<float>(context, fptype);
}
else
{
return new GpuHelper<double>(context, fptype);
}
}
public OpenCLPasswordMatcher ()
{
if (ComputePlatform.Platforms.Count == 0) {
Console.WriteLine ("Cound not find any OpenCL platforms");
Environment.Exit (1);
}
var platform = ComputePlatform.Platforms [0];
logger.Info ("Found {0} computing devices:", platform.Devices.Count);
foreach (var d in platform.Devices) {
logger.Info ("* {0}", d.Name);
}
Context = new ComputeContext (ComputeDeviceTypes.All,
new ComputeContextPropertyList (platform), null, IntPtr.Zero);
Device = Context.Devices [0];
logger.Info ("Using first device.");
// load opencl source
StreamReader streamReader = new StreamReader (MD5_OPENCL_FILE);
string clSource = streamReader.ReadToEnd ();
streamReader.Close ();
// create program with opencl source
ComputeProgram program = new ComputeProgram (Context, clSource);
// compile opencl source
try {
program.Build (null, null, null, IntPtr.Zero);
} catch (Exception e) {
logger.Error ("Build log: " + program.GetBuildLog(Device));
throw e;
}
// load chosen kernel from program
Kernel = program.CreateKernel ("crackMD5");
}
public GraphicsInterop()
{
var glHandle = ((IGraphicsContextInternal)GraphicsContext.CurrentContext).Context.Handle;
var wglHandle = wglGetCurrentDC();
_device = ComputePlatform.Platforms[0].Devices[0];
var p1 = new ComputeContextProperty(ComputeContextPropertyName.Platform, Device.Platform.Handle.Value);
var p2 = new ComputeContextProperty(ComputeContextPropertyName.CL_GL_CONTEXT_KHR, glHandle);
var p3 = new ComputeContextProperty(ComputeContextPropertyName.CL_WGL_HDC_KHR, wglHandle);
var cpl = new ComputeContextPropertyList(new[] { p1, p2, p3 });
_context = new ComputeContext(ComputeDeviceTypes.Gpu, cpl, null, IntPtr.Zero);
_queue = new ComputeCommandQueue(Context, Device, ComputeCommandQueueFlags.None);
GL.ClearColor(0f, 0f, 1f, 1f);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
GL.Ortho(0, 1.0f, 0, 1.0f, -1.0f, 1.0f);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
GL.GenBuffers(1, out _pub);
GL.Enable(EnableCap.Texture2D);
_texture = GL.GenTexture();
}
private void CreateOpenCLContext(OpenCLNNInitParameters oclInitPars)
{
ComputePlatform platform = null;
if (String.IsNullOrEmpty(oclInitPars.PlatformName))
{
platform = OpenCLContext.DefaultPlatform;
}
else
{
platform = OpenCLContext.Platforms.Where(p => string.Compare(oclInitPars.PlatformName, p.Name, true) == 0).FirstOrDefault();
}
if (platform == null) throw new OpenCLException("Platform '" + oclInitPars.PlatformName + "' not found.");
oclContext = new OpenCLContext(ComputeDeviceTypes.All, platform);
try
{
if (string.IsNullOrEmpty(oclInitPars.DeviceName))
{
oclDevice = oclContext.DefaultDevice;
//oclDevice = oclContext.Devices.Where(d => d.Type == ComputeDeviceTypes.Cpu).First();
}
else
{
oclDevice = oclContext.Devices.Where(d => string.Compare(oclInitPars.DeviceName, d.Name, true) == 0).FirstOrDefault();
}
if (oclDevice == null) throw new OpenCLException("Device '" + oclInitPars.DeviceName + "' not found.");
oclQueue = oclContext.CreateQueue(oclDevice, ComputeCommandQueueFlags.OutOfOrderExecution);
}
catch
{
oclContext.Dispose();
oclContext = null;
throw;
}
}
public static Tuple <ComputeDevice, DeviceMiningStatus> GetDeviceMiningStatus(ComputeDevice device)
{
var status = DeviceMiningStatus.CanMine;
if (device == null)
{
// C# is null happy
status = DeviceMiningStatus.DeviceNull;
}
else if (device.IsDisabled)
{
status = DeviceMiningStatus.Disabled;
}
else
{
var hasEnabledAlgo = device.AlgorithmSettings.Aggregate(false,
(current, algo) =>
current | (IsAlgoMiningCapable(algo) || algo is PluginAlgorithm));
if (hasEnabledAlgo == false)
{
status = DeviceMiningStatus.NoEnabledAlgorithms;
}
}
return(new Tuple <ComputeDevice, DeviceMiningStatus>(device, status));
}
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("");
}
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.GetAlgorithmSettings())
{
hasEnabledAlgo |= IsAlgoMiningCapable(algo) && MinerPaths.IsValidMinerPath(algo.MinerBinaryPath);
}
if (hasEnabledAlgo == false)
{
status = DeviceMiningStatus.NoEnabledAlgorithms;
}
}
return(new Tuple <ComputeDevice, DeviceMiningStatus>(device, status));
}
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 = MinerFactory.CreateMiner(_currentDevice, _currentAlgorithm);
if (_currentAlgorithm.MinerBaseType == MinerBaseType.XmrStackCPU && _currentAlgorithm.NiceHashID == AlgorithmType.CryptoNight && string.IsNullOrEmpty(_currentAlgorithm.ExtraLaunchParameters) && _currentAlgorithm.ExtraLaunchParameters.Contains("enable_ht=true") == false)
{
__CPUBenchmarkStatus = new CPUBenchmarkStatus(Globals.ThreadsPerCPU);
_currentAlgorithm.LessThreads = __CPUBenchmarkStatus.LessTreads;
}
else
{
__CPUBenchmarkStatus = null;
}
if (_currentAlgorithm.MinerBaseType == MinerBaseType.Claymore && _currentAlgorithm.NiceHashID == AlgorithmType.Equihash && _currentAlgorithm.ExtraLaunchParameters != null && !_currentAlgorithm.ExtraLaunchParameters.Contains("-asm"))
{
__ClaymoreZcashStatus = new ClaymoreZcashStatus(_currentAlgorithm.ExtraLaunchParameters);
_currentAlgorithm.ExtraLaunchParameters = __ClaymoreZcashStatus.GetTestExtraParams();
}
else
{
__ClaymoreZcashStatus = 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;
}
if (__ClaymoreZcashStatus != null)
{
__ClaymoreZcashStatus.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,
getDotsWaitString());
}
else
{
NextBenchmark();
}
}
public GraphicsInterop(IGraphicsContext context, ComputeDevice device)
{
var os = Environment.OSVersion.Platform;
ComputeContextProperty platformDependantCcp;
switch (os)
{
case PlatformID.Unix:
platformDependantCcp = GetUnixCcp();
break;
case PlatformID.MacOSX:
platformDependantCcp = GetMacCcp(context);
break;
default:
platformDependantCcp = GetWindowsCcp();
break;
}
var glHandle = ((IGraphicsContextInternal)context).Context.Handle;
var p1 = new ComputeContextProperty(ComputeContextPropertyName.Platform, device.Platform.Handle.Value);
var p2 = new ComputeContextProperty(ComputeContextPropertyName.CL_GL_CONTEXT_KHR, glHandle);
var cpl = new ComputeContextPropertyList(new[] { p1, p2, platformDependantCcp });
_context = new ComputeContext(ComputeDeviceTypes.Gpu, cpl, null, IntPtr.Zero);
_queue = new ComputeCommandQueue(Context, device, ComputeCommandQueueFlags.None);
GL.ClearColor(0f, 0f, 1f, 1f);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
GL.Ortho(0, 1.0f, 0, 1.0f, -1.0f, 1.0f);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
GL.GenBuffers(1, out _pub);
GL.Enable(EnableCap.Texture2D);
_texture = GL.GenTexture();
}
// we don't want to group CPU devices
private bool IsGroupBinaryAndAlgorithmSame(ComputeDevice a, ComputeDevice b)
{
return(IsNotCpuGroups(a, b) &&
IsAlgorithmSettingsSame(a.MostProfitableAlgorithm, b.MostProfitableAlgorithm) &&
IsSameBinPath(a, b));
}
override unsafe protected void MinerThread()
{
ComputeProgram program = null;
try {
Random r = new Random();
ComputeDevice computeDevice = OpenCLDevice.GetComputeDevice();
UInt32[] ethashOutput = new UInt32[256];
byte[] ethashHeaderhash = new byte[32];
MarkAsAlive();
MainForm.Logger("Miner thread for Device #" + DeviceIndex + " started.");
program = BuildProgram("ethash_pascal", mEthashLocalWorkSizeArray[0], "-O1", "", "");
MemoryUsage = 256;
MemoryUsage += 32;
MemoryUsage += sPascalInputSize;
MemoryUsage += sPascalOutputSize;
MemoryUsage += sPascalMidstateSize;
using (var searchKernel = program.CreateKernel("search"))
using (var DAGKernel = program.CreateKernel("GenerateDAG"))
using (var ethashOutputBuffer = new ComputeBuffer <UInt32>(Context, ComputeMemoryFlags.ReadWrite, 256))
using (var ethashHeaderBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadOnly, 32))
using (var pascalInputBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadOnly, sPascalInputSize))
using (var pascalOutputBuffer = new ComputeBuffer <UInt32>(Context, ComputeMemoryFlags.ReadWrite, sPascalOutputSize))
using (var pascalMidstateBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadOnly, sPascalMidstateSize))
fixed(UInt32 *ethashOutputPtr = ethashOutput)
fixed(byte *ethashHeaderhashPtr = ethashHeaderhash)
fixed(byte *pascalMidstatePtr = mPascalMidstate)
fixed(byte *pascalInputPtr = mPascalInput)
fixed(UInt32 * pascalOutputPtr = mPascalOutput)
while (!Stopped)
{
ComputeBuffer <byte> ethashDAGBuffer = null;
MarkAsAlive();
try {
int ethashEpoch = -1;
long ethashDAGSize = 0;
searchKernel.SetMemoryArgument(7 + 0, pascalInputBuffer);
searchKernel.SetMemoryArgument(7 + 1, pascalOutputBuffer);
searchKernel.SetMemoryArgument(7 + 4, pascalMidstateBuffer);
searchKernel.SetValueArgument <UInt32>(7 + 5, mPascalRatio);
// Wait for the first job to arrive.
int elapsedTime = 0;
while ((PrimaryStratum == null || PrimaryStratum.GetJob() == null || SecondaryStratum == null || SecondaryStratum.GetJob() == null) && elapsedTime < Parameters.TimeoutForFirstJobInMilliseconds && !Stopped)
{
Thread.Sleep(100);
elapsedTime += 100;
}
if (PrimaryStratum == null || PrimaryStratum.GetJob() == null || SecondaryStratum == null || SecondaryStratum.GetJob() == null)
{
throw new TimeoutException("Stratum server failed to send a new job.");
}
System.Diagnostics.Stopwatch consoleUpdateStopwatch = new System.Diagnostics.Stopwatch();
EthashStratum.Work ethashWork;
EthashStratum.Job ethashJob;
PascalStratum.Work pascalWork;
PascalStratum.Job pascalJob;
while (!Stopped &&
(ethashWork = PrimaryStratum.GetWork()) != null && (ethashJob = ethashWork.GetJob()) != null &&
(pascalWork = SecondaryStratum.GetWork()) != null && (pascalJob = pascalWork.Job) != null)
{
MarkAsAlive();
String ethashPoolExtranonce = PrimaryStratum.PoolExtranonce;
byte[] ethashExtranonceByteArray = Utilities.StringToByteArray(ethashPoolExtranonce);
byte ethashLocalExtranonce = (byte)ethashWork.LocalExtranonce;
UInt64 ethashStartNonce = (UInt64)ethashLocalExtranonce << (8 * (7 - ethashExtranonceByteArray.Length));
for (int i = 0; i < ethashExtranonceByteArray.Length; ++i)
{
ethashStartNonce |= (UInt64)ethashExtranonceByteArray[i] << (8 * (7 - i));
}
ethashStartNonce += (ulong)r.Next(0, int.MaxValue) & (0xfffffffffffffffful >> (ethashExtranonceByteArray.Length * 8 + 8));
String ethashJobID = ethashJob.ID;
String ethashSeedhash = ethashJob.Seedhash;
double ethashDifficulty = PrimaryStratum.Difficulty;
Buffer.BlockCopy(Utilities.StringToByteArray(ethashWork.GetJob().Headerhash), 0, ethashHeaderhash, 0, 32);
Queue.Write <byte>(ethashHeaderBuffer, true, 0, 32, (IntPtr)ethashHeaderhashPtr, null);
Array.Copy(pascalWork.Blob, mPascalInput, sPascalInputSize);
CalculatePascalMidState();
Queue.Write <byte>(pascalMidstateBuffer, true, 0, sPascalMidstateSize, (IntPtr)pascalMidstatePtr, null);
UInt32 pascalStartNonce = (UInt32)(r.Next(0, int.MaxValue));
UInt64 PascalTarget = (UInt64)((double)0xffff0000UL / SecondaryStratum.Difficulty);
searchKernel.SetValueArgument <UInt64>(7 + 3, PascalTarget);
Queue.Write <byte>(pascalInputBuffer, true, 0, sPascalInputSize, (IntPtr)pascalInputPtr, null);
if (ethashEpoch != ethashWork.GetJob().Epoch)
{
if (ethashDAGBuffer != null)
{
MemoryUsage -= ethashDAGBuffer.Size;
ethashDAGBuffer.Dispose();
ethashDAGBuffer = null;
}
ethashEpoch = ethashWork.GetJob().Epoch;
DAGCache cache = new DAGCache(ethashEpoch, ethashWork.GetJob().Seedhash);
ethashDAGSize = Utilities.GetDAGSize(ethashEpoch);
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
mEthashGlobalWorkSizeArray[0] = ethashDAGSize / 64;
mEthashGlobalWorkSizeArray[0] /= 8;
if (mEthashGlobalWorkSizeArray[0] % mEthashLocalWorkSizeArray[0] > 0)
{
mEthashGlobalWorkSizeArray[0] += mEthashLocalWorkSizeArray[0] - mEthashGlobalWorkSizeArray[0] % mEthashLocalWorkSizeArray[0];
}
ComputeBuffer <byte> DAGCacheBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadOnly, cache.GetData().Length);
MemoryUsage += DAGCacheBuffer.Size;
fixed(byte *p = cache.GetData())
Queue.Write <byte>(DAGCacheBuffer, true, 0, cache.GetData().Length, (IntPtr)p, null);
ethashDAGBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, mEthashGlobalWorkSizeArray[0] * 8 * 64 /* ethashDAGSize */); // With this, we can remove a conditional statement in the DAG kernel.
MemoryUsage += ethashDAGBuffer.Size;
DAGKernel.SetValueArgument <UInt32>(0, 0);
DAGKernel.SetMemoryArgument(1, DAGCacheBuffer);
DAGKernel.SetMemoryArgument(2, ethashDAGBuffer);
DAGKernel.SetValueArgument <UInt32>(3, (UInt32)cache.GetData().Length / 64);
DAGKernel.SetValueArgument <UInt32>(4, 0xffffffffu);
for (long start = 0; start < ethashDAGSize / 64; start += mEthashGlobalWorkSizeArray[0])
{
mEthashGlobalWorkOffsetArray[0] = start;
Queue.Execute(DAGKernel, mEthashGlobalWorkOffsetArray, mEthashGlobalWorkSizeArray, mEthashLocalWorkSizeArray, null);
Queue.Finish();
if (Stopped || PrimaryStratum.GetJob() == null || !PrimaryStratum.GetJob().ID.Equals(ethashJobID))
{
break;
}
}
DAGCacheBuffer.Dispose();
MemoryUsage -= DAGCacheBuffer.Size;
if (Stopped || PrimaryStratum.GetJob() == null || !PrimaryStratum.GetJob().ID.Equals(ethashJobID))
{
break;
}
sw.Stop();
MainForm.Logger("Generated DAG for Epoch #" + ethashEpoch + " (" + (long)sw.Elapsed.TotalMilliseconds + "ms).");
}
consoleUpdateStopwatch.Start();
while (!Stopped && PrimaryStratum.GetJob().ID.Equals(ethashJobID) && PrimaryStratum.PoolExtranonce.Equals(ethashPoolExtranonce) && SecondaryStratum.GetJob().Equals(pascalJob))
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
MarkAsAlive();
// Get a new local extranonce if necessary.
if ((ethashStartNonce & (0xfffffffffffffffful >> (ethashExtranonceByteArray.Length * 8 + 8)) + (ulong)mEthashGlobalWorkSizeArray[0] * 3 / 4) >= ((ulong)0x1 << (64 - (ethashExtranonceByteArray.Length * 8 + 8))))
{
break;
}
if (0xffffffffu - pascalStartNonce < (UInt32)mEthashGlobalWorkSizeArray[0] * mPascalRatio)
{
break;
}
UInt64 target = (UInt64)((double)0xffff0000U / ethashDifficulty);
searchKernel.SetMemoryArgument(0, ethashOutputBuffer); // g_output
searchKernel.SetMemoryArgument(1, ethashHeaderBuffer); // g_header
searchKernel.SetMemoryArgument(2, ethashDAGBuffer); // _g_dag
searchKernel.SetValueArgument <UInt32>(3, (UInt32)(ethashDAGSize / 128)); // DAG_SIZE
searchKernel.SetValueArgument <UInt64>(4, ethashStartNonce); // start_nonce
searchKernel.SetValueArgument <UInt64>(5, target); // target
searchKernel.SetValueArgument <UInt32>(6, 0xffffffffu); // isolate
searchKernel.SetValueArgument <UInt32>(7 + 2, pascalStartNonce);
ethashOutput[255] = 0; // ethashOutput[255] is used as an atomic counter.
Queue.Write <UInt32>(ethashOutputBuffer, true, 0, 256, (IntPtr)ethashOutputPtr, null);
mEthashGlobalWorkOffsetArray[0] = 0;
mPascalOutput[255] = 0; // mPascalOutput[255] is used as an atomic counter.
Queue.Write <UInt32>(pascalOutputBuffer, true, 0, sPascalOutputSize, (IntPtr)pascalOutputPtr, null);
Queue.Execute(searchKernel, mEthashGlobalWorkOffsetArray, mEthashGlobalWorkSizeArray, mEthashLocalWorkSizeArray, null);
Queue.Read <UInt32>(ethashOutputBuffer, true, 0, 256, (IntPtr)ethashOutputPtr, null);
if (PrimaryStratum.GetJob() != null && PrimaryStratum.GetJob().ID.Equals(ethashJobID))
{
for (int i = 0; i < ethashOutput[255]; ++i)
{
PrimaryStratum.Submit(Device, ethashWork.GetJob(), ethashStartNonce + (UInt64)ethashOutput[i]);
}
}
ethashStartNonce += (UInt64)mEthashGlobalWorkSizeArray[0] * 3 / 4;
Queue.Read <UInt32>(pascalOutputBuffer, true, 0, sPascalOutputSize, (IntPtr)pascalOutputPtr, null);
if (SecondaryStratum.GetJob() != null && SecondaryStratum.GetJob().Equals(pascalJob))
{
for (int i = 0; i < mPascalOutput[255]; ++i)
{
SecondaryStratum.Submit(Device, pascalWork, mPascalOutput[i]);
}
}
pascalStartNonce += (UInt32)mEthashGlobalWorkSizeArray[0] * mPascalRatio;
sw.Stop();
Speed = ((double)mEthashGlobalWorkSizeArray[0]) / sw.Elapsed.TotalSeconds * 0.75;
Device.TotalHashesPrimaryAlgorithm += (double)mEthashGlobalWorkSizeArray[0] * 0.75;
SpeedSecondaryAlgorithm = ((double)mEthashGlobalWorkSizeArray[0]) / sw.Elapsed.TotalSeconds * mPascalRatio;
Device.TotalHashesSecondaryAlgorithm += (double)mEthashGlobalWorkSizeArray[0] * mPascalRatio;
if (consoleUpdateStopwatch.ElapsedMilliseconds >= 10 * 1000)
{
MainForm.Logger("Device #" + DeviceIndex + ": " + String.Format("{0:N2} Mh/s (Ethash), ", Speed / (1000000)) + String.Format("{0:N2} Mh/s (Pascal)", SpeedSecondaryAlgorithm / (1000000)));
consoleUpdateStopwatch.Restart();
}
}
}
} catch (Exception ex) {
MainForm.Logger("Exception in miner thread: " + ex.Message + ex.StackTrace);
Speed = 0;
if (UnrecoverableException.IsUnrecoverableException(ex))
{
this.UnrecoverableException = new UnrecoverableException(ex, Device);
Stop();
}
else
{
MainForm.Logger("Restarting miner thread...");
System.Threading.Thread.Sleep(Parameters.WaitTimeForRestartingMinerThreadInMilliseconds);
}
} finally {
if (ethashDAGBuffer != null)
{
MemoryUsage -= ethashDAGBuffer.Size;
ethashDAGBuffer.Dispose();
ethashDAGBuffer = null;
}
}
}
} catch (UnrecoverableException ex) {
this.UnrecoverableException = ex;
} catch (Exception ex) {
this.UnrecoverableException = new UnrecoverableException(ex, Device);
} finally {
MarkAsDone();
MemoryUsage = 0;
if (program != null)
{
program.Dispose();
}
program = 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);
}
}
var currentConfig = _currentDevice.DeviceBenchmarkConfig;
if (_currentDevice.DeviceGroupType == DeviceGroupType.CPU)
{
_currentMiner = MinersManager.GetCpuMiner(_currentDevice.Group);
}
else
{
_currentMiner = MinersManager.CreateMiner(currentConfig.DeviceGroupType, _currentAlgorithm.NiceHashID);
}
if (_currentMiner != null && _currentAlgorithm != null)
{
_benchmarkMiners.Add(_currentMiner);
CurrentAlgoName = AlgorithmNiceHashNames.GetName(_currentAlgorithm.NiceHashID);
// this has no effect for CPU miners
_currentMiner.SetCDevs(new string[] { _currentDevice.UUID });
var time = ConfigManager.Instance.GeneralConfig.BenchmarkTimeLimits
.GetBenchamrktime(benchmarkOptions1.PerformanceType, _currentDevice.DeviceGroupType);
//currentConfig.TimeLimit = time;
// dagger about 4 minutes
var showWaitTime = _currentAlgorithm.NiceHashID == AlgorithmType.DaggerHashimoto ? 4 * 60 : time;
dotCount = 0;
_benchmarkingTimer.Start();
_currentMiner.BenchmarkStart(_currentDevice, _currentAlgorithm, time, this);
algorithmsListView1.SetSpeedStatus(_currentDevice, _currentAlgorithm.NiceHashID,
getDotsWaitString());
}
else
{
NextBenchmark();
}
}
internal static Task StopBenchmarForDevice(ComputeDevice device)
{
return(BenchmarkingComputeDeviceHandler.StopBenchmarkingDevice(device));
}
/// <summary>
/// Attempts to initialize OpenCL for the selected GPU.
/// </summary>
internal void InitializeOpenCL()
{
// only initialize once
if (clKernel != null)
return;
// unused memory so Cloo doesn't break with a null ptr
var userDataPtr = Marshal.AllocCoTaskMem(512);
try
{
clDevice = Gpu.CLDevice;
// context we'll be working underneath
clContext = new ComputeContext(
new[] { clDevice },
new ComputeContextPropertyList(clDevice.Platform),
(p1, p2, p3, p4) => { },
userDataPtr);
// queue to control device
clQueue = new ComputeCommandQueue(clContext, clDevice, ComputeCommandQueueFlags.None);
// buffers to store kernel output
clBuffer0 = new ComputeBuffer<uint>(clContext, ComputeMemoryFlags.ReadOnly, 16);
clBuffer1 = new ComputeBuffer<uint>(clContext, ComputeMemoryFlags.ReadOnly, 16);
// obtain the program
clProgram = new ComputeProgram(clContext, Gpu.GetSource());
var b = new StringBuilder();
if (Gpu.WorkSize > 0)
b.Append(" -D WORKSIZE=").Append(Gpu.WorkSize);
if (Gpu.HasBitAlign)
b.Append(" -D BITALIGN");
if (Gpu.HasBfiInt)
b.Append(" -D BFIINT");
try
{
// build kernel for device
clProgram.Build(new[] { clDevice }, b.ToString(), (p1, p2) => { }, userDataPtr);
}
catch (ComputeException)
{
throw new Exception(clProgram.GetBuildLog(clDevice));
}
clKernel = clProgram.CreateKernel("search");
}
finally
{
Marshal.FreeCoTaskMem(userDataPtr);
}
}
private void DeviceCombox_SelectedIndexChanged(object sender, EventArgs e)
{
var comboBox = sender as ComboBox;
if (comboBox == null)
return;
var selectedDevice = (ComputeDevice) comboBox.SelectedItem;
Console.WriteLine("Selected device : " + selectedDevice.Name);
_selectedComputePlatform = (ComputePlatform)PlatformCombox.SelectedItem;
_selectedComputeDevice = (ComputeDevice)DeviceCombox.SelectedItem;
}
private static Dictionary <MinerBaseType, List <Algorithm> > CreateForDevice(ComputeDevice device)
{
if (device == null)
{
return(null);
}
var algoSettings = CreateDefaultsForGroup(device.DeviceGroupType);
if (algoSettings == null)
{
return(null);
}
if (device.DeviceType == DeviceType.AMD)
{
// sgminer stuff
if (algoSettings.ContainsKey(MinerBaseType.sgminer))
{
var sgminerAlgos = algoSettings[MinerBaseType.sgminer];
var lyra2REv2Index = sgminerAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.Lyra2REv2);
//var neoScryptIndex = sgminerAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.NeoScrypt);
var cryptoNightIndex = sgminerAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.CryptoNight);
// Check for optimized version
if (lyra2REv2Index > -1)
{
sgminerAlgos[lyra2REv2Index].ExtraLaunchParameters =
AmdGpuDevice.DefaultParam +
"--nfactor 10 --xintensity 64 --thread-concurrency 0 --worksize 64 --gpu-threads 2";
}
/*
* if (!device.Codename.Contains("Tahiti") && neoScryptIndex > -1)
* {
* sgminerAlgos[neoScryptIndex].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 (cryptoNightIndex > -1)
{
if (device.Codename.Contains("Hawaii"))
{
sgminerAlgos[cryptoNightIndex].ExtraLaunchParameters = "--rawintensity 640 -w 8 -g 2";
}
else if (device.Name.Contains("Vega"))
{
sgminerAlgos[cryptoNightIndex].ExtraLaunchParameters =
AmdGpuDevice.DefaultParam + " --rawintensity 1850 -w 8 -g 2";
}
}
}
if (algoSettings.ContainsKey(MinerBaseType.XmrigAMD))
{
var XmrigAMDAlgos = algoSettings[MinerBaseType.XmrigAMD];
int xmrigCryptoNightV7_Index = XmrigAMDAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.CryptoNightV7);
int xmrigCryptoNightV8_Index = XmrigAMDAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.CryptoNightV8);
//--opencl-launch=
XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=640";
XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=640";
if (xmrigCryptoNightV7_Index > -1)
{
if (device.Codename.Contains("gfx804")) //rx550
{
XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=512";
XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=512";
}
if (device.Codename.Contains("Pitcairn")) //r7-370
{
XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1024";
XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1024";
}
if (device.Codename.Contains("Baffin")) //rx460/560
{
XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1024";
XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1024";
}
if (device.Codename.Contains("Ellesmere")) //rx570/580
{
XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1024";
XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1024";
}
if (device.Codename.Contains("Hawaii"))
{
XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1024";
XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1024";
}
else if (device.Name.Contains("Vega"))
{
XmrigAMDAlgos[xmrigCryptoNightV7_Index].ExtraLaunchParameters = " --opencl-launch=1920";
XmrigAMDAlgos[xmrigCryptoNightV8_Index].ExtraLaunchParameters = " --opencl-launch=1920";
}
}
}
if (algoSettings.ContainsKey(MinerBaseType.mkxminer))
{
var mkxminerAlgos = algoSettings[MinerBaseType.mkxminer];
int mkxminer_Index = mkxminerAlgos.FindIndex((el) => el.NiceHashID == AlgorithmType.Lyra2z);
//--opencl-launch=
//mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " ";
if (mkxminer_Index > -1)
{
if (device.Codename.Contains("gfx804")) //rx550
{
mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 21";
}
if (device.Codename.Contains("Pitcairn")) //r7-370
{
mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 21";
}
if (device.Codename.Contains("Baffin")) //rx460/560
{
mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 22";
}
if (device.Codename.Contains("Ellesmere")) //rx570/580
{
mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 23";
}
if (device.Codename.Contains("Hawaii"))
{
mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 22";;
}
else if (device.Name.Contains("Vega"))
{
mkxminerAlgos[mkxminer_Index].ExtraLaunchParameters = " -I 24";
}
}
}
// 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_old) &&
algoSettings.ContainsKey(MinerBaseType.Claymore))
{
var claymoreOldAlgos = algoSettings[MinerBaseType.Claymore_old];
var cryptoNightOldIndex =
claymoreOldAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.CryptoNight);
var claymoreNewAlgos = algoSettings[MinerBaseType.Claymore];
var cryptoNightNewIndex =
claymoreNewAlgos.FindIndex(el => el.NiceHashID == AlgorithmType.CryptoNight);
if (cryptoNightOldIndex > -1 && cryptoNightNewIndex > -1)
{
//string regex_a_3 = "[5|6][0-9][0-9][0-9]";
var a4 = new List <string>
{
"270",
"270x",
"280",
"280x",
"290",
"290x",
"370",
"380",
"390",
"470",
"480"
};
foreach (var namePart in a4)
{
if (!device.Name.Contains(namePart))
{
continue;
}
claymoreOldAlgos[cryptoNightOldIndex].ExtraLaunchParameters = "-a 4";
break;
}
var old = new List <string>
{
"Verde",
"Oland",
"Bonaire"
};
foreach (var codeName in old)
{
var isOld = device.Codename.Contains(codeName);
claymoreOldAlgos[cryptoNightOldIndex].Enabled = isOld;
claymoreNewAlgos[cryptoNightNewIndex].Enabled = !isOld;
}
}
}
// drivers algos issue
if (device.DriverDisableAlgos)
{
algoSettings = FilterMinerAlgos(algoSettings, new List <AlgorithmType>
{
// AlgorithmType.NeoScrypt,
// AlgorithmType.Lyra2REv2
});
}
// disable another gpu
//Helpers.ConsolePrint("GPU device", "Name: "+device.Name);
if (algoSettings.ContainsKey(MinerBaseType.CastXMR) && (!device.Name.Contains("470") &&
!device.Name.Contains("480") && !device.Name.Contains("570") && !device.Name.Contains("580") &&
!device.Name.Contains("Vega"))
)
{
algoSettings = FilterMinerBaseTypes(algoSettings, new List <MinerBaseType>
{
MinerBaseType.CastXMR
});
}
// disable by default
{
var minerBases = new List <MinerBaseType>
{
MinerBaseType.ethminer,
MinerBaseType.OptiminerAMD
};
foreach (var minerKey in minerBases)
{
if (!algoSettings.ContainsKey(minerKey))
{
continue;
}
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 unstableAlgo in algoSettings[MinerBaseType.ccminer_alexis])
{
unstableAlgo.Enabled = false;
}
}
if (algoSettings.ContainsKey(MinerBaseType.experimental))
{
foreach (var unstableAlgo in algoSettings[MinerBaseType.experimental])
{
unstableAlgo.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
});
}
}
return(algoSettings);
}
public void AttachToDevice(object device)
{
this.computeDevice = device as ComputeDevice ?? throw new ArgumentException($"{nameof(ComputeDevice)} required", nameof(device));
InitComputeKernel();
}
public static object[] GetDeviceRowData(ComputeDevice d)
{
object[] rowData = { d.Enabled, d.GetFullName() };
return(rowData);
}
public OpenClData([NotNull] ComputeContext context, [NotNull] ComputeDevice device, bool failed)
{
Context = context;
Device = device;
InitFailed = failed;
}
internal static void SetCurrentStatus(ComputeDevice dev, AlgorithmContainer algo, string status)
{
//var args = new AlgoStatusEventArgs(dev, algo, status);
// TODO append to NotificationInfo instance
//OnAlgoStatusUpdate?.Invoke(null, args);
}
/// <summary>
/// Gets a read-only collection of available <see cref="ComputeDevice"/>s on the <see cref="ComputePlatform"/>.
/// </summary>
/// <returns> A read-only collection of the available <see cref="ComputeDevice"/>s on the <see cref="ComputePlatform"/>. </returns>
/// <remarks> This method resets the <c>ComputePlatform.Devices</c>. This is useful if one or more of them become unavailable (<c>ComputeDevice.Available</c> is <c>false</c>) after a <see cref="ComputeContext"/> and <see cref="ComputeCommandQueue"/>s that use the <see cref="ComputeDevice"/> have been created and commands have been queued to them. Further calls will trigger an <c>OutOfResourcesComputeException</c> until this method is executed. You will also need to recreate any <see cref="ComputeResource"/> that was created on the no longer available <see cref="ComputeDevice"/>. </remarks>
public ReadOnlyCollection<ComputeDevice> QueryDevices()
{
int handlesLength = 0;
ComputeErrorCode error = CLInterface.CL12.GetDeviceIDs(Handle, ComputeDeviceTypes.All, 0, null, out handlesLength);
ComputeException.ThrowOnError(error);
CLDeviceHandle[] handles = new CLDeviceHandle[handlesLength];
error = CLInterface.CL12.GetDeviceIDs(Handle, ComputeDeviceTypes.All, handlesLength, handles, out handlesLength);
ComputeException.ThrowOnError(error);
ComputeDevice[] devices = new ComputeDevice[handlesLength];
for (int i = 0; i < handlesLength; i++)
devices[i] = new ComputeDevice(this, handles[i]);
this.devices = new ReadOnlyCollection<ComputeDevice>(devices);
return this.devices;
}
/// <summary>
/// Creates a cloo compute device from base type
/// </summary>
/// <param name="baseDevice">base compute device</param>
/// <returns>cloo compute device</returns>
/// <exception cref="ArgumentNullException">baseDevice</exception>
/// <exception cref="ArgumentException">Compute device not found, maybe you need to call ClooDevice.UpdateAllDevices()</exception>
public static ClooDevice FromBaseDevice(ComputeDevice baseDevice)
{
if (baseDevice == null) throw new ArgumentNullException("baseDevice");
ClooDevice clooDevice;
if (_devicesByHandle.TryGetValue(baseDevice.Handle, out clooDevice)) return clooDevice;
throw new ArgumentException("Compute device not found, maybe you need to call ClooDevice.UpdateAllDevices()", "baseDevice");
}
private bool IsNotCpuGroups(ComputeDevice a, ComputeDevice b)
{
return(a.DeviceGroupType != DeviceGroupType.CPU && b.DeviceGroupType != DeviceGroupType.CPU);
}
private static bool IsNvidiaDevice(ComputeDevice a)
{
return(a.DeviceType == DeviceType.NVIDIA);
}
public void Start(IMinerContext context)
{
string code;
var kernelRes = Assembly.GetExecutingAssembly().GetManifestResourceStream("BitMaker.Miner.Cloo.Miner.cl");
using (var rdr = new StreamReader(kernelRes))
code = clProgramSource;
var platform = ComputePlatform.Platforms[0];
var properties = new ComputeContextPropertyList(platform);
device = platform.Devices[0];
ccontext = new ComputeContext(platform.Devices, properties, null, IntPtr.Zero);
program = new ComputeProgram(ccontext, clProgramSource);
program.Build(null, null, notify, IntPtr.Zero);
}
// group only first CPU split
private static bool IsEquihashAnd_CPU_nheqminer(ComputeDevice a)
{
return(a.DeviceType != DeviceType.CPU || // if not cpu then ignore case always good
a.ID == 0); // if CPU ID must be 0
}
public Form_Settings()
{
InitializeComponent();
ApplicationStateManager.SubscribeStateDisplayer(this);
Icon = Properties.Resources.logo;
this.TopMost = ConfigManager.GeneralConfig.GUIWindowsAlwaysOnTop;
// backup settings
ConfigManager.CreateBackup();
// 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 (AvailableDevices.Devices.Count > 0)
{
_selectedComputeDevice = AvailableDevices.Devices[0];
algorithmsListView1.SetAlgorithms(_selectedComputeDevice, _selectedComputeDevice.Enabled);
groupBoxAlgorithmSettings.Text = string.Format(Tr("Algorithm settings for {0} :"),
_selectedComputeDevice.Name);
}
checkBox_DebugConsole.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.DebugConsole));
checkBox_AutoStartMining.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.AutoStartMining));
checkBox_HideMiningWindows.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.HideMiningWindows));
checkBox_MinimizeToTray.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.MinimizeToTray));
checkBox_AutoScaleBTCValues.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.AutoScaleBTCValues), false, DataSourceUpdateMode.OnPropertyChanged);
checkBox_ShowDriverVersionWarning.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.ShowDriverVersionWarning));
checkBox_DisableWindowsErrorReporting.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.DisableWindowsErrorReporting));
checkBox_ShowInternetConnectionWarning.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.ShowInternetConnectionWarning));
checkBox_NVIDIAP0State.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.NVIDIAP0State));
checkBox_LogToFile.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.LogToFile));
checkBox_AllowMultipleInstances.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.AllowMultipleInstances));
checkBox_WindowAlwaysOnTop.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.GUIWindowsAlwaysOnTop));
checkBox_MinimizeMiningWindows.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.MinimizeMiningWindows));
checkBox_RunScriptOnCUDA_GPU_Lost.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.RunScriptOnCUDA_GPU_Lost));
checkBox_RunAtStartup.DataBindings.Add("Checked", ConfigManager.RunAtStartup, nameof(ConfigManager.RunAtStartup.Enabled));
checkBox_ShowGPUPCIeBusIDs.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.ShowGPUPCIeBusIDs));
checkBox_MineRegardlessOfProfit.DataBindings.Add("Checked", MiningProfitSettings.Instance, nameof(MiningProfitSettings.MineRegardlessOfProfit), false, DataSourceUpdateMode.OnPropertyChanged);
textBox_MinProfit.DataBindings.Add("Enabled", MiningProfitSettings.Instance, nameof(MiningProfitSettings.IsMinimumProfitProfitEnabled), false, DataSourceUpdateMode.OnPropertyChanged);
checkBox_DisableDeviceStatusMonitoring.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.DisableDeviceStatusMonitoring));
#if TESTNET || TESTNETDEV || PRODUCTION_NEW
checkBox_DisableDevicePowerModeSettings.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.DisableDevicePowerModeSettings));
#else
checkBox_DisableDevicePowerModeSettings.Enabled = false;
checkBox_DisableDevicePowerModeSettings.Checked = true;
checkBox_DisableDevicePowerModeSettings.Visible = false;
pictureBox_DisableDevicePowerModeSettings.Visible = false;
groupBoxDeviceMonitoring.Height = (int)(groupBoxDeviceMonitoring.Height * 0.7);
#endif
// idle mining
checkBox_IdleWhenNoInternetAccess.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.IdleWhenNoInternetAccess));
checkBox_StartMiningWhenIdle.DataBindings.Add("Checked", ConfigManager.IdleMiningSettings, nameof(ConfigManager.IdleMiningSettings.StartMiningWhenIdle), false, DataSourceUpdateMode.OnPropertyChanged);
comboBox_IdleType.DataBindings.Add("Enabled", ConfigManager.IdleMiningSettings, nameof(ConfigManager.IdleMiningSettings.StartMiningWhenIdle), false, DataSourceUpdateMode.OnPropertyChanged);
comboBox_IdleType.DataBindings.Add("SelectedIndex", ConfigManager.IdleMiningSettings, nameof(ConfigManager.IdleMiningSettings.IdleCheckTypeIndex), false, DataSourceUpdateMode.OnPropertyChanged);
textBox_MinIdleSeconds.DataBindings.Add("Enabled", ConfigManager.IdleMiningSettings, nameof(ConfigManager.IdleMiningSettings.IsIdleCheckTypeInputTimeout), false, DataSourceUpdateMode.OnPropertyChanged);
// comboBox indexes
comboBox_Language.DataBindings.Add("SelectedIndex", ConfigManager.TranslationsSettings, nameof(ConfigManager.TranslationsSettings.LanguageIndex), false, DataSourceUpdateMode.OnPropertyChanged);
// IFTTT textbox
checkBox_UseIFTTT.DataBindings.Add("Checked", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.UseIFTTT), false, DataSourceUpdateMode.OnPropertyChanged);
textBox_IFTTTKey.DataBindings.Add("Enabled", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.UseIFTTT), false, DataSourceUpdateMode.OnPropertyChanged);
textBox_IFTTTKey.DataBindings.Add("Text", ConfigManager.GeneralConfig, nameof(ConfigManager.GeneralConfig.IFTTTKey), false, DataSourceUpdateMode.OnPropertyChanged);
checkBox_RunEthlargement.DataBindings.Add("Checked", ThirdPartyMinerSettings.Instance, nameof(ThirdPartyMinerSettings.Instance.UseEthlargement), false, DataSourceUpdateMode.OnPropertyChanged);
checkBox_RunEthlargement.DataBindings.Add("Enabled", ThirdPartyMinerSettings.Instance, nameof(ThirdPartyMinerSettings.Instance.CanUseEthlargement), false, DataSourceUpdateMode.OnPropertyChanged);
checkBox_Use3rdPartyMiners.CheckedChanged += CheckBox_Use3rdPartyMiners_CheckedChanged;
//checkBox_RunEthlargement.CheckedChanged += CheckBox_RunEthlargement_CheckedChanged;
// At the very end set to true
_isInitFinished = true;
FormHelpers.TranslateFormControls(this);
}
// eqm
private static bool IsEquihashAnd_eqm(ComputeDevice a, ComputeDevice b)
{
return(a.MostProfitableAlgorithm.NiceHashID == AlgorithmType.Equihash &&
a.MostProfitableAlgorithm.NiceHashID == b.MostProfitableAlgorithm.NiceHashID);
}
public static void CreateFailedBenchmarksInfo(ComputeDevice device)
{
var notification = new Notification(NotificationsType.Info, NotificationsGroup.FailedBenchmarks, Tr("Failed benchmarks"), Tr("Some benchmarks for {0} failed to execute. Check benchmark tab for more info.", device.Name));
NotificationsManager.Instance.AddNotificationToList(notification);
}
private static bool IsEquihashDevice_eqm(ComputeDevice a)
{
return(IsEquihashCPU_eqm(a) || IsEquihashNVIDIA_eqm(a));
}
override unsafe protected void MinerThread()
{
Messenger.Default.Register <StopMinerThreadsMessage>(this, msg => {
ThreadPool.QueueUserWorkItem(delegate
{
Messenger.Default.Unregister(this);
this.Dispose();
});
});
Random r = new Random();
ComputeDevice computeDevice = OpenCLDevice.ComputeDevice;
ComputeProgram program;
var GCN1 = computeDevice.Name.Equals("Capeverde") || computeDevice.Name.Equals("Hainan") || computeDevice.Name.Equals("Oland") || computeDevice.Name.Equals("Pitcairn") || computeDevice.Name.Equals("Tahiti");
string programName = String.Empty;
if (_coin == null)
{
Messenger.Default.Send <MinerOutputMessage>(new MinerOutputMessage()
{
OutputText = $"Invalid coin! Device #{DeviceIndex} {_stratum.ActiveClient.Pool.CoinType}"
});
Dispose();
return;
}
int?algo = Utils.MigrateAlgorithm(_stratum.ActiveClient.Pool.Algorithm);
if (algo == null)
{
algo = _coin.Algorithm;
}
switch (algo)
{
case (int)Consts.SupportedAlgos.CryptoNight:
case (int)Consts.SupportedAlgos.CryptoNight_V7:
programName = "cryptonight";
scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 21) * globalWorkSizeA[0]);
break;
case (int)Consts.SupportedAlgos.CryptoNight_V8:
programName = "cryptonightV8";
scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 21) * globalWorkSizeA[0]);
break;
case (int)Consts.SupportedAlgos.CryptoNight_Heavy:
programName = "cryptonightHeavy";
scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 22) * globalWorkSizeA[0]);
break;
case (int)Consts.SupportedAlgos.CryptoNight_Lite:
case (int)Consts.SupportedAlgos.CryptoNight_Lite_V7:
programName = "cryptonightLite";
scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 20) * globalWorkSizeA[0]);
break;
case (int)Consts.SupportedAlgos.CryptoNight_BitTube_V2:
programName = "cryptonightIpbc";
scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 20) * globalWorkSizeA[0]);
break;
case (int)Consts.SupportedAlgos.CryptoNight_Fast:
programName = "cryptonightFast";
scratchpadsBuffer = new ComputeBuffer <byte>(Context, ComputeMemoryFlags.ReadWrite, ((long)1 << 21) * globalWorkSizeA[0]);
break;
}
string algorithmBuildParameters = $@" -I Miners\Kernel -DWORKSIZE={localWorkSizeA[0]} -DSTRIDED_INDEX=1 -DMEMORY_CHUNK_SIZE=2";
program = BuildProgram(programName, localWorkSizeA[0], $"{algorithmBuildParameters} -O5" + (GCN1 ? " -legacy" : ""), algorithmBuildParameters, algorithmBuildParameters);
if (program == null)
{
Messenger.Default.Send <MinerOutputMessage>(new MinerOutputMessage()
{
OutputText = $"Faild to build/load opencl kernel! Device #{DeviceIndex} {AlgorithmName}"
});
Dispose();
return;
}
searchKernel0 = program.CreateKernel("search");
searchKernel1 = program.CreateKernel("search1");
searchKernel2 = program.CreateKernel("search2");
searchKernel3 = program.CreateKernel("search3");
fixed(long *globalWorkOffsetAPtr = globalWorkOffsetA)
fixed(long *globalWorkOffsetBPtr = globalWorkOffsetB)
fixed(long *globalWorkSizeAPtr = globalWorkSizeA)
fixed(long *globalWorkSizeBPtr = globalWorkSizeB)
fixed(long *localWorkSizeAPtr = localWorkSizeA)
fixed(long *localWorkSizeBPtr = localWorkSizeB)
fixed(Int32 * terminatePtr = terminate)
fixed(byte *inputPtr = input)
fixed(UInt32 * outputPtr = output)
{
while (!Stopped)
{
try
{
searchKernel0.SetMemoryArgument(0, inputBuffer);
searchKernel0.SetMemoryArgument(1, scratchpadsBuffer);
searchKernel0.SetMemoryArgument(2, statesBuffer);
searchKernel1.SetMemoryArgument(0, scratchpadsBuffer);
searchKernel1.SetMemoryArgument(1, statesBuffer);
searchKernel1.SetMemoryArgument(2, terminateBuffer);
searchKernel1.SetMemoryArgument(4, inputBuffer);
searchKernel2.SetMemoryArgument(0, scratchpadsBuffer);
searchKernel2.SetMemoryArgument(1, statesBuffer);
searchKernel3.SetMemoryArgument(0, statesBuffer);
searchKernel3.SetMemoryArgument(1, outputBuffer);
// Wait for the first job to arrive.
int elapsedTime = 0;
while ((_stratum == null || _stratum.GetJob() == null) && elapsedTime < 60000 && !Stopped)
{
Thread.Sleep(100);
elapsedTime += 100;
}
if (_stratum == null || _stratum.GetJob() == null)
{
throw new TimeoutException("Stratum server failed to send a new job.");
}
Stopwatch consoleUpdateStopwatch = new Stopwatch();
CryptoNightStratum.Work work;
var events = new CryptoComputeEventList();
while (!Stopped && (work = _stratum.GetWork()) != null)
{
var job = work.GetJob();
Array.Copy(job.Blob, input, job.Blob.Length);
input[job.Blob.Length] = 0x01;
Array.Clear(input, job.Blob.Length + 1, input.Length - (job.Blob.Length + 1));
byte localExtranonce = (byte)work.LocalExtranonce;
UInt32 startNonce;
if (NiceHashMode)
{
startNonce = ((UInt32)input[42] << (8 * 3)) | ((UInt32)localExtranonce << (8 * 2)) | (UInt32)(r.Next(0, int.MaxValue) & (0x0000ffffu));
}
else
{
startNonce = ((UInt32)localExtranonce << (8 * 3)) | (UInt32)(r.Next(0, int.MaxValue) & (0x00ffffffu));
}
if ((_stratum.ActiveClient.Pool.Algorithm != null && (Utils.MigrateAlgorithm(_stratum.ActiveClient.Pool.Algorithm) == (int)Consts.SupportedAlgos.CryptoNight || Utils.MigrateAlgorithm(_stratum.ActiveClient.Pool.Algorithm) == (int)Consts.SupportedAlgos.CryptoNight_Lite)) ||
(_stratum.ActiveClient.Pool.Algorithm == null && (_coin.Algorithm == (int)Consts.SupportedAlgos.CryptoNight ||
_coin.Algorithm == (int)Consts.SupportedAlgos.CryptoNight_Lite)))
{
searchKernel0.SetValueArgument <uint>(3, 0);
searchKernel1.SetValueArgument <uint>(3, 0);
searchKernel2.SetValueArgument <uint>(2, 0);
}
else if ((_stratum.ActiveClient.Pool.Algorithm != null && Consts.V7Coins.Any(x => (int)x == Utils.MigrateAlgorithm(_stratum.ActiveClient.Pool.Algorithm))) ||
(_stratum.ActiveClient.Pool.Algorithm == null && Consts.V7Coins.Any(x => (int)x == _coin.Algorithm)))
{
searchKernel0.SetValueArgument <uint>(3, 7);
searchKernel1.SetValueArgument <uint>(3, 7);
searchKernel2.SetValueArgument <uint>(2, 7);
}
else
{
searchKernel0.SetValueArgument <uint>(3, (uint)job.Variant);
searchKernel1.SetValueArgument <uint>(3, (uint)job.Variant);
searchKernel2.SetValueArgument <uint>(2, (uint)job.Variant);
}
searchKernel3.SetValueArgument <UInt32>(2, job.Target);
Queue.Write <byte>(inputBuffer, false, 0, input.Length, (IntPtr)inputPtr, events);
Queue.Flush();
events.Wait();
events.Clear();
consoleUpdateStopwatch.Start();
while (!Stopped && _stratum.GetJob().Equals(job))
{
globalWorkOffsetA[0] = globalWorkOffsetB[0] = startNonce;
if (NiceHashMode)
{
if ((startNonce & 0xffff) + (UInt32)globalWorkSizeA[0] >= 0x10000)
{
break;
}
}
else
{
if ((startNonce & 0xffffff) + (UInt32)globalWorkSizeA[0] >= 0x1000000)
{
break;
}
}
Stopwatch sw = new Stopwatch();
sw.Start();
output[255] = 0; // output[255] is used as an atomic counter.
Queue.Write <UInt32>(outputBuffer, false, 0, outputSize, (IntPtr)outputPtr, events);
Queue.Flush();
events.Wait();
events.Clear();
terminate[0] = 0;
Queue.Write <Int32>(terminateBuffer, false, 0, 1, (IntPtr)terminatePtr, events);
Queue.Flush();
events.Wait();
events.Clear();
Queue.Execute(searchKernel0, globalWorkOffsetA, globalWorkSizeA, localWorkSizeA, events);
Queue.Flush();
events.Wait();
events.Clear();
if (Stopped)
{
break;
}
Queue.Execute(searchKernel1, globalWorkOffsetB, globalWorkSizeB, localWorkSizeB, events);
Queue.Flush();
events.Wait();
events.Clear();
if (Stopped)
{
break;
}
Queue.Execute(searchKernel2, globalWorkOffsetA, globalWorkSizeA, localWorkSizeA, events);
Queue.Flush();
events.Wait();
events.Clear();
if (Stopped)
{
break;
}
Queue.Execute(searchKernel3, globalWorkOffsetB, globalWorkSizeB, localWorkSizeB, events);
Queue.Flush();
events.Wait();
events.Clear();
if (Stopped)
{
break;
}
Queue.Read <UInt32>(outputBuffer, true, 0, outputSize, (IntPtr)outputPtr, events);
Queue.Flush();
events.Wait();
events.Clear();
if (output[0xFF] > 0xFF)
{
output[0xFF] = 0xFF;
}
if (_stratum.GetJob().Equals(job))
{
for (int i = 0; i < output[0xFF]; ++i)
{
String result = "";
for (int j = 0; j < 8; ++j)
{
UInt32 word = output[256 + i * 8 + j];
result += String.Format("{0:x2}{1:x2}{2:x2}{3:x2}", ((word >> 0) & 0xff), ((word >> 8) & 0xff), ((word >> 16) & 0xff), ((word >> 24) & 0xff));
}
_stratum.Submit(Device, job, output[i], result);
}
}
startNonce += (UInt32)globalWorkSizeA[0];
sw.Stop();
Speed = globalWorkSizeA[0] / sw.Elapsed.TotalSeconds;
if (consoleUpdateStopwatch.ElapsedMilliseconds >= 10 * 1000)
{
//Messenger.Default.Send<MinerOutputMessage>(new MinerOutputMessage() { OutputText = $"Device #{DeviceIndex} (CryptoNight): {Speed:N2} h/s" });
consoleUpdateStopwatch.Restart();
}
}
}
}
catch (Exception ex)
{
Messenger.Default.Send <MinerOutputMessage>(new MinerOutputMessage()
{
OutputText = $"Compute error! Device #{DeviceIndex} (CryptoNight)"
});
}
Speed = 0;
if (!Stopped)
{
Thread.Sleep(5000);
}
}
}
}
private static bool IsEquihashCPU_eqm(ComputeDevice a)
{
return(MinersManager.EquihashCPU_USE_eqm() && a.DeviceType == DeviceType.CPU);
}
private BenchmarkingComputeDeviceHandler(ComputeDevice device)
{
Device = device;
}
private static bool IsEquihashNVIDIA_eqm(ComputeDevice a)
{
return(a.DeviceGroupType == DeviceGroupType.NVIDIA_5_x || a.DeviceGroupType == DeviceGroupType.NVIDIA_6_x);
}
public static string ParseForMiningPairs(List <MiningPair> MiningPairs, DeviceType deviceType, bool showLog = true)
{
_showLog = showLog;
MinerBaseType minerBaseType = MinerBaseType.NONE;
AlgorithmType algorithmType = AlgorithmType.NONE;
if (MiningPairs.Count > 0)
{
var algo = MiningPairs[0].Algorithm;
if (algo != null)
{
algorithmType = algo.NiceHashID;
minerBaseType = algo.MinerBaseType;
}
}
MinerType minerType = GetMinerType(deviceType, minerBaseType, algorithmType);
MinerOptionPackage minerOptionPackage = ExtraLaunchParameters.GetMinerOptionPackageForMinerType(minerType);
List <MiningPair> setMiningPairs = MiningPairs.ConvertAll((mp) => mp);
// handle exceptions and package parsing
// CPU exception
if (deviceType == DeviceType.CPU && minerType != MinerType.Xmrig)
{
CheckAndSetCPUPairs(setMiningPairs);
}
// ethminer exception
if (MinerType.ethminer_OCL == minerType || MinerType.ethminer_CUDA == minerType)
{
// use if missing compute device for correct mapping
// init fakes workaround
var cdevs_mappings = new List <MiningPair>();
{
int id = -1;
var fakeAlgo = new Algorithm(MinerBaseType.ethminer, AlgorithmType.DaggerHashimoto, "daggerhashimoto");
foreach (var pair in setMiningPairs)
{
while (++id != pair.Device.ID)
{
var fakeCdev = new ComputeDevice(id);
cdevs_mappings.Add(new MiningPair(fakeCdev, fakeAlgo));
}
cdevs_mappings.Add(pair);
}
}
// reset setMiningPairs
setMiningPairs = cdevs_mappings;
}
// sgminer exception handle intensity types
if (MinerType.sgminer == minerType)
{
// rawIntensity overrides xintensity, xintensity overrides intensity
var sgminer_intensities = new List <MinerOption>()
{
new MinerOption("Intensity", "-I", "--intensity", "d", MinerOptionFlagType.MultiParam, ","), // default is "d" check if -1 works
new MinerOption("Xintensity", "-X", "--xintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none
new MinerOption("Rawintensity", "", "--rawintensity", "-1", MinerOptionFlagType.MultiParam, ","), // default none
};
var contains_intensity = new Dictionary <MinerOptionType, bool>()
{
{ "Intensity", false },
{ "Xintensity", false },
{ "Rawintensity", false },
};
// check intensity and xintensity, the latter overrides so change accordingly
foreach (var cDev in setMiningPairs)
{
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["Intensity"] && contains_intensity["Xintensity"])
{
LogParser("Sgminer replacing --intensity with --xintensity");
foreach (var cDev in setMiningPairs)
{
cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--intensity", "--xintensity");
}
}
if (contains_intensity["Xintensity"] && contains_intensity["Rawintensity"])
{
LogParser("Sgminer replacing --xintensity with --rawintensity");
foreach (var cDev in setMiningPairs)
{
cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--xintensity", "--rawintensity");
}
}
}
string ret = "";
string general = Parse(setMiningPairs, minerOptionPackage.GeneralOptions, false, minerOptionPackage.TemperatureOptions);
// temp control and parse
if (ConfigManager.GeneralConfig.DisableAMDTempControl)
{
LogParser("DisableAMDTempControl is TRUE, temp control parameters will be ignored");
ret = general;
}
else
{
LogParser("AMD parsing temperature control parameters");
// temp = Parse(setMiningPairs, minerOptionPackage.TemperatureOptions, true, minerOptionPackage.GeneralOptions);
string temp = Parse(setMiningPairs, minerOptionPackage.TemperatureOptions, false, minerOptionPackage.GeneralOptions);
ret = general + " " + temp;
}
return(ret);
}
/// <summary>
/// Gets the build log of the <see cref="ComputeProgram"/> for a specified <see cref="ComputeDevice"/>.
/// </summary>
/// <param name="device"> The <see cref="ComputeDevice"/> building the <see cref="ComputeProgram"/>. Must be one of <see cref="ComputeProgram.Devices"/>. </param>
/// <returns> The build log of the <see cref="ComputeProgram"/> for <paramref name="device"/>. </returns>
public string GetBuildLog(ComputeDevice device)
{
unsafe
{
return GetStringInfo<ComputeProgramBuildInfo>(
device,
ComputeProgramBuildInfo.BuildLog,
CL10.GetProgramBuildInfo);
}
}
/**
* InitAlgorithmsMinerPaths gets and sets miner paths
*/
public static List <Algorithm> GetAndInitAlgorithmsMinerPaths(List <Algorithm> algos, ComputeDevice computeDevice /*, Options: MinerPathsConfig*/)
{
var retAlgos = algos.FindAll((a) => a != null).ConvertAll((a) => {
a.MinerBinaryPath = GetPathFor(computeDevice, a /*, Options*/);
return(a);
});
return(retAlgos);
}
/// <summary>
/// Gets the build log of the <see cref="ComputeProgram"/> for a specified <see cref="ComputeDevice"/>.
/// </summary>
/// <param name="device"> The <see cref="ComputeDevice"/> building the <see cref="ComputeProgram"/>. Must be one of <see cref="ComputeProgram.Devices"/>. </param>
/// <returns> The build log of the <see cref="ComputeProgram"/> for <paramref name="device"/>. </returns>
public string GetBuildLog(ComputeDevice device)
{
return GetStringInfo<CLProgramHandle, CLDeviceHandle, ComputeProgramBuildInfo>(Handle, device.Handle, ComputeProgramBuildInfo.BuildLog, CLInterface.CL10.GetProgramBuildInfo);
}
public MiningPair(ComputeDevice d, Algorithm a)
{
Device = d;
Algorithm = a;
CurrentExtraLaunchParameters = Algorithm.ExtraLaunchParameters;
}
/// <summary>
/// Gets a read-only collection of available <c>ComputeDevice</c>s on the <c>ComputePlatform</c>.
/// </summary>
/// <returns> A read-only collection of the available <c>ComputeDevice</c>s on the <c>ComputePlatform</c>. </returns>
/// <remarks> This method resets the <c>ComputePlatform.Devices</c>. This is useful if one or more of them become unavailable (<c>ComputeDevice.Available</c> is <c>false</c>) after a <c>ComputeContext</c> and <c>ComputeCommandQueue</c>s that use the <c>ComputeDevice</c> have been created and commands have been queued to them. Further calls will trigger an <c>OutOfResourcesComputeException</c> until this method is executed. You will also need to recreate any <c>ComputeResource</c> that was created on the no longer available <c>ComputeDevice</c>. </remarks>
public ReadOnlyCollection<ComputeDevice> QueryDevices()
{
unsafe
{
int handlesLength = 0;
ComputeErrorCode error = CL10.GetDeviceIDs(Handle, ComputeDeviceTypes.All, 0, null, &handlesLength);
ComputeException.ThrowOnError(error);
IntPtr[] handles = new IntPtr[handlesLength];
fixed (IntPtr* devicesPtr = handles)
{
error = CL10.GetDeviceIDs(Handle, ComputeDeviceTypes.All, handlesLength, devicesPtr, null);
ComputeException.ThrowOnError(error);
}
ComputeDevice[] devices = new ComputeDevice[handlesLength];
for (int i = 0; i < handlesLength; i++)
devices[i] = new ComputeDevice(this, handles[i]);
this.devices = new ReadOnlyCollection<ComputeDevice>(devices);
return this.devices;
}
}
/// <summary>
/// Attempts to initialize OpenCL for the selected GPU.
/// </summary>
private void InitializeOpenCL()
{
// only initialize once
if (clKernel != null)
return;
// select the device we've been instructed to use
clDevice = ComputePlatform.Platforms
.SelectMany(i => i.Devices)
.SingleOrDefault(i => i.Handle.Value == Gpu.CLDeviceHandle.Value);
// context we'll be working underneath
clContext = new ComputeContext(new ComputeDevice[] { clDevice }, new ComputeContextPropertyList(clDevice.Platform), null, IntPtr.Zero);
// queue to control device
clQueue = new ComputeCommandQueue(clContext, clDevice, ComputeCommandQueueFlags.None);
// buffers to store kernel output
clBuffer0 = new ComputeBuffer<uint>(clContext, ComputeMemoryFlags.ReadOnly, 16);
clBuffer1 = new ComputeBuffer<uint>(clContext, ComputeMemoryFlags.ReadOnly, 16);
// kernel code
string kernelCode;
using (var rdr = new StreamReader(GetType().Assembly.GetManifestResourceStream("BitMaker.Miner.Gpu.DiabloMiner.cl")))
kernelCode = rdr.ReadToEnd();
clProgram = new ComputeProgram(clContext, kernelCode);
try
{
// build kernel for device
clProgram.Build(new ComputeDevice[] { clDevice }, "-D WORKSIZE=" + clDevice.MaxWorkGroupSize, null, IntPtr.Zero);
}
catch (ComputeException)
{
throw new Exception(clProgram.GetBuildLog(clDevice));
}
clKernel = clProgram.CreateKernel("search");
}
public CLCommandQueue(CLContext context, ComputeDevice device, ComputeCommandQueueFlags flags)
{
_context = context;
_comQueue = new ComputeCommandQueue(context._comContext, device, flags);
}
/// <summary>
/// Gets the <see cref="ComputeProgramBuildStatus"/> of the <see cref="ComputeProgram"/> for a specified <see cref="ComputeDevice"/>.
/// </summary>
/// <param name="device"> The <see cref="ComputeDevice"/> building the <see cref="ComputeProgram"/>. Must be one of <see cref="ComputeProgram.Devices"/>. </param>
/// <returns> The <see cref="ComputeProgramBuildStatus"/> of the <see cref="ComputeProgram"/> for <paramref name="device"/>. </returns>
public ComputeProgramBuildStatus GetBuildStatus(ComputeDevice device)
{
unsafe
{
return (ComputeProgramBuildStatus)GetInfo<ComputeProgramBuildInfo, uint>(
device,
ComputeProgramBuildInfo.Status,
CL10.GetProgramBuildInfo);
}
}
/// <summary>
/// Entry point for a standard work thread.
/// </summary>
private void WorkThread()
{
InitializeOpenCL();
try
{
// continue working until canceled
while (!cts.IsCancellationRequested)
Work(Context.GetWork(this, GetType().Name));
}
catch (OperationCanceledException)
{
// ignore
}
clQueue.Finish();
clKernel.Dispose();
clKernel = null;
clBuffer0.Dispose();
clBuffer0 = null;
clBuffer1.Dispose();
clBuffer1 = null;
clQueue.Dispose();
clQueue = null;
clDevice = null;
clProgram.Dispose();
clProgram = null;
clContext.Dispose();
clContext = null;
}
/// <summary>
/// Gets the <see cref="ComputeProgramBuildStatus"/> of the <see cref="ComputeProgram"/> for a specified <see cref="ComputeDevice"/>.
/// </summary>
/// <param name="device"> The <see cref="ComputeDevice"/> building the <see cref="ComputeProgram"/>. Must be one of <see cref="ComputeProgram.Devices"/>. </param>
/// <returns> The <see cref="ComputeProgramBuildStatus"/> of the <see cref="ComputeProgram"/> for <paramref name="device"/>. </returns>
public ComputeProgramBuildStatus GetBuildStatus(ComputeDevice device)
{
return (ComputeProgramBuildStatus)GetInfo<CLProgramHandle, CLDeviceHandle, ComputeProgramBuildInfo, uint>(Handle, device.Handle, ComputeProgramBuildInfo.Status, CLInterface.CL10.GetProgramBuildInfo);
}
public static string ParseForCDevs(List <ComputeDevice> CDevs, AlgorithmType algorithmType, DeviceType deviceType, string minerPath = "", bool showLog = true)
{
_showLog = showLog;
// init cdevs extra launch parameters
foreach (var cDev in CDevs)
{
cDev.CurrentExtraLaunchParameters = cDev.MostProfitableAlgorithm.ExtraLaunchParameters;
}
// parse for nheqminer
if (algorithmType == AlgorithmType.Equihash)
{
// nheqminer
if (minerPath == MinerPaths.nheqminer)
{
if (deviceType == DeviceType.CPU)
{
foreach (var cDev in CDevs)
{
// extra thread check
if (cDev.CurrentExtraLaunchParameters.Contains("-t"))
{
// nothing
}
else // add threads params mandatory
{
cDev.CurrentExtraLaunchParameters += " -t " + GetThreads(cDev.Threads, cDev.MostProfitableAlgorithm.LessThreads).ToString();
}
}
return(Parse(CDevs, _nheqminer_CPU_Options));
}
if (deviceType == DeviceType.NVIDIA)
{
return(Parse(CDevs, _nheqminer_CUDA_Options));
}
if (deviceType == DeviceType.AMD)
{
return(Parse(CDevs, _nheqminer_AMD_Options));
}
}
else if (minerPath == MinerPaths.eqm)
{
if (deviceType == DeviceType.CPU)
{
foreach (var cDev in CDevs)
{
// extra thread check
if (cDev.CurrentExtraLaunchParameters.Contains("-t"))
{
// nothing
}
else // add threads params mandatory
{
cDev.CurrentExtraLaunchParameters += " -t " + GetThreads(cDev.Threads, cDev.MostProfitableAlgorithm.LessThreads).ToString();
}
// use only first CPU dev
break;
}
return(Parse(CDevs, _eqm_CPU_Options));
}
if (deviceType == DeviceType.NVIDIA)
{
return(Parse(CDevs, _eqm_CUDA_Options));
}
}
}
// parse for device
if (deviceType == DeviceType.NVIDIA)
{
if (algorithmType != AlgorithmType.DaggerHashimoto && algorithmType != AlgorithmType.CryptoNight)
{
return(Parse(CDevs, _ccimerOptions));
}
else if (algorithmType == AlgorithmType.CryptoNight)
{
// check if any device is SM21 or SM3.x if yes return empty for stability reasons
foreach (var cDev in CDevs)
{
if (cDev.DeviceGroupType == DeviceGroupType.NVIDIA_2_1 ||
cDev.DeviceGroupType == DeviceGroupType.NVIDIA_3_x)
{
return("");
}
}
return(Parse(CDevs, _ccimerCryptoNightOptions, true));
}
else // ethminer dagger
// use if missing compute device for correct mapping
{
int id = -1;
var cdevs_mappings = new List <ComputeDevice>();
foreach (var cDev in CDevs)
{
while (++id != cDev.ID)
{
var fakeCdev = new ComputeDevice(id, "", "", "");
fakeCdev.CurrentExtraLaunchParameters = ""; // empty
cdevs_mappings.Add(fakeCdev);
}
cdevs_mappings.Add(cDev);
}
return(Parse(cdevs_mappings, _cudaEthminerOptions));
}
}
else if (deviceType == DeviceType.AMD)
{
if (algorithmType != AlgorithmType.DaggerHashimoto)
{
// 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 CDevs)
{
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 CDevs)
{
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 CDevs)
{
cDev.CurrentExtraLaunchParameters = cDev.CurrentExtraLaunchParameters.Replace("--xintensity", "--rawintensity");
}
}
List <MinerOption> sgminerOptionsNew = new List <MinerOption>();
string temperatureControl = "";
// temp control and parse
if (ConfigManager.Instance.GeneralConfig.DisableAMDTempControl)
{
LogParser("DisableAMDTempControl is TRUE, temp control parameters will be ignored");
}
else
{
LogParser("Sgminer parsing temperature control parameters");
temperatureControl = Parse(CDevs, _sgminerTemperatureOptions, true, _sgminerOptions);
}
LogParser("Sgminer parsing default parameters");
string returnStr = String.Format("{0} {1}", Parse(CDevs, _sgminerOptions, false, _sgminerTemperatureOptions), temperatureControl);
LogParser("Sgminer extra launch parameters merged: " + returnStr);
return(returnStr);
}
else // ethminer dagger
// use if missing compute device for correct mapping
{
int id = -1;
var cdevs_mappings = new List <ComputeDevice>();
foreach (var cDev in CDevs)
{
while (++id != cDev.ID)
{
var fakeCdev = new ComputeDevice(id, "", "", "");
fakeCdev.CurrentExtraLaunchParameters = ""; // empty
cdevs_mappings.Add(fakeCdev);
}
cdevs_mappings.Add(cDev);
}
return(Parse(cdevs_mappings, _oclEthminerOptions));
}
}
else if (deviceType == DeviceType.CPU)
{
foreach (var cDev in CDevs)
{
// extra thread check
if (cDev.CurrentExtraLaunchParameters.Contains("--threads=") || cDev.CurrentExtraLaunchParameters.Contains("-t"))
{
// nothing
}
else // add threads params mandatory
{
cDev.CurrentExtraLaunchParameters += " --threads=" + GetThreads(cDev.Threads, cDev.MostProfitableAlgorithm.LessThreads).ToString();
}
}
return(Parse(CDevs, _cpuminerOptions));
}
return("");
}
private void StoreState()
{
platformBackup = platformComboBox.SelectedIndex;
devicesBackup = new bool[deviceCheckList.Items.Count];
for (int i = 0; i < devicesBackup.Length; i++)
{
devicesBackup[i] = false;
if (deviceCheckList.GetItemChecked(i))
devicesBackup[i] = true;
}
optionsBackup = optionsTextBox.Text;
Platform = ComputePlatform.Platforms[platformComboBox.SelectedIndex];
Devices = new ComputeDevice[deviceCheckList.CheckedItems.Count];
int k = 0;
for (int i = 0; k < Devices.Length && i < Platform.Devices.Count; i++)
if (deviceCheckList.GetItemChecked(i))
Devices[k++] = Platform.Devices[i];
Options = optionsTextBox.Text;
}
PerDeviceProifitDictionary GetEnabledDeviceProifitDictionary(PerDeviceSpeedDictionary speedDict, Dictionary <AlgorithmType, NiceHashSMA> NiceHashData)
{
PerDeviceProifitDictionary profitDict = new PerDeviceProifitDictionary();
// log stuff
int MAX_NAME_LEN = "daggerhashimoto".Length;
int MAX_SPEED_LEN = 15;
StringBuilder stringBuilderFull = new StringBuilder();
stringBuilderFull.AppendLine("Current device profits:");
foreach (var nameBenchKvp in speedDict)
{
var deviceUUID = nameBenchKvp.Key;
var curDevProfits = new Dictionary <AlgorithmType, double>();
StringBuilder stringBuilderDevice = new StringBuilder();
stringBuilderDevice.AppendLine(String.Format("\tProfits for {0} ({1}):", deviceUUID, ComputeDevice.GetNameForUUID(deviceUUID)));
AlgorithmType mostProfitKey = AlgorithmType.NONE;
double mostProfitAlgoVal = -1;
foreach (var algoSpeedKvp in nameBenchKvp.Value)
{
// Log stuff and calculation
string name = AlgorithmNiceHashNames.GetName(algoSpeedKvp.Key);
int namePreatyCount = MAX_NAME_LEN - name.Length;
if (namePreatyCount <= 0)
{
namePreatyCount = 1;
}
string namePreaty = name + new String(' ', namePreatyCount);
bool isEnabled = algoSpeedKvp.Value > 0;
double nhmSMADataVal = NiceHashData[algoSpeedKvp.Key].paying;
// TODO what is the constant at the end?
double algoProfit = algoSpeedKvp.Value * nhmSMADataVal * 0.000000001;
// calculate
if (isEnabled)
{
curDevProfits.Add(algoSpeedKvp.Key, algoProfit);
if (mostProfitAlgoVal < algoProfit)
{
mostProfitKey = algoSpeedKvp.Key;
mostProfitAlgoVal = algoProfit;
}
}
else
{
// if disabled make unprofitable
curDevProfits.Add(algoSpeedKvp.Key, -1000000);
algoProfit *= -1; // make bigger then 0 for logging reasons
}
// log stuff
string speedStr = algoSpeedKvp.Value.ToString("F3");
int speedStrCount = MAX_SPEED_LEN - speedStr.Length;
if (speedStrCount <= 0)
{
speedStrCount = 1;
}
string speedPreaty = new String(' ', speedStrCount) + speedStr;
stringBuilderDevice.AppendLine(String.Format("\t\t{0}\t:\tPROFIT = {1} ({2}, SPEED = {3}, NHSMA = {4})",
namePreaty, // Name
algoProfit.ToString(DOUBLE_FORMAT), // Profit
isEnabled ? "ENABLED " : "DISABLED", // ENABLED/DISABLED
speedPreaty, // Speed
nhmSMADataVal.ToString(DOUBLE_FORMAT) // NiceHashData
));
}
// add profits
profitDict.Add(deviceUUID, curDevProfits);
// log stuff
stringBuilderDevice.AppendLine(String.Format("\t\tMOST PROFITABLE (ENABLED) ALGO: {0}, PROFIT: {1}",
AlgorithmNiceHashNames.GetName(mostProfitKey),
mostProfitAlgoVal.ToString(DOUBLE_FORMAT)));
stringBuilderFull.AppendLine(stringBuilderDevice.ToString());
}
Helpers.ConsolePrint(TAG, stringBuilderFull.ToString());
return(profitDict);
}
