Seemingly inaccurate FPS sensors reading + other minor FPS counter fixes (solved)

[rud01f]

Hello.
I use exe installer version 3.9.3 on Windows 11 with AMD GPU (Radeon RX 6600) with AMD Adrenaline drivers v. 25.6.1 and LibreHardware sensors preset. Recently, I added FPS counter to my Turing screen and soon noticed FPS sensor reading may be innacurate.

• FurMark application displaying 38 FPS internally, Turing screen shows 181 FPS.
• Natural Selection 1 game (half-life based) - , frame limiter on, v-sync on, internal counter shows steady 60-61 FPS, which was visualy confirmed - no picture stuttering. Turing screen shows, depending of the angle of looking around, 38, 41, and 60 FPS. I'm 100% sure frame rate does not drop below 60 FPS (it's an old game, half-life mod, with v-sync disabled i achieve 740 FPS, which is by the way correctly shown by Turing screen).
• GTA V: Enhanced game - (v-sync on) AMD Andrenaline software shows 60-61 FPS, with 99th percentile of 58 FPS, Turing screen sometimes shows 40 FPS, sometimes 80-120.

Thus my question, am I missing some software/hardware quirks and the frame rate shown by Turing screen is technically correct? If not, or even if yes as well, is there a way to "convince" the turing-smart-screen-python software to show correct values of FPS? They seem awfully innacurate and misleading.

Edit: I've installed LibreHarwareMonitor v 0.9.4 application to directly display sensor readings (sensor is "AMD Radeon RX 6600 / Factors / Fullscreen FPS") and those are very accurate. No problem seen there, while it shows correct 59/60 FPS, the turing-smart-screen-python shows 68-79 FPS.

Edit2: ./external/LibreHardwareMonitor/test_librehardwaremonitor.py also shows correct value while turing-smart-screen-python running in parallel shows incorrect values

Edit 3: Solution
The solution was moving update of cls.prev_fps (the FPS counter variable) from Gpu.fps() to Gpu.stats(), and make Gpu.fps() just returm cls.prev_fps. Reason: both Gpu.stats() and Gpu.fps() call "update hardware readings" (cls.get_gpu_to_use() which internally calls get_hw_and_update()) which i believe in result is called twice in short period of time (miliseconds) most probably resulting in incorrect reading.

Please notice

