Customizable sensor update options (adjustable update interval and/or DO NOT monitor)

[hsyhsw]

This one is related with the recent change in LHM behavior that caused an issue reported in #3128.

It all started from my report #2968 months ago. It turned out that it was a LHM behavior forcing 60 seconds interval between updates for ALL storage devices.
After some time I submitted a PR to fix that by overriding that interval to 5 seconds for NVMe drives ONLY, but the author had different idea that removing the update interval entirely might be better. Yeah. I submitted another PR removing that interval and it has been merged into LHM lib.

So... From FanControl v221 released a few days ago, here we are. No forced update interval for all drives. Seemingly, FanControl is refreshing all sensors every second, which causes some HDDs to click every second.

Here are my suggestions. (quite same as the LHM author suggested in my PR thread though)

• Make sensor update interval adjustable
  This allows user to mitigate possible side effects monitoring itself causes like clicking sound, hdd wake-ups from idle, performance drop, ...
• Allow 'do not monitor' option
  Currently, FanControl refreshes all recognized sensors every second whether it is used or not. This option is for selectively turning off monitoring (not calling IHardware.Update() method) for choice sensors, eliminating any possible side effects monitoring itself causes.
  Related issue I've found: HDD spin-down stop working with active HDD temp monitoring #3004

I think they can be quite seamlessly integrated in the Settings > Sensors sections.

These options could be applied for all sensors, but, 'storage devices only' would be all good.
Please let me know what you think, and thanks for this amazing project.

[Spodi]

I would suggest two things:

• unused sensors should not be read unless needed somewhere (e.g. only read everyting as long as you pop out the list)
• If you can detect if storage is an HDD or an SSD, make the poll interval bigger (maybe 60sec, like it used to in LHM) to prevent some HDDs (like my seagate) confusing themselves as a clock. Optionally make it configurable for HDDs.

[hsyhsw]

Love the first one.

[Rem0o]

First suggestion is elegant, but not exactly simple to implement. As a first step I'm exploring the second option as such:

If storage is enabled, the following visitor would be used, else the normal visitor as a strategy pattern.

 public class StorageOptimizedUpdateVisitor : IVisitor
 {
     private int _updateCount;
     private int _genericHardDiskUpdateSkipCount = 60;

     public StorageOptimizedUpdateVisitor()
     {
         _updateCount = 0;
     }

     public void VisitComputer(IComputer computer)
     {
         try
         {
             computer.Traverse(this);
         }
         finally
         {
             _updateCount++;
             if (_updateCount > _genericHardDiskUpdateSkipCount)
             {
                 _updateCount = 0;
             }
         }
     }

     public void VisitHardware(IHardware hardware)
     {
         if (IsGenericHardDisk(hardware))
         {
             if (_updateCount == 0)
                 hardware.Update();
         }
         else
             hardware.Update();

         foreach (IHardware subHardware in hardware.SubHardware)
             subHardware.Accept(this);
     }

     private static bool IsGenericHardDisk(IHardware hardware)
     {
         return hardware.HardwareType == HardwareType.Storage && hardware.Identifier.ToString().StartsWith("hdd");
     }

     public void VisitParameter(IParameter parameter) { }

     public void VisitSensor(ISensor sensor) { }
 }

[hsyhsw]

Feeling not very convenient to selectively update devices in a computer tree currently LHM is offering. I was considering a visitor like:
Even if storage is disabled when instantiating Computer the pattern matching would just work as intended.

    internal class Visitor : IVisitor {
        StorageUpdater _storageUpdater = new StorageUpdater(5, 120);

        public void VisitComputer(IComputer computer) {
            computer.Traverse(this);
        }
        public void VisitHardware(IHardware hardware) {
            if (hardware is AbstractStorage stor)
                _storageUpdater.TryUpdate(stor);
            else
                hardware.Update();
            foreach (IHardware subHardware in hardware.SubHardware)
                subHardware.Accept(this);
        }
        public void VisitSensor(ISensor sensor) {
        }
        public void VisitParameter(IParameter parameter) {
        }
    }

    internal class StorageUpdater {
        // identifier -> (enabled, interval_sec, last_update)
        private readonly Dictionary<string, (bool, TimeSpan, DateTime)> _intervals = new Dictionary<string, (bool, TimeSpan, DateTime)>();
        private readonly uint _nvmeInterval;
        private readonly uint _hddInterval;

        public StorageUpdater(uint nvmeIntervalSec, uint hddIntervalSec) {
            _nvmeInterval = nvmeIntervalSec;
            _hddInterval = hddIntervalSec;
            // or whatever settings like 'per device', ...
        }
        public void TryUpdate(AbstractStorage storage) {
            var settings = GetSettings(storage);
            if (!settings.Item1)
                return;

            TimeSpan diff = DateTime.UtcNow - settings.Item3;
            if (diff > settings.Item2) {
                _intervals[storage.Identifier.ToString()] = (true, settings.Item2, DateTime.UtcNow);
                storage.Update();
            }
        }

        public void Disable(string storageId) {
            if (!_intervals.ContainsKey(storageId))
                return;
            var s = _intervals[storageId];
            _intervals[storageId] = (false, s.Item2, s.Item3);
        }

        private (bool, TimeSpan, DateTime) GetSettings(AbstractStorage storage) {
            var id = storage.Identifier.ToString();
            if (!_intervals.ContainsKey(id)) {
                switch (storage) {
                    case NVMeGeneric nvme:
                        _intervals.Add(id, (true, TimeSpan.FromSeconds(_nvmeInterval), DateTime.MinValue));
                        break;
                    default:
                        _intervals.Add(id, (true, TimeSpan.FromSeconds(_hddInterval), DateTime.MinValue));
                        break;
                }
            }
            return _intervals[id];
        }

[TheMelmacian]

The ideal solution would be if each sensor could be enabled/disabled and configured individually.

But as a first step it would be enough if HDD and SSD sensors could be enabled separately, if possible. This would allow to get rid of the clicking sound altogether without loosing SSD temp sensors.