Skip to content

RTP Comparison - Pre-Writeup

Status: working notes, not a finished post. Methodology, controls, caveats, and the current result set for helpers/StressTestRTP. Trim again before publishing.

Staleness rule. A result section is kept only while its competitor versions match what is currently shipping. When a competitor releases, the affected section is re-run or deleted - never annotated and kept. Superseded run tables live in git history (git log -p on this file), not here.


1. What we're measuring

How each /rtp-style plugin behaves on a single server driven at sustained load by a black-box harness.

Primary axes:

Axis Source Lower-is-better
Cold-start /rtp latency first attempt of each phase, latency_ms yes
Warm-path latency distribution per-target p50/p95/p99/p99.9/max of latency_ms yes
Success rate successes / attempts per phase no
Throughput (TP/s) successful attempts / phase wall-time no
TPS under sustained burst min tps_at_dispatch per phase no
MSPT during eval p99 / max mspt_at_dispatch per phase yes
Main-thread CPU per teleport main_thread_cpu_ms / attempts yes
Background chunk-load share off-tick loads / attributed loads no

Diagnostic axes:

Axis Source Purpose
Process CPU per teleport process_cpu_ms / attempts gross JVM cost per /rtp, async loaders included
Destination scatter (to_x, to_z) per success effective radius, distribution shape, queue reuse
Folia watchdog stalls server log, not the harness region-thread blocking (S-005 class)

Section 8 lists the axes the current harness added; they are not yet reflected in any result section below.


2. Plugins under test

Plugin Version as tested Notes
RTP 26.1 / 26.2 (Pro), 3.1.3 (Lite) Test subject. Configurable centre.
BetterRTP 3.6.13 Configurable centre. Config reverts on shutdown - see section 7.
EzRTP 3.4.0 Configurable centre.
JustRTP see run header Configurable centre. Pre-cache competitor - the closest architectural match to RTP in the roster. Paper/Folia 1.21+ only; no Spigot arm. See section 7.
HuskHomes Paper-4.10 No centre config - pinned to /spawn.
EssentialsX /tpr 2.21.2 Excluded - /tpr is self-only; cannot be driven from console.
DonutRTP 8 Excluded - GUI front-end dispatching BetterRTP. See section 7.

Roster policy: only plugins that load and complete warm-up on the platform under test appear in a result table. A plugin absent from a table is a compatibility finding for its author, not a benchmark loss.


3. Controls applied (apples-to-apples)

This is the control set for the next run. Where it differs from what section 5's runs used, the difference is called out in the row and in section 6's recorded parameters - which stay as the historical record and are not rewritten to match.

Variable Value applied Why
Outer radius 16384 blocks (1024 chunks), every plugin Equalize selectable area across all 6 contenders. RTP region radius: 16384b (1024 chunks); BetterRTP MaxRadius: 17408 (yields 16384 effective blocks due to formula truncation); EzRTP radius.max: 16384; JustRTP max_radius: 16384; JakesRTP radius.max: 16384; HuskHomes region.max: 16384.
Inner radius 1024 blocks (64 chunks), every plugin Full inner exclusion parity. RTP centerRadius: 64 chunks (64 * 16 = 1024 blocks); BetterRTP MinRadius: 1024; EzRTP radius.min: 1024; JustRTP min_radius: 1024; JakesRTP radius.min: 1024; HuskHomes region.min: 1024.
Pregen envelope must cover the full 16384 radius per cell Binding constraint on the radius increase - past the pregenerated edge the run silently becomes a worldgen benchmark.
Cooldowns / delays / countdowns zeroed on every plugin Cooldown is anti-spam policy, not throughput.
Worldgen pregenerated world retained A fresh world neutralizes RTP's anvil prefilter and turns the test into a worldgen benchmark.
delay-chunk-unloads-by (Paper) 10s -> 0s Default lets each teleport coast on the retention cache instead of paying a real load.
Workload unit 4,096 teleports (per-target-count: 4096) Standardized sample size (N=4,096) across both burst and paced runs. Ensures spatial dispersion, duplicate rates, and chunk loads are directly comparable.
Sequence gap 180 s (3 minutes) TPS and G1GC settle between phases, allowing background chunk unloads to stabilize.
JIT warm-up 30 s, 1 cycle through every target Without it the first plugin pays the harness's JIT tax. CSV and spark writes disabled during warm-up.
Dispatch regime Test A: unthrottled (gap=0, immediate-redispatch: true)
Test B: paced 5.0 TP/s (interval=200ms, gap=4t)
Count and rate are decoupled: Test A measures peak capacity / clearance under surge; Test B measures steady-state tick impact.
Per-attempt timeout 5 s Capture-window expiry, not a server failure. See section 4.
Client load 3 real OPed accounts, concurrency 4, burst 10 No fake-player infrastructure.
Server JVM Java 21, -Xmx 16 GB, default G1GC REQ-RTP-SYS-001.

Why the world got bigger. At 4096 blocks the whole selectable area is small enough that every engine's cache converges on a few hundred region files, the OS page cache absorbs the reads, and cached candidates are reused before they can cost anything. That makes every cache look free, which is the one thing the benchmark should not conclude for free. At 16384 blocks the selectable area is 16x larger, so a cache must either hold 16x more distinct chunk neighbourhoods or refill 16x more often, and the section 8 residency, GC and heap-pressure columns finally have signal to read. Consequence: no 16384-radius number is comparable to any 4096-radius number in section 5 - the radius is now part of the run condition, like the dispatch gap.

3.1 The Decoupled 4,096-Teleport Benchmark Architecture

Earlier benchmark iterations coupled attempt counts to elapsed wall time (e.g. 1-hour unpaced runs), causing fast engines to deliver vastly more attempts than slower engines (130,120 attempts for LeafRTP vs 16,573 for JustRTP). Comparing cumulative wall time, gross GC churn, or spatial scatter density across an 8x sample-size divergence introduces severe statistical skew.

In this updated methodology, Count and Rate are treated as orthogonal variables: - Workload Unit: A fixed quota of N = 4,096 teleports (per-target-count: 4096) is held constant across all contenders. - Two Operational Regimes: The identical 4,096-teleport workload is evaluated under two complementary testing regimes answering distinct administrative questions:

                    THE 4,096-TELEPORT BENCHMARK MATRIX
                   (Fixed Work Unit: N = 4,096 teleports)
                                     │
           ┌─────────────────────────┴─────────────────────────┐
           ▼                                                   ▼
Test A: Burst Saturation ("Faster 4,096")     Test B: Steady-State Paced ("Slower 4,096")
────────────────────────────────────────      ───────────────────────────────────────────
• Pacing: Unthrottled / Rate-Unlimited         • Pacing: Matched 5.0 TP/s (200 ms interval)
• Question: "What is peak capacity under       • Question: "During regular gameplay, what
  queue spikes and DoS bursts?"                 does the server actually feel?"
• Harness Settings:                            • Harness Settings:
  - per-target-count: 4096                       - per-target-count: 4096
  - immediate-redispatch: true                   - immediate-redispatch: false
  - dispatch-interval-ms: 0                      - dispatch-interval-ms: 200
  - per-player-gap-ticks: 0                      - per-player-gap-ticks: 4
  - default-concurrency: 4                       - default-concurrency: 4
• Primary Metrics:                             • Primary Metrics:
  - 4,096 queue clearance wall time (s)          - Marginal tick impact (ΔMSPT)
  - Sustained throughput ceiling (TP/s)          - Main-thread CPU utilization (%)
  - Tail latency under surge (p95, p99)          - STW GC pause duration per 1,000 teleports
  - Minimum TPS during phase                     - Async chunk load share (%)
  - Folia / Paper watchdog stalls (S-005)
           │                                                   │
           └─────────────────────────┬─────────────────────────┘
                                     ▼
                      UNIFIED ARTIFACTS & ANALYSIS
                      ────────────────────────────
• Spatial Analysis: Clark-Evans dispersion (R), nearest-neighbor distances,
  duplicate landing counts, and 6-plugin scatter plots (N = 4,096 everywhere).
• Chunk Economics: Total chunk loads generated to find 4,096 safe destinations.
• Memory Churn: JFR-attributed target package bytes allocated across 4,096 attempts.

Why Test A Matters (Burst Saturation / Queue Clearance)

When multiple players join simultaneously, a faction runs an automated command script, or an adversary attempts to DoS the server via command spam, how does each engine behave? Test A runs unthrottled with immediate-redispatch: true and per-player-gap-ticks: 0. It measures: 1. Queue Clearance Time: How many seconds or minutes does it take to clear 4,096 requests? 2. Throughput Ceiling: Sustained TP/s under 100% saturation. 3. Resilience & Watchdogs: Does the engine lock up region threads, trip Folia watchdogs, or crash into multi-second GC pauses?

Why Test B Matters (Steady-State Server Overhead)

During ordinary gameplay, player traffic is paced. An administrator wants to know: "At 5 teleports per second, which plugin introduces the least lag and jitter?" Comparing gross CPU in Test A penalizes fast engines for executing more work per second. In Test B, every plugin delivers the exact same 5.0 TP/s. Throughput is eliminated as a variable, isolating pure algorithmic overhead: 1. Marginal Tick Overhead ($\Delta$MSPT): Computed as MSPT_phase - MSPT_settle_baseline, isolating the exact tick time added by the plugin's workload above ambient server background. 2. Main-Thread CPU %: Percentage of the primary server tick thread consumed by teleport logic. 3. STW GC Freeze Ratio: Percentage of real wall-clock time spent in Stop-The-World garbage collection pauses while recycling candidate objects. 4. Off-Tick Chunk Share: Percentage of chunk reads performed asynchronously (S-005 compliance).

Spatial Analysis Parity (Why Constant N is Essential)

Nearest-neighbor spatial metrics like the Clark-Evans dispersion index ($R = \bar{r}_A / \bar{r}_E$) rely on expected Poisson distance $\bar{r}_E = 1 / (2\sqrt{\rho})$, where spatial point density $\rho = N / A$. If $N$ diverges across plugins (e.g. 130,000 dots vs 16,000 dots within the same area $A$), $\rho$ shifts by nearly an order of magnitude. This makes scatter plots visually deceptive and distorts nearest-neighbor distances. Standardizing $N = 4,096$ across all 6 engines ensures identical density $\rho$, making Clark-Evans $R$, duplicate counts, and 3-chunk proximity clustering mathematically comparable.

Publication Architecture: Lab Working Notes vs Public MkDocs

  • Internal Scratchpad (helpers/StressTestRTP/): Houses raw test harness code, local CSV files, execution logs, and working notes (PRE_WRITEUP.md).
  • Canonical Public Documentation (docs/site/benchmarks.md): Final consolidated results, comparative tables, spatial charts, and reproduction guides will be authored under docs/site/ and published automatically via MkDocs to https://dailystruggle.github.io/RTP/site/benchmarks/. This provides responsive mobile tables, dark/light theme support, client-side search indexing, and permanent, durable links from public storefront pages (FRONT_PAGE.md).

4. What we deliberately do NOT control

  • Algorithmic shape - BetterRTP square, RTP CIRCLE, others vary. Distribution shape is part of plugin identity.
  • Retry budget - BetterRTP MaxAttempts: 32, RTP's count-bound pipeline. Different correctness/perf tradeoffs.
  • Safety-check thoroughness - RTP runs anvil prefilter + biome + vert + neighbour grid; others run far less. Honest framing: RTP trades warm-path latency for higher safety guarantees (S-001), so a normalized "speed" comparison would flatter the shallow verifier.
  • Concurrency model - HuskHomes and BetterRTP serialise per-player; RTP supports concurrent in-flight. We measure both as-shipped.
  • Biome distribution per cell - individual cold-start values vary by ~30%.