• I also resolved small issue with FPS counter, which now limits readed value to maximum 9999 FPS (which in 99.9% of cases won't be exceeded) - while switching from game fullscreen to desktop, FPS from LibreHardwareMonitor sometimes shows value like 2409804123.1283 (extremely large and nonsense) which results in large value displayed and ghosted in later refresh.
• I've also targetted another issue, which is (final, on screen) FPS counter not updated, or rather loaded with old value when it's lower or equal zero. The result was FPS counter stuck at last value from fullscreen game, when returned to desktop (because "desktop" normal FPS value is 0). My patch resets FPS counter to 0 after FPS_RESET_TIME (which is 10 seconds in my example) seconds of value being non-positive.

The part of patched library\sensors\sensors_librehardwaremonitor.py:

    # move it to the beginning of code
    import time

    # in later part of code
class Gpu(sensors.Gpu):   
    # GPU to use is detected once, and its name is saved for future sensors readings
    gpu_name = ""

    # Latest FPS value is backed up in case next reading returns no value
    prev_fps = 0

    # remember when was last FPS reading > 0
    valid_fps_ts = time.time()

    # set FPS counter to zero after this amount of seconds of reading <= 0
    FPS_RESET_TIME = 10.0

    # Get GPU to use for sensors, and update it
    @classmethod
    def get_gpu_to_use(cls):
        gpu_to_use = get_hw_and_update(Hardware.HardwareType.GpuAmd, cls.gpu_name)
        if gpu_to_use is None:
            gpu_to_use = get_hw_and_update(Hardware.HardwareType.GpuNvidia, cls.gpu_name)
        if gpu_to_use is None:
            gpu_to_use = get_hw_and_update(Hardware.HardwareType.GpuIntel, cls.gpu_name)

        return gpu_to_use

    @classmethod
    def stats(cls) -> Tuple[
        float, float, float, float, float]:  # load (%) / used mem (%) / used mem (Mb) / total mem (Mb) / temp (°C)
        gpu_to_use = cls.get_gpu_to_use()
        if gpu_to_use is None:
            # GPU not supported
            return math.nan, math.nan, math.nan, math.nan, math.nan

        load = math.nan
        used_mem = math.nan
        total_mem = math.nan
        temp = math.nan

        for sensor in gpu_to_use.Sensors:
            if sensor.SensorType == Hardware.SensorType.Load and str(sensor.Name).startswith(
                    "GPU Core") and sensor.Value is not None:
                load = float(sensor.Value)
            elif sensor.SensorType == Hardware.SensorType.Load and str(sensor.Name).startswith("D3D 3D") and math.isnan(
                    load) and sensor.Value is not None:
                # Only use D3D usage if global "GPU Core" sensor is not available, because it is less
                # precise and does not cover the entire GPU: https://www.hwinfo.com/forum/threads/what-is-d3d-usage.759/
                load = float(sensor.Value)
            elif sensor.SensorType == Hardware.SensorType.SmallData and str(sensor.Name).startswith(
                    "GPU Memory Used") and sensor.Value is not None:
                used_mem = float(sensor.Value)
            elif sensor.SensorType == Hardware.SensorType.SmallData and str(sensor.Name).startswith(
                    "D3D") and str(sensor.Name).endswith("Memory Used") and math.isnan(
                used_mem) and sensor.Value is not None:
                # Only use D3D memory usage if global "GPU Memory Used" sensor is not available, because it is less
                # precise and does not cover the entire GPU: https://www.hwinfo.com/forum/threads/what-is-d3d-usage.759/
                used_mem = float(sensor.Value)
            elif sensor.SensorType == Hardware.SensorType.SmallData and str(sensor.Name).startswith(
                    "GPU Memory Total") and sensor.Value is not None:
                total_mem = float(sensor.Value)
            elif sensor.SensorType == Hardware.SensorType.Temperature and str(sensor.Name).startswith(
                    "GPU Core") and sensor.Value is not None:
                temp = float(sensor.Value)

        found = False
        if gpu_to_use is None:
            # GPU not supported
            cls.prev_fps = -1
        else:
            try:
                for sensor in gpu_to_use.Sensors:
                    if sensor.SensorType == Hardware.SensorType.Factor and "FPS" in str(
                           sensor.Name) and sensor.Value is not None:
                         # If a reading returns a value <= 0, returns old value instead
                        found = True
                        if int(sensor.Value) > 0:
                            cls.valid_fps_ts = time.time()
                            cls.prev_fps = min(int(sensor.Value),9999)
                            break
                        else:
                            if time.time() - cls.valid_fps_ts >=  cls.FPS_RESET_TIME:
                                cls.prev_fps = 0
            except:
                pass
            if not found:
                cls.prev_fps = -1

        return load, (used_mem / total_mem * 100.0), used_mem, total_mem, temp

    @classmethod
    def fps(cls) -> int:
#        gpu_to_use = cls.get_gpu_to_use()
#        if gpu_to_use is None:
#            # GPU not supported
#            return -1

#        try:
#            for sensor in gpu_to_use.Sensors:
#                if sensor.SensorType == Hardware.SensorType.Factor and "FPS" in str(
#                        sensor.Name) and sensor.Value is not None:
#                    # If a reading returns a value <= 0, returns old value instead
#                    if int(sensor.Value) > 0:
#                        cls.prev_fps = min(int(sensor.Value),9999)
#                    return cls.prev_pfs
#        except:
#            pass

#        # No FPS sensor for this GPU model
#        return -1
        return cls.prev_fps

[rud01f]

Answering myself so this question will be flagged as answered - the solution is above in the question.
Please for someone smart and skilled in github handling release a pull request - I just know Python, that's all.