Server tick: cheaper view requeue and chunk ticket levels

Two costs that grow with players on the server thread:

- Hub::update_view rebuilt a player's chunk queue on every chunk crossing
  by scanning the queue (a Vec) once for each chunk of the view. It now
  checks a set. Same queue, same order (differential test against the old
  scan). 111 -> 16 us per crossing at view 10, 6.5 ms -> 0.13 ms at 32.
- ChunkTickets rebuilt a hash map of every ticketed chunk whenever any
  player changed chunk, and every block entity, mob and ticking chunk
  hashed into it. Levels are now a grid over the tickets' bounding box,
  with the map kept for tickets spread too far apart. At 50 players:
  build 0.23 -> 0.08 ms, lookups about 2x faster (differential test over
  200 random ticket layouts).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UxXpf7d4RgpespL2G2UsGE
This commit is contained in:
Claude
2026-10-21 19:28:55 +00:00
parent fd0473605b
commit da314fa658
2 changed files with 322 additions and 22 deletions
+98 -14
View File
@@ -240,6 +240,30 @@ fn tracked(cx: i32, cz: i32, r: i32, x: i32, z: i32) -> bool {
dx * dx + dz * dz < i64::from(r) * i64::from(r)
}
/// The view's queue around a new centre: the queued chunks still tracked, then
/// the tracked ones neither sent nor queued, closest first (a stable sort, so
/// equally close chunks keep their order).
fn requeue(
queue: &mut Vec<(i32, i32)>,
sent: &crate::fast_hash::FxHashSet<(i32, i32)>,
(cx, cz): (i32, i32),
r: i32,
) {
queue.retain(|&(x, z)| tracked(cx, cz, r, x, z));
// A walking player changes chunk every few ticks with hundreds of chunks
// queued: a set, not a scan of the queue for each of the view's chunks.
let mut queued: crate::fast_hash::FxHashSet<(i32, i32)> = queue.iter().copied().collect();
for dz in -r - 2..=r + 2 {
for dx in -r - 2..=r + 2 {
let key = (cx + dx, cz + dz);
if tracked(cx, cz, r, key.0, key.1) && !sent.contains(&key) && queued.insert(key) {
queue.push(key);
}
}
}
queue.sort_by_key(|&(x, z)| i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2));
}
/// What a level's players were last told of its clock and weather.
#[derive(Clone, Copy)]
struct LevelSync {
@@ -1288,20 +1312,7 @@ impl Hub {
g.sent_chunks.remove(&(x, z));
g.send(&C::ForgetLevelChunk(play::ForgetLevelChunk { pos: [x, z] }));
}
g.chunk_queue.retain(|&(x, z)| tracked(cx, cz, r, x, z));
for dz in -r - 2..=r + 2 {
for dx in -r - 2..=r + 2 {
let key = (cx + dx, cz + dz);
if tracked(cx, cz, r, key.0, key.1)
&& !g.sent_chunks.contains(&key)
&& !g.chunk_queue.contains(&key)
{
g.chunk_queue.push(key);
}
}
}
g.chunk_queue
.sort_by_key(|&(x, z)| i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2));
requeue(&mut g.chunk_queue, &g.sent_chunks, (cx, cz), r);
}
/// PlayerChunkSender.sendNextChunks' choice: ready chunks, closest first,
@@ -2457,3 +2468,76 @@ fn ticking_state(rate: f32, frozen: bool) -> C {
w.bool(frozen);
raw(ids::TICKING_STATE, w.data)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fast_hash::FxHashSet;
/// `requeue` as it was, scanning the queue for each chunk of the view.
fn requeue_scan(
queue: &mut Vec<(i32, i32)>,
sent: &FxHashSet<(i32, i32)>,
(cx, cz): (i32, i32),
r: i32,
) {
queue.retain(|&(x, z)| tracked(cx, cz, r, x, z));
for dz in -r - 2..=r + 2 {
for dx in -r - 2..=r + 2 {
let key = (cx + dx, cz + dz);
if tracked(cx, cz, r, key.0, key.1) && !sent.contains(&key) && !queue.contains(&key)
{
queue.push(key);
}
}
}
queue.sort_by_key(|&(x, z)| i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2));
}
/// A player walking a loop, sending a few chunks a tick: the queue
/// after every move is the one the scan built.
#[test]
fn requeue_matches_the_scan() {
for r in [2, 5, 10, 12, 32] {
let (mut a, mut b) = (Vec::new(), Vec::new());
let mut sent = FxHashSet::default();
for step in 0..60i32 {
let center = ((step % 17) - 8, (step * 3 % 11) - 5);
requeue(&mut a, &sent, center, r);
requeue_scan(&mut b, &sent, center, r);
assert_eq!(a, b, "radius {r}, step {step}");
for key in a.drain(..a.len().min(7)) {
sent.insert(key);
}
b.drain(..b.len().min(7));
sent.retain(|&(x, z)| tracked(center.0, center.1, r, x, z));
}
}
}
/// cargo test --release -p horizon-client --lib lan::hub::tests::requeue_cost -- --ignored --nocapture
#[test]
#[ignore]
fn requeue_cost() {
for r in [10, 16, 32] {
for (name, f) in [
("scan", requeue_scan as fn(&mut _, &_, _, _)),
("set", requeue as fn(&mut _, &_, _, _)),
] {
let sent = FxHashSet::default();
let mut queue = Vec::new();
let start = std::time::Instant::now();
let moves = 200;
for step in 0..moves {
// Nothing sent yet (an explorer waiting on generation).
f(&mut queue, &sent, (step, 0), r);
}
let per = start.elapsed().as_secs_f64() * 1e6 / f64::from(moves);
println!(
"view {r}: {name} {per:.1} us per chunk crossed, {} queued",
queue.len()
);
}
}
}
}
+224 -8
View File
@@ -45,13 +45,52 @@ pub struct Sources {
/// block ticking or lower; `None` ticks everywhere (a game with no server and
/// no player: the headless fixtures).
#[derive(Clone, Default)]
pub struct Levels(Option<Arc<FxHashMap<(i32, i32), (u8, u8)>>>);
pub struct Levels(Option<Arc<Map>>);
/// The levels by chunk: a grid over the tickets' bounding box while it is
/// small (players near each other, the usual case), a map otherwise. Every
/// block entity, mob and ticking chunk asks each tick, so an index beats a
/// hash; and a player crossing into another chunk rebuilds it all.
enum Map {
Grid {
x0: i32,
z0: i32,
width: u32,
depth: u32,
cells: Box<[(u8, u8)]>,
},
Sparse(FxHashMap<(i32, i32), (u8, u8)>),
}
/// The largest grid, in chunks: 1 MiB of levels, a box 724 chunks wide.
const GRID_CELLS: u64 = 1 << 19;
impl Map {
fn get(&self, x: i32, z: i32) -> (u8, u8) {
match self {
Self::Grid {
x0,
z0,
width,
depth,
cells,
} => {
let (dx, dz) = (x.wrapping_sub(*x0) as u32, z.wrapping_sub(*z0) as u32);
if dx < *width && dz < *depth {
cells[(dz * width + dx) as usize]
} else {
NONE
}
}
Self::Sparse(map) => map.get(&(x, z)).copied().unwrap_or(NONE),
}
}
}
impl Levels {
/// Chunk coordinates.
fn get(&self, x: i32, z: i32) -> Option<(u8, u8)> {
let map = self.0.as_ref()?;
Some(map.get(&(x, z)).copied().unwrap_or(NONE))
Some(self.0.as_ref()?.get(x, z))
}
/// `DistanceManager.inEntityTickingRange`, in an entity-ticking chunk:
/// where entities tick.
@@ -112,19 +151,89 @@ impl ChunkTickets {
}
}
fn compute(s: &Sources) -> FxHashMap<(i32, i32), (u8, u8)> {
/// How far a player's tickets reach, and the simulation ticket's level.
fn reach(s: &Sources) -> (i32, i32, i32) {
let view = s.view_distance.clamp(0, 32);
let simulation = s.simulation_distance.clamp(0, 32);
// PLAYER_LOADING within the view distance, PLAYER_SIMULATION at the
// player's chunk (`getPlayerTicketLevel`: never below 0).
let player_sim = (i32::from(ENTITY_TICKING) - simulation).max(0);
let reach = (view + 1).max(i32::from(BLOCK_TICKING) - player_sim);
(view, player_sim, reach)
}
fn compute(s: &Sources) -> Map {
let (view, player_sim, reach) = reach(s);
let boxes = s
.players
.iter()
.map(|&p| (p, reach))
.chain(s.forced.iter().map(|&f| (f, 1)));
let Some((x0, z0, x1, z1)) = boxes.fold(None, |b, ((x, z), r)| {
let (lo_x, lo_z, hi_x, hi_z) = (
i64::from(x) - i64::from(r),
i64::from(z) - i64::from(r),
i64::from(x) + i64::from(r),
i64::from(z) + i64::from(r),
);
Some(match b {
None => (lo_x, lo_z, hi_x, hi_z),
Some((a, b, c, d)) => (lo_x.min(a), lo_z.min(b), hi_x.max(c), hi_z.max(d)),
})
}) else {
return Map::Sparse(FxHashMap::default());
};
let (width, depth) = ((x1 - x0 + 1) as u64, (z1 - z0 + 1) as u64);
if width * depth > GRID_CELLS {
return Map::Sparse(compute_sparse(s));
}
let (x0, z0, width, depth) = (x0 as i32, z0 as i32, width as u32, depth as u32);
let mut cells = vec![NONE; (width * depth) as usize].into_boxed_slice();
let mut lower = |x: i32, z: i32, loading: i32, sim: i32| {
let i = ((z - z0) as u32 * width + (x - x0) as u32) as usize;
let e = &mut cells[i];
e.0 = e.0.min(loading.min(i32::from(NONE.0)) as u8);
e.1 = e.1.min(sim.min(i32::from(NONE.1)) as u8);
};
for &(px, pz) in &s.players {
for dz in -reach..=reach {
for dx in -reach..=reach {
let d = dx.abs().max(dz.abs());
lower(
px + dx,
pz + dz,
i32::from(ENTITY_TICKING) + (d - view).max(0),
player_sim + d,
);
}
}
}
for &(fx, fz) in &s.forced {
for dz in -1i32..=1 {
for dx in -1i32..=1 {
let level = i32::from(ENTITY_TICKING) + dx.abs().max(dz.abs());
lower(fx + dx, fz + dz, level, level);
}
}
}
Map::Grid {
x0,
z0,
width,
depth,
cells,
}
}
/// The levels as a map, for tickets spread too far apart for a grid.
fn compute_sparse(s: &Sources) -> FxHashMap<(i32, i32), (u8, u8)> {
let (view, player_sim, reach) = reach(s);
let mut levels: FxHashMap<(i32, i32), (u8, u8)> = FxHashMap::default();
let mut lower = |key, loading: i32, sim: i32| {
let e = levels.entry(key).or_insert(NONE);
e.0 = e.0.min(loading.min(i32::from(NONE.0)) as u8);
e.1 = e.1.min(sim.min(i32::from(NONE.1)) as u8);
};
// PLAYER_LOADING within the view distance, PLAYER_SIMULATION at the
// player's chunk (`getPlayerTicketLevel`: never below 0).
let player_sim = (i32::from(ENTITY_TICKING) - simulation).max(0);
let reach = (view + 1).max(i32::from(BLOCK_TICKING) - player_sim);
for &(px, pz) in &s.players {
for dz in -reach..=reach {
for dx in -reach..=reach {
@@ -229,4 +338,111 @@ mod tests {
t.update(None);
assert!(t.levels().0.is_none());
}
/// The grid answers as the map does, everywhere around the tickets.
#[test]
fn grid_matches_the_map() {
let mut seed = 0x2545_f491_4f6c_dd1du64;
let mut next = |n: i32| {
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
(seed % (2 * n as u64 + 1)) as i32 - n
};
for case in 0..200 {
let spread = [3, 20, 80][case % 3];
let players: Vec<_> = (0..1 + case % 12)
.map(|_| (next(spread), next(spread)))
.collect();
let forced: Vec<_> = (0..case % 4)
.map(|_| (next(spread), next(spread)))
.collect();
let s = Sources {
players,
forced,
view_distance: 2 + next(12).abs(),
simulation_distance: 2 + next(12).abs(),
};
let Map::Grid { .. } = compute(&s) else {
panic!("case {case} fell back to the map");
};
let (grid, map) = (compute(&s), Map::Sparse(compute_sparse(&s)));
let r = spread + 50;
for z in -r..=r {
for x in -r..=r {
assert_eq!(grid.get(x, z), map.get(x, z), "case {case} at ({x}, {z})");
}
}
}
}
#[test]
fn far_apart_tickets_use_the_map() {
let l = levels(
&[(0, 0), (100_000, -100_000)],
&[(i32::MAX - 2, i32::MIN + 2)],
10,
10,
);
assert!(matches!(**l.0.as_ref().unwrap(), Map::Sparse(_)));
assert!(l.entity_ticking(100_010, -100_010) && !l.block_ticking(50_000, 0));
assert!(l.entity_ticking(i32::MAX - 2, i32::MIN + 2));
}
/// cargo test --release -p horizon-client --lib ticket_levels::tests::levels_cost -- --ignored --nocapture
#[test]
#[ignore]
fn levels_cost() {
for players in [1usize, 10, 25, 50] {
// The benchmark's bots: most near spawn, a fifth flying outwards.
let at: Vec<_> = (0..players)
.map(|i| {
let a = i as f64 * 2.399;
let d = if i % 5 == 0 { 30.0 } else { 3.0 };
((a.cos() * d) as i32, (a.sin() * d) as i32)
})
.collect();
let s = Sources {
players: at.clone(),
forced: Vec::new(),
view_distance: 10,
simulation_distance: 10,
};
let rounds = 200;
let t = std::time::Instant::now();
for _ in 0..rounds {
std::hint::black_box(compute_sparse(std::hint::black_box(&s)));
}
let map_build = t.elapsed().as_secs_f64() * 1e3 / rounds as f64;
let t = std::time::Instant::now();
for _ in 0..rounds {
std::hint::black_box(compute(std::hint::black_box(&s)));
}
let grid_build = t.elapsed().as_secs_f64() * 1e3 / rounds as f64;
// A tick's questions: every chunk within 12 of every player.
let (map, grid) = (Map::Sparse(compute_sparse(&s)), compute(&s));
let ask = |m: &Map| {
let t = std::time::Instant::now();
let mut n = 0u32;
for _ in 0..rounds {
for &(px, pz) in &at {
for z in pz - 12..=pz + 12 {
for x in px - 12..=px + 12 {
n +=
u32::from(std::hint::black_box(m.get(x, z)).0 <= BLOCK_TICKING);
}
}
}
}
std::hint::black_box(n);
t.elapsed().as_secs_f64() * 1e3 / rounds as f64
};
println!(
"{players} players: build {map_build:.3} -> {grid_build:.3} ms, {} lookups {:.3} -> {:.3} ms",
players * 625,
ask(&map),
ask(&grid)
);
}
}
}