Practicality: benchmark-shaped vs production-shaped defaults

A cache can be tuned to win a ten-minute benchmark or to survive a Tuesday evening, and the two are not the same setting. A short entry TTL, a small cap, or a refill loop that only keeps up at benchmark concurrency all look excellent inside one measured phase and stop looking excellent at hour six. The reverse trap is ours: a long-lived pre-verified queue that holds coordinates indefinitely can look like a memory leak in a run too short to show the plateau.

So practicality is recorded as its own axis, not folded into latency:

Practicality question Where it is answered
Does the cache survive longer than the phase? Entry TTL vs the ~600 s phase length. A TTL near or below phase length means the run measures a refilling cache, and a longer deployment measures a different plugin. See the entry-lifetime classes below.
Does the cache size itself, and off what? Static cap vs adaptive sizing. Adaptive on free memory means the plugin's own behaviour changes with -Xmx, so the arm must state the heap it ran on.
What does it cost to hold? peak_resident_chunks, peak_plugin_tickets, tick_thread_alloc_bytes_per_attempt (section 8) - coordinate tuples vs resident chunk neighbourhoods.
What does it cost to refill? chunks_off_tick_share, region_file_reads, gc_* during the steady-state tail of the phase, not the opening minute.
Does it change behaviour under pressure? heap_pressure_* (section 8). An engine that silently cuts attempts or serves cache-only above a heap limit is not the same engine either side of that line.

Rule of thumb for the write-up: quote the second half of the phase. The first half of any phase is a pre-warmed cache draining; the second half is the refill loop's real cost, and that is what an operator actually runs.

Entry-lifetime classes (not one TTL axis)

"Unmeasured cache economics" is not a symmetric charge across the roster, because the engines do not share an expiry model. Three distinct classes:

Class Engine What a 600 s phase sees
Event-invalidated, no timer RTP. Entries in keptLocations / unkeptLocations are not expired on a clock; they leave the buffer when they are served, when the region config changes, or when spatial memory marks the bin bad. In a world with no claim plugin and no terrain edits, prior lifecycle measurement puts effective entry lifetime at "until served" - unbounded. A representative steady state. Nothing was about to expire, so nothing is hidden by phase length. Refill cost is the serve rate, which the phase measures directly.
Persistent spatial memory RTP (MemoryShape bad-location bitmaps) and EzRTP, which likewise retains spatial state across attempts rather than discarding it on a short timer. Amortizing, not expiring: the longer the run, the cheaper the next attempt. A short phase understates this design - the opposite of the TTL trap. Read it in region_file_reads and bin_candidates over the phase tail.
Time-expired JustRTP, ~15 min entry TTL (pin the figure - section 7). A cache that never once expired. This is the class where phase length genuinely caps what can be claimed, and the only class the long-phase run in section 8 exists to fix.

Consequence for the write-up: do not level the three with a single "all caches unmeasured" disclaimer. An unbounded-lifetime cache measured for 600 s is at steady state; a 15-minute-TTL cache measured for 600 s is at t=0 of its own lifecycle. Both statements are honest; they are not the same statement.

The cost that is genuinely unmeasured for RTP is the other half of the trade: long-lived entries mean retention, and retention needs peak_resident_chunks / peak_plugin_tickets at the raised radius, plus verify-on-serve latency for a coordinate that has aged (an entry cached at minute 1 and served at hour 6 must still be safe). That is a residency and staleness question, not a hit-rate one.


5. Results

Only runs on currently-shipping competitor versions are kept. Earlier Spigot 1.20.1 and Paper 1.20.1 passes were removed: every competitor in them has since released, so their numbers are not citable. See the staleness rule at the top.

5.1 Paper, unthrottled dispatch - 20260617-232754 (RTP-Paper 26.1, per-player-gap-ticks: 0)

The canonical single-server head-to-head. The 3-tick per-player gap was set to 0, so the 3-client / concurrency-4 harness dispatches as fast as each engine can absorb. Three phases back-to-back (rtp -> ezrtp -> betterrtp), each ~600 s with the 240 s inter-phase settle gap. HuskHomes was not dispatched this run (see section 5.2).

Plugin Att / Succ TP/s p50 p95 p99 p99.9 max TPS min MSPT p99 / max
RTP 16560 / 16560 (100%) 18.7 1 ms 2 ms 46 ms 518 ms 687 ms 17.5 85.8 / 98.4 ms
ezrtp 7137 / 7018 (98.3%) 13.1 30 ms 189 ms 322 ms 1936 ms 2172 ms 10.3 156.8 / 292 ms
BetterRTP 1633 / 1606 (98.3%) 6.0 480 ms 3217 ms 4402 ms 6229 ms 6383 ms 2.5 859 / 3663 ms

