mirror of
https://github.com/SpeedBreakerProject/speedbreaker.git
synced 2026-10-18 13:01:22 +02:00
d4c206ab98
Co-authored-by: love-gamer <340996855+love-gamer@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
617 lines
31 KiB
C++
617 lines
31 KiB
C++
// Tests for game::WholeVblanks (runtime/game/whole_vblanks.h): the guest
|
|
// vblanks GameFrameTime gives each frame as its game time. From the repo root:
|
|
// clang++ -std=c++20 -O2 -Iruntime tests/whole_vblanks_test.cpp -o build/whole_vblanks_test
|
|
// build/whole_vblanks_test [frames.csv[@30] ...]
|
|
// Without arguments: synthetic frames against vblanks. With NFSMW_GAME_TIME_LOG
|
|
// files (measured_ms,vblanks,...; "@30" after a path: Frame Rate 30): also the
|
|
// game time each rule gives their frames (all but loads: those of 0 to
|
|
// WholeVblanks::kLoadVblanks), against the measured time and the vblanks that
|
|
// fired.
|
|
#include <game/whole_vblanks.h>
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <fstream>
|
|
#include <random>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
static int g_failures = 0;
|
|
#define CHECK(cond, ...) do { if (!(cond)) { g_failures++; printf(" FAIL %s:%d: %s: ", __FILE__, __LINE__, #cond); printf(__VA_ARGS__); printf("\n"); } } while (0)
|
|
|
|
namespace
|
|
{
|
|
constexpr double kRefreshMs = 1000.0 / 60.0;
|
|
|
|
// The rule until 2026-10-07: the count when the measured time is within
|
|
// half a vblank of it, else the measured time.
|
|
uint64_t HalfVblankRule(double measuredMs, uint64_t vblanks, double vblankMs)
|
|
{
|
|
if (vblanks < 1 || vblanks > 6)
|
|
return 0;
|
|
return std::abs(measuredMs / vblankMs - double(vblanks)) > 0.5 ? 0 : vblanks;
|
|
}
|
|
|
|
// The rule from 2026-10-07 to 2026-10-11: each frame its own count,
|
|
// game time level with the vblanks after every frame (a frame that saw
|
|
// none kept its measured time and was given back by the next ones).
|
|
struct CountRule
|
|
{
|
|
double ahead = 0.0;
|
|
uint64_t Give(double measuredMs, uint64_t vblanks, double vblankMs)
|
|
{
|
|
if (vblanks > 6)
|
|
{
|
|
ahead = 0.0;
|
|
return 0;
|
|
}
|
|
if (vblanks == 0)
|
|
{
|
|
ahead = std::min(ahead + std::max(measuredMs, 0.0) / vblankMs, 6.0);
|
|
return 0;
|
|
}
|
|
double owed = double(vblanks) - ahead;
|
|
int64_t give = std::clamp<int64_t>(std::llround(owed), 1, 6);
|
|
ahead = double(give) - owed;
|
|
return uint64_t(give);
|
|
}
|
|
};
|
|
|
|
// v0.1.3's rule (2026-10-11 to 2026-10-12): as WholeVblanks, but a
|
|
// frame of more than 6 vblanks kept its measured time and started over
|
|
// (ahead 0), and nothing was owed beyond kSlack. Below 15 fps the frame
|
|
// after each such one, kSlack behind again, got kSlack fewer than fired.
|
|
struct V013Rule
|
|
{
|
|
double ahead = 0.0;
|
|
static constexpr double kSlack = game::WholeVblanks::kSlack;
|
|
uint64_t Give(double measuredMs, uint64_t vblanks, double vblankMs)
|
|
{
|
|
if (vblanks > 6 || !(vblankMs > 0.0))
|
|
{
|
|
ahead = 0.0;
|
|
return 0;
|
|
}
|
|
ahead -= double(vblanks);
|
|
if (ahead + 1.0 > kSlack)
|
|
{
|
|
ahead = std::min(ahead + std::max(measuredMs, 0.0) / vblankMs, kSlack);
|
|
return 0;
|
|
}
|
|
int64_t give = 1;
|
|
if (ahead + 1.0 < -kSlack)
|
|
give = std::clamp<int64_t>(std::llround(-kSlack - ahead), 1, 6);
|
|
ahead = std::max(ahead + double(give), -kSlack);
|
|
return uint64_t(give);
|
|
}
|
|
};
|
|
|
|
struct Frame
|
|
{
|
|
double ms;
|
|
uint64_t vblanks;
|
|
};
|
|
|
|
// The world steps a frame runs: what it was given, or its measured time
|
|
// in steps, and at most 6 (the stepper's cap; the steps over it are dropped).
|
|
double WorldSteps(uint64_t given, double ms, double vblankMs)
|
|
{
|
|
return given ? double(std::min<uint64_t>(given, 6)) : std::min(ms / vblankMs, 6.0);
|
|
}
|
|
|
|
// GitHub issue #9's mechanism: the main loop runs up to `queue` frames
|
|
// ahead of a display that shows one frame a vblank (the render thread
|
|
// and the GPU ring hold them). A frame's work is 4-10 ms, and with
|
|
// probability `hiccupP` 15 ms or more longer (streaming, a page fault):
|
|
// up to `hiccupMs`. The loop starts a frame when the last one is done
|
|
// and the queue has room (a vblank took a frame from it). Returns the
|
|
// frames' measured times and counts, and how many vblanks found the
|
|
// queue empty (the display showed a frame again).
|
|
std::vector<Frame> QueuedLoop(int queue, double hiccupP, double hiccupMs, int count, uint32_t seed, int& dry)
|
|
{
|
|
std::mt19937 rng(seed);
|
|
std::uniform_real_distribution<double> unit(0.0, 1.0);
|
|
std::vector<double> starts, done;
|
|
std::vector<int> shownAt; // the vblank each frame was first shown at
|
|
double t = 0.0;
|
|
int nextShown = 0; // frames shown so far
|
|
int vblank = 1; // the next vblank to fire, at vblank * kRefreshMs
|
|
dry = 0;
|
|
auto fireUntil = [&](double until) {
|
|
for (; double(vblank) * kRefreshMs <= until; vblank++)
|
|
{
|
|
if (nextShown < int(done.size()) && done[size_t(nextShown)] <= double(vblank) * kRefreshMs)
|
|
shownAt.push_back(vblank), nextShown++;
|
|
else if (nextShown > 0)
|
|
dry++;
|
|
}
|
|
};
|
|
for (int k = 0; k <= count; k++)
|
|
{
|
|
// Room in the queue: frames done but not shown fewer than `queue`.
|
|
while (int(done.size()) - nextShown >= queue)
|
|
{
|
|
double next = double(vblank) * kRefreshMs;
|
|
fireUntil(next);
|
|
t = std::max(t, next);
|
|
}
|
|
fireUntil(t);
|
|
starts.push_back(t);
|
|
double work = 4.0 + 6.0 * unit(rng);
|
|
if (unit(rng) < hiccupP)
|
|
work += 15.0 + (hiccupMs - 15.0) * unit(rng);
|
|
t += work;
|
|
done.push_back(t);
|
|
fireUntil(t);
|
|
}
|
|
std::vector<Frame> out;
|
|
for (int k = 0; k < count; k++)
|
|
{
|
|
double a = starts[size_t(k)], b = starts[size_t(k) + 1];
|
|
uint64_t n = uint64_t(std::floor(b / kRefreshMs) - std::floor(a / kRefreshMs));
|
|
out.push_back({ b - a, n });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
struct Totals
|
|
{
|
|
double measuredMs = 0, vblankMs = 0, newMs = 0, oldMs = 0, v013Ms = 0;
|
|
double newSteps = 0, v013Steps = 0; // world steps (6 a frame at most)
|
|
uint64_t frames = 0, given = 0, paced = 0, pacedGivenOne = 0, notAsV013 = 0;
|
|
int maxSteps = 0;
|
|
};
|
|
|
|
// Each rule's game time for a run of frames.
|
|
Totals Play(const std::vector<Frame>& frames, double vblankMs)
|
|
{
|
|
game::WholeVblanks rule;
|
|
V013Rule v013;
|
|
Totals t;
|
|
for (const Frame& f : frames)
|
|
{
|
|
uint64_t k = rule.Give(f.ms, f.vblanks, vblankMs), old = HalfVblankRule(f.ms, f.vblanks, vblankMs),
|
|
prev = v013.Give(f.ms, f.vblanks, vblankMs);
|
|
t.measuredMs += f.ms;
|
|
t.vblankMs += double(f.vblanks) * vblankMs;
|
|
t.newMs += k ? double(k) * vblankMs : f.ms;
|
|
t.oldMs += old ? double(old) * vblankMs : f.ms;
|
|
t.v013Ms += prev ? double(prev) * vblankMs : f.ms;
|
|
t.newSteps += WorldSteps(k, f.ms, vblankMs);
|
|
t.v013Steps += WorldSteps(prev, f.ms, vblankMs);
|
|
t.notAsV013 += k != prev;
|
|
t.frames++;
|
|
t.given += k != 0;
|
|
t.maxSteps = std::max(t.maxSteps, int(k));
|
|
if (f.vblanks == 1 && std::abs(f.ms / vblankMs - 1.0) <= 0.5)
|
|
{
|
|
t.paced++;
|
|
t.pacedGivenOne += k == 1;
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
|
|
// `count` frames against vblanks due every `vblankMs`, each firing 0 to
|
|
// `lateMs` late (a vblank thread's wake-up; it catches up: one fires
|
|
// before the next is due). Paced: frame i starts 0 to `jitterMs` after
|
|
// vblank i fired, which released it (60 fps held). Else frames last
|
|
// `meanMs` +- `jitterMs` (GPU-bound), so their starts wander between
|
|
// vblanks. A frame's count: the vblanks that fired after its start, up
|
|
// to the next one's (GameFrameTime reads the count at each frame's start).
|
|
std::vector<Frame> Frames(double meanMs, double jitterMs, double vblankMs, double lateMs, bool paced, int count, uint32_t seed)
|
|
{
|
|
std::mt19937 rng(seed);
|
|
std::uniform_real_distribution<double> unit(0.0, 1.0);
|
|
std::vector<double> fired;
|
|
double last = paced ? double(count + 2) * vblankMs : double(count + 2) * (meanMs + jitterMs);
|
|
for (double due = 0.0; due <= last + vblankMs; due += vblankMs)
|
|
fired.push_back(due + unit(rng) * std::min(lateMs, vblankMs * 0.95));
|
|
std::vector<double> starts;
|
|
double t = unit(rng) * vblankMs;
|
|
for (int i = 0; i <= count; i++)
|
|
{
|
|
starts.push_back(paced ? fired[size_t(i)] + 0.05 + unit(rng) * jitterMs : t);
|
|
t += meanMs + (2 * unit(rng) - 1) * jitterMs;
|
|
}
|
|
std::vector<Frame> out;
|
|
size_t v = 0;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
uint64_t n = 0;
|
|
while (v < fired.size() && fired[v] <= starts[i])
|
|
v++;
|
|
while (v < fired.size() && fired[v] <= starts[i + 1])
|
|
v++, n++;
|
|
out.push_back({ starts[i + 1] - starts[i], n });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Issue #9: the queued loop at 60 fps held. With no vblank finding the
|
|
// queue empty, every frame is shown for one vblank and must get one.
|
|
void QueuedLoops()
|
|
{
|
|
struct Case
|
|
{
|
|
const char* name;
|
|
int queue;
|
|
double hiccupP, hiccupMs;
|
|
};
|
|
const Case cases[] = {
|
|
{ "queue 2, a 15-30 ms hiccup every ~3 s", 2, 1.0 / 180, 30.0 },
|
|
{ "queue 3, a 15-45 ms hiccup every ~3 s", 3, 1.0 / 180, 45.0 },
|
|
{ "queue 3, a 15-45 ms hiccup every ~0.5 s (a Deck-like CPU)", 3, 1.0 / 30, 45.0 },
|
|
{ "queue 2, a 15-80 ms hiccup every ~1 s (some run the queue dry)", 2, 1.0 / 60, 80.0 },
|
|
};
|
|
for (const Case& c : cases)
|
|
{
|
|
uint64_t frames = 0, newOff = 0, oldOff = 0, dryTotal = 0;
|
|
double worst = 0;
|
|
for (int p = 0; p < 8; p++)
|
|
{
|
|
int dry = 0;
|
|
std::vector<Frame> loop = QueuedLoop(c.queue, c.hiccupP, c.hiccupMs, 6000, 77u + uint32_t(p), dry);
|
|
game::WholeVblanks rule;
|
|
CountRule old;
|
|
double given = 0, fired = 0;
|
|
for (const Frame& f : loop)
|
|
{
|
|
uint64_t k = rule.Give(f.ms, f.vblanks, kRefreshMs), o = old.Give(f.ms, f.vblanks, kRefreshMs);
|
|
newOff += k != 1;
|
|
oldOff += o != 1;
|
|
given += k ? double(k) : f.ms / kRefreshMs;
|
|
fired += double(f.vblanks);
|
|
}
|
|
frames += loop.size();
|
|
dryTotal += uint64_t(dry);
|
|
worst = std::max(worst, std::abs(given - fired));
|
|
}
|
|
printf(" %-62s frames not given 1: %llu (the rule until 2026-10-11: %llu) of %llu; vblanks with the queue empty %llu; "
|
|
"game time within %.2f vblanks\n", c.name, (unsigned long long)newOff, (unsigned long long)oldOff,
|
|
(unsigned long long)frames, (unsigned long long)dryTotal, worst);
|
|
CHECK(oldOff > 0, "%s: the old rule's hitches are there to remove (%llu)", c.name, (unsigned long long)oldOff);
|
|
if (dryTotal == 0)
|
|
CHECK(newOff == 0, "%s: issue #9: every frame given 1 while the display shows one a vblank (%llu not)", c.name,
|
|
(unsigned long long)newOff);
|
|
else
|
|
CHECK(newOff <= dryTotal && newOff < oldOff, "%s: only frames after an empty queue given more (%llu, %llu empty, old %llu)",
|
|
c.name, (unsigned long long)newOff, (unsigned long long)dryTotal, (unsigned long long)oldOff);
|
|
CHECK(worst <= game::WholeVblanks::kSlack + 1.0, "%s: game time within kSlack + 1 vblanks (%.2f)", c.name, worst);
|
|
}
|
|
}
|
|
|
|
void Synthetic()
|
|
{
|
|
// Frame by frame, from a fresh start.
|
|
{
|
|
game::WholeVblanks r;
|
|
CHECK(r.Give(16.6, 1, kRefreshMs) == 1, "a 60 fps frame: 1");
|
|
CHECK(r.ahead == 0.0, "nothing ahead");
|
|
CHECK(HalfVblankRule(44.0, 2, kRefreshMs) == 0, "the old rule's miss: 44 ms, 2 fired, kept 44 ms");
|
|
// GPU-bound 44 ms frames (2.64 refreshes, 2 or 3 fired): game time
|
|
// falls kSlack behind first, then each gets its count.
|
|
CHECK(r.Give(44.0, 3, kRefreshMs) == 1 && r.ahead == -2.0, "first slow frame: 1 (%.2f behind)", -r.ahead);
|
|
CHECK(r.Give(44.0, 2, kRefreshMs) == 1 && r.ahead == -3.0, "then 1, kSlack behind (%.2f)", -r.ahead);
|
|
CHECK(r.Give(44.0, 3, kRefreshMs) == 3, "3 fired, kSlack behind: 3");
|
|
CHECK(r.Give(44.0, 2, kRefreshMs) == 2, "2 fired: 2");
|
|
CHECK(r.ahead == -game::WholeVblanks::kSlack, "and stays kSlack behind (%.2f)", r.ahead);
|
|
CHECK(r.Give(44.0, 1, 2 * kRefreshMs) == 1 && r.Give(44.0, 2, 2 * kRefreshMs) == 2,
|
|
"Frame Rate 30: 44 ms is 1.32 guest vblanks of 33.3 ms; 1 or 2 fired, given");
|
|
r.Reset();
|
|
CHECK(r.ahead == 0.0, "reset");
|
|
// GitHub issue #9: at 60 fps held, the main loop's frames drift
|
|
// against the vblanks while the display shows one frame a vblank
|
|
// from its queue: a slow frame sees 2 or 3, the next ones none.
|
|
// Each is shown for one vblank and gets one.
|
|
const uint64_t drift[] = { 1, 2, 0, 1, 1, 3, 0, 0, 1, 2, 1, 0, 1 };
|
|
bool allOne = true;
|
|
for (uint64_t k : drift)
|
|
allOne &= r.Give(k == 0 ? 4.0 : 16.6 * double(k), k, kRefreshMs) == 1;
|
|
CHECK(allOne && r.ahead == 0.0, "issue #9: every drifting frame given 1, nothing left over (%.2f)", r.ahead);
|
|
// A slow frame of 6 (100 ms: the queue ran dry, the display waited
|
|
// 3 vblanks): it gets the 3 beyond kSlack, the 3 catching up one each.
|
|
CHECK(r.Give(100.0, 6, kRefreshMs) == 3, "6 fired, 3 beyond kSlack: 3");
|
|
CHECK(r.Give(3.0, 0, kRefreshMs) == 1 && r.Give(3.0, 0, kRefreshMs) == 1 && r.Give(3.0, 0, kRefreshMs) == 1 && r.ahead == 0.0,
|
|
"the frames catching up: 1 each, back level (%.2f)", r.ahead);
|
|
// More frames than vblanks (the queue filling): one each up to
|
|
// kSlack ahead, then their measured time.
|
|
CHECK(r.Give(4.0, 0, kRefreshMs) == 1 && r.Give(4.0, 0, kRefreshMs) == 1 && r.Give(4.0, 0, kRefreshMs) == 1, "kSlack frames ahead: 1 each");
|
|
CHECK(r.Give(4.0, 0, kRefreshMs) == 0 && r.ahead == game::WholeVblanks::kSlack, "then measured time, never more than kSlack ahead");
|
|
CHECK(r.Give(16.6, 1, kRefreshMs) == 1 && r.ahead == game::WholeVblanks::kSlack, "kSlack ahead, a frame of 1: 1 (it fits)");
|
|
CHECK(r.Give(33.3, 2, kRefreshMs) == 1 && r.ahead == game::WholeVblanks::kSlack - 1.0, "a frame of 2: 1, giving one back");
|
|
CHECK(r.Give(120.0, 7, kRefreshMs) == 0 && r.ahead == 0.0, "7 vblanks (loading): measured time, and a fresh start");
|
|
for (int i = 0; i < 20; i++)
|
|
r.Give(30.0, 0, kRefreshMs);
|
|
CHECK(r.ahead == game::WholeVblanks::kSlack, "ahead at most kSlack (%.2f)", r.ahead);
|
|
r.Reset();
|
|
CHECK(r.ahead == 0.0 && r.Give(16.6, 1, 0.0) == 0, "no vblank period: measured time");
|
|
}
|
|
|
|
struct Case
|
|
{
|
|
const char* name;
|
|
double meanMs, jitterMs, vblankMs, lateMs;
|
|
bool paced;
|
|
double oldMin, oldMax; // the half-vblank rule's game time over the vblanks', expected range
|
|
};
|
|
const Case cases[] = {
|
|
{ "60 fps held, starts 0-3 ms late", kRefreshMs, 3.0, kRefreshMs, 0.5, true, 0.9999, 1.0001 },
|
|
{ "30 fps held, Frame Rate 30", 2 * kRefreshMs, 3.0, 2 * kRefreshMs, 0.5, true, 0.9999, 1.0001 },
|
|
{ "60 fps held, vblanks up to 6 ms late", kRefreshMs, 1.0, kRefreshMs, 6.0, true, 0.98, 1.02 },
|
|
{ "GPU-bound 44 ms +-2, Frame Rate 60", 44.0, 2.0, kRefreshMs, 0.5, false, 1.03, 1.2 },
|
|
{ "GPU-bound 49 ms +-2, Frame Rate 60", 49.0, 2.0, kRefreshMs, 0.5, false, 1.005, 1.1 },
|
|
{ "GPU-bound 44 ms +-2, Frame Rate 30", 44.0, 2.0, 2 * kRefreshMs, 0.5, false, 0.7, 0.95 },
|
|
{ "GPU-bound 49 ms +-2, Frame Rate 30", 49.0, 2.0, 2 * kRefreshMs, 0.5, false, 0.7, 0.95 },
|
|
{ "GPU-bound 18.7 ms +-1, vblanks up to 8 ms late", 18.7, 1.0, kRefreshMs, 8.0, false, 0.8, 0.97 },
|
|
{ "GPU-bound 26 ms +-7, Frame Rate 60", 26.0, 7.0, kRefreshMs, 0.5, false, 0.9, 1.1 },
|
|
};
|
|
for (const Case& c : cases)
|
|
{
|
|
double worst = 0, oldMean = 0;
|
|
uint64_t paced = 0, pacedOne = 0, frames = 0, given = 0;
|
|
int maxSteps = 0;
|
|
const int runs = 12;
|
|
for (int p = 0; p < runs; p++)
|
|
{
|
|
Totals t = Play(Frames(c.meanMs, c.jitterMs, c.vblankMs, c.lateMs, c.paced, 4000, 1234u + uint32_t(p)), c.vblankMs);
|
|
worst = std::max(worst, std::abs(t.newMs - t.vblankMs) / c.vblankMs);
|
|
oldMean += t.oldMs / t.vblankMs / runs;
|
|
paced += t.paced;
|
|
pacedOne += t.pacedGivenOne;
|
|
frames += t.frames;
|
|
given += t.given;
|
|
maxSteps = std::max(maxSteps, t.maxSteps);
|
|
}
|
|
printf(" %-48s new rule within %.2f vblanks of the vblanks' time; half-vblank rule x%.4f; %llu of %llu frames given whole vblanks\n",
|
|
c.name, worst, oldMean, (unsigned long long)given, (unsigned long long)frames);
|
|
// Game time against the vblanks that fired, over 4000 frames:
|
|
// within kSlack (and a last frame that saw none), whatever the
|
|
// frames did.
|
|
CHECK(worst <= game::WholeVblanks::kSlack + 1.0, "%s: the new rule within kSlack + 1 vblanks of the vblanks (%.2f)", c.name, worst);
|
|
CHECK(oldMean >= c.oldMin && oldMean <= c.oldMax, "%s: the half-vblank rule's known bias (x%.4f)", c.name, oldMean);
|
|
if (c.paced)
|
|
CHECK(pacedOne == paced && given == frames, "%s: every paced frame given one vblank (%llu of %llu)", c.name,
|
|
(unsigned long long)pacedOne, (unsigned long long)paced);
|
|
CHECK(maxSteps <= 6, "%s: at most 6 vblanks a frame", c.name);
|
|
}
|
|
}
|
|
|
|
// GPU-bound frames below 15 fps: `meanMs` +- `jitterMs`, and with
|
|
// probability `spikeP` one `spikeMs` to 2 x `spikeMs` longer (a texture
|
|
// upload, streaming). Vblanks every kRefreshMs, each 0-0.5 ms late; a
|
|
// frame's count is those after its start up to the next one's.
|
|
std::vector<Frame> SlowFrames(double meanMs, double jitterMs, double spikeP, double spikeMs, int count, uint32_t seed)
|
|
{
|
|
std::mt19937 rng(seed);
|
|
std::uniform_real_distribution<double> unit(0.0, 1.0);
|
|
std::vector<double> starts;
|
|
double t = unit(rng) * kRefreshMs;
|
|
for (int i = 0; i <= count; i++)
|
|
{
|
|
starts.push_back(t);
|
|
double ms = meanMs + (2 * unit(rng) - 1) * jitterMs;
|
|
if (unit(rng) < spikeP)
|
|
ms += spikeMs * (1.0 + unit(rng));
|
|
t += std::max(ms, 1.0);
|
|
}
|
|
std::vector<double> fired;
|
|
for (double due = 0.0; due <= t + kRefreshMs; due += kRefreshMs)
|
|
fired.push_back(due + unit(rng) * 0.5);
|
|
std::vector<Frame> out;
|
|
size_t v = 0;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
uint64_t n = 0;
|
|
while (v < fired.size() && fired[v] <= starts[size_t(i)])
|
|
v++;
|
|
while (v < fired.size() && fired[v] <= starts[size_t(i) + 1])
|
|
v++, n++;
|
|
out.push_back({ starts[size_t(i) + 1] - starts[size_t(i)], n });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Below 15 fps (an Intel UHD laptop GPU at 1.5x, ~12 fps,
|
|
// a frame of 7 or more vblanks every second or so): game time follows the
|
|
// vblanks that fired, frames over 6 included; loads start over.
|
|
void LowFps()
|
|
{
|
|
using game::WholeVblanks;
|
|
const double owedFloor = -WholeVblanks::kSlack - WholeVblanks::kMaxOwed;
|
|
// Frame by frame.
|
|
{
|
|
WholeVblanks r;
|
|
// GPU-bound at 12 fps: kSlack behind after the first, then each
|
|
// its count. The frames before judge the rate: from the fourth
|
|
// one it is below 20 fps.
|
|
CHECK(r.Give(83.0, 5, kRefreshMs) == 2 && r.ahead == -WholeVblanks::kSlack, "12 fps, the first frame: 2 (%.2f)", r.ahead);
|
|
for (int i = 0; i < 3; i++)
|
|
CHECK(r.Give(83.0, 5, kRefreshMs) == 5 && r.ahead == -WholeVblanks::kSlack, "then its count: 5");
|
|
CHECK(r.frameMs >= WholeVblanks::kLowRateMs, "below 20 fps after 4 frames of 83 ms (%.1f ms)", r.frameMs);
|
|
// A frame of 7: 6 (the stepper's cap), 1 owed; the next of 5 gets 6.
|
|
CHECK(r.Give(117.0, 7, kRefreshMs) == 6 && r.ahead == -WholeVblanks::kSlack - 1.0, "7 fired: 6, one owed (%.2f)", r.ahead);
|
|
CHECK(r.Give(83.0, 5, kRefreshMs) == 6 && r.ahead == -WholeVblanks::kSlack, "5 fired, one owed: 6, level again (%.2f)", r.ahead);
|
|
// A frame of 12: 6, and 6 owed, given back one a frame by frames of 5.
|
|
CHECK(r.Give(200.0, 12, kRefreshMs) == 6 && r.ahead == -WholeVblanks::kSlack - 6.0, "12 fired: 6, 6 owed (%.2f)", r.ahead);
|
|
int extra = 0;
|
|
for (int i = 0; i < 6; i++)
|
|
extra += int(r.Give(83.0, 5, kRefreshMs)) - 5;
|
|
CHECK(extra == 6 && r.ahead == -WholeVblanks::kSlack, "frames of 5 give the 6 back, one each (%d, %.2f)", extra, r.ahead);
|
|
// The short frame after a long one (the loop catching up) gives
|
|
// back at most its own count again: a frame of 1 gets 2.
|
|
r.Give(200.0, 12, kRefreshMs);
|
|
CHECK(r.Give(16.6, 1, kRefreshMs) == 2 && r.ahead == -WholeVblanks::kSlack - 5.0, "a frame of 1, 6 owed: 2 (%.2f)", r.ahead);
|
|
for (int i = 0; i < 5; i++)
|
|
r.Give(83.0, 5, kRefreshMs);
|
|
CHECK(r.ahead == -WholeVblanks::kSlack, "the rest by the frames of 5 (%.2f)", r.ahead);
|
|
// At 8 fps (frames of 7-8: more than 6 on average) more is owed
|
|
// than comes back, up to kMaxOwed beyond kSlack.
|
|
for (int i = 0; i < 40; i++)
|
|
CHECK(r.Give(125.0, 7 + uint64_t(i % 2), kRefreshMs) == 6, "8 fps: 6 a frame");
|
|
CHECK(r.ahead == owedFloor, "owed kMaxOwed beyond kSlack, no more (%.2f)", r.ahead);
|
|
// Back at 60 fps: 2 a frame while the frames before still average
|
|
// 50 ms or more, then the rest is forgotten (no catch-up at 60 fps).
|
|
std::string got;
|
|
int back = 0;
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
uint64_t k = r.Give(16.6, 1, kRefreshMs);
|
|
back += int(k) - 1;
|
|
got += std::to_string(k) + " ";
|
|
}
|
|
CHECK(back >= 2 && back <= 8 && r.ahead == -WholeVblanks::kSlack, "60 fps again: 2 a frame for a few, then 1 (%s; %.2f)",
|
|
got.c_str(), r.ahead);
|
|
// At 60 fps a long frame is a hitch, as in v0.1.3: its measured
|
|
// time and a fresh start, nothing owed, so no frame after it runs
|
|
// more than one step (GitHub issue #9's frames).
|
|
for (int i = 0; i < 20; i++)
|
|
r.Give(16.6, 1, kRefreshMs);
|
|
CHECK(r.Give(300.0, 18, kRefreshMs) == 0 && r.ahead == 0.0, "a 300 ms hitch at 60 fps: measured time, a fresh start (%.2f)",
|
|
r.ahead);
|
|
CHECK(r.Give(4.0, 0, kRefreshMs) == 1 && r.Give(16.6, 1, kRefreshMs) == 1 && r.Give(16.6, 1, kRefreshMs) == 1,
|
|
"after it: one a frame, the queue catching up");
|
|
// Half a second is still a frame; more is a load: measured time,
|
|
// nothing owed after it, the rate judged afresh.
|
|
r.Reset();
|
|
for (int i = 0; i < 4; i++)
|
|
r.Give(83.0, 5, kRefreshMs);
|
|
r.Give(200.0, 12, kRefreshMs);
|
|
CHECK(r.ahead < -WholeVblanks::kSlack, "owing again (%.2f)", r.ahead);
|
|
CHECK(r.Give(500.0, WholeVblanks::kLoadVblanks, kRefreshMs) == 6, "30 vblanks: not a load, 6");
|
|
CHECK(r.Give(2000.0, 120, kRefreshMs) == 0 && r.ahead == 0.0 && r.frameMs == WholeVblanks::kHighRateMs,
|
|
"a load (2 s): measured time, nothing owed (%.2f)", r.ahead);
|
|
CHECK(r.Give(83.0, 5, kRefreshMs) == 2 && r.ahead == -WholeVblanks::kSlack, "after it: 2, as from a fresh start (%.2f)", r.ahead);
|
|
r.Give(200.0, 12, kRefreshMs);
|
|
CHECK(r.Give(510.0, WholeVblanks::kLoadVblanks + 1, kRefreshMs) == 0 && r.ahead == 0.0, "31 vblanks: a load");
|
|
}
|
|
|
|
// Long runs: game time over the vblanks that fired (frames over 6
|
|
// included), and world steps (6 a frame at most).
|
|
struct Case
|
|
{
|
|
const char* name;
|
|
double meanMs, jitterMs, spikeP, spikeMs;
|
|
// Game time within kSlack + kMaxOwed (+1) of the vblanks all
|
|
// run long: the frames have room to give back what longer ones
|
|
// owe before kMaxOwed is reached. (With frames of 11-18 vblanks
|
|
// now and then, two close together can reach it: a little is
|
|
// forgotten.)
|
|
bool keepsUp;
|
|
double minRatio; // game time over the vblanks, at least
|
|
};
|
|
const Case cases[] = {
|
|
{ "Intel UHD at 1.5x: 12 fps (80 ms +-35), a 140-235 ms frame every ~1.5 s", 80.0, 35.0, 1.0 / 20, 60.0, true, 0.999 },
|
|
{ "15 fps (67 ms +-20), a 190-310 ms frame every ~2 s", 67.0, 20.0, 1.0 / 30, 120.0, false, 0.999 },
|
|
{ "10.5 fps (95 ms +-15)", 95.0, 15.0, 0.0, 0.0, true, 0.999 },
|
|
{ "11 fps (83 ms +-25), a 170-250 ms frame every ~1 s", 83.0, 25.0, 1.0 / 12, 85.0, false, 0.995 },
|
|
{ "8 fps (125 ms +-25): more than 6 vblanks a frame", 125.0, 25.0, 0.0, 0.0, false, 0.0 },
|
|
};
|
|
for (const Case& c : cases)
|
|
{
|
|
double fired = 0, given = 0, v013 = 0, steps = 0, v013Steps = 0, worst = 0, lowest = 0;
|
|
uint64_t frames = 0, over6 = 0;
|
|
int maxGive = 0;
|
|
for (int p = 0; p < 20; p++)
|
|
{
|
|
std::vector<Frame> run = SlowFrames(c.meanMs, c.jitterMs, c.spikeP, c.spikeMs, 3000, 4321u + uint32_t(p));
|
|
WholeVblanks rule;
|
|
V013Rule prev;
|
|
double runFired = 0, runGiven = 0;
|
|
for (const Frame& f : run)
|
|
{
|
|
uint64_t k = rule.Give(f.ms, f.vblanks, kRefreshMs), o = prev.Give(f.ms, f.vblanks, kRefreshMs);
|
|
runFired += double(f.vblanks);
|
|
runGiven += k ? double(k) : f.ms / kRefreshMs;
|
|
v013 += o ? double(o) : f.ms / kRefreshMs;
|
|
steps += WorldSteps(k, f.ms, kRefreshMs);
|
|
v013Steps += WorldSteps(o, f.ms, kRefreshMs);
|
|
over6 += f.vblanks > 6;
|
|
maxGive = std::max(maxGive, int(k));
|
|
lowest = std::min(lowest, rule.ahead);
|
|
if (c.keepsUp)
|
|
worst = std::max(worst, std::abs(runGiven - runFired));
|
|
}
|
|
fired += runFired;
|
|
given += runGiven;
|
|
frames += run.size();
|
|
}
|
|
printf(" %-56s %.1f%% of frames over 6; game time over vblanks fired %.4f (v0.1.3 %.4f), world steps %.4f (v0.1.3 %.4f)",
|
|
c.name, 100.0 * double(over6) / double(frames), given / fired, v013 / fired, steps / fired, v013Steps / fired);
|
|
if (c.keepsUp)
|
|
printf("; within %.2f vblanks\n", worst);
|
|
else
|
|
printf("; owed %.2f at most\n", -lowest);
|
|
CHECK(maxGive <= 6, "%s: at most 6 a frame (%d)", c.name, maxGive);
|
|
CHECK(lowest >= owedFloor, "%s: never owed more than kSlack + kMaxOwed (%.2f)", c.name, lowest);
|
|
if (c.keepsUp)
|
|
CHECK(worst <= WholeVblanks::kSlack + WholeVblanks::kMaxOwed + 1.0,
|
|
"%s: game time within kSlack + kMaxOwed + 1 of the vblanks over 20 x 3000 frames (%.2f)", c.name, worst);
|
|
CHECK(given / fired >= c.minRatio && steps / fired >= c.minRatio, "%s: game time and world steps follow the vblanks (x%.4f, x%.4f)",
|
|
c.name, given / fired, steps / fired);
|
|
if (c.minRatio > 0.0)
|
|
CHECK(v013 / fired < 0.985 && v013Steps / fired < 0.985, "%s: v0.1.3's rule ran slow here (x%.4f, world x%.4f)", c.name,
|
|
v013 / fired, v013Steps / fired);
|
|
}
|
|
}
|
|
|
|
// NFSMW_GAME_TIME_LOG rows: measured_ms,vblanks,... (the frame's own; the
|
|
// rule used then doesn't change them).
|
|
void Replay(const std::string& arg)
|
|
{
|
|
std::string path = arg;
|
|
double vblankMs = kRefreshMs;
|
|
if (arg.size() > 3 && arg.substr(arg.size() - 3) == "@30")
|
|
{
|
|
path = arg.substr(0, arg.size() - 3);
|
|
vblankMs = 2 * kRefreshMs;
|
|
}
|
|
std::ifstream in(path);
|
|
if (!in)
|
|
{
|
|
printf(" %s: can't read\n", path.c_str());
|
|
g_failures++;
|
|
return;
|
|
}
|
|
std::string line;
|
|
std::getline(in, line);
|
|
std::vector<Frame> frames;
|
|
while (std::getline(in, line))
|
|
{
|
|
double ms;
|
|
unsigned long long k;
|
|
if (sscanf(line.c_str(), "%lf,%llu", &ms, &k) == 2 && k <= game::WholeVblanks::kLoadVblanks)
|
|
frames.push_back({ ms, k });
|
|
}
|
|
if (frames.empty())
|
|
{
|
|
printf(" %s: no frames of 0-%llu vblanks\n", path.c_str(), (unsigned long long)game::WholeVblanks::kLoadVblanks);
|
|
return;
|
|
}
|
|
Totals t = Play(frames, vblankMs);
|
|
printf(" %s: %llu frames of 0-%llu vblanks, %.1f s measured; game time over measured: new rule %.4f, v0.1.3 rule %.4f, "
|
|
"half-vblank rule %.4f, vblanks %.4f; world steps over vblanks: new %.4f, v0.1.3 %.4f; frames given otherwise than by v0.1.3's "
|
|
"rule %llu\n", path.c_str(), (unsigned long long)t.frames, (unsigned long long)game::WholeVblanks::kLoadVblanks,
|
|
t.measuredMs / 1000, t.newMs / t.measuredMs, t.v013Ms / t.measuredMs, t.oldMs / t.measuredMs, t.vblankMs / t.measuredMs,
|
|
t.newSteps * vblankMs / t.vblankMs, t.v013Steps * vblankMs / t.vblankMs, (unsigned long long)t.notAsV013);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
printf("synthetic frames:\n");
|
|
Synthetic();
|
|
printf("a main loop queued ahead of the display (GitHub issue #9):\n");
|
|
QueuedLoops();
|
|
printf("below 15 fps: frames over 6 vblanks, and loads:\n");
|
|
LowFps();
|
|
if (argc > 1)
|
|
printf("logs:\n");
|
|
for (int i = 1; i < argc; i++)
|
|
Replay(argv[i]);
|
|
printf("%s (%d failures)\n", g_failures ? "FAILED" : "passed", g_failures);
|
|
return g_failures ? 1 : 0;
|
|
}
|