atualizado venv global e performance model sem openhardwaremonitor
This commit is contained in:
Diego Freitas
parent
9ff0cd9cd5
commit
2c4b210529
|
|
@ -110,7 +110,7 @@ namespace AgroBase.Forms
|
|||
_appCts?.Dispose();
|
||||
_appCts = new CancellationTokenSource();
|
||||
|
||||
FuncoesGlobais.AddApplicationToStartup();
|
||||
//FuncoesGlobais.AddApplicationToStartup();
|
||||
|
||||
/*
|
||||
* Ordem pensada para campo:
|
||||
|
|
|
|||
|
|
@ -101,6 +101,7 @@ namespace AgroBase.Models
|
|||
return;
|
||||
|
||||
TipoMapa = tipoSelecionado ?? TipoMapaOperacao.Indefinido;
|
||||
await AtualizarInteratividadeMapaAsync(true);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,823 @@
|
|||
//using OpenHardwareMonitor.Hardware;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Threading;
|
||||
using static AgroBase.Models.Enums;
|
||||
|
||||
namespace AgroBase.Models
|
||||
{
|
||||
/// <summary>
|
||||
/// Snapshot de performance do NPC.
|
||||
/// A falha de um sensor nunca deve interromper o loop principal do sensoriamento.
|
||||
/// Valores sem uma nova leitura válida preservam o último valor conhecido.
|
||||
/// </summary>
|
||||
public class PerformanceModel_old
|
||||
{
|
||||
/*
|
||||
private static readonly object ComputerLock = new object();
|
||||
private static readonly object LogLock = new object();
|
||||
private static readonly Dictionary<string, DateTime> UltimoLogPorOrigem = new Dictionary<string, DateTime>();
|
||||
private static readonly TimeSpan IntervaloRetentativaHardware = TimeSpan.FromMinutes(1);
|
||||
private static readonly TimeSpan IntervaloLogRepetido = TimeSpan.FromMinutes(5);
|
||||
|
||||
private static Computer computer;
|
||||
private static DateTime _proximaTentativaHardwareUtc = DateTime.MinValue;
|
||||
|
||||
private readonly object _coletaLock = new object();
|
||||
private readonly object _snapshotLock = new object();
|
||||
private DateTime _ultimaLeituraPerformanceUtc = DateTime.MinValue;
|
||||
private bool _coletaEmAndamento;
|
||||
|
||||
public PerformanceModel_old() : this(true)
|
||||
{
|
||||
}
|
||||
|
||||
private PerformanceModel_old(bool inicializarHardware)
|
||||
{
|
||||
if (inicializarHardware)
|
||||
GarantirComputerInicializado();
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Identificação / estado da coleta
|
||||
// ============================================================
|
||||
|
||||
public DateTime Timestamp { get; set; } = DateTime.Now;
|
||||
public long TimestampUnixMs { get; set; }
|
||||
public DateTime? UltimaColetaConcluidaUtc { get; set; }
|
||||
public DateTime? Hardware_ultima_leitura_valida_utc { get; set; }
|
||||
public DateTime? Hardware_ultima_falha_utc { get; set; }
|
||||
public bool Hardware_monitor_disponivel { get; set; }
|
||||
public bool Ultima_coleta_completa { get; set; }
|
||||
public int Hardware_falhas_consecutivas { get; set; }
|
||||
public long Quantidade_coletas { get; set; }
|
||||
public long Quantidade_falhas { get; set; }
|
||||
public string Ultimo_erro { get; set; }
|
||||
|
||||
public bool Hardware_dados_desatualizados
|
||||
{
|
||||
get
|
||||
{
|
||||
return !Hardware_ultima_leitura_valida_utc.HasValue ||
|
||||
DateTime.UtcNow - Hardware_ultima_leitura_valida_utc.Value > TimeSpan.FromSeconds(10);
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// CPU
|
||||
// ============================================================
|
||||
|
||||
public float? CPU_load_percent { get; set; }
|
||||
public float? CPU_temp_package_c { get; set; }
|
||||
public float? CPU_power_package_w { get; set; }
|
||||
public float? CPU_power_cores_w { get; set; }
|
||||
public float? CPU_power_graphics_w { get; set; }
|
||||
public float? CPU_power_dram_w { get; set; }
|
||||
public float? CPU_clock_avg_mhz { get; set; }
|
||||
public float? CPU_clock_max_mhz { get; set; }
|
||||
public float? CPU_bus_speed_mhz { get; set; }
|
||||
public float? CPU_load => CPU_load_percent;
|
||||
public float? CPU_temp => CPU_temp_package_c;
|
||||
|
||||
// ============================================================
|
||||
// RAM
|
||||
// ============================================================
|
||||
|
||||
public float? RAM_usage_percent { get; set; }
|
||||
public float? RAM_used_gb { get; set; }
|
||||
public float? RAM_available_gb { get; set; }
|
||||
public float? RAM_total_gb => RAM_used_gb.HasValue && RAM_available_gb.HasValue
|
||||
? RAM_used_gb.Value + RAM_available_gb.Value
|
||||
: (float?)null;
|
||||
public float? RAM_usage => RAM_usage_percent;
|
||||
|
||||
// ============================================================
|
||||
// GPU
|
||||
// ============================================================
|
||||
|
||||
public float? GPU_load_percent { get; set; }
|
||||
public float? GPU_core_load_percent { get; set; }
|
||||
public float? GPU_frame_buffer_load_percent { get; set; }
|
||||
public float? GPU_memory_load_percent { get; set; }
|
||||
public float? GPU_video_engine_load_percent { get; set; }
|
||||
public float? GPU_bus_interface_load_percent { get; set; }
|
||||
public float? GPU_temp_core_c { get; set; }
|
||||
public float? GPU_power_w { get; set; }
|
||||
public float? GPU_core_clock_mhz { get; set; }
|
||||
public float? GPU_memory_clock_mhz { get; set; }
|
||||
public float? GPU_shader_clock_mhz { get; set; }
|
||||
public float? GPU_fan_percent { get; set; }
|
||||
public float? GPU_fan_rpm { get; set; }
|
||||
public float? GPU_pcie_rx { get; set; }
|
||||
public float? GPU_pcie_tx { get; set; }
|
||||
public float? GPU_load => GPU_load_percent;
|
||||
public float? GPU_temp => GPU_temp_core_c;
|
||||
|
||||
// ============================================================
|
||||
// GPU memória / VRAM
|
||||
// ============================================================
|
||||
|
||||
public float? GPU_vram_total_mb { get; set; }
|
||||
public float? GPU_vram_used_mb { get; set; }
|
||||
public float? GPU_vram_free_mb { get; set; }
|
||||
public float? GPU_vram_used_percent => GPU_vram_total_mb.HasValue && GPU_vram_total_mb.Value > 0 && GPU_vram_used_mb.HasValue
|
||||
? 100.0f * GPU_vram_used_mb.Value / GPU_vram_total_mb.Value
|
||||
: GPU_memory_load_percent;
|
||||
|
||||
// ============================================================
|
||||
// Disco
|
||||
// ============================================================
|
||||
|
||||
public float? Disk_used_space_percent { get; set; }
|
||||
public float? HDD_load => Disk_used_space_percent;
|
||||
|
||||
// ============================================================
|
||||
// Processo atual
|
||||
// ============================================================
|
||||
|
||||
public int Process_thread_count { get; set; }
|
||||
public long Process_working_set_mb { get; set; }
|
||||
public long Process_private_memory_mb { get; set; }
|
||||
public long Process_virtual_memory_mb { get; set; }
|
||||
public double Process_cpu_time_total_s { get; set; }
|
||||
|
||||
// ============================================================
|
||||
// ThreadPool
|
||||
// ============================================================
|
||||
|
||||
public int ThreadPool_available_worker_threads { get; set; }
|
||||
public int ThreadPool_available_completion_port_threads { get; set; }
|
||||
public int ThreadPool_max_worker_threads { get; set; }
|
||||
public int ThreadPool_max_completion_port_threads { get; set; }
|
||||
public int ThreadPool_used_worker_threads => Math.Max(0, ThreadPool_max_worker_threads - ThreadPool_available_worker_threads);
|
||||
public int ThreadPool_used_completion_port_threads => Math.Max(0, ThreadPool_max_completion_port_threads - ThreadPool_available_completion_port_threads);
|
||||
public float ThreadPool_used_worker_percent => ThreadPool_max_worker_threads <= 0
|
||||
? 0
|
||||
: 100.0f * ThreadPool_used_worker_threads / ThreadPool_max_worker_threads;
|
||||
public float ThreadPool_used_completion_port_percent => ThreadPool_max_completion_port_threads <= 0
|
||||
? 0
|
||||
: 100.0f * ThreadPool_used_completion_port_threads / ThreadPool_max_completion_port_threads;
|
||||
|
||||
public string PerformanceStr
|
||||
{
|
||||
get
|
||||
{
|
||||
return $"CPU={Fmt(CPU_load_percent)}% CPU_T={Fmt(CPU_temp_package_c)}C RAM={Fmt(RAM_usage_percent)}% " +
|
||||
$"GPU={Fmt(GPU_load_percent)}% GPU_Core={Fmt(GPU_core_load_percent)}% GPU_Mem={Fmt(GPU_memory_load_percent)}% " +
|
||||
$"VRAM={Fmt(GPU_vram_used_mb)}/{Fmt(GPU_vram_total_mb)}MB GPU_T={Fmt(GPU_temp_core_c)}C " +
|
||||
$"GPU_P={Fmt(GPU_power_w)}W HW={(Hardware_monitor_disponivel ? "OK" : "INDISP")}";
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Atualização principal
|
||||
// ============================================================
|
||||
|
||||
public void AtualizarDadosPerformance()
|
||||
{
|
||||
AtualizarDadosPerformance(TimeSpan.FromSeconds(1));
|
||||
}
|
||||
|
||||
public void AtualizarDadosPerformance(TimeSpan intervaloMinimo)
|
||||
{
|
||||
if (intervaloMinimo < TimeSpan.Zero)
|
||||
intervaloMinimo = TimeSpan.Zero;
|
||||
|
||||
DateTime agoraUtc = DateTime.UtcNow;
|
||||
|
||||
lock (_coletaLock)
|
||||
{
|
||||
if (_coletaEmAndamento || agoraUtc < _ultimaLeituraPerformanceUtc.Add(intervaloMinimo))
|
||||
return;
|
||||
|
||||
_coletaEmAndamento = true;
|
||||
_ultimaLeituraPerformanceUtc = agoraUtc;
|
||||
}
|
||||
|
||||
bool processoOk = false;
|
||||
bool threadPoolOk = false;
|
||||
bool hardwareOk = false;
|
||||
string ultimoErro = null;
|
||||
|
||||
try
|
||||
{
|
||||
processoOk = TentarAtualizar("Processo", AtualizarDadosProcesso, ref ultimoErro);
|
||||
threadPoolOk = TentarAtualizar("ThreadPool", AtualizarDadosThreadPool, ref ultimoErro);
|
||||
hardwareOk = AtualizarDadosHardware(ref ultimoErro);
|
||||
|
||||
lock (_snapshotLock)
|
||||
{
|
||||
Timestamp = DateTime.Now;
|
||||
TimestampUnixMs = DateTimeOffset.Now.ToUnixTimeMilliseconds();
|
||||
UltimaColetaConcluidaUtc = DateTime.UtcNow;
|
||||
Ultima_coleta_completa = processoOk && threadPoolOk && hardwareOk;
|
||||
Quantidade_coletas++;
|
||||
|
||||
if (ultimoErro != null)
|
||||
{
|
||||
Ultimo_erro = ultimoErro;
|
||||
Quantidade_falhas++;
|
||||
}
|
||||
else
|
||||
{
|
||||
Ultimo_erro = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
RegistrarFalha("Coleta geral", ex);
|
||||
|
||||
lock (_snapshotLock)
|
||||
{
|
||||
Timestamp = DateTime.Now;
|
||||
TimestampUnixMs = DateTimeOffset.Now.ToUnixTimeMilliseconds();
|
||||
UltimaColetaConcluidaUtc = DateTime.UtcNow;
|
||||
Ultima_coleta_completa = false;
|
||||
Ultimo_erro = ResumirErro(ex);
|
||||
Quantidade_coletas++;
|
||||
Quantidade_falhas++;
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
lock (_coletaLock)
|
||||
{
|
||||
_coletaEmAndamento = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private bool AtualizarDadosHardware(ref string ultimoErro)
|
||||
{
|
||||
if (!GarantirComputerInicializado())
|
||||
{
|
||||
lock (_snapshotLock)
|
||||
{
|
||||
Hardware_monitor_disponivel = false;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool algumaLeituraValida = false;
|
||||
bool houveFalha = false;
|
||||
HardwareSnapshot leitura = new HardwareSnapshot();
|
||||
|
||||
try
|
||||
{
|
||||
lock (ComputerLock)
|
||||
{
|
||||
if (computer == null || computer.Hardware == null)
|
||||
throw new InvalidOperationException("OpenHardwareMonitor não está inicializado.");
|
||||
|
||||
foreach (IHardware hardwareItem in computer.Hardware)
|
||||
{
|
||||
try
|
||||
{
|
||||
hardwareItem.Update();
|
||||
|
||||
switch (hardwareItem.HardwareType)
|
||||
{
|
||||
case HardwareType.CPU:
|
||||
LerCpu(hardwareItem, leitura);
|
||||
algumaLeituraValida = true;
|
||||
break;
|
||||
|
||||
case HardwareType.RAM:
|
||||
LerRam(hardwareItem, leitura);
|
||||
algumaLeituraValida = true;
|
||||
break;
|
||||
|
||||
case HardwareType.GpuNvidia:
|
||||
case HardwareType.GpuAti:
|
||||
LerGpu(hardwareItem, leitura);
|
||||
algumaLeituraValida = true;
|
||||
break;
|
||||
|
||||
case HardwareType.HDD:
|
||||
LerDisco(hardwareItem, leitura);
|
||||
algumaLeituraValida = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
houveFalha = true;
|
||||
ultimoErro = ResumirErro(ex);
|
||||
RegistrarFalha($"Hardware {hardwareItem?.Name ?? "desconhecido"}", ex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (algumaLeituraValida)
|
||||
AplicarHardwareSnapshot(leitura);
|
||||
|
||||
lock (_snapshotLock)
|
||||
{
|
||||
Hardware_monitor_disponivel = algumaLeituraValida;
|
||||
|
||||
if (algumaLeituraValida)
|
||||
Hardware_ultima_leitura_valida_utc = DateTime.UtcNow;
|
||||
|
||||
if (algumaLeituraValida && !houveFalha)
|
||||
Hardware_falhas_consecutivas = 0;
|
||||
else
|
||||
Hardware_falhas_consecutivas++;
|
||||
}
|
||||
|
||||
return algumaLeituraValida && !houveFalha;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
ultimoErro = ResumirErro(ex);
|
||||
RegistrarFalha("OpenHardwareMonitor", ex);
|
||||
MarcarFalhaHardware();
|
||||
ReiniciarComputerAposFalha();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static bool GarantirComputerInicializado()
|
||||
{
|
||||
if (!Variaveis.IsAgroBase)
|
||||
return false;
|
||||
|
||||
if (computer != null)
|
||||
return true;
|
||||
|
||||
if (DateTime.UtcNow < _proximaTentativaHardwareUtc)
|
||||
return false;
|
||||
|
||||
lock (ComputerLock)
|
||||
{
|
||||
if (computer != null)
|
||||
return true;
|
||||
|
||||
if (DateTime.UtcNow < _proximaTentativaHardwareUtc)
|
||||
return false;
|
||||
|
||||
Computer novoComputer = null;
|
||||
|
||||
try
|
||||
{
|
||||
novoComputer = new Computer
|
||||
{
|
||||
CPUEnabled = true,
|
||||
GPUEnabled = true,
|
||||
RAMEnabled = true,
|
||||
HDDEnabled = true,
|
||||
MainboardEnabled = false,
|
||||
FanControllerEnabled = false
|
||||
};
|
||||
|
||||
novoComputer.Open();
|
||||
computer = novoComputer;
|
||||
_proximaTentativaHardwareUtc = DateTime.MinValue;
|
||||
return true;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
try
|
||||
{
|
||||
novoComputer?.Close();
|
||||
}
|
||||
catch
|
||||
{
|
||||
}
|
||||
|
||||
computer = null;
|
||||
_proximaTentativaHardwareUtc = DateTime.UtcNow.Add(IntervaloRetentativaHardware);
|
||||
RegistrarFalha("Inicialização OpenHardwareMonitor", ex);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void ReiniciarComputerAposFalha()
|
||||
{
|
||||
lock (ComputerLock)
|
||||
{
|
||||
try
|
||||
{
|
||||
computer?.Close();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
RegistrarFalha("Encerramento OpenHardwareMonitor", ex);
|
||||
}
|
||||
finally
|
||||
{
|
||||
computer = null;
|
||||
_proximaTentativaHardwareUtc = DateTime.UtcNow.Add(IntervaloRetentativaHardware);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void EncerrarMonitoramento()
|
||||
{
|
||||
lock (ComputerLock)
|
||||
{
|
||||
try
|
||||
{
|
||||
computer?.Close();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
RegistrarFalha("Encerramento OpenHardwareMonitor", ex);
|
||||
}
|
||||
finally
|
||||
{
|
||||
computer = null;
|
||||
_proximaTentativaHardwareUtc = DateTime.MinValue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Leitores por hardware
|
||||
// ============================================================
|
||||
|
||||
private static void LerCpu(IHardware hardwareItem, HardwareSnapshot leitura)
|
||||
{
|
||||
float clockSum = 0;
|
||||
int clockCount = 0;
|
||||
|
||||
foreach (ISensor sensor in hardwareItem.Sensors)
|
||||
{
|
||||
if (!sensor.Value.HasValue)
|
||||
continue;
|
||||
|
||||
string name = sensor.Name ?? string.Empty;
|
||||
float value = sensor.Value.Value;
|
||||
|
||||
if (sensor.SensorType == SensorType.Load && name == "CPU Total")
|
||||
leitura.CpuLoad = value;
|
||||
else if (sensor.SensorType == SensorType.Temperature && name == "CPU Package")
|
||||
leitura.CpuTempPackage = value;
|
||||
else if (sensor.SensorType == SensorType.Power && name == "CPU Package")
|
||||
leitura.CpuPowerPackage = value;
|
||||
else if (sensor.SensorType == SensorType.Power && name == "CPU Cores")
|
||||
leitura.CpuPowerCores = value;
|
||||
else if (sensor.SensorType == SensorType.Power && name == "CPU Graphics")
|
||||
leitura.CpuPowerGraphics = value;
|
||||
else if (sensor.SensorType == SensorType.Power && name == "CPU DRAM")
|
||||
leitura.CpuPowerDram = value;
|
||||
else if (sensor.SensorType == SensorType.Clock && name.StartsWith("CPU Core", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
clockSum += value;
|
||||
clockCount++;
|
||||
leitura.CpuClockMax = MaxNullable(leitura.CpuClockMax, value);
|
||||
}
|
||||
else if (sensor.SensorType == SensorType.Clock && name == "Bus Speed")
|
||||
leitura.CpuBusSpeed = value;
|
||||
}
|
||||
|
||||
if (clockCount > 0)
|
||||
leitura.CpuClockAvg = clockSum / clockCount;
|
||||
}
|
||||
|
||||
private static void LerRam(IHardware hardwareItem, HardwareSnapshot leitura)
|
||||
{
|
||||
foreach (ISensor sensor in hardwareItem.Sensors)
|
||||
{
|
||||
if (!sensor.Value.HasValue)
|
||||
continue;
|
||||
|
||||
string name = sensor.Name ?? string.Empty;
|
||||
|
||||
if (sensor.SensorType == SensorType.Load && name == "Memory")
|
||||
leitura.RamUsage = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Data && name == "Used Memory")
|
||||
leitura.RamUsedGb = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Data && name == "Available Memory")
|
||||
leitura.RamAvailableGb = sensor.Value;
|
||||
}
|
||||
}
|
||||
|
||||
private static void LerGpu(IHardware hardwareItem, HardwareSnapshot leitura)
|
||||
{
|
||||
foreach (ISensor sensor in hardwareItem.Sensors)
|
||||
{
|
||||
if (!sensor.Value.HasValue)
|
||||
continue;
|
||||
|
||||
string name = sensor.Name ?? string.Empty;
|
||||
|
||||
if (sensor.SensorType == SensorType.Temperature && name == "GPU Core")
|
||||
leitura.GpuTempCore = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Load && name == "GPU Core")
|
||||
leitura.GpuCoreLoad = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Load && name == "GPU Frame Buffer")
|
||||
leitura.GpuFrameBufferLoad = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Load && name == "GPU Memory")
|
||||
leitura.GpuMemoryLoad = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Load && name == "GPU Video Engine")
|
||||
leitura.GpuVideoEngineLoad = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Load && name == "GPU Bus Interface")
|
||||
leitura.GpuBusInterfaceLoad = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Clock && name == "GPU Core")
|
||||
leitura.GpuCoreClock = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Clock && name == "GPU Memory")
|
||||
leitura.GpuMemoryClock = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Clock && name == "GPU Shader")
|
||||
leitura.GpuShaderClock = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Control && name == "GPU Fan")
|
||||
leitura.GpuFanPercent = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Fan && name == "GPU")
|
||||
leitura.GpuFanRpm = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.SmallData && name == "GPU Memory Total")
|
||||
leitura.GpuVramTotalMb = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.SmallData && name == "GPU Memory Used")
|
||||
leitura.GpuVramUsedMb = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.SmallData && name == "GPU Memory Free")
|
||||
leitura.GpuVramFreeMb = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Power && name == "GPU Power")
|
||||
leitura.GpuPower = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Throughput && name == "GPU PCIE Rx")
|
||||
leitura.GpuPcieRx = sensor.Value;
|
||||
else if (sensor.SensorType == SensorType.Throughput && name == "GPU PCIE Tx")
|
||||
leitura.GpuPcieTx = sensor.Value;
|
||||
}
|
||||
}
|
||||
|
||||
private static void LerDisco(IHardware hardwareItem, HardwareSnapshot leitura)
|
||||
{
|
||||
foreach (ISensor sensor in hardwareItem.Sensors)
|
||||
{
|
||||
if (sensor.Value.HasValue && sensor.SensorType == SensorType.Load && sensor.Name == "Used Space")
|
||||
leitura.DiskUsedSpace = sensor.Value;
|
||||
}
|
||||
}
|
||||
|
||||
private void AplicarHardwareSnapshot(HardwareSnapshot leitura)
|
||||
{
|
||||
lock (_snapshotLock)
|
||||
{
|
||||
CPU_load_percent = leitura.CpuLoad ?? CPU_load_percent;
|
||||
CPU_temp_package_c = leitura.CpuTempPackage ?? CPU_temp_package_c;
|
||||
CPU_power_package_w = leitura.CpuPowerPackage ?? CPU_power_package_w;
|
||||
CPU_power_cores_w = leitura.CpuPowerCores ?? CPU_power_cores_w;
|
||||
CPU_power_graphics_w = leitura.CpuPowerGraphics ?? CPU_power_graphics_w;
|
||||
CPU_power_dram_w = leitura.CpuPowerDram ?? CPU_power_dram_w;
|
||||
CPU_clock_avg_mhz = leitura.CpuClockAvg ?? CPU_clock_avg_mhz;
|
||||
CPU_clock_max_mhz = leitura.CpuClockMax ?? CPU_clock_max_mhz;
|
||||
CPU_bus_speed_mhz = leitura.CpuBusSpeed ?? CPU_bus_speed_mhz;
|
||||
RAM_usage_percent = leitura.RamUsage ?? RAM_usage_percent;
|
||||
RAM_used_gb = leitura.RamUsedGb ?? RAM_used_gb;
|
||||
RAM_available_gb = leitura.RamAvailableGb ?? RAM_available_gb;
|
||||
GPU_core_load_percent = leitura.GpuCoreLoad ?? GPU_core_load_percent;
|
||||
GPU_frame_buffer_load_percent = leitura.GpuFrameBufferLoad ?? GPU_frame_buffer_load_percent;
|
||||
GPU_memory_load_percent = leitura.GpuMemoryLoad ?? GPU_memory_load_percent;
|
||||
GPU_video_engine_load_percent = leitura.GpuVideoEngineLoad ?? GPU_video_engine_load_percent;
|
||||
GPU_bus_interface_load_percent = leitura.GpuBusInterfaceLoad ?? GPU_bus_interface_load_percent;
|
||||
|
||||
float? gpuLoad = MaxNullable(leitura.GpuCoreLoad, leitura.GpuFrameBufferLoad, leitura.GpuMemoryLoad,
|
||||
leitura.GpuVideoEngineLoad, leitura.GpuBusInterfaceLoad);
|
||||
|
||||
GPU_load_percent = gpuLoad ?? GPU_load_percent;
|
||||
GPU_temp_core_c = leitura.GpuTempCore ?? GPU_temp_core_c;
|
||||
GPU_power_w = leitura.GpuPower ?? GPU_power_w;
|
||||
GPU_core_clock_mhz = leitura.GpuCoreClock ?? GPU_core_clock_mhz;
|
||||
GPU_memory_clock_mhz = leitura.GpuMemoryClock ?? GPU_memory_clock_mhz;
|
||||
GPU_shader_clock_mhz = leitura.GpuShaderClock ?? GPU_shader_clock_mhz;
|
||||
GPU_fan_percent = leitura.GpuFanPercent ?? GPU_fan_percent;
|
||||
GPU_fan_rpm = leitura.GpuFanRpm ?? GPU_fan_rpm;
|
||||
GPU_vram_total_mb = leitura.GpuVramTotalMb ?? GPU_vram_total_mb;
|
||||
GPU_vram_used_mb = leitura.GpuVramUsedMb ?? GPU_vram_used_mb;
|
||||
GPU_vram_free_mb = leitura.GpuVramFreeMb ?? GPU_vram_free_mb;
|
||||
GPU_pcie_rx = leitura.GpuPcieRx ?? GPU_pcie_rx;
|
||||
GPU_pcie_tx = leitura.GpuPcieTx ?? GPU_pcie_tx;
|
||||
Disk_used_space_percent = leitura.DiskUsedSpace ?? Disk_used_space_percent;
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Processo / ThreadPool
|
||||
// ============================================================
|
||||
|
||||
private void AtualizarDadosProcesso()
|
||||
{
|
||||
using (Process proc = Process.GetCurrentProcess())
|
||||
{
|
||||
int threadCount = proc.Threads.Count;
|
||||
long workingSetMb = BytesToMb(proc.WorkingSet64);
|
||||
long privateMemoryMb = BytesToMb(proc.PrivateMemorySize64);
|
||||
long virtualMemoryMb = BytesToMb(proc.VirtualMemorySize64);
|
||||
double cpuTimeTotalS = proc.TotalProcessorTime.TotalSeconds;
|
||||
|
||||
lock (_snapshotLock)
|
||||
{
|
||||
Process_thread_count = threadCount;
|
||||
Process_working_set_mb = workingSetMb;
|
||||
Process_private_memory_mb = privateMemoryMb;
|
||||
Process_virtual_memory_mb = virtualMemoryMb;
|
||||
Process_cpu_time_total_s = cpuTimeTotalS;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void AtualizarDadosThreadPool()
|
||||
{
|
||||
ThreadPool.GetAvailableThreads(out int availableWorkerThreads, out int availableCompletionPortThreads);
|
||||
ThreadPool.GetMaxThreads(out int maxWorkerThreads, out int maxCompletionPortThreads);
|
||||
|
||||
lock (_snapshotLock)
|
||||
{
|
||||
ThreadPool_available_worker_threads = availableWorkerThreads;
|
||||
ThreadPool_available_completion_port_threads = availableCompletionPortThreads;
|
||||
ThreadPool_max_worker_threads = maxWorkerThreads;
|
||||
ThreadPool_max_completion_port_threads = maxCompletionPortThreads;
|
||||
}
|
||||
}
|
||||
|
||||
private bool TentarAtualizar(string origem, Action atualizacao, ref string ultimoErro)
|
||||
{
|
||||
try
|
||||
{
|
||||
atualizacao();
|
||||
return true;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
ultimoErro = ResumirErro(ex);
|
||||
RegistrarFalha(origem, ex);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private void MarcarFalhaHardware()
|
||||
{
|
||||
lock (_snapshotLock)
|
||||
{
|
||||
Hardware_monitor_disponivel = false;
|
||||
Hardware_ultima_falha_utc = DateTime.UtcNow;
|
||||
Hardware_falhas_consecutivas++;
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Clone / Snapshot consistente
|
||||
// ============================================================
|
||||
|
||||
public PerformanceModel_old Clone()
|
||||
{
|
||||
lock (_snapshotLock)
|
||||
{
|
||||
return new PerformanceModel_old(false)
|
||||
{
|
||||
Timestamp = Timestamp,
|
||||
TimestampUnixMs = TimestampUnixMs,
|
||||
UltimaColetaConcluidaUtc = UltimaColetaConcluidaUtc,
|
||||
Hardware_ultima_leitura_valida_utc = Hardware_ultima_leitura_valida_utc,
|
||||
Hardware_ultima_falha_utc = Hardware_ultima_falha_utc,
|
||||
Hardware_monitor_disponivel = Hardware_monitor_disponivel,
|
||||
Ultima_coleta_completa = Ultima_coleta_completa,
|
||||
Hardware_falhas_consecutivas = Hardware_falhas_consecutivas,
|
||||
Quantidade_coletas = Quantidade_coletas,
|
||||
Quantidade_falhas = Quantidade_falhas,
|
||||
Ultimo_erro = Ultimo_erro,
|
||||
CPU_load_percent = CPU_load_percent,
|
||||
CPU_temp_package_c = CPU_temp_package_c,
|
||||
CPU_power_package_w = CPU_power_package_w,
|
||||
CPU_power_cores_w = CPU_power_cores_w,
|
||||
CPU_power_graphics_w = CPU_power_graphics_w,
|
||||
CPU_power_dram_w = CPU_power_dram_w,
|
||||
CPU_clock_avg_mhz = CPU_clock_avg_mhz,
|
||||
CPU_clock_max_mhz = CPU_clock_max_mhz,
|
||||
CPU_bus_speed_mhz = CPU_bus_speed_mhz,
|
||||
RAM_usage_percent = RAM_usage_percent,
|
||||
RAM_used_gb = RAM_used_gb,
|
||||
RAM_available_gb = RAM_available_gb,
|
||||
GPU_load_percent = GPU_load_percent,
|
||||
GPU_core_load_percent = GPU_core_load_percent,
|
||||
GPU_frame_buffer_load_percent = GPU_frame_buffer_load_percent,
|
||||
GPU_memory_load_percent = GPU_memory_load_percent,
|
||||
GPU_video_engine_load_percent = GPU_video_engine_load_percent,
|
||||
GPU_bus_interface_load_percent = GPU_bus_interface_load_percent,
|
||||
GPU_temp_core_c = GPU_temp_core_c,
|
||||
GPU_power_w = GPU_power_w,
|
||||
GPU_core_clock_mhz = GPU_core_clock_mhz,
|
||||
GPU_memory_clock_mhz = GPU_memory_clock_mhz,
|
||||
GPU_shader_clock_mhz = GPU_shader_clock_mhz,
|
||||
GPU_fan_percent = GPU_fan_percent,
|
||||
GPU_fan_rpm = GPU_fan_rpm,
|
||||
GPU_vram_total_mb = GPU_vram_total_mb,
|
||||
GPU_vram_used_mb = GPU_vram_used_mb,
|
||||
GPU_vram_free_mb = GPU_vram_free_mb,
|
||||
GPU_pcie_rx = GPU_pcie_rx,
|
||||
GPU_pcie_tx = GPU_pcie_tx,
|
||||
Disk_used_space_percent = Disk_used_space_percent,
|
||||
Process_thread_count = Process_thread_count,
|
||||
Process_working_set_mb = Process_working_set_mb,
|
||||
Process_private_memory_mb = Process_private_memory_mb,
|
||||
Process_virtual_memory_mb = Process_virtual_memory_mb,
|
||||
Process_cpu_time_total_s = Process_cpu_time_total_s,
|
||||
ThreadPool_available_worker_threads = ThreadPool_available_worker_threads,
|
||||
ThreadPool_available_completion_port_threads = ThreadPool_available_completion_port_threads,
|
||||
ThreadPool_max_worker_threads = ThreadPool_max_worker_threads,
|
||||
ThreadPool_max_completion_port_threads = ThreadPool_max_completion_port_threads
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Logs e helpers
|
||||
// ============================================================
|
||||
|
||||
private static void RegistrarFalha(string origem, Exception ex)
|
||||
{
|
||||
try
|
||||
{
|
||||
DateTime agoraUtc = DateTime.UtcNow;
|
||||
|
||||
lock (LogLock)
|
||||
{
|
||||
if (UltimoLogPorOrigem.TryGetValue(origem, out DateTime ultimoLogUtc) &&
|
||||
agoraUtc - ultimoLogUtc < IntervaloLogRepetido)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
UltimoLogPorOrigem[origem] = agoraUtc;
|
||||
}
|
||||
|
||||
string mensagem = $"Falha na telemetria de performance ({origem}): {ResumirErro(ex)}";
|
||||
Variaveis.OperacaoEmAndamento?.InserirEventoOperacao(T_Code.Npc, StatusModulo.Falha, 0, mensagem, null, origem);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// O registro da falha nunca pode gerar outra falha no loop de sensoriamento.
|
||||
}
|
||||
}
|
||||
|
||||
private static string ResumirErro(Exception ex)
|
||||
{
|
||||
if (ex == null)
|
||||
return "Erro desconhecido.";
|
||||
|
||||
string mensagem = $"{ex.GetType().Name}: {ex.Message}";
|
||||
return mensagem.Length <= 500 ? mensagem : mensagem.Substring(0, 500);
|
||||
}
|
||||
|
||||
private static float? MaxNullable(params float?[] values)
|
||||
{
|
||||
float? max = null;
|
||||
|
||||
foreach (float? value in values)
|
||||
{
|
||||
if (value.HasValue && (!max.HasValue || value.Value > max.Value))
|
||||
max = value.Value;
|
||||
}
|
||||
|
||||
return max;
|
||||
}
|
||||
|
||||
private static long BytesToMb(long bytes)
|
||||
{
|
||||
return bytes / (1024L * 1024L);
|
||||
}
|
||||
|
||||
private static string Fmt(float? value, int casas = 1)
|
||||
{
|
||||
return value.HasValue ? value.Value.ToString($"F{casas}") : "-";
|
||||
}
|
||||
|
||||
private sealed class HardwareSnapshot
|
||||
{
|
||||
public float? CpuLoad;
|
||||
public float? CpuTempPackage;
|
||||
public float? CpuPowerPackage;
|
||||
public float? CpuPowerCores;
|
||||
public float? CpuPowerGraphics;
|
||||
public float? CpuPowerDram;
|
||||
public float? CpuClockAvg;
|
||||
public float? CpuClockMax;
|
||||
public float? CpuBusSpeed;
|
||||
public float? RamUsage;
|
||||
public float? RamUsedGb;
|
||||
public float? RamAvailableGb;
|
||||
public float? GpuCoreLoad;
|
||||
public float? GpuFrameBufferLoad;
|
||||
public float? GpuMemoryLoad;
|
||||
public float? GpuVideoEngineLoad;
|
||||
public float? GpuBusInterfaceLoad;
|
||||
public float? GpuTempCore;
|
||||
public float? GpuPower;
|
||||
public float? GpuCoreClock;
|
||||
public float? GpuMemoryClock;
|
||||
public float? GpuShaderClock;
|
||||
public float? GpuFanPercent;
|
||||
public float? GpuFanRpm;
|
||||
public float? GpuVramTotalMb;
|
||||
public float? GpuVramUsedMb;
|
||||
public float? GpuVramFreeMb;
|
||||
public float? GpuPcieRx;
|
||||
public float? GpuPcieTx;
|
||||
public float? DiskUsedSpace;
|
||||
}
|
||||
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
|
@ -80,6 +80,7 @@ class ContextoGlobalRedis:
|
|||
socket_connect_timeout=1.0,
|
||||
retry_on_timeout=True,
|
||||
health_check_interval=15,
|
||||
protocol=2,
|
||||
)
|
||||
|
||||
# ============================================================
|
||||
|
|
|
|||
Binary file not shown.
Loading…
Reference in New Issue