(Latency percentiles over successful attempts: RTP n=16782, ezrtp n=7150, BetterRTP n=1636. TPS/MSPT from the 50 ms -heap.csv sampler, restricted to each phase's measurement window.)

Findings:

  • RTP holds a flat distribution under unthrottled dispatch. p50 1 ms / p95 2 ms / p99 46 ms at 100% success, TPS never below 17.5, MSPT max 98 ms. ~95% of teleports are served instantly from the pre-verified queue; the slowest 1% pay a single bounded async chunk load. The "p99 stays bounded as load rises" criterion held.
  • Serialized engines blow out exactly where predicted once the gap is removed. BetterRTP's foreground chunk-load + retry model collapses: p99 4.4 s, max 6.4 s, MSPT max 3.66 s, TPS to 2.5. EzRTP fares better but still tails badly: p99 322 ms, p99.9 ~1.9 s, TPS floor 10.3.
  • Contrast ratio is the headline axis. At the same offered load RTP's p95 is 2 ms while BetterRTP's is 3217 ms (~1600x) and ezrtp's is 189 ms (~95x).

Caveats:

  • Heap max is not a per-plugin metric - dropped. heap_used_mb topped out at ~16.37 GB in all three phases because that is the -Xmx ceiling, identical for every engine. A meaningful memory axis is MB/attempt or GC-trough behaviour, not max.
  • gap=0 is a throughput-ceiling condition, not the section 3 default. RTP's 18.7 TP/s here is not comparable to the 12.9 TP/s of the gap=3 run in section 5.5. The valid cross-plugin comparison is within this run.
  • cpu_ms_with_chunks* used the base chunk-load-cost-us and is relative-only (section 6 calibration note). Directly-measured columns are unaffected.

Defensible headline (shareable by Lite via the common rtp-core engine):

On Paper, RTP sustained 18.7 TP/s at 100% success (16560/16560) under unthrottled dispatch, with p50 1 ms / p95 2 ms / p99 ~2 ticks (46 ms) and TPS never below 17.5. ~95% of teleports are served instantly from a pre-verified queue; the slowest 1% is a single bounded async chunk load, never a server stall. At the same offered load BetterRTP's p95 was 3.2 s (~1600x) with TPS crashing to 2.5, and EzRTP's was 189 ms (~95x).

5.2 HuskHomes under gap=0: server crash, and the overload thesis

Dispatched under the same per-player-gap-ticks: 0 config that RTP sustained at 100%, HuskHomes' RTP path stalled the main thread and the server crashed before the phase completed, so no huskhomes phase summary was recorded.

Attribution:

  • Corroborated by prior runs. Earlier runs already showed HuskHomes degrading toward player-timeout under sustained load; its per-player serialization cannot drain unthrottled dispatch. The crash is the endpoint of a documented trend, not a one-off.
  • It is a load ceiling, not a "HuskHomes crashes servers" claim. HuskHomes handles normal /rtp traffic fine; its ceiling simply sits below the load RTP absorbs at 100%.
  • Architectural, not a bug claim. The mechanism is main-thread serialization failing to drain - the same property that produced BetterRTP's 4.4 s p99 in section 5.1, taken to its conclusion.

Operator-facing thesis:

You should not be able to crash your server by spamming a teleport command. With RTP you can't - the harness pushed as hard as it allows (per-player-gap-ticks: 0, 3 clients) and RTP held at 100% success, p95 2 ms, TPS never below 17.5. Under the same offered load, HuskHomes' RTP path stalled the main thread and crashed the server.

RTP's async chunk loads + pre-verified queue + bounded buffers make overload unreachable from the command path: at worst the queue drains and players see a brief "finding a safe location" wait, never a tick-thread stall.

Open items: re-run HuskHomes last under gap=0 so a crash never costs the other phases' data, and capture the crash artifact (crash-reports/ entry plus log tail). Confirm it is a watchdog/main-thread stall or OOM before quoting it - a NoSuchMethodError-class failure would be environmental, not a load result.

5.3 Folia - 20260617-191448 (RTP-Folia 26.1, RTP-Pro, two phases ~600 s)

The platform where Paper near-parity collapses. Same controls as section 3, 3 clients. RTP edition here is Pro (the tuned rtp-folia adapter).

Metric RTP-Pro (Folia) EzRTP (Folia) Paper ref (RTP / EzRTP, section 5.5)
Attempts 8113 3180 7755 / 6987
Throughput (per s) 13.5 5.3 12.9 / 11.6
main-thread CPU / attempt (ms) 3.96 6.34 17.97 / 19.06
total CPU / attempt (ms) 199 593 765 / 817
% chunk loads background 14% ~0% (22 of 45,814) 85% / 47%
  • EzRTP throughput halves on Folia (11.6 -> 5.3 /s) while RTP holds or improves (12.9 -> 13.5 /s). The Paper speed parity is a Paper-only artifact.
  • Folia slashes RTP's main-thread cost (17.97 -> 3.96 ms/attempt): region threads parallelize what Paper serialized onto one tick thread.
  • EzRTP does essentially zero background chunk loading on Folia (22 of 45,814), i.e. it loads chunks inline on region threads.

Server-side evidence (independent of the harness), from RTP-Folia/26.1/logs/latest.log:

  • 7 Folia watchdog stalls ("Tick region ... has not responded"), max region unresponsive time 20.39 s.
  • The stack attributes the hang to EzRTP doing a synchronous blocking chunk load on a region scheduler thread: EzRTP-3.4.0 BukkitChunkLoadStrategy.loadChunk -> org.bukkit.World.loadChunk -> ServerChunkCache.syncLoad -> BlockableEventLoop.managedBlock -> Unsafe.park.
  • No watchdog stalls attributed to RTP.

This is the S-005-class pattern manifesting as a multi-second region freeze.

Defensible headline:

On Folia under identical load, EzRTP-3.4.0 blocked region threads on synchronous World.loadChunk, tripping the Folia watchdog 7 times (one region unresponsive 20.4 s) and sustaining only 5.3 TP/s; RTP sustained 13.5 TP/s with zero watchdog stalls and a 3.96 ms main-thread cost per teleport. Harness completion-timeouts are a capture-window metric and are not used as the failure measure; the region stalls are server-emitted.

5.4 Folia Lite - 20260617-205614 (RTP-Folia 26.1, RTP-Lite, single phase ~600 s)

Same host, controls, and harness as 5.3, but the RTP jar is RTP-Lite (reported as RTP v3.1.3) and the roster is RTP-only.

Edition difference. Lite and Pro share the platform-neutral rtp-core teleport engine, but not the Folia platform path. The tuned rtp-folia adapter is Pro-only and excluded from the MIT lite jar (ADR-024 2026-06-10 amendment, ADR-061); on Folia the lite jar runs the correctness-first FoliaAwareScheduler in rtp-paper-common, routing through paper-api's regionized scheduler statics and teleporting via Entity#teleportAsync. So this run measures whether Lite's unoptimized fallback keeps pace with Pro's adapter - not "the same code".

Metric RTP-Lite (Folia) RTP-Pro ref (section 5.3)
Attempts 7507 8113
Successes 7507 (100%) 8109 (~100%, 4 capture-timeouts)
Throughput (per s) 12.5 13.5
main-thread CPU / attempt (ms) 4.15 3.96
total CPU / attempt (ms) 177 199
% chunk loads background 10.8% (19,246 / 177,911) 14%
Folia watchdog stalls 0 0 (none attributed to RTP)
TPS (avg / min) 19.8 / 16 ~20
  • Lite's unoptimized Folia path keeps pace with Pro's tuned adapter - throughput, main-thread cost, and background-chunk share are all within run-to-run noise. The shared rtp-core engine, not the Folia adapter, dominates per-teleport cost at this load, so the Folia advantage over EzRTP holds for both editions.
  • 100% success, zero watchdog stalls, under the same 3-client burst load that froze EzRTP region threads for up to 20.4 s.

What this does NOT settle. 3 clients measures per-teleport cost at light load, not the scaling ceiling. Pro's tuned adapter fans pipeline work across per-region threads and is built to pull ahead as per-region contention rises; that headroom is an architectural expectation, not a number this run demonstrates. Market the Pro Folia advantage as scaling headroom under contention, never as a measured throughput win over Lite at this load.

Additional caveats: the two latest.log lines matching "stalled" are the substring of "installed" (metrics binding log lines), not watchdog stalls. chunks_per_attempt (21.1) is the Folia attribution artifact of section 9.

Defensible headline:

RTP-Lite on Folia sustained 12.5 TP/s at 100% success with zero watchdog stalls and a 4.15 ms main-thread cost per teleport - statistically indistinguishable from RTP-Pro (13.5 TP/s, 3.96 ms) at this 3-client load, and achieved on the correctness-first FoliaAwareScheduler fallback rather than Pro's tuned adapter. The free build delivers the same Folia resilience EzRTP lacked; Pro's adapter is built to scale further under heavier contention.

5.5 Paper, gap=3 four-plugin reference - 20260617-175906

Retained only because it is the sole run containing HuskHomes as a completed phase and the background-chunk-share discriminator across four engines. Section 5.1 supersedes it for latency and throughput ranking (harsher gap=0 config).

Metric RTP EzRTP BetterRTP HuskHomes
Attempts / successes 7755 / 7755 6987 / 6987 2646 / 2639 1957 / 1950
Success rate 100% 100% 99.7% 99.6%
Throughput (per s) 12.9 11.6 4.4 3.2
chunks / attempt 1.58 3.38 5.86 4.59
% chunk loads background (async) 85% 47% 8% 1%
main-thread CPU / attempt (ms) 17.97 19.06 25.57 33.48
total CPU / attempt (ms) 765 817 1811 2589
TPS avg / min (phase) 19.37 / 15.96 15.50 / 12.82 9.99 / 7.37 19.39 / 17.85
MSPT avg / p95 / max (ms) 26.8 / 35.1 / 87.5 56.0 / 86.6 / 1259 130.4 / 185.4 / 6646 9.9 / 31.9 / 57.1
Heap growth in-phase (MB) +2676 -1379 +11633 (to ceiling) +4012
Heap post-GC trough (MB) 9948 5863 2147 5487

Two cross-cutting findings this run is kept for:

  1. The background-chunk share is the discriminator. It lines up exactly with health: RTP 85% -> EzRTP 47% -> BetterRTP 8% -> HuskHomes 1%. The more chunk work a plugin keeps on the main thread, the worse its tick tail (BetterRTP, 6.6 s max MSPT) or its throughput ceiling (HuskHomes, 3.2/s).
  2. No hard memory leak in any phase. Every phase's heap trough dropped back under GC (EzRTP net-decreased). Earlier "memory climbing" was reclaimable churn from a high allocation rate, not retention.

HuskHomes reads as slow-and-heavy but self-limiting: lowest throughput, highest per-attempt main-thread cost, ~99% foreground. Because it self-throttles at gap=3, TPS stayed healthy and MSPT smooth - it never stalls, it just cannot keep up. Remove the gap and it crashes (section 5.2).

5.6 Folia 26.1.2 6GB pinned memory-pressure run - 20260921-134507 (normalized 4,096 attempts)

The first cross-plugin benchmark run under a constrained, pinned heap (-Xms == -Xmx = 6 GB) and with a fixed quota of 4,096 attempts per arm (per-target-count: 4096). Evaluated across LeafRTP (rtp), EzRTP, and JustRTP on Folia 26.1.2 (3 clients, default dispatch pace). Includes JFR object allocation profiling (jdk.ObjectAllocationSample) to isolate per-plugin vs whole-JVM allocation.

Metric LeafRTP (rtp) EzRTP JustRTP
Attempts / successes 4,096 / 4,096 (100%) 4,096 / 4,030 (98.4%) 4,096 / 4,020 (98.1%)
Failures 0 66 (TIMEOUTs / CME) 76 (TIMEOUTs)
Wall-clock time (4k quota) 293.9 s (~4.9 min) 600.9 s (~10.0 min) 1,596.1 s (~26.6 min)
Throughput (3 clients) 13.9 TP/s 6.7 TP/s 2.5 TP/s
Process CPU / attempt (total) 182.4 ms 208.9 ms 729.0 ms
Main/Region thread CPU / attempt 7.9 ms (4.3%) 21.4 ms (10.2%) 79.6 ms (10.9%)
Async / worker CPU / attempt 174.5 ms (95.7%) 187.5 ms (89.8%) 649.4 ms (89.1%)
Chunks loaded / attempt 26.1 22.1 75.1
JFR sampled JVM allocation (total) 349.6 GB 779.7 GB (2.2x) 2,330.7 GB (6.7x)
JVM allocation / attempt 85.3 MB 190.4 MB 569.0 MB
Direct plugin package allocation (JFR) 11.14 GB (2.72 MB/tp) 8.87 GB (2.20 MB/tp) unmapped
Young GC collections (STW) 126 269 (2.1x) 770 (6.1x)
Old GC collections (STW) 2 1 4
Total GC pause time (phase) 21.7 s (7.4% wall) 47.9 s (8.0% wall) 138.8 s (8.7% wall)
Region freezes (5 s threshold) 0 0 0
Player-region TPS 5s min / mean 18.79 / 19.99 13.04 / 19.95 15.25 / 20.00
Fraction of region ticks < 19 TPS 0.03% 0.76% (25x worse) 0.11%

Findings:

  • LeafRTP completes the identical 4k workload in less than half the time of EzRTP and 1/5th the time of JustRTP with zero failures. EzRTP lost 66 teleports to timeouts and its un-synchronized MessageProvider ConcurrentModificationException; JustRTP timed out 76 times.
  • 95.7% of LeafRTP's CPU execution is off-tick: only 7.9 ms per teleport touches the owning region thread. EzRTP requires 2.7x more on-tick CPU (21.4 ms), and JustRTP requires 10x more (79.6 ms).
  • Allocation efficiency directly drives GC interruption rate. On 6 GB heap, LeafRTP's lower per-teleport churn (85.3 MB/attempt vs 190.4 MB for EzRTP and 569.0 MB for JustRTP) triggered only 126 young GCs across 4,096 teleports vs 269 for EzRTP and 770 for JustRTP.
  • Server pause overhead is drastically reduced: across the 4,096 teleports, LeafRTP cost the server only 21.7 s of total stop-the-world GC pause time, compared to 47.9 s for EzRTP and 138.8 s (over 2.3 minutes) for JustRTP.
  • Player-region TPS floor stayed solid: LeafRTP's 5s minimum TPS remained at 18.79 (only 0.03% of samples below target), whereas EzRTP dropped to 13.04 (0.76% below target).

5.7 Paper 26.2 unthrottled dispatch - 20261008-003310 (Test A: 6-plugin 4,096-teleport saturation run)

The definitive multi-plugin saturation benchmark on Paper 26.2 (AMD Ryzen 9 3900X, 16 GB heap). 3 OPed clients, concurrency 4, unpaced dispatch (immediate-redispatch: true, dispatch-interval-ms: 0, per-player-gap-ticks: 0). Outer radius equalized across all contenders to 16,384 blocks with a 1,024-block void around spawn. EzRTP was evaluated with biome validation active (plugins/EzRTP/rtp.yml), resolving the candidate-skipping anomaly from earlier runs.

Metric LeafRTP JakesRTP BetterRTP HuskHomes EzRTP JustRTP
Attempts / Successes 4,096 / 4,096 (100 %) 4,096 / 4,096 (100 %) 4,096 / 4,096 (100 %) 4,096 / 4,096 (100 %) 4,096 / 4,096 (100 %) 4,088 / 4,096 (99.8 %)
Failures 0 0 0 0 0 8 (TIMEOUTs)
Wall-clock time (4k quota) 97.2 s (1.6 min) 176.5 s (2.9 min) 444.2 s (7.4 min) 489.3 s (8.2 min) 517.7 s (8.6 min) 923.8 s (15.4 min)
Throughput 42.15 TP/s 23.20 TP/s 9.22 TP/s 8.37 TP/s 7.91 TP/s 4.43 TP/s
Latency cold / p50 7.0 ms / 5.0 ms 1.0 ms / 21.0 ms 135 ms / 223.0 ms 212 ms / 258.0 ms 184 ms / 240.0 ms 263 ms / 418.0 ms
Latency p95 / p99 7.0 ms / 9.0 ms 73.0 ms / 114.0 ms 628.0 ms / 1,013.0 ms 411.0 ms / 748.0 ms 748.0 ms / 1,125.0 ms 1,724.0 ms / 2,721.0 ms
Fast mode served fraction 99.97 % 0.0 % 0.0 % 0.0 % 0.0 % 0.0 %
Chunks loaded / att (attributed) 0.18 7.14 24.96 31.66 30.94 89.53
Chunks loaded / att (inclusive) 2.92 8.46 26.06 32.22 32.07 91.79
Main-thread CPU / attempt 9.92 ms 13.17 ms 24.86 ms 30.72 ms 34.35 ms 82.79 ms
Process CPU / attempt (total) 77.16 ms 74.77 ms 197.80 ms 226.54 ms 240.56 ms 530.12 ms
Min TPS (Mean TPS) 16.19 (17.82) 12.14 (15.02) 13.23 (19.16) 19.92 (20.00) 18.01 (19.57) 19.83 (19.99)
MSPT p50 / p99 56.4 ms / 80.6 ms 61.8 ms / 104.8 ms 23.4 ms / 120.2 ms 12.7 ms / 17.8 ms 23.3 ms / 88.3 ms 16.8 ms / 26.9 ms
Peak Heap MB 16,296 MB 14,511 MB 15,003 MB 14,339 MB 14,157 MB 13,459 MB
Exact duplicate landings 0 (0.0 %) 0 (0.0 %) 2 (0.05 %) 0 (0.0 %) 0 (0.0 %) 0 (0.0 %)
Near pairs (<= 48 blocks) 0 (random: 82) 108 (random: 82) 123 (random: 78) 136 (random: 85) 153 (random: 125) 115 (random: 78)
Clark-Evans R (spacing) 0.977 (uniform) 0.919 0.906 0.907 0.914 0.897 (clustered)
Landing safety audit 99.5 % safe (547/550) 78.8 % safe (730 noFloor) 99.7 % safe (6 hazard) 98.7 % safe (32 noFloor) 87.9 % safe (441 water) 100.0 % safe (8/8)

Findings:

  1. Resolution of the EzRTP biome discrepancy: In the earlier run without biome filtering (20261006-135938), EzRTP skipped candidate placement checks, reporting artificial throughput of 29.47 TP/s with only 13.0 chunks/att. With biome checks active in plugins/EzRTP/rtp.yml, throughput normalized to 7.91 TP/s with 30.94 chunks/att and 34.35 ms main CPU, perfectly matching the search cost profile of un-indexed candidate discovery. However, 441 of its landings still occurred on water surfaces due to lenient surface checks.
  2. Instant queue clearance under saturation: LeafRTP cleared the full 4,096 teleports in 97.2 seconds (42.15 TP/s) with a median latency of 5.0 ms and p99 of 9.0 ms, driven by a 99.97% pre-warmed queue hit rate. It loaded only 0.18 attributed candidate chunks per attempt (2.92 inclusive chunks).
  3. Tick degradation under unconstrained search (JakesRTP): JakesRTP achieved the second highest throughput (23.20 TP/s), but heavily loaded the main tick thread, driving mean TPS down to 15.02 (min 12.14) and MSPT p99 to 104.8 ms. Furthermore, 730 landings lacked ground blocks (noFloor), dropping safe landing percentage to 78.8%.
  4. Search timeouts and tail latency (JustRTP): JustRTP required 89.53 chunks and 82.79 ms main CPU per attempt, resulting in 8 failed attempts and a p99 latency of 2,721 ms (max 4,751 ms), showing that un-indexed cache replenishment under strict biome rules experiences candidate timeout.
  5. Tick preservation through throttling (HuskHomes): HuskHomes maintained near-perfect tick stability (20.00 avg TPS, 17.8 ms MSPT p99) by evaluating candidates synchronously at a modest 8.37 TP/s (258 ms median latency).
  6. Mathematical spatial uniformity: LeafRTP achieved 0 exact duplicate landings and 0 pairs within 48 blocks (Clark-Evans R = 0.977, nearest pair 75.2 blocks), while competitors produced between 108 and 153 closely adjacent pairs.

5.8 Paper 26.2 paced dispatch at 5 TP/s - 20261008-024412 (Test B: 6-plugin 4,096-teleport steady-state run)

Same server, world, radius, clients and plugin configs as section 5.7. Dispatch paced at one /rtp every 200 ms (immediate-redispatch: false, dispatch-interval-ms: 200, per-player-gap-ticks: 4), 180 s settle gap, spark profiling on for every phase (rotate-seconds: 0, so one profile per phase and the same profiler overhead for every plugin). Phase order: LeafRTP, BetterRTP, EzRTP, JustRTP, JakesRTP, HuskHomes. Supersedes the earlier Test B attempt 20261008-020859.

Achieved rate is attempts / phase wall time. Five plugins held 4.50-4.63 TP/s against the 5.0 TP/s dispatch target; JustRTP fell behind at 3.84 TP/s, so its phase ran 1,065.6 s against 884.6-909.5 s for the others. Latency percentiles are over all 4,096 attempts per plugin; MSPT and TPS come from the 50 ms -heap.csv sampler restricted to each phase window.

Metric LeafRTP JakesRTP BetterRTP HuskHomes EzRTP JustRTP
Attempts / Successes 4,096 / 4,096 (100 %) 4,096 / 4,096 (100 %) 4,096 / 4,096 (100 %) 4,096 / 4,096 (100 %) 4,096 / 4,096 (100 %) 4,094 / 4,096 (99.95 %, 2 TIMEOUTs)
Phase wall time 884.6 s 897.6 s 909.5 s 895.1 s 899.2 s 1,065.6 s
Achieved rate 4.63 TP/s 4.56 TP/s 4.50 TP/s 4.58 TP/s 4.55 TP/s 3.84 TP/s
Latency p50 / p99 / max 6 ms / 14 ms / 34 ms 0 ms / 76 ms / 710 ms 203 ms / 898 ms / 2,151 ms 264 ms / 626 ms / 3,995 ms 171 ms / 923 ms / 1,649 ms 345 ms / 2,729 ms / 5,000 ms
Chunks loaded / att (attributed / inclusive) 9.44 / 58.87 3.88 / 64.58 27.89 / 64.25 38.63 / 62.48 25.17 / 63.48 89.42 / 102.46
Main-thread CPU / attempt 55.49 ms 69.50 ms 60.42 ms 72.83 ms 63.74 ms 96.42 ms
Process CPU / attempt (total) 537.1 ms 581.6 ms 566.4 ms 585.7 ms 555.6 ms 751.2 ms
MSPT p50 / p99 / max 16.4 / 22.6 / 24.5 ms 28.8 / 54.5 / 92.1 ms 27.9 / 54.6 / 166.6 ms 21.1 / 32.3 / 37.8 ms 25.7 / 42.8 / 49.4 ms 23.4 / 34.3 / 36.3 ms
Ticks > 50 ms 0 / 17,692 271 / 17,846 (1.52 %) 329 / 17,992 (1.83 %) 0 / 17,901 0 / 17,964 0 / 21,314
Min TPS (Mean TPS) 19.89 (20.00) 18.55 (19.88) 16.86 (19.80) 19.90 (20.00) 19.70 (19.98) 19.92 (20.00)
Settle-gap MSPT p50 -> phase MSPT p50 12.2 -> 16.4 ms (+4.3) 13.3 -> 28.8 ms (+15.5) 10.8 -> 27.9 ms (+17.1) 17.6 -> 21.1 ms (+3.4) 12.6 -> 25.7 ms (+13.1) 12.9 -> 23.4 ms (+10.5)
GC pause total (collections) 7.9 s (118) 8.1 s (132) 7.5 s (115) 7.9 s (129) 7.5 s (134) 10.0 s (170)
Exact duplicate landings 0 0 0 0 0 0
Near pairs (<= 48 blocks) 0 (random: 81) 127 (random: 84) 126 (random: 84) 105 (random: 82) 142 (random: 129) 129 (random: 85)
Nearest pair 70.0 blocks 4.5 blocks 2.2 blocks 2.2 blocks 4.1 blocks 4.0 blocks
Chunks reused 0 2 7 5 3 7
Clark-Evans R (land-adjusted) 0.978 0.897 0.899 0.920 0.917 0.901
Landing safety audit 99.7 % safe (4,083 / 4,096; 6 noFloor, 5 water, 2 blocked) 77.2 % safe (186 / 241; 55 noFloor) 99.7 % safe (4,082 / 4,096; 12 hazard, 2 noFloor) 98.9 % safe (2,275 / 2,301; 26 noFloor) 88.5 % safe (3,625 / 4,096; 424 water, 37 blocked, 10 hazard) 100.0 % safe (8 / 8 checked)

Spatial columns use successful landings only. The "random" figure is the near-pair count of a random scatter with the plugin's own landing intensity per (terrain class, equal-area ring) cell, from CrossPluginDestinationScatterVisualizerTest; it absorbs water and biome rejection and each plugin's radial profile, so it is the land-adjusted expectation, not a uniform disc. EzRTP's baseline is the highest because its landings concentrate into the smallest effective area (450 km² against 698-725 km² for the others). Chunks reused counts floor(block / 16) collisions.

Findings:

  1. Latency at equal offered rate. LeafRTP answered at p50 6 ms / p99 14 ms / max 34 ms from its pre-verified queue. The plugins that search per command took p50 171-345 ms and p99 626-2,729 ms. JakesRTP answered most commands without a live search (p50 0 ms) but its tail reached p99 76 ms and max 710 ms.
  2. Tick cost at equal work. LeafRTP had the lowest MSPT at p50, p99 and max of all six (16.4 / 22.6 / 24.5 ms) and no tick over 50 ms. BetterRTP (329 ticks over 50 ms, max 166.6 ms, min TPS 16.86) and JakesRTP (271 ticks over 50 ms, max 92.1 ms, min TPS 18.55) stalled ticks at 5 TP/s. JakesRTP's low attributed chunk count (3.88) did not make it cheap per tick: its MSPT p50 of 28.8 ms was the highest of the six.
  3. Settle-gap delta. Against the median MSPT of the last 120 s before each phase, LeafRTP added 4.3 ms and HuskHomes 3.4 ms; the other four added 10.5-17.1 ms. HuskHomes' baseline (17.6 ms) was measured straight after the JakesRTP phase and sits 4-7 ms above the other five baselines (10.8-13.3 ms), so its delta is taken from a raised floor. The absolute phase MSPT columns above do not depend on the baseline.
  4. CPU per teleport. LeafRTP had the lowest main-thread CPU (55.49 ms) and process CPU (537.1 ms) per attempt. Both include the server's own tick work over the phase, which is near-equal across phases because wall time is near-equal; JustRTP's 96.42 / 751.2 ms also carries its 20 % longer phase.
  5. Chunks. LeafRTP loaded the fewest chunks per attempt inclusive of the landing area (58.87 against 62.48-102.46). Its attributed count rose from 0.18 in Test A to 9.44 here, above JakesRTP's 3.88. The 885 s phase spans background refill cycles of the pre-verified queue (backlogRefillThreshold 0.5 hysteresis) that the 97 s Test A phase mostly did not; the per-cause split of the 9.44 is not broken out yet.
  6. Spacing. LeafRTP: 0 pairs within 48 blocks against 81 expected at random over the land it used, nearest pair 70.0 blocks, no chunk reused. Each other plugin landed more close pairs than its own random baseline (105-142 against 82-129), with nearest pairs of 2.2-4.5 blocks and 2-7 reused chunks. This is the count that decides how few rolls it takes to land on someone else's arrival point; mean nearest-neighbour distance moves far less.
  7. JustRTP could not hold the pace. At 89.42 attributed chunks and 96.42 ms main-thread CPU per attempt it averaged 3.84 TP/s and timed out twice. Correction to working notes: the "1 exact duplicate, nearest pair 0.0 blocks" figure for this phase came from counting those 2 failed attempts, which the harness records at the (0, 0) placeholder. Over its 4,094 landings JustRTP had 0 duplicates and a 4.0-block nearest pair.

5.9 Folia 26.2 paced dispatch at 5 TP/s - 20261008-052141 (Test B: 4-plugin 4,096-teleport steady-state run)

Executed on Folia 26.2 (16 GB heap, Ryzen 9 3900X) on the exact same world seed, radius (1,024 to 16,384 blocks), 3 OPed clients, and paced harness settings (dispatch-interval-ms: 200, per-player-gap-ticks: 4, sequence.gap-seconds: 180, sequence.per-target-seconds: 1800, spark rotate-seconds: 0) as Paper Test B (section 5.8). JakesRTP was excluded (does not declare Folia support in plugin.yml).

Contender fate on Folia: - BetterRTP: Pruned during 30 s warm-up after 6 of 6 attempts threw IllegalStateException: Thread failed main thread check: Cannot retrieve chunk asynchronously, context=[thread=Folia Region Scheduler Thread, region={null}]. - EzRTP: Suffered an unhandled TickThread Cannot retrieve chunk asynchronously in getHighestBlockYAt on regional threads. Because EzRTP only invokes its completion callback on normal execution, the exception permanently locked out 2 of 3 player accounts into infinite "active attempt" states. The phase reached the 1,800 s cap at only 1,415 successful teleports and 949 consecutive 5 s timeouts. - JustRTP: Saturated Folia's asynchronous worker queues with unindexed random candidate chunk loading (136.6 attributed chunks/att). Could not sustain 5.0 TP/s, averaging 2.25 TP/s, and timed out at 1,800 s after completing 4,056 attempts. Caused 5.17 % of regional 5-second TPS samples to drop below 20 TPS. - HuskHomes & LeafRTP: Both completed cleanly at full pace (4.63 TP/s and 4.83 TP/s).

Metric LeafRTP HuskHomes JustRTP EzRTP
Attempts / Successes 4,096 / 4,096 (100 %) 4,095 / 4,096 (99.98 %, 1 timeout) 4,056 / 4,087 (99.24 %, 31 timeouts) 1,415 / 2,364 (59.86 %, 949 timeouts)
Phase wall time 848.8 s 884.7 s 1,800.3 s (capped) 1,804.8 s (capped)
Achieved rate 4.83 TP/s 4.63 TP/s 2.25 TP/s 0.78 TP/s
Latency p50 / p95 / p99 / max 137 ms / 203 ms / 206 ms / 399 ms 404 ms / 785 ms / 1,065 ms / 4,928 ms 901 ms / 3,050 ms / 4,746 ms / 5,004 ms 455 ms / 4,995 ms / 5,010 ms / 5,151 ms
Latency p50 / p95 (successful only) 137 ms / 203 ms 404 ms / 785 ms 900 ms / 2,905 ms 303 ms / 605 ms
Chunks loaded / att (attributed / inclusive) 32.40 / 69.27 36.08 / 42.40 136.62 / 138.47 23.87 / 25.28
Region-thread CPU / attempt 60.38 ms 109.31 ms 287.32 ms 291.03 ms
Process CPU / attempt (total) 368.36 ms 407.94 ms 1,149.74 ms 580.37 ms
Regional TPS 5s min / mean 8.52 / 19.89 15.85 / 19.97 6.33 / 19.81 6.09 / 19.98
Regional ticks < 20 TPS % 0.88 % 0.63 % 5.17 % 0.32 % (mostly idle)
GC pause total (collections) 7.3 s (102) 6.5 s (159) 16.8 s (301) 1.6 s (89)
Exact duplicate landings 1 (0 in live) 0 0 0
Near pairs (<= 48 blocks) 16 (0 in live) (random: 81) 108 (random: 82) 96 (random: 84) 15 (random: 12)
Nearest pair 50.8 blocks (live) 4.5 blocks 1.4 blocks 14.3 blocks
Chunks reused 1 (0 in live) 5 7 0
Clark-Evans R 0.937 0.893 0.890 inf
Landing safety audit 99.9 % safe (4,093 safe, 2 noFloor, 1 suffocating, 0 water) 98.9 % safe (4,049 safe, 46 noFloor, 0 water) 99.7 % safe (4,044 safe, 12 hazard, 0 water) 87.8 % safe (1,242 safe, 154 water, 17 suffocating, 2 hazard)

Findings:

  1. LeafRTP CPU efficiency scales on Folia. Gross process CPU per attempt dropped 31.5 % compared to Paper Test B (368.4 ms vs 537.1 ms). LeafRTP’s Anvil region prefilter and Hilbert selection do zero synchronous work on region threads, enabling Folia's threaded regions to tick with minimal contention.
  2. The Folia latency floor. On Paper, LeafRTP's median latency was 6 ms. On Folia, it rose to 137 ms. This ~100-150 ms transition is the intrinsic scheduling cost of Folia's regional entity transfer between the originating and destination region threads across tick boundaries.
  3. JustRTP computational explosion. JustRTP required 136.62 attributed chunk loads and 1,149.74 ms process CPU per attempt (+53 % vs Paper). Its lack of spatial indexing caused heavy thread context switching and worker queue saturation on Folia, degrading regional TPS (5.17 % samples below 20 TPS).
  4. EzRTP regional thread violation and account lockout. EzRTP calls getHighestBlockYAt on coordinates outside the current region's bounds. Folia throws IllegalStateException: Thread failed main thread check: Cannot retrieve chunk asynchronously. EzRTP fails to clear its activeAttempt state on exception, rendering that player permanently incapable of using /rtp until a plugin restart.
  5. Persistent EzRTP water landings. EzRTP placed players on water surfaces in 10.9 % of all successful teleports (154 landings), matching the ~10.4-10.8 % water rate seen across Paper Test A and Test B.

5.10 Paper 26.2 Linux open-loop ramp - 2026-10-09 overnight (Test C, partial)

First open-loop stress-point data (method in section 8.1). Rig: AMD Threadripper 7970X, NVMe, Ubuntu 24.04, Paper 26.2, OpenJDK 25, -Xmx16G, default G1. Roster: 48 offline-mode Mineflayer bots (devstack/clients/bench-swarm.js) on a separate Windows machine over the network, non-op, granted each plugin's use node plus its queue/cooldown/delay bypass (rtp.unqueued for LeafRTP, ezrtp.forcertp + ezrtp.queue.bypass for EzRTP). Server view-distance=4, simulation-distance=2, and the harness caps each bot's server-side view and simulation distance to 2 during a ramp (ramp.player-view-distance), so every plugin pays the same landing-area load. Broadcast message and per-teleport success logging off, spark off. Stage 120 s for the flat 100 TP/s runs and 60 s per ladder stage, 30 s unrecorded warm-up, 5 s attempt timeout. EzRTP config is the same 1,024-16,384 block circle as sections 5.7-5.9; LeafRTP's region file was carried over from the same setup but was not re-read for this write-up.

Validity. The overnight driver (scripts/bench_overnight.py) ran 39 ramps. Only 5 measured the intended plugin. The driver isolated each target by renaming the other RTP jars while the server was down, but the new JVM had already scanned plugins/ by then, so each session loaded the previous target's jar set. Server logs confirm the loaded set per session; every ramp listed below ran with its target enabled. The other 34 rows (BetterRTP, HuskHomes, justRTP, JakesRTP, and LeafRTP/EzRTP ramps that ran in the wrong session) are 0-success rows against a server without that plugin and are discarded, not counted as failures. Fix for the next run: rename the jars before sending restart.

Run Plugins loaded Target Offered Achieved Successes / attempts Timeouts Harness shed Latency p50 / p95 / p99 MSPT p50 / p95 TPS min Heap peak Verdict
20261009-044336 all six LeafRTP 100 96.2 TP/s 11,548 / 11,548 0 446 129 / 701 / 967 ms 69.4 / 121.8 ms 7.3 16,226 MB FAIL MSPT_P95
20261009-054148 LeafRTP only LeafRTP 100 98.7 TP/s 11,843 / 11,843 0 154 63 / 547 / 778 ms 50.0 / 103.3 ms 8.6 16,351 MB FAIL MSPT_P95
20261009-070736 LeafRTP only LeafRTP 100 97.7 TP/s 11,722 / 11,722 0 272 86 / 662 / 948 ms 93.2 / 111.1 ms 7.5 16,266 MB FAIL MSPT_P95
20261009-051201 EzRTP only EzRTP 5 4.98 TP/s 299 / 299 0 0 156 / 505 / 908 ms 22.5 / 23.7 ms 20.0 12,997 MB PASS
10 7.15 TP/s 429 / 599 170 (28.4 %) 0 2,710 / 4,059 / 4,813 ms 24.9 / 26.4 ms 19.9 13,331 MB FAIL achieved, failure rate
20 8.18 TP/s 491 / 788 297 (37.7 %) 411 3,505 / 3,651 / 4,415 ms 25.3 / 29.2 ms 16.6 13,046 MB FAIL achieved, failure rate, HARNESS_SATURATED
20261009-063819 EzRTP only EzRTP 5 4.98 TP/s 299 / 299 0 0 155 / 607 / 918 ms 22.1 / 23.3 ms 20.0 13,364 MB PASS
10 7.72 TP/s 463 / 599 136 (22.7 %) 0 2,261 / 4,109 / 4,809 ms 25.5 / 27.4 ms 20.0 13,276 MB FAIL achieved, failure rate
20 8.30 TP/s 498 / 788 290 (36.8 %) 411 3,505 / 3,558 / 4,357 ms 25.5 / 29.3 ms 19.9 13,169 MB FAIL achieved, failure rate, HARNESS_SATURATED

Offered and achieved are TP/s. Achieved = successful teleports / stage seconds. Latency is dispatch to arrival over completed attempts. No errors and no console-visible busy rejections were recorded in any row.

Findings:

  1. LeafRTP at 100 TP/s offered: 35,113 of 35,113 teleports succeeded across three 2-minute runs, and the server stayed up. Achieved 96.2-98.7 TP/s (all above the 95 % line); the stages failed only the MSPT p95 <= 50 ms criterion (103-122 ms), with TPS dipping to 7.3-8.6. So the tick budget ran out before LeafRTP's pipeline did. 100 TP/s is past LeafRTP's stress point on this rig; no valid LeafRTP ladder ran, so where between 5 and 100 TP/s the 50 ms line sits is not measured. The run with all six plugins loaded (044336) carried the other plugins' background work (EzRTP's biome cache warm-up and pre-cache among it) and was the slowest of the three.
  2. LeafRTP latency at 100 TP/s is mostly queueing outside the pipeline. 154-446 dispatch slots per run found no idle bot (48-bot roster), and every command waits for a tick that takes ~100 ms. A 16-bot ramp on the same rig earlier that night measured LeafRTP's own dispatch-to-teleport time at p50 3 ms / p95 5 ms in its 100 TP/s stage, with the rest spent before the command reached LeafRTP; that run was stopped by hand and is not tabulated.
  3. LeafRTP cost at 100 TP/s (054148): 7.7 ms main-thread CPU and 94 ms process CPU per teleport; chunk-system threads used 588 s CPU against 91 s on the main thread; ~8.9 chunks loaded per teleport (landing area included); GC time 5.9 % of wall. No idle baseline was recorded (see below), so these are gross, not net.
  4. EzRTP stress point: 5 TP/s, reproduced in both runs. Asked for 10 and 20 TP/s it completed 7.2-8.3 TP/s, timed out 23-38 % of attempts, and its p50 latency rose to 2.3-3.5 s, while MSPT p95 stayed at 26-29 ms. Its limit is its own pipeline, not server load. This matches its 7.91 TP/s closed-loop ceiling on the 3900X (section 5.7). The 20 TP/s stages are also HARNESS_SATURATED (all 48 bots waiting on slow attempts), which does not change the verdict since the 10 TP/s stage had already failed with no shed slots.
  5. Heap reached the 16 GB ceiling in all three LeafRTP runs (16.2-16.4 GB peak) and stayed near 13 GB for EzRTP's lower rates. Peak heap is the -Xmx ceiling under G1 (caveat 11), but whether this is retention at 100 TP/s or G1 deferring collection has not been separated; check post-GC troughs before claiming either.

