smooth the synthetic event generator: tight band around a slow random walk, lower default rate (#23)

The original generator placed every new limit order at a uniformly
random integer price in [95, 105] and ran the engine at 50,000
events per second. On the desktop bench this is fine; on the Twilight
dashboard wired to the live Fly machine it looks like the top of
book is glitching across 100 different values per second, because
that is literally what is happening.

Replace the price distribution with a mean-reverting random walk
around a fixed anchor (kAnchor = 100). Each event nudges the
reference by at most one tick, and the away-from-anchor step is
suppressed when the reference has drifted off the anchor. New limit
orders cluster within four ticks of the reference, so the resting
book builds depth at a handful of adjacent levels rather than
scattering across the whole price range. The event mix favors limit
orders more heavily (80 percent limits, 8 percent market sweeps,
12 percent cancels) so the visible book accumulates depth between
fills.

Drop the default rate from 50000 to 400 events per second. The bench
binary is the right place to push throughput; the live demo runs at
a rate the React renderer can show legibly. Update fly.toml's
MERIDIAN_RATE accordingly.

Local smoke (60 frames over 10 s against the rebuilt server, seed 7):

  mid visited values: 99.5, 100.0, 100.5
  bid/ask pairs alternate between (100,101), (99,101), (99,100)

That is one to two ticks of organic movement, not flashing across
the whole 10-tick range. 182/182 release tests still pass.

Author: MustafaNazeer

apps/server/main.cpp

@@ -51,7 +51,12 @@ namespace {
 
 struct Cfg {
     int port = 0;
-    std::uint64_t rate_eps = 50000;  // engine events per second
+    // Default rate is sized for a small Fly machine, not the bench. The
+    // bench binary is the right place to push events per second; this
+    // default keeps the live demo visually legible (the React dashboard
+    // updates at 30 Hz and individual book moves should be readable).
+    // Bump via --rate when running the server on a beefier host.
+    std::uint64_t rate_eps = 400;
     std::uint64_t seed = 42;
     std::vector<std::string> origins;  // empty = accept any (dev default)
 };
@@ -198,10 +203,25 @@ int main(int argc, char** argv) {
     std::fflush(stdout);
 
     // Engine thread: synthetic limit / market / cancel mix.
+    //
+    // The price model tracks a slowly drifting reference mid: every event
+    // nudges it by at most one tick with a strong pull toward the anchor
+    // (kAnchor = 100), so the displayed top of book moves like a real
+    // instrument rather than skipping uniformly across a wide range. New
+    // limit orders cluster near the current reference (one to four ticks
+    // off depending on side), so a tight visible spread builds and
+    // moves a tick at a time. The event mix favors limit orders so the
+    // book accumulates depth between cancels and market sweeps.
     std::thread engine_thr([&]() {
         std::mt19937_64 rng(cfg.seed);
-        std::uniform_int_distribution<int> price_dist(95, 105);
-        std::uniform_int_distribution<int> qty_dist(1, 30);
+        constexpr int kAnchor = 100;
+        constexpr int kPriceFloor = 92;
+        constexpr int kPriceCeiling = 108;
+        int reference = kAnchor;
+
+        std::uniform_int_distribution<int> offset_dist(0, 3);   // ticks off the mid
+        std::uniform_int_distribution<int> drift_dist(-1, 1);   // small random walk
+        std::uniform_int_distribution<int> qty_dist(1, 25);
         std::uniform_int_distribution<int> bucket(0, 99);
         std::bernoulli_distribution side_dist(0.5);
 
@@ -220,22 +240,54 @@ int main(int argc, char** argv) {
             ev.symbol = kSym;
             ev.ts = ++ts;
             ev.side = side_dist(rng) ? meridian::Side::Buy : meridian::Side::Sell;
+
+            // Mean-reverting random walk: each event nudges the
+            // reference at most one tick. At the anchor the step is a
+            // free uniform draw over {-1, 0, +1}; away from the anchor
+            // the away-direction step is suppressed so the reference
+            // drifts back toward the anchor over time. This keeps the
+            // displayed top of book within a few ticks of kAnchor.
+            const int raw_step = drift_dist(rng);
+            const int pull = reference > kAnchor ? -1 : (reference < kAnchor ? 1 : 0);
+            int step;
+            if (pull == 0) {
+                step = raw_step;
+            } else if (raw_step == 0 || raw_step == pull) {
+                step = raw_step;
+            } else {
+                step = 0;
+            }
+            reference += step;
+            if (reference < kPriceFloor) reference = kPriceFloor;
+            if (reference > kPriceCeiling) reference = kPriceCeiling;
+
             const int b = bucket(rng);
-            if (b < 70 || max_id == 0) {
+            if (b < 80 || max_id == 0) {
+                // Limit order placed near the reference, with a small
+                // offset so the resting book builds depth across a
+                // handful of ticks rather than at one price.
                 ev.kind = meridian::EventKind::NewOrder;
                 ev.type = meridian::OrderType::Limit;
                 ev.order_id = next_id++;
-                ev.price = price_dist(rng);
+                const int offset = offset_dist(rng);
+                ev.price = (ev.side == meridian::Side::Buy)
+                    ? reference - offset
+                    : reference + offset;
                 ev.qty = qty_dist(rng);
                 max_id = ev.order_id;
-            } else if (b < 90) {
+            } else if (b < 88) {
+                // Occasional market sweep that lifts the resting book.
                 ev.kind = meridian::EventKind::NewOrder;
                 ev.type = meridian::OrderType::Market;
                 ev.order_id = next_id++;
                 ev.price = 0;
                 ev.qty = qty_dist(rng) / 4 + 1;
                 max_id = ev.order_id;
             } else {
+                // Cancellation of an existing order. Real exchanges
+                // cancel far more orders than they fill; the 12 percent
+                // share here is a deliberate undercount to keep the
+                // visible book lively rather than empty.
                 std::uniform_int_distribution<meridian::OrderId> cancel_dist(1, max_id);
                 ev.kind = meridian::EventKind::Cancel;
                 ev.order_id = cancel_dist(rng);

fly.toml

@@ -22,7 +22,12 @@ primary_region = "iad"
 
 [env]
   MERIDIAN_PORT = "8080"
-  MERIDIAN_RATE = "50000"
+  # The live demo runs at a visually legible rate, not a benchmark rate.
+  # The bench binary is the right place to push events per second; this
+  # value (400 events per second, ~13 per 30 Hz sampler tick) keeps the
+  # dashboard lively without flooding the React renderer or the Fly
+  # shared CPU machine.
+  MERIDIAN_RATE = "400"
   MERIDIAN_SEED = "42"
   # The Origin allowlist for /ws upgrades. Browsers always send Origin;
   # the production lockdown rejects anything that is not the Cloudflare