public void UpdateLogs(List <GpuLogger.Benchmark.SensorValue> sensorLog)
{
List <UserFriendlySensorValue> userFriendlySensorValues = new List <UserFriendlySensorValue>(sensorLog.Count);
List <GpuLogger.Benchmark.SensorValue> sortedSensorLog = sensorLog.OrderByDescending(value => value.TimeStamp).ToList();
// If over 9000, just use max size, else make sure it doesn't get out of index
int max = _rows > 9000 ? sortedSensorLog.Count : sortedSensorLog.Count < _rows ? sortedSensorLog.Count : _rows;
for (int index = 0; index < max; index++)
{
GpuLogger.Benchmark.SensorValue sensorValue = sortedSensorLog[index];
UserFriendlySensorValue userFriendlySensorValue = new UserFriendlySensorValue
{
TimeStamp =
GuiHelper.UnixTimeStampToDateTime(sensorValue.TimeStamp).ToString(CultureInfo.InvariantCulture),
Temperature = sensorValue.Temperature.ToString(CultureInfo.InvariantCulture) + "°C",
FanPercentage = sensorValue.FanPercentage.ToString(CultureInfo.InvariantCulture) + " %",
FanRpm = sensorValue.FanRpm.ToString(CultureInfo.InvariantCulture),
CoreClockFrequency = GuiHelper.GetRightMagnitude(sensorValue.CoreClockFrequency, "Hz"),
MemoryClockFrequency = GuiHelper.GetRightMagnitude(sensorValue.MemoryClockFrequency, "Hz"),
ShareAnswerPing = sensorValue.ShareAnswerPing.ToString(CultureInfo.InvariantCulture) + " ms",
MiningUrlPing = sensorValue.MiningUrlPing.ToString(CultureInfo.InvariantCulture) + " ms",
NetworkRigPing = sensorValue.NetworkRigPing.ToString(CultureInfo.InvariantCulture) + " ms",
};
userFriendlySensorValues.Add(userFriendlySensorValue);
}
dgvSensorLogs.DataSource = new SortableBindingList <UserFriendlySensorValue>(userFriendlySensorValues);
}
public void UpdateLogs(HashSet <GpuLogger.Benchmark.HashEntry> hashLogs)
{
List <UserFriendlyHashEntry> userFriendlyHashEntries = new List <UserFriendlyHashEntry>(hashLogs.Count);
List <GpuLogger.Benchmark.HashEntry> sortedHashLogs = hashLogs.OrderByDescending(entry => entry.TimeStamp).ToList();
// If over 9000, just use max size, else make sure it doesn't get out of index
int max = _rows > 9000? sortedHashLogs.Count : sortedHashLogs.Count < _rows ? sortedHashLogs.Count : _rows;
for (int index = 0; index < max; index++)
{
GpuLogger.Benchmark.HashEntry hashEntry = sortedHashLogs[index];
UserFriendlyHashEntry userFriendlyHashEntry = new UserFriendlyHashEntry
{
TimeStamp =
GuiHelper.UnixTimeStampToDateTime(hashEntry.TimeStamp).ToString(CultureInfo.InvariantCulture),
HashRate = GuiHelper.GetRightMagnitude(hashEntry.HashRate, "H"),
HashCount = GuiHelper.GetRightMagnitude(hashEntry.HashCount),
Found = String.Format("{0:0}", hashEntry.Found),
Height = String.Format("{0:0}", hashEntry.Height),
Difficulty = hashEntry.Difficulty.ToString(CultureInfo.InvariantCulture)
};
userFriendlyHashEntries.Add(userFriendlyHashEntry);
}
dgvHashLogs.DataSource = new SortableBindingList <UserFriendlyHashEntry>(userFriendlyHashEntries);
}
public void UpdateCharts(HashSet <GpuLogger.Benchmark.HashEntry> hashLogs, List <GpuLogger.Benchmark.Availability> availabilityTimeStamps)
{
List <ChartFriendlyHashEntry> chartFriendlyHashEntries = new List <ChartFriendlyHashEntry>(hashLogs.Count);
DateTime now = DateTime.Now;
TimeSpan start = new TimeSpan(_hours, 0, 0);
IEnumerable <ChartFriendlyHashEntry> friendlyHashEntries = hashLogs.OrderBy(entry => entry.TimeStamp).Select(hashEntry => new ChartFriendlyHashEntry
{
TimeStamp = GuiHelper.UnixTimeStampToDateTime(hashEntry.TimeStamp),
HashRate = (double)Decimal.Round(hashEntry.HashRate, MidpointRounding.AwayFromZero),
Found = hashEntry.Found,
Difficulty = (double)hashEntry.Difficulty,
HashCount = hashEntry.HashCount
}).Where(chartFriendlyHashEntry => _hours > 9000 || chartFriendlyHashEntry.TimeStamp > (now - start));
List <ChartFriendlyHashEntry> values = friendlyHashEntries as List <ChartFriendlyHashEntry> ?? friendlyHashEntries.ToList();
if (values.Count > 0)
{
chartFriendlyHashEntries.AddRange(values);
chartHash.SuspendLayout();
chartHash.DataSource = chartFriendlyHashEntries;
chartHash.DataBind();
UpdateAvailabilityCharts(availabilityTimeStamps, values);
AutoFormatXAxis(chartFriendlyHashEntries);
chartHash.ResumeLayout(true);
}
}
private void UpdateAvailabilityCharts(List <GpuLogger.Benchmark.Availability> availabilityTimeStamps, IList <ChartFriendlySensorValue> friendlySensorValues)
{
chartSensor.Series["AvailabilityTemperatureSeries"].Points.Clear();
chartSensor.Series["AvailabilityPingSeries"].Points.Clear();
DateTime firstTimeStamp = friendlySensorValues[0].TimeStamp;
double chartTempMaximum = friendlySensorValues.Max(value => value.Temperature) * 1.2;
double chartTempMinimum = friendlySensorValues.Min(value => value.Temperature) * 0.8;
double chartPingMaximum = friendlySensorValues.SelectMany(
value => new[] { value.MiningUrlPing, value.NetworkRigPing, value.ShareAnswerPing }).Max() * 1.2;
const double chartPingMinimum = 0;
for (int index = 0; index < availabilityTimeStamps.Count - 1; index++)
{
GpuLogger.Benchmark.Availability availabilityTimeStamp = availabilityTimeStamps[index];
DateTime dateTime = GuiHelper.UnixTimeStampToDateTime(availabilityTimeStamp.TimeStamp);
if (!availabilityTimeStamp.Available && dateTime > firstTimeStamp)
{
GpuLogger.Benchmark.Availability nextAvailabilityTimeStamp = availabilityTimeStamps[index + 1];
DateTime nextDateTime = GuiHelper.UnixTimeStampToDateTime(nextAvailabilityTimeStamp.TimeStamp);
chartSensor.Series["AvailabilityTemperatureSeries"].Points.AddXY(dateTime + new TimeSpan(0, 0, 1),
chartTempMinimum);
chartSensor.Series["AvailabilityTemperatureSeries"].Points.AddXY(dateTime + new TimeSpan(0, 0, 1),
chartTempMaximum + 1);
chartSensor.Series["AvailabilityTemperatureSeries"].Points.AddXY(nextDateTime - new TimeSpan(0, 0, 1),
chartTempMaximum + 1);
chartSensor.Series["AvailabilityTemperatureSeries"].Points.AddXY(nextDateTime - new TimeSpan(0, 0, 1),
chartTempMinimum);
chartSensor.Series["AvailabilityPingSeries"].Points.AddXY(dateTime + new TimeSpan(0, 0, 1),
chartPingMinimum);
chartSensor.Series["AvailabilityPingSeries"].Points.AddXY(dateTime + new TimeSpan(0, 0, 1),
chartPingMaximum + 1);
chartSensor.Series["AvailabilityPingSeries"].Points.AddXY(nextDateTime - new TimeSpan(0, 0, 1),
chartPingMaximum + 1);
chartSensor.Series["AvailabilityPingSeries"].Points.AddXY(nextDateTime - new TimeSpan(0, 0, 1),
chartPingMinimum);
}
}
chartSensor.ChartAreas["ChartAreaTemperatureFan"].AxisY.Maximum = chartTempMaximum;
chartSensor.ChartAreas["ChartAreaTemperatureFan"].AxisY.Minimum = chartTempMinimum;
chartSensor.ChartAreas["ChartAreaPingFrequency"].AxisY.Maximum = chartPingMaximum;
chartSensor.ChartAreas["ChartAreaPingFrequency"].AxisY.Minimum = chartPingMinimum;
}
private void UpdateAvailabilityCharts(List <GpuLogger.Benchmark.Availability> availabilityTimeStamps, IList <ChartFriendlyHashEntry> friendlyHashEntry)
{
chartHash.Series["AvailabilityFoundSeries"].Points.Clear();
chartHash.Series["AvailabilityDifficultySeries"].Points.Clear();
DateTime firstTimeStamp = friendlyHashEntry[0].TimeStamp;
const double chartFoundMaximum = 5;
const double chartFoundMinimum = 0;
double chartDifficultyMaximum = friendlyHashEntry.Max(value => value.Difficulty) * 1.2;
const double chartDifficultyMinimum = 0;;
for (int index = 0; index < availabilityTimeStamps.Count - 1; index++)
{
GpuLogger.Benchmark.Availability availabilityTimeStamp = availabilityTimeStamps[index];
DateTime dateTime = GuiHelper.UnixTimeStampToDateTime(availabilityTimeStamp.TimeStamp);
if (!availabilityTimeStamp.Available && dateTime > firstTimeStamp)
{
GpuLogger.Benchmark.Availability nextAvailabilityTimeStamp = availabilityTimeStamps[index + 1];
DateTime nextDateTime = GuiHelper.UnixTimeStampToDateTime(nextAvailabilityTimeStamp.TimeStamp);
chartHash.Series["AvailabilityFoundSeries"].Points.AddXY(dateTime + new TimeSpan(0, 0, 1),
chartFoundMinimum);
chartHash.Series["AvailabilityFoundSeries"].Points.AddXY(dateTime + new TimeSpan(0, 0, 1),
chartFoundMaximum + 1);
chartHash.Series["AvailabilityFoundSeries"].Points.AddXY(nextDateTime - new TimeSpan(0, 0, 1),
chartFoundMaximum + 1);
chartHash.Series["AvailabilityFoundSeries"].Points.AddXY(nextDateTime - new TimeSpan(0, 0, 1),
chartFoundMinimum);
chartHash.Series["AvailabilityDifficultySeries"].Points.AddXY(dateTime + new TimeSpan(0, 0, 1),
chartDifficultyMinimum);
chartHash.Series["AvailabilityDifficultySeries"].Points.AddXY(dateTime + new TimeSpan(0, 0, 1),
chartDifficultyMaximum + 1);
chartHash.Series["AvailabilityDifficultySeries"].Points.AddXY(nextDateTime - new TimeSpan(0, 0, 1),
chartDifficultyMaximum + 1);
chartHash.Series["AvailabilityDifficultySeries"].Points.AddXY(nextDateTime - new TimeSpan(0, 0, 1),
chartDifficultyMinimum);
}
}
chartHash.ChartAreas["ChartAreaFoundHashrate"].AxisY2.Maximum = chartFoundMaximum;
chartHash.ChartAreas["ChartAreaFoundHashrate"].AxisY2.Minimum = chartFoundMinimum;
chartHash.ChartAreas["ChartAreaDifficultyHashcount"].AxisY2.Maximum = chartDifficultyMaximum;
chartHash.ChartAreas["ChartAreaDifficultyHashcount"].AxisY2.Minimum = chartDifficultyMinimum;
}
public void UpdateCharts(List <GpuLogger.Benchmark.SensorValue> sensorValues, List <GpuLogger.Benchmark.Availability> availabilityTimeStamps, string os)
{
List <ChartFriendlySensorValue> chartFriendlySensorValues = new List <ChartFriendlySensorValue>(sensorValues.Count);
DateTime now = DateTime.Now;
TimeSpan start = new TimeSpan(_hours, 0, 0);
bool windows = os.StartsWith("windows");
chartSensor.ChartAreas["ChartAreaTemperatureFan"].AxisY2.Title = windows ? "Fan (RPM)" : "Fan (%)";
IEnumerable <ChartFriendlySensorValue> friendlySensorValues = sensorValues
.OrderBy(value => value.TimeStamp).Select(sensorValue => new ChartFriendlySensorValue
{
TimeStamp = GuiHelper.UnixTimeStampToDateTime(sensorValue.TimeStamp),
Temperature = (double)sensorValue.Temperature,
Fan = (double)(windows ? sensorValue.FanRpm : sensorValue.FanPercentage),
CoreClockFrequency = (double)sensorValue.CoreClockFrequency,
MemoryClockFrequency = (double)sensorValue.MemoryClockFrequency,
ShareAnswerPing = sensorValue.ShareAnswerPing,
MiningUrlPing = sensorValue.MiningUrlPing,
NetworkRigPing = sensorValue.NetworkRigPing,
}).Where(chartFriendlySensorValue => _hours > 9000 || chartFriendlySensorValue.TimeStamp > (now - start));
IList <ChartFriendlySensorValue> values = friendlySensorValues as IList <ChartFriendlySensorValue> ?? friendlySensorValues.ToList();
if (values.Count > 0)
{
chartFriendlySensorValues.AddRange(values);
chartSensor.SuspendLayout();
chartSensor.DataSource = chartFriendlySensorValues;
chartSensor.DataBind();
UpdateAvailabilityCharts(availabilityTimeStamps, values);
AutoFormatXAxis(chartFriendlySensorValues);
chartSensor.ResumeLayout(true);
}
}
public void UpdateGui()
{
if (!_pauseUpdate)
{
if (Gpu.CurrentBenchmark != null && Gpu.BenchLogs != null && Gpu.BenchLogs.Count > 0)
{
UpdateInternalControls();
UserFriendlyBenchmarks = new List <UserFriendlyBenchmark>(Gpu.BenchLogs.Count);
foreach (GpuLogger.Benchmark benchmark in Gpu.BenchLogs)
{
string timeStarted = GuiHelper.UnixTimeStampToDateTime(benchmark.TimeStamp).ToString("g");
string timeLastUpdate = benchmark.SensorLog.Count > 2
? GuiHelper.UnixTimeStampToDateTime(benchmark.SensorLog[benchmark.SensorLog.Count - 1].TimeStamp).ToString("g")
: timeStarted;
string averageHashRate = string.Empty;
string standardDeviation = string.Empty;
string averageTemperature = string.Empty;
string rightMagnitude = string.Empty;
string minerNameVersion = string.Empty;
string stratum = string.Empty;
if (benchmark.CurrentStatistic != null && benchmark.MinerSetup != null)
{
averageHashRate =
GuiHelper.GetRightMagnitude(benchmark.CurrentStatistic.HarmonicAverageHashRate, "H");
standardDeviation =
GuiHelper.GetRightMagnitude(benchmark.CurrentStatistic.StandardDeviation, "H");
rightMagnitude =
GuiHelper.GetRightMagnitude(benchmark.CurrentStatistic.TotalHashCount);
averageTemperature =
benchmark.CurrentStatistic.AverageTemperature.ToString("##.##") + " °C";
minerNameVersion = benchmark.MinerSetup.ToString();
stratum = benchmark.MinerSetup.MiningUrl;
}
UserFriendlyBenchmark userFriendlyBenchmark = new UserFriendlyBenchmark
{
TimeStarted = timeStarted,
TimeLastUpdate = timeLastUpdate,
Algorithm = benchmark.Algorithm,
AverageHashRate = averageHashRate,
StandardDeviation = standardDeviation,
HashCount = rightMagnitude,
AverageTemperature = averageTemperature,
MinerNameVersion = minerNameVersion,
Stratum = stratum
};
UserFriendlyBenchmarks.Insert(0, userFriendlyBenchmark);
}
int rowIndex = dgvBenchmarks.SelectedRows.Count > 0 ? dgvBenchmarks.SelectedRows[0].Index : 0;
dgvBenchmarks.DataSource = new SortableBindingList <UserFriendlyBenchmark>(UserFriendlyBenchmarks);
if (dgvBenchmarks.Rows.Count > 0)
{
dgvBenchmarks.CurrentCell = dgvBenchmarks.Rows[rowIndex].Cells[0];
}
}
}
}