Gaps in this run's data (backfill later):

  • net_* / idle_* columns are empty: the ramp idle baseline did not record on the server (deployed jar or config predates it, or the window was not saved). Costs above are gross.
  • Sync-load attribution self-test reported FAIL_TICKET, so chunks_sync_* is -1. That result is a finding about the server (ticket promotion counted as a blocking load), not a broken self-test, but it leaves the column empty.
  • EzRTP's timeouts were not cross-checked against the swarm's busy_chat count. A player-only busy reply would surface as a timeout (section 8.1 known limit).
  • n=3 for LeafRTP (one with every plugin loaded) and n=2 for EzRTP. BetterRTP, HuskHomes, justRTP and JakesRTP have no valid Test C result.

6. Recorded test parameters

Captured verbatim from each server's plugins/StressTestRTP/config.yml so the runs are reproducible. The runs share identical harness settings; they differ only in target roster, RTP edition (Pro vs Lite), host platform, and per-player-gap-ticks.

Parameter Value
dispatch-as-player true
roster all
attempt-timeout-ms 5000 (capture window; see section 9)
console-fail-enabled true
console-fail-patterns [] (empty -> built-in defaults; source of the warm-up false-failure warning)
save-worlds-between-phases auto
default-concurrency 4
per-player-gap-ticks 3, or 0 for section 5.1 / 5.2
default-burst 10
no-progress-kickstart-ms 30000
sequence.per-target-seconds 600
sequence.gap-seconds 240
sequence.warmup-seconds 30
sequence.warmup-target-cycles 1
sample-period-ms 50
chunk-load-cost-us (base, used) 28221.0 (Spigot default)
chunk-load-cost-us-paper / -folia 1830.0 each (present but NOT applied)
spark enabled, profile-per-phase, timeout 660 s, only-ticks-over-ms 0, rotate 60 s
Paper 20260617-175906 Folia 20260617-191448 Folia Lite 20260617-205614 Paper gap=0 20260617-232754
Host RTP-Paper / 26.2 RTP-Folia / 26.1 RTP-Folia / 26.1 RTP-Paper / 26.1
RTP edition Pro Pro Lite Pro
Targets (in order) rtp, betterrtp, huskhomes, ezrtp rtp, ezrtp rtp rtp, ezrtp, betterrtp
Phases recorded 4 2 1 3

