Merge pull request #233 from rdbtCVS/perf/lighting-worker-results-20261014

perf: return only lighting from chunk light workers
This commit is contained in:
Ludovic Marie
2026-10-15 06:56:10 +02:00
committed by GitHub
8 changed files with 299 additions and 43 deletions
@@ -9,7 +9,7 @@ use horizon_client::{
biome::Biomes,
blocks::BlockFacts,
chunk::{Chunk, MIN_Y, SECTIONS},
light::{LightTables, light_chunk},
light::{LightTables, apply_lighting, light_chunk},
mesher::{MeshTables, Mesher},
models,
streaming::{ChunkGenerator, Proto},
@@ -105,7 +105,7 @@ fn main() -> Result<()> {
);
let mut chunks: Vec<Chunk> = chunks.iter().map(|c| (**c).clone()).collect();
for ((x, z), sections) in lit {
chunks[((z - 1) * inner + x - 1) as usize].sections = sections;
apply_lighting(&mut chunks[((z - 1) * inner + x - 1) as usize], sections);
}
let chunks: Vec<Arc<Chunk>> = chunks.into_iter().map(Arc::new).collect();
let at = |x: i32, z: i32| chunks[((z - 1) * inner + x - 1) as usize].clone();
@@ -9,7 +9,7 @@ use horizon_client::{
biome::Biomes,
blocks::BlockFacts,
chunk::{Chunk, MIN_Y, SECTIONS, index},
light::{LightTables, light_chunk},
light::{LightTables, apply_lighting, light_chunk},
save,
};
use horizon_core::position::ChunkPos;
@@ -101,7 +101,7 @@ fn main() -> horizon_client::Result<()> {
.unwrap_or((None, None));
let nib = |a: &Option<Vec<u8>>| a.as_ref().map(|a| (a[i >> 1] >> ((i & 1) * 4)) & 15);
let id = chunks[&(x, z)].get(wx & 15, wy, wz & 15);
let packed = lit[si].light(i);
let packed = lit[si].get(i);
println!(
"{wy}: {} horizon sky {} block {} vanilla sky {:?} block {:?}",
facts.states[id as usize].name,
@@ -157,7 +157,7 @@ fn main() -> horizon_client::Result<()> {
.map_or(15, |a| (a[(i & 255) >> 1] >> ((i & 1) * 4)) & 15),
};
let vb = nibble(&block, 0);
let packed = section.light(i);
let packed = section.get(i);
let (hs, hb) = (packed >> 4, packed & 15);
total += 1;
if hs != vs {
@@ -228,7 +228,7 @@ fn incremental(
std::array::from_fn(|dx| chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1)))
});
let mut c = chunks[&(x, z)].clone();
c.sections = light_chunk(&region, tables, sky_light);
apply_lighting(&mut c, light_chunk(&region, tables, sky_light));
c.lit = true;
world.insert((x, z), Arc::new(c));
}
@@ -299,7 +299,7 @@ fn incremental(
let full = light_chunk(&region, tables, sky_light);
for (si, s) in full.iter().enumerate() {
for i in 0..4096 {
let (a, b) = (s.light(i), world[&(kx, kz)].sections[si].light(i));
let (a, b) = (s.get(i), world[&(kx, kz)].sections[si].light(i));
if a != b {
bad += 1;
if bad < 20 {
@@ -11,7 +11,7 @@ use horizon_client::{
collisions,
containers::{BlockEntity, CreakingHeart},
items::{ItemStack, Items},
light::{LightTables, light_chunk},
light::{LightTables, apply_lighting, light_chunk},
mobs::{
Damage, MobType, creaking,
creaking_heart::{self, HeartEvent, HeartHost},
@@ -779,7 +779,7 @@ fn main() -> horizon_client::Result<()> {
})
});
let mut c = (*world.chunks[&(x, z)]).clone();
c.sections = light_chunk(&region, &tables, true);
apply_lighting(&mut c, light_chunk(&region, &tables, true));
c.lit = true;
((x, z), c)
})
@@ -10,7 +10,7 @@ use horizon_client::{
biome::Biomes,
blocks::BlockFacts,
chunk::{Chunk, MIN_Y, SECTIONS},
light::{LightTables, light_chunk},
light::{LightTables, apply_lighting, light_chunk},
save::{self, SaveTables},
};
use horizon_core::position::ChunkPos;
@@ -157,7 +157,7 @@ fn main() -> horizon_client::Result<()> {
std::array::from_fn(|dx| chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1)))
});
let mut chunk = chunks[&(x, z)].clone();
chunk.sections = light_chunk(&region, &lights, sky_light);
apply_lighting(&mut chunk, light_chunk(&region, &lights, sky_light));
chunk.lit = true;
let ours = save::encode_with(&chunk, assets.registry, &biomes, Some(&tables), sky_light);
let theirs = &originals[&(x, z)];
+10 -4
View File
@@ -20,6 +20,15 @@ pub enum Light {
Uniform(u8),
Full(Box<[u8; 4096]>),
}
impl Light {
#[inline]
pub fn get(&self, i: usize) -> u8 {
match self {
Self::Uniform(v) => *v,
Self::Full(a) => a[i],
}
}
}
#[inline]
pub fn index(x: i32, y: i32, z: i32) -> usize {
((y & 15) << 8 | (z & 15) << 4 | (x & 15)) as usize
@@ -59,10 +68,7 @@ impl Section {
}
#[inline]
pub fn light(&self, i: usize) -> u8 {
match &self.light {
Light::Uniform(v) => *v,
Light::Full(a) => a[i],
}
self.light.get(i)
}
pub fn is_uniform(&self, v: u16) -> bool {
self.blocks.is_uniform(u32::from(v))
+219 -21
View File
@@ -16,7 +16,7 @@
//! directly to resident chunks after a block change.
use crate::{
blocks::BlockFacts,
chunk::{Chunk, HEIGHT, Light, MIN_Y, SECTIONS, Section, index},
chunk::{Chunk, HEIGHT, Light, MIN_Y, SECTIONS, index},
};
use horizon_core::geometry::{Direction, ShapeOp, VoxelShape};
use horizon_world::registry::{BlockRegistry, BlockStateId};
@@ -195,8 +195,8 @@ pub fn light_chunk(
region: &[[Option<&Chunk>; 3]; 3],
tables: &LightTables,
sky_light: bool,
) -> Vec<Arc<Section>> {
let center = region[1][1].expect("centre chunk");
) -> Vec<Light> {
region[1][1].expect("centre chunk");
// Highest occupied section in the region bounds the work.
let mut top_section = 0;
for chunk in region.iter().flatten().flatten() {
@@ -321,20 +321,22 @@ pub fn light_chunk(
};
spread(&mut sky, &mut sky_queue);
spread(&mut block, &mut queue);
let mut sections = Vec::with_capacity(SECTIONS);
for (si, section) in center.sections.iter().enumerate() {
let mut out = (**section).clone();
let open = if sky_light { 0xF0 } else { 0x00 };
if si * 16 >= h {
out.light = Light::Uniform(open);
} else {
let mut data = Box::new([0u8; 4096]);
pack_lighting(h, &sky, &block, sky_light)
}
/// Extract just the centre column's light; never copy worker snapshot sections.
fn pack_lighting(h: usize, sky: &[u8], block: &[u8], sky_light: bool) -> Vec<Light> {
let at = |x: usize, y: usize, z: usize| (y * W + z) * W + x;
let open = if sky_light { 0xF0 } else { 0x00 };
(0..SECTIONS)
.map(|si| {
if si * 16 >= h {
return Light::Uniform(open);
}
let mut data = Box::new([open; 4096]);
for ly in 0..16 {
let y = si * 16 + ly;
if y >= h {
for i in 0..256 {
data[ly << 8 | i] = open;
}
continue;
}
for lz in 0..16 {
@@ -344,12 +346,21 @@ pub fn light_chunk(
}
}
}
out.light = Light::Full(data);
}
out.compact();
sections.push(Arc::new(out));
if data.iter().all(|&v| v == data[0]) {
Light::Uniform(data[0])
} else {
Light::Full(data)
}
})
.collect()
}
/// Move a worker's light into current sections, preserving later block/biome
/// edits and immutable snapshots retained by other workers.
pub fn apply_lighting(chunk: &mut Chunk, lights: Vec<Light>) {
for (section, light) in chunk.sections.iter_mut().zip(lights) {
Arc::make_mut(section).light = light;
}
sections
}
/// Resident chunks the incremental relighter reads and writes.
@@ -622,7 +633,7 @@ mod tests {
std::array::from_fn(|dx| chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1)))
});
let mut c = chunks[&(x, z)].clone();
c.sections = light_chunk(&region, &tables(), true);
apply_lighting(&mut c, light_chunk(&region, &tables(), true));
c.lit = true;
((x, z), Arc::new(c))
})
@@ -691,11 +702,198 @@ mod tests {
for (si, s) in full.iter().enumerate() {
for i in 0..4096 {
assert_eq!(
s.light(i),
s.get(i),
w[&(0, 0)].sections[si].light(i),
"section {si} index {i}"
);
}
}
}
#[test]
fn lighting_result_preserves_current_edits_and_snapshots() {
let mut current = Chunk::empty(0, 0);
current.set(8, MIN_Y, 8, TORCH);
let region = [[None; 3], [None, Some(&current), None], [None; 3]];
let lights = light_chunk(&region, &tables(), true);
let Light::Full(data) = &lights[0] else {
panic!("torch light varies");
};
let result_storage = data.as_ptr();
let snapshot = current.clone();
current.set(8, MIN_Y, 8, STONE);
Arc::make_mut(&mut current.sections[0]).biomes.set(0, 3);
let edited_snapshot = current.clone();
apply_lighting(&mut current, lights);
let Light::Full(data) = &current.sections[0].light else {
panic!("torch light varies");
};
assert_eq!(
result_storage,
data.as_ptr(),
"returned light storage moves without cloning"
);
current.lit = true;
assert_eq!(current.get(8, MIN_Y, 8), STONE);
assert_eq!(current.sections[0].biomes.get(0), 3);
assert_eq!(snapshot.get(8, MIN_Y, 8), TORCH);
assert_eq!(edited_snapshot.sections[0].light(index(8, MIN_Y, 8)), 0xF0);
let mut world = HashMap::from([((0, 0), Arc::new(current))]);
// Streaming replays edits made after the job snapshot with force=true.
relight(&mut world, &tables(), true, &[(8, MIN_Y, 8)], true);
let region = [[None; 3], [None, Some(&*world[&(0, 0)]), None], [None; 3]];
let fresh = light_chunk(&region, &tables(), true);
for (section, light) in world[&(0, 0)].sections.iter().zip(fresh) {
for i in 0..4096 {
assert_eq!(section.light(i), light.get(i));
}
}
}
#[test]
fn empty_chunk_missing_neighbours_and_no_sky() {
let mut chunk = Chunk::empty(0, 0);
for sky in [false, true] {
let region = [[None; 3], [None, Some(&chunk), None], [None; 3]];
let lights = light_chunk(&region, &tables(), sky);
assert_eq!(lights.len(), SECTIONS);
assert!(
lights
.iter()
.all(|v| matches!(v, Light::Uniform(n) if *n == if sky { 0xF0 } else { 0 }))
);
let section = Arc::as_ptr(&chunk.sections[0]);
apply_lighting(&mut chunk, lights);
assert_eq!(section, Arc::as_ptr(&chunk.sections[0]));
}
}
// Original main's worker packaging and streaming application. Kept here
// so the benchmark compares the real former copy/compaction work.
fn baseline_pack(
center: &Chunk,
h: usize,
sky: &[u8],
block: &[u8],
) -> Vec<Arc<crate::chunk::Section>> {
let at = |x: usize, y: usize, z: usize| (y * W + z) * W + x;
let mut sections = Vec::with_capacity(SECTIONS);
for (si, section) in center.sections.iter().enumerate() {
let mut out = (**section).clone();
if si * 16 >= h {
out.light = Light::Uniform(0xF0);
} else {
let mut data = Box::new([0u8; 4096]);
for ly in 0..16 {
let y = si * 16 + ly;
if y >= h {
for i in 0..256 {
data[ly << 8 | i] = 0xF0;
}
continue;
}
for lz in 0..16 {
for lx in 0..16 {
let p = at(16 + lx, y, 16 + lz);
data[index(lx as i32, ly as i32, lz as i32)] = sky[p] << 4 | block[p];
}
}
}
out.light = Light::Full(data);
}
out.compact();
sections.push(Arc::new(out));
}
sections
}
fn baseline_apply(chunk: &mut Chunk, sections: Vec<Arc<crate::chunk::Section>>) {
for (target, lit) in chunk.sections.iter_mut().zip(sections) {
let mut section = (**target).clone();
section.light = lit.light.clone();
*target = Arc::new(section);
}
}
#[test]
#[ignore = "microbenchmark; run with --ignored --nocapture"]
fn benchmark_worker_light_results() {
use std::{hint::black_box, time::Instant};
let mut fixture = Chunk::empty(0, 0);
for (si, s) in fixture.sections.iter_mut().enumerate() {
let section = Arc::make_mut(s);
for i in 0..4096 {
section.set(i, ((i + si) % 16) as u16);
}
for i in 0..64 {
section.biomes.set(i, (i % 4) as u32);
}
section.light = Light::Full(Box::new([0x87; 4096]));
}
let h = HEIGHT as usize;
let sky: Vec<_> = (0..W * W * h).map(|i| (i % 16) as u8).collect();
let block: Vec<_> = (0..W * W * h).map(|i| ((i / 16) % 16) as u8).collect();
let mut old = fixture.clone();
let mut new = fixture.clone();
baseline_apply(&mut old, baseline_pack(&fixture, h, &sky, &block));
apply_lighting(&mut new, pack_lighting(h, &sky, &block, true));
for (a, b) in old.sections.iter().zip(&new.sections) {
for i in 0..4096 {
assert_eq!(a.light(i), b.light(i));
assert_eq!(a.get(i), b.get(i));
}
for i in 0..64 {
assert_eq!(a.biomes.get(i), b.biomes.get(i));
}
}
for shared in [false, true] {
let mut times = [Vec::new(), Vec::new()];
for round in 0..11 {
for optimized in [round % 2 == 0, round % 2 != 0] {
let mut current = fixture.clone();
let held = shared.then(|| current.clone());
// Warm up and detach for the uniquely-owned scenario.
apply_lighting(&mut current, pack_lighting(h, &sky, &block, true));
let started = Instant::now();
for _ in 0..500 {
let retained = shared.then(|| current.clone());
if optimized {
apply_lighting(
black_box(&mut current),
pack_lighting(h, black_box(&sky), black_box(&block), true),
);
} else {
baseline_apply(
black_box(&mut current),
baseline_pack(
black_box(&fixture),
h,
black_box(&sky),
black_box(&block),
),
);
}
black_box(retained);
black_box(&current);
}
if round > 0 {
times[usize::from(optimized)]
.push(started.elapsed().as_secs_f64() * 1e6 / 500.0);
}
black_box(held);
}
}
for values in &mut times {
values.sort_by(f64::total_cmp);
}
println!(
"pack+apply shared={shared}: baseline {:.3} us optimized {:.3} us speedup {:.2}x",
times[0][5],
times[1][5],
times[0][5] / times[1][5]
);
}
let payload: usize = fixture.sections.iter().map(|s| s.heap_bytes()).sum();
println!(
"fixture heap payload {payload} bytes; old worker clones it plus 24 section Arcs; old application clones current payload and 98304 returned light bytes. New worker clones zero section payload; new application clones current payload only when shared."
);
}
}
+3 -7
View File
@@ -5,7 +5,7 @@
use crate::fast_hash::{FxHashMap, FxHashSet};
use crate::{
chunk::{Chunk, SECTIONS},
light::{LightTables, light_chunk},
light::{LightTables, apply_lighting, light_chunk},
mesher::{MeshTables, Mesher, Region, SectionMesh, borrow},
world::World,
};
@@ -93,7 +93,7 @@ pub enum Done {
/// A proto chunk, and whether it was decorated (loaded so from the save).
Proto(i32, i32, Proto, bool),
Decorated(i32, i32, Box<[Proto; 9]>),
Lit(i32, i32, Vec<Arc<crate::chunk::Section>>, u64),
Lit(i32, i32, Vec<crate::chunk::Light>, u64),
Meshed(i32, i32, i32, SectionMesh, u64),
}
struct Queued {
@@ -491,11 +491,7 @@ impl Streaming {
if let Some(chunk) = world.chunks.get_mut(&(x, z)) {
let chunk = Arc::make_mut(chunk);
// Keep blocks edited since the snapshot; take only light.
for (target, lit) in chunk.sections.iter_mut().zip(sections) {
let mut section = (**target).clone();
section.light = lit.light.clone();
*target = Arc::new(section);
}
apply_lighting(chunk, sections);
chunk.lit = true;
self.lit.insert((x, z));
self.replay_light_edits(world, x, z, snapshot);
@@ -0,0 +1,56 @@
# Lighting worker result packaging
`light_chunk` now returns only `Vec<Light>`. `apply_lighting` moves each light
into the current section through `Arc::make_mut`, preserving current block and
biome edits and snapshots held by other workers. Streaming still rejects stale
sequences before applying results and replays edits after applying valid light.
All direct examples use the same application function.
## Reproduce
```sh
CARGO_INCREMENTAL=0 CARGO_TARGET_DIR=/home/bob/Documents/horizon/target cargo test -p horizon-client --lib --profile fast benchmark_worker_light_results -- --ignored --nocapture
```
The ignored test invokes the production `pack_lighting` and `apply_lighting`
functions and compares them to original main's packaging/application loops.
It checks every resulting block, biome, and light value before timing. Each
measurement uses 500 columns per batch, one discarded warm-up batch, and ten
measured batches with alternating baseline/optimized order and `black_box`.
The reported median is the upper middle of the ten samples. Both implementations
receive identical precomputed propagation arrays. The fixture contains 24
sections with 16-state block palettes, four-biome palettes, and existing full
light arrays. A second case retains a fresh snapshot each iteration to force
copy-on-write during application. Fixtures are synthetic, not loaded saves.
AMD Ryzen 5 5600X, Linux x86_64, rustc 1.99.0, optimized `fast` profile,
nonincremental, no LTO:
| Packaging + application | Original main | New | Speedup |
| --- | ---: | ---: | ---: |
| Sections uniquely owned | 63.948 us/column | 44.397 us/column | 1.44x |
| Snapshot retained | 65.332 us/column | 53.025 us/column | 1.23x |
These measurements exclude propagation, region snapshot creation, outer chunk
copy-on-write, channels, replay, and remeshing. They establish savings in the
actual worker output/application paths, not a whole lighting runtime or FPS gain.
## Copy and allocation scope
`Section::heap_bytes` reports 149,760 bytes of fixture payload per column.
Original packaging clones that payload and allocates 24 section Arcs. Original
application clones the current section payload, allocates another 24 section
Arcs, and clones 98,304 bytes of returned light. New packaging clones no section
payload and allocates no section Arcs. New application moves the returned light;
with unique sections it clones no payload and allocates no section Arcs. With a
retained snapshot it still copies the current section payload and allocates 24
Arcs, as required to preserve the snapshot. New light arrays and the result Vec
still allocate. These are structural copy/allocation observations, not global
allocator instrumentation; byte figures exclude Arc headers, Vec headers, and
allocator overhead.
Focused tests cover moved light buffer identity, current block/biome edits,
retained snapshots, forced replay versus fresh full relighting, empty chunks,
missing neighbours, no-sky dimensions, light attenuation, occlusion, and
incremental/full equivalence. The stale-sequence guard and missing-current-chunk
handling in streaming are unchanged.