private void PopulateCpuApiData(Miner.CPU miner, Miner.Device.CPU device, double divisor, ref JsonAPI.Miner cpuMiner)
{
try
{
cpuMiner = new JsonAPI.Miner()
{
Type = device.Type,
DeviceID = device.DeviceID,
ModelName = device.Name,
HashRate = (float)(miner.GetHashRateByDevice(device) / divisor),
HasMonitoringAPI = miner.HasMonitoringAPI
};
}
catch (Exception ex)
{
var errorMessage = string.Empty;
var currentEx = ex;
while (currentEx != null)
{
if (!string.IsNullOrEmpty(errorMessage))
{
errorMessage += " ";
}
errorMessage += currentEx.Message;
currentEx = currentEx.InnerException;
}
Program.Print(string.Format("[ERROR] {0}", errorMessage));
}
}
private void Process(HttpListener listener)
{
listener.Start();
Program.Print(string.Format("[INFO] JSON-API service started at {0}...", listener.Prefixes.ElementAt(0)));
while (m_isOngoing)
{
HttpListenerResponse response = listener.GetContext().Response;
var api = new JsonAPI();
float divisor = 0;
ulong totalHashRate = 0ul;
foreach (var miner in m_miners)
{
totalHashRate += miner.GetTotalHashrate();
}
var sTotalHashRate = totalHashRate.ToString();
if (sTotalHashRate.Length > 12 + 1)
{
divisor = 1000000000000;
api.HashRateUnit = "TH/s";
api.TotalHashRate = totalHashRate / divisor;
}
else if (sTotalHashRate.Length > 9 + 1)
{
divisor = 1000000000;
api.HashRateUnit = "GH/s";
api.TotalHashRate = totalHashRate / divisor;
}
else if (sTotalHashRate.Length > 6 + 1)
{
divisor = 1000000;
api.HashRateUnit = "MH/s";
api.TotalHashRate = totalHashRate / divisor;
}
else if (sTotalHashRate.Length > 3 + 1)
{
divisor = 1000;
api.HashRateUnit = "KH/s";
api.TotalHashRate = totalHashRate / divisor;
}
foreach (var miner in m_miners)
{
foreach (var device in miner.Devices.Where(d => d.DeviceID > -1))
{
JsonAPI.Miner newMiner = null;
if (miner.HasMonitoringAPI)
{
switch (device.Type)
{
case "CUDA":
{
var solver = ((Miner.CUDA)miner).Solver;
newMiner = new JsonAPI.CudaMiner()
{
Type = device.Type,
DeviceID = device.DeviceID,
ModelName = device.Name,
HashRate = miner.GetHashrateByDevice(device.Platform, device.DeviceID) / divisor,
HasMonitoringAPI = miner.HasMonitoringAPI,
SettingIntensity = device.Intensity,
SettingMaxCoreClockMHz = solver.getDeviceSettingMaxCoreClock(device.DeviceID),
SettingMaxMemoryClockMHz = solver.getDeviceSettingMaxMemoryClock(device.DeviceID),
SettingPowerLimitPercent = solver.getDeviceSettingPowerLimit(device.DeviceID),
SettingThermalLimitC = solver.getDeviceSettingThermalLimit(device.DeviceID),
SettingFanLevelPercent = solver.getDeviceSettingFanLevelPercent(device.DeviceID),
CurrentFanTachometerRPM = solver.getDeviceCurrentFanTachometerRPM(device.DeviceID),
CurrentTemperatureC = solver.getDeviceCurrentTemperature(device.DeviceID),
CurrentCoreClockMHz = solver.getDeviceCurrentCoreClock(device.DeviceID),
CurrentMemoryClockMHz = solver.getDeviceCurrentMemoryClock(device.DeviceID),
CurrentUtilizationPercent = solver.getDeviceCurrentUtilizationPercent(device.DeviceID),
CurrentPState = solver.getDeviceCurrentPstate(device.DeviceID),
CurrentThrottleReasons = solver.getDeviceCurrentThrottleReasons(device.DeviceID)
};
}
break;
case "OpenCL":
{
var solver = ((Miner.OpenCL)miner).Solver;
newMiner = new JsonAPI.AMD_Miner()
{
Type = device.Type,
DeviceID = device.DeviceID,
ModelName = device.Name,
HashRate = miner.GetHashrateByDevice(device.Platform, device.DeviceID) / divisor,
HasMonitoringAPI = miner.HasMonitoringAPI,
Platform = device.Platform,
SettingIntensity = device.Intensity,
SettingMaxCoreClockMHz = solver.getDeviceSettingMaxCoreClock(device.Platform, device.DeviceID),
SettingMaxMemoryClockMHz = solver.getDeviceSettingMaxMemoryClock(device.Platform, device.DeviceID),
SettingPowerLimitPercent = solver.getDeviceSettingPowerLimit(device.Platform, device.DeviceID),
SettingThermalLimitC = solver.getDeviceSettingThermalLimit(device.Platform, device.DeviceID),
SettingFanLevelPercent = solver.getDeviceSettingFanLevelPercent(device.Platform, device.DeviceID),
CurrentFanTachometerRPM = solver.getDeviceCurrentFanTachometerRPM(device.Platform, device.DeviceID),
CurrentTemperatureC = solver.getDeviceCurrentTemperature(device.Platform, device.DeviceID),
CurrentCoreClockMHz = solver.getDeviceCurrentCoreClock(device.Platform, device.DeviceID),
CurrentMemoryClockMHz = solver.getDeviceCurrentMemoryClock(device.Platform, device.DeviceID),
CurrentUtilizationPercent = solver.getDeviceCurrentUtilizationPercent(device.Platform, device.DeviceID)
};
}
break;
}
}
else
{
switch (device.Type)
{
case "OpenCL":
newMiner = new JsonAPI.OpenCLMiner()
{
Type = device.Type,
DeviceID = device.DeviceID,
ModelName = device.Name,
HashRate = miner.GetHashrateByDevice(device.Platform, device.DeviceID) / divisor,
HasMonitoringAPI = miner.HasMonitoringAPI,
Platform = device.Platform,
SettingIntensity = device.Intensity
};
break;
default:
newMiner = new JsonAPI.Miner()
{
Type = device.Type,
DeviceID = device.DeviceID,
ModelName = device.Name,
HashRate = miner.GetHashrateByDevice(device.Platform, (device.Type == "CPU")
? Array.IndexOf(miner.Devices, device)
: device.DeviceID) / divisor,
HasMonitoringAPI = miner.HasMonitoringAPI
};
break;
}
}
if (newMiner != null)
{
api.Miners.Add(newMiner);
}
}
}
byte[] buffer = Encoding.UTF8.GetBytes(Utils.Json.SerializeFromObject(api, Utils.Json.BaseClassFirstSettings));
response.ContentLength64 = buffer.Length;
using (var output = response.OutputStream)
if (buffer != null)
{
output.Write(buffer, 0, buffer.Length);
}
response.Close();
}
}
private void ProcessApiDataResponse(HttpListenerResponse response)
{
Task.Factory.StartNew(() =>
{
try
{
double divisor = 1;
var api = new JsonAPI();
PopulateCommonApiData(ref api, ref divisor);
foreach (var miner in m_miners)
{
foreach (var device in miner.Devices.Where(d => d.AllowDevice))
{
if (miner.HasMonitoringAPI)
{
switch (device.Type)
{
case "CUDA":
JsonAPI.CUDA_Miner cudaMiner = null;
PopulateCudaApiData((Miner.CUDA)miner, (Miner.Device.CUDA)device, divisor, ref cudaMiner);
if (cudaMiner != null)
{
api.Miners.Add(cudaMiner);
}
break;
case "OpenCL":
JsonAPI.AMD_Miner amdMiner = null;
PopulateAmdApiData((Miner.OpenCL)miner, (Miner.Device.OpenCL)device, divisor, ref amdMiner);
if (amdMiner != null)
{
api.Miners.Add(amdMiner);
}
break;
}
}
else
{
switch (device.Type)
{
case "OpenCL":
JsonAPI.OpenCLMiner openClMiner = null;
PopulateOpenCLApiData((Miner.OpenCL)miner, (Miner.Device.OpenCL)device, divisor, ref openClMiner);
if (openClMiner != null)
{
api.Miners.Add(openClMiner);
}
break;
case "CPU":
default:
JsonAPI.Miner cpuMiner = null;
PopulateCpuApiData((Miner.CPU)miner, (Miner.Device.CPU)device, divisor, ref cpuMiner);
if (cpuMiner != null)
{
api.Miners.Add(cpuMiner);
}
break;
}
}
}
}
api.Miners.Sort((x, y) => x.PciBusID.CompareTo(y.PciBusID));
byte[] buffer = Encoding.UTF8.GetBytes(Utils.Json.SerializeFromObject(api, Utils.Json.BaseClassFirstSettings));
using (var output = response.OutputStream)
{
if (buffer != null)
{
output.Write(buffer, 0, buffer.Length);
output.Flush();
}
}
}
catch (Exception ex)
{
response.StatusCode = (int)HttpStatusCode.InternalServerError;
var errorMessage = string.Empty;
var currentEx = ex;
while (currentEx != null)
{
if (!string.IsNullOrEmpty(errorMessage))
{
errorMessage += " ";
}
errorMessage += currentEx.Message;
currentEx = currentEx.InnerException;
}
Program.Print(string.Format("[ERROR] {0}", errorMessage));
}
finally
{
try
{
if (response != null)
{
response.Close();
}
}
catch (Exception ex)
{
var errorMessage = string.Empty;
var currentEx = ex;
while (currentEx != null)
{
if (!string.IsNullOrEmpty(errorMessage))
{
errorMessage += " ";
}
errorMessage += currentEx.Message;
currentEx = currentEx.InnerException;
}
Program.Print(string.Format("[ERROR] {0}", errorMessage));
}
}
},
TaskCreationOptions.LongRunning);
}
private void Process(HttpListener listener)
{
listener.Start();
Program.Print(string.Format("[INFO] JSON-API service started at {0}...", listener.Prefixes.ElementAt(0)));
while (m_isOngoing)
{
HttpListenerResponse response = listener.GetContext().Response;
var api = new JsonAPI();
float divisor = 1;
ulong totalHashRate = 0ul;
foreach (var miner in m_miners)
{
totalHashRate += miner.GetTotalHashrate();
}
var sTotalHashRate = totalHashRate.ToString();
if (sTotalHashRate.Length > 12 + 1)
{
divisor = 1000000000000;
api.HashRateUnit = "TH/s";
}
else if (sTotalHashRate.Length > 9 + 1)
{
divisor = 1000000000;
api.HashRateUnit = "GH/s";
}
else if (sTotalHashRate.Length > 6 + 1)
{
divisor = 1000000;
api.HashRateUnit = "MH/s";
}
else if (sTotalHashRate.Length > 3 + 1)
{
divisor = 1000;
api.HashRateUnit = "KH/s";
}
var networkInterface = m_miners.Select(m => m.NetworkInterface).FirstOrDefault(m => m != null);
api.EffectiveHashRate = (networkInterface?.GetEffectiveHashrate() ?? 0f) / divisor;
api.TotalHashRate = totalHashRate / divisor;
api.MinerAddress = networkInterface.MinerAddress ?? string.Empty;
api.MiningURL = networkInterface.SubmitURL ?? string.Empty;
api.CurrentChallenge = networkInterface.CurrentChallenge ?? string.Empty;
api.CurrentDifficulty = networkInterface.Difficulty;
api.LastSubmitLatencyMS = networkInterface?.LastSubmitLatency ?? -1;
api.LatencyMS = networkInterface?.Latency ?? -1;
api.Uptime = (long)(DateTime.Now - Program.LaunchTime).TotalSeconds;
api.RejectedShares = m_miners.Select(m => m.NetworkInterface).Distinct().Sum(i => (long)(i.RejectedShares));
api.AcceptedShares = m_miners.Select(m => m.NetworkInterface).Distinct().Sum(i => (long)(i.SubmittedShares)) - api.RejectedShares;
foreach (var miner in m_miners)
{
foreach (var device in miner.Devices.Where(d => d.AllowDevice))
{
JsonAPI.Miner newMiner = null;
if (miner.HasMonitoringAPI)
{
switch (device.Type)
{
case "CUDA":
{
var tempValue = 0;
var tempSize = 0ul;
var tempStr = new StringBuilder(1024);
var instancePtr = ((Miner.CUDA)miner).m_instance;
newMiner = new JsonAPI.CUDA_Miner()
{
Type = device.Type,
DeviceID = device.DeviceID,
PciBusID = device.PciBusID,
ModelName = device.Name,
HashRate = miner.GetHashrateByDevice(device.Platform, device.DeviceID) / divisor,
HasMonitoringAPI = miner.HasMonitoringAPI,
SettingIntensity = device.Intensity
};
if (((Miner.CUDA)miner).UseNvSMI)
{
((JsonAPI.CUDA_Miner)newMiner).SettingMaxCoreClockMHz = -1;
((JsonAPI.CUDA_Miner)newMiner).SettingMaxMemoryClockMHz = -1;
tempValue = Miner.API.NvSMI.GetDeviceSettingPowerLimit(device.PciBusID);
((JsonAPI.CUDA_Miner)newMiner).SettingPowerLimitPercent = tempValue;
tempValue = Miner.API.NvSMI.GetDeviceSettingThermalLimit(device.PciBusID);
((JsonAPI.CUDA_Miner)newMiner).SettingThermalLimitC = tempValue;
tempValue = Miner.API.NvSMI.GetDeviceSettingFanLevelPercent(device.PciBusID);
((JsonAPI.CUDA_Miner)newMiner).SettingFanLevelPercent = tempValue;
((JsonAPI.CUDA_Miner)newMiner).CurrentFanTachometerRPM = -1;
tempValue = Miner.API.NvSMI.GetDeviceCurrentTemperature(device.PciBusID);
((JsonAPI.CUDA_Miner)newMiner).CurrentTemperatureC = tempValue;
tempValue = Miner.API.NvSMI.GetDeviceCurrentCoreClock(device.PciBusID);
((JsonAPI.CUDA_Miner)newMiner).CurrentCoreClockMHz = tempValue;
tempValue = Miner.API.NvSMI.GetDeviceCurrentMemoryClock(device.PciBusID);
((JsonAPI.CUDA_Miner)newMiner).CurrentMemoryClockMHz = tempValue;
tempValue = Miner.API.NvSMI.GetDeviceCurrentUtilizationPercent(device.PciBusID);
((JsonAPI.CUDA_Miner)newMiner).CurrentUtilizationPercent = tempValue;
tempValue = Miner.API.NvSMI.GetDeviceCurrentPstate(device.PciBusID);
((JsonAPI.CUDA_Miner)newMiner).CurrentPState = tempValue;
tempStr.Append(Miner.API.NvSMI.GetDeviceCurrentThrottleReasons(device.PciBusID));
((JsonAPI.CUDA_Miner)newMiner).CurrentThrottleReasons = tempStr.ToString();
}
else
{
Miner.CUDA.Solver.GetDeviceSettingMaxCoreClock(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).SettingMaxCoreClockMHz = tempValue;
Miner.CUDA.Solver.GetDeviceSettingMaxMemoryClock(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).SettingMaxMemoryClockMHz = tempValue;
Miner.CUDA.Solver.GetDeviceSettingPowerLimit(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).SettingPowerLimitPercent = tempValue;
Miner.CUDA.Solver.GetDeviceSettingThermalLimit(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).SettingThermalLimitC = tempValue;
Miner.CUDA.Solver.GetDeviceSettingFanLevelPercent(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).SettingFanLevelPercent = tempValue;
Miner.CUDA.Solver.GetDeviceCurrentFanTachometerRPM(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).CurrentFanTachometerRPM = tempValue;
Miner.CUDA.Solver.GetDeviceCurrentTemperature(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).CurrentTemperatureC = tempValue;
Miner.CUDA.Solver.GetDeviceCurrentCoreClock(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).CurrentCoreClockMHz = tempValue;
Miner.CUDA.Solver.GetDeviceCurrentMemoryClock(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).CurrentMemoryClockMHz = tempValue;
Miner.CUDA.Solver.GetDeviceCurrentUtilizationPercent(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).CurrentUtilizationPercent = tempValue;
Miner.CUDA.Solver.GetDeviceCurrentPstate(instancePtr, device.DeviceID, ref tempValue);
((JsonAPI.CUDA_Miner)newMiner).CurrentPState = tempValue;
Miner.CUDA.Solver.GetDeviceCurrentThrottleReasons(instancePtr, device.DeviceID, tempStr, ref tempSize);
((JsonAPI.CUDA_Miner)newMiner).CurrentThrottleReasons = tempStr.ToString();
}
}
break;
case "OpenCL":
{
var tempValue = 0;
var tempStr = new StringBuilder(1024);
var instancePtr = ((Miner.OpenCL)miner).m_instance;
newMiner = new JsonAPI.AMD_Miner()
{
Type = device.Type,
DeviceID = device.DeviceID,
PciBusID = device.PciBusID,
ModelName = device.Name,
HashRate = miner.GetHashrateByDevice(device.Platform, device.DeviceID) / divisor,
HasMonitoringAPI = miner.HasMonitoringAPI,
Platform = device.Platform,
SettingIntensity = device.Intensity
};
if (((Miner.OpenCL)miner).UseLinuxQuery)
{
((JsonAPI.AMD_Miner)newMiner).SettingMaxCoreClockMHz = -1;
((JsonAPI.AMD_Miner)newMiner).SettingMaxMemoryClockMHz = -1;
((JsonAPI.AMD_Miner)newMiner).SettingPowerLimitPercent = -1;
((JsonAPI.AMD_Miner)newMiner).SettingThermalLimitC = int.MinValue;
((JsonAPI.AMD_Miner)newMiner).SettingFanLevelPercent = Miner.API.AmdLinuxQuery.GetDeviceSettingFanLevelPercent(device.PciBusID);
((JsonAPI.AMD_Miner)newMiner).CurrentFanTachometerRPM = Miner.API.AmdLinuxQuery.GetDeviceCurrentFanTachometerRPM(device.PciBusID);
((JsonAPI.AMD_Miner)newMiner).CurrentTemperatureC = Miner.API.AmdLinuxQuery.GetDeviceCurrentTemperature(device.PciBusID);
((JsonAPI.AMD_Miner)newMiner).CurrentCoreClockMHz = Miner.API.AmdLinuxQuery.GetDeviceCurrentCoreClock(device.PciBusID);
((JsonAPI.AMD_Miner)newMiner).CurrentMemoryClockMHz = Miner.API.AmdLinuxQuery.GetDeviceCurrentCoreClock(device.PciBusID);
((JsonAPI.AMD_Miner)newMiner).CurrentUtilizationPercent = Miner.API.AmdLinuxQuery.GetDeviceCurrentUtilizationPercent(device.PciBusID);
}
else
{
Miner.OpenCL.Solver.GetDeviceSettingMaxCoreClock(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).SettingMaxCoreClockMHz = tempValue;
Miner.OpenCL.Solver.GetDeviceSettingMaxMemoryClock(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).SettingMaxMemoryClockMHz = tempValue;
Miner.OpenCL.Solver.GetDeviceSettingPowerLimit(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).SettingPowerLimitPercent = tempValue;
Miner.OpenCL.Solver.GetDeviceSettingThermalLimit(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).SettingThermalLimitC = tempValue;
Miner.OpenCL.Solver.GetDeviceSettingFanLevelPercent(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).SettingFanLevelPercent = tempValue;
Miner.OpenCL.Solver.GetDeviceCurrentFanTachometerRPM(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).CurrentFanTachometerRPM = tempValue;
Miner.OpenCL.Solver.GetDeviceCurrentTemperature(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).CurrentTemperatureC = tempValue;
Miner.OpenCL.Solver.GetDeviceCurrentCoreClock(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).CurrentCoreClockMHz = tempValue;
Miner.OpenCL.Solver.GetDeviceCurrentMemoryClock(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).CurrentMemoryClockMHz = tempValue;
Miner.OpenCL.Solver.GetDeviceCurrentUtilizationPercent(instancePtr, new StringBuilder(device.Platform), device.DeviceID, ref tempValue);
((JsonAPI.AMD_Miner)newMiner).CurrentUtilizationPercent = tempValue;
}
}
break;
}
}
else
{
switch (device.Type)
{
case "OpenCL":
newMiner = new JsonAPI.OpenCLMiner()
{
Type = device.Type,
DeviceID = device.DeviceID,
ModelName = device.Name,
HashRate = miner.GetHashrateByDevice(device.Platform, device.DeviceID) / divisor,
HasMonitoringAPI = miner.HasMonitoringAPI,
Platform = device.Platform,
SettingIntensity = device.Intensity
};
break;
default:
newMiner = new JsonAPI.Miner()
{
Type = device.Type,
DeviceID = device.DeviceID,
ModelName = device.Name,
HashRate = miner.GetHashrateByDevice(device.Platform, (device.Type == "CPU")
? Array.IndexOf(miner.Devices, device)
: device.DeviceID) / divisor,
HasMonitoringAPI = miner.HasMonitoringAPI
};
break;
}
}
if (newMiner != null)
{
api.Miners.Add(newMiner);
}
}
}
api.Miners.Sort((x, y) => x.PciBusID.CompareTo(y.PciBusID));
byte[] buffer = Encoding.UTF8.GetBytes(Utils.Json.SerializeFromObject(api, Utils.Json.BaseClassFirstSettings));
response.ContentLength64 = buffer.Length;
using (var output = response.OutputStream)
if (buffer != null)
{
output.Write(buffer, 0, buffer.Length);
}
response.Close();
}
}