Target commands: rtp:rtp, betterrtp:betterrtp, huskhomes:rtp, ezrtp:forcertp {player} world. The EzRTP dispatch uses the force variant so its cooldown/limit gating is bypassed; the others use their plain /rtp-equivalent.

Namespaced-command hazard. When two plugins register /rtp, Bukkit's command map keeps one PluginCommand per label, so <plugin>:rtp can resolve to the wrong plugin. Verify each arm with /<plugin>:rtp <TAB> before trusting a row, and prefer a plugin-unique command (forcertp, betterrtp) where one exists. A whole prior run set was invalidated by this.

Calibration note. Despite chunk-load-cost-us-paper / -folia being set, StressTestRTPPlugin.beginRun() reads only the base chunk-load-cost-us (28221.0, the Spigot default), confirmed by the server log line chunk-load-cost-us=28221.00 amending phase CPU. Every cpu_ms_with_chunks* figure above is therefore relative-only / overstated. All directly-measured columns (throughput, main-thread CPU, TPS, success, watchdog stalls) are unaffected. Set the base key per platform before quoting any absolute.


7. Version-independent plugin findings

Structural findings that do not depend on a particular benchmark run, so they survive competitor releases. Anything version-pinned belongs in section 5.

RTP

  • Cold-start carries no first-attempt penalty: the pre-warmed keptLocations queue serves the first /rtp of a phase as fast as the thousandth.
  • Bounded p99 is the direct payoff of the count-bound pipeline (ADR-015).
  • Unit convention verification: In config.yml, radius: 16384b explicitly uses the b suffix for blocks, while centerRadius: 64 defaults to chunks (64 chunks * 16 blocks/chunk = 1,024 blocks). This confirms that LeafRTP operates on the exact 1,024 to 16,384 block boundary, maintaining 1:1 parity with all competitor configs without discrepancy.
  • No entry TTL by default. Queue entries are invalidated by events (served, config change, spatial-memory rejection), not by a clock, so in a claim-free and edit-free world effective entry lifetime is "until served". Prior lifecycle measurement is the basis for that claim; re-confirm it at the raised radius rather than assuming it scales. The trade this buys and the trade it costs are in section 4 Entry-lifetime classes: hit rate does not decay with idle time, and the bill arrives as retention plus a staleness obligation (verification happens on serve, so an aged coordinate is re-checked, not trusted).
  • The anvil prefilter reads .mca NBT off-thread and needs no Folia region, materializing a live chunk only for candidates that survive the off-thread screen. This is the structural Folia advantage; on pregenerated Paper it is invisible, which is why Paper speed parity misleads.

