🚧Increase fps calc perf

[CalvinWilkinson]

Complete The Item Below

• I have updated the title without removing the 🚧 emoji.

Description

Increase the performance of the TimeService, which is used to calculate a game's FPS(Frames Per Sec).

This will involve the current implementation

// <copyright file="TimerService.cs" company="KinsonDigital">
// Copyright (c) KinsonDigital. All rights reserved.
// </copyright>

namespace Velaptor.Services;

using System;
using System.Runtime.CompilerServices;

/// <inheritdoc/>
internal sealed class TimerService : ITimerService
{
    private const int SAMPLE_SIZE = 1000;
    private readonly IStopWatchWrapper stopWatch;
    private readonly double[] timeSamples = new double[SAMPLE_SIZE];
    private readonly double tickFreqMs;
    private double runningSum;
    private long startTicks;
    private long stopTicks;
    private int index;
    private bool isArrayFull;
    private int divisor;

    /// <summary>
    /// Initializes a new instance of the <see cref="TimerService"/> class.
    /// </summary>
    /// <param name="stopWatch">Tracks and measures time passed.</param>
    public TimerService(IStopWatchWrapper stopWatch)
    {
        this.stopWatch = stopWatch;
        this.tickFreqMs = 1000.0 / this.stopWatch.Frequency;
    }

    /// <inheritdoc/>
    /// <remarks>This is averaged over 1000 samples.</remarks>
    public float MillisecondsPassed { get; private set; }

    /// <inheritdoc/>
    public void Start() => this.startTicks = this.stopWatch.GetTimestamp();

    /// <inheritdoc/>
    public void Stop()
    {
        this.stopTicks = this.stopWatch.GetTimestamp();
        var sample = (this.stopTicks - this.startTicks) * this.tickFreqMs;
        AddSample(sample);

        // Set the divisor to avoid division by zero and to divide by the correct number of samples
        // which is important for calculating the average
        this.divisor = this.index == 1 ? 1 : this.index;

        // Calculate average using running sum
        MillisecondsPassed = (float)(this.runningSum / (this.isArrayFull ? SAMPLE_SIZE : this.divisor));
    }

    /// <inheritdoc/>
    public void Reset()
    {
        this.index = 0;
        this.runningSum = 0;
        this.isArrayFull = false;
        Array.Clear(this.timeSamples, 0, SAMPLE_SIZE);
        MillisecondsPassed = 0;
    }

    /// <summary>
    /// Adds the given <paramref name="sample"/> to the list of samples.
    /// </summary>
    /// <param name="sample">The sample to add.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void AddSample(double sample)
    {
        // Subtract the old value from running sum before replacing it
        this.runningSum -= this.timeSamples[this.index];
        this.runningSum += sample;
        this.timeSamples[this.index] = sample;

        if (this.index == SAMPLE_SIZE - 1)
        {
            this.isArrayFull = true;
        }

        this.index = this.index >= this.timeSamples.Length - 1
            ? 0
            : this.index + 1;
    }
}

This will also require changes to the IStopWatchWrapper interface and StopWatchWrapper class implementation. We do not need any of the current methods used. The only method we need to wrap now is the GetTimestamp() method.

Do the following:

1. Remove all of the current props and methods in the stopwatch wrapper types
2. Implement the GetTimestamp() method, which is the only method needed.
3. Update the TimerService implementation to the code above.
4. Make sure the new implementation works correctly with FPS numbers comparable to the old one.
5. Update the unit tests for the TimerService

Acceptance Criteria

The items to complete to satisfy the Definition of Done.

Preview Give feedback

1. All the unit tests have been executed and passed locally after the PR work is complete. (Why? Refer to 'Additional Information' below.)
2. Stopwatch wrapper types updated
3. TimeService updated for perf improvements
4. TimeService tests updated

ToDo Items

The items to complete to satisfy the Definition of Done.

Preview Give feedback

1. Add a change type label to the issue. Refer to the Change Type Labels section below.
2. Add a priority label to the issue. Refer to the Priority Type Labels section below.
3. Link the issue to the correct milestone (if applicable).

Issue Dependencies

No response

Related Work

No response

Additional Information:

Unit Tests

Reasons for local unit test execution:

• Unit tests might pass locally but not in the CI environment during the status check process or vice-versa.
• Tests might pass on the developer's machine but not necessarily on the code reviewer's machine.
• If you notice that the test status check has passed but the test failed locally, please notify a project maintainer!

💡Warning💡
If the unit tests pass remotely and are not executed locally, this means we could be letting a bug slip into production.
Though bugs will always exist in some capacity, we should all do our part to help prevent them from happening.

Change Type Labels

Change Type	Label
Bug Fixes	🐛bug
Breaking Changes	🧨breaking-changes
New Feature	✨new-feature
CICD Changes	♻️cicd
Config Changes	⚙️config
Performance Improvements	🏎️performance
Code Doc Changes	🗒️documentation/code
Product Doc Changes	📝documentation/product

Priority Type Labels

Priority Type	Label
Low Priority	low priority
Medium Priority	medium priority
High Priority	high priority

Code of Conduct

• I agree to follow this project's Code of Conduct.