25347403728

Committed 04 May 2026 10:34PM UTC coverage: 28.36% (-0.1%) from 28.482%

Build # 25347403728

Build Type

push

coveralls.net

Committed by

DemoBytom

Commit Message

Fix wrong names for `AppHost` and `ServiceDefaults` project names

Both the `AppHost` as well as `ServiceDefaults` projects lacked the dot in `Demo.Engine`. Fixes the naming convention.

Coverage Stats

1226 of 4323 relevant lines covered (28.36%)

0.32 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.15

/src/Demo.Engine.Core/Services/FpsTimer.cs

// Copyright © Michał Dembski and contributors.
// Distributed under MIT license. See LICENSE file in the root for more information.

using System.Diagnostics;
using System.Diagnostics.Metrics;
using Demo.Engine.Core.Interfaces;
using Demo.Engine.Core.ValueObjects;
using Microsoft.Extensions.Logging;

namespace Demo.Engine.Core.Services;

internal sealed class FpsTimer(
    ILogger<FpsTimer> logger)
    : IFpsTimer
{
    private static readonly Gauge<int> _upsGauge = Instrumentation.Meter.CreateGauge<int>(
        "demo.engine.ups.gauge",
        "ups",
        "Updates per second");

    private static readonly Histogram<int> _upsHistogram = Instrumentation.Meter.CreateHistogram<int>(
        "demo.engine.ups.histogram",
        "ups",
        "Updates per second");

    internal sealed class SurfaceFpsCounter(
        ILogger logger,
        RenderingSurfaceId surfaceId)
        : IFpsTimer.IFpsInternalTimer
    {
        private readonly ILogger _logger = logger;
        private readonly RenderingSurfaceId _surfaceId = surfaceId;

        private float _averageMs { get; set; } = 0.0f;
        private ulong _fpsCounter { get; set; } = 1;
        private long _start;
        private long _seconds = Stopwatch.GetTimestamp();

        private static readonly Gauge<int> _fpsGauge = Instrumentation.Meter.CreateGauge<int>(
            "demo.engine.fps.gauge",
            "fps",
            "Frames per second");

        private static readonly Histogram<int> _fpsHistogram = Instrumentation.Meter.CreateHistogram<int>(
            "demo.engine.fps.histogram",
            "fps",
            "Frames per second");

        public void Start()
            => _start = Stopwatch.GetTimestamp();

        public void Stop()
        {
            var dt = Stopwatch.GetElapsedTime(_start);

            _averageMs += (dt.Milliseconds - _averageMs) / _fpsCounter;
            ++_fpsCounter;

            if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
            {
                _logger.LogAverageSurfaceFps(
                    _surfaceId,
                    _averageMs,
                    _fpsCounter);

                _fpsGauge.Record((int)_fpsCounter,
                    new KeyValuePair<string, object?>("surfaceId", _surfaceId));
                _fpsHistogram.Record((int)_fpsCounter,
                    new KeyValuePair<string, object?>("surfaceId", _surfaceId));

                _averageMs = 0.0f;
                _fpsCounter = 1;
                _seconds = Stopwatch.GetTimestamp();
            }
        }
    }

    private readonly ILogger<FpsTimer> _logger = logger;
    private readonly Dictionary<RenderingSurfaceId, SurfaceFpsCounter> _surfaceFpsCounters = [];

    public void StartRenderingTimer(
        RenderingSurfaceId surfaceId)
    {
        if (!_surfaceFpsCounters.TryGetValue(
            surfaceId,
            out var fpsCounter))
        {
            fpsCounter = new SurfaceFpsCounter(
                _logger,
                surfaceId);

            _surfaceFpsCounters.Add(
                surfaceId,
                fpsCounter);
        }

        fpsCounter.Start();
    }

    public FpsTimerScope StartRenderingTimerScope(
        RenderingSurfaceId surfaceId)
    {
        if (!_surfaceFpsCounters.TryGetValue(
            surfaceId,
            out var fpsCounter))
        {
            fpsCounter = new SurfaceFpsCounter(
                _logger,
                surfaceId);

            _surfaceFpsCounters.Add(
                surfaceId,
                fpsCounter);
        }

        return new FpsTimerScope(
            fpsCounter);
    }

    public void StopRenderingTimer(
        RenderingSurfaceId surfaceId)
    {
        if (_surfaceFpsCounters.TryGetValue(
            surfaceId,
            out var fpsCounter))
        {
            fpsCounter.Stop();
        }
    }

    private float _averageMs { get; set; } = 0.0f;
    private ulong _upsCounter { get; set; } = 1;
    private long _start;
    private long _seconds = Stopwatch.GetTimestamp();

    public void StartUpdateTimer()
        => _start = Stopwatch.GetTimestamp();

    public void StopUpdateTimer()
    {
        var dt = Stopwatch.GetElapsedTime(_start);

        _averageMs += (dt.Milliseconds - _averageMs) / _upsCounter;
        ++_upsCounter;

        if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
        {
            _logger.LogAverageUps(
                _averageMs,
                _upsCounter);

            _upsGauge.Record((int)_upsCounter);
            _upsHistogram.Record((int)_upsCounter);

            _averageMs = 0.0f;
            _upsCounter = 1;
            _seconds = Stopwatch.GetTimestamp();
        }
    }
}