BetterRTP

  • Config edits revert on shutdown. Verify the radius actually took effect via the destination scatter, or attrib +R the file after editing.
  • Radius calculation bug (RandomLocation.generateRound()): Decompilation of me.SuperRonanCraft.BetterRTP.references.rtpinfo.RandomLocation.generateRound() reveals an arithmetic bug in its annulus boundary calculation:
    int minRadius = rtpWorld.getMinRadius();
    int maxRadius = rtpWorld.getMaxRadius();
    int delta = maxRadius - minRadius;
    // Factoring error: substitutes delta instead of maxRadius into the area formula:
    double d5 = Math.PI * (delta - minRadius) * (delta + minRadius);
    double rand = d5 * random.nextDouble();
    double r = Math.sqrt(rand / Math.PI + (minRadius * minRadius));
    
    Substituting delta = maxRadius - minRadius reduces the area factor to: d5 = PI * (max - 2*min) * max. When random.nextDouble() approaches 1.0, the maximum distance evaluates to: R_effective = sqrt((max - 2*min)*max + min^2) = maxRadius - minRadius. Because BetterRTP unintentionally subtracts minRadius from its outer reach, configuring MaxRadius: 16384 with MinRadius: 1024 only searches up to 15,360 blocks (a 1,024-block truncation). Setting MaxRadius: 17408 is the mathematically necessary compensation to achieve the intended 16,384-block outer perimeter (17408 - 1024 = 16384).
  • Radial striping and spiral banding: BetterRTP calculates its angle as theta = 2 * Math.PI * (r - Math.floor(r)). Because the angle is coupled directly to the fractional remainder of the distance rather than an independent uniform random angle, candidate destinations cluster into distinct spiral stripes and radial bands visible in scatter plots.
  • MaxAttempts: 32 retry loop: failures surface as long latency on the one successful retry, not as failure rows.
  • Has a Queue.Enabled pre-warm; serialises per-player ("already rtp'ing" rejections are caught by ConsoleWatcher).
  • Folia main-thread chunk-load violation (2026-06-17, Folia 26.1.2-8). TickThread logged Thread failed main thread check: Async chunk retrieval on Folia Region Scheduler Thread #2 during the Global Region tick. Stack: BetterRTP's bundled PaperLib (me.SuperRonanCraft.BetterRTP.lib.paperlib) AsyncChunksSync.getChunkAtAsync -> CraftWorld.getChunkAt, dispatched from QueueGenerator.lambda$addQueue$4 via AsyncHandler.sync. The shaded PaperLib falls back to the synchronous implementation, then calls getChunkAt from a thread that does not own the chunk. Its queue pre-fill is therefore partially broken on Folia 26.1.x, inflating cold/warm latency and abort rate. Disclose in any Folia 26.1.x head-to-head including BetterRTP.

HuskHomes

  • Serialises per-player and uses a normal-distribution placement biased toward the outer radius - clashes with sustained dispatch. Not a bug; HuskHomes' /rtp is a secondary feature of a cross-server homes plugin.
  • No centre config - pinned to /spawn, so it cannot be moved off a configurable plugin's cell. Sequence spawn-anchored plugins apart.
  • Folia main-thread chunk-load violation (same date/platform, same root cause, different thread class): repeated TickThread errors on Folia Async Scheduler Threads, stack NormalDistributionEngine.generateSafeLocation -> BukkitSavePositionProvider.findSafeGroundLocation -> shaded PaperLib (net.william278.huskhomes.libraries.paperlib) AsyncChunksSync -> CraftWorld.getChunkAt. Both plugins ship the same vendored PaperLib, so this is a common PaperLib-on-Folia-26.1.x failure, not a coincidence. Consequence: HuskHomes' safety check cannot reliably read the destination chunk on Folia 26.1.x.

EzRTP

  • Ships a 5 s countdown by default; disable it or the measurement is UX padding.
  • Genuinely async-looking on Paper (~47% background chunk loads) but does essentially zero background loading on Folia, loading inline on region threads - the section 5.3 watchdog stalls.
  • Folia main-thread violation, but via getHighestBlockYAt, not PaperLib (observed 2026-09-21, Folia 26.1.2). EzRTP's own BukkitPlatformWorldAccess.getSurfaceY calls the synchronous CraftWorld.getHighestBlockYAt from a Folia Region Scheduler Thread for a chunk owned by a different region, so TickThread.ensureTickThread throws IllegalStateException and the /rtp dispatch fails outright with a Bukkit CommandException (stack: LocationFinder.surfaceY -> generateCandidateLocationAsync -> attemptFindLocation -> findSafeLocationAsync -> TeleportExecutor.performTeleport). Distinct root cause from the BetterRTP/HuskHomes vendored-PaperLib AsyncChunksSync -> CraftWorld.getChunkAt failure - EzRTP loads no PaperLib - but the same class of bug: a live block-height query issued off the owning region thread. On Folia this is a hard per-attempt failure, not just a stall, and corroborates the section 5.3 "inline on region threads" note above. Reproduced unchanged on EzRTP 3.4.3 / Folia 26.2 (run 20261008-052141, 2026-10-08): same stack, chunk_pos=[9, 111] requested from the region centred at [145, -584].
  • Non-thread-safe message formatting and database cache (ConcurrentModificationException) (observed 2026-09-21 and 2026-09-22, Folia 26.1.2, runs 20260921-025943 and 20260922-132724). Under concurrent /rtp dispatch EzRTP's MessageProvider.format mutated a shared HashMap via computeIfAbsent across region threads. Furthermore, during run 20260922-132724, EzRTP threw ConcurrentModificationException in me.nik.ezrtp.storage.Database.checkCache (LinkedHashMap$LinkedHashIterator.nextNode), followed by NullPointerException in me.nik.ezrtp.manager.CooldownManager.lambda$sendCooldownMessage$0.
  • Permanent player command lock-out on unhandled task exception (observed 2026-09-22, Folia 26.1.2). When teleport() crashes from an unhandled exception (ConcurrentModificationException in Database.checkCache), EzRTP aborts before reaching its in-flight cleanup routine. The player's UUID remains permanently trapped in EzRTP's internal inTeleport / queue set. Subsequent /rtp commands from that specific player are silently dropped (inTeleport.contains(uuid) == true), making EzRTP completely unresponsive to that account while remaining responsive to others. Under sustained multi-account dispatch this defect cascaded across accounts, locking out 2 of the 3 test players consecutively without recovering. Contrasts with LeafRTP's S-004 fail-safe completion guarantees (CompletableFuture.whenComplete in MemoryTracker), which ensure player state cleanup on all exit paths. Third reproduction, EzRTP 3.4.3 / Folia 26.2 (run 20261008-052141, Test B paced at 200 ms, 2026-10-08). Trigger this time is the getHighestBlockYAt main-thread violation above, not the ConcurrentModificationException, so any unhandled exception inside /rtp locks the account. TeleportExecutor adds the player to an active-attempt set (ConcurrentHashMap.newKeySet()) when a request starts and removes them only through its completion callback (withActiveAttemptCleanup -> clearActiveAttempt); the thrown CommandException never reaches that callback. Observed: leaf_27 threw at 05:43:11 and leaf_26 at 05:43:44 (one exception each); from then on every /rtp from those two accounts went unanswered (92 and 86 consecutive 5 s timeouts by 05:51, zero successes), while leaf26, which never threw, kept succeeding (1,150 OK, 2 timeouts). EzRTP gives no message and logs nothing after the first exception. The lock persisted for the rest of the phase; recovery without a plugin restart (e.g. relog) was not tested. The harness keeps dispatching to locked accounts by design: the timeouts are what a real player on that server gets, so they stay in EzRTP's Folia success rate and latency, and its cost-per-teleport figures for that phase come almost entirely from the one unlocked account.
  • Retains spatial state rather than short-TTL entries. Its memory of where it has already looked is not on a ~minutes timer, so like RTP it belongs in the amortizing class of section 4, not the time-expired one: a longer run should make it cheaper per attempt, not reset it. Confirm from the shipped config which keys bound that state (size cap, persistence across restart) and record them in section 6 before drawing the contrast in public.

