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:
@@ -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()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user