Compare commits
1
Commits
main
...
beta8/charts
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
86ba0c7c27 |
No files matched your search
@@ -102,6 +102,28 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
|
||||
|
||||
### Fixed
|
||||
|
||||
- **A frame-generation session's lows, median, min / max, σ and stutter count are over application frames**, as
|
||||
`03_METRICS` always said they were: they were computed over every present, generated ones included, so a ×2
|
||||
session's 1% low could sit above its native average, and a game that submits its generated frames in a burst —
|
||||
the owner's Onimusha demo capture, DLSS frame generation ×3 — read a median of 2,073 FPS at a native 60. Sessions
|
||||
recorded before this release keep the numbers they were stored with; their charts use the corrected rule.
|
||||
- **Pausing capture no longer puts a pause-long frame and the paused minutes into the session.** The first frame
|
||||
after a resume was measured from the last one before the pause; it follows a gap now, and every average is over
|
||||
the time that was measured. Records lost when the capture agent fell behind are left out of that time the same way,
|
||||
so an average reads the rate the game ran at rather than the survivors spread over the lost time.
|
||||
- **The charts are honest about what they draw.** The frametime chart's default line is application frame to
|
||||
application frame (it was each frame's interval to the generated frame before it), of the one swapchain the
|
||||
statistics are over (two swapchains' intervals were drawn interleaved); the every-present line no longer draws
|
||||
0 ms frames after gaps and says that presents are timed at submission; segments are labelled with their settings;
|
||||
the sensor overlay is in step with the frames (it was drawn from the session's start, tens of seconds early —
|
||||
schema 0013 records where the first frame sits, so sessions recorded before keep the overlay off). The histogram
|
||||
is binned over the 0.5th–99.5th percentile with its bars centred on their bins; the percentile curve and its
|
||||
1% / 0.1% low markers are drawn only where the session has the frames for them, the rule the stat cards follow.
|
||||
The Sensors charts put power on a watt axis, call the memory plot *Memory*, leave out VRAM readings of 0, give
|
||||
every line its own colour in the light theme too, and chart **sessions that were not hooked** — their sensors
|
||||
were recorded and shown nowhere.
|
||||
- **A game's page updates when one of its sessions finishes** — its sessions, trend and header kept what the page
|
||||
opened with until it was left and reopened.
|
||||
- **The Trend tab was blank the first time a game's page opened.** It is drawn at once, on a date axis that keeps its
|
||||
label and the theme's colours. "Average" is two metrics now — Native FPS and Presented FPS — so a line never mixes
|
||||
the two, and never shows a presented rate that includes generated frames. Temperatures, loads, power and memory
|
||||
|
||||
@@ -55,8 +55,32 @@ entirely rather than counted as one long frame. Including it would fabricate a
|
||||
stutter — the exact artifact these metrics exist to detect honestly. Gaps count
|
||||
toward the session's data-quality warnings.
|
||||
|
||||
> **Since beta.8 a pause is a gap, and a gap is not time either.** The Overlay records nothing while FR-3.9's pause
|
||||
> holds, so the first record after the resume is QPC-apart from the last one before it by the whole pause: counted, a
|
||||
> fabricated minutes-long frame in every statistic — the Overlay's own comment on its pause check (`MayObserve`) names that
|
||||
> artefact — and paused minutes in every average. `CaptureSession` reads the QPC as it tells the ring to resume and marks
|
||||
> a gap before the first record stamped at or after it (`CaptureSessionTests.TheFirstRecordPresentedAfterAResumeFollowsAGap`,
|
||||
> red before the fix). And **`D`, the time base of every average, is the time the kept intervals span** — first to last
|
||||
> present less every interval a gap sat in (`FrameTimeSeries.MeasuredSeconds`, `FgWindow.Seconds`): Presented FPS is
|
||||
> the kept intervals over the seconds they span, and Native / Displayed leave the gaps out of their seconds too. For
|
||||
> lost records this reads the survivors' rate (a drop is the Agent falling behind, not the game) where it read the
|
||||
> survivors spread over the lost time — a rate nobody measured; with no gap nothing changes.
|
||||
|
||||
**Lows use application frames only.** Generated frames smooth display cadence but do not represent simulation stalls; mixing them hides real stutter. A secondary "Displayed 1% Low" is stored for the Displayed chart series but never replaces the headline.
|
||||
|
||||
> **And since beta.8 (2026-09-25) they are computed that way — until then they were not.** Where generated frames were
|
||||
> counted (`fg_mode` a technology, or `active`), `SessionAggregator` took the median, the lows, min / max, σ and the stutter
|
||||
> rule over every present of the dominant stream: the 1% low of a ×2 session sat above its native average, and on the
|
||||
> owner's Onimusha demo capture (DLSS FG ×3, which submits each generated frame half a millisecond after its application
|
||||
> frame) the stored median read **2,073 FPS on a 60 FPS game**. `ft_app` is now `Domain.Metrics.FrameTimeSeries.ApplicationFrames`:
|
||||
> the interval between two consecutive presents that carried an application frame's token, the generated presents between
|
||||
> them adding no interval of their own; a gap or a present that does not claim the count breaks the chain. The segments'
|
||||
> lows follow; the Displayed 1% low stays over every present. **A technology named and no application frame counted**
|
||||
> (`no_evaluations`, `not_counted`) has no frame statistic at all — N/A rather than a low over presents that include
|
||||
> generated frames. Per-present attribution is accurate to one present (§Frame Generation); it was measured regular —
|
||||
> application, generated, generated, repeating — on that capture. **Rows written before beta.8 keep their stored
|
||||
> numbers**, as with the steady state (#198); their charts are drawn from the blob with the new rule.
|
||||
|
||||
> **When frame generation is NOT measured, the lows are taken over presents and labelled
|
||||
> `(presented)`** — added 2026-09-03 with Presented FPS. On a title with no in-process frame
|
||||
> generation that is exactly the application-frame low; on one that generates frames through a
|
||||
|
||||
@@ -315,6 +315,12 @@ than a tuning knob. ~~There is no UI thread in P2; the pipe reader (P3) joins as
|
||||
the pipe's tasks touches the ring or the recorder, and the session loop never waits on a client. The command half (PR-1b) is the
|
||||
`Channel` producer this sentence anticipated.
|
||||
|
||||
> **The pause is a gap (beta.8).** FR-3.9's pause stops the Overlay recording; the loop reads the QPC as it tells the ring
|
||||
> to resume (`ApplyPause`, before `SetPaused(false)`, on the Overlay's own clock — `Stopwatch` is `QueryPerformanceCounter`)
|
||||
> and marks a gap before the first drained record stamped at or after it (`MarkResume`). A record drained after the
|
||||
> resume but stamped before it is a straggler the pause had not reached. `03_METRICS` §Data gaps says what a gap then
|
||||
> does to the statistics and to `D`.
|
||||
|
||||
## Telemetry poller
|
||||
|
||||
1 Hz on its own thread: `CompositeTelemetrySource.TryRead` (`18_GPU_VENDOR_APIS` — DXGI/PDH baseline, LibreHardwareMonitor sensors, NVAPI extras on NVIDIA) + optional CPU sample when the Agent is elevated and PawnIO is present. Never called from the game process, never faster than 500 ms. Samples carry the session QPC epoch for timeline alignment.
|
||||
|
||||
@@ -293,7 +293,10 @@ CREATE TABLE frame_blobs (
|
||||
dispatch_rays BLOB, -- uint32[] : ray volume per frame, tier 1 only
|
||||
pso_created BLOB, -- uint16[] : compile COUNT per frame, not a flag
|
||||
vram_proc BLOB, -- uint32[] MB per frame; held 1 Hz sample, see 03_METRICS
|
||||
latency_us BLOB -- uint32[], tier 1 + Reflex only
|
||||
latency_us BLOB, -- uint32[], tier 1 + Reflex only
|
||||
first_present_ms REAL -- schema 0013 (beta.8): the dominant stream's first present, ms from qpc_epoch —
|
||||
-- the sensors' zero (t_ms) against the frames'. NULL before; the charts then
|
||||
-- keep the sensor overlay off rather than draw it out of step
|
||||
);
|
||||
|
||||
CREATE TABLE sensor_blobs (
|
||||
@@ -376,6 +379,9 @@ Because Tier-1 and Tier-2 sessions carry different fields, every query that comp
|
||||
> record ON THE SAME SWAPCHAIN; the first record of a stream, and any record after a torn slot or an
|
||||
> overwrite skip, carries 0 with the `frame_flags` gap bit set, so the statistics exclude it and the export
|
||||
> still reconstructs `qpc_ms`. `swapchain_ids` is present only when the session held more than one stream.
|
||||
> **Schema 0013 (beta.8)** adds `frame_blobs.first_present_ms`: the charts draw the dominant stream from its first present
|
||||
> and the sensors from `qpc_epoch`, and nothing said how far apart the two zeros were. Gaps stay closed up on the frame
|
||||
> axis (a gap's interval is stored as 0), so a series still drifts ahead of its sensors past each gap.
|
||||
> Sensor series are aligned to `t_ms` (milliseconds from `qpc_epoch`) and a tick with no reading is stored as
|
||||
> **−1** — never 0, which would be a reading — because temperatures, loads, power and memory are never negative.s (NaN forbidden — assert).
|
||||
|
||||
|
||||
@@ -303,6 +303,41 @@ Stat cards (Avg uses `FpsReadout`, Median, 1% Low, 0.1% Low, Min/Max, σ, stutte
|
||||
> has no per-frame source yet), the segment ribbon as alternating spans when there is more than one segment,
|
||||
> and GPU temperature / load on the right axis behind the sensor toggle; `DistributionChart` draws the FPS
|
||||
> histogram and the percentile curve (`Domain.Metrics.Percentile`, so the two lows are two points on it).
|
||||
>
|
||||
> **Honest charts, 2026-09-25 (beta.8, owner item 8: "fix the charts that are not reasonable").** Measured first on the
|
||||
> owner's own Onimusha demo capture (DLSS FG ×3, read from a copy of the ledger): the title submits each generated frame
|
||||
> half a millisecond after its application frame, so the "native" series — each application frame's interval to the
|
||||
> present before it — was a generated frame's half millisecond, and the stored median read 2,073 FPS on a 60 FPS game.
|
||||
> What changed, each with a test (`SessionSeriesLoaderTests`, `ChartMathTests`, `PagesLoadTests`):
|
||||
> - **One stream.** `SessionSeriesLoader` charts the swapchain the statistics are over (`SegmentBuilder.DominantStream`,
|
||||
> identified first, then the most presents) — the stored intervals are per swapchain, and two streams interleaved on
|
||||
> one axis drew neither — with that stream's segments; the CSV export is the same stream (its header says so).
|
||||
> - **Application frame to application frame.** The default series is each application frame's time from the previous
|
||||
> application frame, the generated presents between them adding their intervals to it; a gap breaks the chain. It is
|
||||
> labelled *Application frames* where frame generation was counted and *Presents* where it was not — never "Native"
|
||||
> alone. A session whose presents were all generated (the `no_evaluations` refusal) charts every present and says so.
|
||||
> - **The every-present line** (FR-5.4's toggle) leaves out the presents after a gap, which were drawn as 0 ms frames,
|
||||
> and a note says what it is not: presents are timed at submission, and a burst of generated frames is not the
|
||||
> display's cadence.
|
||||
> - **Segments are labelled** with their settings (upscaler, render → output, frame generation) where the segment is
|
||||
> wide enough; the label was computed for every segment and drawn for none.
|
||||
> - **The sensor overlay is in step.** Schema 0013's `frame_blobs.first_present_ms` says where the first present sits on
|
||||
> the sensors' clock; the overlay was drawn tens of seconds early (the launch and the loading screen). A session
|
||||
> recorded before keeps the overlay off rather than drawn out of step; gaps are still closed up on the frame axis, and
|
||||
> the note says how many when the overlay is on.
|
||||
> - **Distribution.** The histogram is binned over the 0.5th–99.5th percentile, not min–max (one 0.3 ms non-frame set the
|
||||
> axis to thousands of FPS), with the frames outside counted in a note, and its bars sit on their bins' centres (they
|
||||
> sat half a bin left: ScottPlot's bins are lower edges). The percentile curve is drawn only where ten frames lie
|
||||
> beyond a percentile on each side — FR-4.8's rule, generalised — so its 1% and 0.1% lows are marked exactly where
|
||||
> the stat cards publish them, and the single shortest interval no longer sets the axis; the 0–100 axis holds.
|
||||
> - **Sensors** (the tab and a new section of the summary window): power on a watt axis at the right, the second
|
||||
> plot is *Memory* (the game's VRAM, the adapter's, the system's RAM), a per-present VRAM of 0 is a present the sample
|
||||
> did not reach and is left out, the time axis says where its zero is, and every line has its own colour in both
|
||||
> themes (the light theme drew power and CPU temperature in one gold). **A session that was not hooked charts its
|
||||
> sensors** — kept since 2026-09-22, shown nowhere until now.
|
||||
> - **The game page follows the Agent while it is shown**: a `SessionCompleted` for this game reloads it
|
||||
> (`GameDetailViewModel.Attach` / `Detach` on the page's Loaded / Unloaded; the link is a singleton and must not hold the
|
||||
> page). Its sessions, trend and header were the ones it opened with.
|
||||
> **FR-5.3:** `Charts/Decimator` — every bucket's min and max in order, ≤ 4000 points per series per draw, a
|
||||
> 500k-point series keeps its spike and its dip (`DecimatorTests`). Zoom and pan are ScottPlot's.
|
||||
> **FR-9:** `SessionExporter` — the CSV with `03_METRICS` §Export schema's column line verbatim and the `#`
|
||||
|
||||
@@ -1613,6 +1613,15 @@ only be refused, never the finding (FR-2.2).
|
||||
struct): C puts typedefs and functions in one namespace, and MSVC's error names neither clearly.
|
||||
- **The driver profile is a configuration.** `sessions.driver_profile` says what the NVIDIA App set; it never feeds
|
||||
the upscaler ladder or the factor. The bridge has no DRS writer, and a PR that adds one is a different product.
|
||||
- **Present-to-present is not a frame time on a frame-generation title.** DLSS FG submits its generated frames in a
|
||||
burst (measured: half a millisecond apart on the owner's Onimusha capture); anything over `ft_app` — lows, median,
|
||||
σ, stutter, the charts' default line — is application frame to application frame (`FrameTimeSeries.ApplicationFrames`,
|
||||
`SessionSeriesLoader.ApplicationFrames`).
|
||||
- **A gap is neither a frame time nor time** (beta.8): `FrameTimeSeries.MeasuredSeconds` and `FgWindow.Seconds` leave
|
||||
out every interval a gap sat in. A pause is a gap (`CaptureSession.MarkResume`); do not mark one any other way.
|
||||
- **Reading the owner's ledger for evidence: copy it (`ledger.db` + `-wal`) to the scratchpad and read the copy** with
|
||||
plain SQLite — never a FrameLedger binary against the data folder. `capture_tier` is an integer (1 = hooked); the
|
||||
frame flags are Generated = 1, Gap = 4.
|
||||
- **A view model that loads in its constructor raises its events to nobody** until the page subscribes; a page must
|
||||
draw what the view model already holds when it is made (the Trend tab was blank on every first open).
|
||||
- **`Axes.DateTimeTicksBottom()` replaces the bottom axis**: call it before the theme and the label, or both are lost.
|
||||
|
||||
@@ -57,6 +57,25 @@ public sealed record ChartPalette(
|
||||
return new ChartPalette(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10], c[11], c[12]);
|
||||
}
|
||||
|
||||
/// <summary>The colour a key names — how a chart that assigns palette entries to series by name reads them (<c>SensorsChart</c>).</summary>
|
||||
public Color ByKey(string key) => key switch
|
||||
{
|
||||
"Chart_Figure" => Figure,
|
||||
"Chart_Data" => Data,
|
||||
"Chart_Axis" => Axis,
|
||||
"Chart_Grid" => Grid,
|
||||
"Chart_Native" => Native,
|
||||
"Chart_Displayed" => Displayed,
|
||||
"Chart_Stutter" => Stutter,
|
||||
"Chart_StutterPso" => StutterPso,
|
||||
"Chart_Sensor" => Sensor,
|
||||
"Chart_SensorSecondary" => SensorSecondary,
|
||||
"Chart_Segment" => Segment,
|
||||
"Chart_Histogram" => Histogram,
|
||||
"Chart_Percentile" => Percentile,
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(key), key, "not a chart palette key"),
|
||||
};
|
||||
|
||||
private static ChartPalette Load(ApplicationTheme theme)
|
||||
{
|
||||
string file = theme == ApplicationTheme.Light ? "ChartPalette.Light.xaml" : "ChartPalette.Dark.xaml";
|
||||
|
||||
@@ -1,10 +1,15 @@
|
||||
<UserControl x:Class="FrameLedger.App.Charts.DistributionChart"
|
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
|
||||
xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
|
||||
xmlns:sp="clr-namespace:ScottPlot.WPF;assembly=ScottPlot.WPF"
|
||||
MinHeight="240">
|
||||
<!-- FR-5.1: the FPS histogram and the percentile curve, side by side. -->
|
||||
<!-- FR-5.1: the FPS histogram and the percentile curve, side by side; the note says what the histogram's range left out (beta.8). -->
|
||||
<Grid>
|
||||
<Grid.RowDefinitions>
|
||||
<RowDefinition Height="*" />
|
||||
<RowDefinition Height="Auto" />
|
||||
</Grid.RowDefinitions>
|
||||
<Grid.ColumnDefinitions>
|
||||
<ColumnDefinition Width="*" />
|
||||
<ColumnDefinition Width="12" />
|
||||
@@ -12,5 +17,6 @@
|
||||
</Grid.ColumnDefinitions>
|
||||
<sp:WpfPlot x:Name="Histogram" Grid.Column="0" />
|
||||
<sp:WpfPlot x:Name="Percentiles" Grid.Column="2" />
|
||||
<ui:TextBlock x:Name="Note" Grid.Row="1" Grid.ColumnSpan="3" Margin="0,4,0,0" Appearance="Tertiary" TextWrapping="Wrap" Visibility="Collapsed" />
|
||||
</Grid>
|
||||
</UserControl>
|
||||
@@ -1,3 +1,5 @@
|
||||
using System.Globalization;
|
||||
using System.Windows;
|
||||
using System.Windows.Controls;
|
||||
using ScottPlot;
|
||||
using ScottPlot.Plottables;
|
||||
@@ -7,8 +9,10 @@ namespace FrameLedger.App.Charts;
|
||||
/// <summary>
|
||||
/// FR-5.1's distribution: a histogram of instantaneous FPS over application frames, and the percentile curve —
|
||||
/// FPS at each percentile of frametime under <c>03_METRICS</c>' linear method (<c>Domain.Metrics.Percentile</c>),
|
||||
/// so the 1% and 0.1% lows on the stat cards are two points on this curve.
|
||||
/// so the 1% and 0.1% lows on the stat cards are two points on this curve, marked where the session has the frames for
|
||||
/// them (<see cref="PercentileCurve"/>).
|
||||
/// </summary>
|
||||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime")]
|
||||
public partial class DistributionChart : UserControl
|
||||
{
|
||||
private const int _bins = 60;
|
||||
@@ -22,38 +26,46 @@ public partial class DistributionChart : UserControl
|
||||
|
||||
public ScottPlot.Plot HistogramPlot => Histogram.Plot;
|
||||
|
||||
/// <summary>The percentile plot, for a test's look at its axis.</summary>
|
||||
public ScottPlot.Plot PercentilePlot => Percentiles.Plot;
|
||||
|
||||
public void Show(SessionSeries? series)
|
||||
{
|
||||
DrawHistogram(series);
|
||||
int outside = DrawHistogram(series);
|
||||
DrawPercentiles(series);
|
||||
Note.Text = outside > 0 ? string.Format(CultureInfo.CurrentCulture, Strings.Chart_Note_OutsideRange_Format, outside) : string.Empty;
|
||||
Note.Visibility = outside > 0 ? Visibility.Visible : Visibility.Collapsed;
|
||||
}
|
||||
|
||||
private void DrawHistogram(SessionSeries? series)
|
||||
/// <summary>Draws the histogram; the frames its range left out.</summary>
|
||||
private int DrawHistogram(SessionSeries? series)
|
||||
{
|
||||
ScottPlot.Plot plot = Histogram.Plot;
|
||||
plot.Clear();
|
||||
ChartTheme.Apply(plot);
|
||||
plot.XLabel(Strings.Chart_Axis_Fps);
|
||||
plot.YLabel(Strings.Chart_Axis_Count);
|
||||
int outside = 0;
|
||||
if (series is { AppFrameTimesMs.Length: > 1 })
|
||||
{
|
||||
double[] fps = [.. series.AppFrameTimesMs.Where(static f => f > 0).Select(static f => 1000.0 / f)];
|
||||
if (fps.Length > 1)
|
||||
FpsHistogram histogram = FpsHistogram.Of(series.AppFrameTimesMs, _bins);
|
||||
if (histogram.Centers.Length > 0)
|
||||
{
|
||||
var histogram = ScottPlot.Statistics.Histogram.WithBinCount(_bins, fps);
|
||||
BarPlot bars = plot.Add.Bars(histogram.Bins, histogram.Counts.Select(static c => (double)c));
|
||||
BarPlot bars = plot.Add.Bars(histogram.Centers, histogram.Counts);
|
||||
bars.Color = ChartTheme.Current.Histogram;
|
||||
foreach (Bar bar in bars.Bars)
|
||||
{
|
||||
bar.Size = histogram.FirstBinSize;
|
||||
bar.Size = histogram.BinWidth;
|
||||
bar.LineWidth = 0;
|
||||
}
|
||||
|
||||
outside = histogram.Outside;
|
||||
plot.Axes.AutoScale();
|
||||
}
|
||||
}
|
||||
|
||||
Histogram.Refresh();
|
||||
return outside;
|
||||
}
|
||||
|
||||
private void DrawPercentiles(SessionSeries? series)
|
||||
@@ -66,11 +78,24 @@ public partial class DistributionChart : UserControl
|
||||
if (series is { AppFrameTimesMs.Length: > 1 })
|
||||
{
|
||||
(double[] xs, double[] ys) = PercentileCurve.Of(series.AppFrameTimesMs);
|
||||
Scatter line = plot.Add.ScatterLine(xs, ys, ChartTheme.Current.Percentile);
|
||||
line.LineWidth = 2;
|
||||
line.LegendText = Strings.Chart_Series_Percentile;
|
||||
plot.Axes.SetLimitsX(0, 100);
|
||||
if (xs.Length > 0)
|
||||
{
|
||||
Scatter line = plot.Add.ScatterLine(xs, ys, ChartTheme.Current.Percentile);
|
||||
line.LineWidth = 2;
|
||||
line.LegendText = Strings.Chart_Series_Percentile;
|
||||
}
|
||||
|
||||
foreach ((double x, double fps, bool pointOne) in PercentileCurve.Lows(series.AppFrameTimesMs))
|
||||
{
|
||||
Scatter low = plot.Add.ScatterPoints(new[] { x }, new[] { fps }, ChartTheme.Current.Stutter);
|
||||
low.MarkerSize = 7;
|
||||
low.LegendText = pointOne ? Strings.Summary_Stat_P01Low : Strings.Summary_Stat_P1Low;
|
||||
}
|
||||
|
||||
// The axis is 0–100 whatever the curve covers: AutoScale first, then the X limits (AutoScale afterwards undid them).
|
||||
plot.Axes.AutoScale();
|
||||
plot.Axes.SetLimitsX(0, 100);
|
||||
plot.ShowLegend(Alignment.LowerLeft);
|
||||
}
|
||||
|
||||
Percentiles.Refresh();
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
using FrameLedger.Domain.Metrics;
|
||||
|
||||
namespace FrameLedger.App.Charts;
|
||||
|
||||
/// <summary>
|
||||
/// The distribution tab's histogram of instantaneous FPS over application frames (FR-5.1), binned over the 0.5th to the
|
||||
/// 99.5th percentile and drawn at each bin's CENTRE (beta.8). Binned over min to max, one frame of a fraction of a
|
||||
/// millisecond — a present that followed another by nothing — stretched the axis to thousands of FPS and squeezed every
|
||||
/// real frame into two bars; and a bar is drawn centred on its position, where ScottPlot's bins are lower edges, so every
|
||||
/// bar sat half a bin to the left of what it counted.
|
||||
/// </summary>
|
||||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1819:Properties should not return arrays", Justification = "a data carrier for ScottPlot, which draws double[]")]
|
||||
public sealed record FpsHistogram(double[] Centers, double[] Counts, double BinWidth, int Outside)
|
||||
{
|
||||
/// <summary>The share cut from each end before binning.</summary>
|
||||
public const double TailFraction = 0.005;
|
||||
|
||||
public static FpsHistogram Of(IReadOnlyList<double> appFrameTimesMs, int bins = 60)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(appFrameTimesMs);
|
||||
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(bins);
|
||||
double[] fps = [.. appFrameTimesMs.Where(static f => f > 0).Select(static f => 1000.0 / f)];
|
||||
if (fps.Length == 0)
|
||||
{
|
||||
return new FpsHistogram([], [], 0, 0);
|
||||
}
|
||||
|
||||
IReadOnlyList<double> sorted = Percentile.Sorted(fps);
|
||||
double lo = Percentile.Linear(sorted, TailFraction) ?? sorted[0];
|
||||
double hi = Percentile.Linear(sorted, 1 - TailFraction) ?? sorted[^1];
|
||||
if (hi - lo < 1e-9)
|
||||
{
|
||||
// Every frame at one rate: one bar, a frame per second wide, centred on it.
|
||||
return new FpsHistogram([lo], [fps.Length], 1, 0);
|
||||
}
|
||||
|
||||
double width = (hi - lo) / bins;
|
||||
var counts = new double[bins];
|
||||
int outside = 0;
|
||||
foreach (double v in fps)
|
||||
{
|
||||
if (v < lo || v > hi)
|
||||
{
|
||||
outside++;
|
||||
continue;
|
||||
}
|
||||
|
||||
counts[Math.Min(bins - 1, (int)((v - lo) / width))]++;
|
||||
}
|
||||
|
||||
double[] centers = [.. Enumerable.Range(0, bins).Select(b => lo + ((b + 0.5) * width))];
|
||||
return new FpsHistogram(centers, counts, width, outside);
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,17 @@
|
||||
<UserControl x:Class="FrameLedger.App.Charts.FrametimeChart"
|
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
|
||||
xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
|
||||
xmlns:sp="clr-namespace:ScottPlot.WPF;assembly=ScottPlot.WPF"
|
||||
MinHeight="260">
|
||||
<!-- 08_UI §Session summary / FR-5.1: the frametime timeline, min/max decimated (FR-5.3); zoom and pan are ScottPlot's. -->
|
||||
<sp:WpfPlot x:Name="Plot" />
|
||||
<!-- 08_UI §Session summary / FR-5.1: the frametime timeline, min/max decimated (FR-5.3); zoom and pan are ScottPlot's.
|
||||
The note above it says what the lines are not, when that is not obvious (beta.8). -->
|
||||
<Grid>
|
||||
<Grid.RowDefinitions>
|
||||
<RowDefinition Height="Auto" />
|
||||
<RowDefinition Height="*" />
|
||||
</Grid.RowDefinitions>
|
||||
<ui:TextBlock x:Name="Note" Grid.Row="0" Margin="0,0,0,4" Appearance="Tertiary" TextWrapping="Wrap" Visibility="Collapsed" />
|
||||
<sp:WpfPlot x:Name="Plot" Grid.Row="1" />
|
||||
</Grid>
|
||||
</UserControl>
|
||||
@@ -1,3 +1,5 @@
|
||||
using System.Globalization;
|
||||
using System.Windows;
|
||||
using System.Windows.Controls;
|
||||
using ScottPlot;
|
||||
using ScottPlot.Plottables;
|
||||
@@ -5,13 +7,17 @@ using ScottPlot.Plottables;
|
||||
namespace FrameLedger.App.Charts;
|
||||
|
||||
/// <summary>
|
||||
/// The frametime timeline (FR-5.1, FR-5.3, FR-5.4, FR-5.5): the application-frame series by default, the
|
||||
/// displayed (every present) series on request, stutter markers coloured by cause where the PSO count says so,
|
||||
/// the segment ribbon as translucent spans, and the sensor overlay on the right axis. Series are min/max
|
||||
/// decimated per draw; the raw arrays stay in the <see cref="SessionSeries"/>.
|
||||
/// The frametime timeline (FR-5.1, FR-5.3, FR-5.4, FR-5.5): the application-frame series by default, every present on
|
||||
/// request, stutter markers coloured by cause where the PSO count says so, the segment ribbon as translucent spans with
|
||||
/// their settings named, and the sensor overlay on the right axis. Series are min/max decimated per draw; the raw arrays
|
||||
/// stay in the <see cref="SessionSeries"/>.
|
||||
/// </summary>
|
||||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime")]
|
||||
public partial class FrametimeChart : UserControl
|
||||
{
|
||||
/// <summary>A segment narrower than this share of the axis keeps its shading and loses its label (the labels would overlap).</summary>
|
||||
private const double _labelledSegmentShare = 0.12;
|
||||
|
||||
private SessionSeries? _series;
|
||||
private bool _displayed;
|
||||
private bool _sensors;
|
||||
@@ -28,6 +34,9 @@ public partial class FrametimeChart : UserControl
|
||||
/// <summary>How many points the last draw put on the axes (a test's window into the decimation).</summary>
|
||||
public int DrawnPoints { get; private set; }
|
||||
|
||||
/// <summary>The note the last draw showed above the plot; empty when it had nothing to say.</summary>
|
||||
public string NoteText => Note.Text;
|
||||
|
||||
public void Show(SessionSeries? series, bool displayed, bool sensors)
|
||||
{
|
||||
_series = series;
|
||||
@@ -48,6 +57,37 @@ public partial class FrametimeChart : UserControl
|
||||
Redraw();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// What the lines are not, when that is not obvious (beta.8): a session whose presents were all generated is charted as
|
||||
/// presents; every present is timed at submission, which is not the display's cadence; and the overlay's sensors run ahead
|
||||
/// of the frames past every gap the time axis closes up.
|
||||
/// </summary>
|
||||
internal static string NoteFor(SessionSeries? series, bool displayed, bool sensors)
|
||||
{
|
||||
if (series is null || series.Presents == 0)
|
||||
{
|
||||
return string.Empty;
|
||||
}
|
||||
|
||||
var lines = new List<string>(2);
|
||||
if (series.NoApplicationFrames)
|
||||
{
|
||||
lines.Add(Strings.Chart_Note_NoApplicationFrames);
|
||||
}
|
||||
else if (displayed && series.HasGenerated)
|
||||
{
|
||||
lines.Add(Strings.Chart_Note_PresentsTiming);
|
||||
}
|
||||
|
||||
int gaps = series.Gap.Skip(1).Count(static g => g);
|
||||
if (sensors && series.SensorsAligned && gaps > 0)
|
||||
{
|
||||
lines.Add(string.Format(CultureInfo.CurrentCulture, Strings.Chart_Note_GapsClosed_Format, gaps));
|
||||
}
|
||||
|
||||
return string.Join(Environment.NewLine, lines);
|
||||
}
|
||||
|
||||
private void Redraw()
|
||||
{
|
||||
ScottPlot.Plot plot = Plot.Plot;
|
||||
@@ -56,6 +96,8 @@ public partial class FrametimeChart : UserControl
|
||||
ChartTheme.Apply(plot);
|
||||
plot.XLabel(Strings.Chart_Axis_Time);
|
||||
plot.YLabel(Strings.Chart_Axis_Frametime);
|
||||
Note.Text = NoteFor(_series, _displayed, _sensors);
|
||||
Note.Visibility = Note.Text.Length > 0 ? Visibility.Visible : Visibility.Collapsed;
|
||||
if (_series is null || _series.Presents == 0)
|
||||
{
|
||||
Plot.Refresh();
|
||||
@@ -63,26 +105,33 @@ public partial class FrametimeChart : UserControl
|
||||
}
|
||||
|
||||
ChartPalette p = ChartTheme.Current;
|
||||
bool generating = _series.HasGenerated && !_series.NoApplicationFrames;
|
||||
DrawSegments(plot, p);
|
||||
if (_displayed && _series.HasGenerated)
|
||||
if (_displayed && generating)
|
||||
{
|
||||
DrawSeries(plot, _series.TimesS, [.. _series.FrameTimesMs.Select(static f => (double)f)], p.Displayed, Strings.Chart_Series_Displayed);
|
||||
DrawPresents(plot, p);
|
||||
}
|
||||
|
||||
DrawSeries(plot, _series.AppTimesS, _series.AppFrameTimesMs, p.Native, Strings.Chart_Series_Native);
|
||||
DrawSeries(plot, _series.AppTimesS, _series.AppFrameTimesMs, p.Native, generating ? Strings.Chart_Series_AppFrames : Strings.Chart_Series_Presents);
|
||||
DrawStutter(plot, p);
|
||||
if (_sensors)
|
||||
if (_sensors && _series.SensorsAligned)
|
||||
{
|
||||
DrawSensors(plot, p);
|
||||
}
|
||||
|
||||
plot.Axes.AutoScale();
|
||||
LabelSegments(plot, p);
|
||||
plot.ShowLegend(Alignment.UpperRight);
|
||||
Plot.Refresh();
|
||||
}
|
||||
|
||||
private void DrawSeries(ScottPlot.Plot plot, double[] xs, double[] ys, Color color, string label)
|
||||
private void DrawSeries(ScottPlot.Plot plot, IReadOnlyList<double> xs, IReadOnlyList<double> ys, Color color, string label)
|
||||
{
|
||||
if (xs.Count == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
(double[] dx, double[] dy) = Decimator.MinMax(xs, ys);
|
||||
DrawnPoints += dx.Length;
|
||||
SignalXY line = plot.Add.SignalXY(dx, dy, color);
|
||||
@@ -90,6 +139,23 @@ public partial class FrametimeChart : UserControl
|
||||
line.LegendText = label;
|
||||
}
|
||||
|
||||
/// <summary>Every present but those after a gap, whose stored interval is 0 — not a frame, and it was drawn as a 0 ms one.</summary>
|
||||
private void DrawPresents(ScottPlot.Plot plot, ChartPalette p)
|
||||
{
|
||||
var xs = new List<double>(_series!.Presents);
|
||||
var ys = new List<double>(_series.Presents);
|
||||
for (int i = 0; i < _series.Presents; i++)
|
||||
{
|
||||
if (!_series.Gap[i])
|
||||
{
|
||||
xs.Add(_series.TimesS[i]);
|
||||
ys.Add(_series.FrameTimesMs[i]);
|
||||
}
|
||||
}
|
||||
|
||||
DrawSeries(plot, xs, ys, p.Displayed, Strings.Chart_Series_Displayed);
|
||||
}
|
||||
|
||||
private void DrawStutter(ScottPlot.Plot plot, ChartPalette p)
|
||||
{
|
||||
if (_series?.Stutter is null)
|
||||
@@ -152,6 +218,34 @@ public partial class FrametimeChart : UserControl
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Each segment's settings at its top-left corner (beta.8: the label was computed for every segment and drawn for none),
|
||||
/// where the segment is wide enough to hold it. Placed after the axes are scaled, at their top.
|
||||
/// </summary>
|
||||
private void LabelSegments(ScottPlot.Plot plot, ChartPalette p)
|
||||
{
|
||||
if (_series is null || _series.Segments.Count < 2)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
AxisLimits limits = plot.Axes.GetLimits();
|
||||
double width = limits.Right - limits.Left;
|
||||
foreach (SegmentSpan segment in _series.Segments.Where(s => s.Label.Length > 0 && s.EndS - s.StartS >= width * _labelledSegmentShare))
|
||||
{
|
||||
Text label = plot.Add.Text(segment.Label, segment.StartS, limits.Top);
|
||||
label.LabelFontSize = 11;
|
||||
label.LabelFontColor = p.Axis;
|
||||
label.LabelAlignment = Alignment.UpperLeft;
|
||||
label.LabelOffsetX = 4;
|
||||
label.LabelOffsetY = 4;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// GPU temperature and load on the right axis, over the frames' span only: the sensors sit on the frames' axis when the
|
||||
/// blob said where the first present is (schema 0013), and ticks before it are the launch and the loading screen.
|
||||
/// </summary>
|
||||
private void DrawSensors(ScottPlot.Plot plot, ChartPalette p)
|
||||
{
|
||||
if (_series is null)
|
||||
@@ -162,14 +256,16 @@ public partial class FrametimeChart : UserControl
|
||||
IYAxis right = plot.Axes.Right;
|
||||
right.Label.Text = Strings.Chart_Axis_Sensor;
|
||||
int n = 0;
|
||||
double end = _series.DurationS;
|
||||
foreach (SensorSeries sensor in _series.Sensors.Where(static s => s.Name is "gpu_temp" or "gpu_load"))
|
||||
{
|
||||
if (sensor.TimesS.Length == 0)
|
||||
int[] inside = [.. Enumerable.Range(0, sensor.TimesS.Length).Where(i => sensor.TimesS[i] >= 0 && sensor.TimesS[i] <= end)];
|
||||
if (inside.Length == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
(double[] dx, double[] dy) = Decimator.MinMax(sensor.TimesS, sensor.Values, 1000);
|
||||
(double[] dx, double[] dy) = Decimator.MinMax([.. inside.Select(i => sensor.TimesS[i])], [.. inside.Select(i => sensor.Values[i])], 1000);
|
||||
DrawnPoints += dx.Length;
|
||||
Scatter line = plot.Add.ScatterLine(dx, dy, n++ == 0 ? p.Sensor : p.SensorSecondary);
|
||||
line.LineWidth = 1;
|
||||
|
||||
@@ -2,9 +2,22 @@ using FrameLedger.Domain.Metrics;
|
||||
|
||||
namespace FrameLedger.App.Charts;
|
||||
|
||||
/// <summary>FPS at each percentile (0…100) of frametime, under <c>03_METRICS</c>' linear method — the distribution tab's curve and Compare's overlay.</summary>
|
||||
/// <summary>
|
||||
/// FPS at each percentile of frametime, under <c>03_METRICS</c>' linear method — the distribution tab's curve and Compare's
|
||||
/// overlay — drawn only where the session has the frames to say it (beta.8).
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <b>A percentile is drawn when at least <see cref="FramesBeyond"/> frames lie beyond it on each side</b> — FR-4.8's rule
|
||||
/// generalised: the 1% low (the 99th percentile) needs 1,000 frames and the 0.1% low (the 99.9th) 10,000, which is exactly
|
||||
/// ten frames beyond each. The curve drew 0 to 100 whatever the count: its 100th point was the single worst frame, its 0th
|
||||
/// the single shortest interval — thousands of FPS that set the axis for every other point — and its 99th was a 1% low the
|
||||
/// stat card beside it refused to publish.
|
||||
/// </remarks>
|
||||
public static class PercentileCurve
|
||||
{
|
||||
/// <summary>Frames that must lie beyond a percentile, on each side, for it to be drawn.</summary>
|
||||
public const int FramesBeyond = 10;
|
||||
|
||||
public static (double[] Xs, double[] Ys) Of(IReadOnlyList<double> appFrameTimesMs)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(appFrameTimesMs);
|
||||
@@ -14,15 +27,57 @@ public static class PercentileCurve
|
||||
}
|
||||
|
||||
IReadOnlyList<double> sorted = Percentile.Sorted(appFrameTimesMs);
|
||||
var xs = new double[101];
|
||||
var ys = new double[101];
|
||||
for (int i = 0; i <= 100; i++)
|
||||
var xs = new List<double>(103);
|
||||
var ys = new List<double>(103);
|
||||
foreach (double p in Percents())
|
||||
{
|
||||
xs[i] = i;
|
||||
double? ft = Percentile.Linear(sorted, i / 100.0);
|
||||
ys[i] = ft is > 0 ? 1000.0 / ft.Value : 0;
|
||||
if (Supported(sorted.Count, p) && Fps(sorted, p) is double fps)
|
||||
{
|
||||
xs.Add(p);
|
||||
ys.Add(fps);
|
||||
}
|
||||
}
|
||||
|
||||
return (xs, ys);
|
||||
return ([.. xs], [.. ys]);
|
||||
}
|
||||
|
||||
/// <summary>The 1% and 0.1% lows as points on the curve (x 99 and 99.9), each only where the session has the frames for it.</summary>
|
||||
public static IReadOnlyList<(double X, double Fps, bool PointOne)> Lows(IReadOnlyList<double> appFrameTimesMs)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(appFrameTimesMs);
|
||||
IReadOnlyList<double> sorted = Percentile.Sorted(appFrameTimesMs);
|
||||
var lows = new List<(double, double, bool)>(2);
|
||||
if (Supported(sorted.Count, 99) && Fps(sorted, 99) is double p1)
|
||||
{
|
||||
lows.Add((99, p1, false));
|
||||
}
|
||||
|
||||
if (Supported(sorted.Count, 99.9) && Fps(sorted, 99.9) is double p01)
|
||||
{
|
||||
lows.Add((99.9, p01, true));
|
||||
}
|
||||
|
||||
return lows;
|
||||
}
|
||||
|
||||
/// <summary>At least <see cref="FramesBeyond"/> of <paramref name="frames"/> lie beyond <paramref name="percent"/> on each side.</summary>
|
||||
public static bool Supported(int frames, double percent) =>
|
||||
frames * Math.Min(percent, 100 - percent) / 100.0 >= FramesBeyond - 1e-9;
|
||||
|
||||
/// <summary>0, 0.1, 1 … 99, 99.9, 100 — in order, because the curve is drawn as a line through them.</summary>
|
||||
private static IEnumerable<double> Percents()
|
||||
{
|
||||
yield return 0;
|
||||
yield return 0.1;
|
||||
for (int i = 1; i <= 99; i++)
|
||||
{
|
||||
yield return i;
|
||||
}
|
||||
|
||||
yield return 99.9;
|
||||
yield return 100;
|
||||
}
|
||||
|
||||
private static double? Fps(IReadOnlyList<double> sorted, double percent) =>
|
||||
Percentile.Linear(sorted, percent / 100.0) is > 0 and double ft ? 1000.0 / ft : null;
|
||||
}
|
||||
@@ -5,12 +5,32 @@ using ScottPlot.Plottables;
|
||||
namespace FrameLedger.App.Charts;
|
||||
|
||||
/// <summary>
|
||||
/// The Sensors tab: GPU core / hotspot temperature and load / power on one plot (°C and % left, W right),
|
||||
/// and VRAM on another — the game's own usage (the per-present <c>vram_proc</c> blob, a held 1 Hz sample)
|
||||
/// and the adapter-wide figure (the <c>vram_adapter</c> sensor) as two differently-labelled series.
|
||||
/// The Sensors tab: GPU core / hotspot temperature, load, CPU temperature and load on one plot (°C and % left) with the GPU's
|
||||
/// power on a watt axis at the right, and memory on another — the game's own VRAM (the per-present <c>vram_proc</c> blob, a
|
||||
/// held 1 Hz sample), the adapter-wide VRAM (the <c>vram_adapter</c> sensor) and the system's RAM as differently-labelled
|
||||
/// series. Since beta.8 it draws a session that was not hooked too: its sensors are all it has.
|
||||
/// </summary>
|
||||
public partial class SensorsChart : UserControl
|
||||
{
|
||||
/// <summary>The temperatures-and-load plot's series, each with the palette key it is drawn in and whether it is on the watt axis.</summary>
|
||||
internal static readonly IReadOnlyList<(string Series, string PaletteKey, bool Watts)> TempsPlot =
|
||||
[
|
||||
("gpu_temp", "Chart_Sensor", false),
|
||||
("gpu_hotspot", "Chart_Stutter", false),
|
||||
("gpu_load", "Chart_Native", false),
|
||||
("gpu_power", "Chart_SensorSecondary", true),
|
||||
("cpu_temp", "Chart_Percentile", false),
|
||||
("cpu_load", "Chart_Displayed", false),
|
||||
];
|
||||
|
||||
/// <summary>The memory plot's series and their palette keys; <c>vram_proc</c> is the per-present blob, the others sensors.</summary>
|
||||
internal static readonly IReadOnlyList<(string Series, string PaletteKey)> MemoryPlot =
|
||||
[
|
||||
("vram_proc", "Chart_Displayed"),
|
||||
("vram_adapter", "Chart_SensorSecondary"),
|
||||
("ram_mb", "Chart_Percentile"),
|
||||
];
|
||||
|
||||
public SensorsChart()
|
||||
{
|
||||
InitializeComponent();
|
||||
@@ -20,29 +40,38 @@ public partial class SensorsChart : UserControl
|
||||
|
||||
public int DrawnSeries { get; private set; }
|
||||
|
||||
/// <summary>The temperatures plot, for a test's look at its axes.</summary>
|
||||
public ScottPlot.Plot TempsPlotView => Temps.Plot;
|
||||
|
||||
public void Show(SessionSeries? series)
|
||||
{
|
||||
DrawnSeries = 0;
|
||||
DrawTemps(series);
|
||||
DrawVram(series);
|
||||
DrawMemory(series);
|
||||
}
|
||||
|
||||
/// <summary>The time axis says where its zero is: the first frame when the sensors sit on the frames' axis, the session's start otherwise.</summary>
|
||||
internal static string TimeAxisLabel(SessionSeries? series) =>
|
||||
series is { SensorsAligned: true, Presents: > 0 } ? Strings.Chart_Axis_TimeFromFirstFrame : Strings.Chart_Axis_TimeFromStart;
|
||||
|
||||
private void DrawTemps(SessionSeries? series)
|
||||
{
|
||||
ScottPlot.Plot plot = Temps.Plot;
|
||||
plot.Clear();
|
||||
ChartTheme.Apply(plot);
|
||||
plot.XLabel(Strings.Chart_Axis_Time);
|
||||
plot.XLabel(TimeAxisLabel(series));
|
||||
plot.YLabel(Strings.Chart_Axis_Sensor);
|
||||
if (series is not null)
|
||||
{
|
||||
ChartPalette p = ChartTheme.Current;
|
||||
Line(plot, series, "gpu_temp", Strings.Sensors_Series_GpuTemp, p.Sensor, null);
|
||||
Line(plot, series, "gpu_hotspot", Strings.Sensors_Series_GpuHotspot, p.Stutter, null);
|
||||
Line(plot, series, "gpu_load", Strings.Sensors_Series_GpuLoad, p.Native, null);
|
||||
Line(plot, series, "gpu_power", Strings.Sensors_Series_GpuPower, p.SensorSecondary, plot.Axes.Right);
|
||||
Line(plot, series, "cpu_temp", Strings.Sensors_Series_CpuTemp, p.Percentile, null);
|
||||
Line(plot, series, "cpu_load", Strings.Sensors_Series_CpuLoad, p.Displayed, null);
|
||||
foreach ((string name, string key, bool watts) in TempsPlot)
|
||||
{
|
||||
if (Line(plot, series, name, Label(name), p.ByKey(key), watts ? plot.Axes.Right : null) && watts)
|
||||
{
|
||||
plot.Axes.Right.Label.Text = Strings.Sensors_Axis_Watts;
|
||||
}
|
||||
}
|
||||
|
||||
plot.Axes.AutoScale();
|
||||
plot.ShowLegend(Alignment.UpperRight);
|
||||
}
|
||||
@@ -50,28 +79,19 @@ public partial class SensorsChart : UserControl
|
||||
Temps.Refresh();
|
||||
}
|
||||
|
||||
private void DrawVram(SessionSeries? series)
|
||||
private void DrawMemory(SessionSeries? series)
|
||||
{
|
||||
ScottPlot.Plot plot = Vram.Plot;
|
||||
plot.Clear();
|
||||
ChartTheme.Apply(plot);
|
||||
plot.XLabel(Strings.Chart_Axis_Time);
|
||||
plot.XLabel(TimeAxisLabel(series));
|
||||
plot.YLabel(Strings.Sensors_Axis_Mb);
|
||||
if (series is not null)
|
||||
{
|
||||
ChartPalette p = ChartTheme.Current;
|
||||
if (series.VramProcMb is { Length: > 0 } proc)
|
||||
{
|
||||
int n = Math.Min(proc.Length, series.TimesS.Length);
|
||||
(double[] xs, double[] ys) = Decimator.MinMax(series.TimesS[..n], [.. proc.Take(n).Select(static v => (double)v)], 1000);
|
||||
Scatter line = plot.Add.ScatterLine(xs, ys, p.Displayed);
|
||||
line.LineWidth = 1;
|
||||
line.LegendText = Strings.Sensors_Series_VramProcess;
|
||||
DrawnSeries++;
|
||||
}
|
||||
|
||||
Line(plot, series, "vram_adapter", Strings.Sensors_Series_VramAdapter, p.SensorSecondary, null);
|
||||
Line(plot, series, "ram_mb", Strings.Sensors_Series_Ram, p.Percentile, null);
|
||||
DrawProcessVram(plot, series, p.ByKey(MemoryPlot[0].PaletteKey));
|
||||
Line(plot, series, "vram_adapter", Strings.Sensors_Series_VramAdapter, p.ByKey(MemoryPlot[1].PaletteKey), null);
|
||||
Line(plot, series, "ram_mb", Strings.Sensors_Series_Ram, p.ByKey(MemoryPlot[2].PaletteKey), null);
|
||||
plot.Axes.AutoScale();
|
||||
plot.ShowLegend(Alignment.UpperRight);
|
||||
}
|
||||
@@ -79,12 +99,49 @@ public partial class SensorsChart : UserControl
|
||||
Vram.Refresh();
|
||||
}
|
||||
|
||||
private void Line(ScottPlot.Plot plot, SessionSeries series, string name, string label, Color color, IYAxis? axis)
|
||||
/// <summary>
|
||||
/// The game's own VRAM, per present on the frames' axis — a 0 is a present the sample did not reach (the record's zero,
|
||||
/// SessionFinalizer.Series), never a reading, and is left out (beta.8).
|
||||
/// </summary>
|
||||
private void DrawProcessVram(ScottPlot.Plot plot, SessionSeries series, Color color)
|
||||
{
|
||||
if (series.VramProcMb is not { Length: > 0 } proc)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int n = Math.Min(proc.Length, series.TimesS.Length);
|
||||
int[] read = [.. Enumerable.Range(0, n).Where(i => proc[i] > 0)];
|
||||
if (read.Length == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
(double[] xs, double[] ys) = Decimator.MinMax([.. read.Select(i => series.TimesS[i])], [.. read.Select(i => (double)proc[i])], 1000);
|
||||
Scatter line = plot.Add.ScatterLine(xs, ys, color);
|
||||
line.LineWidth = 1;
|
||||
line.LegendText = Strings.Sensors_Series_VramProcess;
|
||||
DrawnSeries++;
|
||||
}
|
||||
|
||||
private static string Label(string series) => series switch
|
||||
{
|
||||
"gpu_temp" => Strings.Sensors_Series_GpuTemp,
|
||||
"gpu_hotspot" => Strings.Sensors_Series_GpuHotspot,
|
||||
"gpu_load" => Strings.Sensors_Series_GpuLoad,
|
||||
"gpu_power" => Strings.Sensors_Series_GpuPower,
|
||||
"cpu_temp" => Strings.Sensors_Series_CpuTemp,
|
||||
"cpu_load" => Strings.Sensors_Series_CpuLoad,
|
||||
_ => series,
|
||||
};
|
||||
|
||||
/// <summary>Draws one sensor series if the session has it; whether it did.</summary>
|
||||
private bool Line(ScottPlot.Plot plot, SessionSeries series, string name, string label, Color color, IYAxis? axis)
|
||||
{
|
||||
SensorSeries? sensor = series.Sensors.FirstOrDefault(s => string.Equals(s.Name, name, StringComparison.Ordinal));
|
||||
if (sensor is null || sensor.TimesS.Length == 0)
|
||||
{
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
|
||||
(double[] xs, double[] ys) = Decimator.MinMax(sensor.TimesS, sensor.Values, 1000);
|
||||
@@ -97,5 +154,6 @@ public partial class SensorsChart : UserControl
|
||||
}
|
||||
|
||||
DrawnSeries++;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,15 +1,20 @@
|
||||
namespace FrameLedger.App.Charts;
|
||||
|
||||
/// <summary>
|
||||
/// A session's per-present series decoded for the charts and the export: every present in drained order with its
|
||||
/// time from the session start, its interval, whether it was generated, whether a gap sat before it; the
|
||||
/// application-frame view (non-generated, non-gap) with the stutter flags over it; the segments on the time
|
||||
/// axis; the sensor series. Decoded once per window, decimated per draw.
|
||||
/// A session's per-present series decoded for the charts and the export: every present of the charted stream in drained
|
||||
/// order with its time from the stream's first present, its interval, whether it was generated, whether a gap sat before
|
||||
/// it; the application-frame view with the stutter flags over it; the segments on the time axis; the sensor series.
|
||||
/// Decoded once per window, decimated per draw.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <b>One stream (beta.8).</b> A session that presented to more than one swapchain is charted on the one its statistics are
|
||||
/// over (<c>SegmentBuilder.DominantStream</c>: identified first, then the most presents) — the stored intervals are per
|
||||
/// swapchain, and interleaving two streams' intervals on one time axis drew neither.
|
||||
/// </remarks>
|
||||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1819:Properties should not return arrays", Justification = "a data carrier for the charts: ScottPlot draws double[] and a 500k-frame session is decimated per draw, not copied per read")]
|
||||
public sealed record SessionSeries
|
||||
{
|
||||
/// <summary>Seconds from the first present, per present (a cumulative sum of the intervals).</summary>
|
||||
/// <summary>Seconds from the stream's first present, per present (a cumulative sum of the intervals; a gap adds none).</summary>
|
||||
public required double[] TimesS { get; init; }
|
||||
|
||||
/// <summary>The stored interval per present, ms; 0 on the first present and after a gap.</summary>
|
||||
@@ -37,23 +42,59 @@ public sealed record SessionSeries
|
||||
public ushort[]? RenderRes { get; init; }
|
||||
|
||||
// the application-frame view
|
||||
|
||||
/// <summary>The time of each application frame's present, seconds.</summary>
|
||||
public required double[] AppTimesS { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// Each application frame's time, ms: from the previous application frame's present to its own (beta.8) — the generated
|
||||
/// presents between them add no interval, and a gap breaks the chain. Every present's interval where nothing was generated.
|
||||
/// </summary>
|
||||
public required double[] AppFrameTimesMs { get; init; }
|
||||
|
||||
/// <summary>Index into the per-present arrays for each application frame.</summary>
|
||||
public required int[] AppPresentIndex { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// Every present was generated — frame generation counted and no application frame's token arrived (the <c>no_evaluations</c>
|
||||
/// refusal) — so the application-frame view is every present instead, and the chart says so.
|
||||
/// </summary>
|
||||
public bool NoApplicationFrames { get; init; }
|
||||
|
||||
/// <summary>Per application frame, from <c>Domain.Metrics.StutterDetector</c>; null when the session is too short for the window.</summary>
|
||||
public bool[]? Stutter { get; init; }
|
||||
|
||||
public required IReadOnlyList<SegmentSpan> Segments { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// The sensor series. On the frames' axis — seconds from the first present, negative before it — when
|
||||
/// <see cref="SensorsAligned"/>; from the session's start otherwise.
|
||||
/// </summary>
|
||||
public required IReadOnlyList<SensorSeries> Sensors { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// The sensors are placed on the frames' time axis: the blob said where the first present sits on the sensors' clock
|
||||
/// (schema 0013). A session recorded before cannot draw them over its frames.
|
||||
/// </summary>
|
||||
public bool SensorsAligned { get; init; }
|
||||
|
||||
public int Presents => TimesS.Length;
|
||||
|
||||
public bool HasGenerated => Generated.Any(static g => g);
|
||||
|
||||
public double DurationS => TimesS.Length == 0 ? 0 : TimesS[^1];
|
||||
|
||||
/// <summary>A series with no frames: a session that was not hooked still has its sensors (beta.8).</summary>
|
||||
public static SessionSeries SensorsOnly(IReadOnlyList<SensorSeries> sensors) => new()
|
||||
{
|
||||
TimesS = [],
|
||||
FrameTimesMs = [],
|
||||
Generated = [],
|
||||
Gap = [],
|
||||
AppTimesS = [],
|
||||
AppFrameTimesMs = [],
|
||||
AppPresentIndex = [],
|
||||
Segments = [],
|
||||
Sensors = sensors,
|
||||
};
|
||||
}
|
||||
@@ -6,10 +6,11 @@ using FrameLedger.Infrastructure.Blobs;
|
||||
namespace FrameLedger.App.Charts;
|
||||
|
||||
/// <summary>
|
||||
/// Decodes one session's blobs into a <see cref="SessionSeries"/>: the frametime series with the gap and
|
||||
/// generated bits, the application-frame view with <c>StutterDetector</c> over it (the same rule the stored
|
||||
/// <c>stutter_count</c> came from), the segments mapped from frame index to seconds, and the sensors aligned to
|
||||
/// their <c>t_ms</c>. Null when the session has no frame blob (Tier 2, or swept by retention).
|
||||
/// Decodes one session's blobs into a <see cref="SessionSeries"/>: the charted stream's frametime series with the gap
|
||||
/// and generated bits, the application-frame view with <c>StutterDetector</c> over it (the rule the stored
|
||||
/// <c>stutter_count</c> came from), the segments mapped from frame index to seconds, and the sensors. Null when the
|
||||
/// session has no frame blob (Tier 2, or swept by retention); <see cref="LoadSensorsAsync"/> reads a Tier-2 session's
|
||||
/// sensors on their own.
|
||||
/// </summary>
|
||||
public sealed class SessionSeriesLoader
|
||||
{
|
||||
@@ -30,61 +31,165 @@ public sealed class SessionSeriesLoader
|
||||
return Decode(frames, segments, sensors);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The sensor series alone, timed from the session's start — what a session that was not hooked has to chart (beta.8: the
|
||||
/// Tier-2 row has kept its sensors since 2026-09-22, and no chart read them). Empty when none were recorded.
|
||||
/// </summary>
|
||||
public async Task<IReadOnlyList<SensorSeries>> LoadSensorsAsync(long sessionId, CancellationToken ct = default) =>
|
||||
DecodeSensors(await _sessions.FindSensorsAsync(sessionId, ct).ConfigureAwait(false), offsetS: 0);
|
||||
|
||||
public static SessionSeries Decode(FrameBlobs frames, IReadOnlyList<SegmentRow> segments, IReadOnlyList<SensorBlob> sensors)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(frames);
|
||||
ArgumentNullException.ThrowIfNull(segments);
|
||||
ArgumentNullException.ThrowIfNull(sensors);
|
||||
float[] frametimes = SeriesCodec.DecodeFloat32(frames.FrameTimes.ToArray());
|
||||
byte[] flags = SeriesCodec.DecodeBytes(frames.FrameFlags.ToArray());
|
||||
int n = Math.Min(frametimes.Length, flags.Length);
|
||||
float[] allFrametimes = SeriesCodec.DecodeFloat32(frames.FrameTimes.ToArray());
|
||||
byte[] allFlags = SeriesCodec.DecodeBytes(frames.FrameFlags.ToArray());
|
||||
int total = Math.Min(allFrametimes.Length, allFlags.Length);
|
||||
uint[]? swapchains = frames.SwapchainIds is { } ids ? SeriesCodec.DecodeUInt32(ids.ToArray()) : null;
|
||||
(int[] keep, uint? swapchain) = ChartedStream(total, swapchains);
|
||||
|
||||
float[] frametimes = Pick(allFrametimes, keep);
|
||||
byte[] flags = Pick(allFlags, keep);
|
||||
int n = keep.Length;
|
||||
var times = new double[n];
|
||||
var generated = new bool[n];
|
||||
var gap = new bool[n];
|
||||
double t = 0;
|
||||
var appTimes = new List<double>(n);
|
||||
var appFrametimes = new List<double>(n);
|
||||
var appIndex = new List<int>(n);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
t += frametimes[i] / 1000.0;
|
||||
times[i] = t;
|
||||
generated[i] = (flags[i] & (byte)FrameFlagBits.Generated) != 0;
|
||||
gap[i] = (flags[i] & (byte)FrameFlagBits.Gap) != 0;
|
||||
if (i > 0 && !generated[i] && !gap[i] && frametimes[i] > 0)
|
||||
{
|
||||
appTimes.Add(t);
|
||||
appFrametimes.Add(frametimes[i]);
|
||||
appIndex.Add(i);
|
||||
}
|
||||
}
|
||||
|
||||
(List<int> appIndex, List<double> appFrametimes, bool noApplicationFrames) = ApplicationFrames(frametimes, generated, gap);
|
||||
StutterResult? stutter = StutterDetector.Detect(appFrametimes);
|
||||
uint[]? frameIndex = frames.FrameIndex is { } fi ? SeriesCodec.DecodeUInt32(fi.ToArray()) : null;
|
||||
uint[]? frameIndex = frames.FrameIndex is { } fi ? PickOptional(SeriesCodec.DecodeUInt32(fi.ToArray()), keep) : null;
|
||||
double? offsetS = frames.FirstPresentMs / 1000.0;
|
||||
return new SessionSeries
|
||||
{
|
||||
TimesS = times,
|
||||
FrameTimesMs = frametimes.Length == n ? frametimes : frametimes[..n],
|
||||
FrameTimesMs = frametimes,
|
||||
Generated = generated,
|
||||
Gap = gap,
|
||||
FrameIndex = frameIndex,
|
||||
RtFlags = frames.RtFlags is { } rt ? SeriesCodec.DecodeBytes(rt.ToArray()) : null,
|
||||
DispatchRays = frames.DispatchRays is { } dr ? SeriesCodec.DecodeUInt32(dr.ToArray()) : null,
|
||||
PsoCreated = frames.PsoCreated is { } pso ? SeriesCodec.DecodeUInt16(pso.ToArray()) : null,
|
||||
VramProcMb = frames.VramProc is { } vram ? SeriesCodec.DecodeUInt32(vram.ToArray()) : null,
|
||||
LatencyUs = frames.LatencyUs is { } lat ? SeriesCodec.DecodeUInt32(lat.ToArray()) : null,
|
||||
RenderRes = frames.RenderRes is { } rr ? SeriesCodec.DecodeUInt16(rr.ToArray()) : null,
|
||||
AppTimesS = [.. appTimes],
|
||||
RtFlags = frames.RtFlags is { } rt ? PickOptional(SeriesCodec.DecodeBytes(rt.ToArray()), keep) : null,
|
||||
DispatchRays = frames.DispatchRays is { } dr ? PickOptional(SeriesCodec.DecodeUInt32(dr.ToArray()), keep) : null,
|
||||
PsoCreated = frames.PsoCreated is { } pso ? PickOptional(SeriesCodec.DecodeUInt16(pso.ToArray()), keep) : null,
|
||||
VramProcMb = frames.VramProc is { } vram ? PickOptional(SeriesCodec.DecodeUInt32(vram.ToArray()), keep) : null,
|
||||
LatencyUs = frames.LatencyUs is { } lat ? PickOptional(SeriesCodec.DecodeUInt32(lat.ToArray()), keep) : null,
|
||||
RenderRes = frames.RenderRes is { } rr ? PickQuads(SeriesCodec.DecodeUInt16(rr.ToArray()), keep) : null,
|
||||
AppTimesS = [.. appIndex.Select(i => times[i])],
|
||||
AppFrameTimesMs = [.. appFrametimes],
|
||||
AppPresentIndex = [.. appIndex],
|
||||
NoApplicationFrames = noApplicationFrames,
|
||||
Stutter = stutter is null ? null : [.. stutter.IsStutter],
|
||||
Segments = MapSegments(segments, times, frameIndex),
|
||||
Sensors = DecodeSensors(sensors),
|
||||
Segments = MapSegments([.. segments.Where(s => swapchain is null || s.SwapchainId == swapchain.Value)], times, frameIndex),
|
||||
Sensors = DecodeSensors(sensors, offsetS ?? 0),
|
||||
SensorsAligned = offsetS is not null,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The presents of the stream the charts draw — the one the session's statistics are over (<c>SegmentBuilder.DominantStream</c>:
|
||||
/// identified first, then the most presents) — as indices into the blob, and that stream's id; every present, and no id,
|
||||
/// when the blob held one stream.
|
||||
/// </summary>
|
||||
internal static (int[] Keep, uint? Swapchain) ChartedStream(int count, uint[]? swapchains)
|
||||
{
|
||||
if (swapchains is null || swapchains.Length < count)
|
||||
{
|
||||
return ([.. Enumerable.Range(0, count)], null);
|
||||
}
|
||||
|
||||
IReadOnlyList<int> keep = SegmentBuilder.DominantStream([.. Enumerable.Range(0, count)], i => swapchains[i]);
|
||||
return ([.. keep], keep.Count > 0 ? swapchains[keep[0]] : null);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The application-frame view: each application frame's time is from the previous application frame's present to its own —
|
||||
/// the generated presents between them add their intervals to it, never an interval of their own — and a gap breaks the
|
||||
/// chain. Where every present was generated, every present's interval, and the flag that says so.
|
||||
/// </summary>
|
||||
internal static (List<int> Index, List<double> FrametimesMs, bool NoApplicationFrames) ApplicationFrames(float[] frametimes, bool[] generated, bool[] gap)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(frametimes);
|
||||
ArgumentNullException.ThrowIfNull(generated);
|
||||
ArgumentNullException.ThrowIfNull(gap);
|
||||
bool noApplicationFrames = generated.Length > 0 && generated.All(static g => g);
|
||||
var index = new List<int>(frametimes.Length);
|
||||
var ms = new List<double>(frametimes.Length);
|
||||
bool chain = false;
|
||||
double sinceApplicationFrame = 0;
|
||||
for (int i = 0; i < frametimes.Length; i++)
|
||||
{
|
||||
if (gap[i])
|
||||
{
|
||||
chain = false;
|
||||
sinceApplicationFrame = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
sinceApplicationFrame += frametimes[i];
|
||||
}
|
||||
|
||||
if (generated[i] && !noApplicationFrames)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (chain && sinceApplicationFrame > 0)
|
||||
{
|
||||
index.Add(i);
|
||||
ms.Add(sinceApplicationFrame);
|
||||
}
|
||||
|
||||
chain = true;
|
||||
sinceApplicationFrame = 0;
|
||||
}
|
||||
|
||||
return (index, ms, noApplicationFrames);
|
||||
}
|
||||
|
||||
private static T[] Pick<T>(T[] values, int[] keep)
|
||||
{
|
||||
if (keep.Length == values.Length)
|
||||
{
|
||||
return values;
|
||||
}
|
||||
|
||||
var picked = new T[keep.Length];
|
||||
for (int i = 0; i < keep.Length; i++)
|
||||
{
|
||||
picked[i] = values[keep[i]];
|
||||
}
|
||||
|
||||
return picked;
|
||||
}
|
||||
|
||||
/// <summary>A per-present series the blob may have written shorter than the frames: only the kept presents it covers.</summary>
|
||||
private static T[] PickOptional<T>(T[] values, int[] keep) => keep.Length == values.Length ? values : [.. keep.Where(i => i < values.Length).Select(i => values[i])];
|
||||
|
||||
private static ushort[] PickQuads(ushort[] values, int[] keep)
|
||||
{
|
||||
if (keep.Length * 4 == values.Length)
|
||||
{
|
||||
return values;
|
||||
}
|
||||
|
||||
var picked = new List<ushort>(keep.Length * 4);
|
||||
foreach (int i in keep.Where(i => (i * 4) + 3 < values.Length))
|
||||
{
|
||||
picked.AddRange(values.AsSpan(i * 4, 4).ToArray());
|
||||
}
|
||||
|
||||
return [.. picked];
|
||||
}
|
||||
|
||||
/// <summary>A segment's <c>start_frame</c>/<c>end_frame</c> are frame indices; the present at that index (or the nearest) gives the seconds.</summary>
|
||||
private static IReadOnlyList<SegmentSpan> MapSegments(IReadOnlyList<SegmentRow> segments, double[] times, uint[]? frameIndex)
|
||||
private static List<SegmentSpan> MapSegments(IReadOnlyList<SegmentRow> segments, double[] times, uint[]? frameIndex)
|
||||
{
|
||||
if (times.Length == 0)
|
||||
{
|
||||
@@ -125,7 +230,11 @@ public sealed class SessionSeriesLoader
|
||||
return string.Join(" · ", new[] { upscaler, resolution, fg }.Where(static x => x.Length > 0));
|
||||
}
|
||||
|
||||
private static List<SensorSeries> DecodeSensors(IReadOnlyList<SensorBlob> sensors)
|
||||
/// <summary>
|
||||
/// Every sensor series against <c>t_ms</c> less <paramref name="offsetS"/> — the first present's place on the sensors'
|
||||
/// clock, so they share the frames' axis (schema 0013) — and −1 dropped: a tick with no reading, never a zero.
|
||||
/// </summary>
|
||||
private static List<SensorSeries> DecodeSensors(IReadOnlyList<SensorBlob> sensors, double offsetS)
|
||||
{
|
||||
SensorBlob? clock = sensors.FirstOrDefault(static s => string.Equals(s.Series, "t_ms", StringComparison.Ordinal));
|
||||
float[]? tMs = clock is null ? null : SeriesCodec.DecodeFloat32(clock.Data.ToArray());
|
||||
@@ -147,7 +256,7 @@ public sealed class SessionSeriesLoader
|
||||
continue; // SessionFinalizer.SensorMissing: a tick with no reading, never a zero
|
||||
}
|
||||
|
||||
xs.Add(tMs is not null && i < tMs.Length ? tMs[i] / 1000.0 : i / Math.Max(blob.Hz, 0.001));
|
||||
xs.Add((tMs is not null && i < tMs.Length ? tMs[i] / 1000.0 : i / Math.Max(blob.Hz, 0.001)) - offsetS);
|
||||
ys.Add(values[i]);
|
||||
}
|
||||
|
||||
|
||||
@@ -299,9 +299,10 @@
|
||||
</TabItem>
|
||||
<TabItem Header="{x:Static vm:GameDetailViewModel.TabSensors}">
|
||||
<StackPanel Margin="0,12,0,0">
|
||||
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.SelectedNote}"
|
||||
Visibility="{Binding ViewModel.SelectedNote, Converter={StaticResource NullToCollapsed}}" />
|
||||
<charts:SensorsChart x:Name="Sensors" Visibility="{Binding ViewModel.SelectedHasSeries, Converter={StaticResource BoolToVis}}" />
|
||||
<!-- A session that was not hooked has its sensors (beta.8): the tab's own note and visibility, not the frames'. -->
|
||||
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.SensorsNote}"
|
||||
Visibility="{Binding ViewModel.SensorsNote, Converter={StaticResource NullToCollapsed}}" />
|
||||
<charts:SensorsChart x:Name="Sensors" Visibility="{Binding ViewModel.SelectedHasSensors, Converter={StaticResource BoolToVis}}" />
|
||||
</StackPanel>
|
||||
</TabItem>
|
||||
<TabItem Header="{x:Static vm:GameDetailViewModel.TabLatency}">
|
||||
|
||||
@@ -18,10 +18,12 @@ public partial class GameDetailPage : INavigableView<GameDetailViewModel>
|
||||
// nobody: the Trend tab was blank on every first open (beta.8). Draw what it holds now; a later load redraws.
|
||||
OnTrendPresented(this, EventArgs.Empty);
|
||||
OnSelectionPresented(this, EventArgs.Empty);
|
||||
Loaded += (_, _) => ViewModel.Attach();
|
||||
Unloaded += (_, _) =>
|
||||
{
|
||||
ViewModel.SelectionPresented -= OnSelectionPresented;
|
||||
ViewModel.TrendPresented -= OnTrendPresented;
|
||||
ViewModel.Detach();
|
||||
};
|
||||
}
|
||||
|
||||
@@ -31,7 +33,7 @@ public partial class GameDetailPage : INavigableView<GameDetailViewModel>
|
||||
{
|
||||
Frametime.Show(ViewModel.SelectedSeries, displayed: false, sensors: false);
|
||||
Distribution.Show(ViewModel.SelectedSeries);
|
||||
Sensors.Show(ViewModel.SelectedSeries);
|
||||
Sensors.Show(ViewModel.SelectedSensors);
|
||||
Latency.Show(ViewModel.SelectedSeries, ViewModel.SelectedSession?.Row.LatencyAvgUs, ViewModel.SelectedSession?.Row.LatencyP95Us);
|
||||
}
|
||||
|
||||
|
||||
@@ -110,6 +110,7 @@ public sealed class SessionExporter
|
||||
}
|
||||
|
||||
w.WriteLine("# note: vram_mb is a held 1 Hz sample, not a per-frame measurement; qpc_ms is relative to the first present");
|
||||
w.WriteLine("# note: one swapchain's presents, the stream the statistics are over; qpc_ms closes up every gap (frametime_ms 0)");
|
||||
}
|
||||
|
||||
private static SegmentRow? SegmentAt(SegmentRow[] byFrame, uint frameIndex)
|
||||
|
||||
Generated
+27
@@ -85,12 +85,20 @@ public static class Strings
|
||||
nameof(Chart_Axis_Percentile),
|
||||
nameof(Chart_Axis_Sensor),
|
||||
nameof(Chart_Axis_Time),
|
||||
nameof(Chart_Axis_TimeFromFirstFrame),
|
||||
nameof(Chart_Axis_TimeFromStart),
|
||||
nameof(Chart_Decimated_Format),
|
||||
nameof(Chart_Note_GapsClosed_Format),
|
||||
nameof(Chart_Note_NoApplicationFrames),
|
||||
nameof(Chart_Note_OutsideRange_Format),
|
||||
nameof(Chart_Note_PresentsTiming),
|
||||
nameof(Chart_Series_AppFrames),
|
||||
nameof(Chart_Series_Displayed),
|
||||
nameof(Chart_Series_GpuLoad),
|
||||
nameof(Chart_Series_GpuTemp),
|
||||
nameof(Chart_Series_Native),
|
||||
nameof(Chart_Series_Percentile),
|
||||
nameof(Chart_Series_Presents),
|
||||
nameof(Chart_Series_Stutter),
|
||||
nameof(Chart_Series_StutterPso),
|
||||
nameof(Chip_NA),
|
||||
@@ -544,6 +552,7 @@ public static class Strings
|
||||
nameof(Rules_Update_NoAgent),
|
||||
nameof(Rules_Update_Title),
|
||||
nameof(Sensors_Axis_Mb),
|
||||
nameof(Sensors_Axis_Watts),
|
||||
nameof(Sensors_Empty),
|
||||
nameof(Sensors_Series_CpuLoad),
|
||||
nameof(Sensors_Series_CpuTemp),
|
||||
@@ -907,8 +916,22 @@ public static class Strings
|
||||
|
||||
public static string Chart_Axis_Time => ResourceManager.GetString(nameof(Chart_Axis_Time), Culture) ?? nameof(Chart_Axis_Time);
|
||||
|
||||
public static string Chart_Axis_TimeFromFirstFrame => ResourceManager.GetString(nameof(Chart_Axis_TimeFromFirstFrame), Culture) ?? nameof(Chart_Axis_TimeFromFirstFrame);
|
||||
|
||||
public static string Chart_Axis_TimeFromStart => ResourceManager.GetString(nameof(Chart_Axis_TimeFromStart), Culture) ?? nameof(Chart_Axis_TimeFromStart);
|
||||
|
||||
public static string Chart_Decimated_Format => ResourceManager.GetString(nameof(Chart_Decimated_Format), Culture) ?? nameof(Chart_Decimated_Format);
|
||||
|
||||
public static string Chart_Note_GapsClosed_Format => ResourceManager.GetString(nameof(Chart_Note_GapsClosed_Format), Culture) ?? nameof(Chart_Note_GapsClosed_Format);
|
||||
|
||||
public static string Chart_Note_NoApplicationFrames => ResourceManager.GetString(nameof(Chart_Note_NoApplicationFrames), Culture) ?? nameof(Chart_Note_NoApplicationFrames);
|
||||
|
||||
public static string Chart_Note_OutsideRange_Format => ResourceManager.GetString(nameof(Chart_Note_OutsideRange_Format), Culture) ?? nameof(Chart_Note_OutsideRange_Format);
|
||||
|
||||
public static string Chart_Note_PresentsTiming => ResourceManager.GetString(nameof(Chart_Note_PresentsTiming), Culture) ?? nameof(Chart_Note_PresentsTiming);
|
||||
|
||||
public static string Chart_Series_AppFrames => ResourceManager.GetString(nameof(Chart_Series_AppFrames), Culture) ?? nameof(Chart_Series_AppFrames);
|
||||
|
||||
public static string Chart_Series_Displayed => ResourceManager.GetString(nameof(Chart_Series_Displayed), Culture) ?? nameof(Chart_Series_Displayed);
|
||||
|
||||
public static string Chart_Series_GpuLoad => ResourceManager.GetString(nameof(Chart_Series_GpuLoad), Culture) ?? nameof(Chart_Series_GpuLoad);
|
||||
@@ -919,6 +942,8 @@ public static class Strings
|
||||
|
||||
public static string Chart_Series_Percentile => ResourceManager.GetString(nameof(Chart_Series_Percentile), Culture) ?? nameof(Chart_Series_Percentile);
|
||||
|
||||
public static string Chart_Series_Presents => ResourceManager.GetString(nameof(Chart_Series_Presents), Culture) ?? nameof(Chart_Series_Presents);
|
||||
|
||||
public static string Chart_Series_Stutter => ResourceManager.GetString(nameof(Chart_Series_Stutter), Culture) ?? nameof(Chart_Series_Stutter);
|
||||
|
||||
public static string Chart_Series_StutterPso => ResourceManager.GetString(nameof(Chart_Series_StutterPso), Culture) ?? nameof(Chart_Series_StutterPso);
|
||||
@@ -1825,6 +1850,8 @@ public static class Strings
|
||||
|
||||
public static string Sensors_Axis_Mb => ResourceManager.GetString(nameof(Sensors_Axis_Mb), Culture) ?? nameof(Sensors_Axis_Mb);
|
||||
|
||||
public static string Sensors_Axis_Watts => ResourceManager.GetString(nameof(Sensors_Axis_Watts), Culture) ?? nameof(Sensors_Axis_Watts);
|
||||
|
||||
public static string Sensors_Empty => ResourceManager.GetString(nameof(Sensors_Empty), Culture) ?? nameof(Sensors_Empty);
|
||||
|
||||
public static string Sensors_Series_CpuLoad => ResourceManager.GetString(nameof(Sensors_Series_CpuLoad), Culture) ?? nameof(Sensors_Series_CpuLoad);
|
||||
|
||||
@@ -1462,11 +1462,11 @@
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Sensors_Temps_Header" xml:space="preserve">
|
||||
<value>温度と負荷</value>
|
||||
<value>温度・負荷・電力</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Sensors_Vram_Header" xml:space="preserve">
|
||||
<value>VRAM</value>
|
||||
<value>メモリ</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Tabs_SelectASession" xml:space="preserve">
|
||||
@@ -3077,4 +3077,40 @@
|
||||
<value>このゲームのセッションには、まだ {0} の値がありません。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Chart_Series_AppFrames" xml:space="preserve">
|
||||
<value>アプリケーションフレーム</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Chart_Series_Presents" xml:space="preserve">
|
||||
<value>提示</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Chart_Note_NoApplicationFrames" xml:space="preserve">
|
||||
<value>このセッションではフレーム生成がアプリケーションフレームを一つも数えなかったため、グラフはすべての提示を表示しています。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Chart_Note_PresentsTiming" xml:space="preserve">
|
||||
<value>提示はゲームが送信した時点で計時されます。生成フレームはまとめて送信され、後で均等な間隔で表示されることが多いため、「表示」の線は画面の表示間隔ではありません。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Chart_Note_GapsClosed_Format" xml:space="preserve">
|
||||
<value>時間軸は {0} 個の欠落(一時停止、または失われた記録)を詰めて表示するため、その後のセンサーの線はフレームより先行します。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Chart_Note_OutsideRange_Format" xml:space="preserve">
|
||||
<value>0.5〜99.5 パーセンタイルの範囲外にある {0} フレームはヒストグラムに描画されていません。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Chart_Axis_TimeFromFirstFrame" xml:space="preserve">
|
||||
<value>最初のフレームからの時間 (秒)</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Chart_Axis_TimeFromStart" xml:space="preserve">
|
||||
<value>セッション開始からの時間 (秒)</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Sensors_Axis_Watts" xml:space="preserve">
|
||||
<value>W</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
</root>
|
||||
@@ -1102,10 +1102,10 @@
|
||||
<value>VRAM used by this game (MB)</value>
|
||||
</data>
|
||||
<data name="Sensors_Temps_Header" xml:space="preserve">
|
||||
<value>Temperatures and load</value>
|
||||
<value>Temperatures, load and power</value>
|
||||
</data>
|
||||
<data name="Sensors_Vram_Header" xml:space="preserve">
|
||||
<value>VRAM</value>
|
||||
<value>Memory</value>
|
||||
</data>
|
||||
<data name="Tabs_SelectASession" xml:space="preserve">
|
||||
<value>Select a session in the Sessions tab to see it here.</value>
|
||||
@@ -2318,4 +2318,31 @@ The documents below are the full terms; this summary does not replace them.</val
|
||||
<data name="Trend_Empty_Format" xml:space="preserve">
|
||||
<value>No session of this game has a value for {0} yet.</value>
|
||||
</data>
|
||||
<data name="Chart_Series_AppFrames" xml:space="preserve">
|
||||
<value>Application frames</value>
|
||||
</data>
|
||||
<data name="Chart_Series_Presents" xml:space="preserve">
|
||||
<value>Presents</value>
|
||||
</data>
|
||||
<data name="Chart_Note_NoApplicationFrames" xml:space="preserve">
|
||||
<value>Frame generation counted no application frame in this session, so the chart shows every present.</value>
|
||||
</data>
|
||||
<data name="Chart_Note_PresentsTiming" xml:space="preserve">
|
||||
<value>Presents are timed when the game submits them. Generated frames are often submitted in a burst and shown later at an even pace, so the Displayed line is not the display's cadence.</value>
|
||||
</data>
|
||||
<data name="Chart_Note_GapsClosed_Format" xml:space="preserve">
|
||||
<value>The time axis closes up {0} gap(s) — a pause, or records that were lost — so the sensor lines run ahead of the frames after each.</value>
|
||||
</data>
|
||||
<data name="Chart_Note_OutsideRange_Format" xml:space="preserve">
|
||||
<value>{0} frame(s) outside the 0.5–99.5 percentile range are not drawn in the histogram.</value>
|
||||
</data>
|
||||
<data name="Chart_Axis_TimeFromFirstFrame" xml:space="preserve">
|
||||
<value>Time from the first frame (s)</value>
|
||||
</data>
|
||||
<data name="Chart_Axis_TimeFromStart" xml:space="preserve">
|
||||
<value>Time from the session's start (s)</value>
|
||||
</data>
|
||||
<data name="Sensors_Axis_Watts" xml:space="preserve">
|
||||
<value>W</value>
|
||||
</data>
|
||||
</root>
|
||||
@@ -1097,10 +1097,10 @@
|
||||
<value>VRAM game này dùng (MB)</value>
|
||||
</data>
|
||||
<data name="Sensors_Temps_Header" xml:space="preserve">
|
||||
<value>Nhiệt độ và tải</value>
|
||||
<value>Nhiệt độ, tải và công suất</value>
|
||||
</data>
|
||||
<data name="Sensors_Vram_Header" xml:space="preserve">
|
||||
<value>VRAM</value>
|
||||
<value>Bộ nhớ</value>
|
||||
</data>
|
||||
<data name="Tabs_SelectASession" xml:space="preserve">
|
||||
<value>Chọn một phiên ở thẻ Phiên chơi để xem tại đây.</value>
|
||||
@@ -2313,4 +2313,31 @@ Các tài liệu bên dưới là điều khoản đầy đủ; phần tóm tắ
|
||||
<data name="Trend_Empty_Format" xml:space="preserve">
|
||||
<value>Chưa có phiên nào của game này có giá trị cho {0}.</value>
|
||||
</data>
|
||||
<data name="Chart_Series_AppFrames" xml:space="preserve">
|
||||
<value>Khung hình ứng dụng</value>
|
||||
</data>
|
||||
<data name="Chart_Series_Presents" xml:space="preserve">
|
||||
<value>Lần xuất khung</value>
|
||||
</data>
|
||||
<data name="Chart_Note_NoApplicationFrames" xml:space="preserve">
|
||||
<value>Phiên này đếm frame generation nhưng không có khung hình ứng dụng nào, nên biểu đồ vẽ mọi lần xuất khung.</value>
|
||||
</data>
|
||||
<data name="Chart_Note_PresentsTiming" xml:space="preserve">
|
||||
<value>Mỗi lần xuất khung được đo lúc game gửi đi. Khung hình sinh thường được gửi dồn một lúc rồi mới hiển thị đều, nên đường Hiển thị không phải nhịp của màn hình.</value>
|
||||
</data>
|
||||
<data name="Chart_Note_GapsClosed_Format" xml:space="preserve">
|
||||
<value>Trục thời gian bỏ qua {0} khoảng trống (tạm dừng, hoặc bản ghi bị mất), nên đường cảm biến chạy trước khung hình sau mỗi khoảng.</value>
|
||||
</data>
|
||||
<data name="Chart_Note_OutsideRange_Format" xml:space="preserve">
|
||||
<value>{0} khung hình nằm ngoài khoảng phân vị 0,5–99,5 không được vẽ trong biểu đồ tần suất.</value>
|
||||
</data>
|
||||
<data name="Chart_Axis_TimeFromFirstFrame" xml:space="preserve">
|
||||
<value>Thời gian từ khung hình đầu (s)</value>
|
||||
</data>
|
||||
<data name="Chart_Axis_TimeFromStart" xml:space="preserve">
|
||||
<value>Thời gian từ lúc bắt đầu phiên (s)</value>
|
||||
</data>
|
||||
<data name="Sensors_Axis_Watts" xml:space="preserve">
|
||||
<value>W</value>
|
||||
</data>
|
||||
</root>
|
||||
@@ -17,5 +17,6 @@
|
||||
<Color x:Key="Chart_SensorSecondary">#FFE0C060</Color>
|
||||
<Color x:Key="Chart_Segment">#2260CDFF</Color>
|
||||
<Color x:Key="Chart_Histogram">#CC4CC2FF</Color>
|
||||
<Color x:Key="Chart_Percentile">#FFFFC857</Color>
|
||||
<!-- Not a second gold beside Chart_SensorSecondary (beta.8): the Sensors tab draws both. -->
|
||||
<Color x:Key="Chart_Percentile">#FFFF79C6</Color>
|
||||
</ResourceDictionary>
|
||||
@@ -13,5 +13,6 @@
|
||||
<Color x:Key="Chart_SensorSecondary">#FFB8860B</Color>
|
||||
<Color x:Key="Chart_Segment">#1A0A6FB3</Color>
|
||||
<Color x:Key="Chart_Histogram">#CC0A6FB3</Color>
|
||||
<Color x:Key="Chart_Percentile">#FFB8860B</Color>
|
||||
<!-- Not Chart_SensorSecondary's gold (beta.8): the Sensors tab draws both, and in this theme they were one colour. -->
|
||||
<Color x:Key="Chart_Percentile">#FF795548</Color>
|
||||
</ResourceDictionary>
|
||||
@@ -14,6 +14,7 @@ using FrameLedger.Application.TriState;
|
||||
using FrameLedger.Domain.Detection;
|
||||
using FrameLedger.Domain.Sessions;
|
||||
using FrameLedger.Infrastructure.Io;
|
||||
using FrameLedger.Shared.Ipc;
|
||||
using Wpf.Ui.Controls;
|
||||
|
||||
namespace FrameLedger.App.ViewModels;
|
||||
@@ -35,6 +36,9 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
private readonly IMessageStrip _strip;
|
||||
private readonly ISessionSummaryOpener _summaries;
|
||||
private readonly SessionSeriesLoader _loader;
|
||||
private readonly IAgentLink? _agent;
|
||||
private readonly UiThread _ui = new();
|
||||
private bool _attached;
|
||||
private readonly IHardwareSnapshotRepository _hardware;
|
||||
private readonly SessionSelection _selection;
|
||||
private readonly RegisteredSettings? _settings;
|
||||
@@ -140,6 +144,13 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
[ObservableProperty]
|
||||
private bool _selectedHasSeries;
|
||||
|
||||
/// <summary>The Sensors tab's note: why nothing is drawn there, or empty.</summary>
|
||||
[ObservableProperty]
|
||||
private string _sensorsNote = Strings.Tabs_SelectASession;
|
||||
|
||||
[ObservableProperty]
|
||||
private bool _selectedHasSensors;
|
||||
|
||||
[ObservableProperty]
|
||||
private string _latencyText = string.Empty;
|
||||
|
||||
@@ -161,9 +172,10 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
public GameDetailViewModel(GameLibrary library, GameSelection selection, HookingConsent consent, IPageNavigator navigator,
|
||||
IConfirmations confirmations, IEditGamePrompt edit, IMessageStrip strip, ISessionSummaryOpener summaries,
|
||||
SessionSeriesLoader loader, IHardwareSnapshotRepository hardware, SessionSelection sessionSelection, IGamePicker picker,
|
||||
RegisteredSettings? settings = null)
|
||||
RegisteredSettings? settings = null, IAgentLink? agent = null)
|
||||
{
|
||||
_settings = settings;
|
||||
_agent = agent;
|
||||
_picker = picker ?? throw new ArgumentNullException(nameof(picker));
|
||||
_selection = sessionSelection ?? throw new ArgumentNullException(nameof(sessionSelection));
|
||||
_library = library ?? throw new ArgumentNullException(nameof(library));
|
||||
@@ -285,6 +297,12 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
/// <summary>The selected session's decoded series (null: none selected, Tier 2, or swept).</summary>
|
||||
public SessionSeries? SelectedSeries { get; private set; }
|
||||
|
||||
/// <summary>
|
||||
/// What the Sensors tab draws: the selected session's series, or — for a session that was not hooked — its sensors alone
|
||||
/// (beta.8: a Tier-2 row has kept them since 2026-09-22, and the tab said "not hooked" over them).
|
||||
/// </summary>
|
||||
public SessionSeries? SelectedSensors { get; private set; }
|
||||
|
||||
public IReadOnlyList<TrendPoint> TrendPoints { get; private set; } = [];
|
||||
|
||||
public IReadOnlyList<HardwareChange> HardwareChanges { get; private set; } = [];
|
||||
@@ -370,9 +388,43 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
|
||||
partial void OnIncludeMidSessionChanged(bool value) => RebuildTrendPoints();
|
||||
|
||||
/// <summary>
|
||||
/// Listens to the Agent while the page is on screen (beta.8): a session of this game that finishes reloads the page, so
|
||||
/// its sessions, trend and header include it — they were the ones the page opened with until it was left and reopened.
|
||||
/// The page calls it on Loaded and <see cref="Detach"/> on Unloaded; the link is a singleton and must not hold the page.
|
||||
/// </summary>
|
||||
public void Attach()
|
||||
{
|
||||
if (_agent is not null && !_attached)
|
||||
{
|
||||
_agent.EventReceived += OnAgentEvent;
|
||||
_attached = true;
|
||||
}
|
||||
}
|
||||
|
||||
public void Detach()
|
||||
{
|
||||
if (_agent is not null && _attached)
|
||||
{
|
||||
_agent.EventReceived -= OnAgentEvent;
|
||||
_attached = false;
|
||||
}
|
||||
}
|
||||
|
||||
private void OnAgentEvent(object? sender, AgentEventArgs e) => _ui.Post(() =>
|
||||
{
|
||||
if (string.Equals(e.Envelope.Type, IpcMessageType.SessionCompleted, StringComparison.Ordinal)
|
||||
&& IpcCodec.Payload<SessionCompletedEvent>(e.Envelope) is { SessionId: not null } completed
|
||||
&& completed.GameId is long game && game == _gameId)
|
||||
{
|
||||
Pending = LoadAsync();
|
||||
}
|
||||
});
|
||||
|
||||
private async Task LoadSelectedAsync(SessionItemViewModel? session)
|
||||
{
|
||||
SelectedSeries = null;
|
||||
SelectedSensors = null;
|
||||
HasLatency = false;
|
||||
LatencyText = string.Empty;
|
||||
if (session is null)
|
||||
@@ -382,11 +434,14 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
else if (!session.IsHooked)
|
||||
{
|
||||
SelectedNote = Strings.Tabs_SelectedNotHooked;
|
||||
IReadOnlyList<SensorSeries> sensors = await _loader.LoadSensorsAsync(session.Id).ConfigureAwait(true);
|
||||
SelectedSensors = sensors.Count > 0 ? SessionSeries.SensorsOnly(sensors) : null;
|
||||
}
|
||||
else
|
||||
{
|
||||
SelectedSeries = await _loader.LoadAsync(session.Id).ConfigureAwait(true);
|
||||
SelectedNote = SelectedSeries is null ? Strings.Tabs_SelectedNoFrames : string.Empty;
|
||||
SelectedSensors = SelectedSeries;
|
||||
HasLatency = SelectedSeries?.LatencyUs is { Length: > 0 } && session.Row.ReflexActive == true;
|
||||
LatencyText = HasLatency && session.Row.LatencyAvgUs is long avg && session.Row.LatencyP95Us is long p95
|
||||
? string.Format(CultureInfo.CurrentCulture, Strings.Latency_Stats_Format, avg / 1000.0, p95 / 1000.0)
|
||||
@@ -394,6 +449,11 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
}
|
||||
|
||||
SelectedHasSeries = SelectedSeries is not null;
|
||||
SelectedHasSensors = SelectedSensors is { } shown && (shown.Sensors.Count > 0 || shown.VramProcMb is { Length: > 0 });
|
||||
SensorsNote = session is null ? Strings.Tabs_SelectASession
|
||||
: SelectedHasSensors ? string.Empty
|
||||
: session.IsHooked && SelectedSeries is null ? Strings.Tabs_SelectedNoFrames
|
||||
: Strings.Sensors_Empty;
|
||||
SelectionPresented?.Invoke(this, EventArgs.Empty);
|
||||
}
|
||||
|
||||
|
||||
@@ -91,9 +91,17 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
|
||||
[ObservableProperty]
|
||||
private bool _showDisplayed;
|
||||
|
||||
/// <summary>
|
||||
/// The frametime chart can draw the sensors over the frames: they were recorded and the blob says where the first present
|
||||
/// sits on their clock (schema 0013). A session recorded before keeps the overlay off rather than drawn out of step.
|
||||
/// </summary>
|
||||
[ObservableProperty]
|
||||
private bool _hasSensors;
|
||||
|
||||
/// <summary>The Sensors section has something to draw — in either tier (beta.8).</summary>
|
||||
[ObservableProperty]
|
||||
private bool _hasSensorCharts;
|
||||
|
||||
[ObservableProperty]
|
||||
private bool _showSensors;
|
||||
|
||||
@@ -135,6 +143,8 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
|
||||
|
||||
public static string DistributionHeader => Strings.Summary_Distribution_Header;
|
||||
|
||||
public static string SensorsHeader => Strings.GameDetail_Tab_Sensors;
|
||||
|
||||
public static string ShowDisplayedText => Strings.Summary_Show_Displayed;
|
||||
|
||||
public static string ShowSensorsText => Strings.Summary_Show_Sensors;
|
||||
@@ -159,6 +169,9 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
|
||||
|
||||
public SessionSeries? Series { get; private set; }
|
||||
|
||||
/// <summary>What the Sensors section draws: <see cref="Series"/> for a hooked session, the sensors alone for one that was not.</summary>
|
||||
public SessionSeries? SensorSeries { get; private set; }
|
||||
|
||||
public ObservableCollection<StatCardModel> Stats { get; } = [];
|
||||
|
||||
public ObservableCollection<TriStateChipModel> Chips { get; } = [];
|
||||
@@ -184,6 +197,7 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
|
||||
_segments = await _sessions.FindSegmentsAsync(sessionId, ct).ConfigureAwait(true);
|
||||
_snapshot = await _hardware.FindAsync(Row.SnapshotId, ct).ConfigureAwait(true);
|
||||
Series = Row.Tier == CaptureTier.Hooked ? await _loader.LoadAsync(sessionId, ct).ConfigureAwait(true) : null;
|
||||
SensorSeries = Series ?? (await _loader.LoadSensorsAsync(sessionId, ct).ConfigureAwait(true) is { Count: > 0 } sensors ? SessionSeries.SensorsOnly(sensors) : null);
|
||||
Present();
|
||||
}
|
||||
|
||||
@@ -320,7 +334,8 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
|
||||
Tags = _annotation is null ? string.Empty : string.Join(", ", _annotation.Tags);
|
||||
Notes = _annotation?.Notes ?? string.Empty;
|
||||
HasDisplayed = Series?.HasGenerated == true;
|
||||
HasSensors = Series?.Sensors.Count > 0;
|
||||
HasSensors = Series is { SensorsAligned: true, Sensors.Count: > 0 };
|
||||
HasSensorCharts = SensorSeries is { } shown && (shown.Sensors.Count > 0 || shown.VramProcMb is { Length: > 0 });
|
||||
DecimationNote = Series is null ? string.Empty : string.Format(CultureInfo.CurrentCulture, Strings.Chart_Decimated_Format, Series.Presents, Math.Min(Series.Presents, Decimator.DefaultBuckets * 2));
|
||||
PresentStats(row);
|
||||
PresentChips();
|
||||
|
||||
@@ -109,6 +109,12 @@
|
||||
<charts:DistributionChart x:Name="Distribution" Margin="0,6,0,0" Height="260" />
|
||||
</StackPanel>
|
||||
|
||||
<!-- sensors, in either tier (beta.8): a session that was not hooked has nothing else to chart -->
|
||||
<StackPanel Visibility="{Binding ViewModel.HasSensorCharts, Converter={StaticResource BoolToVis}}">
|
||||
<ui:TextBlock Margin="0,16,0,0" FontTypography="Subtitle" Text="{x:Static vm:SessionSummaryViewModel.SensorsHeader}" />
|
||||
<charts:SensorsChart x:Name="Sensors" Margin="0,6,0,0" />
|
||||
</StackPanel>
|
||||
|
||||
<!-- annotations -->
|
||||
<ui:TextBlock Margin="0,16,0,0" FontTypography="Subtitle" Text="{x:Static vm:SessionSummaryViewModel.AnnotationsHeader}" />
|
||||
<ui:TextBox Margin="0,6,0,0" AutomationProperties.Name="{x:Static vm:SessionSummaryViewModel.TagsPlaceholder}" PlaceholderText="{x:Static vm:SessionSummaryViewModel.TagsPlaceholder}" Text="{Binding ViewModel.Tags, UpdateSourceTrigger=PropertyChanged}" />
|
||||
|
||||
@@ -60,6 +60,7 @@ public partial class SessionSummaryWindow : FluentWindow
|
||||
{
|
||||
Frametime.Show(ViewModel.Series, ViewModel.ShowDisplayed, ViewModel.ShowSensors);
|
||||
Distribution.Show(ViewModel.Series);
|
||||
Sensors.Show(ViewModel.SensorSeries);
|
||||
}
|
||||
|
||||
private void OnExportPng(object sender, RoutedEventArgs e) => _ = ViewModel.ExportPngAsync(Frametime.ScottPlot);
|
||||
|
||||
@@ -567,6 +567,14 @@ public sealed class CaptureSession(
|
||||
bool paused = pause?.IsPaused ?? false;
|
||||
if (paused != state.Paused)
|
||||
{
|
||||
// The resume's instant is read BEFORE the ring is told (beta.8): the Overlay records nothing until it reads the
|
||||
// cleared flag, so a record stamped at or after this QPC was presented after the pause — and the first of them
|
||||
// follows a gap (MarkResume). The clock is the Overlay's own: Stopwatch is QueryPerformanceCounter.
|
||||
if (!paused)
|
||||
{
|
||||
state.ResumedAtQpc = Stopwatch.GetTimestamp();
|
||||
}
|
||||
|
||||
sink.SetPaused(paused);
|
||||
state.Paused = paused;
|
||||
}
|
||||
@@ -581,6 +589,9 @@ public sealed class CaptureSession(
|
||||
/// <summary>What the ring was last told about FR-3.9's pause (P3 PR-1b).</summary>
|
||||
public bool Paused { get; set; }
|
||||
|
||||
/// <summary>The QPC read as the ring was told to resume, until the first record presented after it is marked (beta.8).</summary>
|
||||
public long? ResumedAtQpc { get; set; }
|
||||
|
||||
public List<FlFrameRecord> Records { get; } = [];
|
||||
|
||||
public List<ulong> Gaps { get; } = [];
|
||||
@@ -647,13 +658,45 @@ public sealed class CaptureSession(
|
||||
do
|
||||
{
|
||||
int gapsBefore = state.Gaps.Count;
|
||||
int recordsBefore = state.Records.Count;
|
||||
r = sink.Drain(buffer, state.Gaps);
|
||||
MarkGaps(state, r, gapsBefore);
|
||||
state.Records.AddRange(buffer.AsSpan(0, r.Copied).ToArray());
|
||||
MarkResume(state, recordsBefore);
|
||||
}
|
||||
while (r.Copied == buffer.Length);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// FR-3.9's pause as a gap (beta.8): the Overlay records nothing while paused, so the first record presented after the
|
||||
/// resume is QPC-apart from the last one before the pause by the whole pause. Counted, that interval is a fabricated
|
||||
/// long frame in every statistic and paused time in every average; it follows a gap instead, as a torn slot's survivor
|
||||
/// does. A record drained after the resume but stamped before it is a straggler the pause had not reached yet.
|
||||
/// </summary>
|
||||
private static void MarkResume(DrainState state, int from)
|
||||
{
|
||||
if (state.ResumedAtQpc is not long resumed)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i = from; i < state.Records.Count; i++)
|
||||
{
|
||||
if ((long)state.Records[i].Qpc < resumed)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!state.GapBefore.Contains(i))
|
||||
{
|
||||
state.GapBefore.Add(i);
|
||||
}
|
||||
|
||||
state.ResumedAtQpc = null;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Which copied record each torn slot (and an overwrite skip) preceded: walk the slots this call
|
||||
/// examined in order, and the first record after a bad slot carries the gap
|
||||
|
||||
@@ -29,4 +29,11 @@ public sealed record FrameBlobs
|
||||
public ReadOnlyMemory<byte>? VramProc { get; init; }
|
||||
|
||||
public ReadOnlyMemory<byte>? LatencyUs { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// Schema 0013 (beta.8): the first present of the stream the charts draw (<c>SegmentBuilder.DominantStream</c>), in ms from
|
||||
/// the session's <c>qpc_epoch</c> — the distance between the frame series' zero and the sensor series' (<c>t_ms</c>). Null
|
||||
/// for a row written before, whose sensors cannot be placed on its frames.
|
||||
/// </summary>
|
||||
public double? FirstPresentMs { get; init; }
|
||||
}
|
||||
@@ -47,7 +47,8 @@ public static class SessionAggregator
|
||||
private static SessionRow ApplyFrames(SessionRow row, Context c)
|
||||
{
|
||||
FrameStatistics stats = c.Stats;
|
||||
StutterResult? stutter = c.Series is null ? null : StutterDetector.Detect(c.Series.FrameTimesMs);
|
||||
FrameTimeSeries? frames = c.Frames;
|
||||
StutterResult? stutter = frames is null ? null : StutterDetector.Detect(frames.FrameTimesMs);
|
||||
LatencyAggregates latency = LatencyAggregates.From(c.Dominant);
|
||||
return row with
|
||||
{
|
||||
@@ -65,7 +66,7 @@ public static class SessionAggregator
|
||||
FrametimeStdDevMs = stats.StdDevMs,
|
||||
StutterCount = stutter?.Count,
|
||||
StutterTimePct = stutter?.TimePct,
|
||||
PsoStutterPct = stutter is null || c.Series is null ? null : StutterDetector.PsoStutterPct(stutter, c.Series, c.Dominant),
|
||||
PsoStutterPct = stutter is null || frames is null ? null : StutterDetector.PsoStutterPct(stutter, frames, c.Dominant),
|
||||
// Null, not false, when no latency sample exists: nothing measures Reflex today, and a false is an answer nobody gave.
|
||||
ReflexActive = latency.Count > 0 ? true : null,
|
||||
LatencyAvgUs = latency.AverageUs is { } a ? (long)Math.Round(a) : null,
|
||||
@@ -93,7 +94,7 @@ public static class SessionAggregator
|
||||
DisplayedFps = usable ? fg!.DisplayedFps : steady?.DisplayedFps,
|
||||
FgFactorScope = usable && fg!.Factor is not null ? "session" : steady is not null ? "steady" : null,
|
||||
FgSteadyShare = steady?.Share,
|
||||
DisplayedP1LowFps = usable && c.Verdict is FgVerdict.Named or FgVerdict.ActiveUnidentified ? c.Stats.P1LowFps : null,
|
||||
DisplayedP1LowFps = usable && c.Verdict is FgVerdict.Named or FgVerdict.ActiveUnidentified ? c.PresentStats.P1LowFps : null,
|
||||
DisplayedCountedBy = usable || steady is not null ? (fg!.DxgiCounted ? "dxgi" : "hook") : null,
|
||||
FgNoneWithheldReason = c.Withheld,
|
||||
FgRefusal = usable ? null : fg?.Refusal is { } refusal ? Vocabulary.FgRefusal(refusal.Kind) : null,
|
||||
@@ -254,7 +255,11 @@ public static class SessionAggregator
|
||||
}
|
||||
|
||||
FrameTimeSeries series = FrameTimeSeries.From(seg.Samples, null, c.Input.QpcFrequency);
|
||||
FrameStatistics stats = FrameStatistics.From(series.FrameTimesMs, presented: true);
|
||||
|
||||
// The segment's low is over the frames the session's is (beta.8): application frames where generated ones were counted.
|
||||
FrameStatistics stats = c.Generating
|
||||
? FrameStatistics.From(FrameTimeSeries.ApplicationFrames(seg.Samples, null, c.Input.QpcFrequency).FrameTimesMs, presented: false)
|
||||
: FrameStatistics.From(series.FrameTimesMs, presented: true);
|
||||
UpscaleExtent? extent = UpscaleExtent.From(seg.Samples);
|
||||
UpscalerKind? upscaler = seg.Samples.Where(static s => s.Claims(MeasuredFields.Upscaler))
|
||||
.Select(static s => s.Upscaler)
|
||||
@@ -299,15 +304,25 @@ public static class SessionAggregator
|
||||
HashSet<int> gapBefore = DominantGaps(input, dominantRecords);
|
||||
Series = Dominant.Count > 0 ? FrameTimeSeries.From(Dominant, gapBefore, input.QpcFrequency) : null;
|
||||
|
||||
Fg = All.Count > 0 ? FgWindow.From(All, input.QpcFrequency) : null;
|
||||
Fg = All.Count > 0 ? FgWindow.From(All, input.QpcFrequency, new HashSet<int>(input.GapBefore)) : null;
|
||||
FgCounted = FgLadder.FgHookRan(input.Records);
|
||||
var census = (FlRuntimeCensus)input.Writer.RuntimeCensus;
|
||||
Withheld = Fg?.IsNone == true ? FgLadder.WithholdNone(census, input.Modules, input.Writer) : null;
|
||||
FgIdentity = FgLadder.Identity(dominantRecords);
|
||||
Verdict = FgLadder.Resolve(FgIdentity, Fg, Withheld);
|
||||
Stats = Series is null
|
||||
|
||||
// 03_METRICS §Core definitions: the median, the lows, min / max, σ and the stutter rule are over ft_app. Where
|
||||
// generated frames were counted (beta.8) that is application frame to application frame, never present to
|
||||
// present: generated presents sit between them, and on a title that submits them in a burst the present-to-
|
||||
// present median was a generated frame's half millisecond. The presents keep the Displayed 1% low.
|
||||
Generating = Verdict is FgVerdict.Named or FgVerdict.ActiveUnidentified;
|
||||
PresentStats = Series is null
|
||||
? FrameStatistics.Empty(presented: true)
|
||||
: FrameStatistics.From(Series.FrameTimesMs, presented: Verdict is not (FgVerdict.Named or FgVerdict.ActiveUnidentified));
|
||||
: FrameStatistics.From(Series.FrameTimesMs, presented: true);
|
||||
Frames = Generating && Dominant.Count > 0 ? FrameTimeSeries.ApplicationFrames(Dominant, gapBefore, input.QpcFrequency) : Series;
|
||||
Stats = Generating
|
||||
? FrameStatistics.From(Frames?.FrameTimesMs ?? [], presented: false)
|
||||
: PresentStats;
|
||||
Hdr = HdrVerdict.Of(Dominant);
|
||||
}
|
||||
|
||||
@@ -333,8 +348,21 @@ public static class SessionAggregator
|
||||
|
||||
public FgVerdict Verdict { get; }
|
||||
|
||||
/// <summary>Generated frames were counted, or a technology named: the frame statistics are over application frames.</summary>
|
||||
public bool Generating { get; }
|
||||
|
||||
/// <summary>
|
||||
/// The series the frame statistics and the stutter rule are over: application frames where generated frames were
|
||||
/// counted, the dominant stream's presents otherwise.
|
||||
/// </summary>
|
||||
public FrameTimeSeries? Frames { get; }
|
||||
|
||||
/// <summary>The statistics over <see cref="Frames"/>.</summary>
|
||||
public FrameStatistics Stats { get; }
|
||||
|
||||
/// <summary>The statistics over every present of the dominant stream — the Displayed 1% low's.</summary>
|
||||
public FrameStatistics PresentStats { get; }
|
||||
|
||||
public Tri Hdr { get; }
|
||||
|
||||
/// <summary>The gap-before set re-indexed onto the dominant stream: a gap in the drained order lands on the same record there.</summary>
|
||||
|
||||
@@ -70,7 +70,10 @@ public sealed class SessionFinalizer
|
||||
{
|
||||
Row = r.Row,
|
||||
Segments = r.Segments,
|
||||
Frames = r.Samples.Count == 0 ? null : EncodeFrames(r.Samples, input.Hooked.GapBefore, row.QpcFrequency),
|
||||
Frames = r.Samples.Count == 0 ? null : EncodeFrames(r.Samples, input.Hooked.GapBefore, row.QpcFrequency) with
|
||||
{
|
||||
FirstPresentMs = FirstPresentMs(r.Dominant, row.QpcEpoch, row.QpcFrequency),
|
||||
},
|
||||
Sensors = EncodeSensors(input.Sensors, row.QpcEpoch, row.QpcFrequency),
|
||||
};
|
||||
}
|
||||
@@ -120,6 +123,19 @@ public sealed class SessionFinalizer
|
||||
return new FinalizeOutcome(FinalizeStatus.Saved, id, swept, gameId);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Schema 0013 (beta.8): the charted stream's first present on the sensors' clock — ms from <c>qpc_epoch</c>, the zero
|
||||
/// <c>t_ms</c> counts from. Null when the stream is empty or its first present predates the epoch (a clock nobody can
|
||||
/// place the sensors on).
|
||||
/// </summary>
|
||||
public static double? FirstPresentMs(IReadOnlyList<FrameSample> dominant, ulong qpcEpoch, long qpcFrequency)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(dominant);
|
||||
return dominant.Count == 0 || dominant[0].Qpc < qpcEpoch || qpcFrequency <= 0
|
||||
? null
|
||||
: (dominant[0].Qpc - qpcEpoch) * 1000.0 / qpcFrequency;
|
||||
}
|
||||
|
||||
/// <summary>The full <c>frame_blobs</c> row over every record in drained order.</summary>
|
||||
private FrameBlobs EncodeFrames(IReadOnlyList<FrameSample> samples, IReadOnlyList<int> gapBefore, long qpcFrequency)
|
||||
{
|
||||
|
||||
@@ -36,7 +36,7 @@ public sealed record FgWindow
|
||||
/// <summary>Presents that drained a non-empty Streamline word (<see cref="FeatureBits.RayReconstructionObserved"/>).</summary>
|
||||
public required int Batches { get; init; }
|
||||
|
||||
/// <summary>Seconds spanned by the window's intervals.</summary>
|
||||
/// <summary>Seconds spanned by the window's intervals, less every interval a gap sat in (beta.8: a pause, lost records).</summary>
|
||||
public required double Seconds { get; init; }
|
||||
|
||||
/// <summary>Samples the writer could not attribute to a swapchain.</summary>
|
||||
@@ -177,8 +177,11 @@ public sealed record FgWindow
|
||||
/// <summary>Frame generation is active: a published factor at or above <see cref="ActiveThreshold"/>.</summary>
|
||||
public bool IsActive => Factor is double f && f >= ActiveThreshold;
|
||||
|
||||
/// <summary>Builds the window over EVERY drained sample, or the reason there is none.</summary>
|
||||
public static FgWindow From(IReadOnlyList<FrameSample> all, long qpcFrequency)
|
||||
/// <summary>
|
||||
/// Builds the window over EVERY drained sample, or the reason there is none. <paramref name="gapBefore"/> indexes the
|
||||
/// samples that follow a gap — a pause (FR-3.9), lost records — whose intervals the rates' time base leaves out.
|
||||
/// </summary>
|
||||
public static FgWindow From(IReadOnlyList<FrameSample> all, long qpcFrequency, IReadOnlySet<int>? gapBefore = null)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(all);
|
||||
|
||||
@@ -188,7 +191,7 @@ public sealed record FgWindow
|
||||
return Nothing(new FgRefusal(FgRefusalKind.NotCounted, FgRefusalSubject.Factor));
|
||||
}
|
||||
|
||||
FgWindow tallied = Tally(all, start, qpcFrequency);
|
||||
FgWindow tallied = Tally(all, start, qpcFrequency, gapBefore);
|
||||
FgRefusal? refusal = RefusalFor(tallied);
|
||||
bool mixedStates = refusal is { Kind: FgRefusalKind.NonUniform, Subject: FgRefusalSubject.Factor };
|
||||
return tallied with { Refusal = refusal, Steady = mixedStates ? FgSteadyState.From(all, start, qpcFrequency) : null };
|
||||
@@ -215,7 +218,7 @@ public sealed record FgWindow
|
||||
|
||||
private static bool DrainedBatch(in FrameSample s) => s.Features.HasFlag(FeatureBits.RayReconstructionObserved);
|
||||
|
||||
private static FgWindow Tally(IReadOnlyList<FrameSample> all, int start, long qpcFrequency)
|
||||
private static FgWindow Tally(IReadOnlyList<FrameSample> all, int start, long qpcFrequency, IReadOnlySet<int>? gapBefore)
|
||||
{
|
||||
// Index is the value; the last slot lumps everything at or above it, which is where a saturated 255
|
||||
// lands. `Saturated` counts those separately, because 255 is a sentinel as much as a value and must
|
||||
@@ -258,7 +261,7 @@ public sealed record FgWindow
|
||||
Presents = all.Count - start,
|
||||
Evaluations = sigma,
|
||||
Batches = batches,
|
||||
Seconds = RecordWindow.SecondsOf(all, start, qpcFrequency),
|
||||
Seconds = RecordWindow.SecondsOf(all, start, qpcFrequency, gapBefore),
|
||||
Unidentified = unidentified,
|
||||
Streams = streams.Count,
|
||||
StreamsInterleaved = Interleaved(all, start, streams.Count),
|
||||
|
||||
@@ -16,6 +16,12 @@ namespace FrameLedger.Domain.Metrics;
|
||||
/// that laps the ring can return an older record after a newer one, and a negative delta is not a frame
|
||||
/// time in either direction.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>The average's time base leaves the gaps out too (beta.8).</b> A pause (FR-3.9) is a gap since then — the first
|
||||
/// record after the resume carries one — and an average over first-to-last present would have spread the frames of
|
||||
/// the measured time over the paused minutes as well. <see cref="MeasuredSeconds"/> is the time the kept intervals
|
||||
/// span; with no gap it is <see cref="DurationSeconds"/>.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed record FrameTimeSeries
|
||||
{
|
||||
@@ -31,19 +37,26 @@ public sealed record FrameTimeSeries
|
||||
/// <summary>Intervals excluded because the clock did not advance across them.</summary>
|
||||
public required int ExcludedNonPositive { get; init; }
|
||||
|
||||
/// <summary><c>D</c>: first present to last present, in seconds — the time base of every average.</summary>
|
||||
/// <summary>First present to last present, in seconds: the wall clock the series spans, gaps included.</summary>
|
||||
public required double DurationSeconds { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// <c>D</c>, the time base of every average: the seconds the kept intervals span — <see cref="DurationSeconds"/> less
|
||||
/// every interval a gap sat in (a pause, lost records).
|
||||
/// </summary>
|
||||
public required double MeasuredSeconds { get; init; }
|
||||
|
||||
/// <summary>Presents in the stream.</summary>
|
||||
public required int Presents { get; init; }
|
||||
|
||||
public int Count => FrameTimesMs.Count;
|
||||
|
||||
/// <summary>
|
||||
/// The time-based average: <c>presents / D</c>, NOT the mean of instantaneous FPS values, which weights fast
|
||||
/// frames more than slow ones. Null without a duration to divide by.
|
||||
/// The time-based average: frames over <c>D</c>, NOT the mean of instantaneous FPS values, which weights fast
|
||||
/// frames more than slow ones — the kept intervals over the seconds they span, which is <c>(presents − 1) / D</c>
|
||||
/// wherever nothing was left out. Null without a duration to divide by.
|
||||
/// </summary>
|
||||
public double? AverageFps => DurationSeconds > 0 && Presents > 1 ? (Presents - 1) / DurationSeconds : null;
|
||||
public double? AverageFps => MeasuredSeconds > 0 && Count > 0 ? Count / MeasuredSeconds : null;
|
||||
|
||||
/// <summary>
|
||||
/// Builds the series over one stream. <paramref name="gapBefore"/> holds the indices of samples that follow
|
||||
@@ -88,7 +101,96 @@ public sealed record FrameTimeSeries
|
||||
ExcludedForGaps = gaps,
|
||||
ExcludedNonPositive = nonPositive,
|
||||
DurationSeconds = duration,
|
||||
MeasuredSeconds = times.Sum() / 1000.0,
|
||||
Presents = stream.Count,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The APPLICATION-frame series over one stream on which frame generation was counted — <c>ft_app</c>, every
|
||||
/// statistic <c>03_METRICS</c> §Core definitions takes over it: the interval between two consecutive presents that
|
||||
/// carried an application frame (<see cref="MeasuredFields.FgCounts"/> claimed, <see cref="FrameSample.FgEvaluations"/>
|
||||
/// above zero), ending at the second. The generated presents between them add no interval of their own.
|
||||
/// <see cref="Presents"/> counts the application-frame presents and <see cref="DurationSeconds"/> spans the first to the
|
||||
/// last of them.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>A chain is broken — the interval left out and counted in <see cref="ExcludedForGaps"/> — by a gap anywhere
|
||||
/// inside it, and by a sample that does not claim the count</b>, of which nobody said whether it was generated. A clock
|
||||
/// that did not advance is <see cref="ExcludedNonPositive"/>, as in <see cref="From"/>.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Why not the interval to the previous present (beta.8, 2026-09-25).</b> The owner's Onimusha demo capture (DLSS
|
||||
/// Frame Generation ×3) submits each generated frame about half a millisecond after its application frame, so its
|
||||
/// present-to-present intervals run 0.5 / 0.5 / 15.7 ms: the median over presents read 2,073 FPS against a native 60,
|
||||
/// and the chart's "native" series — the interval from each application frame to the present before it — was a
|
||||
/// generated frame's half millisecond. Application frame to application frame reads a 60.3 FPS median.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// A present that drained two tokens is one timestamp and one application frame here: the drain attributes a token to
|
||||
/// the next present, which is accurate to one present (<c>03_METRICS</c> §Frame Generation) and was measured regular —
|
||||
/// application, generated, generated, repeating — on that title.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static FrameTimeSeries ApplicationFrames(IReadOnlyList<FrameSample> stream, IReadOnlySet<int>? gapBefore, long qpcFrequency)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(stream);
|
||||
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(qpcFrequency);
|
||||
|
||||
var times = new List<double>();
|
||||
var ending = new List<int>();
|
||||
int gaps = 0;
|
||||
int nonPositive = 0;
|
||||
int applicationFrames = 0;
|
||||
int first = -1;
|
||||
int previous = -1;
|
||||
bool broken = false;
|
||||
for (int i = 0; i < stream.Count; i++)
|
||||
{
|
||||
FrameSample s = stream[i];
|
||||
broken |= gapBefore?.Contains(i) == true || !s.Claims(MeasuredFields.FgCounts);
|
||||
if (!s.Claims(MeasuredFields.FgCounts) || s.FgEvaluations == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
applicationFrames++;
|
||||
if (first < 0)
|
||||
{
|
||||
first = i;
|
||||
}
|
||||
else if (broken)
|
||||
{
|
||||
gaps++;
|
||||
}
|
||||
else
|
||||
{
|
||||
long delta = (long)s.Qpc - (long)stream[previous].Qpc;
|
||||
if (delta > 0)
|
||||
{
|
||||
times.Add(delta * 1000.0 / qpcFrequency);
|
||||
ending.Add(i);
|
||||
}
|
||||
else
|
||||
{
|
||||
nonPositive++;
|
||||
}
|
||||
}
|
||||
|
||||
previous = i;
|
||||
broken = false;
|
||||
}
|
||||
|
||||
return new FrameTimeSeries
|
||||
{
|
||||
FrameTimesMs = times,
|
||||
EndingSample = ending,
|
||||
ExcludedForGaps = gaps,
|
||||
ExcludedNonPositive = nonPositive,
|
||||
DurationSeconds = first < 0 ? 0 : Math.Max(0, ((long)stream[previous].Qpc - (long)stream[first].Qpc) / (double)qpcFrequency),
|
||||
MeasuredSeconds = times.Sum() / 1000.0,
|
||||
Presents = applicationFrames,
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -55,11 +55,18 @@ public static class RecordWindow
|
||||
|
||||
/// <summary>Seconds spanned by the intervals of <c>[start, stream.Count)</c>.</summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// Non-positive intervals are skipped rather than summed. A drain that laps the ring can return an
|
||||
/// older record after a newer one — legitimately, because it resumes at the oldest survivor — and
|
||||
/// a negative delta is not a frame time in either direction.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// The interval into every index of <paramref name="gapBefore"/> is skipped as well (beta.8): a pause (FR-3.9) and
|
||||
/// lost records are time nothing was measured in, and a rate over them would count frames that were never seen.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static double SecondsOf<T>(IReadOnlyList<T> stream, int start, long qpcFrequency, Func<T, ulong> qpcOf)
|
||||
public static double SecondsOf<T>(IReadOnlyList<T> stream, int start, long qpcFrequency, Func<T, ulong> qpcOf,
|
||||
IReadOnlySet<int>? gapBefore = null)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(stream);
|
||||
ArgumentNullException.ThrowIfNull(qpcOf);
|
||||
@@ -69,7 +76,7 @@ public static class RecordWindow
|
||||
for (int i = start + 1; i < stream.Count; i++)
|
||||
{
|
||||
long delta = (long)qpcOf(stream[i]) - (long)qpcOf(stream[i - 1]);
|
||||
if (delta > 0)
|
||||
if (delta > 0 && gapBefore?.Contains(i) != true)
|
||||
{
|
||||
seconds += (double)delta / qpcFrequency;
|
||||
}
|
||||
@@ -78,7 +85,7 @@ public static class RecordWindow
|
||||
return seconds;
|
||||
}
|
||||
|
||||
/// <summary>Seconds spanned by the intervals of <c>[start, stream.Count)</c> over samples.</summary>
|
||||
public static double SecondsOf(IReadOnlyList<FrameSample> stream, int start, long qpcFrequency) =>
|
||||
SecondsOf(stream, start, qpcFrequency, static s => s.Qpc);
|
||||
/// <summary>Seconds spanned by the intervals of <c>[start, stream.Count)</c> over samples, the gaps' left out.</summary>
|
||||
public static double SecondsOf(IReadOnlyList<FrameSample> stream, int start, long qpcFrequency, IReadOnlySet<int>? gapBefore = null) =>
|
||||
SecondsOf(stream, start, qpcFrequency, static s => s.Qpc, gapBefore);
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
-- 0013 (2026-09-25): where the charted stream's first present sits on the session's clock (beta.8, owner request: "fix
|
||||
-- the charts that are not reasonable").
|
||||
--
|
||||
-- The frame series are timed from their first present (frametimes are intervals, 06_DATA_MODEL §Blob encoding) and the
|
||||
-- sensor series from qpc_epoch (sensor_blobs' t_ms), and nothing said how far apart the two zeros were: the game's launch
|
||||
-- and its loading screen lie between them, so the frametime chart's sensor overlay was drawn tens of seconds early. This
|
||||
-- column is that distance — the first present of the stream the charts draw (SegmentBuilder.DominantStream, the rule the
|
||||
-- session's statistics use), in milliseconds from qpc_epoch — written by the finalizer with the frames.
|
||||
--
|
||||
-- NULL for every row written before, whose overlay stays off rather than drawn out of step. Gaps are still collapsed in the
|
||||
-- frame time axis (a gap's interval is stored as 0), so a series drifts ahead of its sensors by every gap it held.
|
||||
|
||||
ALTER TABLE frame_blobs ADD COLUMN first_present_ms REAL;
|
||||
@@ -22,15 +22,15 @@ public sealed class SqliteSessionRepository : ISessionRepository
|
||||
|
||||
private const string _insertFrames =
|
||||
"INSERT INTO frame_blobs (session_id, codec, sample_count, frametimes, frame_flags, frame_index, swapchain_ids, rt_flags, "
|
||||
+ "render_res, dispatch_rays, pso_created, vram_proc, latency_us) VALUES (@id, @Codec, @SampleCount, @FrameTimes, @FrameFlags, "
|
||||
+ "@FrameIndex, @SwapchainIds, @RtFlags, @RenderRes, @DispatchRays, @PsoCreated, @VramProc, @LatencyUs)";
|
||||
+ "render_res, dispatch_rays, pso_created, vram_proc, latency_us, first_present_ms) VALUES (@id, @Codec, @SampleCount, @FrameTimes, "
|
||||
+ "@FrameFlags, @FrameIndex, @SwapchainIds, @RtFlags, @RenderRes, @DispatchRays, @PsoCreated, @VramProc, @LatencyUs, @FirstPresentMs)";
|
||||
|
||||
private const string _insertSensor =
|
||||
"INSERT INTO sensor_blobs (session_id, series, hz, codec, data) VALUES (@id, @Series, @Hz, @Codec, @Data)";
|
||||
|
||||
private const string _selectFrames =
|
||||
"SELECT codec, sample_count, frametimes, frame_flags, frame_index, swapchain_ids, rt_flags, render_res, "
|
||||
+ "dispatch_rays, pso_created, vram_proc, latency_us FROM frame_blobs WHERE session_id = @sessionId";
|
||||
+ "dispatch_rays, pso_created, vram_proc, latency_us, first_present_ms FROM frame_blobs WHERE session_id = @sessionId";
|
||||
|
||||
private const string _exists = "SELECT COUNT(*) FROM sessions WHERE session_guid = @guid";
|
||||
|
||||
@@ -243,6 +243,7 @@ public sealed class SqliteSessionRepository : ISessionRepository
|
||||
PsoCreated = SqliteReaders.Blob(r, 9),
|
||||
VramProc = SqliteReaders.Blob(r, 10),
|
||||
LatencyUs = SqliteReaders.Blob(r, 11),
|
||||
FirstPresentMs = SqliteReaders.Double(r, 12),
|
||||
};
|
||||
|
||||
private static async Task<bool> ExistsInAsync(SqliteConnection c, SqliteTransaction? tx, Guid guid, CancellationToken ct) =>
|
||||
@@ -296,6 +297,7 @@ public sealed class SqliteSessionRepository : ISessionRepository
|
||||
cmd.Parameters.AddWithValue("@PsoCreated", Optional(f.PsoCreated));
|
||||
cmd.Parameters.AddWithValue("@VramProc", Optional(f.VramProc));
|
||||
cmd.Parameters.AddWithValue("@LatencyUs", Optional(f.LatencyUs));
|
||||
cmd.Parameters.AddWithValue("@FirstPresentMs", f.FirstPresentMs is double first ? first : (object)DBNull.Value);
|
||||
await cmd.ExecuteNonQueryAsync(ct).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,161 @@
|
||||
using System.IO;
|
||||
using System.Xml.Linq;
|
||||
using FluentAssertions;
|
||||
using FrameLedger.App.Charts;
|
||||
using FrameLedger.Application.Persistence;
|
||||
using FrameLedger.Infrastructure.Blobs;
|
||||
|
||||
namespace FrameLedger.App.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// beta.8's honest charts, as the pure functions under them: the histogram's range and bar positions, where the percentile
|
||||
/// curve may speak, what the frametime chart's note says, and the sensors chart's colours told apart in both themes.
|
||||
/// </summary>
|
||||
[Collection(StringsCultureCollection.Name)]
|
||||
public sealed class ChartMathTests
|
||||
{
|
||||
[Fact]
|
||||
public void TheHistogramIsBinnedBetweenTheHalfPercentilesAndDrawnAtBinCentres()
|
||||
{
|
||||
// 996 frames between 15 and 18 ms, and four that are not frames anyone saw: two presents 0.3 ms apart, two 200 ms hitches.
|
||||
List<double> frametimes = [.. Enumerable.Range(0, 996).Select(static i => 15 + ((i % 100) * 0.03)), 0.3, 0.3, 200, 200];
|
||||
|
||||
FpsHistogram h = FpsHistogram.Of(frametimes, bins: 60);
|
||||
|
||||
h.Centers.Should().HaveCount(60);
|
||||
h.Centers.Min().Should().BeGreaterThan(50, "a 5 FPS hitch does not stretch the axis");
|
||||
h.Centers.Max().Should().BeLessThan(70, "nor a 3,333 FPS non-frame");
|
||||
(h.Centers[1] - h.Centers[0]).Should().BeApproximately(h.BinWidth, 1e-9);
|
||||
h.Outside.Should().BeGreaterThanOrEqualTo(4);
|
||||
(h.Counts.Sum() + h.Outside).Should().Be(1_000, "every frame is in a bar or counted as outside");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void OneRateIsOneBarAndNothingIsNoBar()
|
||||
{
|
||||
FpsHistogram one = FpsHistogram.Of([.. Enumerable.Repeat(16.0, 50)]);
|
||||
one.Centers.Should().Equal(62.5);
|
||||
one.Counts.Should().Equal(50);
|
||||
|
||||
FpsHistogram.Of([]).Centers.Should().BeEmpty();
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(1_000, 99, true)]
|
||||
[InlineData(999, 99, false)]
|
||||
[InlineData(10_000, 99.9, true)]
|
||||
[InlineData(9_999, 99.9, false)]
|
||||
[InlineData(1_000_000, 100, false)]
|
||||
[InlineData(1_000_000, 0, false)]
|
||||
public void APercentileIsDrawnWhereTenFramesLieBeyondIt(int frames, double percent, bool drawn) =>
|
||||
PercentileCurve.Supported(frames, percent).Should().Be(drawn, "FR-4.8's guards are this rule: 1,000 frames for the 1% low, 10,000 for the 0.1%");
|
||||
|
||||
[Fact]
|
||||
public void TheCurveStopsWhereTheSessionHasNoFramesToSayMore()
|
||||
{
|
||||
(double[] small, _) = PercentileCurve.Of([.. Enumerable.Range(0, 100).Select(static i => 16.0 + (i * 0.01))]);
|
||||
small.First().Should().Be(10);
|
||||
small.Last().Should().Be(90);
|
||||
PercentileCurve.Lows([.. Enumerable.Repeat(16.0, 100)]).Should().BeEmpty();
|
||||
|
||||
(double[] mid, _) = PercentileCurve.Of([.. Enumerable.Repeat(16.0, 1_000)]);
|
||||
mid.Should().StartWith(1).And.EndWith(99).And.NotContain(0).And.NotContain(100);
|
||||
PercentileCurve.Lows([.. Enumerable.Repeat(16.0, 1_000)]).Should().ContainSingle().Which.X.Should().Be(99);
|
||||
|
||||
(double[] large, _) = PercentileCurve.Of([.. Enumerable.Repeat(16.0, 10_000)]);
|
||||
large.Should().Contain(0.1).And.Contain(99.9).And.BeInAscendingOrder();
|
||||
PercentileCurve.Lows([.. Enumerable.Repeat(16.0, 10_000)]).Should().HaveCount(2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TheFrametimeNoteSaysWhatTheLinesAreNot() => InEnglish(() =>
|
||||
{
|
||||
SessionSeries plain = SessionSeriesLoader.Decode(Blob([0, 10, 10], [4, 0, 0]), [], []);
|
||||
SessionSeries generating = SessionSeriesLoader.Decode(Blob([0, 1, 9, 1, 9], [4, 1, 0, 1, 0]), [], []);
|
||||
SessionSeries allGenerated = SessionSeriesLoader.Decode(Blob([0, 10, 10], [5, 1, 1]), [], []);
|
||||
SessionSeries gapped = SessionSeriesLoader.Decode(Blob([0, 10, 0, 10], [4, 0, 4, 0]) with { FirstPresentMs = 0 }, [], []);
|
||||
|
||||
FrametimeChart.NoteFor(plain, displayed: true, sensors: true).Should().BeEmpty();
|
||||
FrametimeChart.NoteFor(generating, displayed: false, sensors: false).Should().BeEmpty();
|
||||
FrametimeChart.NoteFor(generating, displayed: true, sensors: false).Should().Be(Strings.Chart_Note_PresentsTiming);
|
||||
FrametimeChart.NoteFor(allGenerated, displayed: false, sensors: false).Should().Be(Strings.Chart_Note_NoApplicationFrames);
|
||||
FrametimeChart.NoteFor(gapped, displayed: false, sensors: true).Should().Contain("1 gap");
|
||||
FrametimeChart.NoteFor(null, displayed: true, sensors: true).Should().BeEmpty();
|
||||
return 0;
|
||||
});
|
||||
|
||||
[Fact]
|
||||
public void TheSensorsAxisSaysWhereItsZeroIs() => InEnglish(() =>
|
||||
{
|
||||
SensorsChart.TimeAxisLabel(SessionSeriesLoader.Decode(Blob([0, 10], [4, 0]) with { FirstPresentMs = 0 }, [], [])).Should().Be(Strings.Chart_Axis_TimeFromFirstFrame);
|
||||
SensorsChart.TimeAxisLabel(SessionSeries.SensorsOnly([])).Should().Be(Strings.Chart_Axis_TimeFromStart);
|
||||
SensorsChart.TimeAxisLabel(null).Should().Be(Strings.Chart_Axis_TimeFromStart);
|
||||
return 0;
|
||||
});
|
||||
|
||||
/// <summary>
|
||||
/// beta.8: the light theme drew the GPU's power and the CPU's temperature in one gold, and the adapter's VRAM and the RAM
|
||||
/// likewise — two lines a reader could not tell apart. Every pair of lines on one plot is now ≥ 60 apart in RGB.
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData("ChartPalette.Dark.xaml")]
|
||||
[InlineData("ChartPalette.Light.xaml")]
|
||||
public void TheSensorsChartsLinesAreToldApartInEachTheme(string file)
|
||||
{
|
||||
Dictionary<string, (int R, int G, int B)> palette = Palette(file);
|
||||
|
||||
foreach (string[] plot in new[] { SensorsChart.TempsPlot.Select(static s => s.PaletteKey).ToArray(), SensorsChart.MemoryPlot.Select(static s => s.PaletteKey).ToArray() })
|
||||
{
|
||||
for (int i = 0; i < plot.Length; i++)
|
||||
{
|
||||
for (int j = i + 1; j < plot.Length; j++)
|
||||
{
|
||||
Distance(palette[plot[i]], palette[plot[j]]).Should().BeGreaterThanOrEqualTo(60, $"{plot[i]} and {plot[j]} are two lines on one plot in {file}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static readonly XNamespace _x = "http://schemas.microsoft.com/winfx/2006/xaml";
|
||||
private static readonly XNamespace _p = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
|
||||
|
||||
private static Dictionary<string, (int R, int G, int B)> Palette(string file)
|
||||
{
|
||||
string dir = AppContext.BaseDirectory;
|
||||
while (!File.Exists(Path.Combine(dir, "FrameLedger.slnx")))
|
||||
{
|
||||
dir = Path.GetDirectoryName(dir) ?? throw new InvalidOperationException("FrameLedger.slnx not found above the test binary");
|
||||
}
|
||||
|
||||
XDocument doc = XDocument.Load(Path.Combine(dir, "src", "FrameLedger.App", "Styles", file));
|
||||
return doc.Root!.Elements(_p + "Color").ToDictionary(
|
||||
e => (string)e.Attribute(_x + "Key")!,
|
||||
e => (Convert.ToInt32(e.Value.Substring(3, 2), 16), Convert.ToInt32(e.Value.Substring(5, 2), 16), Convert.ToInt32(e.Value.Substring(7, 2), 16)),
|
||||
StringComparer.Ordinal);
|
||||
}
|
||||
|
||||
private static double Distance((int R, int G, int B) a, (int R, int G, int B) b) =>
|
||||
Math.Sqrt(((a.R - b.R) * (a.R - b.R)) + ((a.G - b.G) * (a.G - b.G)) + ((a.B - b.B) * (a.B - b.B)));
|
||||
|
||||
private static FrameBlobs Blob(float[] frametimes, byte[] flags) => new()
|
||||
{
|
||||
Codec = SeriesCodec.Tag,
|
||||
SampleCount = frametimes.Length,
|
||||
FrameTimes = SeriesCodec.EncodeFloat32(frametimes),
|
||||
FrameFlags = SeriesCodec.EncodeBytes(flags),
|
||||
};
|
||||
|
||||
private static void InEnglish(Func<int> body)
|
||||
{
|
||||
System.Globalization.CultureInfo? previous = Strings.Culture;
|
||||
Strings.Culture = System.Globalization.CultureInfo.GetCultureInfo("en");
|
||||
try
|
||||
{
|
||||
body();
|
||||
}
|
||||
finally
|
||||
{
|
||||
Strings.Culture = previous;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -655,15 +655,76 @@ public sealed class GameDetailViewModelTests
|
||||
await pending;
|
||||
vm.SelectedHasSeries.Should().BeFalse();
|
||||
vm.SelectedNote.Should().Be(Strings.Tabs_SelectedNotHooked);
|
||||
vm.SelectedHasSensors.Should().BeFalse("this Tier-2 row recorded no sensor");
|
||||
vm.SensorsNote.Should().Be(Strings.Sensors_Empty);
|
||||
|
||||
vm.SelectedSession = vm.Sessions[1];
|
||||
Task pending2 = vm.Pending;
|
||||
await pending2;
|
||||
vm.SelectedHasSeries.Should().BeTrue();
|
||||
vm.SelectedSeries!.Presents.Should().Be(300);
|
||||
vm.SelectedHasSensors.Should().BeTrue();
|
||||
vm.SensorsNote.Should().BeEmpty();
|
||||
vm.HasLatency.Should().BeFalse("no Reflex on this session");
|
||||
}
|
||||
|
||||
/// <summary>beta.8: a session of this game that finishes while its page is shown reloads the page; another game's does not, nor one after the page left.</summary>
|
||||
[Fact]
|
||||
public async Task ASessionOfThisGameThatFinishesReloadsThePage()
|
||||
{
|
||||
await using ScratchLedger s = await ScratchLedger.OpenAsync();
|
||||
GameRow game = await s.GameAsync("Alpha");
|
||||
await s.SessionAsync(game.Id, DateTimeOffset.UtcNow.AddDays(-1));
|
||||
var link = new FakeAgentLink();
|
||||
var vm = new GameDetailViewModel(s.Library, new GameSelection { GameId = game.Id }, new HookingConsent(new FakeAgent(), new FakePrompt()), new FakeNavigator(),
|
||||
new FakeConfirmations(RemoveGameChoice.Cancel), new FakeEdit(null), new FakeStrip(), new NoSummaries(),
|
||||
new Charts.SessionSeriesLoader(s.Sessions), new Infrastructure.Persistence.SqliteHardwareSnapshotRepository(s.Db), new SessionSelection(),
|
||||
new FakePicker(null), agent: link);
|
||||
Task loaded = vm.Pending;
|
||||
await loaded;
|
||||
vm.Attach();
|
||||
vm.Attach(); // a second Loaded does not subscribe twice
|
||||
|
||||
long second = await s.SessionAsync(game.Id, DateTimeOffset.UtcNow);
|
||||
link.Raise(IpcMessageType.SessionCompleted, new SessionCompletedEvent(Guid.NewGuid(), second, "normal", 1, "saved", "exited", game.Id + 1, "Other"));
|
||||
Task other = vm.Pending;
|
||||
await other;
|
||||
vm.Sessions.Should().ContainSingle("another game's session is not this page's");
|
||||
|
||||
link.Raise(IpcMessageType.SessionCompleted, new SessionCompletedEvent(Guid.NewGuid(), second, "normal", 1, "saved", "exited", game.Id, "Alpha"));
|
||||
Task reloaded = vm.Pending;
|
||||
await reloaded;
|
||||
vm.Sessions.Should().HaveCount(2);
|
||||
|
||||
vm.Detach();
|
||||
await s.SessionAsync(game.Id, DateTimeOffset.UtcNow.AddMinutes(5));
|
||||
link.Raise(IpcMessageType.SessionCompleted, new SessionCompletedEvent(Guid.NewGuid(), second + 1, "normal", 1, "saved", "exited", game.Id, "Alpha"));
|
||||
Task after = vm.Pending;
|
||||
await after;
|
||||
vm.Sessions.Should().HaveCount(2, "the page left: nothing listens");
|
||||
}
|
||||
|
||||
/// <summary>beta.8: a session that was not hooked has its sensors, and the Sensors tab draws them instead of saying "not hooked".</summary>
|
||||
[Fact]
|
||||
public async Task ATierTwoSessionsSensorsAreTheSensorsTabs()
|
||||
{
|
||||
await using ScratchLedger s = await ScratchLedger.OpenAsync();
|
||||
GameRow game = await s.GameAsync("Alpha");
|
||||
await s.NotHookedWithSensorsAsync(game.Id, DateTimeOffset.UtcNow.AddDays(-1));
|
||||
(GameDetailViewModel vm, _, _, _, _) = await BuildAsync(s, game.Id);
|
||||
|
||||
vm.SelectedSession = vm.Sessions[0];
|
||||
Task pending = vm.Pending;
|
||||
await pending;
|
||||
|
||||
vm.SelectedHasSeries.Should().BeFalse("no frames");
|
||||
vm.SelectedNote.Should().Be(Strings.Tabs_SelectedNotHooked);
|
||||
vm.SelectedHasSensors.Should().BeTrue();
|
||||
vm.SensorsNote.Should().BeEmpty();
|
||||
vm.SelectedSensors!.Sensors.Select(static x => x.Name).Should().BeEquivalentTo("gpu_temp", "gpu_power");
|
||||
vm.SelectedSensors.SensorsAligned.Should().BeFalse("timed from the session's start: there is no first frame");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CapabilityFlagsReadAsProductNamesInEitherShape()
|
||||
{
|
||||
|
||||
@@ -39,7 +39,8 @@ internal sealed class ScratchLedger : IAsyncDisposable
|
||||
return await Games.EnsureAsync(new ExecutableFingerprint { ExePath = exe, SizeBytes = 1, MtimeUnixMs = 1 }, name, TestContext.Current.CancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
public async Task<long> SessionAsync(long gameId, DateTimeOffset startedAt, int seconds = 600, bool hooked = true, string fgMode = "none", double? native = 60, double? displayed = null, double? factor = null, ExitStatus exit = ExitStatus.Normal, string? fgRefusal = null, double? presented = null, string? qualifier = null)
|
||||
public async Task<long> SessionAsync(long gameId, DateTimeOffset startedAt, int seconds = 600, bool hooked = true, string fgMode = "none", double? native = 60, double? displayed = null, double? factor = null, ExitStatus exit = ExitStatus.Normal, string? fgRefusal = null, double? presented = null, string? qualifier = null,
|
||||
IReadOnlyList<SensorBlob>? sensors = null)
|
||||
{
|
||||
long snapshotId = await new SqliteHardwareSnapshotRepository(Db).EnsureAsync(new HardwareSnapshot { GpuName = "G" }, startedAt, TestContext.Current.CancellationToken).ConfigureAwait(false);
|
||||
var row = new SessionRow
|
||||
@@ -73,9 +74,17 @@ internal sealed class ScratchLedger : IAsyncDisposable
|
||||
P1LowFps = hooked ? 48 : null,
|
||||
MaxGpuTemp = 71,
|
||||
};
|
||||
return await Sessions.InsertFinalizedAsync(new FinalizedSession { Row = row }, TestContext.Current.CancellationToken).ConfigureAwait(false);
|
||||
return await Sessions.InsertFinalizedAsync(new FinalizedSession { Row = row, Sensors = sensors ?? [] }, TestContext.Current.CancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>A session that was not hooked, with the sensors a Tier-2 row keeps (since 2026-09-22): three ticks of GPU temperature and power.</summary>
|
||||
public Task<long> NotHookedWithSensorsAsync(long gameId, DateTimeOffset startedAt) => SessionAsync(gameId, startedAt, hooked: false, sensors:
|
||||
[
|
||||
new SensorBlob { Series = "t_ms", Hz = 1, Codec = FrameLedger.Infrastructure.Blobs.SeriesCodec.Tag, Data = FrameLedger.Infrastructure.Blobs.SeriesCodec.EncodeFloat32([500, 1500, 2500]) },
|
||||
new SensorBlob { Series = "gpu_temp", Hz = 1, Codec = FrameLedger.Infrastructure.Blobs.SeriesCodec.Tag, Data = FrameLedger.Infrastructure.Blobs.SeriesCodec.EncodeFloat32([55, 56, 57]) },
|
||||
new SensorBlob { Series = "gpu_power", Hz = 1, Codec = FrameLedger.Infrastructure.Blobs.SeriesCodec.Tag, Data = FrameLedger.Infrastructure.Blobs.SeriesCodec.EncodeFloat32([150, 160, 170]) },
|
||||
]);
|
||||
|
||||
/// <summary>A hooked session WITH blobs: <paramref name="frames"/> presents at 60 fps, a 4× spike every <paramref name="spikeEvery"/> frames, one segment, a gpu_temp series.</summary>
|
||||
public async Task<long> SessionWithFramesAsync(long gameId, DateTimeOffset startedAt, int frames, int spikeEvery)
|
||||
{
|
||||
@@ -103,6 +112,7 @@ internal sealed class ScratchLedger : IAsyncDisposable
|
||||
FrameTimes = FrameLedger.Infrastructure.Blobs.SeriesCodec.EncodeFloat32(frametimes),
|
||||
FrameFlags = FrameLedger.Infrastructure.Blobs.SeriesCodec.EncodeBytes(flags),
|
||||
FrameIndex = FrameLedger.Infrastructure.Blobs.SeriesCodec.EncodeUInt32(index),
|
||||
FirstPresentMs = 0, // schema 0013: the frames and the sensors share a zero, so the overlay is drawn
|
||||
},
|
||||
Sensors =
|
||||
[
|
||||
|
||||
@@ -41,19 +41,110 @@ public sealed class SessionSeriesLoaderTests
|
||||
s.Generated.Should().Equal(false, false, true, false, false, false);
|
||||
s.Gap.Should().Equal(true, false, false, false, true, false);
|
||||
s.HasGenerated.Should().BeTrue();
|
||||
// the first present, the generated one and the one after a gap are not application frames
|
||||
// the first present, the generated one and the one after a gap end no application frame; the third application
|
||||
// frame's time spans the generated present before it (beta.8: application frame to application frame)
|
||||
s.AppPresentIndex.Should().Equal(_appFrames);
|
||||
s.AppFrameTimesMs.Should().Equal(10, 10, 40);
|
||||
s.AppFrameTimesMs.Should().Equal(10, 20, 40);
|
||||
s.NoApplicationFrames.Should().BeFalse();
|
||||
s.Stutter.Should().BeNull("three frames is under the 19-frame window, so the detector answers null rather than a guess");
|
||||
s.Segments.Select(static g => g.StartS).Should().Equal(0, 0.03);
|
||||
s.Segments[0].Label.Should().StartWith("DLSS");
|
||||
SensorSeries gpu = s.Sensors.Should().ContainSingle().Which;
|
||||
gpu.Name.Should().Be("gpu_temp");
|
||||
gpu.TimesS.Should().Equal(0, 2);
|
||||
s.SensorsAligned.Should().BeFalse("a blob written before schema 0013 does not say where its first present sits");
|
||||
gpu.Values.Should().Equal(60, 62); // −1 is a tick with no reading, dropped
|
||||
s.PsoCreated![5].Should().Be(3);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// beta.8, the owner's Onimusha capture (DLSS FG ×3): each generated frame is submitted half a millisecond after its
|
||||
/// application frame. The "native" series was each application frame's interval to the present before it — a generated
|
||||
/// frame's half millisecond. It is application frame to application frame now.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void TheApplicationFramesTimeSpansTheGeneratedPresentsBeforeIt()
|
||||
{
|
||||
var frametimes = new List<float> { 0 };
|
||||
var flags = new List<byte> { 4 };
|
||||
for (int f = 0; f < 30; f++)
|
||||
{
|
||||
frametimes.AddRange([0.5f, 0.5f, 15.667f]);
|
||||
flags.AddRange([1, 1, 0]);
|
||||
}
|
||||
|
||||
SessionSeries s = SessionSeriesLoader.Decode(Blob([.. frametimes], [.. flags]), [], []);
|
||||
|
||||
s.AppFrameTimesMs.Should().HaveCount(30).And.AllSatisfy(static ft => ft.Should().BeApproximately(16.667, 0.001));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EveryPresentGeneratedIsChartedAsPresentsAndSaysSo()
|
||||
{
|
||||
// The no_evaluations shape: frame generation counted and no application frame's token arrived.
|
||||
SessionSeries s = SessionSeriesLoader.Decode(Blob([0, 10, 10, 10], [5, 1, 1, 1]), [], []);
|
||||
|
||||
s.NoApplicationFrames.Should().BeTrue();
|
||||
s.AppFrameTimesMs.Should().Equal(10, 10, 10);
|
||||
}
|
||||
|
||||
/// <summary>beta.8: a session that presented to two swapchains is charted on the one its statistics are over, with that stream's segments.</summary>
|
||||
[Fact]
|
||||
public void OnlyTheDominantStreamIsCharted()
|
||||
{
|
||||
// Stream 7 (a launcher window) presents twice; stream 3 five times. Intervals are per stream, as the finalizer stores them.
|
||||
FrameBlobs frames = Blob([0, 0, 16, 100, 16, 16, 16], [4, 4, 0, 0, 0, 0, 0]) with
|
||||
{
|
||||
SwapchainIds = SeriesCodec.EncodeUInt32([7, 3, 3, 7, 3, 3, 3]),
|
||||
FrameIndex = SeriesCodec.EncodeUInt32([0, 1, 2, 3, 4, 5, 6]),
|
||||
};
|
||||
SegmentRow[] segments = [new() { SwapchainId = 7, StartFrame = 0, EndFrame = 3 }, new() { SwapchainId = 3, StartFrame = 1, EndFrame = 6 }];
|
||||
|
||||
SessionSeries s = SessionSeriesLoader.Decode(frames, segments, []);
|
||||
|
||||
s.Presents.Should().Be(5);
|
||||
s.FrameIndex.Should().Equal(1u, 2u, 4u, 5u, 6u);
|
||||
s.AppFrameTimesMs.Should().Equal(16, 16, 16, 16);
|
||||
s.Segments.Should().ContainSingle("stream 7's segment is not on this axis");
|
||||
}
|
||||
|
||||
/// <summary>Schema 0013: the first present's place on the sensors' clock puts the sensors on the frames' axis — before it, negative.</summary>
|
||||
[Fact]
|
||||
public void SensorsAreOnTheFramesAxisWhenTheBlobSaysWhereTheFirstPresentIs()
|
||||
{
|
||||
SensorBlob[] sensors =
|
||||
[
|
||||
new() { Series = "t_ms", Hz = 1, Codec = SeriesCodec.Tag, Data = SeriesCodec.EncodeFloat32([0, 5000, 10000]) },
|
||||
new() { Series = "gpu_temp", Hz = 1, Codec = SeriesCodec.Tag, Data = SeriesCodec.EncodeFloat32([50, 60, 70]) },
|
||||
];
|
||||
|
||||
SessionSeries s = SessionSeriesLoader.Decode(Blob([0, 10, 10], [4, 0, 0]) with { FirstPresentMs = 5000 }, [], sensors);
|
||||
|
||||
s.SensorsAligned.Should().BeTrue();
|
||||
s.Sensors.Should().ContainSingle().Which.TimesS.Should().Equal(-5, 0, 5);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ATierTwoSessionsSensorsLoadOnTheirOwn()
|
||||
{
|
||||
await using ScratchLedger s = await ScratchLedger.OpenAsync();
|
||||
GameRow game = await s.GameAsync("Alpha");
|
||||
long id = await s.NotHookedWithSensorsAsync(game.Id, DateTimeOffset.UtcNow);
|
||||
|
||||
IReadOnlyList<SensorSeries> sensors = await new SessionSeriesLoader(s.Sessions).LoadSensorsAsync(id, Ct);
|
||||
|
||||
sensors.Select(static x => x.Name).Should().BeEquivalentTo("gpu_temp", "gpu_power");
|
||||
sensors[0].TimesS.Should().Equal(0.5, 1.5, 2.5);
|
||||
}
|
||||
|
||||
private static FrameBlobs Blob(float[] frametimes, byte[] flags) => new()
|
||||
{
|
||||
Codec = SeriesCodec.Tag,
|
||||
SampleCount = frametimes.Length,
|
||||
FrameTimes = SeriesCodec.EncodeFloat32(frametimes),
|
||||
FrameFlags = SeriesCodec.EncodeBytes(flags),
|
||||
};
|
||||
|
||||
[Fact]
|
||||
public async Task ATierTwoSessionOrOneWithoutABlobLoadsAsNull()
|
||||
{
|
||||
|
||||
@@ -66,6 +66,8 @@ public sealed class SessionSummaryViewModelTests
|
||||
vm.Chips.Should().HaveCount(3);
|
||||
vm.Chips[0].IsYes.Should().BeTrue();
|
||||
vm.DecimationNote.Should().Contain("300");
|
||||
vm.HasSensors.Should().BeTrue("the blob says where the first present is, so the overlay is drawn in step");
|
||||
vm.HasSensorCharts.Should().BeTrue();
|
||||
|
||||
SessionSummaryViewModel two = Build(s);
|
||||
await two.LoadAsync(tier2, Ct);
|
||||
@@ -73,6 +75,16 @@ public sealed class SessionSummaryViewModelTests
|
||||
two.Series.Should().BeNull();
|
||||
two.Stats.Single(c => string.Equals(c.Label, "Median", StringComparison.Ordinal)).Value.Should().Be("N/A");
|
||||
two.Stats.Single(c => string.Equals(c.Label, "Average", StringComparison.Ordinal)).Value.Should().Be("N/A");
|
||||
two.HasSensorCharts.Should().BeFalse("this Tier-2 row recorded no sensor");
|
||||
|
||||
// beta.8: a Tier-2 session with sensors charts them — no overlay, there are no frames to lay them over.
|
||||
long sensed = await s.NotHookedWithSensorsAsync(game.Id, DateTimeOffset.UtcNow.AddHours(-2));
|
||||
SessionSummaryViewModel three = Build(s);
|
||||
await three.LoadAsync(sensed, Ct);
|
||||
three.Series.Should().BeNull();
|
||||
three.HasSensors.Should().BeFalse();
|
||||
three.HasSensorCharts.Should().BeTrue();
|
||||
three.SensorSeries!.Sensors.Should().HaveCount(2);
|
||||
|
||||
SessionSummaryViewModel missing = Build(s);
|
||||
await missing.LoadAsync(tier2 + 99, Ct);
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
using System.Diagnostics;
|
||||
using FluentAssertions;
|
||||
using FrameLedger.Application.AntiCheat;
|
||||
using FrameLedger.Application.Capture;
|
||||
@@ -393,6 +394,86 @@ public sealed class CaptureSessionTests : IAsyncDisposable
|
||||
guard.EvaluateCalls.Should().BeGreaterThan(scansBeforePause, "supervision keeps scanning while the recording is paused");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// beta.8: the Overlay records nothing while paused, so the first record after a resume is QPC-apart from the last one
|
||||
/// before the pause by the whole pause — a fabricated long frame in every statistic, and time the averages counted.
|
||||
/// It follows a gap now, like a torn slot's survivor.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task TheFirstRecordPresentedAfterAResumeFollowsAGap()
|
||||
{
|
||||
IGameConsentStore store = await StoreWithAsync().ConfigureAwait(true);
|
||||
var guard = new CountingGuard();
|
||||
var pause = new SwitchablePause();
|
||||
using var sink = new PresentingSink();
|
||||
using var alive = new FakeLiveness();
|
||||
using var stop = new CancellationTokenSource();
|
||||
var loop = new CaptureSession(store, new HookedCaptureGate(guard), guard, new FixedResolver(_pid, SessionEndReason.Running),
|
||||
new DelegateLivenessSource(_ => alive), new DelegateRingAttacher(_ => (sink, ShmAttachRefusal.Ok)),
|
||||
new CaptureOptions
|
||||
{
|
||||
DrainInterval = TimeSpan.FromMilliseconds(1),
|
||||
ScanInterval = TimeSpan.FromSeconds(30),
|
||||
AttachBudget = TimeSpan.FromSeconds(5),
|
||||
MaxDuration = TimeSpan.FromSeconds(30),
|
||||
LogFlushGrace = TimeSpan.FromMilliseconds(1),
|
||||
}, pause: pause);
|
||||
|
||||
Task<CaptureOutcome> running = loop.RunAsync(_exe, Fingerprint, "payload.dll", TestContext.Current.CancellationToken, stop.Token);
|
||||
await Task.Delay(30, TestContext.Current.CancellationToken).ConfigureAwait(true);
|
||||
pause.IsPaused = true;
|
||||
await Task.Delay(120, TestContext.Current.CancellationToken).ConfigureAwait(true);
|
||||
pause.IsPaused = false;
|
||||
await Task.Delay(30, TestContext.Current.CancellationToken).ConfigureAwait(true);
|
||||
await stop.CancelAsync().ConfigureAwait(true);
|
||||
CaptureOutcome r = await running.ConfigureAwait(true);
|
||||
|
||||
// The pause is the one long interval in the stream; the record that ends it is the one after the resume.
|
||||
int afterResume = Enumerable.Range(1, r.Records.Count - 1).MaxBy(i => r.Records[i].Qpc - r.Records[i - 1].Qpc);
|
||||
(r.Records[afterResume].Qpc - r.Records[afterResume - 1].Qpc).Should().BeGreaterThan((ulong)(Stopwatch.Frequency / 20), "the pause lasted 120 ms");
|
||||
r.GapBefore.Should().ContainSingle().Which.Should().Be(afterResume, "the interval that spans the pause is not a frame time");
|
||||
}
|
||||
|
||||
/// <summary>A ring the Overlay writes one record into per drain while it is not paused, stamped with the QPC as the Overlay's present is.</summary>
|
||||
private sealed class PresentingSink : ICaptureSink
|
||||
{
|
||||
private bool _paused;
|
||||
private uint _frame;
|
||||
|
||||
public FlWriterState WriterState => new() { Status = (uint)FlStatus.Ready };
|
||||
|
||||
public FlShmHandshake Handshake => default;
|
||||
|
||||
public long TotalDropped => 0;
|
||||
|
||||
public long TotalGaps => 0;
|
||||
|
||||
public DrainResult Drain(Span<FlFrameRecord> into, IList<ulong> gapIndices)
|
||||
{
|
||||
if (Volatile.Read(ref _paused))
|
||||
{
|
||||
return new DrainResult(0, 0, 0);
|
||||
}
|
||||
|
||||
into[0] = new FlFrameRecord { FrameIndex = _frame++, Qpc = (ulong)Stopwatch.GetTimestamp(), SwapchainId = 1 };
|
||||
return new DrainResult(1, 0, 0);
|
||||
}
|
||||
|
||||
public void PublishGuardResult(uint completedEvaluations, bool unhookRequested)
|
||||
{
|
||||
}
|
||||
|
||||
public void SetPaused(bool paused) => Volatile.Write(ref _paused, paused);
|
||||
|
||||
public void RequestLogFlush()
|
||||
{
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task TheModuleSnapshotIsTakenBesideEveryGuardScanAndOnceMoreBeforeTheLastDrain()
|
||||
{
|
||||
|
||||
@@ -162,16 +162,18 @@ public sealed class SessionProgressCalculatorTests
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AGapInsideTheWindowReadsAsPresentsThatAreNotThereNotAsAFasterRate()
|
||||
public void AGapInsideTheWindowIsTimeNothingWasMeasuredIn()
|
||||
{
|
||||
// 50 records dropped from the middle of the last 5 s, with the gap marked at the record that follows:
|
||||
// the presented rate is the presents that exist over the window (the row's PresentedFps rule), so it
|
||||
// reads 90, and the window says so with its count rather than stretching the survivors to 100.
|
||||
// 50 records dropped from the middle of the last 5 s, with the gap marked at the record that follows. Until beta.8
|
||||
// the rate was the presents that survived over the whole window — 90, a rate nobody measured: the game presented
|
||||
// the lost 50 at the same 100, and a drop is the Agent falling behind, not the game. The rate is now over the time the
|
||||
// kept intervals span (the row's PresentedFps rule, FrameTimeSeries.MeasuredSeconds), which a pause (FR-3.9) needs as
|
||||
// well: its minutes are a gap since beta.8, and they held no frame anyone saw. The count still says 450.
|
||||
List<FlFrameRecord> records = SessionFixtures.Stream(1000, FlMeasured.OutputRes);
|
||||
records.RemoveRange(700, 50);
|
||||
SessionProgressEvent e = SessionProgressCalculator.Compute(_guid, Progress(records, gaps: [700]), SessionFixtures.QpcFrequency, 10, gpu: null);
|
||||
|
||||
e.Presents5s.Should().BeInRange(445, 455);
|
||||
e.PresentedFps5s.Should().BeApproximately(90, 1.5, "450 presents over 5 s — the missing frames are missing, not invented");
|
||||
e.PresentedFps5s.Should().BeApproximately(100, 1.5, "450 presents over the 4.5 s they span — the survivors' rate, and no frame invented");
|
||||
}
|
||||
}
|
||||
@@ -148,6 +148,59 @@ public sealed class SessionAggregatorTests
|
||||
x2.DisplayedP1LowFps.Should().NotBeNull();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// beta.8 (03_METRICS §Core definitions, "Lows use application frames only"): a session that counted generated frames
|
||||
/// takes its median, lows, min / max, σ and stutter over application frames. The shape is the owner's Onimusha capture —
|
||||
/// each generated frame submitted half a millisecond after its application frame — where the statistics over presents
|
||||
/// put the 1% low above the native average and the median at a generated frame's half millisecond.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void AGeneratingSessionsFrameStatisticsAreOverApplicationFrames()
|
||||
{
|
||||
var writer = new FlWriterState { Status = 1, HooksInstalledMask = 0xB, RuntimeCensus = (uint)(FlRuntimeCensus.Ran | FlRuntimeCensus.SlInterposer | FlRuntimeCensus.SlDlssG) };
|
||||
FlMeasured claims = _presentOnly | FlMeasured.Fg | FlMeasured.FgCounts;
|
||||
var records = new List<FlFrameRecord>();
|
||||
for (int f = 0; f < 1_500; f++)
|
||||
{
|
||||
// 20 ms per application frame on the fixtures' 10 MHz clock; its generated frame 0.5 ms behind it.
|
||||
ulong app = SessionFixtures.QpcEpoch + 10_000_000 + ((ulong)f * 200_000);
|
||||
records.Add(new FlFrameRecord { FrameIndex = (uint)(2 * f), Qpc = app, SwapchainId = 1, Api = (byte)FlApi.D3D12, MeasuredMask = (ushort)claims, FgEvaluations = 1, FgMode = (byte)FlFgMode.DlssG });
|
||||
records.Add(new FlFrameRecord { FrameIndex = (uint)((2 * f) + 1), Qpc = app + 5_000, SwapchainId = 1, Api = (byte)FlApi.D3D12, MeasuredMask = (ushort)claims, FgMode = (byte)FlFgMode.DlssG });
|
||||
}
|
||||
|
||||
AggregationResult r = SessionAggregator.Aggregate(SessionFixtures.Skeleton(), SessionFixtures.Hooked(records, writer));
|
||||
SessionRow row = r.Row;
|
||||
|
||||
r.FgVerdict.Should().Be(FgVerdict.Named);
|
||||
row.FgFactor.Should().BeApproximately(2, 0.01);
|
||||
row.NativeFps.Should().BeApproximately(50, 0.1);
|
||||
row.MedianFps.Should().BeApproximately(50, 0.01, "application frame to application frame, not the half millisecond to a generated one");
|
||||
row.P1LowFps.Should().BeApproximately(50, 0.01).And.BeLessThanOrEqualTo(row.NativeFps!.Value + 0.01, "a low is never above the average it is a low of");
|
||||
row.MinFps.Should().BeApproximately(50, 0.01);
|
||||
row.MaxFps.Should().BeApproximately(50, 0.01);
|
||||
row.FrametimeStdDevMs.Should().BeApproximately(0, 1e-6);
|
||||
row.StutterCount.Should().Be(0);
|
||||
row.DisplayedP1LowFps.Should().BeApproximately(1000 / 19.5, 0.01, "the Displayed low stays over every present");
|
||||
r.Segments.Should().ContainSingle().Which.P1LowFps.Should().BeApproximately(50, 0.01, "the segment's low is over the frames the session's is");
|
||||
}
|
||||
|
||||
/// <summary>A technology named and no application frame counted: no frame statistic, rather than one over presents that include generated frames.</summary>
|
||||
[Fact]
|
||||
public void ANamedSessionThatCountedNoApplicationFrameHasNoFrameStatistics()
|
||||
{
|
||||
var writer = new FlWriterState { Status = 1, HooksInstalledMask = 0xB, RuntimeCensus = (uint)(FlRuntimeCensus.Ran | FlRuntimeCensus.SlInterposer | FlRuntimeCensus.SlDlssG) };
|
||||
List<FlFrameRecord> zeroTokens = [.. SessionFixtures.Stream(2_000, _presentOnly | FlMeasured.Fg | FlMeasured.FgCounts).Select(static r => r with { FgMode = (byte)FlFgMode.DlssG, FgEvaluations = 0 })];
|
||||
|
||||
SessionRow row = SessionAggregator.Aggregate(SessionFixtures.Skeleton(), SessionFixtures.Hooked(zeroTokens, writer)).Row;
|
||||
|
||||
row.FgRefusal.Should().Be("no_evaluations");
|
||||
row.MedianFps.Should().BeNull();
|
||||
row.P1LowFps.Should().BeNull();
|
||||
row.MinFps.Should().BeNull();
|
||||
row.StutterCount.Should().BeNull();
|
||||
row.PresentedFps.Should().BeApproximately(100, 0.01, "the presented rate stands alone, with its qualifier");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ANamedUpscalerWithParametersFillsTheExtentAndTheSegment()
|
||||
{
|
||||
|
||||
@@ -70,6 +70,23 @@ public sealed class SessionFinalizerTests
|
||||
frames.FrameIndex.Should().NotBeNull("the writer's counter is always there");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Schema 0013 (beta.8): the charted stream's first present on the sensors' clock, so the frametime chart can draw them in
|
||||
/// step. The charts draw the dominant stream, so a smaller stream that presented first (a launcher window) is not the zero.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void TheChartedStreamsFirstPresentIsPlacedOnTheSensorsClock()
|
||||
{
|
||||
(SessionFinalizer finalizer, _) = Make();
|
||||
List<FlFrameRecord> records = SessionFixtures.Stream(100, FlMeasured.OutputRes | FlMeasured.PresentArgs);
|
||||
records.Insert(0, records[0] with { SwapchainId = 2, Qpc = SessionFixtures.QpcEpoch + 2_000_000 });
|
||||
|
||||
FrameBlobs frames = finalizer.Build(new FinalizeInput { Skeleton = SessionFixtures.Skeleton(), Hooked = SessionFixtures.Hooked(records) }).Frames!;
|
||||
|
||||
frames.FirstPresentMs.Should().BeApproximately(1_000, 1e-9, "the dominant stream's first present, 10,000,000 ticks at 10 MHz after the epoch");
|
||||
SessionFinalizer.FirstPresentMs([], SessionFixtures.QpcEpoch, SessionFixtures.QpcFrequency).Should().BeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AConstantRenderResolutionIsNotStoredPerFrame()
|
||||
{
|
||||
|
||||
@@ -80,6 +80,22 @@ public sealed class FgWindowTests
|
||||
"Native x Factor must reconstruct Displayed, or the trio does not describe one window");
|
||||
}
|
||||
|
||||
/// <summary>beta.8: a pause is a gap, and the rates are over the time that was measured — not spread over the paused minute.</summary>
|
||||
[Fact]
|
||||
public void ThePausedMinuteIsNotInTheRatesTimeBase()
|
||||
{
|
||||
List<FrameSample> before = FgStream(appFrames: 40, k: 2);
|
||||
List<FrameSample> after = FgStream(appFrames: 40, k: 2, startQpc: before[^1].Qpc + (60 * (ulong)Frequency));
|
||||
List<FrameSample> stream = [.. before, .. after];
|
||||
FgWindow unpaused = FgWindow.From(FgStream(appFrames: 80, k: 2), Frequency);
|
||||
|
||||
FgWindow w = FgWindow.From(stream, Frequency, new HashSet<int> { before.Count });
|
||||
|
||||
w.Factor.Should().BeApproximately(2, 0.01);
|
||||
w.NativeFps.Should().BeApproximately(unpaused.NativeFps!.Value, 1.0, "the minute paused measured nothing");
|
||||
w.DisplayedFps.Should().BeApproximately(unpaused.DisplayedFps!.Value, 2.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnFgStateChangeMidSessionRefusesRatherThanAveraging()
|
||||
{
|
||||
|
||||
@@ -49,6 +49,10 @@ public sealed class FrameTimeSeriesTests
|
||||
s.EndingSample.Should().Equal(1, 3);
|
||||
s.ExcludedForGaps.Should().Be(1);
|
||||
s.DurationSeconds.Should().BeApproximately(0.05, 1e-9, "the session's wall clock still spans the gap");
|
||||
|
||||
// beta.8: the average is over the time that was measured — a pause is a gap since then, and its minutes held no frame.
|
||||
s.MeasuredSeconds.Should().BeApproximately(0.02, 1e-9);
|
||||
s.AverageFps.Should().BeApproximately(100, 1e-6);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
@@ -80,4 +84,110 @@ public sealed class FrameTimeSeriesTests
|
||||
[Fact]
|
||||
public void AZeroFrequencyIsRefused() =>
|
||||
FluentActions.Invoking(() => FrameTimeSeries.From(Stream(2), null, 0)).Should().Throw<ArgumentOutOfRangeException>();
|
||||
|
||||
[Fact]
|
||||
public void ApplicationFramesAreTheIntervalsBetweenThePresentsThatCarriedOne()
|
||||
{
|
||||
// ×3: every third present drained the application frame's token.
|
||||
List<FrameSample> stream = FgStream(appFrames: 5, k: 3);
|
||||
|
||||
FrameTimeSeries s = FrameTimeSeries.ApplicationFrames(stream, null, Frequency);
|
||||
|
||||
s.FrameTimesMs.Should().HaveCount(4).And.AllSatisfy(ft => ft.Should().BeApproximately(3 * Step * 1000.0 / Frequency, 1e-9));
|
||||
s.EndingSample.Should().Equal(3, 6, 9, 12);
|
||||
s.Presents.Should().Be(5, "the application-frame presents, not every present");
|
||||
s.DurationSeconds.Should().BeApproximately(12.0 * Step / Frequency, 1e-9);
|
||||
s.ExcludedForGaps.Should().Be(0);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The measured shape (the owner's Onimusha demo capture, DLSS FG ×3, 2026-09-25): each generated frame is submitted half
|
||||
/// a millisecond after its application frame. Over presents the median frame is half a millisecond — 2,000 FPS on a
|
||||
/// 60 FPS game; application frame to application frame is the 16.7 ms the game ran at.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void GeneratedPresentsSubmittedInABurstDoNotShortenTheApplicationFrame()
|
||||
{
|
||||
var stream = new List<FrameSample>();
|
||||
for (int f = 0; f < 40; f++)
|
||||
{
|
||||
ulong app = 1_000_000 + (ulong)(f * 16_667);
|
||||
stream.Add(Counted(app, tokens: 1));
|
||||
stream.Add(Counted(app + 500, tokens: 0));
|
||||
stream.Add(Counted(app + 1_000, tokens: 0));
|
||||
}
|
||||
|
||||
FrameTimeSeries presents = FrameTimeSeries.From(stream, null, Frequency);
|
||||
FrameTimeSeries application = FrameTimeSeries.ApplicationFrames(stream, null, Frequency);
|
||||
|
||||
FrameStatistics.From(presents.FrameTimesMs, presented: true).MedianFps.Should().BeApproximately(2000, 1);
|
||||
FrameStatistics.From(application.FrameTimesMs, presented: false).MedianFps.Should().BeApproximately(60, 0.01);
|
||||
application.Count.Should().Be(39);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AGapInsideAnApplicationFrameExcludesThatIntervalOnly()
|
||||
{
|
||||
List<FrameSample> stream = FgStream(appFrames: 4, k: 2);
|
||||
|
||||
// The gap sits before sample 5, a generated present between application frames 4 and 6.
|
||||
FrameTimeSeries s = FrameTimeSeries.ApplicationFrames(stream, new HashSet<int> { 5 }, Frequency);
|
||||
|
||||
s.EndingSample.Should().Equal(2, 4);
|
||||
s.ExcludedForGaps.Should().Be(1);
|
||||
s.Presents.Should().Be(4);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ASampleThatDoesNotClaimTheCountBreaksTheChain()
|
||||
{
|
||||
// Two uncounted presents lead (the hook installed late), and one in the middle: nobody said whether it was generated.
|
||||
List<FrameSample> counted = FgStream(appFrames: 4, k: 2, startQpc: 3_000_000);
|
||||
List<FrameSample> stream = [Present(1_000_000), Present(2_000_000), .. counted];
|
||||
stream[5] = stream[5] with { Measured = MeasuredFields.OutputRes | MeasuredFields.PresentArgs };
|
||||
|
||||
FrameTimeSeries s = FrameTimeSeries.ApplicationFrames(stream, null, Frequency);
|
||||
|
||||
s.EndingSample.Should().Equal(4, 8); // sample 6's interval spans the uncounted sample 5
|
||||
s.ExcludedForGaps.Should().Be(1);
|
||||
s.Presents.Should().Be(4, "the leading uncounted presents are not application frames");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AStreamThatCountedNoApplicationFrameHasNoSeries()
|
||||
{
|
||||
List<FrameSample> stream = [.. FgStream(appFrames: 3, k: 2).Select(static s => s with { FgEvaluations = 0 })];
|
||||
|
||||
FrameTimeSeries s = FrameTimeSeries.ApplicationFrames(stream, null, Frequency);
|
||||
|
||||
s.Count.Should().Be(0);
|
||||
s.Presents.Should().Be(0);
|
||||
s.DurationSeconds.Should().Be(0);
|
||||
s.AverageFps.Should().BeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnApplicationFrameTheClockDidNotAdvanceToIsNotAFrameTime()
|
||||
{
|
||||
List<FrameSample> stream = FgStream(appFrames: 3, k: 1);
|
||||
stream.Add(stream[0]); // a lapped drain returned an older record last
|
||||
|
||||
FrameTimeSeries s = FrameTimeSeries.ApplicationFrames(stream, null, Frequency);
|
||||
|
||||
s.Count.Should().Be(2);
|
||||
s.ExcludedNonPositive.Should().Be(1);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ApplicationFramesRefuseAZeroFrequency() =>
|
||||
FluentActions.Invoking(() => FrameTimeSeries.ApplicationFrames(FgStream(2, 2), null, 0)).Should().Throw<ArgumentOutOfRangeException>();
|
||||
|
||||
private static FrameSample Counted(ulong qpc, byte tokens) => new()
|
||||
{
|
||||
Qpc = qpc,
|
||||
SwapchainId = 1,
|
||||
Measured = MeasuredFields.OutputRes | MeasuredFields.PresentArgs | MeasuredFields.Fg | MeasuredFields.FgCounts,
|
||||
FgEvaluations = tokens,
|
||||
FgMode = FgKind.DlssG,
|
||||
};
|
||||
}
|
||||
@@ -52,6 +52,18 @@ public sealed class RecordWindowTests
|
||||
RecordWindow.SecondsOf(stream, 4, Frequency).Should().Be(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SecondsLeaveOutTheIntervalIntoAGap()
|
||||
{
|
||||
// beta.8: a pause (FR-3.9) is a gap before the first record after the resume, and its minute measured nothing.
|
||||
List<FrameSample> stream = Stream(4, step: Frequency / 100);
|
||||
stream.Add(Present(stream[^1].Qpc + (60 * Frequency)));
|
||||
stream.Add(Present(stream[^1].Qpc + (Frequency / 100)));
|
||||
|
||||
RecordWindow.SecondsOf(stream, 0, Frequency, new HashSet<int> { 4 }).Should().BeApproximately(0.04, 1e-9);
|
||||
RecordWindow.SecondsOf(stream, 0, Frequency).Should().BeApproximately(60.04, 1e-9, "without the gap set, the pause is time");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AZeroFrequencyIsRefused() =>
|
||||
FluentActions.Invoking(() => RecordWindow.SecondsOf(Stream(2), 0, 0)).Should().Throw<ArgumentOutOfRangeException>();
|
||||
|
||||
@@ -133,6 +133,31 @@ public sealed class LedgerDatabaseTests
|
||||
cancellationToken: Ct)).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>Schema 0013 (2026-09-25): <c>frame_blobs.first_present_ms</c>, NULL for every row written before.</summary>
|
||||
[Fact]
|
||||
public async Task ScriptThirteenAddsTheFirstPresentColumn()
|
||||
{
|
||||
await using LedgerFixture f = await LedgerFixture.OpenAsync();
|
||||
MigrationRunner.LatestVersion.Should().BeGreaterThanOrEqualTo(13);
|
||||
string path = f.Path;
|
||||
await f.Db.DisposeAsync().ConfigureAwait(true);
|
||||
var c12 = new SqliteConnection(new SqliteConnectionStringBuilder { DataSource = path, Pooling = false }.ToString());
|
||||
await using (c12.ConfigureAwait(true))
|
||||
{
|
||||
await c12.OpenAsync(Ct).ConfigureAwait(true);
|
||||
await RewindToAsync(c12, 12).ConfigureAwait(true);
|
||||
}
|
||||
|
||||
LedgerDatabase migrated = await LedgerDatabase.OpenAsync(path, ct: Ct).ConfigureAwait(true);
|
||||
await using (migrated.ConfigureAwait(true))
|
||||
{
|
||||
migrated.SchemaVersion.Should().Be(MigrationRunner.LatestVersion);
|
||||
long columns = await migrated.ReadAsync((c, ct) => c.ExecuteScalarAsync<long>(new CommandDefinition(
|
||||
"SELECT COUNT(*) FROM pragma_table_info('frame_blobs') WHERE name = 'first_present_ms'", cancellationToken: ct)), Ct).ConfigureAwait(true);
|
||||
columns.Should().Be(1);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Schema 0012 (2026-09-25): <c>sessions.driver_profile</c>, NULL for every row written before.</summary>
|
||||
[Fact]
|
||||
public async Task ScriptTwelveAddsTheDriverProfileColumn()
|
||||
|
||||
@@ -64,6 +64,7 @@ public sealed class SqliteSessionRepositoryTests
|
||||
FrameTimes = SeriesCodec.EncodeFloat32([.. Enumerable.Repeat(16.6f, n)]),
|
||||
FrameFlags = SeriesCodec.EncodeBytes(new byte[n]),
|
||||
LatencyUs = SeriesCodec.EncodeUInt32([.. Enumerable.Repeat(12_000u, n)]),
|
||||
FirstPresentMs = 18_250.5,
|
||||
};
|
||||
|
||||
[Fact]
|
||||
@@ -96,6 +97,7 @@ public sealed class SqliteSessionRepositoryTests
|
||||
kinds.Should().Be("null/blob/null", "an optional series that was not measured is stored as NULL");
|
||||
frames.RenderRes.HasValue.Should().BeFalse("nothing varied, so the column stayed NULL");
|
||||
frames.LatencyUs.HasValue.Should().BeTrue();
|
||||
frames.FirstPresentMs.Should().Be(18_250.5, "schema 0013: where the charted stream starts on the sensors' clock");
|
||||
|
||||
// unix-ms on the row itself, and the tri-state text is what 06_DATA_MODEL says.
|
||||
(long startedAt, string? fg, string? rt) = await f.Db.ReadAsync(async (c, ct) => (
|
||||
|
||||
Reference in new issue
Block a user