JustRTP

  • The roster's only genuine pre-cache peer. kotorinet/justRTP, CC BY-NC-SA, Paper/Folia 1.21 through 26.2, Java 21+. It keeps a background cache of pre-validated spots so a normal /rtp serves from memory rather than searching live - the same shape as RTP's keptLocations. Every other competitor in section 5 either loads chunks in the foreground or serialises per player, so JustRTP is the first arm where the comparison is cache-vs-cache rather than cache-vs-search.
  • Native Folia support, no vendored PaperLib. It does not inherit the AsyncChunksSync -> CraftWorld.getChunkAt main-thread violation that breaks BetterRTP's and HuskHomes' queue pre-fill on Folia 26.1.x. Expect it to be the strongest Folia arm, and do not read a weak Folia result as vindication of our design if it turns out otherwise.
  • The cache sizes itself off free memory, TPS, player count and live demand. Two consequences for measurement: (a) the plugin's behaviour is a function of -Xmx, so its arm is only citable alongside the heap it ran on, and (b) it self-throttles on TPS, meaning a bad TPS reading in an earlier phase can shrink its cache before its own phase starts. Sequence it after a full settle gap and record heap_pressure_* for it specifically.
  • ~15 minute entry TTL - the practicality question. Cached locations expire on a short timer. Inside a ~600 s measured phase that TTL never fires, so the benchmark reads an intact cache and reports the best case. In production the TTL becomes the dominant term: on a quiet server every entry expires before anyone uses it, so the cache is pure background cost at a near-zero hit rate and /rtp falls back to a live search at exactly the moment the operator was promised instant. On a busy server it never matters. Worth stating plainly rather than scoring: a TTL that short is a freshness choice - guard against a spot being built over or claimed since validation - and the price of that choice is a cache that only pays off above some traffic threshold. RTP takes the other side of the trade, long-lived coordinates plus verification on serve, and pays for it in retention instead.
  • Measurement requirement, not an accusation. To keep this honest the JustRTP arm must run longer than one TTL (>= 2x TTL, so ~30 min against the current 600 s phase) or the figure published is a cache that was never allowed to expire. RTP runs the same long phase - but for the opposite reason, and the write-up should say so: RTP has no expiry timer to outlive, so its long phase tests retention and staleness, not hit-rate decay. Until such a run exists, no JustRTP hit-rate or latency number goes in the write-up.
  • Verify the TTL from the shipped config before quoting it. The 15 min figure is an operator-side observation; pin it to the actual key and value in the tested build's cache config and record both in section 6.
  • Loose duplicate classification by proximity (within 3 chunks / 48 blocks): When classifying duplicates by practical player proximity (landing within <= 3 chunks / 48 blocks):
  • JustRTP: Delivered 151 same-chunk collisions (3.75%) and 263 within-3-chunk duplicates (6.53%) across the full 16k border; under 7.5k radius, this spiked to 586 within-3-chunk duplicates (14.40%!).
  • EzRTP: In square mode, center-clustering concentrated landings near spawn (143 block duplicates); in random mode, it generated 3 same-chunk (0.07%) and 166 within-3-chunk (4.05%) landings across an 840M-block circle.
  • LeafRTP: Maintained 1 same-chunk collision (0.02%) and 154 within-3-chunk landings (3.76%) under native 1:1 Feistel sampling (stride S = 1). When uniquePlacements: 'auto' is configured in default.yml, Dyadic Stride (S = 256) mathematically enforces >= 16-chunk (256-block) inter-arrival spacing, reducing 3-chunk proximity duplicates to 0.0%.
  • Overlapping and identical placements under concurrency (observed 2026-09-21, Folia 26.1.2). JustRTP handed out the exact same destination coordinate at the same time to simultaneous /rtp requests from separate accounts. Root cause: its cache manager does not atomically reserve or evict candidate locations upon checkout during async chunk preparation; concurrent dispatches on the same tick or within the async validation window read the same un-popped queue head or positive reuse pool entry. Note on cross_plugin_destinations_scatter_chart.png: while the scatter chart reported "0 duplicates" for JustRTP, that metric was derived from a single-stream sequential benchmark run (20260921-171738.csv) where requests were evaluated in staggered series. Under real multi-player concurrent dispatch, "0 duplicates" fails immediately. Relevant to the cache-vs-cache comparison: LeafRTP's keptLocations/unkeptLocations pop locations atomically via lock-free CAS before dispatching, mathematically guaranteeing that no two players can ever receive the same coordinate even on the exact same tick.
  • Folia cross-region main-thread violation on cache re-validation (observed 2026-09-22, Folia 26.1.2). When JustRTP validates or serves a candidate location from its cache via RTPService.revalidateCachedLocation -> SafetyValidator.isLocationAbsolutelySafeAsync scheduled from FoliaScheduler / FoliaGlobalRegionScheduler, it invokes CraftBlock.getType() / CraftBlock.getBlockState() for coordinates across the world (BlockPos{x=7079, y=153, z=-13948}) from a thread that does not own that region (context=[thread=Folia Region Scheduler Thread #0, region={null}]). Moonrise/Folia's TickThread.ensureTickThread intercepts this cross-region read and throws IllegalStateException: Cannot read world asynchronously, warning [JustRTP] Error checking safety async. This proves JustRTP lacks true Folia region-scheduler affinity: its "async" safety validator relies on naked Bukkit block access without scheduling onto the target location's owning region.
  • Excluded surfaces. /rtp gui, zones, air RTP, matchmaking queue and cross-server are out of scope - the harness drives the plain teleport path only. Also: JustRTP registers /rtp, so it collides with our own label exactly as JakesRTP did (section 6 command-map hazard). Dispatch via a plugin-unique form and confirm with /justrtp:rtp <TAB>; this is the highest-risk arm in the roster for silent self-measurement.

EssentialsX

  • Excluded from the head-to-head: /tpr is self-only and cannot be driven from console without per-player chat dispatch.
  • /tpr is a timeout source on Spigot. Including the /tpr target in the roster produces a high, reproducible timeout rate for that target's slice; removing the target (EssentialsX still installed, nothing else changed) eliminates it. It is the act of dispatching /tpr, not EssentialsX's presence, that drives it. Silent failure: the attempts simply never produce a PlayerTeleportEvent within the deadline. Hypothesis (not root-caused): /tpr is a teleport-request command, so its handshake/warmup path does not emit the event the probe waits on. Not observed on Paper/Folia. See docs/dev/LESSONS_LEARNED.md Stress Testing.
  • Default posture: /tpr excluded from Spigot rosters. A run that keeps it must say so and must not be compared against rosters that excluded it.

DonutRTP

  • Excluded - not an independent implementation. The bundled JAR is a GUI front-end that dispatches BetterRTP commands; it does no chunk loading, safety checking, or distribution math. Every teleport button in its bundled gui/*.yml hard-codes betterrtp world world_N, and its settings.yml exposes only duration and buffer-blocks - no radius, centre, shape, or cooldown keys, because those are BetterRTP's.
  • Publishing it as its own row would be "BetterRTP's pipeline plus GUI overhead" and would halve BetterRTP's dispatches. Write-up line: operators using DonutRTP can read the BetterRTP row as their own.

8. Harness axes added since these runs (methodology follow-up)

The harness gained ~1000 lines of instrumentation after the section 5 runs were captured, so no result section above carries these columns. They are listed here as the methodology delta to fill on the next run. Schema conventions: for counts and durations -1 means NOT MEASURED and never zero; for strings, empty means NOT AVAILABLE. The harness writes its own schema notes alongside the CSVs.

New axis Columns What it settles
Served-mode split served_mode, served_mode_source, served_mode_threshold_ms, served_mode_direct; per phase mode_threshold_ms, mode_threshold_method, fast_mode_fraction, fast_p50/p95/p99_ms, cold_p50/p95/p99_ms Replaces any bare mean over a bimodal (queue-hit vs chunk-load) population. served_mode is inferred from observables only; the direct reading from the plugin under test has its own column so the two are never conflated, and it is empty for every competitor arm.
Foreground/background chunk split chunks_on_tick, chunks_off_tick, chunks_off_tick_share Turns the async share - the section 5.5 discriminator - from a derived figure into a direct measurement. On-tick means the single tick thread on Spigot/Paper, or the region thread owning the loaded chunk on Folia.
Tick-thread occupancy tick_intervals, tick_interval_total_ms, tick_interval_max_ms, tick_region_ownership Records occupancy as coalesced intervals, not a total: one 8 ms stall and sixteen 0.5 ms ones are not the same tick health, and a total cannot tell them apart. Loads within 10 ms merge into one interval so work on two different ticks can never be merged.
Folia region accounting region_context_acquisitions, region_freeze_threshold_ms, region_freezes, region_freezes_tick_stall, region_freezes_hop_stall, region_worst_freeze_ms Gives the harness its own region-freeze evidence instead of leaning entirely on the server watchdog (section 5.3), and counts region hops - the cost a live-block-API verifier pays per scattered candidate. The freeze threshold is a compile-time constant stated in the row, chosen before any run was read.
Region-file reads and bin occupancy region_file_reads, bin_candidates, bin_occupancy_max; per phase region_reads_per_attempt, bin_candidates_per_batch Measures the candidates-per-32x32-bin the cost model previously assumed to be 64. Implied by observed chunk loads, so it cannot see region bytes read without materializing a chunk - exactly what our prefilter does - and therefore understates RTP's avoided reads.
Storage class and read latency per phase storage_class, storage_class_method, storage_read_p50/p90/p99/max_us, storage_read_label Lets a downstream model select a cost distribution instead of assuming one. FIRST_TOUCH_UNKNOWN_PAGE_CACHE: farthest-from-origin first, no file probed twice, but pages already resident read warm - so a lower bound on cold-read latency.
GC and allocation churn gc_young_*, gc_old_*, gc_unclassified_collections, gc_total_*, gc_time_fraction_of_wall, tick_thread_alloc_bytes[_per_attempt], tick_alloc_scope The churn term that heap-used alone cannot separate from retention - the gap section 5.5's "no hard leak" finding had to argue around. gc_time_fraction_of_wall sums parallel GC threads and can exceed 1.0; it is not a pause fraction. Allocation is one recorded tick thread, not JVM-wide (FOLIA_GLOBAL_REGION_PARTIAL on Folia).
Chunk residency peak_resident_chunks, peak_plugin_tickets, peak_target_plugin_tickets Separates a design that keeps coordinate tuples and releases its tickets from one that keeps chunk neighbourhoods resident. Peaks, not averages - an average hides retention. The ticket census needs Paper's World#getPluginChunkTickets() and runs on its own slow timer (ticket-sample-period-ms, min 250 ms) because the query walks every ticketed chunk; it is -1 on Spigot and Folia.
Heap-pressure triggers heap_pressure_events, heap_pressure_first_heap_used_mb, heap_pressure_first_trigger, plus <stamp>-heap-triggers.csv Some engines govern their own heap and cut max attempts / serve cache-only above a limit; a comparison drawn across that boundary is not like-for-like. The harness records the trigger line and the heap level only - no response is inferred. Patterns are deliberately narrow (heap-pressure-patterns), since a false positive becomes a claimed behaviour change that never happened.
Crash-safe phase capture <stamp>-phases-partial.csv The per-attempt and 50 ms heap CSVs already flush per row, but the phase summary was only written at phase end, so the section 5.2 crash lost its aggregate. flushPartialPhase() now snapshots the in-flight phase (self-throttled to once per 2 s, called from Runner.tick()); endPhase deletes the sidecar, so a leftover file is itself the signal that the phase it describes crashed.
Open-loop stress point <stamp>-ramp.csv (one row per fixed-rate stage: offered_tps, achieved_tps, busy_rejections, harness_shed, mspt_p95, tps_min, verdict, fail_criteria), <stamp>-ramp-summary.txt Closed-loop modes cap offered rate at in-flight / latency (Little's law), so a fast plugin's throughput measured there is the harness's ceiling. The ramp offers load at a fixed rate and reports the highest rate each plugin sustains; see section 8.1.

Method work and status for the 4,096-attempt benchmark series:

  1. [DONE] Equalize search boundary across all 6 contenders: Fully audited and aligned on the Paper 26.2 test server to a 1,024 to 16,384 block radius:
  2. LeafRTP: radius: 16384b, centerRadius: 64 (chunks = 1,024b), centerX: 0, centerZ: 0.
  3. BetterRTP: MaxRadius: 17408 (yielding 16,384b effective due to the delta truncation bug), MinRadius: 1024, CenterX: 0, CenterZ: 0, Shape: circle.
  4. EzRTP: radius.min: 1024, radius.max: 16384, center: 0, 0, search-pattern: circle.
  5. JustRTP: min_radius: 1024, max_radius: 16384, center_x: 0, center_z: 0.
  6. JakesRTP: radius.min: 1024, radius.max: 16384, shape: circle, center: 0, 0.
  7. HuskHomes: region.min: 1024, region.max: 16384.
  8. [DONE] Test A (Burst Saturation / Queue Clearance):
  9. Executed in run 20261008-003310 across all 6 contenders with biome verification active.
  10. Evaluated peak throughput ceiling, total 4,096-attempt clearance time, surge tail latencies, and spatial distributions. Full results recorded in section 5.7 and RESULTS.md.
  11. [DONE] Test B (Steady-State Paced at 5.0 TP/s - Paper 26.2):
  12. Executed in run 20261008-024412 across all 6 contenders (supersedes 20261008-020859). In plugins/StressTestRTP/config.yml: per-target-count: 4096, immediate-redispatch: false, dispatch-interval-ms: 200, per-player-gap-ticks: 4, per-player-gap-ms: -1, sequence.gap-seconds: 180, sequence.per-target-seconds: 1800, spark rotate-seconds: 0.
  13. Evaluated tick impact (absolute MSPT and $\Delta$MSPT against the settle baseline), main-thread and process CPU per attempt, GC, chunk loads and spatial distributions at equal offered rate. Full results recorded in section 5.8 and RESULTS.md. chunks_off_tick_share reads 0.000 for every plugin on Paper and does not discriminate there.
  14. [DONE] Test B (Steady-State Paced at 5.0 TP/s - Folia 26.2):
  15. Executed in run 20261008-052141 across LeafRTP, EzRTP, JustRTP, and HuskHomes.
  16. Identified BetterRTP warm-up crash, EzRTP thread violation lockout and water landing bug, JustRTP 1,150 ms CPU scaling issue, and LeafRTP 31.5 % CPU reduction. Full results in section 5.9 and RESULTS.md.
  17. [CONFIGURED / NEXT] Test A (Burst Saturation / Queue Clearance - Folia 26.2):
  18. Configured in C:\GameServers\Minecraft\testServer\RTP-Folia\26.2\plugins\StressTestRTP\config.yml with dispatch-interval-ms: 0, immediate-redispatch: true, per-player-gap-ticks: 0, per-target-count: 4096.
  19. BetterRTP and EzRTP disabled due to fatal Folia threading incompatibilities; LeafRTP, JustRTP, and HuskHomes in active roster.
  20. [IN PROGRESS] Publication Pipeline to MkDocs (docs/site/benchmarks.md):
  21. Synthesize Test A and Test B CSV outputs, Spark flame graphs, and JFR allocations directly into docs/site/benchmarks.md for web publishing and storefront links.
  22. Set the base chunk-load-cost-us per platform if chunk-amended CPU modeling is desired (section 6 calibration note).
  23. Configure residency-target-plugin per arm if isolated per-plugin ticket counts are desired in multi-target sequence CSVs.
  24. [DONE] Arrival-block safety audit: Integrated into Test A and Test B runs via MetricsRecorder (landing_floor, landing_feet, landing_head, landing_class) across Paper and Folia. Successfully identified EzRTP depositing ~10.9 % of arrivals into water surfaces, and HuskHomes/JakesRTP void/noFloor landings.
  25. [PARTIAL] Test C (Stress point ramp - Paper 26.2, Linux): /rtpstress ramp <target> per contender, server restart between targets, roster of 48 offline-mode bots from devstack/clients/bench-swarm.js (connection-throttle: -1), cooldowns disabled. Definition in section 8.1. Overnight 2026-10-09: valid for LeafRTP (flat 100 TP/s, n=3) and EzRTP (ladder, n=2) only; results and the jar-isolation ordering bug in section 5.10. Remaining: BetterRTP, HuskHomes, justRTP, JakesRTP, and a LeafRTP ladder.

8.1 Stress point definition (Test C)

The stress point is the highest offered rate a plugin sustains on this rig, measured open-loop so it is not bounded by the harness.

  • Offered load: fixed-rate stages, default 5, 10, 20, 40, 80, 160, 320 TP/s, 60 s each, after a 30 s unrecorded warm-up. Dispatch slots are issued on schedule whether or not earlier attempts have completed; each slot goes to an idle roster player (one attempt in flight per player).
  • Harness saturation is separated from plugin saturation: a slot with no idle player is harness_shed. A failing stage whose shed slots alone exceed the 5 % allowance is tagged HARNESS_SATURATED, and any stress point just below it is reported as a lower bound.
  • Pass criteria (all): achieved (successful teleports / stage seconds) at least 95 % of offered; MSPT p95 at most 50 ms; (timeouts + errors) at most 1 % of attempts. Plugin-side busy rejections are shed load, reported per stage, and count against achieved, not against the failure rate.
  • Stress point = highest passing stage. Stop rules: two consecutive failing stages, or wall-clock TPS < 5 continuously for 10 s (that stage is aborted, recorded, and fails LOW_TPS_ABORT). Each stage row is flushed before the next stage, so a crash keeps every completed stage.
  • Report: stress point (stage, offered TP/s) plus the first failing stage and the criterion it failed. A plugin that fails stage 0 has no stress point on this rig; say so, do not interpolate.
  • Known limit: busy rejections are counted only when the plugin's reply reaches the console. Player-only chat replies surface as timeouts, so a plugin that politely sheds load via chat is billed as failing. Cross-check with the swarm's busy_chat count before publishing such a row.

9. Caveats and what this does not prove

Must appear in the public write-up.

Rig and load

  1. Single-server, single-machine rig; not a multi-server / proxy setup.
  2. Three real online accounts in the closed-loop runs (sections 5.1-5.9), not hundreds of players. Absolute numbers are a floor; with 50 real players everything degrades but the ranking should hold. The open-loop ramp (section 5.10) uses 48 idle Mineflayer bots with server view distance capped at 2: real connections and chunk sends, but not 48 players moving and building.
  3. Cooldowns and countdowns disabled everywhere - pipeline throughput, not anti-spam or UX policy.
  4. All plugins forced to the same outer radius (4096 blocks in section 5's runs, 16384 from the next run set); an author may argue that is not their default deployment shape. Never mix radii across a comparison - a bigger world is a different working set, not a harder version of the same one.
  5. Some plugins ignore centre-XY config and run at world spawn, so phase order alternates configurable and spawn-anchored cells.
  6. No GC tuning beyond default Paper flags (G1GC).
  7. Never mix dispatch gaps. gap=0 and gap=3 numbers are different conditions; compare only within a run.

Measurement

  1. TIMEOUT is a capture-window expiry, not a server failure. It means no completion was captured within 5 s. At high throughput a sub-tick teleport and a genuinely slow one can look alike to the oracle - the harness races itself. The race is biased in the slower plugin's favour: false timeouts concentrate on near-0 ms teleports (RTP's queue fast path), while an engine with guaranteed scheduler hops floors its latency above the race window. So RTP's handful of timeouts are treated as capture artifacts, and a competitor's are treated as real only when corroborated by server-side evidence.
  2. chunks_per_attempt is unreliable on Folia (e.g. RTP 29.6 vs its Paper 1.58): inflated by region ticketing plus ChunkLoadCounter over-attribution on region threads. Not a behavioural number.
  3. MSPT on Folia is the global-region sample, not per-region, so it is blind to a single hung region and is not a useful Folia discriminator. Use throughput plus watchdog evidence.
  4. Heap max is not a per-plugin metric - it is the -Xmx ceiling.
  5. MSPT is world-tick cost, not "server frozen": at peak MSPT the server was still chat-responsive at the ~50 ms level.
  6. cpu_ms_with_chunks* is relative-only until the calibration note in section 6 is addressed.
  7. A ~600 s phase is shorter than some caches live - but that cuts differently per engine. For a time-expired cache (JustRTP, ~15 min) the phase ends before a single entry expires, so the result is a best case by construction. For an event-invalidated cache (RTP, whose entries carry no timer in a claim-free world) there is no expiry event to miss, so the phase is a steady state and the open question is retention, not hit rate. Do not write one disclaimer covering both - see section 4 Entry-lifetime classes.

What this benchmark does NOT prove

  • That RTP is faster than every plugin in every configuration. Untested: low concurrency, very large or very small radii, cross-server, low-RAM servers.
  • That any competitor is "bad". BetterRTP is reasonable for low-volume servers; HuskHomes is optimized for cross-server homes and its /rtp is secondary. The findings are about where each design's ceiling sits.
  • That the observed defects cannot be fixed. The PaperLib-on-Folia violations in section 7 are one dependency swap away for their authors.
  • That results generalize to 50+ concurrent players (see caveat 2).
  • Anything about long-run cache economics for the time-expired class. No phase yet outlives JustRTP's ~15 min TTL, so its hit rate and refill cost are unmeasured. This is not a uniform charge: RTP's entries carry no expiry timer, and EzRTP's spatial state amortizes rather than expires, so for those engines a 600 s phase is a steady state and what remains unmeasured is retention over hours and staleness of aged entries, not hit-rate decay. Section 4's practicality questions are posed, not answered - per class.
  • Anything about destination safety. The harness counts completed teleports, not safe landings. Until the section 8 arrival audit lands, no claim about correctness or safety is supported by these numbers.

End of pre-writeup. Edit before publishing.