Add M10.6c probe-marker prediction traces and close M10.6
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m54s
Foundation / checks (postgres) (push) Canceled after 0s
Foundation / checks (tsan) (push) Canceled after 0s
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 12m33s
Foundation / checks (network) (push) Canceled after 10m23s
Foundation / checks (client) (push) Canceled after 12m33s
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m54s
Foundation / checks (postgres) (push) Canceled after 0s
Foundation / checks (tsan) (push) Canceled after 0s
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 12m33s
Foundation / checks (network) (push) Canceled after 10m23s
Foundation / checks (client) (push) Canceled after 12m33s
evo-motion-trace drives the engineering client's own session code through the owned impairment relay against a real-time 50 ms loopback region: exact without loss, 94-99 % exact at 60-200 ms RTT with 2-5 % loss, every profile converging after stopping, restart resync about 2-3 s (docs/networking/M10_PREDICTION_TRACES.md). The CTest motion-trace-smoke checks convergence, bounds and a majority of exact predictions. The relay lets a new sender take over after the current client has been silent for 1 s (reconnects); the client counts refusal receipts. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
+2
-2
@@ -25,8 +25,8 @@
|
||||
{"name": "client-probe", "configurePreset": "client-probe", "targets": ["evo-client-probe"]},
|
||||
{"name": "network", "configurePreset": "network", "targets": ["evo-client-state-tests", "evo-network-tests", "evo-dev-session"]},
|
||||
{"name": "quic", "configurePreset": "quic", "targets": ["evo-quic-smoke-tests", "evo-quic-transport-tests", "evo-quic-session-tests", "evo-quic-hol-measure", "evo-session-probe", "evo-network-tests"]},
|
||||
{"name": "client-network", "configurePreset": "client-network", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests", "evo-session-probe"]},
|
||||
{"name": "client-package", "configurePreset": "client-package", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests"]}
|
||||
{"name": "client-network", "configurePreset": "client-network", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests", "evo-motion-trace", "evo-session-probe"]},
|
||||
{"name": "client-package", "configurePreset": "client-package", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests", "evo-motion-trace"]}
|
||||
],
|
||||
"testPresets": [
|
||||
{"name": "debug", "configurePreset": "debug", "output": {"outputOnFailure": true}},
|
||||
|
||||
@@ -61,6 +61,9 @@ struct RemoteStatus {
|
||||
double marker_x_mm{}, marker_y_mm{};
|
||||
std::size_t inputs_pending{}, other_markers{};
|
||||
std::uint64_t lead{}, corrections{}, max_error_um{}, snaps{};
|
||||
// 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{};
|
||||
};
|
||||
// A probe marker to draw: the own one predicted and smoothed, others as replicated.
|
||||
struct MarkerView {
|
||||
@@ -146,8 +149,17 @@ class RemoteSession {
|
||||
s.corrections = predictor_.stats().corrections;
|
||||
s.max_error_um = predictor_.stats().max_error_um;
|
||||
s.snaps = smoother_.snaps();
|
||||
s.rejected_inputs = predictor_.stats().rejected_inputs;
|
||||
s.dropped_inputs = predictor_.stats().dropped_inputs;
|
||||
s.max_pending = predictor_.stats().max_pending;
|
||||
s.resends = resends_;
|
||||
s.refused_inputs = refused_;
|
||||
return s;
|
||||
}
|
||||
// Prediction error samples since the last call (micrometres; for measurements).
|
||||
[[nodiscard]] std::vector<std::uint64_t> take_prediction_errors() {
|
||||
return predictor_.take_errors();
|
||||
}
|
||||
// Markers to draw this frame (empty without a session or snapshot).
|
||||
[[nodiscard]] const std::vector<MarkerView>& markers() const noexcept {
|
||||
return markers_;
|
||||
@@ -293,6 +305,7 @@ class RemoteSession {
|
||||
if (!sequence)
|
||||
return;
|
||||
static_cast<void>(predictor_.input({*sequence, tick, want}));
|
||||
resends_ += want == sent_ ? 1 : 0;
|
||||
sent_ = want;
|
||||
sent_tick_ = server_tick_;
|
||||
const auto entry = next_entry_++;
|
||||
@@ -316,6 +329,7 @@ class RemoteSession {
|
||||
lead_.admitted(it->tick, r.server_tick);
|
||||
} else {
|
||||
predictor_.rejected(r.sequence); // It never takes effect.
|
||||
++refused_;
|
||||
if (r.status == network::AdmitStatus::outside_window)
|
||||
lead_.too_late(); // Arrived after its tick: schedule further ahead.
|
||||
log_.record({it->entry, client::OutcomeState::rejected,
|
||||
@@ -468,6 +482,7 @@ class RemoteSession {
|
||||
client::CorrectionSmoother smoother_;
|
||||
client::InputLead lead_;
|
||||
std::optional<Clock::time_point> last_present_;
|
||||
std::uint64_t resends_{}, refused_{};
|
||||
std::vector<network::ReplicatedMarker> others_;
|
||||
std::vector<MarkerView> markers_;
|
||||
bool established_{}, welcomed_{}, exhausted_{};
|
||||
|
||||
@@ -91,6 +91,17 @@ if(EVO_BUILD_CLIENT)
|
||||
evo_msquic_runtime(evo-client-remote-tests)
|
||||
add_test(NAME client-remote-session COMMAND evo-client-remote-tests)
|
||||
set_tests_properties(client-remote-session PROPERTIES TIMEOUT 120 LABELS "client;quic-session")
|
||||
# M10.6c prediction traces through the impairment relay (development measurement); the
|
||||
# smoke run is a short impaired profile plus a restart with convergence bounds.
|
||||
add_executable(evo-motion-trace tools/network/motion_trace.cpp)
|
||||
target_include_directories(evo-motion-trace PRIVATE "${PROJECT_SOURCE_DIR}/apps/evo-client")
|
||||
target_compile_definitions(evo-motion-trace PRIVATE EVO_CLIENT_NETWORK=1)
|
||||
target_link_libraries(evo-motion-trace PRIVATE evo_client_ui evo_session_client
|
||||
evo_session_server evo_client_prediction evo_network_impair)
|
||||
evo_owned_target(evo-motion-trace)
|
||||
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")
|
||||
endif()
|
||||
endif()
|
||||
if(BUILD_TESTING)
|
||||
|
||||
+1
-2
@@ -531,8 +531,7 @@ probe) with process evidence done; 10.5c engineering client switched to M10 sess
|
||||
10.6 split (ADR-0094, EXPERIMENT probe marker, not an organism movement rule): 10.6a shared
|
||||
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 follow.
|
||||
10.6-10.9 planned.
|
||||
traces done (networking/M10_PREDICTION_TRACES.md). 10.7-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
|
||||
|
||||
+4
-1
@@ -57,7 +57,10 @@ protocol v3 marker records (v2, deployed, is frozen and refused), and the client
|
||||
(bounded replay from the authoritative marker, corrections, smoothing, adaptive input lead).
|
||||
M10.6b wires it: evo-server gives every session a marker in the habitat area, the probe
|
||||
prints it, and the engineering client predicts and draws it (WASD), following it with
|
||||
camera and interest. Next: 10.6c impaired traces and the correction report.
|
||||
camera and interest. M10.6c traces it through the impairment relay: exact without loss,
|
||||
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. Next: M10.7
|
||||
interpolation and session loss.
|
||||
|
||||
## Previous gate - 2026-10-02
|
||||
|
||||
|
||||
@@ -96,3 +96,22 @@ rules. Session protocol v2 was deployed to evolution-dev on 2026-10-06 and is fr
|
||||
intention moves the predicted marker and the authority confirms it with zero error.
|
||||
- The real-process test: the probe's marker moved +x with its intention applied, and
|
||||
evo-server reported the motion area.
|
||||
|
||||
## M10.6c traces and close (2026-10-06)
|
||||
- `evo-motion-trace` drives the client's own session code through the impairment relay
|
||||
against a real-time 50 ms loopback region; the figures are in
|
||||
[M10_PREDICTION_TRACES](../networking/M10_PREDICTION_TRACES.md).
|
||||
- Prediction is exact without loss.
|
||||
- With 2-5 % loss and 60-200 ms RTT, 94-99 % of samples are exact. Errors stay within the
|
||||
motion of the lost or late inputs (at most about 1.4 m) and are corrected by the resend.
|
||||
- All profiles converge on the authority when stopped.
|
||||
- A restart resyncs in about 2-3 s (the reconnect pause).
|
||||
- The CTest `motion-trace-smoke` (labels client, quic-session) runs 6 s of rtt60-loss2 plus
|
||||
a restart. It fails unless both converge, the input list stays within its bound and most
|
||||
predictions are exact.
|
||||
- The owned UDP relay now lets a new sender take over once the current client has been
|
||||
silent for 1 s, so a reconnecting client (new source port) can be traced. Concurrent
|
||||
senders are still dropped.
|
||||
- The client now counts refusal receipts (`refused`) separately from inputs the predictor
|
||||
removed; the unused `PredictionStats::refused_inputs` field is gone.
|
||||
- M10.6 is complete. Sub-tick presentation and remote-marker interpolation belong to 10.7.
|
||||
|
||||
@@ -4562,3 +4562,44 @@ clang-format 19 was applied to the changed files.
|
||||
Not done:
|
||||
- impaired traces (10.6c);
|
||||
- a GUI run against evolution-dev, which needs a v3 server.
|
||||
|
||||
## 2026-10-06 — M10.6c prediction traces (ADR-0094)
|
||||
|
||||
Implemented:
|
||||
- `evo-motion-trace` (the client's own session code through the impairment relay against
|
||||
a real-time 50 ms loopback region);
|
||||
- the CTest `motion-trace-smoke`;
|
||||
- the relay takeover by a new sender after the current client has been silent for 1 s;
|
||||
- a refusal count in the client status, replacing the unused predictor field.
|
||||
|
||||
Figures are in docs/networking/M10_PREDICTION_TRACES.md. Linux, one run of each profile:
|
||||
- clean and lan: 100 % exact;
|
||||
- rtt60-loss2: 97.9 %;
|
||||
- rtt120-loss2: 99.3 %; restart resync 2,946 ms;
|
||||
- rtt200-loss5: 94.1 %; p99 500 mm, max 989.9 mm.
|
||||
|
||||
Every profile converged after stopping. Windows was similar, with a maximum of 1,399.8 mm
|
||||
at rtt200-loss5. The smoke profile passed 3 times in a row on Linux.
|
||||
|
||||
Found and fixed during development:
|
||||
- the relay ignored a reconnecting client (new source port), so restart resync timed out;
|
||||
- refusals were undercounted when an input had already been dropped;
|
||||
- a clang-tidy widening-cast finding.
|
||||
|
||||
Executed:
|
||||
- **Linux GCC 14**
|
||||
- preset `client-network`: CTest 15/15, including motion-trace-smoke and
|
||||
client-remote-session;
|
||||
- preset `quic`: 4/4, including quic-transport with the changed relay.
|
||||
- **Linux Clang 19:** clang-tidy 19 on the trace tool, client app, remote test, predictor
|
||||
and relay.
|
||||
- **Windows MSVC 19.44** (fresh binaries):
|
||||
- preset `quic`: 4/4;
|
||||
- preset `client-network`: 13/13, including motion-trace-smoke;
|
||||
- a full trace run.
|
||||
|
||||
The Postgres suite was not rerun: no server code changed since 10.6b.
|
||||
|
||||
Not done:
|
||||
- traces over the dev route (a v3 server must be deployed first);
|
||||
- many-client load (10.8).
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
# M10.6c probe-marker prediction traces (2026-10-06)
|
||||
|
||||
Development reference for ADR-0094 (EXPERIMENT: a probe marker, not organism movement).
|
||||
Tool: `evo-motion-trace` (tools/network/motion_trace.cpp, preset `client-network`).
|
||||
|
||||
## Setup
|
||||
- The engineering client's own session code (`apps/evo-client/remote_session.hpp`: the
|
||||
predictor, adaptive lead, resend, smoothing).
|
||||
- A loopback region simulating at 50 ms in real time, with RegionSessions and probe
|
||||
markers.
|
||||
- The owned UDP impairment relay with the same impairment in both directions (seed 0xE6).
|
||||
- Script: a new direction every 0.4-1.1 s from 9 choices (including stop) for 20 s. Then
|
||||
stop and require convergence: nothing in flight and the presented (smoothed) marker
|
||||
exactly on the authoritative position.
|
||||
- The `rtt120-loss2` profile then advances the epoch: the session reconnects with its next
|
||||
grant after the client's 2 s pause, and resync is measured until the prediction matches
|
||||
the respawned marker.
|
||||
- Error: one sample per authoritative snapshot of the own marker. It is the distance
|
||||
between what the client predicted for that tick and what the authority reported.
|
||||
Corrections are the jumps that rebasing made to the presented position.
|
||||
|
||||
## Results (Linux GCC 14 release, WSL2, one run)
|
||||
|
||||
| Profile | RTT ms | Jitter ms | Loss | Samples | Exact | p95 mm | p99 mm | max mm | Corrections | Refused | Dropped | Resends | Final lead | Max pending | Converged |
|
||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
||||
| clean | 0 | 0 | 0 % | 400 | 100 % | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 1 | yes |
|
||||
| lan | 20 | 2 | 0 % | 400 | 100 % | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 1 | yes |
|
||||
| rtt60-loss2 | 60 | 5 | 2 % | 378 | 97.9 % | 0 | 369.5 | 799.9 | 3 | 2 | 3 | 3 | 4 | 1 | yes |
|
||||
| rtt120-loss2 | 120 | 10 | 2 % | 279 | 99.3 % | 0 | 0 | 200.0 | 1 | 2 | 2 | 2 | 2 | 1 | yes |
|
||||
| rtt200-loss5 | 200 | 20 | 5 % | 358 | 94.1 % | 100.0 | 500.0 | 989.9 | 6 | 5 | 7 | 6 | 7 | 2 | yes |
|
||||
|
||||
Windows MSVC 19.44 (same tool, one run):
|
||||
- clean and lan: 100 % exact.
|
||||
- rtt60-loss2: 99.5 % exact, max 200 mm.
|
||||
- rtt120-loss2: 98.6 %, max 500 mm; resync 2,498 ms.
|
||||
- rtt200-loss5: 94.3 %, p95 100 mm, p99 600 mm, max 1,399.8 mm, lead 7, max 2 pending.
|
||||
- All profiles converged.
|
||||
|
||||
Restart (rtt120-loss2): resync took 2,946 ms, almost all of it the client's reconnect pause
|
||||
(2 s) and login. The smoke profile (6 s of rtt60-loss2 plus a restart) passed three runs in a
|
||||
row: 95.9-98.3 % exact, resync 2,241-2,248 ms.
|
||||
|
||||
## Reading
|
||||
- Without loss every prediction is exact: the rule is shared and integer-exact, and inputs
|
||||
are scheduled far enough ahead.
|
||||
- Errors come from inputs that did not take effect: lost datagrams (dropped) or arrivals
|
||||
after their tick (refused, which also raises the lead). Each costs at most the motion
|
||||
until the resend lands: 100 mm per tick, so up to about 1.4 m at 200 ms RTT with 5 % loss
|
||||
(two losses in a row). Smoothing hid
|
||||
every correction (no snaps above 2 m).
|
||||
- The input list stayed tiny (at most 2 pending), far below its bound of 32. Replay depth
|
||||
equals the lead plus the snapshot age.
|
||||
- The lead adapts upward on refusals (7 at 200 ms RTT) and back down when receipts show
|
||||
spare ticks. At 120 ms it ended at 2 after recovering; occasional refusals stay bounded
|
||||
by the resend rule.
|
||||
- Figures are single runs on one machine with wall-clock pacing: indicative, not
|
||||
acceptance thresholds. The CTest `motion-trace-smoke` checks only convergence,
|
||||
boundedness and a majority of exact predictions.
|
||||
|
||||
## Not measured
|
||||
- Remote-entity interpolation (10.7).
|
||||
- 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.
|
||||
@@ -35,7 +35,7 @@ struct AuthoritativeMarker {
|
||||
};
|
||||
struct PredictionStats {
|
||||
std::uint64_t authoritative{}, corrections{}, replayed_ticks{}, dropped_inputs{},
|
||||
rejected_inputs{}, refused_inputs{};
|
||||
rejected_inputs{};
|
||||
std::uint64_t max_error_um{}, max_pending{};
|
||||
};
|
||||
|
||||
|
||||
@@ -97,6 +97,7 @@ struct UdpRelay::Impl {
|
||||
std::uint16_t port{};
|
||||
sockaddr_in target{};
|
||||
std::optional<sockaddr_in> client;
|
||||
Clock::time_point client_seen{};
|
||||
mutable std::mutex mutex;
|
||||
Impairment up, down;
|
||||
RelayCounters counters;
|
||||
@@ -169,11 +170,17 @@ struct UdpRelay::Impl {
|
||||
if (n <= 0)
|
||||
continue;
|
||||
const std::lock_guard lock{mutex};
|
||||
if (side == 0 && !client)
|
||||
client = from; // The first client owns the relay.
|
||||
if (side == 0 && (from.sin_port != client->sin_port ||
|
||||
from.sin_addr.s_addr != client->sin_addr.s_addr))
|
||||
continue;
|
||||
// One client at a time: the first owns the relay; another sender takes over
|
||||
// only after the owner has been silent for a second (a reconnect, M10.6c).
|
||||
const bool owner = client && from.sin_port == client->sin_port &&
|
||||
from.sin_addr.s_addr == client->sin_addr.s_addr;
|
||||
if (side == 0 && !owner) {
|
||||
if (client && now - client_seen < std::chrono::seconds{1})
|
||||
continue;
|
||||
client = from;
|
||||
}
|
||||
if (side == 0)
|
||||
client_seen = now;
|
||||
admit(side == 0, {buffer.data(), buffer.data() + n}, now);
|
||||
}
|
||||
std::vector<Pending> ready;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#pragma once
|
||||
// M10.2 owned UDP impairment relay (ADR-0090) for tests and measurements; never shipped.
|
||||
// Listens on 127.0.0.1:<port> for one client and forwards to 127.0.0.1:<target>, applying
|
||||
// Listens on 127.0.0.1:<port> for one client at a time (a new sender takes over after the
|
||||
// current one has been silent for 1 s: a reconnect) and forwards to 127.0.0.1:<target>, applying
|
||||
// seeded loss, duplication, reordering, delay/jitter, a payload-size (MTU) limit and
|
||||
// corruption to each packet in each direction. Impairment decisions come from SplitMix64
|
||||
// in packet order; wall-clock delivery times are not deterministic. Runs its own thread.
|
||||
|
||||
@@ -0,0 +1,346 @@
|
||||
// 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.
|
||||
//
|
||||
// evo-motion-trace [--seconds S] [--profile NAME] [--smoke]
|
||||
//
|
||||
// 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).
|
||||
#include "evo/client/session_host.hpp"
|
||||
#include "evo/network/dev_credentials.hpp"
|
||||
#include "evo/network/session_grant.hpp"
|
||||
#include "evo/server/region_sessions.hpp"
|
||||
#include "remote_session.hpp"
|
||||
#include "udp_relay.hpp"
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <chrono>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <functional>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
using namespace evo;
|
||||
using namespace evo::network;
|
||||
using Clock = std::chrono::steady_clock;
|
||||
using std::chrono::milliseconds;
|
||||
constexpr std::string_view server_name = "dev-region.evolution.test";
|
||||
constexpr world::WorldIdentity world_id{9, 2};
|
||||
constexpr std::uint64_t region = 21;
|
||||
constexpr std::chrono::milliseconds tick_period{50};
|
||||
|
||||
struct Profile {
|
||||
std::string name;
|
||||
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());
|
||||
}
|
||||
double percentile_mm(std::vector<std::uint64_t> v, double p) {
|
||||
if (v.empty())
|
||||
return 0;
|
||||
std::ranges::sort(v);
|
||||
const auto rank = static_cast<std::size_t>(p / 100 * static_cast<double>(v.size() - 1));
|
||||
return static_cast<double>(v.at(rank)) / 1000;
|
||||
}
|
||||
|
||||
struct Files {
|
||||
std::filesystem::path dir, ca, certificate, key;
|
||||
std::string ca_pem;
|
||||
};
|
||||
std::optional<Files> credentials() {
|
||||
const auto made = generate_dev_credentials(DeploymentEnvironment::dev, server_name, 1,
|
||||
std::chrono::system_clock::now());
|
||||
if (!made)
|
||||
return std::nullopt;
|
||||
Files f;
|
||||
f.dir = std::filesystem::temp_directory_path() / "evo-motion-trace";
|
||||
std::filesystem::remove_all(f.dir);
|
||||
std::filesystem::create_directories(f.dir);
|
||||
f.ca_pem = made->authority_pem;
|
||||
f.ca = f.dir / "ca.pem";
|
||||
f.certificate = f.dir / "server.pem";
|
||||
f.key = f.dir / "server.key";
|
||||
for (const auto& [path, text] : {std::pair{f.ca, made->authority_pem},
|
||||
std::pair{f.certificate, made->server_certificate_pem},
|
||||
std::pair{f.key, made->server_key_pem}}) {
|
||||
std::ofstream out{path, std::ios::binary | std::ios::trunc};
|
||||
out << text;
|
||||
if (!out)
|
||||
return std::nullopt;
|
||||
}
|
||||
return f;
|
||||
}
|
||||
std::array<std::uint8_t, grant_private_key_bytes> scalar() {
|
||||
std::array<std::uint8_t, grant_private_key_bytes> s{};
|
||||
s.back() = 0x2C;
|
||||
return s;
|
||||
}
|
||||
|
||||
// One profile: a fresh region, relay and client session.
|
||||
class Trace {
|
||||
public:
|
||||
Trace(const Files& f, const Profile& p) : files_{f}, profile_{p} {}
|
||||
std::optional<Result> run(std::chrono::seconds moving, bool restart) {
|
||||
auto key = GrantSigningKey::import(DeploymentEnvironment::dev, 1, scalar());
|
||||
if (!key)
|
||||
return std::nullopt;
|
||||
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()});
|
||||
auto sessions = server::RegionSessions::create(std::move(c));
|
||||
if (!sessions)
|
||||
return std::nullopt;
|
||||
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 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) {
|
||||
GrantClaims g;
|
||||
g.grant_id = 700 + serial;
|
||||
g.account.bytes.fill(0x5A);
|
||||
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 (!signed_grant)
|
||||
return std::nullopt;
|
||||
grants.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)})))
|
||||
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;
|
||||
}
|
||||
|
||||
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) {
|
||||
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);
|
||||
}
|
||||
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);
|
||||
}
|
||||
const Files& files_;
|
||||
Profile profile_;
|
||||
std::unique_ptr<server::RegionSessions> sessions_;
|
||||
std::unique_ptr<impair::UdpRelay> relay_;
|
||||
std::uint64_t epoch_{1}, tick_{1}, 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());
|
||||
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::fflush(stdout);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
std::chrono::seconds seconds{20};
|
||||
std::string only;
|
||||
bool smoke = false;
|
||||
for (int i = 1; i < argc; ++i) {
|
||||
const std::string_view a = argv[i];
|
||||
if (a == "--smoke")
|
||||
smoke = 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",
|
||||
stderr);
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
const auto files = credentials();
|
||||
if (!files)
|
||||
return 2;
|
||||
std::vector<Profile> profiles{{"clean", milliseconds{0}, milliseconds{0}, 0.0},
|
||||
{"lan", milliseconds{10}, milliseconds{2}, 0.0},
|
||||
{"rtt60-loss2", milliseconds{30}, milliseconds{5}, 0.02},
|
||||
{"rtt120-loss2", milliseconds{60}, milliseconds{10}, 0.02},
|
||||
{"rtt200-loss5", milliseconds{100}, milliseconds{20}, 0.05}};
|
||||
if (smoke) {
|
||||
profiles = {{"rtt60-loss2", milliseconds{30}, milliseconds{5}, 0.02}};
|
||||
seconds = std::chrono::seconds{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 (!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())))
|
||||
code = 1;
|
||||
}
|
||||
std::filesystem::remove_all(files->dir);
|
||||
return code;
|
||||
}
|
||||
Reference in New Issue
Block a user