CpuMeter.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Diagnostics;
using System.Linq;
using Ephemera.NBagOfTricks;


namespace Ephemera.NBagOfUis
{
    public partial class CpuMeter : UserControl
    {
        #region Fields
        /// <summary>Total usage.</summary>
        PerformanceCounter? _cpuPerf = null;

        /// <summary>Logical processes.</summary>
        PerformanceCounter[]? _processesPerf = null;

        /// <summary> </summary>
        bool _inited = false;

        /// <summary> </summary>
        readonly Timer _timer = new();

        /// <summary> </summary>
        readonly int _min = 0;

        /// <summary> </summary>
        readonly int _max = 100;

        /// <summary>Storage.</summary>
        double[][]? _processesBuffs = null;

        /// <summary>Storage.</summary>
        double[]? _cpuBuff = null;

        /// <summary>Storage.</summary>
        int _buffIndex = 0;

        ///// <summary>CPU info.</summary>
        //int _cores = 0;

        ///// <summary>CPU info.</summary>
        //int _physicalProcessors = 0;

        /// <summary>CPU info.</summary>
        int _logicalProcessors = 0;

        /// <summary>The pen.</summary>
        readonly Pen _pen = new(Color.Black, 1);

        /// <summary>For drawing text.</summary>
        readonly StringFormat _format = new() { LineAlignment = StringAlignment.Center, Alignment = StringAlignment.Center };
        #endregion

        #region Properties
        /// <summary>User can change.</summary>
        public string Label { get; set; } = "cpu";

        /// <summary> </summary>
        public bool Enable { get; set; } = false;

        /// <summary>Default is 500 msec. Change if you like.</summary>
        public int UpdateFreq { set { _timer.Interval = value; } }

        /// <summary>For styling.</summary>
        public Color DrawColor { get { return _pen.Color; } set { _pen.Color = value; } }
        #endregion

        #region Lifecycle
        /// <summary>
        /// Constructor.
        /// </summary>
        public CpuMeter()
        {
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.OptimizedDoubleBuffer, true);
            Name = "CpuMeter";

            _timer.Tick += Timer_Tick;
            _timer.Interval = 500;
            _timer.Start();
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _pen?.Dispose();
                _cpuPerf?.Dispose();
                _format?.Dispose();
                _processesPerf?.ForEach(p => p?.Dispose());
            }
            base.Dispose(disposing);
        }
        #endregion

        #region Private functions
        /// <summary>
        /// Paints the volume meter.
        /// </summary>
        protected override void OnPaint(PaintEventArgs pe)
        {
            pe.Graphics.Clear(BackColor);

            // Draw data. FUTURE: for each process?
            if(_cpuBuff is not null)
            {
                for (int i = 0; i < _cpuBuff.Length; i++)
                {
                    int index = _buffIndex - i;
                    index = index < 0 ? index + _cpuBuff.Length : index;

                    double val = _cpuBuff[index];

                    // Draw data point.
                    double y = MathUtils.Map(val, _min, _max, Height, 0);
                    pe.Graphics.DrawLine(_pen, (float)i, (float)y, (float)i, Height);
                }
            }

            Rectangle r = new(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height / 2);
            pe.Graphics.DrawString(Label, Font, Brushes.Black, r, _format);
        }

        /// <summary>
        /// Update drawing area.
        /// </summary>
        protected override void OnResize(EventArgs e)
        {
            if(_inited)
            {
                SetBuffs();
            }

            Invalidate();
            base.OnResize(e);
        }

        /// <summary>
        /// 
        /// </summary>
        void SetBuffs()
        {
            if(_processesBuffs is not null)
            {
                int size = Width;
                for (int i = 0; i < _processesBuffs.Length; i++)
                {
                    _processesBuffs[i] = new double[size];
                }

                _cpuBuff = new double[size];

                _buffIndex = 0;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Tick(object? sender, EventArgs e)
        {
            if(Enable)
            {
                if (_cpuPerf is null)
                {
                    InitPerf();
                }
                else if (_cpuBuff is not null && _processesPerf is not null && _processesBuffs is not null)
                {
                    _cpuBuff[_buffIndex] = 0;

                    for (int i = 0; i < _processesPerf.Length; i++)
                    {
                        float val = _processesPerf[i].NextValue();
                        _processesBuffs[i][_buffIndex] = val;
                    }

                    _cpuBuff[_buffIndex] = _cpuPerf.NextValue();

                    _buffIndex++;
                    if (_buffIndex >= _cpuBuff.Length)
                    {
                        _buffIndex = 0;
                    }

                    Invalidate();
                }
            }
        }

        /// <summary>
        /// Defer init as they are slow processes.
        /// </summary>
        void InitPerf()
        {
            // The Processor (% Processor Time) counter will be out of 100 and will give the total usage across all
            // processors /cores/etc in the computer. However, the Processor (% Process Time) is scaled by the number
            // of logical processors. To get average usage across a computer, divide the result by Environment.ProcessorCount.

            // There are several different pieces of information relating to processors that you could get:
            // Number of physical processors
            // Number of cores
            // Number of logical processors.
            // These can all be different; in the case of a machine with 2 dual-core hyper-threading-enabled processors,
            //   there are 2 physical processors, 4 cores, and 8 logical processors.

            _logicalProcessors = Environment.ProcessorCount;
            _processesPerf = new PerformanceCounter[_logicalProcessors];
            _processesBuffs = new double[_logicalProcessors][];

            for (int i = 0; i < _logicalProcessors; i++)
            {
                var pc = new PerformanceCounter("Processor", "% Processor Time", i.ToString());
                _processesPerf[i] = pc;
            }

            _cpuPerf = new PerformanceCounter("Processor", "% Processor Time", "_Total");

            SetBuffs();

            _inited = true;
        }
        #endregion
    }
}