1	// Copyright © Michał Dembski and contributors.
2	// Distributed under MIT license. See LICENSE file in the root for more information.
3
4	using System.Diagnostics;
5	using System.Diagnostics.Metrics;
6	using Demo.Engine.Core.Interfaces;
7	using Demo.Engine.Core.ValueObjects;
8	using Microsoft.Extensions.Logging;
9
10	namespace Demo.Engine.Core.Services;
11
12	internal sealed class FpsTimer(	1✔
13	ILogger<FpsTimer> logger)	1✔
14	: IFpsTimer
15	{
16	private static readonly Gauge<int> _upsGauge = Instrumentation.Meter.CreateGauge<int>(
17	"demo.engine.ups.gauge",
18	"ups",
19	"Updates per second");
20
21	private static readonly Histogram<int> _upsHistogram = Instrumentation.Meter.CreateHistogram<int>(
22	"demo.engine.ups.histogram",
23	"ups",
24	"Updates per second");
25
26	internal sealed class SurfaceFpsCounter(	2✔
27	ILogger logger,	2✔
28	RenderingSurfaceId surfaceId)	2✔
29	: IFpsTimer.IFpsInternalTimer
30	{
31	private readonly ILogger _logger = logger;	2✔
32	private readonly RenderingSurfaceId _surfaceId = surfaceId;	2✔
33
34	private float _averageMs { get; set; } = 0.0f;
35	private ulong _fpsCounter { get; set; } = 1;	2✔
36	private long _start;
37	private long _seconds = Stopwatch.GetTimestamp();	2✔
38
39	private static readonly Gauge<int> _fpsGauge = Instrumentation.Meter.CreateGauge<int>(	×
40	"demo.engine.fps.gauge",	×
41	"fps",	×
42	"Frames per second");	×
43
44	private static readonly Histogram<int> _fpsHistogram = Instrumentation.Meter.CreateHistogram<int>(	×
45	"demo.engine.fps.histogram",	×
46	"fps",	×
47	"Frames per second");	×
48
49	public void Start()
50	=> _start = Stopwatch.GetTimestamp();	2✔
51
52	public void Stop()
53	{
54	var dt = Stopwatch.GetElapsedTime(_start);	2✔
55
56	_averageMs += (dt.Milliseconds - _averageMs) / _fpsCounter;	2✔
57	++_fpsCounter;	2✔
58
59	if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
60	{
61	_logger.LogAverageSurfaceFps(	×
62	_surfaceId,	×
63	_averageMs,	×
64	_fpsCounter);	×
65
66	_fpsGauge.Record((int)_fpsCounter,	×
67	new KeyValuePair<string, object?>("surfaceId", _surfaceId));	×
68	_fpsHistogram.Record((int)_fpsCounter,	×
69	new KeyValuePair<string, object?>("surfaceId", _surfaceId));	×
70
71	_averageMs = 0.0f;	×
72	_fpsCounter = 1;	×
73	_seconds = Stopwatch.GetTimestamp();	×
74	}
75	}	2✔
76	}
77
78	private readonly ILogger<FpsTimer> _logger = logger;	1✔
79	private readonly Dictionary<RenderingSurfaceId, SurfaceFpsCounter> _surfaceFpsCounters = [];	1✔
80
81	public void StartRenderingTimer(
82	RenderingSurfaceId surfaceId)
83	{
84	if (!_surfaceFpsCounters.TryGetValue(
85	surfaceId,
86	out var fpsCounter))
87	{
88	fpsCounter = new SurfaceFpsCounter(
89	_logger,
90	surfaceId);
91
92	_surfaceFpsCounters.Add(
93	surfaceId,
94	fpsCounter);
95	}
96
97	fpsCounter.Start();
98	}
99
100	public FpsTimerScope StartRenderingTimerScope(
101	RenderingSurfaceId surfaceId)
102	{
103	if (!_surfaceFpsCounters.TryGetValue(	1✔
104	surfaceId,	1✔
105	out var fpsCounter))	1✔
106	{
107	fpsCounter = new SurfaceFpsCounter(	1✔
108	_logger,	1✔
109	surfaceId);	1✔
110
111	_surfaceFpsCounters.Add(	1✔
112	surfaceId,	1✔
113	fpsCounter);	1✔
114	}
115
116	return new FpsTimerScope(	1✔
117	fpsCounter);	1✔
118	}
119
120	public void StopRenderingTimer(
121	RenderingSurfaceId surfaceId)
122	{
123	if (_surfaceFpsCounters.TryGetValue(
124	surfaceId,
125	out var fpsCounter))
126	{
127	fpsCounter.Stop();
128	}
129	}
130
131	private float _averageMs { get; set; } = 0.0f;
132	private ulong _upsCounter { get; set; } = 1;	1✔
133	private long _start;
134	private long _seconds = Stopwatch.GetTimestamp();	1✔
135
136	public void StartUpdateTimer()
137	=> _start = Stopwatch.GetTimestamp();	1✔
138
139	public void StopUpdateTimer()
140	{
141	var dt = Stopwatch.GetElapsedTime(_start);	1✔
142
143	_averageMs += (dt.Milliseconds - _averageMs) / _upsCounter;	1✔
144	++_upsCounter;	1✔
145
146	if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
147	{
148	_logger.LogAverageUps(
149	_averageMs,
150	_upsCounter);
151
152	_upsGauge.Record((int)_upsCounter);
153	_upsHistogram.Record((int)_upsCounter);
154
155	_averageMs = 0.0f;
156	_upsCounter = 1;
157	_seconds = Stopwatch.GetTimestamp();
158	}
159	}	1✔
160	}

DemoBytom / DemoEngine / 25347403728

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous