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]; } } } }