Wire M10.7b interpolation and the stale loss view into the client
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m55s
Foundation / checks (client) (push) Successful in 12m27s
Foundation / checks (network) (push) Successful in 12m46s
Foundation / checks (tsan) (push) Successful in 7m59s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (checks) (push) Canceled after 25m13s
Foundation / checks (postgres) (push) Canceled after 12m48s

ADR-0095. The engineering client times presentation with the tick clock:
its own marker between ticks, other markers interpolated a few ticks behind
(grey when stale). Silence beyond 3 ticks and long-gap holds are stale. A lost
session leaves its last view frozen and labelled stale until the reconnect's
fresh baseline; nothing is predicted or sent meanwhile.

evo-motion-trace --remote measures remote-marker error between two clients
through the relay, with a 1.5 s outage (motion-trace-remote-smoke CTest).
Prediction errors are recorded only for ticks inputs are scheduled for.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dingo
2026-10-06 17:50:41 -04:00
co-authored by Claude Opus 5.5
parent 90cdb61e30
commit 5728e7682e
17 changed files with 651 additions and 210 deletions
+9 -7
View File
@@ -184,17 +184,19 @@ std::optional<evo::client::ScreenPoint> parse_point(std::string_view value) {
return std::nullopt;
return evo::client::ScreenPoint{static_cast<double>(x), static_cast<double>(y)};
}
// A probe marker (ADR-0094): the own one larger and amber, others smaller and blue; clipped.
void marker_box(std::vector<evo::render::Rectangle>& out, double x, double y, bool own,
// A probe marker (ADR-0094): the own one larger and amber, others smaller and blue; stale
// ones (no current authority, ADR-0095) grey. Clipped to the viewport.
void marker_box(std::vector<evo::render::Rectangle>& out, double x, double y, bool own, bool stale,
double width, double height) {
const double half = own ? 7 : 4;
const double x0 = std::max(x - half, 0.0), y0 = std::max(y - half, 0.0);
const double x1 = std::min(x + half, width), y1 = std::min(y + half, height);
if (x1 > x0 && y1 > y0)
out.push_back(
{static_cast<float>(x0), static_cast<float>(y0), static_cast<float>(x1 - x0),
static_cast<float>(y1 - y0),
own ? evo::render::Color{250, 190, 40, 255} : evo::render::Color{90, 170, 250, 255}});
out.push_back({static_cast<float>(x0), static_cast<float>(y0), static_cast<float>(x1 - x0),
static_cast<float>(y1 - y0),
stale ? evo::render::Color{120, 120, 120, 255}
: own ? evo::render::Color{250, 190, 40, 255}
: evo::render::Color{90, 170, 250, 255}});
}
void outline(std::vector<evo::render::Rectangle>& out, double l, double t, double r, double b,
double width, double height) {
@@ -544,7 +546,7 @@ int main(int argc, char** argv) try {
if (const auto* remote = host.session(); remote && mode() == Mode::remote)
for (const auto& m : remote->markers())
if (const auto at = camera->world_to_screen({m.x_mm, m.y_mm}))
marker_box(boxes, at->x, at->y, m.own, width, height);
marker_box(boxes, at->x, at->y, m.own, m.stale, width, height);
if (const auto* o = selection.organism(orgs)) {
const auto b = evo::render::organism_bounds(*o, *camera);
outline(boxes, b.left - 3, b.top - 3, b.right + 3, b.bottom + 3, width, height);
+6 -2
View File
@@ -153,7 +153,8 @@ void banner(const PanelView& v, PanelActions& a) {
a.open_controls = true;
} else {
ImGui::TextColored(v.remote && v.remote->phase == "connected" ? green : amber,
"DEV REGION - %s", v.remote ? v.remote->phase.c_str() : "?");
"DEV REGION - %s%s", v.remote ? v.remote->phase.c_str() : "?",
v.remote && v.remote->stale_view ? " - STALE (last view, frozen)" : "");
ImGui::SameLine();
if (ImGui::SmallButton("Disconnect"))
a.ask_disconnect = true;
@@ -366,7 +367,10 @@ void session(const PanelView& v) {
row("Corrections", std::to_string(s.corrections) + ", max error " +
std::to_string(s.max_error_um / 1000) + " mm, " +
std::to_string(s.snaps) + " snaps");
row("Other markers", std::to_string(s.other_markers));
char delay[48];
std::snprintf(delay, sizeof delay, "%zu, %.1f ticks behind, %zu stale", s.other_markers,
s.interpolation_delay, s.stale_markers);
row("Other markers", delay);
}
ImGui::EndTable();
}
+71 -14
View File
@@ -17,6 +17,12 @@
// intention that was lost or refused is sent again once nothing is in flight and the
// authority holds another vector. While following, the camera and the interest follow the
// predicted marker (or, before a marker exists, the server's default view).
//
// M10.7b (ADR-0095): a drift-corrected tick clock (observed server ticks) times the
// presentation. The own marker is drawn between ticks; other markers are interpolated
// `delay` ticks behind (adaptive), extrapolated at most two ticks, then marked stale. When the
// session is lost the last view stays frozen and stale: the own marker at its last
// authoritative position, nothing predicted or sent. A new session starts afresh.
#include "evo/client/camera.hpp"
#include "evo/client/environment_view.hpp"
#include "evo/client/input.hpp"
@@ -33,6 +39,7 @@
#include <vector>
#ifdef EVO_CLIENT_NETWORK
#include "evo/client/interpolation.hpp"
#include "evo/client/motion_prediction.hpp"
#include "evo/client/region_session.hpp"
#include "evo/network/quic_transport.hpp"
@@ -64,11 +71,18 @@ struct RemoteStatus {
// Refusal receipts (each, whether or not the input was still pending), inputs the
// predictor removed as refused or dropped as never applied, and repeated vectors.
std::uint64_t refused_inputs{}, rejected_inputs{}, dropped_inputs{}, resends{}, max_pending{};
// Interpolation (ADR-0095): the current delay in ticks, markers shown stale, and whether
// the whole view is a frozen copy from a lost session.
double interpolation_delay{}, remote_render_tick{}; // Ticks: delay, clock - delay.
std::size_t stale_markers{};
bool stale_view{};
};
// A probe marker to draw: the own one predicted and smoothed, others as replicated.
struct MarkerView {
double x_mm{}, y_mm{};
bool own{};
bool stale{}; // No current authority behind it (draw dimmed).
bool extrapolated{}; // Continued beyond the newest snapshot (at most two ticks).
};
#ifdef EVO_CLIENT_NETWORK
@@ -78,6 +92,7 @@ static_assert(std::is_same_v<client::GrantRecord, network::WireGrant>,
class RemoteSession {
public:
static constexpr std::uint16_t interest_radius = 7;
static constexpr double silent_ticks = 3; // Extrapolation limit (2) plus the clock's lead.
// Looks the endpoint up once (blocking); nothing connects until the first step().
static std::optional<RemoteSession> open(const client::ConnectMaterial& m) {
const auto address = network::quic::resolve_ipv4(m.endpoint.host);
@@ -136,7 +151,7 @@ class RemoteSession {
s.focus_y = sent_interest_->y;
s.focus_z = sent_interest_->z;
}
for (const auto& m : markers_)
for (const auto& m : markers_) {
if (m.own) {
s.marker = true;
s.marker_x_mm = m.x_mm;
@@ -144,6 +159,11 @@ class RemoteSession {
} else {
++s.other_markers;
}
s.stale_markers += m.stale ? 1 : 0;
}
s.interpolation_delay = interpolator_.delay();
s.remote_render_tick = render_tick_;
s.stale_view = stale_view_;
s.inputs_pending = predictor_.pending();
s.lead = lead_.lead();
s.corrections = predictor_.stats().corrections;
@@ -208,6 +228,10 @@ class RemoteSession {
if (!established_)
welcome(ui, launcher);
server_tick_ = c.server_tick();
if (server_tick_ != observed_tick_) { // Every watermark or snapshot tick times the clock.
observed_tick_ = server_tick_;
clock_.observe(server_tick_, now);
}
send(intention);
receipts();
snapshot();
@@ -281,6 +305,11 @@ class RemoteSession {
predictor_.reset(); // A new session has a new marker.
smoother_.reset();
lead_.reset();
clock_.reset(); // Fresh baseline: the frozen view of a lost session is dropped.
interpolator_.reset();
markers_.clear();
observed_tick_ = 0;
stale_view_ = false;
launcher.observe(client::ConnectSignal::welcome);
notify(ui, "Connected to the dev region (fresh baseline).", client::NoticeLevel::info);
std::printf("session welcome session=%llu epoch=%llu tick=%llu\n",
@@ -367,13 +396,14 @@ class RemoteSession {
static_cast<void>(organisms_.accept(std::move(*o)).has_value());
}
}
others_.clear();
std::vector<client::RemoteMarker> remote;
for (const auto& m : v->markers) {
if (m.own)
predictor_.authoritative({v->tick, m.applied_sequence, m.state, m.area});
else
others_.push_back(m);
remote.push_back({m.id, m.state});
}
interpolator_.push(v->tick, remote);
if (!following_ || v->environment.empty() || predictor_.authority())
return; // With a marker, present() follows it instead.
const auto [lx, hx] =
@@ -397,23 +427,36 @@ class RemoteSession {
: 0;
last_present_ = now;
markers_.clear();
const auto predicted = predictor_.predict(server_tick_ + lead_.lead());
interpolator_.advance(elapsed);
const auto clock = clock_.at(now).value_or(static_cast<double>(server_tick_));
// The own marker in the predicted present, between whole ticks.
const auto presented = clock + static_cast<double>(lead_.lead());
const auto whole = static_cast<std::uint64_t>(std::floor(presented));
// Errors are measured only for ticks inputs are already being scheduled for.
const auto predicted = predictor_.predict_between(
whole, presented - static_cast<double>(whole), whole <= server_tick_ + lead_.lead());
const auto& authority = predictor_.authority();
if (predicted && authority) {
smoother_.add(predictor_.take_correction());
const auto offset = smoother_.advance(elapsed);
const MarkerView own{static_cast<double>(predicted->x + offset.x) / 1000,
static_cast<double>(predicted->y + offset.y) / 1000, true};
const MarkerView own{(predicted->x + static_cast<double>(offset.x)) / 1000,
(predicted->y + static_cast<double>(offset.y)) / 1000, true};
markers_.push_back(own);
if (following_) {
recentre_ = offered_ = client::WorldPoint{own.x_mm, own.y_mm};
wanted_ = network::SessionInterest{cell(predicted->x), cell(predicted->y),
authority->area.z, interest_radius};
const auto x = static_cast<std::int64_t>(std::floor(predicted->x));
const auto y = static_cast<std::int64_t>(std::floor(predicted->y));
wanted_ =
network::SessionInterest{cell(x), cell(y), authority->area.z, interest_radius};
}
}
for (const auto& m : others_)
markers_.push_back({static_cast<double>(m.state.x) / 1000,
static_cast<double>(m.state.y) / 1000, false});
// Other markers in the recent past, interpolated.
render_tick_ = clock - interpolator_.delay();
// A silent server freezes the clock; beyond the extrapolation limit that silence is
// what makes the shown markers stale.
const bool silent = clock_.silence(now).value_or(0) > silent_ticks;
for (const auto& m : interpolator_.at(render_tick_))
markers_.push_back({m.x / 1000, m.y / 1000, false, m.stale || silent, m.extrapolated});
}
static std::int64_t cell(std::int64_t um) {
constexpr auto size = network::motion::micrometres_per_cell;
@@ -430,9 +473,19 @@ class RemoteSession {
pending_.clear();
environment_.mark_stale();
organisms_.mark_stale();
// Freeze the view as it was: the own marker at its last authoritative position,
// everything stale. Nothing is predicted or sent until a new session starts afresh.
const auto& authority = predictor_.authority();
std::erase_if(markers_, [](const MarkerView& m) { return m.own; });
if (authority)
markers_.push_back({static_cast<double>(authority->state.x) / 1000,
static_cast<double>(authority->state.y) / 1000, true});
for (auto& m : markers_) {
m.stale = true;
m.extrapolated = false;
}
stale_view_ = was_established || stale_view_;
predictor_.reset(); // The marker ended with its session.
others_.clear();
markers_.clear();
client_.reset();
established_ = false;
const bool not_ready =
@@ -483,8 +536,12 @@ class RemoteSession {
client::InputLead lead_;
std::optional<Clock::time_point> last_present_;
std::uint64_t resends_{}, refused_{};
std::vector<network::ReplicatedMarker> others_;
client::TickClock clock_;
client::MarkerInterpolator interpolator_;
std::uint64_t observed_tick_{};
double render_tick_{};
std::vector<MarkerView> markers_;
bool stale_view_{};
bool established_{}, welcomed_{}, exhausted_{};
bool following_{true}; // The camera follows the server's (default) view.
};
+3
View File
@@ -102,6 +102,9 @@ if(EVO_BUILD_CLIENT)
evo_msquic_runtime(evo-motion-trace)
add_test(NAME motion-trace-smoke COMMAND evo-motion-trace --smoke)
set_tests_properties(motion-trace-smoke PROPERTIES TIMEOUT 120 LABELS "client;quic-session")
# M10.7b: two clients, remote-marker interpolation error and a 1.5 s outage (ADR-0095).
add_test(NAME motion-trace-remote-smoke COMMAND evo-motion-trace --remote --smoke)
set_tests_properties(motion-trace-remote-smoke PROPERTIES TIMEOUT 120 LABELS "client;quic-session")
endif()
endif()
if(BUILD_TESTING)
+2 -2
View File
@@ -532,8 +532,8 @@ probe) with process evidence done; 10.5c engineering client switched to M10 sess
probe-motion-v1 rule, server markers, session protocol v3 marker records and the client
predictor done; 10.6b wiring (sessions, evo-server, probe, GUI marker) done; 10.6c impaired
traces done (networking/M10_PREDICTION_TRACES.md). 10.7 split (ADR-0095): 10.7a tick clock,
remote-marker interpolation and fractional prediction done; 10.7b client wiring, loss view
and two-client trace follow. 10.8-10.9 planned.
remote-marker interpolation and fractional prediction done; 10.7b client wiring, stale loss
view and two-client interpolation traces done. 10.8-10.9 planned.
**Entry:** M9 client/session evidence and M7/M8 dev/stage durability. Read
NETWORK_ARCHITECTURE, PERSISTENCE_ARCHITECTURE and ADR-0017. The M9 transport is
+5 -2
View File
@@ -61,8 +61,11 @@ camera and interest. M10.6c traces it through the impairment relay: exact withou
94-99 % exact at 60-200 ms RTT with 2-5 % loss, convergence after stopping and a restart
resync of about 2-3 s (networking/M10_PREDICTION_TRACES.md). M10.6 is complete. M10.7a (ADR-0095) adds a drift-corrected tick clock, adaptive
interpolation of remote markers (2-6 ticks behind, at most 2 ticks extrapolated, then
stale; organisms never) and sub-tick own-marker presentation. Next: 10.7b client wiring,
the stale loss view and a two-client trace.
stale; organisms never) and sub-tick own-marker presentation. M10.7b wires it into the
engineering client. A lost session's view stays frozen and labelled stale until the
reconnect's fresh baseline. In two-client traces, remote markers shown as current stay
within about 0.1 m of the true path, and outages show stale. M10.7 is complete. Next:
M10.8 authority transfer between two regions (needs a ratified handoff ADR).
## Previous gate - 2026-10-02
@@ -55,3 +55,34 @@ when a snapshot is lost. No controllable organism moves yet.
- Remote markers are shown 100-300 ms in the past, the own marker in the predicted
present. That is the usual split; interactions that need both are later work.
- Extrapolated or stale markers are flagged so the client can draw them differently.
## M10.7b client wiring, loss view and traces (2026-10-06)
- **Engineering client** (`apps/evo-client/remote_session.hpp`):
- every newly observed server tick (watermark or snapshot) feeds the clock;
- each snapshot's other markers go to the interpolator;
- the own marker is presented at clock + lead, between whole ticks;
- other markers are presented at clock - delay;
- the Session panel shows the delay and the stale count;
- stale markers are drawn grey.
- **Silence is stale.** The clock freezes one tick past the last observation, so on a
silent link the render tick never passes the newest snapshot. Markers are therefore also
stale once 3 ticks (150 ms) pass without any observation. A marker held across a gap of
more than 8 ticks is stale too.
- **Session loss.** The last view stays frozen: the own marker at its last authoritative
position, all markers stale. The banner reads "STALE (last view, frozen)" and the
environment is already stale-encoded. Nothing is predicted or sent. Welcome resets the
clock, interpolator and markers (fresh baseline). The server already stops admission and
removes the marker when a session closes: no offline progression.
- **Error measurement** records a prediction only for ticks at or before the newest server
tick plus the lead. The clock may run one tick past the newest observation, and inputs
for such a tick may still come. Recording it gave false errors, seen as a Windows-only
test failure.
- **Evidence:**
- `client-remote-session`: the frozen stale view and its reset on reconnect; two
sessions each seeing the other's marker behind its own predicted view; removal when
one leaves.
- `evo-motion-trace --remote`, with the CTest `motion-trace-remote-smoke`: current
markers' 95th percentile within 1 m, the outage mostly shown stale, recovery after it.
- Figures in [M10_PREDICTION_TRACES](../networking/M10_PREDICTION_TRACES.md).
- Not covered: interpolating organisms (none move; they are shown as replicated and never
extrapolated). M10.7 is complete.
+44
View File
@@ -4635,3 +4635,47 @@ Executed:
- `client-network`: 13/13.
Not done: client wiring, the loss view and the two-client trace (10.7b).
## 2026-10-06 — M10.7b client interpolation, loss view and traces (ADR-0095)
Implemented:
- the engineering client's tick clock, interpolated remote markers (grey when stale), the
own marker between ticks, and the frozen stale view on loss (banner, all markers stale,
own marker at its last authoritative position), reset on Welcome;
- `TickClock::silence` and silence-based staleness; long-gap holds marked stale;
- error recording limited to scheduled ticks (`predict_between(..., record)`);
- `evo-motion-trace --remote` and the CTest `motion-trace-remote-smoke`;
- a shared region bench in the trace tool.
Found and fixed during development:
- an outage never showed stale (the frozen clock kept the render tick inside the buffer);
- post-outage holds were shown as current;
- false prediction errors from presenting one tick past the scheduled ticks (a Windows-only
`client-remote-session` failure);
- MSVC rejecting `std::erase_if` with a member-pointer predicate;
- two clang-tidy optional-access findings.
Figures are in docs/networking/M10_PREDICTION_TRACES.md:
- remote markers shown as current: p99 at most 60.7 mm, max 100 mm;
- outages: 84-90 % of samples shown stale, recovery 150-950 ms;
- smoke variance: one of three runs had 32 % extrapolated and 36 % stale samples, with
current errors still 0.
Executed:
- **Linux GCC 14:**
- preset `client-network`: CTest 16/16 (including both trace smokes and
client-remote-session);
- preset `quic`: 4/4;
- full remote and prediction trace runs.
- **Linux Clang 19:** ASan/UBSan `evo-network-tests`, and clang-tidy 19 on the trace tool,
client app, panels, remote test, interpolation sources and tests.
- **Windows MSVC 19.44** (fresh binaries):
- preset `client-network`: 14/14;
- `client-remote-session` passed 5 times in a row after the fix;
- preset `quic`: 4/4.
The Postgres suite was not rerun: no server code changed in M10.7.
Not done:
- interpolating organisms (none move);
- a GUI run against evolution-dev (needs a v3 server).
+4 -1
View File
@@ -35,7 +35,10 @@ evo-client --connect void.aeternalisgames.com:7400 --server-name NAME --ca dev-c
are blue), an engineering experiment, not an organism (ADR-0094). It is predicted
locally and corrected by the server; the camera follows it until you pan or zoom.
The Session panel lists each intention as sent, admitted, rejected, simulated (final;
intentions are never durable) or unknown, plus the prediction figures.
intentions are never durable) or unknown, plus the prediction figures. Other players'
markers are shown a few ticks in the past, interpolated (ADR-0095); grey means stale.
- If the connection is lost, the last view stays on screen, frozen and labelled STALE,
until the reconnect brings a fresh view. Nothing you press is sent meanwhile.
- Each reconnect uses the next grant. A second client with a bundle for the same account
takes the session over; the first stops (do not share bundles).
- A server on an older session protocol (v1, v2) refuses the client
+42
View File
@@ -62,3 +62,45 @@ row: 95.9-98.3 % exact, resync 2,241-2,248 ms.
- Many clients at once (10.8).
- Real links (dev route); deferred until a v3 server is deployed.
- Sub-tick presentation: the marker steps at 20 Hz.
## M10.7b remote interpolation (2026-10-06, ADR-0095)
`evo-motion-trace --remote`. Two clients, each behind its own relay with the profile's
impairment. A moves with the script; B shows A's marker interpolated. Every 10 ms B's
presented position is compared with A's authoritative path, interpolated linearly at B's
render tick (clock minus delay). Midway through the 20 s, B's link is cut for 1.5 s
(outage). "Current" excludes markers shown as stale.
| Profile | Samples | p99 mm (all) | max mm (all) | Current p99 mm | Current max mm | Extrapolated | Stale | Mean delay (ticks) | Outage shown stale | Recovered ms |
|---|---|---|---|---|---|---|---|---|---|---|
| clean | 1705 | 0 | 2,514.0 | 0 | 0 | 0 % | 0.8 % | 2.00 | 89.9 % | 156 |
| lan | 1706 | 0 | 2,518.7 | 0 | 0 | 0 % | 0.8 % | 2.00 | 89.3 % | 160 |
| rtt60-loss2 | 1704 | 0 | 2,598.8 | 0 | 0 | 0 % | 0.8 % | 2.00 | 89.9 % | 154 |
| rtt120-loss2 | 1700 | 87.6 | 2,977.8 | 60.7 | 100.0 | 0 % | 2.8 % | 2.98 | 86.3 % | 510 |
| rtt200-loss5 | 1696 | 2,811.5 | 2,862.4 | 22.0 | 83.0 | 2.5 % | 5.3 % | 2.11 | 84.2 % | 950 |
- Markers shown as current are within about 0.1 m of the true path at their render tick.
Linear motion between snapshots is exact; errors come from direction changes within a
gap.
- The large all-sample maxima come from the long-gap rule after the outage: the
pre-outage position is held until the first post-outage snapshot's tick. Those frames
are flagged stale and drawn grey, never presented as current.
- During the outage the marker is shown stale after the 150 ms grace (the clock freezes
one tick past the last observation; silence beyond 3 ticks is stale). The ~10 % of
outage samples that are not yet stale are that grace.
- Recovery (the first non-stale frame after the link returns) takes 150-950 ms. It grows
with RTT and loss: the next snapshot must arrive, and the delay must cover it.
- Variance: in one of three smoke runs (rtt60-loss2, 8 s), 32 % of samples were
extrapolated and 36 % stale, while current errors stayed at 0 mm. That is consistent
with snapshot datagrams being dropped under congestion while watermarks still arrived;
the adaptive delay rose only to 2.23 ticks on average. The other two runs matched the
table.
Prediction rerun after the M10.7 changes (own marker presented between ticks; errors
recorded only for ticks inputs are scheduled for):
- clean: 100 % exact.
- lan: 99.8 %.
- rtt60-loss2: 99.5 %.
- rtt120-loss2: 97.1 %; resync 2,500 ms.
- rtt200-loss5: 94.2 %; max 1,293.3 mm.
All profiles converged.
+7 -4
View File
@@ -35,12 +35,15 @@ class TickClock {
[[nodiscard]] std::uint64_t snaps() const noexcept {
return snaps_;
}
// Ticks of local time since the last observation (nothing before the first): a silent
// server freezes the clock, so silence itself is what marks views stale.
[[nodiscard]] std::optional<double> silence(Clock::time_point now) const;
private:
[[nodiscard]] double raw(double base, Clock::time_point now) const;
TickClockLimits limits_;
std::optional<double> base_tick_;
Clock::time_point base_time_{};
Clock::time_point base_time_{}, seen_{};
std::uint64_t newest_{};
double returned_{};
std::uint64_t snaps_{};
@@ -51,9 +54,9 @@ class TickClock {
// snapshot a marker continues its replicated held vector for at most `max_extrapolation`
// ticks, then freezes and is marked stale. A marker appears at the tick of the snapshot that
// added it and disappears at the tick of the one that removed it (never interpolated toward a
// removal). Snapshots further apart than `max_gap` are not interpolated across (the newer
// one is shown from its tick). The delay adapts to the observed gaps between received
// snapshots (lost or late ones), within [min_delay, max_delay].
// removal). Snapshots further apart than `max_gap` are not interpolated across: the older is
// held, marked stale, until the newer one's tick. The delay adapts to the observed gaps between
// received snapshots (lost or late ones), within [min_delay, max_delay].
struct InterpolationLimits {
double min_delay{2}, max_delay{6}; // Ticks (ADR-0095).
double max_extrapolation{2}; // Ticks beyond the newest snapshot.
+6 -2
View File
@@ -55,11 +55,14 @@ class MotionPredictor {
// nothing before the first authoritative state.
[[nodiscard]] std::optional<network::motion::State> predict(std::uint64_t tick);
// M10.7 (ADR-0095): the position `fraction` (0..1) of the way from tick to tick + 1, for
// presentation between ticks; records the prediction for `tick` like predict().
// presentation between ticks. With `record`, the prediction for `tick` is kept to measure
// errors like predict(); a caller presenting beyond the tick it schedules inputs for passes
// false (inputs for that tick may still come).
struct Point {
double x{}, y{}; // Micrometres.
};
[[nodiscard]] std::optional<Point> predict_between(std::uint64_t tick, double fraction);
[[nodiscard]] std::optional<Point> predict_between(std::uint64_t tick, double fraction,
bool record = true);
// The jump rebasing made to the newest prediction (old minus new), since the last call.
struct Offset {
std::int64_t x{}, y{};
@@ -82,6 +85,7 @@ class MotionPredictor {
}
private:
[[nodiscard]] std::optional<network::motion::State> predict(std::uint64_t tick, bool record);
[[nodiscard]] std::optional<network::motion::State> replay(std::uint64_t tick);
// Re-predicts the newest presented tick after a change and accumulates the jump.
void rebase(const std::optional<network::motion::State>& before);
+10 -1
View File
@@ -26,6 +26,7 @@ double TickClock::raw(double base, Clock::time_point now) const {
void TickClock::observe(std::uint64_t tick, Clock::time_point now) {
newest_ = std::max(newest_, tick);
seen_ = now;
const auto sample = static_cast<double>(tick);
if (!base_tick_) {
base_tick_ = sample;
@@ -43,6 +44,12 @@ void TickClock::observe(std::uint64_t tick, Clock::time_point now) {
base_time_ = now;
}
std::optional<double> TickClock::silence(Clock::time_point now) const {
if (!base_tick_)
return std::nullopt;
return ms(now - seen_) / limits_.tick_ms;
}
std::optional<double> TickClock::at(Clock::time_point now) {
if (!base_tick_)
return std::nullopt;
@@ -123,8 +130,10 @@ std::vector<PresentedMarker> MarkerInterpolator::at(double render_tick) {
snapshots_, [&](const Snapshot& s) { return static_cast<double>(s.tick) > render_tick; });
const auto& a = *std::prev(b);
if (b->tick - a.tick > limits_.max_gap) {
++stats_.gap_snaps; // Too far apart to interpolate: hold the older until the newer.
++stats_.gap_snaps; // Too far apart to interpolate: hold the older (stale) until b.
show(a);
for (auto& m : out)
m.stale = true;
return out;
}
const auto t =
+8 -4
View File
@@ -66,6 +66,10 @@ void MotionPredictor::authoritative(const AuthoritativeMarker& a) {
}
std::optional<network::motion::State> MotionPredictor::predict(std::uint64_t tick) {
return predict(tick, true);
}
std::optional<network::motion::State> MotionPredictor::predict(std::uint64_t tick, bool record) {
if (!authority_)
return std::nullopt;
const auto authority_tick = authority_->tick;
@@ -73,7 +77,7 @@ std::optional<network::motion::State> MotionPredictor::predict(std::uint64_t tic
if (!state)
return std::nullopt;
presented_tick_ = tick;
if (tick > authority_tick) {
if (record && tick > authority_tick) {
history_[tick] = *state;
while (history_.size() > limits_.max_history)
history_.erase(history_.begin());
@@ -81,9 +85,9 @@ std::optional<network::motion::State> MotionPredictor::predict(std::uint64_t tic
return state;
}
std::optional<MotionPredictor::Point> MotionPredictor::predict_between(std::uint64_t tick,
double fraction) {
const auto from = predict(tick);
std::optional<MotionPredictor::Point>
MotionPredictor::predict_between(std::uint64_t tick, double fraction, bool record) {
const auto from = predict(tick, record);
if (!from)
return std::nullopt;
const auto to = replay(tick + 1);
+46
View File
@@ -243,7 +243,13 @@ void views_interest_and_intentions(Region& r) {
CHECK(s.environment().freshness() == client::Freshness::stale);
CHECK(s.outcomes().entries().size() == 2 && s.outcomes().entries()[1].sequence == 2 &&
s.outcomes().entries()[1].state == OutcomeState::unknown);
// The lost session's view stays frozen and stale (ADR-0095): the own marker at its last
// authoritative position, nothing moving while reconnecting.
const auto frozen = s.status();
CHECK(frozen.stale_view && frozen.marker && frozen.stale_markers == s.markers().size() &&
std::ranges::all_of(s.markers(), [](const auto& m) { return m.stale; }));
CHECK(c.until(r, [&] { return s.status().phase == "connected"; }, 20));
CHECK(!s.status().stale_view);
CHECK(s.status().epoch == 4 && s.status().session != old_session &&
s.status().grants_left == 0 && c.phase() == LaunchPhase::connected);
// Views restart for the new epoch, at the camera's interest (sent again).
@@ -263,6 +269,45 @@ void views_interest_and_intentions(Region& r) {
CHECK(c.host.launcher().error() == LaunchError::grant_refused && !c.host.session());
}
// Two sessions: each sees the other's marker interpolated a few ticks behind its
// authoritative path; a session that leaves takes its marker with it (ADR-0095).
void remote_markers(Region& r) {
Client a, b;
CHECK(a.host.connect(RemoteSession::open(r.material({r.grant(account(7), 1)}))));
CHECK(b.host.connect(RemoteSession::open(r.material({r.grant(account(8), 1)}))));
const auto both = [&] {
a.host.step(Clock::now(), a.intention, a.ui);
return a.phase() == LaunchPhase::connected && b.phase() == LaunchPhase::connected &&
a.host.session()->status().marker && b.host.session()->status().other_markers == 1;
};
CHECK(b.until(r, both, 20));
auto& sa = *a.host.session();
auto& sb = *b.host.session();
a.intention.move_y = 1000; // A walks +y at 100 mm per tick.
const auto drive = [&](auto done) {
return b.until(
r,
[&] {
a.host.step(Clock::now(), a.intention, a.ui);
return done();
},
20);
};
const auto remote = [&] {
const auto it = std::ranges::find_if(sb.markers(), [](const auto& m) { return !m.own; });
CHECK(it != sb.markers().end());
return *it;
};
CHECK(drive([&] { return remote().y_mm > 4500; }));
// B shows A in the recent past: behind A's own (predicted) view, never ahead of it.
const auto seen = remote();
CHECK(!seen.stale && seen.x_mm == 3500 && seen.y_mm < sa.status().marker_y_mm &&
sb.status().interpolation_delay >= 2 && sb.status().interpolation_delay <= 6);
// A leaves: its marker disappears from B's view.
a.host.cancel();
CHECK(drive([&] { return sb.status().other_markers == 0; }));
}
void refusals(Region& r) {
// A grant for another region: refused before any Welcome; the launcher stops.
Client wrong;
@@ -289,6 +334,7 @@ int main() try {
{
Region r{files};
views_interest_and_intentions(r);
remote_markers(r);
refusals(r);
}
std::filesystem::remove_all(files.dir);
+5 -2
View File
@@ -38,8 +38,10 @@ void clock_basics() {
// A resume far ahead (pause, reconnect) snaps forward.
clock.observe(200, t0 + milliseconds{5000});
CHECK(clock.snaps() == 1 && near(must(clock.at(t0 + milliseconds{5000})), 200));
// Silence is measured in local ticks since the last observation.
CHECK(near(must(clock.silence(t0 + milliseconds{5100})), 2));
clock.reset();
CHECK(!clock.at(t0));
CHECK(!clock.at(t0) && !clock.silence(t0));
clock.observe(3, t0);
CHECK(near(must(clock.at(t0)), 3)); // After a reset (new epoch) it may start lower.
}
@@ -108,7 +110,8 @@ void interpolation() {
const std::vector<RemoteMarker> later{marker(1, 9'000'000)};
m.push(20, later);
at = m.at(12);
CHECK(at.size() == 2 && near(at[0].x, 400'000) && m.stats().gap_snaps == 1);
CHECK(at.size() == 2 && near(at[0].x, 400'000) && at[0].stale && at[1].stale &&
m.stats().gap_snaps == 1);
CHECK(near(m.at(20)[0].x, 9'000'000));
m.reset();
CHECK(m.at(20).empty() && near(m.delay(), 2));
+352 -169
View File
@@ -1,17 +1,23 @@
// M10.6c probe-marker prediction traces (ADR-0094). Development measurement, not a test of
// game behaviour: the engineering client's own session code (apps/evo-client
// remote_session.hpp) against a loopback region that simulates at 50 ms in real time, through
// the owned UDP impairment relay. Each profile scripts WASD-like movement, then stops and
// requires the prediction to converge on the authority.
// M10.6c/M10.7b probe-marker traces (ADR-0094, ADR-0095). Development measurement, not a
// test of game behaviour: the engineering client's own session code (apps/evo-client
// remote_session.hpp) against a loopback region that simulates at 50 ms in real time,
// through the owned UDP impairment relay (one relay per client).
//
// evo-motion-trace [--seconds S] [--profile NAME] [--smoke]
// evo-motion-trace [--seconds S] [--profile NAME] [--remote] [--smoke]
//
// One line per profile:
// Prediction (default): one client scripts WASD-like movement, then stops and requires its
// prediction to converge on the authority. One line per profile:
// motion PROFILE rtt=MS jitter=MS loss=% samples=N exact=% p50/p95/p99/max=MM corrections=N
// snaps=N refused=N dropped=N resends=N lead=TICKS max_pending=N converged=0|1
// and for the restart profile: restart resync_ms=MS converged=0|1.
// --smoke runs one short impaired profile plus the restart and exits 1 unless both converge,
// the input list stayed bounded and most predictions were exact (the CTest).
// Remote (--remote): client A moves, client B shows A's marker interpolated; every 10 ms
// B's presented position is compared with A's authoritative path at B's render tick. Midway,
// B's link is cut for 1.5 s (outage). One line per profile:
// remote PROFILE rtt=MS jitter=MS loss=% samples=N p50/p95/p99/max=MM
// current_p99/max=MM (markers not shown stale) extrapolated=% stale=% delay=TICKS
// outage_stale=% recovered_ms=MS
// --smoke runs one short impaired profile (prediction: plus a restart) and exits 1 unless
// its bounds hold (the CTests).
#include "evo/client/session_host.hpp"
#include "evo/network/dev_credentials.hpp"
#include "evo/network/session_grant.hpp"
@@ -27,6 +33,7 @@
#include <filesystem>
#include <fstream>
#include <functional>
#include <map>
#include <optional>
#include <string>
#include <string_view>
@@ -38,6 +45,7 @@ using namespace evo;
using namespace evo::network;
using Clock = std::chrono::steady_clock;
using std::chrono::milliseconds;
using Host = client::SessionHost<client_app::RemoteSession>;
constexpr std::string_view server_name = "dev-region.evolution.test";
constexpr world::WorldIdentity world_id{9, 2};
constexpr std::uint64_t region = 21;
@@ -48,17 +56,12 @@ struct Profile {
milliseconds one_way{}, jitter{};
double loss{};
};
struct Result {
std::vector<std::uint64_t> errors;
client_app::RemoteStatus status;
bool converged{};
double resync_ms{};
};
std::uint64_t now_seconds() {
return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::system_clock::now().time_since_epoch())
.count());
}
// Nearest-rank percentile of micrometre samples, in millimetres.
double percentile_mm(std::vector<std::uint64_t> v, double p) {
if (v.empty())
return 0;
@@ -66,6 +69,9 @@ double percentile_mm(std::vector<std::uint64_t> v, double p) {
const auto rank = static_cast<std::size_t>(p / 100 * static_cast<double>(v.size() - 1));
return static_cast<double>(v.at(rank)) / 1000;
}
double share(std::uint64_t part, std::uint64_t whole) {
return whole == 0 ? 0.0 : 100.0 * static_cast<double>(part) / static_cast<double>(whole);
}
struct Files {
std::filesystem::path dir, ca, certificate, key;
@@ -99,194 +105,357 @@ std::array<std::uint8_t, grant_private_key_bytes> scalar() {
s.back() = 0x2C;
return s;
}
impair::Impairment impairment(const Profile& p) {
impair::Impairment way;
way.delay = p.one_way;
way.jitter = p.jitter;
way.loss = p.loss;
return way;
}
// One profile: a fresh region, relay and client session.
class Trace {
// WASD-like movement: a new direction every 0.4-1.1 s (seeded), held in between.
class Script {
public:
Trace(const Files& f, const Profile& p) : files_{f}, profile_{p} {}
std::optional<Result> run(std::chrono::seconds moving, bool restart) {
void step(client::Intention& intention) {
if (Clock::now() < change_)
return;
static constexpr std::array<std::pair<std::int16_t, std::int16_t>, 9> directions{
{{1000, 0},
{-1000, 0},
{0, 1000},
{0, -1000},
{707, 707},
{-707, 707},
{707, -707},
{-707, -707},
{0, 0}}};
const auto d = directions.at(next() % directions.size());
intention.move_x = d.first;
intention.move_y = d.second;
change_ = Clock::now() + milliseconds{400 + static_cast<int>(next() % 700)};
}
private:
std::uint64_t next() {
seed_ = ((seed_ ^ (seed_ >> 31)) * 0xBF58'476D'1CE4'E5B9ULL) + 1;
return seed_;
}
std::uint64_t seed_{0x9E37'79B9'7F4A'7C15ULL};
Clock::time_point change_{};
};
// A loopback region on real 50 ms ticks with probe markers, and clients behind relays.
class Bench {
public:
explicit Bench(const Files& f) : files_{f} {}
bool start() {
auto key = GrantSigningKey::import(DeploymentEnvironment::dev, 1, scalar());
if (!key)
return std::nullopt;
return false;
key_.emplace(std::move(*key));
server::RegionSessionsConfig c;
c.transport.certificate_pem_file = files_.certificate.string();
c.transport.key_pem_file = files_.key.string();
c.control.environment = DeploymentEnvironment::dev;
c.control.world = world_id;
c.control.region = region;
c.control.epoch = epoch_;
c.issuer_keys.push_back({1, *key->public_key()});
c.control.epoch = epoch;
c.issuer_keys.push_back({1, *key_->public_key()});
auto sessions = server::RegionSessions::create(std::move(c));
if (!sessions)
return std::nullopt;
return false;
sessions_ = std::move(*sessions);
sessions_->set_default_interest({0, 0, 0, 7});
if (!sessions_->set_motion_area({-20'000'000, -20'000'000, 20'999'999, 20'999'999, 0},
500'000, 500'000))
return sessions_->set_motion_area({-20'000'000, -20'000'000, 20'999'999, 20'999'999, 0},
500'000, 500'000);
}
// A client session behind its own relay, with `grants` single-use grants.
std::optional<std::pair<std::unique_ptr<impair::UdpRelay>, std::unique_ptr<Host>>>
client(std::uint8_t account, const Profile& p, std::uint64_t grants) {
auto relay = impair::UdpRelay::start(sessions_->port(), impairment(p), impairment(p),
0xE6 + account);
if (!relay)
return std::nullopt;
impair::Impairment way;
way.delay = profile_.one_way;
way.jitter = profile_.jitter;
way.loss = profile_.loss;
relay_ = impair::UdpRelay::start(sessions_->port(), way, way, 0xE6);
if (!relay_)
return std::nullopt;
std::vector<WireGrant> grants;
for (std::uint64_t serial = 1; serial <= 4; ++serial) {
std::vector<WireGrant> bundle;
for (std::uint64_t serial = 1; serial <= grants; ++serial) {
GrantClaims g;
g.grant_id = 700 + serial;
g.account.bytes.fill(0x5A);
g.grant_id = (std::uint64_t{account} << 16) + serial;
g.account.bytes.fill(account);
g.serial = serial;
g.world = world_id;
g.region = region;
g.issued_at = now_seconds();
g.expires_at = g.issued_at + 300;
const auto signed_grant = key->sign(g);
if (!key_)
return std::nullopt;
const auto signed_grant = key_->sign(g);
if (!signed_grant)
return std::nullopt;
grants.push_back(*signed_grant);
bundle.push_back(*signed_grant);
}
client::SessionHost<client_app::RemoteSession> host;
if (!host.connect(client_app::RemoteSession::open({{"127.0.0.1", relay_->port()},
std::string{server_name},
files_.ca_pem,
files_.ca.string(),
std::move(grants)})))
auto host = std::make_unique<Host>();
if (!host->connect(client_app::RemoteSession::open({{"127.0.0.1", relay->port()},
std::string{server_name},
files_.ca_pem,
files_.ca.string(),
std::move(bundle)})))
return std::nullopt;
client::UiState ui;
client::Intention intention;
auto* session = host.session();
const auto connected = [&] { return session && session->status().phase == "connected"; };
if (!pump(host, ui, intention, connected, std::chrono::seconds{10}))
return std::nullopt;
Result r;
// Movement: a new direction every 0.4-1.1 s (seeded), held in between.
std::uint64_t seed = 0x9E37'79B9'7F4A'7C15ULL;
const auto next = [&] {
seed = (seed ^ (seed >> 31)) * 0xBF58'476D'1CE4'E5B9ULL + 1;
return seed;
};
const std::array<std::pair<std::int16_t, std::int16_t>, 9> directions{{{1000, 0},
{-1000, 0},
{0, 1000},
{0, -1000},
{707, 707},
{-707, 707},
{707, -707},
{-707, -707},
{0, 0}}};
const auto end = Clock::now() + moving;
auto change = Clock::now();
while (Clock::now() < end) {
if (Clock::now() >= change) {
const auto d = directions.at(next() % directions.size());
intention.move_x = d.first;
intention.move_y = d.second;
change = Clock::now() + milliseconds{400 + static_cast<int>(next() % 700)};
}
if (!pump(
host, ui, intention, [] { return false; }, milliseconds{10}) &&
!host.session())
return std::nullopt;
collect(r, *host.session());
}
// Stop and require convergence: no input in flight, prediction equal to the authority.
intention.move_x = intention.move_y = 0;
r.converged = pump(
host, ui, intention, [&] { return settled(*host.session()); }, std::chrono::seconds{5});
collect(r, *host.session());
if (restart) {
// A restart: the epoch advances, the session reconnects with its next grant and the
// marker is respawned; resync is the time until the prediction matches again.
const auto before = host.session()->status().session;
++epoch_;
const auto start = Clock::now();
const bool back = pump(
host, ui, intention,
[&] {
const auto s = host.session()->status();
return s.phase == "connected" && s.session != before && s.marker &&
settled(*host.session());
},
std::chrono::seconds{15});
r.resync_ms = std::chrono::duration<double, std::milli>(Clock::now() - start).count();
r.converged = r.converged && back;
collect(r, *host.session());
}
r.status = host.session()->status();
return r;
return std::pair{std::move(relay), std::move(host)};
}
private:
// Region ticks every 50 ms of real time; the client steps every millisecond.
bool pump(client::SessionHost<client_app::RemoteSession>& host, client::UiState& ui,
const client::Intention& intention, const std::function<bool()>& done,
std::chrono::milliseconds limit) {
// One server iteration: a new tick every 50 ms of real time, then poll and replicate.
void serve() {
const auto now = Clock::now();
if (now >= next_tick_) {
++tick;
next_tick_ = std::max(next_tick_ + tick_period, now - tick_period);
}
sessions_->poll({true, epoch, tick}, now_seconds(), now);
if (tick != replicated_) {
replicated_ = tick;
sessions_->replicate(tick, [](const SessionInterest&) {
ReplicationSource s;
s.identity = world_id;
return s;
});
}
static_cast<void>(sessions_->take_events());
}
// Steps the region and the clients (each with its intention) until `done` or `limit`.
bool pump(const std::vector<std::pair<Host*, client::Intention*>>& clients,
const std::function<bool()>& done, std::chrono::milliseconds limit) {
client::UiState ui;
const auto end = Clock::now() + limit;
while (Clock::now() < end) {
const auto now = Clock::now();
if (now >= next_tick_) {
++tick_;
next_tick_ = std::max(next_tick_ + tick_period, now - tick_period);
serve();
for (const auto& [host, intention] : clients) {
host->step(Clock::now(), *intention, ui);
if (!host->session())
return false;
}
sessions_->poll({true, epoch_, tick_}, now_seconds(), now);
if (tick_ != replicated_) {
replicated_ = tick_;
sessions_->replicate(tick_, [](const SessionInterest&) {
ReplicationSource s;
s.identity = world_id;
return s;
});
}
static_cast<void>(sessions_->take_events());
host.step(Clock::now(), intention, ui);
if (!host.session())
return false;
if (done())
return true;
std::this_thread::sleep_for(milliseconds{1});
}
return done();
}
// Nothing in flight and the presented (smoothed) marker on the authoritative position.
bool settled(client_app::RemoteSession& s) {
const auto status = s.status();
const auto* m = sessions_->markers().of(status.session);
return status.marker && m != nullptr && status.inputs_pending == 0 &&
m->state.vector == motion::Vector{} &&
std::llround(status.marker_x_mm * 1000) == m->state.x &&
std::llround(status.marker_y_mm * 1000) == m->state.y;
}
static void collect(Result& r, client_app::RemoteSession& s) {
for (const auto e : s.take_prediction_errors())
r.errors.push_back(e);
[[nodiscard]] const motion::Marker* marker(std::uint64_t session) const {
return sessions_->markers().of(session);
}
std::uint64_t epoch{1}, tick{1};
private:
const Files& files_;
Profile profile_;
std::optional<GrantSigningKey> key_;
std::unique_ptr<server::RegionSessions> sessions_;
std::unique_ptr<impair::UdpRelay> relay_;
std::uint64_t epoch_{1}, tick_{1}, replicated_{};
std::uint64_t replicated_{};
Clock::time_point next_tick_{Clock::now()};
};
void report(const Profile& p, const Result& r) {
const auto exact = std::ranges::count(r.errors, std::uint64_t{0});
const auto share = r.errors.empty() ? 0.0
: 100.0 * static_cast<double>(exact) /
static_cast<double>(r.errors.size());
bool connected(Host& h) {
return h.session() && h.session()->status().phase == "connected";
}
// Nothing in flight and the presented (smoothed) own marker on the authoritative position.
bool settled(const Bench& bench, client_app::RemoteSession& s) {
const auto status = s.status();
const auto* m = bench.marker(status.session);
return status.marker && m != nullptr && status.inputs_pending == 0 &&
m->state.vector == motion::Vector{} &&
std::llround(status.marker_x_mm * 1000) == m->state.x &&
std::llround(status.marker_y_mm * 1000) == m->state.y;
}
struct PredictionResult {
std::vector<std::uint64_t> errors;
client_app::RemoteStatus status;
bool converged{};
double resync_ms{};
};
std::optional<PredictionResult> prediction(const Files& files, const Profile& p,
std::chrono::seconds moving, bool restart) {
Bench bench{files};
if (!bench.start())
return std::nullopt;
auto made = bench.client(0x5A, p, 4);
if (!made)
return std::nullopt;
auto& host = *made->second;
client::Intention intention;
const std::vector<std::pair<Host*, client::Intention*>> one{{&host, &intention}};
if (!bench.pump(one, [&] { return connected(host); }, std::chrono::seconds{10}))
return std::nullopt;
PredictionResult r;
const auto collect = [&] {
for (const auto e : host.session()->take_prediction_errors())
r.errors.push_back(e);
};
Script script;
const auto end = Clock::now() + moving;
while (Clock::now() < end) {
script.step(intention);
if (!bench.pump(one, [] { return false; }, milliseconds{10}) && !host.session())
return std::nullopt;
collect();
}
// Stop and require convergence on the authority.
intention = {};
r.converged =
bench.pump(one, [&] { return settled(bench, *host.session()); }, std::chrono::seconds{5});
collect();
if (restart) {
// The epoch advances: the session reconnects with its next grant and the marker is
// respawned; resync is the time until the prediction matches again.
const auto before = host.session()->status().session;
++bench.epoch;
const auto start = Clock::now();
const bool back = bench.pump(
one,
[&] {
const auto s = host.session()->status();
return s.phase == "connected" && s.session != before && s.marker &&
settled(bench, *host.session());
},
std::chrono::seconds{15});
r.resync_ms = std::chrono::duration<double, std::milli>(Clock::now() - start).count();
r.converged = r.converged && back;
collect();
}
r.status = host.session()->status();
return r;
}
struct RemoteResult {
std::vector<std::uint64_t> errors; // Outside the outage.
std::vector<std::uint64_t> current; // The same, for markers not shown as stale.
std::uint64_t samples{}, extrapolated{}, stale{}, outage_samples{}, outage_stale{};
double delay_sum{}, recovered_ms{-1};
};
std::optional<RemoteResult> remote(const Files& files, const Profile& p,
std::chrono::seconds moving) {
Bench bench{files};
if (!bench.start())
return std::nullopt;
auto a = bench.client(0x61, p, 2);
auto b = bench.client(0x62, p, 2);
if (!a || !b)
return std::nullopt;
auto& ha = *a->second;
auto& hb = *b->second;
client::Intention ia, ib;
const std::vector<std::pair<Host*, client::Intention*>> both{{&ha, &ia}, {&hb, &ib}};
if (!bench.pump(
both,
[&] {
return connected(ha) && connected(hb) && hb.session()->status().other_markers == 1;
},
std::chrono::seconds{10}))
return std::nullopt;
const auto session_a = ha.session()->status().session;
// A's authoritative path by tick (state after the tick).
std::map<std::uint64_t, std::pair<double, double>> path;
const auto record = [&] {
if (const auto* m = bench.marker(session_a))
path[bench.tick] = {static_cast<double>(m->state.x), static_cast<double>(m->state.y)};
};
const auto truth = [&](double t) -> std::optional<std::pair<double, double>> {
const auto lo = static_cast<std::uint64_t>(std::floor(t));
const auto from = path.find(lo), to = path.find(lo + 1);
if (from == path.end() || to == path.end())
return std::nullopt;
const auto f = t - static_cast<double>(lo);
return std::pair{from->second.first + ((to->second.first - from->second.first) * f),
from->second.second + ((to->second.second - from->second.second) * f)};
};
RemoteResult r;
Script script;
const auto start = Clock::now();
const auto outage_from = start + (moving / 2), outage_to = outage_from + milliseconds{1500};
bool cut = false;
const auto end = start + moving;
while (Clock::now() < end) {
const auto now = Clock::now();
if (!cut && now >= outage_from && now < outage_to) {
impair::Impairment dead = impairment(p);
dead.loss = 1.0;
b->first->set(dead, dead);
cut = true;
} else if (cut && now >= outage_to) {
b->first->set(impairment(p), impairment(p));
cut = false;
}
script.step(ia);
if (!bench.pump(
both,
[&] {
record();
return false;
},
milliseconds{10}) &&
(!ha.session() || !hb.session()))
return std::nullopt;
const auto s = hb.session()->status();
const auto& markers = hb.session()->markers();
const auto it = std::ranges::find_if(markers, [](const auto& m) { return !m.own; });
if (it == markers.end())
continue;
const bool in_outage = Clock::now() >= outage_from && Clock::now() < outage_to;
if (in_outage) {
++r.outage_samples;
r.outage_stale += it->stale ? 1 : 0;
continue;
}
if (Clock::now() >= outage_to && r.recovered_ms < 0 && !it->stale)
r.recovered_ms =
std::chrono::duration<double, std::milli>(Clock::now() - outage_to).count();
const auto t = truth(s.remote_render_tick);
if (!t)
continue;
++r.samples;
r.extrapolated += it->extrapolated ? 1 : 0;
r.stale += it->stale ? 1 : 0;
r.delay_sum += s.interpolation_delay;
const auto dx = (it->x_mm * 1000) - t->first, dy = (it->y_mm * 1000) - t->second;
const auto error = static_cast<std::uint64_t>(std::llround(std::hypot(dx, dy)));
r.errors.push_back(error);
if (!it->stale)
r.current.push_back(error);
}
return r;
}
void report(const Profile& p, const PredictionResult& r) {
const auto exact = static_cast<std::uint64_t>(std::ranges::count(r.errors, std::uint64_t{0}));
const auto& s = r.status;
std::printf(
"motion %s rtt=%lld jitter=%lld loss=%.1f samples=%zu exact=%.1f "
"p50/p95/p99/max=%.1f/%.1f/%.1f/%.1f corrections=%llu snaps=%llu refused=%llu "
"dropped=%llu resends=%llu lead=%llu max_pending=%llu converged=%d\n",
p.name.c_str(), 2 * static_cast<long long>(p.one_way.count()),
static_cast<long long>(p.jitter.count()), p.loss * 100, r.errors.size(), share,
percentile_mm(r.errors, 50), percentile_mm(r.errors, 95), percentile_mm(r.errors, 99),
percentile_mm(r.errors, 100), static_cast<unsigned long long>(s.corrections),
static_cast<unsigned long long>(s.snaps), static_cast<unsigned long long>(s.refused_inputs),
static_cast<unsigned long long>(s.dropped_inputs),
static_cast<unsigned long long>(s.resends), static_cast<unsigned long long>(s.lead),
static_cast<unsigned long long>(s.max_pending), r.converged ? 1 : 0);
std::printf("motion %s rtt=%lld jitter=%lld loss=%.1f samples=%zu exact=%.1f "
"p50/p95/p99/max=%.1f/%.1f/%.1f/%.1f corrections=%llu snaps=%llu refused=%llu "
"dropped=%llu resends=%llu lead=%llu max_pending=%llu converged=%d\n",
p.name.c_str(), 2 * static_cast<long long>(p.one_way.count()),
static_cast<long long>(p.jitter.count()), p.loss * 100, r.errors.size(),
share(exact, r.errors.size()), percentile_mm(r.errors, 50),
percentile_mm(r.errors, 95), percentile_mm(r.errors, 99),
percentile_mm(r.errors, 100), static_cast<unsigned long long>(s.corrections),
static_cast<unsigned long long>(s.snaps),
static_cast<unsigned long long>(s.refused_inputs),
static_cast<unsigned long long>(s.dropped_inputs),
static_cast<unsigned long long>(s.resends), static_cast<unsigned long long>(s.lead),
static_cast<unsigned long long>(s.max_pending), r.converged ? 1 : 0);
if (r.resync_ms > 0)
std::printf("restart %s resync_ms=%.0f converged=%d\n", p.name.c_str(), r.resync_ms,
r.converged ? 1 : 0);
std::fflush(stdout);
}
void report(const Profile& p, const RemoteResult& r) {
std::printf("remote %s rtt=%lld jitter=%lld loss=%.1f samples=%llu "
"p50/p95/p99/max=%.1f/%.1f/%.1f/%.1f current_p99/max=%.1f/%.1f extrapolated=%.1f "
"stale=%.1f delay=%.2f outage_stale=%.1f recovered_ms=%.0f\n",
p.name.c_str(), 2 * static_cast<long long>(p.one_way.count()),
static_cast<long long>(p.jitter.count()), p.loss * 100,
static_cast<unsigned long long>(r.samples), percentile_mm(r.errors, 50),
percentile_mm(r.errors, 95), percentile_mm(r.errors, 99),
percentile_mm(r.errors, 100), percentile_mm(r.current, 99),
percentile_mm(r.current, 100), share(r.extrapolated, r.samples),
share(r.stale, r.samples),
r.samples == 0 ? 0.0 : r.delay_sum / static_cast<double>(r.samples),
share(r.outage_stale, r.outage_samples), r.recovered_ms);
std::fflush(stdout);
}
} // namespace
@@ -294,17 +463,20 @@ void report(const Profile& p, const Result& r) {
int main(int argc, char** argv) {
std::chrono::seconds seconds{20};
std::string only;
bool smoke = false;
bool smoke = false, remote_mode = false;
for (int i = 1; i < argc; ++i) {
const std::string_view a = argv[i];
if (a == "--smoke")
smoke = true;
else if (a == "--remote")
remote_mode = true;
else if (a == "--seconds" && i + 1 < argc)
seconds = std::chrono::seconds{std::max(1, std::atoi(argv[++i]))};
else if (a == "--profile" && i + 1 < argc)
only = argv[++i];
else {
std::fputs("usage: evo-motion-trace [--seconds S] [--profile NAME] [--smoke]\n",
std::fputs("usage: evo-motion-trace [--seconds S] [--profile NAME] [--remote] "
"[--smoke]\n",
stderr);
return 2;
}
@@ -319,23 +491,34 @@ int main(int argc, char** argv) {
{"rtt200-loss5", milliseconds{100}, milliseconds{20}, 0.05}};
if (smoke) {
profiles = {{"rtt60-loss2", milliseconds{30}, milliseconds{5}, 0.02}};
seconds = std::chrono::seconds{6};
seconds = std::chrono::seconds{remote_mode ? 8 : 6};
}
int code = 0;
for (const auto& p : profiles) {
if (!only.empty() && p.name != only)
continue;
Trace t{*files, p};
const auto r = t.run(seconds, smoke || p.name == "rtt120-loss2");
if (remote_mode) {
const auto r = remote(*files, p, seconds);
if (!r) {
std::printf("remote %s setup-failed\n", p.name.c_str());
code = 1;
continue;
}
report(p, *r);
// Bounds: errors within a metre at the 95th percentile, the outage shown stale,
// recovery after it.
if (smoke && (r->samples == 0 || percentile_mm(r->current, 95) > 1000 ||
share(r->outage_stale, r->outage_samples) < 50 || r->recovered_ms < 0))
code = 1;
continue;
}
const auto r = prediction(*files, p, seconds, smoke || p.name == "rtt120-loss2");
if (!r) {
std::printf("motion %s setup-failed\n", p.name.c_str());
code = 1;
continue;
}
report(p, *r);
if (r->resync_ms > 0)
std::printf("restart %s resync_ms=%.0f converged=%d\n", p.name.c_str(), r->resync_ms,
r->converged ? 1 : 0);
const auto exact = std::ranges::count(r->errors, std::uint64_t{0});
if (smoke && (!r->converged || r->status.max_pending > 32 || r->errors.empty() ||
exact * 2 < static_cast<std::ptrdiff_t>(r->errors.size())))