From bae797575737c6568083faf6f929edc338892b53 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Sat, 17 Oct 2026 18:05:39 -0400 Subject: [PATCH 01/28] Add bounded hierarchical surface terrain LODs for distant views (#718) --- crates/horizon-client/src/flatgen.rs | 37 +- crates/horizon-client/src/game.rs | 109 ++- crates/horizon-client/src/game/control.rs | 20 + crates/horizon-client/src/game/packs.rs | 1 + crates/horizon-client/src/game/remote.rs | 3 + crates/horizon-client/src/game/render_tick.rs | 2 +- crates/horizon-client/src/gfx.rs | 204 ++++- crates/horizon-client/src/gfx/lod.rs | 142 +++ crates/horizon-client/src/gfx/translucency.rs | 43 + crates/horizon-client/src/graphics.rs | 21 +- crates/horizon-client/src/graphics_ui.rs | 56 +- crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/lod.rs | 862 ++++++++++++++++++ crates/horizon-client/src/mesher/facing.rs | 5 + crates/horizon-client/src/save.rs | 229 ++++- crates/horizon-client/src/streaming.rs | 46 +- crates/horizon-client/src/testgen.rs | 48 + crates/horizon-client/src/vanillagen.rs | 23 + .../horizon-world/src/worldgen/generator.rs | 119 ++- docs/graphics.md | 16 +- 20 files changed, 1923 insertions(+), 64 deletions(-) create mode 100644 crates/horizon-client/src/gfx/lod.rs create mode 100644 crates/horizon-client/src/lod.rs diff --git a/crates/horizon-client/src/flatgen.rs b/crates/horizon-client/src/flatgen.rs index 1cff68b11..339f1fca1 100644 --- a/crates/horizon-client/src/flatgen.rs +++ b/crates/horizon-client/src/flatgen.rs @@ -6,6 +6,7 @@ use horizon_world::{nbt::Tag, registry::BlockRegistry}; pub struct FlatTerrain { layers: Vec, biome: u16, + surface: Option, } impl FlatTerrain { /// The overworld generator of `world_gen_settings` (`data.dimensions`), if it @@ -34,9 +35,40 @@ impl FlatTerrain { layers.extend(std::iter::repeat_n(state, height as usize)); } } + let biome = biomes.id(&biome); + let mut water = None; + let mut surface = None; + for (i, &id) in layers + .iter() + .take(crate::chunk::HEIGHT as usize) + .enumerate() + .rev() + { + let state = horizon_world::registry::BlockStateId(id); + let name = registry.state(state)?.name.as_str(); + if matches!( + name, + "minecraft:air" | "minecraft:cave_air" | "minecraft:void_air" + ) { + continue; + } + let height = crate::chunk::MIN_Y + i as i32 + 1; + if matches!(name, "minecraft:water" | "minecraft:lava") { + water.get_or_insert((height, state)); + } else { + surface = Some(crate::lod::Surface { + height, + state, + water, + biome, + }); + break; + } + } Some(Self { layers, - biome: biomes.id(&biome), + biome, + surface, }) } /// FlatLevelSource.getSpawnHeight: the top of the layers. @@ -154,6 +186,9 @@ pub fn settings_from_json( impl ChunkGenerator for FlatTerrain { type Worker = (); fn worker(&self) {} + fn lod_surface(&self, _: &mut (), _: i32, _: i32) -> Option { + self.surface + } fn proto(&self, _: &mut (), cx: i32, cz: i32) -> crate::streaming::Proto { let mut chunk = Chunk::empty(cx, cz); for s in &mut chunk.sections { diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f13be4c84..1fb3a7889 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -780,6 +780,9 @@ struct Game<'a> { screen_fx: horizon_client::screen_effects::ScreenEffects, world: World, streaming: Streaming, + lod: Option, + lod_source_attempted: bool, + lod_observe: horizon_client::fast_hash::FxHashSet<(i32, i32)>, options: Options, player: Option, spawn: Option, @@ -6426,6 +6429,7 @@ impl Game<'_> { self.using = None; self.screen = Screen::Playing; self.title = None; + self.clear_lod(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -6575,6 +6579,7 @@ impl Game<'_> { self.pickups.clear(); self.orbs.clear(); self.mining = None; + self.clear_lod(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -6753,6 +6758,7 @@ impl Game<'_> { self.sleep_timer = 0; self.clear_entities(); self.screen = Screen::Playing; + self.clear_lod(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -8626,9 +8632,10 @@ impl Game<'_> { } else { self.bob_matrix(alpha as f32) }; - let distance = (self.streaming.radius * 16) as f32; + let terrain_distance = self.terrain_distance(); + let distance = (terrain_distance * 16) as f32; let depth_far = - horizon_client::camera::depth_far(self.streaming.radius, self.settings.cloud_range); + horizon_client::camera::depth_far(terrain_distance, self.settings.cloud_range); self.view_frustum = self .renderer .as_ref() @@ -8705,6 +8712,7 @@ impl Game<'_> { bob, sky, distance, + detail_distance: (self.streaming.radius * 16) as f32, depth_far, underwater, title: title && !live, @@ -8889,7 +8897,7 @@ impl Game<'_> { ); // Camera.depthFar, as the renderer's far plane. let depth_far = - horizon_client::camera::depth_far(self.streaming.radius, self.settings.cloud_range); + horizon_client::camera::depth_far(self.terrain_distance(), self.settings.cloud_range); if !self .border_renderer .prepare(&self.border_state, camera, distance, depth_far) @@ -9096,10 +9104,63 @@ impl Game<'_> { } Ok(()) } + /// Only surface LOD worlds extend the renderer's range, never simulation. + fn terrain_distance(&self) -> i32 { + if self.lod.is_some() && self.dim != Dim::Nether { + self.streaming + .radius + .max(self.settings.horizon.lod_distance.min(1024) as i32) + } else { + self.streaming.radius + } + } + fn clear_lod(&mut self) { + self.lod = None; + self.lod_source_attempted = false; + self.lod_observe.clear(); + if let Some(renderer) = &mut self.renderer { + renderer.clear_lods(); + } + } + fn prepare_lod(&mut self) { + let enabled = self.settings.horizon.lod_distance > 0 + && self.dim != Dim::Nether + && self.renderer.is_some() + && self.player.is_some() + && self.title.is_none() + && (self.remote.is_none() || self.integrated.is_some()); + if !enabled { + if self.lod.is_some() || self.lod_source_attempted { + self.clear_lod(); + } + return; + } + if self.lod_source_attempted { + return; + } + self.lod_source_attempted = true; + let source = match &self.integrated { + Some(server) => server.call(|game| game.streaming.lod_source()), + None => Some(self.streaming.lod_source()), + }; + if let Some(source) = source { + self.lod = Some(horizon_client::lod::Lod::new( + source, + self.pack.context.clone(), + )); + self.lod_observe.extend(self.world.chunks.keys().copied()); + } + } fn update_world(&mut self) { if let Err(e) = self.poll_remote() { log::warn!("Horizon: {e}"); } + self.prepare_lod(); + if self.lod.is_some() { + for &((x, _, z), _, _) in &self.world.light_edits { + self.lod_observe.insert((x >> 4, z >> 4)); + } + } if let Some(p) = &self.player { self.streaming.center = ( (p.position.x.floor() as i32) >> 4, @@ -9108,6 +9169,21 @@ impl Game<'_> { } let (uploads, unloaded) = horizon_client::spans::time("streaming", || self.streaming.update(&mut self.world)); + if let Some(lod) = &mut self.lod { + self.lod_observe + .extend(uploads.iter().map(|(key, _)| (key.0, key.2))); + for chunk in &unloaded { + lod.observe(chunk, &self.res.facts); + self.lod_observe.remove(&(chunk.x, chunk.z)); + } + let observe: Vec<_> = self.lod_observe.iter().copied().take(2).collect(); + for key in observe { + self.lod_observe.remove(&key); + if let Some(chunk) = self.world.chunks.get(&key) { + lod.observe(chunk, &self.res.facts); + } + } + } let dirty: Vec<_> = unloaded .iter() .filter(|c| self.world.modified.remove(&(c.x, c.z))) @@ -9183,6 +9259,30 @@ impl Game<'_> { renderer.remove((c.x, sy, c.z)); } } + if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) { + let covered = renderer + .lod_detail_columns() + .filter(|&(x, z)| { + horizon_client::streaming::in_view_distance( + self.streaming.center, + self.streaming.radius, + x, + z, + ) + }) + .collect(); + for (key, mesh) in lod.update( + [player.position.x, player.position.y, player.position.z], + self.streaming.radius, + self.settings.horizon.lod_distance, + covered, + ) { + renderer.upload_lod(key, &mesh); + } + for key in lod.removed() { + renderer.remove_lod(key); + } + } } } } @@ -10040,6 +10140,9 @@ impl<'a> Game<'a> { screen_fx: Default::default(), world, streaming, + lod: None, + lod_source_attempted: false, + lod_observe: Default::default(), options, player: None, spawn: None, diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index cf7510065..9b5fc3bc6 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -20,6 +20,7 @@ const HELP: &[&str] = &[ "hotbar 1-9 select a hotbar slot", "give ITEM [COUNT] add items to the inventory", "render-distance N chunks, 2..64", + "lod-distance N far surface chunks, 0 disables, up to1024", "time TICKS set the time of day", "summon KIND [X Y Z] [baby] spawn a mob (in front of the player without a position)", "mobs [RADIUS] list mobs near the player with their AI state", @@ -368,6 +369,15 @@ impl Game<'_> { self.apply_settings(); ok() } + "lod-distance" => { + let n: u32 = arg(1)?.parse()?; + if n > 1024 { + return Err("LOD distance must be 0..1024".into()); + } + self.settings.horizon.lod_distance = n; + self.apply_settings(); + ok() + } "time" => { self.world.day_time = arg(1)?.parse()?; ok() @@ -699,6 +709,15 @@ impl Game<'_> { .map(|k| format!("{k:?}")) .collect(); physical_keys.sort(); + let lod = json!({ + "distance": self.settings.horizon.lod_distance, + "terrain_distance": self.terrain_distance(), + "source": if self.lod.is_none() { "none" } else if self.integrated.is_some() { "integrated" } else { "local" }, + "source_attempted": self.lod_source_attempted, + "active_tiles": self.lod.as_ref().map_or(0, |lod| lod.stats().0), + "cached_tiles": self.lod.as_ref().map_or(0, |lod| lod.stats().1), + "pending_observations": self.lod_observe.len(), + }); let mut status = json!({ "screen": self.screen_name(), "debug": { @@ -757,6 +776,7 @@ impl Game<'_> { .eye_position() .map(|e| self.shown_name_tags(glam::DVec3::from_array(e))), }); + status["lod"] = lod; status["physical_keys"] = json!(physical_keys); status } diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs index 0b95dd2ad..dad536282 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -170,6 +170,7 @@ impl Game<'_> { horizon_client::ui::load_metadata(root); lang::set(lang::Language::load(&[&root.to_path_buf()], &lang::code())); self.audio.reload(root); + self.clear_lod(); self.streaming.reload_resources(&mut self.world, context); self.pending_uploads.clear(); // New GPU textures: a renderer built from the reloaded resources; the diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index c2fab26db..7e8114444 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -258,6 +258,7 @@ impl Game<'_> { self.screen = Screen::Playing; self.title = None; self.dim = Dim::Overworld; + self.clear_lod(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -362,6 +363,7 @@ impl Game<'_> { self.border = Default::default(); self.screen = Screen::Playing; self.container = None; + self.clear_lod(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -595,6 +597,7 @@ impl Game<'_> { // A new ClientLevel: a new chunk storage, centred on 0, 0. r.chunk_center = (0, 0); } + self.clear_lod(); if let Some(renderer) = self.renderer.as_mut() { renderer.clear_sections(); } diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index 4ee10e6d2..fad4f7352 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -85,7 +85,7 @@ impl Game<'_> { (water & 255) as f32 / 255.0, ], biome, - render_distance_chunks: self.streaming.radius, + render_distance_chunks: self.terrain_distance(), cloud_range_chunks: self.settings.cloud_range, camera_y: camera.y, // level.getMinY(): the Nether and the End start at y 0. diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 4280efd4a..ff874136f 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -59,6 +59,7 @@ pub fn outline_vertices(edges: &[[f64; 6]], camera: glam::DVec3) -> Vec<[f32; 6] mod arena; mod java_stages; +mod lod; mod occlusion; mod pack_stages; pub mod panorama; @@ -115,6 +116,8 @@ pub struct Frame<'a> { pub sky: Sky, /// Render distance in blocks (fog end). pub distance: f32, + /// Full-detail terrain distance in blocks; distant LODs bypass the cave graph. + pub detail_distance: f32, /// `Camera.depthFar`: the far plane (`crate::camera::depth_far`). pub depth_far: f32, pub underwater: bool, @@ -322,6 +325,8 @@ pub struct Renderer { outline: wgpu::Buffer, depth: wgpu::TextureView, sections: resident::Resident, + lods: HashMap, + detail_columns: HashMap<(i32, i32), u32>, arena: arena::Arena, sorted_indices: arena::Arena, translucent_sorter: translucency::Sorter, @@ -333,6 +338,8 @@ pub struct Renderer { pub multi_draw: bool, /// Per-frame scratch, kept to avoid allocating every frame. visible: Vec, + visible_lods: Vec, + translucent_draws: Vec<(u64, usize, [u32; 5], (u32, Option))>, origins: Vec<[f32; 4]>, /// `DrawIndexedIndirectArgs` words: index count, instance count, first /// index, base vertex, first instance. @@ -530,6 +537,7 @@ impl Renderer { let vertices: u64 = self .sections .values() + .chain(self.lods.values().map(|tile| &tile.mesh)) .map(|s| u64::from(s.solid + s.translucent) * 4) .sum(); [self.arena.bytes(), vertices * stride] @@ -1746,6 +1754,8 @@ impl Renderer { outline, depth, sections: resident::Resident::default(), + lods: HashMap::new(), + detail_columns: HashMap::new(), arena, sorted_indices, translucent_sorter: translucency::Sorter::default(), @@ -1754,6 +1764,8 @@ impl Renderer { indirect_capacity: 1024, multi_draw, visible: Vec::new(), + visible_lods: Vec::new(), + translucent_draws: Vec::new(), origins: Vec::new(), draws: Vec::new(), draw_pages: Vec::new(), @@ -1921,11 +1933,22 @@ impl Renderer { } else { self.block_entities.insert(key, mesh.block_entities.clone()); } + self.release_section(key); + let section = self.upload_mesh(mesh); + if section.is_some() || (mesh.solid.is_empty() && mesh.translucent.is_empty()) { + *self.detail_columns.entry((key.0, key.2)).or_default() |= 1 << key.1; + } else if let Some(mask) = self.detail_columns.get_mut(&(key.0, key.2)) { + *mask &= !(1 << key.1); + } + if let Some(section) = section { + self.sections.insert(key, section); + } + } + fn upload_mesh(&mut self, mesh: &SectionMesh) -> Option { let solid = (mesh.solid.len() / 4) as u32; let translucent = (mesh.translucent.len() / 4) as u32; - self.release_section(key); if solid + translucent == 0 { - return; + return None; } let max = solid.max(translucent); if max > self.index_quads { @@ -1934,16 +1957,14 @@ impl Renderer { } let vertices = (mesh.solid.len() + mesh.translucent.len()) as u64; // With video and system memory both full, the section is not drawn. - let Some((page, start)) = self.arena.alloc(&self.device, &self.queue, vertices) else { - return; - }; + let (page, start) = self.arena.alloc(&self.device, &self.queue, vertices)?; let sorted_indices = if translucent > 0 { let indices = self.sorted_indices .alloc(&self.device, &self.queue, u64::from(translucent) * 6); if indices.is_none() { self.arena.release(page, start, vertices); - return; + return None; } indices } else { @@ -1961,25 +1982,22 @@ impl Renderer { ); } } - self.sections.insert( - key, - SectionGpu { - page, - start, - solid, - translucent, - faces: mesh.faces, - sort: translucency::SortState::new( - mesh.translucent - .as_chunks::<4>() - .0 - .iter() - .map(|q| translucency::quad_center(q[0].pos, q[2].pos)) - .collect(), - ), - sorted_indices, - }, - ); + Some(SectionGpu { + page, + start, + solid, + translucent, + faces: mesh.faces, + sort: translucency::SortState::new( + mesh.translucent + .as_chunks::<4>() + .0 + .iter() + .map(|q| translucency::quad_center(q[0].pos, q[2].pos)) + .collect(), + ), + sorted_indices, + }) } /// Draws `count` section draws from `first` with the arena and section /// origins bound: one indirect multi-draw, or a loop without it. @@ -2008,14 +2026,17 @@ impl Renderer { } fn release_section(&mut self, key: SectionKey) { if let Some(s) = self.sections.remove(key) { - if let Some((page, start)) = s.sorted_indices { - self.sorted_indices - .release(page, start, u64::from(s.translucent) * 6); - } - self.arena - .release(s.page, s.start, u64::from(s.solid + s.translucent) * 4); + self.release_mesh(s); } } + fn release_mesh(&mut self, s: SectionGpu) { + if let Some((page, start)) = s.sorted_indices { + self.sorted_indices + .release(page, start, u64::from(s.translucent) * 6); + } + self.arena + .release(s.page, s.start, u64::from(s.solid + s.translucent) * 4); + } /// Block-entity blocks of every meshed section (see `SectionMesh::block_entities`). pub fn block_entities(&self) -> impl Iterator { self.block_entities.values().flatten() @@ -2023,12 +2044,26 @@ impl Renderer { pub fn clear_sections(&mut self) { self.block_entities.clear(); self.sections.clear(); + self.lods.clear(); + self.detail_columns.clear(); self.arena.clear(); self.sorted_indices.clear(); self.translucency_cursor = 0; self.occlusion.clear(); } + pub fn lod_detail_columns(&self) -> impl Iterator + '_ { + let complete = (1u32 << (crate::chunk::HEIGHT / 16)) - 1; + self.detail_columns + .iter() + .filter_map(move |(&column, &mask)| (mask == complete).then_some(column)) + } pub fn remove(&mut self, key: SectionKey) { + if let Some(mask) = self.detail_columns.get_mut(&(key.0, key.2)) { + *mask &= !(1 << key.1); + if *mask == 0 { + self.detail_columns.remove(&(key.0, key.2)); + } + } self.block_entities.remove(&key); self.occlusion.remove(key); self.release_section(key); @@ -2395,7 +2430,7 @@ impl Renderer { ); let culling = !frame.title && frame.cave_culling; if culling { - let radius = (frame.distance / 16.0) as i32 + 2; + let radius = (frame.detail_distance / 16.0) as i32 + 2; self.occlusion.update(camera_section, radius); } let reachable = &self.occlusion; @@ -2403,14 +2438,26 @@ impl Renderer { visible.clear(); self.sections.visible( camera, - (frame.distance / 16.0) as i32, + (frame.detail_distance / 16.0) as i32, &view, |k| !culling || reachable.contains(k), &mut visible, ); - self.drawn_sections = visible.len(); - if visible.len() as u64 > self.instance_capacity { - self.instance_capacity = (visible.len() as u64).next_power_of_two(); + let mut visible_lods = std::mem::take(&mut self.visible_lods); + visible_lods.clear(); + if frame.title { + visible.clear(); + } else { + visible_lods.extend( + self.lods + .iter() + .filter_map(|(&key, tile)| tile.visible(key, camera, frame.distance, &view)), + ); + visible_lods.sort_unstable_by_key(|v| (v.distance, v.key)); + } + self.drawn_sections = visible.len() + visible_lods.len(); + if self.drawn_sections as u64 > self.instance_capacity { + self.instance_capacity = (self.drawn_sections as u64).next_power_of_two(); self.instances = self.device.create_buffer(&wgpu::BufferDescriptor { label: Some("Section origins"), size: self.instance_capacity * 16, @@ -2422,7 +2469,12 @@ impl Renderer { self.origins.extend( visible .iter() - .map(|v| [v.origin[0], v.origin[1], v.origin[2], 0.0]), + .map(|v| [v.origin[0], v.origin[1], v.origin[2], 0.0]) + .chain( + visible_lods + .iter() + .map(|v| [v.origin[0], v.origin[1], v.origin[2], 0.0]), + ), ); if !self.origins.is_empty() { self.uploads.buffer( @@ -2432,9 +2484,6 @@ impl Renderer { bytemuck::cast_slice(&self.origins), ); } - if frame.title { - visible.clear(); - } // Solid sections front to back, then translucent ones back to front, // as one list of indirect draws over the section arena. self.draws.clear(); @@ -2452,10 +2501,20 @@ impl Renderer { self.draw_pages.push((s.page, None)); }); } + for (i, v) in visible_lods.iter().enumerate() { + let s = &self.lods[&v.key].mesh; + s.faces.ranges(eye - Vec3::from(v.origin), |first, quads| { + let first = s.start + u64::from(first) * 4; + self.draws + .push([quads * 6, 1, 0, first as u32, (visible.len() + i) as u32]); + self.draw_pages.push((s.page, None)); + }); + } let solid_draws = self.draws.len() as u32; // LevelRenderer: nearby sections each frame, plus a rotating eighth // (at least 15) of the visible list. Cached views avoid needless sorts. - let count = visible.len(); + self.translucent_draws.clear(); + let count = visible.len() + visible_lods.len(); let budget = (count / 8).max(15).min(count); self.translucency_cursor %= count.max(1); for (i, v) in visible.iter().enumerate().rev() { @@ -2483,16 +2542,62 @@ impl Renderer { ); } let first = s.start + u64::from(s.solid) * 4; - self.draws.push([ - s.translucent * 6, - 1, - index_start as u32, - first as u32, - i as u32, - ]); - self.draw_pages.push((s.page, Some(index_page))); + self.translucent_draws.push(( + v.distance, + i, + [ + s.translucent * 6, + 1, + index_start as u32, + first as u32, + i as u32, + ], + (s.page, Some(index_page)), + )); } } + for (i, v) in visible_lods.iter().enumerate() { + let instance = visible.len() + i; + let tile = self.lods.get_mut(&v.key).expect("visible resident tile"); + let s = &mut tile.mesh; + if let Some((index_page, index_start)) = s.sorted_indices { + let scheduled = (instance + count - self.translucency_cursor) % count < budget; + if (!s.sort.is_sorted() || scheduled) + && let Some(indices) = s.sort.update_lod( + camera.to_array(), + v.key.origin(), + &mut self.translucent_sorter, + ) + { + self.uploads.buffer( + &mut encoder, + self.sorted_indices.buffer(index_page), + index_start * 4, + bytemuck::cast_slice(indices), + ); + } + let first = s.start + u64::from(s.solid) * 4; + self.translucent_draws.push(( + v.distance, + instance, + [ + s.translucent * 6, + 1, + index_start as u32, + first as u32, + instance as u32, + ], + (s.page, Some(index_page)), + )); + } + } + // Near water and distant water share one back-to-front draw order. + self.translucent_draws + .sort_unstable_by(|a, b| b.0.cmp(&a.0).then(a.1.cmp(&b.1))); + for &(_, _, draw, pages) in &self.translucent_draws { + self.draws.push(draw); + self.draw_pages.push(pages); + } self.translucency_cursor += budget; let translucent_draws = self.draws.len() as u32 - solid_draws; if self.multi_draw && !self.draws.is_empty() { @@ -3052,6 +3157,7 @@ impl Renderer { self.last_encode = started.elapsed().saturating_sub(self.last_wait); let _ = self.started; self.visible = visible; + self.visible_lods = visible_lods; Ok(true) } } diff --git a/crates/horizon-client/src/gfx/lod.rs b/crates/horizon-client/src/gfx/lod.rs new file mode 100644 index 000000000..43c01f6ae --- /dev/null +++ b/crates/horizon-client/src/gfx/lod.rs @@ -0,0 +1,142 @@ +//! Far meshes share the terrain arena and passes, with their actual bounds +//! rather than the 16³ boxes used by the near-section residency walk. +use super::{Frustum, Renderer, SectionGpu}; +use crate::{lod::TileKey, mesher::SectionMesh}; +use glam::{DVec3, Vec3}; + +pub(super) struct Tile { + pub mesh: SectionGpu, + bounds: Bounds, +} + +#[derive(Clone, Copy)] +struct Bounds { + min: Vec3, + max: Vec3, +} + +impl Bounds { + fn mesh(mesh: &SectionMesh) -> Option { + let mut positions = mesh + .solid + .iter() + .chain(&mesh.translucent) + .map(|v| Vec3::from(v.pos)); + let first = positions.next()?; + let mut bounds = Self { + min: first, + max: first, + }; + for pos in positions { + bounds.min = bounds.min.min(pos); + bounds.max = bounds.max.max(pos); + } + Some(bounds) + } + + fn visible(self, origin: DVec3, distance: f32, frustum: &Frustum) -> Option { + let min = origin + self.min.as_dvec3(); + let max = origin + self.max.as_dvec3(); + let nearest = DVec3::ZERO.clamp(min, max); + if nearest.x * nearest.x + nearest.z * nearest.z > f64::from(distance).powi(2) + || !frustum.intersects(min.as_vec3(), max.as_vec3()) + { + return None; + } + Some(((min + max) * 0.5).length_squared().to_bits()) + } +} + +pub(super) struct Visible { + pub key: TileKey, + pub distance: u64, + pub origin: [f32; 3], +} + +impl Tile { + pub fn visible( + &self, + key: TileKey, + camera: DVec3, + distance: f32, + frustum: &Frustum, + ) -> Option { + let origin = DVec3::from(key.origin().map(f64::from)) - camera; + Some(Visible { + key, + distance: self.bounds.visible(origin, distance, frustum)?, + origin: origin.as_vec3().to_array(), + }) + } +} + +impl Renderer { + pub fn resident_lods(&self) -> usize { + self.lods.len() + } + + pub fn upload_lod(&mut self, key: TileKey, mesh: &SectionMesh) { + self.remove_lod(key); + if let Some(bounds) = Bounds::mesh(mesh) + && let Some(mesh) = self.upload_mesh(mesh) + { + self.lods.insert(key, Tile { mesh, bounds }); + } + } + + pub fn remove_lod(&mut self, key: TileKey) { + if let Some(tile) = self.lods.remove(&key) { + self.release_mesh(tile.mesh); + } + } + + pub fn clear_lods(&mut self) { + for (_, tile) in std::mem::take(&mut self.lods) { + self.release_mesh(tile.mesh); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::mesher::TerrainVertex; + + #[test] + fn large_tile_bounds_include_water_and_do_not_cull_by_origin() { + let vertex = |pos| TerrainVertex { + pos, + uv: [0.0; 2], + layer: 0, + light: 0, + color: 0, + }; + let mesh = SectionMesh { + solid: vec![vertex([0.0, -64.0, 0.0]), vertex([1024.0, 100.0, 1024.0])], + translucent: vec![vertex([512.0, 120.0, 512.0])], + ..Default::default() + }; + let bounds = Bounds::mesh(&mesh).unwrap(); + assert_eq!(bounds.min, Vec3::new(0.0, -64.0, 0.0)); + assert_eq!(bounds.max, Vec3::new(1024.0, 120.0, 1024.0)); + let view = Frustum { + planes: super::super::frustum( + super::super::world_projection(70.0, 16.0 / 9.0, 8192.0) + * crate::camera::view_matrix(0.0, 0.0), + ), + }; + // The tile origin is farther than the range, but its far edge reaches + // the camera. Negative world origins therefore remain visible. + assert!( + bounds + .visible(DVec3::new(-1000.0, -80.0, -512.0), 256.0, &view) + .is_some() + ); + assert!( + bounds + .visible(DVec3::new(-2000.0, -80.0, -512.0), 256.0, &view) + .is_none() + ); + assert!(Bounds::mesh(&SectionMesh::default()).is_none()); + } +} diff --git a/crates/horizon-client/src/gfx/translucency.rs b/crates/horizon-client/src/gfx/translucency.rs index 927152a39..4c1ad6683 100644 --- a/crates/horizon-client/src/gfx/translucency.rs +++ b/crates/horizon-client/src/gfx/translucency.rs @@ -47,6 +47,25 @@ impl SortState { self.last.is_some() } + /// Large tiles cannot use the section viewpoint shortcut: the camera may + /// cross a quad's plane while remaining on the same side of the first 16³. + pub fn update_lod<'a>( + &mut self, + camera: [f64; 3], + origin: [i32; 3], + sorter: &'a mut Sorter, + ) -> Option<&'a [u32]> { + let block = camera.map(|v| v.floor() as i32); + if self.last.is_some_and(|(last, _)| last == block) { + return None; + } + self.last = Some((block, [0; 3])); + Some(sorter.sort( + &self.centers, + std::array::from_fn(|i| (camera[i] - f64::from(origin[i])) as f32), + )) + } + /// TranslucencyPointOfView and ResortTransparencyTask: diagonal views keep /// their ordering until the point of view changes; aligned views also /// resort on crossing a block boundary. Sub-block movement needs no upload. @@ -116,4 +135,28 @@ mod tests { .is_some() ); } + #[test] + fn large_tiles_resort_inside_the_same_section_viewpoint() { + let mut state = SortState::new(vec![[32.0, 0.0, 0.0], [96.0, 0.0, 0.0]]); + let mut sorter = Sorter::default(); + assert_eq!( + state + .update_lod([48.0, 20.0, 20.0], [0; 3], &mut sorter) + .unwrap()[0], + 4 + ); + assert!( + state + .update_lod([48.5, 20.0, 20.0], [0; 3], &mut sorter) + .is_none() + ); + // Both views have positive x/y/z signs relative to the first section, + // so the section-sized shortcut would incorrectly keep the old order. + assert_eq!( + state + .update_lod([80.0, 20.0, 20.0], [0; 3], &mut sorter) + .unwrap()[0], + 0 + ); + } } diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs index f10c6b3b3..0009fd0fa 100644 --- a/crates/horizon-client/src/graphics.rs +++ b/crates/horizon-client/src/graphics.rs @@ -115,6 +115,8 @@ pub enum Overlay { #[derive(Clone, Debug, PartialEq)] pub struct Graphics { pub preset: Preset, + /// Distant surface terrain range, in chunks; 0 disables LODs. + pub lod_distance: u32, /// Skip sections hidden behind closed ones (vanilla's occlusion graph). pub cave_culling: bool, /// Hide shared leaf and mangrove-root faces, reducing foliage density. @@ -152,6 +154,7 @@ impl Default for Graphics { fn default() -> Self { Self { preset: Preset::Custom, + lod_distance: 0, cave_culling: true, cull_leaves: false, entity_culling: false, @@ -197,6 +200,7 @@ impl Graphics { let number = |d: u32| value.parse().unwrap_or(d); match key.trim() { "preset" => g.preset = Preset::parse(value), + "lodDistance" => g.lod_distance = number(g.lod_distance).min(1024), "caveCulling" => g.cave_culling = flag(g.cave_culling), "cullLeaves" => g.cull_leaves = flag(g.cull_leaves), "entityCulling" => g.entity_culling = flag(g.entity_culling), @@ -234,8 +238,9 @@ impl Graphics { } pub fn serialize(&self) -> String { format!( - "preset:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nlevel:{}\nbatteryMode:{}\nshaderPack:{}\n", + "preset:{}\nlodDistance:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nlevel:{}\nbatteryMode:{}\nshaderPack:{}\n", self.preset.name(), + self.lod_distance, bool_text(self.cave_culling), bool_text(self.cull_leaves), bool_text(self.entity_culling), @@ -330,6 +335,7 @@ mod tests { fn round_trips() { let g = Graphics { preset: Preset::Balanced, + lod_distance: 256, cave_culling: false, cull_leaves: true, entity_culling: true, @@ -357,6 +363,19 @@ mod tests { ); } + #[test] + fn lod_distance_is_opt_in_and_bounded() { + assert_eq!(Graphics::default().lod_distance, 0); + for distance in [0, 64, 128, 256, 512, 1024] { + let g = Graphics::parse(&format!("lodDistance:{distance}\n")); + assert_eq!(g.lod_distance, distance); + assert_eq!(Graphics::parse(&g.serialize()), g); + } + assert_eq!(Graphics::parse("lodDistance:10000\n").lod_distance, 1024); + assert_eq!(Graphics::parse("lodDistance:-1\n").lod_distance, 0); + assert_eq!(Graphics::parse("lodDistance:invalid\n").lod_distance, 0); + } + #[test] fn battery_mode_only_lowers_the_frame_cap() { let mut g = Graphics::default(); diff --git a/crates/horizon-client/src/graphics_ui.rs b/crates/horizon-client/src/graphics_ui.rs index 745cd5d80..236dc8333 100644 --- a/crates/horizon-client/src/graphics_ui.rs +++ b/crates/horizon-client/src/graphics_ui.rs @@ -21,6 +21,7 @@ pub enum Level { #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum H { Preset, + LodDistance, CaveCulling, CullLeaves, EntityCulling, @@ -76,7 +77,12 @@ pub fn rows(level: Level) -> Vec { let render = v( Opt::RenderDistance, High, - "How far terrain is drawn, in chunks. The biggest lever on frame time.", + "Full-detail terrain range. LOD Distance can extend local worlds farther.", + ); + let lod = h( + H::LodDistance, + Medium, + "Coarse distant surface in local worlds; no extra simulation.", ); let fov = v( Opt::Fov, @@ -100,10 +106,11 @@ pub fn rows(level: Level) -> Vec { "Sets the options below together. Changing one makes it Custom.", ); match level { - Level::Simple => vec![preset, render, fov, fps, vsync, gui], + Level::Simple => vec![preset, render, lod, fov, fps, vsync, gui], Level::Advanced => vec![ Row::Header("Rendering"), render, + lod, v( Opt::SimulationDistance, Medium, @@ -311,6 +318,10 @@ impl H { let g = &s.horizon; match self { H::Preset => labelled("Preset", g.preset.label()), + H::LodDistance => match g.lod_distance { + 0 => labelled("LOD Distance", "Off"), + n => labelled("LOD Distance", format!("{n} chunks")), + }, H::CaveCulling => labelled("Cave Culling", on_off(g.cave_culling)), H::CullLeaves => labelled("Cull Leaves", on_off(g.cull_leaves)), H::EntityCulling => labelled("Entity Culling", on_off(g.entity_culling)), @@ -383,6 +394,9 @@ impl H { } let g = &mut s.horizon; match self { + H::LodDistance => { + g.lod_distance = step(&[0, 64, 128, 256, 512, 1024], g.lod_distance, back) + } H::CaveCulling => g.cave_culling = !g.cave_culling, H::CullLeaves => g.cull_leaves = !g.cull_leaves, H::EntityCulling => g.entity_culling = !g.entity_culling, @@ -467,6 +481,10 @@ impl Item { } pub fn label(self, s: &Settings) -> Text { match self { + Item::Vanilla(Opt::RenderDistance) if s.horizon.lod_distance > 0 => labelled( + "Full Detail Distance", + format!("{} chunks", s.render_distance), + ), Item::Vanilla(o) => o.label(s), Item::Horizon(h) => h.label(s), } @@ -923,6 +941,40 @@ mod tests { } } + #[test] + fn lod_distance_cycles_in_both_levels_without_changing_near_distance() { + let mut s = Settings::default(); + let item = Item::Horizon(H::LodDistance); + let near = s.render_distance; + assert_eq!(item.label(&s).plain(), "LOD Distance: Off"); + for level in [Level::Simple, Level::Advanced] { + let items: Vec<_> = rows(level) + .into_iter() + .filter_map(|row| match row { + Row::Setting(setting) => Some(setting.item), + Row::Header(_) => None, + }) + .collect(); + let render = items + .iter() + .position(|i| *i == Item::Vanilla(Opt::RenderDistance)) + .unwrap(); + assert_eq!(items[render + 1], item); + } + for distance in [64, 128, 256, 512, 1024, 0] { + item.cycle(&mut s, false, [854, 480]); + assert_eq!(s.horizon.lod_distance, distance); + assert_eq!(s.render_distance, near); + } + item.cycle(&mut s, true, [854, 480]); + assert_eq!(s.horizon.lod_distance, 1024); + assert_eq!(item.label(&s).plain(), "LOD Distance: 1024 chunks"); + assert_eq!( + Item::Vanilla(Opt::RenderDistance).label(&s).plain(), + format!("Full Detail Distance: {near} chunks") + ); + } + #[test] fn the_shader_pack_row_is_off_by_default_and_outside_presets() { let mut s = Settings::default(); diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 45e09a6a3..d1f5e64bd 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -100,6 +100,7 @@ pub mod landing; pub mod lang; pub mod level_loading; pub mod light; +pub mod lod; pub mod logging; pub mod menu; pub mod menu_blur; diff --git a/crates/horizon-client/src/lod.rs b/crates/horizon-client/src/lod.rs new file mode 100644 index 000000000..3d39c2639 --- /dev/null +++ b/crates/horizon-client/src/lod.rs @@ -0,0 +1,862 @@ +//! Bounded surface terrain for distances beyond the resident chunk area. +//! Far tiles never enter World, lighting, simulation or the section cave graph. +use crate::{ + blocks::{BlockFacts, Fluid}, + chunk::{Chunk, HEIGHT, MIN_Y}, + fast_hash::{FxHashMap, FxHashSet}, + mesher::{FaceGroups, SectionMesh, TerrainVertex}, + streaming::{LodSource, WorkerContext}, +}; +use horizon_core::position::BlockPos; +use horizon_world::registry::BlockStateId; +use std::{ + collections::VecDeque, + sync::{ + Arc, Condvar, Mutex, + atomic::{AtomicBool, Ordering}, + mpsc, + }, + thread, +}; + +const CELLS: usize = 16; +const MAX_SAVED: usize = 8192; +/// Top solid face and optional fluid face, in absolute block coordinates. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Surface { + pub height: i32, + pub state: BlockStateId, + pub water: Option<(i32, BlockStateId)>, + pub biome: u16, +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct TileKey { + pub x: i32, + pub z: i32, + pub level: u8, +} +impl TileKey { + pub fn size(self) -> i32 { + 64 << self.level + } + pub fn origin(self) -> [i32; 3] { + [self.x * self.size(), 0, self.z * self.size()] + } + fn children(self) -> [Self; 4] { + std::array::from_fn(|i| Self { + x: self.x * 2 + (i & 1) as i32, + z: self.z * 2 + (i >> 1) as i32, + level: self.level - 1, + }) + } + fn distance(self, camera: [i32; 2]) -> i32 { + let [x, _, z] = self.origin(); + (x - camera[0]) + .max(camera[0] - x - self.size()) + .max(z - camera[1]) + .max(camera[1] - z - self.size()) + .max(0) + } +} +#[derive(Default)] +struct Plan { + roots: Vec, + nodes: FxHashSet, + split: FxHashSet, +} +impl Plan { + fn new(camera: [i32; 2], detail: i32, distance: u32) -> Self { + let range = distance.min(1024) as i32 * 16; + let mut level = 0; + while (64 << level) < range { + level += 1; + } + let size = 64 << level; + let mut result = Self::default(); + for z in (camera[1] - range).div_euclid(size)..=(camera[1] + range).div_euclid(size) { + for x in (camera[0] - range).div_euclid(size)..=(camera[0] + range).div_euclid(size) { + let key = TileKey { x, z, level }; + result.roots.push(key); + result.visit(key, camera, detail, range); + } + } + result + } + fn visit(&mut self, key: TileKey, camera: [i32; 2], detail: i32, range: i32) { + if key.distance(camera) > range { + return; + } + self.nodes.insert(key); + // Inside the near area, stride4 divides chunk boundaries exactly. + if key.level > 0 && key.distance(camera) < (key.size() * 2).max(detail * 16 + 64) { + self.split.insert(key); + for child in key.children() { + self.visit(child, camera, detail, range); + } + } + } + fn select( + &self, + key: TileKey, + ready: &FxHashMap>>, + out: &mut Vec, + ) -> bool { + if !self.nodes.contains(&key) { + return true; + } + if self.split.contains(&key) { + let start = out.len(); + if key + .children() + .into_iter() + .all(|child| self.select(child, ready, out)) + { + return true; + } + if ready.contains_key(&key) { + out.truncate(start); + out.push(key); + return true; + } + // Keep any children already available while the parent is loading. + out.truncate(start); + for child in key.children() { + self.select(child, ready, out); + } + false + } else if ready.contains_key(&key) { + out.push(key); + true + } else { + false + } + } +} +struct Job { + key: TileKey, +} +struct Done { + key: TileKey, + samples: Vec>, +} +struct Shared { + jobs: Mutex>, + wake: Condvar, + stop: AtomicBool, +} +#[derive(Clone, Copy)] +struct Style { + layer: u16, + tint: i32, + translucent: bool, + light: u16, +} +/// One background worker and at most two outstanding sample jobs. Only the +/// current view's quadtree and a bounded set of visited summaries are retained. +pub struct Lod { + shared: Arc, + thread: Option>, + results: mpsc::Receiver, + context: Arc, + area: Option<([i32; 2], i32, u32)>, + plan: Plan, + pending: FxHashSet, + ready: FxHashMap>>, + active: FxHashSet, + dirty: FxHashSet, + removed: Vec, + covered: FxHashSet<(i32, i32)>, + covered_bounds: Option<[i32; 4]>, + saved: FxHashMap<(i32, i32), [Option; 16]>, + saved_order: VecDeque<(i32, i32)>, + styles: FxHashMap, +} +impl Lod { + pub fn new(source: Arc, context: Arc) -> Self { + let shared = Arc::new(Shared { + jobs: Mutex::new(VecDeque::new()), + wake: Condvar::new(), + stop: AtomicBool::new(false), + }); + let worker = shared.clone(); + let (tx, results) = mpsc::channel(); + let handle = thread::Builder::new() + .name("Far terrain".into()) + .spawn(move || { + let mut sampler = source.sampler(); + loop { + let job = { + let mut jobs = worker.jobs.lock().unwrap(); + while jobs.is_empty() && !worker.stop.load(Ordering::Relaxed) { + jobs = worker.wake.wait(jobs).unwrap(); + } + if worker.stop.load(Ordering::Relaxed) { + break; + } + jobs.pop_front().unwrap() + }; + let [x, _, z] = job.key.origin(); + let stride = job.key.size() / CELLS as i32; + let mut samples = Vec::with_capacity(CELLS * CELLS); + for dz in 0..CELLS { + if worker.stop.load(Ordering::Relaxed) { + break; + } + for dx in 0..CELLS { + samples.push( + sampler.sample(x + dx as i32 * stride, z + dz as i32 * stride), + ); + } + } + if tx + .send(Done { + key: job.key, + samples, + }) + .is_err() + { + break; + } + } + }) + .expect("far terrain worker"); + Self { + shared, + thread: Some(handle), + results, + context, + area: None, + plan: Plan::default(), + pending: FxHashSet::default(), + ready: FxHashMap::default(), + active: FxHashSet::default(), + dirty: FxHashSet::default(), + removed: Vec::new(), + covered: FxHashSet::default(), + covered_bounds: None, + saved: FxHashMap::default(), + saved_order: VecDeque::new(), + styles: FxHashMap::default(), + } + } + pub fn stats(&self) -> (usize, usize) { + (self.active.len(), self.ready.len()) + } + pub fn removed(&mut self) -> Vec { + std::mem::take(&mut self.removed) + } + pub fn invalidate_chunk(&mut self, x: i32, z: i32) { + for &key in &self.active { + let [ox, _, oz] = key.origin(); + if x * 16 < ox + key.size() + && (x + 1) * 16 > ox + && z * 16 < oz + key.size() + && (z + 1) * 16 > oz + { + self.dirty.insert(key); + } + } + } + /// Sample only sixteen columns, from current block storage (heightmaps can + /// be stale after edits). Memory stays bounded while exploring indefinitely. + pub fn observe(&mut self, chunk: &Chunk, facts: &BlockFacts) { + let values = std::array::from_fn(|i| { + let x = (i & 3) as i32 * 4; + let z = (i >> 2) as i32 * 4; + let mut water = None; + for y in (MIN_Y..MIN_Y + HEIGHT).rev() { + let state = BlockStateId(chunk.get(x, y, z)); + if facts.is_air(state) { + continue; + } + let f = facts.get(state); + if !matches!(f.fluid, Fluid::None) { + if water.is_none() { + water = Some((y + 1, state)); + } + } else if f.solid_render || f.name.ends_with("_leaves") { + return Some(Surface { + height: y + 1, + state, + water, + biome: chunk.biome(x, y, z), + }); + } + } + water.map(|(y, state)| Surface { + height: MIN_Y, + state: facts.air, + water: Some((y, state)), + biome: chunk.biome(x, y - 1, z), + }) + }); + let key = (chunk.x, chunk.z); + if self.saved.get(&key) == Some(&values) { + return; + } + if !self.saved.contains_key(&key) { + while self.saved.len() >= MAX_SAVED { + if let Some(old) = self.saved_order.pop_front() { + self.saved.remove(&old); + } + } + self.saved_order.push_back(key); + } + self.saved.insert(key, values); + self.invalidate_chunk(chunk.x, chunk.z); + } + pub fn update( + &mut self, + camera: [f64; 3], + detail: i32, + distance: u32, + covered: FxHashSet<(i32, i32)>, + ) -> Vec<(TileKey, SectionMesh)> { + let camera = [camera[0].floor() as i32, camera[2].floor() as i32]; + // Replan at chunk boundaries, not on every camera movement. + let area = ( + [camera[0].div_euclid(16), camera[1].div_euclid(16)], + detail, + distance, + ); + if self.area != Some(area) { + self.area = Some(area); + self.plan = Plan::new(camera, detail, distance); + self.ready.retain(|key, _| self.plan.nodes.contains(key)); + } + while let Ok(done) = self.results.try_recv() { + self.pending.remove(&done.key); + if self.plan.nodes.contains(&done.key) { + if done.samples.len() == CELLS * CELLS { + self.ready.insert(done.key, done.samples); + } + } + } + if self.covered != covered { + let changes: Vec<_> = self + .covered + .symmetric_difference(&covered) + .copied() + .collect(); + for (x, z) in changes { + self.invalidate_chunk(x, z); + } + self.covered_bounds = covered.iter().fold(None, |bounds, &(x, z)| { + Some(match bounds { + None => [x * 16, z * 16, (x + 1) * 16, (z + 1) * 16], + Some([x0, z0, x1, z1]) => [ + x0.min(x * 16), + z0.min(z * 16), + x1.max((x + 1) * 16), + z1.max((z + 1) * 16), + ], + }) + }); + self.covered = covered; + } + let mut selected = Vec::new(); + for &key in &self.plan.roots { + self.plan.select(key, &self.ready, &mut selected); + } + let next: FxHashSet<_> = selected.iter().copied().collect(); + self.removed.extend(self.active.difference(&next).copied()); + self.dirty.extend(next.difference(&self.active).copied()); + self.active = next; + self.dirty.retain(|key| self.active.contains(key)); + let keys: Vec<_> = self.dirty.drain().collect(); + let meshes = keys.into_iter().map(|key| (key, self.mesh(key))).collect(); + let mut wanted: Vec<_> = self + .plan + .nodes + .iter() + .copied() + .filter(|key| !self.ready.contains_key(key) && !self.pending.contains(key)) + .collect(); + // Coarse ancestors first: cover the horizon quickly, then refine. + wanted + .sort_unstable_by_key(|key| (std::cmp::Reverse(key.level), key.distance(camera), *key)); + let mut jobs = self.shared.jobs.lock().unwrap(); + for key in wanted + .into_iter() + .take(2usize.saturating_sub(self.pending.len())) + { + self.pending.insert(key); + jobs.push_back(Job { key }); + } + self.shared.wake.notify_one(); + meshes + } + fn style(&mut self, state: BlockStateId) -> Style { + if let Some(style) = self.styles.get(&state) { + return *style; + } + let registry = self.context.assets.registry; + let name = registry.state(state).map(|s| s.name.as_str()).unwrap_or(""); + let fluid = match name { + "minecraft:water" | "minecraft:bubble_column" => Some(("block/water_still", true, -2)), + "minecraft:lava" => Some(("block/lava_still", false, -1)), + _ => None, + }; + let style = if let Some((sprite, translucent, tint)) = fluid { + Style { + layer: self + .context + .assets + .sprite_layers + .get(sprite) + .or_else(|| { + self.context + .assets + .sprite_layers + .get(&format!("minecraft:{sprite}")) + }) + .copied() + .unwrap_or(0) as u16, + tint, + translucent, + light: 240 + | (self + .context + .tables + .facts(state) + .map_or(0, |f| u16::from(f.emission)) + * 16 + << 8), + } + } else { + let models = self + .context + .assets + .model_catalog + .collect(state, BlockPos::new(0, 0, 0)) + .ok(); + let face = models.as_ref().and_then(|m| { + m.iter() + .flat_map(|(_, m)| &m.faces) + .find(|f| f.quad.facing == horizon_assets::model::Direction::Up) + }); + Style { + layer: face.map_or(0, |f| f.layer as u16), + tint: if face.is_some_and(|f| f.quad.tint_index >= 0) { + if name.contains("leaves") { -3 } else { 0 } + } else { + -1 + }, + translucent: face.is_some_and(|f| f.translucent), + light: 240 + | (self + .context + .tables + .facts(state) + .map_or(0, |f| u16::from(f.emission)) + * 16 + << 8), + } + }; + self.styles.insert(state, style); + style + } + fn mesh(&mut self, key: TileKey) -> SectionMesh { + let mut mesh = SectionMesh::default(); + let stride = key.size() / CELLS as i32; + let [ox, _, oz] = key.origin(); + let mut samples = self.ready[&key].clone(); + for z in 0..CELLS { + for x in 0..CELLS { + let (wx, wz) = (ox + x as i32 * stride, oz + z as i32 * stride); + if let Some(saved) = self.saved.get(&(wx.div_euclid(16), wz.div_euclid(16))) { + samples[z * CELLS + x] = + saved[((wz.rem_euclid(16) / 4) * 4 + wx.rem_euclid(16) / 4) as usize]; + } + } + } + for z in 0..CELLS { + for x in 0..CELLS { + let (wx, wz) = (ox + x as i32 * stride, oz + z as i32 * stride); + let Some(sample) = samples[z * CELLS + x] else { + continue; + }; + // Only fine cells overlap near chunks; coarse parent fallbacks + // also clip individual chunk-sized pieces while children load. + let overlaps = self.covered_bounds.is_some_and(|[x0, z0, x1, z1]| { + wx < x1 && wx + stride > x0 && wz < z1 && wz + stride > z0 + }); + let step = if overlaps { stride.min(16) } else { stride }; + for dz in (0..stride).step_by(step as usize) { + for dx in (0..stride).step_by(step as usize) { + if self + .covered + .contains(&((wx + dx).div_euclid(16), (wz + dz).div_euclid(16))) + { + continue; + } + let (x0, z0, x1, z1) = ( + (x as i32 * stride + dx) as f32, + (z as i32 * stride + dz) as f32, + (x as i32 * stride + dx + step) as f32, + (z as i32 * stride + dz + step) as f32, + ); + let y = sample.height as f32; + if y > MIN_Y as f32 { + let style = self.style(sample.state); + let color = self.color(style, sample.biome); + quad( + &mut mesh, + style, + color, + [[x0, y, z1], [x1, y, z1], [x1, y, z0], [x0, y, z0]], + 1.0, + ); + for (nx, nz, cell_edge, neighbor, points, shade) in [ + ( + x as i32 - 1, + z as i32, + dx == 0, + [wx + dx - 1, wz + dz], + [[x0, y, z0], [x0, y, z1], [x0, 0.0, z1], [x0, 0.0, z0]], + 0.6, + ), + ( + x as i32 + 1, + z as i32, + dx + step == stride, + [wx + dx + step, wz + dz], + [[x1, y, z1], [x1, y, z0], [x1, 0.0, z0], [x1, 0.0, z1]], + 0.6, + ), + ( + x as i32, + z as i32 - 1, + dz == 0, + [wx + dx, wz + dz - 1], + [[x1, y, z0], [x0, y, z0], [x0, 0.0, z0], [x1, 0.0, z0]], + 0.8, + ), + ( + x as i32, + z as i32 + 1, + dz + step == stride, + [wx + dx, wz + dz + step], + [[x0, y, z1], [x1, y, z1], [x1, 0.0, z1], [x0, 0.0, z1]], + 0.8, + ), + ] { + let cut_edge = self.covered.contains(&( + neighbor[0].div_euclid(16), + neighbor[1].div_euclid(16), + )); + let floor = if cut_edge { + // Near terrain may be below the coarse top; + // close the cut instead of exposing its underside. + MIN_Y + } else if !cell_edge { + continue; + } else if (0..CELLS as i32).contains(&nx) + && (0..CELLS as i32).contains(&nz) + { + samples[(nz as usize) * CELLS + nx as usize] + .map_or(MIN_Y, |s| s.height) + } else { + MIN_Y + }; + if floor < sample.height { + let mut p = points; + p[2][1] = floor as f32; + p[3][1] = floor as f32; + p.reverse(); + quad(&mut mesh, style, color, p, shade); + } + } + } + if let Some((height, state)) = sample.water { + let style = self.style(state); + let color = self.color(style, sample.biome); + let y = height as f32 - 1.0 / 9.0; + quad( + &mut mesh, + style, + color, + [[x0, y, z1], [x1, y, z1], [x1, y, z0], [x0, y, z0]], + 1.0, + ); + } + } + } + } + } + mesh.faces = FaceGroups::group(&mut mesh.solid); + mesh + } + fn color(&self, style: Style, biome: u16) -> u32 { + let b = self.context.biomes.get(biome); + match style.tint { + -2 => b.water, + -3 => b.foliage, + 0 => b.grass, + _ => 0xffffff, + } + } +} +fn quad(mesh: &mut SectionMesh, style: Style, color: u32, points: [[f32; 3]; 4], shade: f32) { + let channel = |shift: u32| (((color >> shift) & 255u32) as f32 * shade) as u32; + let color = channel(16) | (channel(8) << 8) | (channel(0) << 16) | 0xff000000; + let out = if style.translucent { + &mut mesh.translucent + } else { + &mut mesh.solid + }; + out.extend( + points + .into_iter() + .zip([[0., 1.], [1., 1.], [1., 0.], [0., 0.]]) + .map(|(pos, uv)| TerrainVertex { + pos, + uv, + layer: style.layer, + light: style.light, + color, + }), + ); +} +impl Drop for Lod { + fn drop(&mut self) { + self.shared.stop.store(true, Ordering::Relaxed); + self.shared.wake.notify_one(); + if let Some(thread) = self.thread.take() { + let _ = thread.join(); + } + } +} +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn far_plan_is_bounded_and_near_tiles_align_with_chunks() { + for camera in [[0, 0], [-1, -17], [1023, -4097]] { + for distance in [64, 256, 1024] { + let plan = Plan::new(camera, 12, distance); + assert!(plan.nodes.len() < 2500, "{} nodes", plan.nodes.len()); + for key in &plan.nodes { + if !plan.split.contains(key) && key.distance(camera) < 12 * 16 { + assert_eq!(key.level, 0); + } + } + let cells = plan + .nodes + .iter() + .filter(|k| !plan.split.contains(k)) + .count(); + assert!(cells < 2000); + } + } + assert_eq!( + TileKey { + x: -1, + z: -2, + level: 1 + } + .origin(), + [-128, 0, -256] + ); + } + #[test] + fn parent_covers_missing_children_then_retires_without_overlap() { + let parent = TileKey { + x: -1, + z: 0, + level: 1, + }; + let mut plan = Plan::default(); + plan.roots.push(parent); + plan.nodes.insert(parent); + plan.split.insert(parent); + plan.nodes.extend(parent.children()); + let mut ready = FxHashMap::default(); + ready.insert(parent, vec![]); + ready.insert(parent.children()[0], vec![]); + let mut selected = Vec::new(); + assert!(plan.select(parent, &ready, &mut selected)); + assert_eq!(selected, [parent]); + for child in parent.children() { + ready.insert(child, vec![]); + } + selected.clear(); + assert!(plan.select(parent, &ready, &mut selected)); + assert_eq!(selected, parent.children()); + } + #[test] + fn coarse_quad_keeps_winding_light_and_transparency() { + let mut mesh = SectionMesh::default(); + let style = Style { + layer: 7, + tint: -1, + translucent: true, + light: 240, + }; + quad( + &mut mesh, + style, + 0x123456, + [ + [0., 70., 64.], + [64., 70., 64.], + [64., 70., 0.], + [0., 70., 0.], + ], + 1., + ); + assert!(mesh.solid.is_empty()); + assert_eq!(mesh.translucent.len(), 4); + assert_eq!(mesh.translucent[0].color, 0xff563412); + let q = &mesh.translucent; + assert!( + (glam::Vec3::from(q[1].pos) - glam::Vec3::from(q[0].pos)) + .cross(glam::Vec3::from(q[2].pos) - glam::Vec3::from(q[0].pos)) + .y + > 0. + ); + } + #[test] + #[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"] + fn real_mesh_clips_near_chunks_and_preserves_water_and_edited_surfaces() -> crate::Result<()> { + use crate::{ + assets::Assets, biome::Biomes, light::LightTables, mesher::MeshTables, + testgen::TestTerrain, + }; + let root = std::path::PathBuf::from( + std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"), + ); + let assets = Arc::new(Assets::load(&root)?); + let facts = BlockFacts::load(&root, assets.registry)?; + let biomes = Arc::new(Biomes::load(&root)?); + let tables = Arc::new(MeshTables::new( + &assets, + &facts, + crate::models::load_visibility(&root, assets.registry)?, + )?); + let context = Arc::new(WorkerContext { + light: Arc::new(LightTables::load(&root, assets.registry, &facts)?), + tables, + assets: assets.clone(), + biomes: biomes.clone(), + }); + let source = Arc::new(TestTerrain::new(assets.registry, &biomes)?); + let mut lod = Lod::new(source, context); + let stone = assets.registry.default_state("minecraft:stone").unwrap(); + let water = assets.registry.default_state("minecraft:water").unwrap(); + let key = TileKey { + x: -1, + z: -1, + level: 3, + }; + lod.ready.insert( + key, + vec![ + Some(Surface { + height: 70, + state: stone, + water: Some((80, water)), + biome: biomes.id("minecraft:plains"), + }); + CELLS * CELLS + ], + ); + // A chunk covers only one quarter of this parent's 32² cell. Both + // opaque terrain and water must leave precisely that 16² footprint. + lod.covered.insert((-1, -2)); + lod.covered_bounds = Some([-16, -32, 0, -16]); + let mesh = lod.mesh(key); + let top_area = |vertices: &[TerrainVertex], y: f32| { + vertices + .as_chunks::<4>() + .0 + .iter() + .filter(|quad| quad.iter().all(|v| (v.pos[1] - y).abs() < 0.001)) + .map(|quad| { + let a = glam::Vec3::from(quad[0].pos); + let b = glam::Vec3::from(quad[1].pos); + let c = glam::Vec3::from(quad[2].pos); + let normal = (b - a).cross(c - a); + assert!(normal.y > 0.0, "surface must face the camera from above"); + let center = (a + c) * 0.5; + let [ox, _, oz] = key.origin(); + let chunk = ( + ((center.x as i32) + ox).div_euclid(16), + ((center.z as i32) + oz).div_euclid(16), + ); + assert!( + !lod.covered.contains(&chunk), + "LOD overlaps a full-detail chunk" + ); + normal.y + }) + .sum::() + }; + let expected = (key.size() * key.size() - 16 * 16) as f32; + assert_eq!(top_area(&mesh.solid, 70.0), expected); + assert_eq!(top_area(&mesh.translucent, 80.0 - 1.0 / 9.0), expected); + assert_eq!( + mesh.faces.quads.iter().sum::() as usize, + mesh.solid.len() / 4 + ); + assert!(mesh.translucent.iter().all(|v| v.light == 240)); + let side = |axis: usize, plane: f32, low: f32, high: f32| { + let other = if axis == 0 { 2 } else { 0 }; + mesh.solid + .as_chunks::<4>() + .0 + .iter() + .filter(|quad| { + quad.iter().all(|v| v.pos[axis] == plane) + && quad.iter().map(|v| v.pos[1]).fold(f32::INFINITY, f32::min) + == MIN_Y as f32 + && quad + .iter() + .map(|v| v.pos[1]) + .fold(f32::NEG_INFINITY, f32::max) + == 70.0 + && quad + .iter() + .map(|v| v.pos[other]) + .fold(f32::INFINITY, f32::min) + == low + && quad + .iter() + .map(|v| v.pos[other]) + .fold(f32::NEG_INFINITY, f32::max) + == high + }) + .map(move |quad| { + let a = glam::Vec3::from(quad[0].pos); + (glam::Vec3::from(quad[1].pos) - a).cross(glam::Vec3::from(quad[2].pos) - a) + [axis] + }) + .collect::>() + }; + // The two exposed edges face the missing full-detail chunk and seal + // the height mismatch all the way down. Shared subpieces add no walls. + let east_cut = side(0, 496.0, 480.0, 496.0); + assert_eq!(east_cut.len(), 1); + assert!(east_cut[0] > 0.0); + let north_cut = side(2, 496.0, 496.0, 512.0); + assert_eq!(north_cut.len(), 1); + assert!(north_cut[0] < 0.0); + assert!(side(0, 496.0, 496.0, 512.0).is_empty()); + + // Block edits do not refresh Chunk.heights; observation must scan the + // actual blocks, including builds above the old heightmap. + let mut chunk = Chunk::empty(-1, -1); + chunk.set(0, 120, 0, stone.0); + chunk.set(4, 54, 4, stone.0); + for y in 55..64 { + chunk.set(4, y, 4, water.0); + } + lod.observe(&chunk, &facts); + let observed = &lod.saved[&(-1, -1)]; + assert_eq!(observed[0].unwrap().height, 121); + assert_eq!(observed[0].unwrap().state, stone); + assert_eq!(observed[5].unwrap().height, 55); + assert_eq!(observed[5].unwrap().water, Some((64, water))); + Ok(()) + } +} diff --git a/crates/horizon-client/src/mesher/facing.rs b/crates/horizon-client/src/mesher/facing.rs index 2a7f0ba61..b27e59e29 100644 --- a/crates/horizon-client/src/mesher/facing.rs +++ b/crates/horizon-client/src/mesher/facing.rs @@ -42,6 +42,11 @@ impl Default for FaceGroups { } impl FaceGroups { + /// Group arbitrary-sized terrain quads, including distant LOD tiles. + pub fn group(solid: &mut Vec) -> Self { + group(solid) + } + /// Whether group `g` can hold a front-facing quad for an eye at `eye`, /// relative to the section's minimum corner. pub fn visible(&self, g: usize, eye: Vec3) -> bool { diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 7ef38788b..6adb69de6 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -29,7 +29,7 @@ use horizon_world::{ chunk::BlockState, chunk_status::ChunkStatus, compression::Compression, - heightmap::{Heightmap, HeightmapChunk, HeightmapType}, + heightmap::{Heightmap, HeightmapChunk, HeightmapState, HeightmapType}, nbt::{self, Compound, JavaString, Limits, NamedTag, Tag}, region::{ChunkRecord, RegionFile, RegionWriter}, registry::{BlockRegistry, BlockStateId}, @@ -2783,11 +2783,188 @@ pub struct Persistent { pub registry: Arc, pub biomes: Arc, } +type LodSurfaces = [Option; 16]; +struct SavedLodSampler { + generator: Arc>, + inner: Box, + cache: std::collections::VecDeque<((i32, i32), Option)>, +} +impl crate::streaming::LodSampler for SavedLodSampler { + fn sample(&mut self, x: i32, z: i32) -> Option { + let key = (x >> 4, z >> 4); + let cached = match self.cache.iter().position(|(at, _)| *at == key) { + Some(index) => self.cache.remove(index).unwrap(), + None => { + let surfaces = self.generator.save.lod_surfaces( + key.0, + key.1, + &self.generator.registry, + &self.generator.biomes, + ); + (key, surfaces) + } + }; + let surfaces = cached.1; + self.cache.push_front(cached); + self.cache.truncate(128); + match surfaces { + Some(surfaces) => surfaces[((z & 15) / 4 * 4 + (x & 15) / 4) as usize], + None => self.inner.sample(x, z), + } + } +} + +/// Read one palette entry without expanding the other entries in the section. +fn lod_palette_entry( + container: &Tag, + index: usize, + entries: usize, + minimum_bits: u32, +) -> Option<&Tag> { + let Tag::List(palette) = container.get("palette")? else { + return None; + }; + if palette.is_empty() || palette.len() > entries || index >= entries { + return None; + } + if palette.len() == 1 { + return palette.first(); + } + let bits = (usize::BITS - (palette.len() - 1).leading_zeros()).max(minimum_bits); + let per_word = 64 / bits as usize; + let Tag::LongArray(data) = container.get("data")? else { + return None; + }; + if data.len() != entries.div_ceil(per_word) { + return None; + } + let value = ((data[index / per_word] as u64 >> ((index % per_word) * bits as usize)) + & ((1 << bits) - 1)) as usize; + palette.get(value) +} +fn decode_lod_surfaces( + root: &NamedTag, + assets: &crate::assets::Assets, + biomes: &Biomes, +) -> Option { + let Tag::List(sections) = root.tag.get("sections")? else { + return None; + }; + let mut sections: Vec<_> = sections + .iter() + .filter_map(|section| { + let y = number(section.get("Y"))? as i32; + (MIN_Y >> 4..(MIN_Y >> 4) + SECTIONS as i32) + .contains(&y) + .then_some((y, section)) + }) + .collect(); + sections.sort_unstable_by_key(|(y, _)| std::cmp::Reverse(*y)); + let mut surfaces = [None; 16]; + let mut water = [None; 16]; + let mut states = BTreeMap::new(); + for (section_y, section) in sections { + let Some(blocks) = section.get("block_states") else { + continue; + }; + for z in (0..16).step_by(4) { + for x in (0..16).step_by(4) { + let cell = z / 4 * 4 + x / 4; + if surfaces[cell].is_some() { + continue; + } + for y in (0..16).rev() { + let entry = lod_palette_entry(blocks, y * 256 + z * 16 + x, 4096, 4)?; + let descriptor = BlockState::from_nbt(entry).ok()?; + let state = *states.entry(descriptor.clone()).or_insert_with(|| { + assets + .registry + .id(&descriptor) + .or_else(|| assets.registry.default_state(&descriptor.name)) + }); + let Some(state) = state else { + continue; + }; + let properties = assets.properties.heightmap_state(state); + if properties.is_air() { + continue; + } + let height = section_y * 16 + y as i32 + 1; + if matches!( + descriptor.name.as_str(), + "minecraft:water" | "minecraft:lava" + ) { + water[cell].get_or_insert((height, state)); + continue; + } + if !properties.blocks_motion_in_heightmap() { + continue; + } + let biome = section + .get("biomes") + .and_then(|container| { + lod_palette_entry(container, (y / 4) * 16 + (z / 4) * 4 + x / 4, 64, 1) + }) + .and_then(|tag| match tag { + Tag::String(name) => Some(biomes.id(&name.to_string_lossy())), + _ => None, + }) + .unwrap_or(0); + surfaces[cell] = Some(crate::lod::Surface { + height, + state, + water: water[cell], + biome, + }); + break; + } + } + } + } + Some(surfaces) +} +impl SaveDir { + fn lod_surfaces( + &self, + x: i32, + z: i32, + assets: &crate::assets::Assets, + biomes: &Biomes, + ) -> Option { + let pending = self + .pending + .lock() + .ok()? + .get(&(false, x, z)) + .map(|(_, record)| record.clone()); + let root = if let Some(record) = pending { + record.tag().map(|tag| (*tag).clone())? + } else { + // Far-only reads must not populate the gameplay region cache across the whole view. + let mut region = RegionFile::open(self.region_path("region", x >> 5, z >> 5)).ok()?; + region + .read(ChunkPos::new(x, z)) + .ok()?? + .nbt(Limits::default()) + .ok()? + }; + decode_lod_surfaces(&root, assets, biomes) + } +} + impl ChunkGenerator for Persistent { type Worker = G::Worker; fn worker(&self) -> G::Worker { self.inner.worker() } + fn lod_sampler(self: Arc) -> Box { + let inner = ChunkGenerator::lod_sampler(self.inner.clone()); + Box::new(SavedLodSampler { + generator: self, + inner, + cache: Default::default(), + }) + } fn load(&self, x: i32, z: i32) -> Option { self.save .tables @@ -2799,6 +2976,10 @@ impl ChunkGenerator for Persistent { chunk.entities = self.save.load_entities(x, z); Some(chunk) } + fn lod_surface(&self, worker: &mut G::Worker, x: i32, z: i32) -> Option { + // Resident/visited summaries override this procedural fallback in the LOD cache. + self.inner.lod_surface(worker, x, z) + } fn prepare_loaded(&self, worker: &mut G::Worker, chunk: &Chunk) { self.inner.prepare_loaded(worker, chunk); } @@ -2857,6 +3038,52 @@ impl ChunkGenerator for Persistent { #[cfg(test)] mod tests { + #[test] + fn saved_far_surface_reads_builds_and_water_without_gameplay_chunks() { + let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES") else { + return; + }; + let root = PathBuf::from(root); + let assets = crate::assets::Assets::load(&root).expect("assets"); + let biomes = Biomes::load(&root).expect("biomes"); + let stone = assets.registry.default_state("minecraft:stone").unwrap(); + let water = assets.registry.default_state("minecraft:water").unwrap(); + let sand = assets.registry.default_state("minecraft:sand").unwrap(); + let mut chunk = Chunk::empty(-2, 3); + chunk.set(0, 109, 0, stone.0); + chunk.set(4, 54, 4, sand.0); + for y in 55..64 { + chunk.set(4, y, 4, water.0); + } + let mut saved = encode(&chunk, assets.registry, &biomes); + put( + &mut saved.tag, + "block_entities", + Tag::String("not decoded by far sampling".into()), + ); + let dir = std::env::temp_dir().join(format!("horizon-lod-save-{}", std::process::id())); + fs::create_dir_all(&dir).unwrap(); + let save = SaveDir::new(dir.clone()); + save.write_records("region", vec![((-2, 3), Some(saved))], true) + .unwrap(); + let reopened = SaveDir::new(dir.clone()); + let surfaces = reopened + .lod_surfaces(-2, 3, &assets, &biomes) + .expect("saved summary"); + assert_eq!(surfaces[0].unwrap().height, 110); + assert_eq!(surfaces[0].unwrap().state, stone); + let underwater = surfaces[5].unwrap(); + assert_eq!((underwater.height, underwater.state), (55, sand)); + assert_eq!(underwater.water, Some((64, water))); + assert!(surfaces[15].is_none(), "saved void stays empty"); + assert!( + reopened.regions.lock().unwrap().is_empty(), + "far reads do not grow gameplay region cache" + ); + drop((save, reopened)); + fs::remove_dir_all(dir).unwrap(); + } + #[test] fn save_batch_preserves_order_coordinates_and_ownership() { use crate::containers::BlockEntity; diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index 38fa33c7d..6453908c7 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -32,6 +32,25 @@ pub type Proto = Box; pub trait ChunkGenerator: Send + Sync + 'static { type Worker: Send + 'static; fn worker(&self) -> Self::Worker; + fn lod_sampler(self: Arc) -> Box + where + Self: Sized, + { + let worker = self.worker(); + Box::new(GeneratorSampler { + generator: self, + worker, + }) + } + /// An undecorated far-terrain column, without allocating gameplay chunks. + fn lod_surface( + &self, + _worker: &mut Self::Worker, + _x: i32, + _z: i32, + ) -> Option { + None + } /// A previously saved final chunk, bypassing generation. fn load(&self, _x: i32, _z: i32) -> Option { None @@ -63,8 +82,29 @@ pub trait ChunkGenerator: Send + Sync + 'static { /// neighbours' decoration is done, so it can't be generated again. fn save_finished(&self, _chunk: Chunk) {} } +/// Independent, thread-owned far-terrain sampling state. +pub trait LodSampler: Send { + fn sample(&mut self, x: i32, z: i32) -> Option; +} +pub trait LodSource: Send + Sync { + fn sampler(self: Arc) -> Box; +} +struct GeneratorSampler { + generator: Arc, + worker: G::Worker, +} +impl LodSampler for GeneratorSampler { + fn sample(&mut self, x: i32, z: i32) -> Option { + self.generator.lod_surface(&mut self.worker, x, z) + } +} +impl LodSource for G { + fn sampler(self: Arc) -> Box { + ChunkGenerator::lod_sampler(self) + } +} /// The generator's saving, for the streamer (which doesn't know its type). -trait Saves: Send + Sync { +trait Saves: LodSource { fn save_protos(&self, protos: &[&Proto]); fn save_finished(&self, chunk: Chunk); } @@ -486,6 +526,10 @@ impl Streaming { mesh: true, } } + /// Shares generation resources, but gives distant work its own worker state. + pub fn lod_source(&self) -> Arc { + self.saves.clone() + } /// Resource packs reloaded (`LevelRenderer.allChanged`): mesh with the new /// models and sprites, and rebuild every loaded section. Meshes in flight /// were made with the old resources; their results are dropped. diff --git a/crates/horizon-client/src/testgen.rs b/crates/horizon-client/src/testgen.rs index 6268a8b6c..cded7ae47 100644 --- a/crates/horizon-client/src/testgen.rs +++ b/crates/horizon-client/src/testgen.rs @@ -64,6 +64,19 @@ fn hash(x: i32, z: i32) -> u32 { impl ChunkGenerator for TestTerrain { type Worker = (); fn worker(&self) {} + fn lod_surface(&self, _: &mut (), x: i32, z: i32) -> Option { + let h = Self::height(x, z); + Some(crate::lod::Surface { + height: h + 1, + state: horizon_world::registry::BlockStateId(if h <= 63 { + self.sand + } else { + self.grass + }), + water: (h < 62).then_some((63, horizon_world::registry::BlockStateId(self.water))), + biome: self.plains, + }) + } fn proto(&self, w: &mut (), x: i32, z: i32) -> crate::streaming::Proto { Box::new(self.generate(w, x, z)) } @@ -136,3 +149,38 @@ impl TestTerrain { chunk } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn far_surface_agrees_with_generated_land_and_water() { + let terrain = TestTerrain { + stone: 1, + dirt: 2, + grass: 3, + water: 4, + sand: 5, + bedrock: 6, + log: 7, + leaves: 8, + short_grass: 9, + plains: 10, + }; + let mut wet = false; + for (cx, cz) in [(0, 0), (-7, 3), (15, -12), (-21, -8)] { + let chunk = terrain.generate(&mut (), cx, cz); + for x in 0..16 { + let surface = terrain.lod_surface(&mut (), cx * 16 + x, cz * 16).unwrap(); + assert_eq!(chunk.get(x, surface.height - 1, 0), surface.state.0); + if let Some((height, state)) = surface.water { + wet = true; + assert_eq!(chunk.get(x, height - 1, 0), state.0); + assert_eq!(chunk.get(x, height, 0), 0); + } + } + } + assert!(wet, "fixture includes underwater land"); + } +} diff --git a/crates/horizon-client/src/vanillagen.rs b/crates/horizon-client/src/vanillagen.rs index 657817bb9..6d8aeaa4b 100644 --- a/crates/horizon-client/src/vanillagen.rs +++ b/crates/horizon-client/src/vanillagen.rs @@ -35,6 +35,7 @@ pub struct VanillaTerrain { tick_blocks: Vec, /// Block index -> default state id: `tick_blocks` the other way. tick_states: Vec, + lod_supported: bool, } /// A proto chunk, or the position of one whose generation failed. enum VanillaProto { @@ -106,6 +107,7 @@ impl VanillaTerrain { query: std::sync::Mutex::new(None), tick_blocks, tick_states, + lod_supported: dimension != "minecraft:the_nether", }) } /// A proto chunk's blocks, biomes, scheduled ticks and post-processing @@ -265,6 +267,27 @@ impl ChunkGenerator for VanillaTerrain { fn worker(&self) -> GeneratorWorker { self.generator.worker() } + fn lod_surface( + &self, + worker: &mut GeneratorWorker, + x: i32, + z: i32, + ) -> Option { + if !self.lod_supported { + return None; + } + let surface = worker.surface_sample(x, z)?; + Some(crate::lod::Surface { + height: surface.height, + state: surface.state, + water: surface.water, + biome: self + .biome_map + .get(surface.biome.0 as usize) + .copied() + .unwrap_or(0), + }) + } /// The structure starts a saved chunk references, as vanilla reads them /// with the chunk: built here, on the loading worker, into the /// generator's cache, rather than on the game thread the first time diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs index 12dfc10d9..41f5d424b 100644 --- a/crates/horizon-world/src/worldgen/generator.rs +++ b/crates/horizon-world/src/worldgen/generator.rs @@ -24,8 +24,8 @@ use super::{ decode_noise, density::DensityRegistry, material_condition::{ - MaterialConditionRegistry, MaterialRule, MaterialRuleError, MaterialRuleLibrary, - MaterialSurfaceQueries, + MaterialConditionRegistry, MaterialConditions, MaterialDensitySources, MaterialRule, + MaterialRuleError, MaterialRuleLibrary, MaterialSurfaceQueries, }, material_extensions::{ExtensionBlocks, ExtensionNoises, MaterialExtensions}, material_stage::{SurfaceInputs, TopMaterialInputs, build_surface}, @@ -1412,6 +1412,7 @@ trait SeededPipeline: Send + Sync { ) -> Result; fn data(&self) -> &Arc; fn sea_level(&self) -> i32; + fn surface_sample(&self, worker: &mut WorkerState, x: i32, z: i32) -> Option; fn structure_starts( &self, worker: &mut WorkerState, @@ -1594,6 +1595,69 @@ where } None } + fn surface_sample(&self, worker: &mut WorkerState, x: i32, z: i32) -> Option { + let mut top = None; + let mut water = None; + let mut below = 0; + self.noise_column(x, z, &mut |y, state| { + let properties = self.data.states.get(state); + if properties.is_air() || properties.has_fluid() { + if top.is_some() { + return true; + } + if properties.has_fluid() { + water.get_or_insert((y + 1, state)); + } else { + // Match the material traversal's water reset across air gaps. + water = None; + } + } else { + top.get_or_insert((y + 1, state)); + below += 1; + } + false + }); + let (height, state) = top?; + let y = height - 1; + let position = BlockPos::new(x, y, z); + let mut resolver = self.source.resolver( + &self.climate, + self.router.get(RouterField::Erosion).as_ref(), + ); + // Use a fresh bounded context: far samples must not grow the chunk/structure caches. + let mut biome_context = SamplerContext::default(); + let biome = resolver + .sample(&mut biome_context, self.zoom.quart_at_block(position)) + .ok()?; + let biome = self.data.biome_id(biome)?; + let volume = DensityVolume::new([1; 3], [x, y, z], [1; 3]).ok()?; + let queries = SurfaceQueries { + pipeline: self, + temperatures: &mut worker.temperatures, + biome: Biomes::Resolver(&mut resolver, &mut biome_context), + possible: None, + }; + let sources = MaterialDensitySources::new( + queries, + volume, + self.preliminary.clone(), + SamplerContext::default(), + ) + .ok()?; + let mut material = + MaterialConditions::::new(self.generation(), self.root.clone(), sources); + let rule = material.add_rule(self.rule.clone()).ok()?; + // shortcut: distant surfaces omit slope rules and column extensions; nearby chunks provide full terrain. + material.update_xz(x, z, 0, 0); + material.update_y(1, below, water.map_or(i32::MIN, |(height, _)| height), y); + let state = material.try_apply(rule, position).ok()?.unwrap_or(state); + Some(SurfaceSample { + height, + state, + water, + biome, + }) + } fn noise_biomes(&self, worker: &mut WorkerState, quarts: &[[i32; 3]]) -> Vec> { let mut resolver = self.source.resolver( &self.climate, @@ -1864,6 +1928,15 @@ impl OverworldGenerator { } } +/// A surface-only noise column for far terrain. Heights are exclusive top faces. +#[derive(Clone, Copy, Debug)] +pub struct SurfaceSample { + pub height: i32, + pub state: BlockStateId, + pub water: Option<(i32, BlockStateId)>, + pub biome: BiomeId, +} + /// Per-thread generation state. pub struct GeneratorWorker { pipeline: Arc, @@ -1877,6 +1950,10 @@ impl GeneratorWorker { self.state.timings.chunks += 1; result } + /// Noise/aquifer surface and its material rule, without chunks, structures or features. + pub fn surface_sample(&mut self, x: i32, z: i32) -> Option { + self.pipeline.surface_sample(&mut self.state, x, z) + } /// `/locate structure`: the nearest start of one of `names`. pub fn locate( &mut self, @@ -1935,6 +2012,44 @@ impl GeneratorWorker { mod tests { use super::*; + #[test] + fn far_surface_matches_undecorated_land_and_keeps_end_void() { + let root = std::env::var_os("HORIZON_TEST_RESOURCES") + .or_else(|| std::env::var_os("HORIZON_RESOURCES")) + .map(std::path::PathBuf::from) + .unwrap_or_else(|| { + Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3") + }); + if !root.join("worldgen/world_presets.json").exists() { + eprintln!("skipping: no worldgen bundle at {}", root.display()); + return; + } + let registry: &'static BlockRegistry = Box::leak(Box::new( + crate::level::data::load_registry(&root).expect("registry"), + )); + let data = GeneratorData::load(&root.join("worldgen"), registry).expect("worldgen data"); + let generator = + OverworldGenerator::without_structures(data.clone(), 1234).expect("generator"); + let mut worker = generator.worker(); + let sample = worker.surface_sample(0, 0).expect("land"); + let chunk = worker.generate_proto(ChunkPos::new(0, 0)).expect("terrain"); + assert_eq!( + sample.water.map_or(sample.height, |(height, _)| height), + chunk.surface_height(0, 0) + ); + assert_eq!(sample.state, chunk.block(0, sample.height - 1, 0)); + assert!( + sample.water.is_some(), + "fixture includes underwater terrain" + ); + let end = + OverworldGenerator::for_dimension(data, 1234, "minecraft:normal", "minecraft:the_end") + .expect("End generator"); + let mut worker = end.worker(); + assert!(worker.surface_sample(0, 0).is_some()); + assert!(worker.surface_sample(256, 0).is_none()); + } + /// Generators of one seed and dimension share their ring positions; /// another seed or generator gets its own, and old entries go. #[test] diff --git a/docs/graphics.md b/docs/graphics.md index a55313bea..727203646 100644 --- a/docs/graphics.md +++ b/docs/graphics.md @@ -4,7 +4,7 @@ In the Horizon menu style, the Options screen's **Video** section holds the graphics settings, with a Simple / Advanced switch at the top (remembered between sessions): -- **Simple**: a preset (Performance, Balanced, Quality, Ultra or Custom), render distance, FOV, max framerate, VSync and GUI scale. +- **Simple**: a preset (Performance, Balanced, Quality, Ultra or Custom), render distance, LOD distance, FOV, max framerate, VSync and GUI scale. - **Advanced**: every setting, grouped under Rendering, Quality, Display, Preferences, Performance and Overlay. In the Classic style, Video Settings starts with two buttons opening the same settings as vanilla-looking screens. @@ -17,7 +17,7 @@ Every row has a one-line description and its cost in frame time (none, low, medi | Group | Setting | Stored in | | --- | --- | --- | | Rendering | render distance, simulation distance, entity distance | `options.txt` (vanilla keys) | -| | cave culling, chunk updates per frame | `horizon-graphics.txt` | +| | LOD distance, cave culling, chunk updates per frame | `horizon-graphics.txt` | | Quality | smooth lighting, mipmap levels, biome blend, clouds, cloud distance, weather radius, particles, entity shadows, cutout leaves | `options.txt` | | | sky, fog, weather, animated textures | `horizon-graphics.txt` | | Display | FOV, max framerate, VSync, fullscreen, GUI scale | `options.txt` | @@ -31,7 +31,17 @@ Every row has a one-line description and its cost in frame time (none, low, medi Which settings each level shows, their descriptions and costs are in `crates/horizon-client/src/graphics_ui.rs` (`rows`); the Horizon shell draws them in `options_horizon.rs` with `ui_theme::described_row`, and the Classic screens use `graphics_style.rs`. -Not implemented: distant-terrain LOD, anisotropic filtering (wgpu needs linear magnification for it, which blurs close blocks), MSAA (FXAA instead) and exclusive fullscreen (fullscreen is borderless). +## Distant terrain + +**LOD Distance** is off by default. Enable it in Simple or Advanced graphics settings and choose 64, 128, 256, 512 or 1024 chunks. With LODs enabled, **Full Detail Distance** controls the nearby normal chunks; LOD Distance controls the outer view. Keep the nearby range modest, for example 12 chunks with a 256-chunk LOD distance. Increasing the distant range does not increase simulation distance. + +Distant terrain uses progressively coarser surface meshes, streamed in bounded background work instead of loading full chunks out to the distant range. It is available in local Overworld and End worlds; surface LODs are disabled in the Nether. Far samples approximate undecorated terrain: distant caves, decorations, structures and player builds are not guaranteed to match the nearby world. Procedural distant terrain requires a local world's generator; remote servers do not supply their world-generation seed. + +LOD terrain enters the existing world colour and depth passes, so supported shader-pack postprocessing can see it. This does not add Iris material passes or shadow maps: Java packs still have the [existing fullscreen-pass limitations](shader-packs.md). Shader appearance and transitions need testing with the selected pack. + +The setting is stored as `lodDistance` in `horizon-graphics.txt`; `0` disables it. Existing `renderDistance` in `options.txt` keeps its normal meaning for full chunks. + +Not implemented: anisotropic filtering (wgpu needs linear magnification for it, which blurs close blocks), MSAA (FXAA instead) and exclusive fullscreen (fullscreen is borderless). ## Benchmark From 594929b7956bf3ef5206ceff880c3e9049a88fc4 Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Sat, 17 Oct 2026 18:13:20 -0400 Subject: [PATCH 02/28] Validate LOD loading, shader depth and current terrain draw paths --- crates/horizon-client/src/game.rs | 1 + crates/horizon-client/src/lod.rs | 26 ++++++-------------------- docs/graphics.md | 2 +- 3 files changed, 8 insertions(+), 21 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 30d5c73c1..1151339a8 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -10694,6 +10694,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> { bob: glam::Mat4::IDENTITY, sky: horizon_client::environment::Sky::default(), distance: 12.0, + detail_distance: 12.0, depth_far: 1000.0, underwater: false, cave_culling: false, diff --git a/crates/horizon-client/src/lod.rs b/crates/horizon-client/src/lod.rs index 3d39c2639..59adc4e7e 100644 --- a/crates/horizon-client/src/lod.rs +++ b/crates/horizon-client/src/lod.rs @@ -326,10 +326,8 @@ impl Lod { } while let Ok(done) = self.results.try_recv() { self.pending.remove(&done.key); - if self.plan.nodes.contains(&done.key) { - if done.samples.len() == CELLS * CELLS { - self.ready.insert(done.key, done.samples); - } + if self.plan.nodes.contains(&done.key) && done.samples.len() == CELLS * CELLS { + self.ready.insert(done.key, done.samples); } } if self.covered != covered { @@ -397,6 +395,8 @@ impl Lod { "minecraft:lava" => Some(("block/lava_still", false, -1)), _ => None, }; + let light = + 240 | (u16::from(self.context.tables.facts(state).map_or(0, |f| f.emission)) << 12); let style = if let Some((sprite, translucent, tint)) = fluid { Style { layer: self @@ -414,14 +414,7 @@ impl Lod { .unwrap_or(0) as u16, tint, translucent, - light: 240 - | (self - .context - .tables - .facts(state) - .map_or(0, |f| u16::from(f.emission)) - * 16 - << 8), + light, } } else { let models = self @@ -443,14 +436,7 @@ impl Lod { -1 }, translucent: face.is_some_and(|f| f.translucent), - light: 240 - | (self - .context - .tables - .facts(state) - .map_or(0, |f| u16::from(f.emission)) - * 16 - << 8), + light, } }; self.styles.insert(state, style); diff --git a/docs/graphics.md b/docs/graphics.md index efd1dd00a..1d125a851 100644 --- a/docs/graphics.md +++ b/docs/graphics.md @@ -35,7 +35,7 @@ Which settings each level shows, their descriptions and costs are in `crates/hor **LOD Distance** is off by default. Enable it in Simple or Advanced graphics settings and choose 64, 128, 256, 512 or 1024 chunks. With LODs enabled, **Full Detail Distance** controls the nearby normal chunks; LOD Distance controls the outer view. Keep the nearby range modest, for example 12 chunks with a 256-chunk LOD distance. Increasing the distant range does not increase simulation distance. -Distant terrain uses progressively coarser surface meshes, streamed in bounded background work instead of loading full chunks out to the distant range. It is available in local Overworld and End worlds; surface LODs are disabled in the Nether. Far samples approximate undecorated terrain: distant caves, decorations, structures and player builds are not guaranteed to match the nearby world. Procedural distant terrain requires a local world's generator; remote servers do not supply their world-generation seed. +Distant terrain uses progressively coarser surface meshes, streamed in bounded background work instead of loading full chunks out to the distant range. It is available in local Overworld and End worlds; surface LODs are disabled in the Nether. Unknown terrain samples use noise/aquifer heights and surface materials, omitting caves, decorations, structures and slope-dependent extensions. Loaded and saved terrain supplies bounded surface summaries, including player edits; small details can disappear between samples. This is a surface approximation, not full block geometry. Procedural distant terrain requires a local world's generator; remote servers do not supply their world-generation seed. LOD terrain enters the existing world colour and depth passes, so supported shader-pack postprocessing can see it. This does not add Iris material passes or shadow maps: Java packs still have the [existing fullscreen-pass limitations](shader-packs.md). Shader appearance and transitions need testing with the selected pack. From ce77a4189d157747c9f1e250422c0c04342b251c Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Sun, 18 Oct 2026 02:26:03 +0100 Subject: [PATCH 03/28] Specialize unary density evaluation per bulk buffer --- crates/horizon-core/src/density/arithmetic.rs | 187 +- crates/horizon-core/src/density/tests.rs | 40 + docs/noise-aquifer-benchmark.md | 80 + noise-aquifer-results/.gitignore | 5 + noise-aquifer-results/bench.py | 40 + noise-aquifer-results/binary-hashes.txt | 2 + noise-aquifer-results/binary-size.txt | 3 + noise-aquifer-results/build_snapshots.py | 22 + noise-aquifer-results/candidate.patch | 264 + noise-aquifer-results/chunk-parity.json | 458 ++ noise-aquifer-results/chunkgen_profile.rs | 478 ++ noise-aquifer-results/chunkgen_snapshot.rs | 532 +++ noise-aquifer-results/core-final-tests.log | 105 + noise-aquifer-results/density-parity.json | 40 + noise-aquifer-results/environment.json | 14 + .../final-codegen-check.json | 21 + noise-aquifer-results/gate-raw.json | 530 +++ noise-aquifer-results/gate-summary.json | 42 + .../initial-shared-inline/binary-hashes.txt | 2 + .../initial-shared-inline/candidate.patch | 73 + .../initial-shared-inline/gate-raw.json | 530 +++ .../initial-shared-inline/gate-summary.json | 42 + noise-aquifer-results/loop-codegen.json | 30 + noise-aquifer-results/matrix-raw.json | 4226 +++++++++++++++++ noise-aquifer-results/matrix-summary.json | 322 ++ .../parity-binary-hashes.txt | 3 + noise-aquifer-results/reference-assessment.md | 14 + noise-aquifer-results/snapshot-accessor.patch | 15 + noise-aquifer-results/summarize.py | 38 + noise-aquifer-results/summary.json | 691 +++ noise-aquifer-results/summary.txt | 9 + noise-aquifer-results/symbols.json | 25 + noise-aquifer-results/terrain-parity.json | 424 ++ noise-aquifer-results/validate_chunks.py | 28 + noise-aquifer-results/validate_density.py | 33 + noise-aquifer-results/validate_terrain.py | 27 + noise-aquifer-results/workloads.json | 12 + noise-aquifer-results/world-final-tests.log | 137 + 38 files changed, 9538 insertions(+), 6 deletions(-) create mode 100644 docs/noise-aquifer-benchmark.md create mode 100644 noise-aquifer-results/.gitignore create mode 100644 noise-aquifer-results/bench.py create mode 100644 noise-aquifer-results/binary-hashes.txt create mode 100644 noise-aquifer-results/binary-size.txt create mode 100644 noise-aquifer-results/build_snapshots.py create mode 100644 noise-aquifer-results/candidate.patch create mode 100644 noise-aquifer-results/chunk-parity.json create mode 100644 noise-aquifer-results/chunkgen_profile.rs create mode 100644 noise-aquifer-results/chunkgen_snapshot.rs create mode 100644 noise-aquifer-results/core-final-tests.log create mode 100644 noise-aquifer-results/density-parity.json create mode 100644 noise-aquifer-results/environment.json create mode 100644 noise-aquifer-results/final-codegen-check.json create mode 100644 noise-aquifer-results/gate-raw.json create mode 100644 noise-aquifer-results/gate-summary.json create mode 100644 noise-aquifer-results/initial-shared-inline/binary-hashes.txt create mode 100644 noise-aquifer-results/initial-shared-inline/candidate.patch create mode 100644 noise-aquifer-results/initial-shared-inline/gate-raw.json create mode 100644 noise-aquifer-results/initial-shared-inline/gate-summary.json create mode 100644 noise-aquifer-results/loop-codegen.json create mode 100644 noise-aquifer-results/matrix-raw.json create mode 100644 noise-aquifer-results/matrix-summary.json create mode 100644 noise-aquifer-results/parity-binary-hashes.txt create mode 100644 noise-aquifer-results/reference-assessment.md create mode 100644 noise-aquifer-results/snapshot-accessor.patch create mode 100644 noise-aquifer-results/summarize.py create mode 100644 noise-aquifer-results/summary.json create mode 100644 noise-aquifer-results/summary.txt create mode 100644 noise-aquifer-results/symbols.json create mode 100644 noise-aquifer-results/terrain-parity.json create mode 100644 noise-aquifer-results/validate_chunks.py create mode 100644 noise-aquifer-results/validate_density.py create mode 100644 noise-aquifer-results/validate_terrain.py create mode 100644 noise-aquifer-results/workloads.json create mode 100644 noise-aquifer-results/world-final-tests.log diff --git a/crates/horizon-core/src/density/arithmetic.rs b/crates/horizon-core/src/density/arithmetic.rs index f82b96ce2..7961adf04 100644 --- a/crates/horizon-core/src/density/arithmetic.rs +++ b/crates/horizon-core/src/density/arithmetic.rs @@ -75,9 +75,12 @@ pub enum UnaryOp { max: f32, }, } -impl UnaryOp { - pub(super) fn apply(self, value: f32, bulk: bool) -> f32 { - match self { +// One expression definition for scalar dispatch and specialized bulk loops. +macro_rules! unary_apply { + ($operation:expr, $value:expr, $bulk:expr) => {{ + let value = $value; + let bulk = $bulk; + match $operation { Self::Abs => value.abs(), Self::Negate => -value, Self::Square => value * value, @@ -137,6 +140,85 @@ impl UnaryOp { } } } + }}; +} +impl UnaryOp { + pub(super) fn apply(self, value: f32, bulk: bool) -> f32 { + unary_apply!(self, value, bulk) + } + /// Dispatch once per volume so each loop has one fixed arithmetic operation. + /// Keep the scalar expression shared, including the bulk min/max behavior. + fn apply_bulk(self, buffer: &mut [f32]) { + // Specialization can reverse which NaN operand supplies the payload. + // Retain the original dispatch for non-finite constant operands. + let non_finite = match self { + Self::PowerBase(value) | Self::PowerExponent(value) => !value.is_finite(), + Self::LeakyRelu(value) + | Self::Add(value) + | Self::SubtractFrom(value) + | Self::Multiply(value) + | Self::DivideInto(value) + | Self::Minimum(value) + | Self::Maximum(value) => !value.is_finite(), + Self::Clamp { min, max } => !min.is_finite() || !max.is_finite(), + Self::ConstantRangeChoice { + min_inclusive, + max_exclusive, + inside, + outside, + } => { + !min_inclusive.is_finite() + || !max_exclusive.is_finite() + || !inside.is_finite() + || !outside.is_finite() + } + _ => false, + }; + if non_finite { + for value in buffer { + *value = self.apply(*value, true); + } + return; + } + macro_rules! apply { + ($operation:expr) => { + for value in buffer { + *value = unary_apply!($operation, *value, true); + } + }; + } + match self { + Self::Abs => apply!(Self::Abs), + Self::Negate => apply!(Self::Negate), + Self::Square => apply!(Self::Square), + Self::Cube => apply!(Self::Cube), + Self::Sqrt => apply!(Self::Sqrt), + Self::Log => apply!(Self::Log), + Self::PowerBase(base) => apply!(Self::PowerBase(base)), + Self::PowerExponent(exponent) => apply!(Self::PowerExponent(exponent)), + Self::Reciprocal => apply!(Self::Reciprocal), + Self::Sign => apply!(Self::Sign), + Self::Squeeze => apply!(Self::Squeeze), + Self::LeakyRelu(factor) => apply!(Self::LeakyRelu(factor)), + Self::Add(right) => apply!(Self::Add(right)), + Self::SubtractFrom(left) => apply!(Self::SubtractFrom(left)), + Self::Multiply(right) => apply!(Self::Multiply(right)), + Self::DivideInto(left) => apply!(Self::DivideInto(left)), + Self::Minimum(right) => apply!(Self::Minimum(right)), + Self::Maximum(right) => apply!(Self::Maximum(right)), + Self::ConstantRangeChoice { + min_inclusive, + max_exclusive, + inside, + outside, + } => apply!(Self::ConstantRangeChoice { + min_inclusive, + max_exclusive, + inside, + outside + }), + Self::Clamp { min, max } => apply!(Self::Clamp { min, max }), + } } } #[derive(Clone, Debug)] @@ -162,9 +244,7 @@ impl DensitySampler for UnarySampler { ) -> Result<(), SampleError> { check_buffer(buffer, volume)?; self.input.sample_volume(context, buffer, volume)?; - for value in buffer { - *value = self.operation.apply(*value, true); - } + self.operation.apply_bulk(buffer); Ok(()) } } @@ -246,3 +326,98 @@ impl DensitySampler for BinarySampler { }) } } + +#[cfg(test)] +mod bulk_tests { + use super::*; + + #[inline(never)] + fn dispatched_reference(operation: UnaryOp, value: f32) -> f32 { + operation.apply(value, true) + } + + #[test] + fn fixed_operation_loops_preserve_float_bits() { + let mut operations = vec![ + UnaryOp::Abs, + UnaryOp::Negate, + UnaryOp::Square, + UnaryOp::Cube, + UnaryOp::Sqrt, + UnaryOp::Log, + UnaryOp::Reciprocal, + UnaryOp::Sign, + UnaryOp::Squeeze, + ]; + for factor in [0.0, -0.0, 0.5, -1.0, f32::INFINITY, f32::NAN] { + operations.extend([ + UnaryOp::LeakyRelu(factor), + UnaryOp::Add(factor), + UnaryOp::SubtractFrom(factor), + UnaryOp::Multiply(factor), + UnaryOp::DivideInto(factor), + UnaryOp::Minimum(factor), + UnaryOp::Maximum(factor), + UnaryOp::Clamp { + min: -factor, + max: factor, + }, + UnaryOp::ConstantRangeChoice { + min_inclusive: -factor, + max_exclusive: factor, + inside: -0.0, + outside: 17.0, + }, + ]); + } + for exponent in [0.0, -0.0, 0.5, -1.0, 2.0, 3.0, f64::INFINITY, f64::NAN] { + operations.extend([ + UnaryOp::PowerBase(exponent), + UnaryOp::PowerExponent(exponent), + ]); + } + let mut values: Vec = [ + 0, + 0x8000_0000, + 1, + 0x8000_0001, + 0x007f_ffff, + 0x0080_0000, + 0x3f00_0000, + 0xbf00_0000, + 0x3f80_0000, + 0xbf80_0000, + 0x7f7f_ffff, + 0xff7f_ffff, + 0x7f80_0000, + 0xff80_0000, + 0x7fc0_0000, + 0x7fa0_0001, + 0xffc0_1234, + ] + .into_iter() + .map(f32::from_bits) + .collect(); + let mut bits = 0x484f_5249u32; + for _ in 0..4096 { + bits ^= bits << 13; + bits ^= bits >> 17; + bits ^= bits << 5; + values.push(f32::from_bits(bits)); + } + for operation in operations { + for length in [0, 1, 3, 16, 257, values.len()] { + let mut actual = values[..length].to_vec(); + operation.apply_bulk(&mut actual); + for (i, (&input, actual)) in values.iter().zip(actual).enumerate() { + let expected = dispatched_reference(operation, input); + assert_eq!( + actual.to_bits(), + expected.to_bits(), + "{operation:?}, index {i}, input {input:?}" + ); + } + } + } + } +} diff --git a/crates/horizon-core/src/density/tests.rs b/crates/horizon-core/src/density/tests.rs index 77a643097..f94b95356 100644 --- a/crates/horizon-core/src/density/tests.rs +++ b/crates/horizon-core/src/density/tests.rs @@ -755,3 +755,43 @@ fn spline_lazy_branch_failure_preserves_completed_output_and_returns_scratch() { assert_eq!(context.scratch.len(), 2); assert_eq!(sampler.sample_value(&mut context, [0; 3]), Ok(7.0)); } + +#[test] +fn unary_bulk_keeps_child_failure_writes_and_full_buffer_tail() { + #[derive(Debug)] + struct PartialInput; + impl DensitySampler for PartialInput { + fn sample_value(&self, _: &mut SamplerContext, _: [i32; 3]) -> Result { + Err(SampleError::ZeroGradientPeriod) + } + fn sample_volume( + &self, + _: &mut SamplerContext, + buffer: &mut [f32], + _: DensityVolume, + ) -> Result<(), SampleError> { + buffer[0] = -3.0; + Err(SampleError::ZeroGradientPeriod) + } + } + let volume = DensityVolume::new([1; 3], [0; 3], [1; 3]).unwrap(); + let mut context = SamplerContext::default(); + let mut buffer = [17.0; 3]; + let sampler = UnarySampler { + input: Arc::new(PartialInput), + operation: UnaryOp::Square, + }; + assert_eq!( + sampler.sample_volume(&mut context, &mut buffer, volume), + Err(SampleError::ZeroGradientPeriod) + ); + assert_eq!(buffer, [-3.0, 17.0, 17.0]); + let sampler = UnarySampler { + input: Arc::new(ConstantSampler(-3.0)), + operation: UnaryOp::Square, + }; + sampler + .sample_volume(&mut context, &mut buffer, volume) + .unwrap(); + assert_eq!(buffer, [9.0; 3]); +} diff --git a/docs/noise-aquifer-benchmark.md b/docs/noise-aquifer-benchmark.md new file mode 100644 index 000000000..080a0bcc5 --- /dev/null +++ b/docs/noise-aquifer-benchmark.md @@ -0,0 +1,80 @@ +# Bulk unary density evaluation benchmark + +**Qualification: yes for the representative initialized Overworld workloads.** One focused bulk density arithmetic change reduces whole-terrain wall time by 13.891% with one worker and 11.191% with four workers at the primary site. A predeclared second seed/site improves 13.657% and 13.701%. These are whole-region terrain elapsed / input chunk count, not stage-only or microbenchmark results. Terrain plus decoration also exceeds 5% at both Overworld sites and worker counts. Nether/End results are smaller and are reported below. + +Baseline: `e4f8154cb4115aa1ee622381d9b12387cdf515d4`. Candidate: that baseline plus `noise-aquifer-results/candidate.patch` (the scoped production change and its tests). Branch `t3/optimize-noise-aquifers`, isolated checkout `/home/bob/.t3/worktrees/horizon/t3-e477fa56` (physical `/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56`). No other checkout was changed. + +## Focus and feasibility + +The existing initialized profile attributed 18.09% terrain self CPU to unary density arithmetic. Inspection found an operation match and function call for each buffer element. The candidate dispatches once per bulk buffer, allowing fixed-operation loops and compiler vectorization. Scalar arithmetic retains its existing dispatch; all arithmetic expressions have one shared definition. Non-finite constant operands retain the original per-element path because specialization can select a different NaN operand payload. Sampling calls, child-failure propagation, complete buffer-tail transformation, floating-point expressions and buffer allocation remain the same. + +The requested reference was inspected on its oldest and newest supported source branches. Its direct palette write still maintains section counters and resolves/grows the palette. Horizon already bypasses several generic costs, while exact old-state/count and partial-write behavior still matters. A validated palette-token writer and dense palette construction were assessed as materially different designs; neither was rejected merely because an earlier small hash change failed. The profile provided a stronger focused opportunity in unary arithmetic, so no storage rewrite was attempted. See [reference mechanism and applicability](../noise-aquifer-results/reference-assessment.md) for pinned source links and details. + +This shared density kernel also accelerates bulk material-density preparation. At the primary one-worker site the noise bracket improves 5.772879 → 5.229395 ms/chunk (9.414%), while surface improves 4.467371 → 3.314584 (25.805%). The 13.891% whole-terrain result must not be described as a noise-only stage improvement. No surface rules, traversal, decoration, structures, scheduling or caches were edited. + +## Declared method + +Workloads were fixed in `noise-aquifer-results/workloads.json` before candidate editing: 16×16 terrain chunks (256), 14×14 decorated interior (196), seed 12345 / center (0,0), all three dimensions at one and four workers. The second Overworld site uses seed -1 / center (32,-32), also at one and four workers. Each initialized process first generates and discards the same offset 9×9 region at center+(64,64), using the same seeded generator, before timing starts; measured workers are newly created. This excludes initial ring work without pre-generating measured chunks. Initialization timings remain in the logs/summary. + +Each case has one discarded process pair, then five measured pairs alternating baseline/candidate order. Processes, builds and benchmarks were sequential. The cold one-worker Overworld case omits initialization and is reported separately. Wall timing is the diagnostic’s exact elapsed / 256 JSON field, never the thread-multiplied human display. Combined timing is (terrain elapsed + complete existing phased decoration elapsed) / 256, retaining identical border and stage work. Decoration duration comes from the unchanged diagnostic’s printed duration, with its original rounding. + +Machine: AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM, Linux 7.2.11-zen1-1-zen, Rust 1.99.0. `fast` inherits release with LTO disabled, 16 codegen units and incremental compilation; no extra Rust flags were set. Prepared 26.3 resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Reused Cargo target `/srv/bob-data/horizon-stage3d-target`, preserving its `fast` symlink to `/tmp/horizon-density-eval/fast-build`. Both baseline and candidate were freshly built and copied to private versioned executables. Desktop/background activity was not isolated. + +## All measured medians + +Values are baseline → candidate, ms per input terrain chunk; parentheses are percent reduction. Negative individual-pair reductions mean regressions. + +- **overworld, 1 worker(s), seed 12345, center (0, 0), initialized:** terrain 12.270935 → 10.566346 (13.891%); combined 14.202495 → 12.541112 (11.698%). Paired terrain range 12.218% to 15.467%; candidate slower in 0/5 pairs. +- **overworld, 4 worker(s), seed 12345, center (0, 0), initialized:** terrain 3.837939 → 3.408437 (11.191%); combined 4.405165 → 3.987592 (9.479%). Paired terrain range 7.647% to 13.352%; candidate slower in 0/5 pairs. +- **the_nether, 1 worker(s), seed 12345, center (0, 0), initialized:** terrain 5.000868 → 4.843412 (3.149%); combined 5.381649 → 5.215208 (3.093%). Paired terrain range -3.917% to 6.809%; candidate slower in 2/5 pairs. +- **the_nether, 4 worker(s), seed 12345, center (0, 0), initialized:** terrain 1.395740 → 1.367372 (2.033%); combined 1.497615 → 1.473427 (1.615%). Paired terrain range 0.323% to 17.443%; candidate slower in 0/5 pairs. +- **the_end, 1 worker(s), seed 12345, center (0, 0), initialized:** terrain 1.087874 → 1.054903 (3.031%); combined 1.161584 → 1.128076 (2.885%). Paired terrain range -0.144% to 14.336%; candidate slower in 1/5 pairs. +- **the_end, 4 worker(s), seed 12345, center (0, 0), initialized:** terrain 0.275263 → 0.260434 (5.387%); combined 0.302814 → 0.288325 (4.785%). Paired terrain range 4.468% to 6.365%; candidate slower in 0/5 pairs. +- **overworld, 1 worker(s), seed -1, center (32, -32), initialized:** terrain 11.333986 → 9.786101 (13.657%); combined 12.356760 → 10.854422 (12.158%). Paired terrain range 7.854% to 14.172%; candidate slower in 0/5 pairs. +- **overworld, 4 worker(s), seed -1, center (32, -32), initialized:** terrain 3.058178 → 2.639180 (13.701%); combined 3.357631 → 2.938479 (12.484%). Paired terrain range 10.767% to 14.651%; candidate slower in 0/5 pairs. +- **overworld, 1 worker(s), seed 12345, center (0, 0), cold:** terrain 23.049481 → 21.473030 (6.839%); combined 24.984204 → 23.443390 (6.167%). Paired terrain range 6.458% to 7.944%; candidate slower in 0/5 pairs. + +Nether one-worker repeats 1 and 3 regress 0.555% and 3.917%; End one-worker repeat 1 regresses 0.144%. Nether four-worker and End one-worker have large favorable outliers (paired improvements up to 17.443% and 14.336%), so their small median gains should not be generalized. All Overworld initialized pairs exceed 5%; the smallest is 7.647% at the primary four-worker site. No case was removed or selected after seeing timings. Cold results include startup and are not used to establish the recurring improvement. + +Primary terrain process CPU medians: 12.1 → 10.5 ms/input chunk at one worker, 15.2 → 13.5 at four workers. This existing `/proc` accounting has 100 Hz quantization and a rounded display. Aggregate stage worker elapsed is not an exclusive CPU share. Primary peak process RSS: 786588 → 786608 KiB (one worker), 834016 → 833440 KiB (four workers), effectively unchanged. All workload CPU/RSS medians are in `summary.json`; process CPU additionally includes initialization/other phases where explicitly named. No new heap buffer is introduced. Executable `.text` grows 2860 bytes, 5164975 → 5167835 bytes. Compiler output shows packed float instructions in the specialized bulk method; the original bulk method had none. + +An initial variant additionally forced the shared scalar helper inline. Its excluded five-pair primary result was 12.240292 → 10.644734 ms/chunk (13.035%). This broader variant was not used for qualification; the narrowed bulk-only candidate independently reproduced the benefit. The early hypothesis that scalar inlining explained the surface gain was disproved by the narrowed result and inspection of material-density bulk preparation. Initial raw data/patch/hashes are retained under `noise-aquifer-results/initial-shared-inline/`. + +## Correctness + +- 191 final optimized unit/integration tests pass: 86 core library, 91 world library, 6 context/world-field integration tests, and 8 integration tests covering material stages, carving, ticks, retrogen biomes and biome regions. Storage/palette randomized editing, packing, invalid-write atomicity, density caches/errors and interpolation tests are included. +- New bit-exact tests cover every unary operation, signed zeros, subnormals, infinities, NaN payloads, 4096 deterministic random float patterns, multiple buffer lengths and varied constants. A new child-error test verifies partial input writes survive without applying the operation and verifies complete oversized-buffer tails on success. An initial non-finite-operand NaN payload failure was fixed by retaining original dispatch for those constants; the strict assertion was retained. +- Fresh candidate and Java client/server density runs each match **15,524,627 output lines**. The existing input corpus was authenticated against its recorded checksum and unchanged corpus/oracle source; both Java sides were freshly compiled/run against independently checksum-verified pinned JARs. +- Fresh scoped terrain-fill parity matches **7,950,873 lines on each Java side**: 114 fixtures, 200 fills, 61 noise-aquifer fixtures and 24 structure-density fixtures. This covers actual noise fill, prefilled sections, partial vertical volumes, repeated fills, both seeded factories, bundled routers/aquifers, raw section states, WG heightmaps and ordered postprocessing. The repository harness was changed only in memory to use `fast` build/profile paths and isolated private output storage; the adaptation script and its hashes are saved. +- Full baseline/candidate chunk differential: 12 cases (three dimensions × two seeds/sites × one/four workers), each with 81 terrain chunks and 49 interior decorations. All 81 retained chunks, including borders, are compared both after terrain and after decoration: **24/24 exact byte comparisons pass**, covering 1,317,207,694 bytes per revision. Snapshots include raw and public block reads, section palettes/storage, all quart biomes, block entities and entities (binary NBT preserving numeric bits and order), complete saved block/fluid ticks including delay/priority, all six heightmaps with presence/raw words, ordered postprocessing and actual non-air counts. Chunk status, decoration flag, retrogen metadata and structure identities/bounds are included. +- Snapshot builds use the same temporary read-only accessor for actual non-air counts on both revisions. It is removed from production source. The final production-only benchmark rebuild has byte-identical `.text` and `.rodata` to the measured candidate; the twelve changed read-only relocation-data words are source-location line numbers decreasing by four after removing the accessor. Binary/codegen hashes are saved. +- `git diff --check` passes. + +Validation is scoped to these workloads and corpora, not every seed, biome or future compiler. Whole-chunk parity is a complete comparison of the listed generated fields against the baseline; it is not a claim that every untested generation behavior matches Java. Full-chunk Java gameplay, lighting, meshing, saving and streaming were not benchmarked. No required affected metadata was omitted from the baseline/candidate differential. + +## Evidence and reproduction + +Public evidence is under `noise-aquifer-results/`: `workloads.json`, `environment.json`, `binary-hashes.txt`, `parity-binary-hashes.txt`, `final-codegen-check.json`, `gate-raw.json`, `matrix-raw.json`, `summary.json`, `density-parity.json`, `terrain-parity.json`, `chunk-parity.json`, test logs, diagnostic sources and runners. Raw measurements include discarded warmups, exact commands and every measured pair; summaries exclude only the declared warmups. Private executables, density outputs and full chunk snapshots are under `/srv/bob-data/horizon-noise-aquifer-e477fa56/`; noise-fill fixture data is ignored under `noise-aquifer-results/private-parity/`. No private fixtures, chunk dumps, game resources or Java binaries are committed. + +For fresh baseline/candidate performance builds in this isolated checkout, use the saved `chunkgen_profile.rs` as `crates/horizon-world/examples/chunkgen_profile.rs`, build each source variant with the command below, and copy its executable to the matching `baseline` or `candidate` path expected by `bench.py`. Baseline is the pinned commit; the candidate patch is saved independently. The measured candidate also had the unused diagnostic accessor available; it emits no benchmark code. Remove copied example/accessor support afterward. + +```sh +CARGO_TARGET_DIR=/srv/bob-data/horizon-stage3d-target cargo build --profile fast -p horizon-world --example chunkgen_profile +python3 noise-aquifer-results/bench.py gate +python3 noise-aquifer-results/bench.py matrix +python3 noise-aquifer-results/summarize.py +``` + +For differential snapshots, copy `chunkgen_snapshot.rs` into the examples directory and apply `snapshot-accessor.patch`, then run `python3 noise-aquifer-results/build_snapshots.py` (it saves/restores the candidate arithmetic source and builds both variants). Run `validate_chunks.py`, then remove the temporary accessor and copied examples. The density runner expects a fast `horizon-density-parity` binary copied to the private executable directory; `build_snapshots.py` also produces it. Run `validate_density.py`. Run the scoped terrain oracle with `CARGO_TARGET_DIR=/srv/bob-data/horizon-stage3d-target python3 noise-aquifer-results/validate_terrain.py`; its fixtures stay in ignored private storage. The paths are intentionally explicit and can be adjusted together on another machine. + +Final unit/integration commands: + +```sh +CARGO_TARGET_DIR=/srv/bob-data/horizon-stage3d-target cargo test --profile fast -p horizon-core --lib --test density_world_fields +CARGO_TARGET_DIR=/srv/bob-data/horizon-stage3d-target cargo test --profile fast -p horizon-world --lib --test material_stage --test carving_stage --test tick_data --test retrogen_biomes --test biome_region +git diff --check +``` + +## Advice for the surface task + +Reprofile with this change present before evaluating a separate surface optimization. Shared bulk density preparation already accounts for about 1.15 ms/chunk of the primary surface-bracket saving; do not count it again as a later task’s improvement. Compiled rule evaluation and remaining column traversal are unchanged. No task in another area was started. diff --git a/noise-aquifer-results/.gitignore b/noise-aquifer-results/.gitignore new file mode 100644 index 000000000..b32d8cc68 --- /dev/null +++ b/noise-aquifer-results/.gitignore @@ -0,0 +1,5 @@ +/private-parity/ +/__pycache__/ +*.log +!core-final-tests.log +!world-final-tests.log diff --git a/noise-aquifer-results/bench.py b/noise-aquifer-results/bench.py new file mode 100644 index 000000000..ac2288e01 --- /dev/null +++ b/noise-aquifer-results/bench.py @@ -0,0 +1,40 @@ +import subprocess,os,json,pathlib,re,statistics,sys +root=pathlib.Path(__file__).resolve().parent +bins=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56') +resources='/srv/bob-data/horizon/.local/horizon-client/26.3' +phase=sys.argv[1] if len(sys.argv)>1 else 'gate' +cases=[('overworld',1,12345,0,0,True)] if phase=='gate' else [(d,t,12345,0,0,True) for d in ['overworld','the_nether','the_end'] for t in [1,4] if (d,t)!=('overworld',1)]+[('overworld',t,-1,32,-32,True) for t in [1,4]]+[('overworld',1,12345,0,0,False)] +rows=[] +for dim,threads,seed,cx,cz,warm in cases: + for repeat in range(-1,5): + order=['baseline','candidate'] if repeat%2==0 else ['candidate','baseline'] + for version in order: + name=f'{dim}-t{threads}-s{seed}-c{cx}_{cz}-w{int(warm)}-r{repeat}-{version}' + cmd=[sys.executable,'-c',"import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)",str(bins/version),resources,'--seed',str(seed),'--size','16','--threads',str(threads),'--dimension',dim,'--center',str(cx),str(cz)] + env=dict(os.environ) + env.pop('HORIZON_PROFILE_SIGNAL',None);env.pop('HORIZON_PROFILE_WARM',None) + if warm:env['HORIZON_PROFILE_WARM']='1' + r=subprocess.run(cmd,text=True,capture_output=True,env=env,check=True) + (root/(name+'.log')).write_text(r.stdout+r.stderr) + row=json.loads(next(x.split(' ',1)[1] for x in r.stdout.splitlines() if x.startswith('PROFILE_STAGES '))) + m=re.search(r'decorated (\d+) chunks in ([0-9.]+)(ms|s)',r.stdout) + deco=float(m[2])*(1 if m[3]=='ms' else 1000) + # Parent diagnostic prints rounded decoration duration, retain this precision limit. + row.update(version=version,repeat=repeat,dimension=dim,seed=seed,center=[cx,cz],warm=warm,cmd=cmd,decorated=int(m[1]),decoration_ms=deco,combined_ms_chunk=row['wall_ms_chunk']+deco/row['chunks']) + cpu=re.search(r'cpu time ([0-9.]+) ms/chunk',r.stdout) + resource=re.search(r'RESOURCE ([0-9.]+) ([0-9.]+) (\d+)',r.stderr) + row.update(terrain_cpu_ms_chunk=float(cpu[1]),process_user_s=float(resource[1]),process_system_s=float(resource[2]),peak_rss_kib=int(resource[3])) + rows.append(row) + (root/(phase+'-raw.json')).write_text(json.dumps(rows,indent=2)+'\n') + print(name,round(row['wall_ms_chunk'],6),flush=True) +summary=[] +for case in cases: + dim,threads,seed,cx,cz,warm=case + rs=[r for r in rows if (r['dimension'],r['threads'],r['seed'],*r['center'],r['warm'])==case and r['repeat']>=0] + out=dict(dimension=dim,threads=threads,seed=seed,center=[cx,cz],warm=warm) + for metric in ['wall_ms_chunk','combined_ms_chunk','noise','surface','terrain_cpu_ms_chunk','peak_rss_kib']: + med={v:statistics.median(r[metric] for r in rs if r['version']==v) for v in ['baseline','candidate']} + out[metric]={**med,'reduction_percent':100*(med['baseline']-med['candidate'])/med['baseline']} + summary.append(out) +(root/(phase+'-summary.json')).write_text(json.dumps(summary,indent=2)+'\n') +print(json.dumps(summary,indent=2)) diff --git a/noise-aquifer-results/binary-hashes.txt b/noise-aquifer-results/binary-hashes.txt new file mode 100644 index 000000000..778f9e2bc --- /dev/null +++ b/noise-aquifer-results/binary-hashes.txt @@ -0,0 +1,2 @@ +65d134def1e54944b105cf13e28945eea717f75aabf5dfd827f70645b22abc3c /srv/bob-data/horizon-noise-aquifer-e477fa56/baseline +198f60a68b2616aa394861c517297d4a14cc0949e3b56600905b6f86c05e59b8 /srv/bob-data/horizon-noise-aquifer-e477fa56/candidate diff --git a/noise-aquifer-results/binary-size.txt b/noise-aquifer-results/binary-size.txt new file mode 100644 index 000000000..268cb840a --- /dev/null +++ b/noise-aquifer-results/binary-size.txt @@ -0,0 +1,3 @@ + text data bss dec hex filename +5164975 130720 3344 5299039 50db5f /srv/bob-data/horizon-noise-aquifer-e477fa56/baseline +5167835 130640 576 5299051 50db6b /srv/bob-data/horizon-noise-aquifer-e477fa56/candidate diff --git a/noise-aquifer-results/build_snapshots.py b/noise-aquifer-results/build_snapshots.py new file mode 100644 index 000000000..3d3bd0d33 --- /dev/null +++ b/noise-aquifer-results/build_snapshots.py @@ -0,0 +1,22 @@ +"""Build diagnostic snapshots for both revisions, restoring candidate sources on exit.""" +import os,pathlib,subprocess,shutil +root=pathlib.Path(__file__).resolve().parents[1] +results=pathlib.Path(__file__).parent +work=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56') +target=pathlib.Path('/srv/bob-data/horizon-stage3d-target') +env=dict(os.environ,CARGO_TARGET_DIR=str(target)) +arithmetic=root/'crates/horizon-core/src/density/arithmetic.rs' +candidate=arithmetic.read_bytes() +(work/'candidate-arithmetic.rs').write_bytes(candidate) +def build(args,log): + with (results/log).open('w') as f:subprocess.run(['cargo','build','--profile','fast',*args],cwd=root,env=env,stdout=f,stderr=subprocess.STDOUT,check=True) +try: + build(['-p','horizon-world','--example','chunkgen_snapshot'],'snapshot-candidate-build.log') + shutil.copy2(target/'fast/examples/chunkgen_snapshot',work/'snapshot-candidate') + build(['-p','horizon-core','--bin','horizon-density-parity'],'density-build.log') + shutil.copy2(target/'fast/horizon-density-parity',work/'horizon-density-parity') + arithmetic.write_bytes(subprocess.check_output(['git','show','e4f8154cb4115aa1ee622381d9b12387cdf515d4:crates/horizon-core/src/density/arithmetic.rs'],cwd=root)) + build(['-p','horizon-world','--example','chunkgen_snapshot'],'snapshot-baseline-build.log') + shutil.copy2(target/'fast/examples/chunkgen_snapshot',work/'snapshot-baseline') +finally: + arithmetic.write_bytes(candidate) diff --git a/noise-aquifer-results/candidate.patch b/noise-aquifer-results/candidate.patch new file mode 100644 index 000000000..17a45e3aa --- /dev/null +++ b/noise-aquifer-results/candidate.patch @@ -0,0 +1,264 @@ +diff --git a/crates/horizon-core/src/density/arithmetic.rs b/crates/horizon-core/src/density/arithmetic.rs +index f82b96ce..7961adf0 100644 +--- a/crates/horizon-core/src/density/arithmetic.rs ++++ b/crates/horizon-core/src/density/arithmetic.rs +@@ -75,9 +75,12 @@ pub enum UnaryOp { + max: f32, + }, + } +-impl UnaryOp { +- pub(super) fn apply(self, value: f32, bulk: bool) -> f32 { +- match self { ++// One expression definition for scalar dispatch and specialized bulk loops. ++macro_rules! unary_apply { ++ ($operation:expr, $value:expr, $bulk:expr) => {{ ++ let value = $value; ++ let bulk = $bulk; ++ match $operation { + Self::Abs => value.abs(), + Self::Negate => -value, + Self::Square => value * value, +@@ -137,6 +140,85 @@ impl UnaryOp { + } + } + } ++ }}; ++} ++impl UnaryOp { ++ pub(super) fn apply(self, value: f32, bulk: bool) -> f32 { ++ unary_apply!(self, value, bulk) ++ } ++ /// Dispatch once per volume so each loop has one fixed arithmetic operation. ++ /// Keep the scalar expression shared, including the bulk min/max behavior. ++ fn apply_bulk(self, buffer: &mut [f32]) { ++ // Specialization can reverse which NaN operand supplies the payload. ++ // Retain the original dispatch for non-finite constant operands. ++ let non_finite = match self { ++ Self::PowerBase(value) | Self::PowerExponent(value) => !value.is_finite(), ++ Self::LeakyRelu(value) ++ | Self::Add(value) ++ | Self::SubtractFrom(value) ++ | Self::Multiply(value) ++ | Self::DivideInto(value) ++ | Self::Minimum(value) ++ | Self::Maximum(value) => !value.is_finite(), ++ Self::Clamp { min, max } => !min.is_finite() || !max.is_finite(), ++ Self::ConstantRangeChoice { ++ min_inclusive, ++ max_exclusive, ++ inside, ++ outside, ++ } => { ++ !min_inclusive.is_finite() ++ || !max_exclusive.is_finite() ++ || !inside.is_finite() ++ || !outside.is_finite() ++ } ++ _ => false, ++ }; ++ if non_finite { ++ for value in buffer { ++ *value = self.apply(*value, true); ++ } ++ return; ++ } ++ macro_rules! apply { ++ ($operation:expr) => { ++ for value in buffer { ++ *value = unary_apply!($operation, *value, true); ++ } ++ }; ++ } ++ match self { ++ Self::Abs => apply!(Self::Abs), ++ Self::Negate => apply!(Self::Negate), ++ Self::Square => apply!(Self::Square), ++ Self::Cube => apply!(Self::Cube), ++ Self::Sqrt => apply!(Self::Sqrt), ++ Self::Log => apply!(Self::Log), ++ Self::PowerBase(base) => apply!(Self::PowerBase(base)), ++ Self::PowerExponent(exponent) => apply!(Self::PowerExponent(exponent)), ++ Self::Reciprocal => apply!(Self::Reciprocal), ++ Self::Sign => apply!(Self::Sign), ++ Self::Squeeze => apply!(Self::Squeeze), ++ Self::LeakyRelu(factor) => apply!(Self::LeakyRelu(factor)), ++ Self::Add(right) => apply!(Self::Add(right)), ++ Self::SubtractFrom(left) => apply!(Self::SubtractFrom(left)), ++ Self::Multiply(right) => apply!(Self::Multiply(right)), ++ Self::DivideInto(left) => apply!(Self::DivideInto(left)), ++ Self::Minimum(right) => apply!(Self::Minimum(right)), ++ Self::Maximum(right) => apply!(Self::Maximum(right)), ++ Self::ConstantRangeChoice { ++ min_inclusive, ++ max_exclusive, ++ inside, ++ outside, ++ } => apply!(Self::ConstantRangeChoice { ++ min_inclusive, ++ max_exclusive, ++ inside, ++ outside ++ }), ++ Self::Clamp { min, max } => apply!(Self::Clamp { min, max }), ++ } + } + } + #[derive(Clone, Debug)] +@@ -162,9 +244,7 @@ impl DensitySampler for UnarySampler { + ) -> Result<(), SampleError> { + check_buffer(buffer, volume)?; + self.input.sample_volume(context, buffer, volume)?; +- for value in buffer { +- *value = self.operation.apply(*value, true); +- } ++ self.operation.apply_bulk(buffer); + Ok(()) + } + } +@@ -246,3 +326,98 @@ impl DensitySampler for BinarySampler { + }) + } + } ++ ++#[cfg(test)] ++mod bulk_tests { ++ use super::*; ++ ++ #[inline(never)] ++ fn dispatched_reference(operation: UnaryOp, value: f32) -> f32 { ++ operation.apply(value, true) ++ } ++ ++ #[test] ++ fn fixed_operation_loops_preserve_float_bits() { ++ let mut operations = vec![ ++ UnaryOp::Abs, ++ UnaryOp::Negate, ++ UnaryOp::Square, ++ UnaryOp::Cube, ++ UnaryOp::Sqrt, ++ UnaryOp::Log, ++ UnaryOp::Reciprocal, ++ UnaryOp::Sign, ++ UnaryOp::Squeeze, ++ ]; ++ for factor in [0.0, -0.0, 0.5, -1.0, f32::INFINITY, f32::NAN] { ++ operations.extend([ ++ UnaryOp::LeakyRelu(factor), ++ UnaryOp::Add(factor), ++ UnaryOp::SubtractFrom(factor), ++ UnaryOp::Multiply(factor), ++ UnaryOp::DivideInto(factor), ++ UnaryOp::Minimum(factor), ++ UnaryOp::Maximum(factor), ++ UnaryOp::Clamp { ++ min: -factor, ++ max: factor, ++ }, ++ UnaryOp::ConstantRangeChoice { ++ min_inclusive: -factor, ++ max_exclusive: factor, ++ inside: -0.0, ++ outside: 17.0, ++ }, ++ ]); ++ } ++ for exponent in [0.0, -0.0, 0.5, -1.0, 2.0, 3.0, f64::INFINITY, f64::NAN] { ++ operations.extend([ ++ UnaryOp::PowerBase(exponent), ++ UnaryOp::PowerExponent(exponent), ++ ]); ++ } ++ let mut values: Vec = [ ++ 0, ++ 0x8000_0000, ++ 1, ++ 0x8000_0001, ++ 0x007f_ffff, ++ 0x0080_0000, ++ 0x3f00_0000, ++ 0xbf00_0000, ++ 0x3f80_0000, ++ 0xbf80_0000, ++ 0x7f7f_ffff, ++ 0xff7f_ffff, ++ 0x7f80_0000, ++ 0xff80_0000, ++ 0x7fc0_0000, ++ 0x7fa0_0001, ++ 0xffc0_1234, ++ ] ++ .into_iter() ++ .map(f32::from_bits) ++ .collect(); ++ let mut bits = 0x484f_5249u32; ++ for _ in 0..4096 { ++ bits ^= bits << 13; ++ bits ^= bits >> 17; ++ bits ^= bits << 5; ++ values.push(f32::from_bits(bits)); ++ } ++ for operation in operations { ++ for length in [0, 1, 3, 16, 257, values.len()] { ++ let mut actual = values[..length].to_vec(); ++ operation.apply_bulk(&mut actual); ++ for (i, (&input, actual)) in values.iter().zip(actual).enumerate() { ++ let expected = dispatched_reference(operation, input); ++ assert_eq!( ++ actual.to_bits(), ++ expected.to_bits(), ++ "{operation:?}, index {i}, input {input:?}" ++ ); ++ } ++ } ++ } ++ } ++} +diff --git a/crates/horizon-core/src/density/tests.rs b/crates/horizon-core/src/density/tests.rs +index 77a64309..f94b9535 100644 +--- a/crates/horizon-core/src/density/tests.rs ++++ b/crates/horizon-core/src/density/tests.rs +@@ -755,3 +755,43 @@ fn spline_lazy_branch_failure_preserves_completed_output_and_returns_scratch() { + assert_eq!(context.scratch.len(), 2); + assert_eq!(sampler.sample_value(&mut context, [0; 3]), Ok(7.0)); + } ++ ++#[test] ++fn unary_bulk_keeps_child_failure_writes_and_full_buffer_tail() { ++ #[derive(Debug)] ++ struct PartialInput; ++ impl DensitySampler for PartialInput { ++ fn sample_value(&self, _: &mut SamplerContext, _: [i32; 3]) -> Result { ++ Err(SampleError::ZeroGradientPeriod) ++ } ++ fn sample_volume( ++ &self, ++ _: &mut SamplerContext, ++ buffer: &mut [f32], ++ _: DensityVolume, ++ ) -> Result<(), SampleError> { ++ buffer[0] = -3.0; ++ Err(SampleError::ZeroGradientPeriod) ++ } ++ } ++ let volume = DensityVolume::new([1; 3], [0; 3], [1; 3]).unwrap(); ++ let mut context = SamplerContext::default(); ++ let mut buffer = [17.0; 3]; ++ let sampler = UnarySampler { ++ input: Arc::new(PartialInput), ++ operation: UnaryOp::Square, ++ }; ++ assert_eq!( ++ sampler.sample_volume(&mut context, &mut buffer, volume), ++ Err(SampleError::ZeroGradientPeriod) ++ ); ++ assert_eq!(buffer, [-3.0, 17.0, 17.0]); ++ let sampler = UnarySampler { ++ input: Arc::new(ConstantSampler(-3.0)), ++ operation: UnaryOp::Square, ++ }; ++ sampler ++ .sample_volume(&mut context, &mut buffer, volume) ++ .unwrap(); ++ assert_eq!(buffer, [9.0; 3]); ++} diff --git a/noise-aquifer-results/chunk-parity.json b/noise-aquifer-results/chunk-parity.json new file mode 100644 index 000000000..4fdbfdbeb --- /dev/null +++ b/noise-aquifer-results/chunk-parity.json @@ -0,0 +1,458 @@ +[ + { + "dimension": "overworld", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s12345-c0_0-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s12345-c0_0-candidate-terrain.bin", + "baseline_bytes": 70871678, + "candidate_bytes": 70871678, + "equal": true, + "baseline_sha256": "2ad69a09980586e9bd293e58cffa02212bbc30a1a21a83cb85bb289b6cd85aa8", + "candidate_sha256": "2ad69a09980586e9bd293e58cffa02212bbc30a1a21a83cb85bb289b6cd85aa8" + }, + { + "dimension": "overworld", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s12345-c0_0-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s12345-c0_0-candidate-decorated.bin", + "baseline_bytes": 72477690, + "candidate_bytes": 72477690, + "equal": true, + "baseline_sha256": "68c21c8c5ff5d227ff715c186c95278eb44169821b9295e35b550f0c3a4941ae", + "candidate_sha256": "68c21c8c5ff5d227ff715c186c95278eb44169821b9295e35b550f0c3a4941ae" + }, + { + "dimension": "overworld", + "threads": 1, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s-1-c32_-32-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s-1-c32_-32-candidate-terrain.bin", + "baseline_bytes": 70926924, + "candidate_bytes": 70926924, + "equal": true, + "baseline_sha256": "7cea600cfb8151fa97adcf55a192dab1465487fd86db098d115c82b27de4ae75", + "candidate_sha256": "7cea600cfb8151fa97adcf55a192dab1465487fd86db098d115c82b27de4ae75" + }, + { + "dimension": "overworld", + "threads": 1, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s-1-c32_-32-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s-1-c32_-32-candidate-decorated.bin", + "baseline_bytes": 71982927, + "candidate_bytes": 71982927, + "equal": true, + "baseline_sha256": "ed77837ac1031f3eee0a4646fdeb2b71f0d7a6671e5042a76e849ce6431b28e4", + "candidate_sha256": "ed77837ac1031f3eee0a4646fdeb2b71f0d7a6671e5042a76e849ce6431b28e4" + }, + { + "dimension": "overworld", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s12345-c0_0-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s12345-c0_0-candidate-terrain.bin", + "baseline_bytes": 70871678, + "candidate_bytes": 70871678, + "equal": true, + "baseline_sha256": "2ad69a09980586e9bd293e58cffa02212bbc30a1a21a83cb85bb289b6cd85aa8", + "candidate_sha256": "2ad69a09980586e9bd293e58cffa02212bbc30a1a21a83cb85bb289b6cd85aa8" + }, + { + "dimension": "overworld", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s12345-c0_0-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s12345-c0_0-candidate-decorated.bin", + "baseline_bytes": 72477690, + "candidate_bytes": 72477690, + "equal": true, + "baseline_sha256": "68c21c8c5ff5d227ff715c186c95278eb44169821b9295e35b550f0c3a4941ae", + "candidate_sha256": "68c21c8c5ff5d227ff715c186c95278eb44169821b9295e35b550f0c3a4941ae" + }, + { + "dimension": "overworld", + "threads": 4, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s-1-c32_-32-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s-1-c32_-32-candidate-terrain.bin", + "baseline_bytes": 70926924, + "candidate_bytes": 70926924, + "equal": true, + "baseline_sha256": "7cea600cfb8151fa97adcf55a192dab1465487fd86db098d115c82b27de4ae75", + "candidate_sha256": "7cea600cfb8151fa97adcf55a192dab1465487fd86db098d115c82b27de4ae75" + }, + { + "dimension": "overworld", + "threads": 4, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s-1-c32_-32-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s-1-c32_-32-candidate-decorated.bin", + "baseline_bytes": 71982927, + "candidate_bytes": 71982927, + "equal": true, + "baseline_sha256": "ed77837ac1031f3eee0a4646fdeb2b71f0d7a6671e5042a76e849ce6431b28e4", + "candidate_sha256": "ed77837ac1031f3eee0a4646fdeb2b71f0d7a6671e5042a76e849ce6431b28e4" + }, + { + "dimension": "the_nether", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s12345-c0_0-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s12345-c0_0-candidate-terrain.bin", + "baseline_bytes": 47625247, + "candidate_bytes": 47625247, + "equal": true, + "baseline_sha256": "a406f643b6acc121f7f0b48497c5ed2a479a9d64528bd210714ddd6666ce9c22", + "candidate_sha256": "a406f643b6acc121f7f0b48497c5ed2a479a9d64528bd210714ddd6666ce9c22" + }, + { + "dimension": "the_nether", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s12345-c0_0-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s12345-c0_0-candidate-decorated.bin", + "baseline_bytes": 48076401, + "candidate_bytes": 48076401, + "equal": true, + "baseline_sha256": "b754a8bc209b8b6587288692edcdc6e1c920d87d5bbb31b600c4f5fc16bee894", + "candidate_sha256": "b754a8bc209b8b6587288692edcdc6e1c920d87d5bbb31b600c4f5fc16bee894" + }, + { + "dimension": "the_nether", + "threads": 1, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s-1-c32_-32-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s-1-c32_-32-candidate-terrain.bin", + "baseline_bytes": 47483043, + "candidate_bytes": 47483043, + "equal": true, + "baseline_sha256": "70aa070734aeda158baf10746d92bc3d4c86bd2b77704223964ec0a54ee6e5f0", + "candidate_sha256": "70aa070734aeda158baf10746d92bc3d4c86bd2b77704223964ec0a54ee6e5f0" + }, + { + "dimension": "the_nether", + "threads": 1, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s-1-c32_-32-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s-1-c32_-32-candidate-decorated.bin", + "baseline_bytes": 47748532, + "candidate_bytes": 47748532, + "equal": true, + "baseline_sha256": "e12f60fef0afb86cc8d1a357dac46938bf560c326cd1dc8f75b48b337b6ce6e3", + "candidate_sha256": "e12f60fef0afb86cc8d1a357dac46938bf560c326cd1dc8f75b48b337b6ce6e3" + }, + { + "dimension": "the_nether", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s12345-c0_0-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s12345-c0_0-candidate-terrain.bin", + "baseline_bytes": 47625247, + "candidate_bytes": 47625247, + "equal": true, + "baseline_sha256": "a406f643b6acc121f7f0b48497c5ed2a479a9d64528bd210714ddd6666ce9c22", + "candidate_sha256": "a406f643b6acc121f7f0b48497c5ed2a479a9d64528bd210714ddd6666ce9c22" + }, + { + "dimension": "the_nether", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s12345-c0_0-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s12345-c0_0-candidate-decorated.bin", + "baseline_bytes": 48076401, + "candidate_bytes": 48076401, + "equal": true, + "baseline_sha256": "b754a8bc209b8b6587288692edcdc6e1c920d87d5bbb31b600c4f5fc16bee894", + "candidate_sha256": "b754a8bc209b8b6587288692edcdc6e1c920d87d5bbb31b600c4f5fc16bee894" + }, + { + "dimension": "the_nether", + "threads": 4, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s-1-c32_-32-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s-1-c32_-32-candidate-terrain.bin", + "baseline_bytes": 47483043, + "candidate_bytes": 47483043, + "equal": true, + "baseline_sha256": "70aa070734aeda158baf10746d92bc3d4c86bd2b77704223964ec0a54ee6e5f0", + "candidate_sha256": "70aa070734aeda158baf10746d92bc3d4c86bd2b77704223964ec0a54ee6e5f0" + }, + { + "dimension": "the_nether", + "threads": 4, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s-1-c32_-32-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s-1-c32_-32-candidate-decorated.bin", + "baseline_bytes": 47748532, + "candidate_bytes": 47748532, + "equal": true, + "baseline_sha256": "e12f60fef0afb86cc8d1a357dac46938bf560c326cd1dc8f75b48b337b6ce6e3", + "candidate_sha256": "e12f60fef0afb86cc8d1a357dac46938bf560c326cd1dc8f75b48b337b6ce6e3" + }, + { + "dimension": "the_end", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s12345-c0_0-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s12345-c0_0-candidate-terrain.bin", + "baseline_bytes": 45817706, + "candidate_bytes": 45817706, + "equal": true, + "baseline_sha256": "a9ff378aabcaa78e3fe83174759583e6b91dfdce287ef5b5770d73ffe490ed76", + "candidate_sha256": "a9ff378aabcaa78e3fe83174759583e6b91dfdce287ef5b5770d73ffe490ed76" + }, + { + "dimension": "the_end", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s12345-c0_0-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s12345-c0_0-candidate-decorated.bin", + "baseline_bytes": 45993605, + "candidate_bytes": 45993605, + "equal": true, + "baseline_sha256": "4253a573b8710684556955c3c6e0c3b4a6175156dd79da8da1635baf97890e2f", + "candidate_sha256": "4253a573b8710684556955c3c6e0c3b4a6175156dd79da8da1635baf97890e2f" + }, + { + "dimension": "the_end", + "threads": 1, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s-1-c32_-32-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s-1-c32_-32-candidate-terrain.bin", + "baseline_bytes": 44800047, + "candidate_bytes": 44800047, + "equal": true, + "baseline_sha256": "7626139e9b822d4439770629794ec658fb7b8238c51090541513aa518cabeee2", + "candidate_sha256": "7626139e9b822d4439770629794ec658fb7b8238c51090541513aa518cabeee2" + }, + { + "dimension": "the_end", + "threads": 1, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s-1-c32_-32-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s-1-c32_-32-candidate-decorated.bin", + "baseline_bytes": 44800047, + "candidate_bytes": 44800047, + "equal": true, + "baseline_sha256": "747b4c3a207bdc115b264a0bf41e97231bb9311f57e5a7ae1e104a14359bbed0", + "candidate_sha256": "747b4c3a207bdc115b264a0bf41e97231bb9311f57e5a7ae1e104a14359bbed0" + }, + { + "dimension": "the_end", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s12345-c0_0-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s12345-c0_0-candidate-terrain.bin", + "baseline_bytes": 45817706, + "candidate_bytes": 45817706, + "equal": true, + "baseline_sha256": "a9ff378aabcaa78e3fe83174759583e6b91dfdce287ef5b5770d73ffe490ed76", + "candidate_sha256": "a9ff378aabcaa78e3fe83174759583e6b91dfdce287ef5b5770d73ffe490ed76" + }, + { + "dimension": "the_end", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s12345-c0_0-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s12345-c0_0-candidate-decorated.bin", + "baseline_bytes": 45993605, + "candidate_bytes": 45993605, + "equal": true, + "baseline_sha256": "4253a573b8710684556955c3c6e0c3b4a6175156dd79da8da1635baf97890e2f", + "candidate_sha256": "4253a573b8710684556955c3c6e0c3b4a6175156dd79da8da1635baf97890e2f" + }, + { + "dimension": "the_end", + "threads": 4, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "terrain", + "terrain_chunks": 81, + "decorated_chunks": 0, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s-1-c32_-32-baseline-terrain.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s-1-c32_-32-candidate-terrain.bin", + "baseline_bytes": 44800047, + "candidate_bytes": 44800047, + "equal": true, + "baseline_sha256": "7626139e9b822d4439770629794ec658fb7b8238c51090541513aa518cabeee2", + "candidate_sha256": "7626139e9b822d4439770629794ec658fb7b8238c51090541513aa518cabeee2" + }, + { + "dimension": "the_end", + "threads": 4, + "seed": -1, + "center": [ + 32, + -32 + ], + "phase": "decorated", + "terrain_chunks": 81, + "decorated_chunks": 49, + "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s-1-c32_-32-baseline-decorated.bin", + "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s-1-c32_-32-candidate-decorated.bin", + "baseline_bytes": 44800047, + "candidate_bytes": 44800047, + "equal": true, + "baseline_sha256": "747b4c3a207bdc115b264a0bf41e97231bb9311f57e5a7ae1e104a14359bbed0", + "candidate_sha256": "747b4c3a207bdc115b264a0bf41e97231bb9311f57e5a7ae1e104a14359bbed0" + } +] diff --git a/noise-aquifer-results/chunkgen_profile.rs b/noise-aquifer-results/chunkgen_profile.rs new file mode 100644 index 000000000..eaeab5f99 --- /dev/null +++ b/noise-aquifer-results/chunkgen_profile.rs @@ -0,0 +1,478 @@ +//! Chunk generation throughput and sanity map. +//! +//! chunkgen_bench [--seed S] [--size N] [--threads T] +//! [--center CX CZ] [--verify ] [--no-decorate] +//! [--dimension overworld|the_nether|the_end] +use horizon_core::position::ChunkPos; +use horizon_world::{ + DATA_VERSION, + heightmap::HeightmapType, + nbt::Tag, + registry::BlockRegistry, + worldgen::generator::{ + DecorateStats, GeneratorData, GeneratorWorker, OverworldGenerator, ProtoChunk, StageTimings, + }, +}; +use serde_json::Value; +use std::{ + collections::BTreeMap, + fs, + io::{BufRead, BufReader}, + path::{Path, PathBuf}, + sync::{ + Mutex, + atomic::{AtomicUsize, Ordering}, + }, + time::Instant, +}; + +type Error = Box; + +fn tag(v: &Value) -> Tag { + match v { + Value::String(s) => Tag::String(s.as_str().into()), + Value::Number(n) => Tag::Int(n.as_i64().unwrap() as i32), + Value::Array(a) => Tag::List(a.iter().map(tag).collect()), + Value::Object(o) => { + Tag::Compound(o.iter().map(|(k, v)| (k.as_str().into(), tag(v))).collect()) + } + _ => panic!("invalid registry metadata"), + } +} +fn registry(resources: &Path) -> Result<&'static BlockRegistry, Error> { + let facts: Value = serde_json::from_str(&fs::read_to_string(resources.join("facts.json"))?)?; + let registry = BlockRegistry::from_nbt(&Tag::compound([ + ("DataVersion", Tag::Int(DATA_VERSION)), + ( + "states", + Tag::List( + facts["states"] + .as_array() + .unwrap() + .iter() + .map(|v| tag(&v[4])) + .collect(), + ), + ), + ("defaults", tag(&facts["defaults"])), + ]))?; + Ok(Box::leak(Box::new(registry))) +} + +/// The material-stage fixture's chunk dump format. +fn dump(chunk: &ProtoChunk) -> Vec { + let terrain = &chunk.terrain; + let mut out = Vec::new(); + for section in 0..terrain.height() as usize / 16 { + out.push(format!("section {section}")); + let data = terrain.section(section).unwrap(); + for y in 0..16 { + for z in 0..16 { + let mut line = String::from("blocks"); + for x in 0..16 { + line += &format!(" {}", data.get((y << 8) | (z << 4) | x).unwrap().0); + } + out.push(line); + } + } + } + for kind in [HeightmapType::WorldSurfaceWg, HeightmapType::OceanFloorWg] { + out.push(format!("heightmap {}", kind.name())); + for word in terrain.heightmap(kind).unwrap().raw_data() { + out.push(format!("{word:x}")); + } + } + for (section, offsets) in terrain.postprocessing().iter().enumerate() { + out.push(format!("post {section} {}", offsets.len())); + out.extend(offsets.iter().map(u16::to_string)); + } + out +} + +/// Compare generated chunks with vanilla's post-carver dumps in server.txt. +fn verify(data: &std::sync::Arc, parity: &Path) -> Result<(), Error> { + let cases = [ + (-1i64, -2, 3), + (0x0123_4567_89ab_cdef, 1_875_000, -1_875_000), + ]; + let mut expected = Vec::new(); + for (seed, x, z) in cases { + let generator = OverworldGenerator::without_structures(data.clone(), seed)?; + let lines = dump(&generator.worker().generate_proto(ChunkPos::new(x, z))?); + if let Ok(path) = std::env::var("HORIZON_VERIFY_DUMP") { + fs::write(format!("{path}{seed}.txt"), lines.join("\n") + "\n")?; + } + expected.push((seed, lines)); + } + let mut matched = vec![false; expected.len()]; + let mut lines = BufReader::new(fs::File::open(parity.join("server.txt"))?).lines(); + let mut candidates = 0; + while let Some(line) = lines.next() { + if line? != "generatedcarving ok" { + continue; + } + candidates += 1; + // Each candidate dump is followed by other output; compare per case. + let mut active = (0..expected.len()).collect::>(); + let length = expected.iter().map(|(_, e)| e.len()).max().unwrap_or(0); + for i in 0..length { + let Some(line) = lines.next() else { break }; + let line = line?; + active.retain(|&c| { + let expected = &expected[c].1; + if i == expected.len() { + matched[c] = true; + } + i < expected.len() && expected[i] == line + }); + if active.is_empty() { + break; + } + } + for c in active { + matched[c] = true; + } + } + for ((seed, _), ok) in expected.iter().zip(&matched) { + println!( + "verify seed {seed}: {}", + if *ok { "MATCH" } else { "MISMATCH" } + ); + } + println!("({candidates} vanilla generated-terrain dumps scanned)"); + if matched.iter().all(|m| *m) { + Ok(()) + } else { + Err("generated chunks differ from vanilla".into()) + } +} + +/// Structure starts in the oracle's line format (VanillaStructureStartOracle). +fn dump_starts( + generator: &OverworldGenerator, + seed: i64, + [x0, z0, x1, z1]: [i32; 4], + out: &Path, +) -> Result<(), Error> { + use horizon_world::worldgen::structure::{Rotation, start::Piece}; + let _ = seed; + let mut worker = generator.worker(); + let mut lines = Vec::new(); + let start = Instant::now(); + for cx in x0..=x1 { + for cz in z0..=z1 { + for s in worker.structure_starts(ChunkPos::new(cx, cz)) { + let b = s.bounding_box; + lines.push(format!( + "start {cx} {cz} {} {} {} {} {} {} {} {}", + s.name, + b.min[0], + b.min[1], + b.min[2], + b.max[0], + b.max[1], + b.max[2], + s.pieces.len() + )); + for piece in &s.pieces { + let Piece::Pool(p) = piece else { + let b = piece.bounding_box(); + lines.push(format!( + "piece {} {} {} {} {} {} {}", + piece.type_name(), + b.min[0], + b.min[1], + b.min[2], + b.max[0], + b.max[1], + b.max[2] + )); + continue; + }; + let b = p.bounding_box; + let rotation = match p.rotation { + Rotation::None => "NONE", + Rotation::Clockwise90 => "CLOCKWISE_90", + Rotation::Clockwise180 => "CLOCKWISE_180", + Rotation::Counterclockwise90 => "COUNTERCLOCKWISE_90", + }; + lines.push(format!( + "piece minecraft:jigsaw {} {} {} {} {} {} {} {} {} {rotation} {} {}", + b.min[0], + b.min[1], + b.min[2], + b.max[0], + b.max[1], + b.max[2], + p.position[0], + p.position[1], + p.position[2], + p.ground_level_delta, + p.junctions.len() + )); + } + } + } + } + println!( + "structure starts for {} chunks in {:.2?}", + (x1 - x0 + 1) * (z1 - z0 + 1), + start.elapsed() + ); + fs::write(out, lines.join("\n") + "\n")?; + Ok(()) +} + +/// Process CPU seconds (Linux), robust against other load on shared machines. +fn cpu_seconds() -> f64 { + fs::read_to_string("/proc/self/stat") + .ok() + .and_then(|stat| { + let fields = stat + .rsplit_once(')')? + .1 + .split_whitespace() + .collect::>(); + Some((fields[11].parse::().ok()? + fields[12].parse::().ok()?) / 100.) + }) + .unwrap_or(0.) +} +fn glyph(name: &str) -> char { + let name = name.strip_prefix("minecraft:").unwrap_or(name); + match name { + "water" => '~', + "lava" => '!', + "dirt_path" => '_', + "cobblestone" | "mossy_cobblestone" => 'o', + "hay_block" => 'h', + _ if name.ends_with("planks") || name.ends_with("stairs") || name.ends_with("slab") => 'P', + _ if name.contains("glass") => 'g', + "grass_block" => '"', + "sand" | "suspicious_sand" => '.', + "red_sand" => ',', + "sandstone" | "red_sandstone" => '=', + "stone" | "deepslate" | "andesite" | "diorite" | "granite" | "tuff" => '#', + "gravel" => ':', + "dirt" | "coarse_dirt" | "rooted_dirt" => 'd', + "podzol" => 'p', + "mycelium" => 'm', + "mud" => 'u', + "snow" | "snow_block" | "powder_snow" => 's', + "ice" | "packed_ice" | "blue_ice" => 'i', + "clay" => 'c', + "calcite" => 'C', + _ if name.ends_with("terracotta") => 't', + _ if name.ends_with("leaves") => '*', + _ if name.ends_with("log") || name.ends_with("wood") => '|', + _ if name.contains("grass") || name.contains("fern") || name.contains("flower") => '\'', + _ => '?', + } +} + +fn main() -> Result<(), Error> { + let profile_boot = Instant::now(); + let mut args = std::env::args().skip(1); + let resources = PathBuf::from(args.next().expect("client resource directory")); + let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0)); + let mut parity = None; + let mut decorate = true; + let mut dimension = String::from("minecraft:overworld"); + let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None; + while let Some(arg) = args.next() { + let mut next = || args.next().expect("argument value"); + match arg.as_str() { + "--seed" => seed = next().parse()?, + "--size" => size = next().parse()?, + "--threads" => threads = next().parse()?, + "--center" => center = (next().parse()?, next().parse()?), + "--verify" => parity = Some(PathBuf::from(next())), + "--no-decorate" => decorate = false, + "--dimension" => { + let d = next(); + dimension = if d.contains(':') { + d + } else { + format!("minecraft:{d}") + }; + } + "--starts" => { + starts = Some(( + next().parse()?, + next().parse()?, + next().parse()?, + next().parse()?, + PathBuf::from(next()), + )) + } + _ => return Err(format!("unknown argument {arg}").into()), + } + } + let start = Instant::now(); + let registry = registry(&resources)?; + let data = GeneratorData::load(&resources.join("worldgen"), registry)?; + println!("loaded resources in {:.2?}", start.elapsed()); + if let Some(parity) = parity { + verify(&data, &parity)?; + } + let start = Instant::now(); + let generator = + OverworldGenerator::for_dimension(data.clone(), seed, "minecraft:normal", &dimension)?; + if std::env::var_os("HORIZON_LIST_UNSUPPORTED").is_some() { + for (feature, error) in generator.unsupported_features() { + println!("unsupported {feature}: {error}"); + } + } + println!("seeded generator in {:.2?}", start.elapsed()); + if let Some((x0, z0, x1, z1, out)) = starts { + dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?; + return Ok(()); + } + if std::env::var_os("HORIZON_PROFILE_WARM").is_some() { + let start = Instant::now(); + let mut warm = generator.worker(); + for z in 0..9 { for x in 0..9 { + let _ = warm.generate_proto(ChunkPos::new(center.0 + 64 + x, center.1 + 64 + z))?; + }} + println!("warmup_ms {:.6}", start.elapsed().as_secs_f64() * 1000.0); + } + println!("PROFILE_MEASURE_START {:.9}", profile_boot.elapsed().as_secs_f64()); + let (x0, z0) = (center.0 - size / 2, center.1 - size / 2); + let count = (size * size) as usize; + let next = AtomicUsize::new(0); + let slots: Vec>> = (0..count).map(|_| Mutex::new(None)).collect(); + let timings = Mutex::new(Vec::new()); + let cpu = cpu_seconds(); + let start = Instant::now(); + std::thread::scope(|scope| -> Result<(), Error> { + let handles = (0..threads) + .map(|_| { + scope.spawn(|| -> Result<(), Error> { + let mut worker = generator.worker(); + loop { + let i = next.fetch_add(1, Ordering::Relaxed); + if i >= count { + timings.lock().unwrap().push(worker.stage_timings()); + return Ok(()); + } + let pos = ChunkPos::new(x0 + (i as i32 % size), z0 + (i as i32 / size)); + *slots[i].lock().unwrap() = Some(worker.generate_proto(pos)?); + } + }) + }) + .collect::>(); + handles.into_iter().try_for_each(|h| h.join().unwrap()) + })?; + let elapsed = start.elapsed(); + println!("PROFILE_TERRAIN_END {:.9}", profile_boot.elapsed().as_secs_f64()); + println!( + "generated {count} proto chunks with {threads} threads in {elapsed:.2?}: {:.1} chunks/s ({:.1} ms/chunk/thread)", + count as f64 / elapsed.as_secs_f64(), + elapsed.as_secs_f64() * 1000. * threads as f64 / count as f64 + ); + println!( + " cpu time {:.1} ms/chunk", + (cpu_seconds() - cpu) * 1000. / count as f64 + ); + println!("PROFILE_WALL_MS_CHUNK {:.6}", elapsed.as_secs_f64() * 1000.0 / count as f64); + let timings = timings.into_inner().unwrap(); + let per_chunk = |f: fn(&StageTimings) -> std::time::Duration| { + timings + .iter() + .map(f) + .sum::() + .as_secs_f64() + * 1000. + / count as f64 + }; + println!("PROFILE_STAGES {}", serde_json::json!({ + "chunks": count, "threads": threads, + "biomes": per_chunk(|t| t.biomes), "structures": per_chunk(|t| t.structures), + "noise": per_chunk(|t| t.noise), "surface": per_chunk(|t| t.surface), + "carvers": per_chunk(|t| t.carvers), + "wall_ms_chunk": elapsed.as_secs_f64() * 1000.0 / count as f64, + })); + let mut chunks: Vec> = slots + .into_iter() + .map(|slot| slot.into_inner().unwrap()) + .collect(); + if decorate && size >= 3 { + let totals = Mutex::new(DecorateStats::default()); + let start = Instant::now(); + let mut decorated = 0; + // Disjoint 3×3 regions per phase can be decorated concurrently. + for phase in 0..9 { + let mut regions = Vec::new(); + for z in 1..size - 1 { + for x in 1..size - 1 { + if (x % 3) * 3 + z % 3 != phase { + continue; + } + let mut region = Vec::with_capacity(9); + for dz in -1..=1 { + for dx in -1..=1 { + region + .push(chunks[((z + dz) * size + x + dx) as usize].take().unwrap()); + } + } + regions.push(((x, z), region)); + } + } + decorated += regions.len(); + let queue = Mutex::new(regions); + let done = Mutex::new(Vec::new()); + std::thread::scope(|scope| -> Result<(), Error> { + let handles = (0..threads) + .map(|_| { + scope.spawn(|| -> Result<(), Error> { + let mut worker: GeneratorWorker = generator.worker(); + loop { + let Some((at, region)) = queue.lock().unwrap().pop() else { + return Ok(()); + }; + let mut region: [ProtoChunk; 9] = + region.try_into().map_err(|_| "region size")?; + let stats = worker.decorate(&mut region)?; + let mut totals = totals.lock().unwrap(); + totals.placed += stats.placed; + totals.unsupported += stats.unsupported; + totals.failed += stats.failed; + totals.skipped.extend(stats.skipped); + drop(totals); + done.lock().unwrap().push((at, region)); + } + }) + }) + .collect::>(); + handles.into_iter().try_for_each(|h| h.join().unwrap()) + })?; + for ((x, z), region) in done.into_inner().unwrap() { + for (i, chunk) in region.into_iter().enumerate() { + let (dx, dz) = (i as i32 % 3 - 1, i as i32 / 3 - 1); + chunks[((z + dz) * size + x + dx) as usize] = Some(chunk); + } + } + } + let elapsed = start.elapsed(); + let totals = totals.into_inner().unwrap(); + println!( + "decorated {decorated} chunks in {elapsed:.2?}: {:.1} chunks/s; feature roots placed {}, unsupported {}, failed {}", + decorated as f64 / elapsed.as_secs_f64(), + totals.placed, + totals.unsupported, + totals.failed + ); + if std::env::var_os("HORIZON_FEATURE_ERRORS").is_some() { + for (name, error) in generator.unsupported_features() { + println!("unsupported {name}: {error}"); + } + } + if !totals.skipped.is_empty() { + println!( + "skipped roots: {}", + totals.skipped.into_iter().collect::>().join(" ") + ); + } + } + println!("PROFILE_MEASURE_END {:.9}", profile_boot.elapsed().as_secs_f64()); + Ok(()) +} diff --git a/noise-aquifer-results/chunkgen_snapshot.rs b/noise-aquifer-results/chunkgen_snapshot.rs new file mode 100644 index 000000000..4411fc972 --- /dev/null +++ b/noise-aquifer-results/chunkgen_snapshot.rs @@ -0,0 +1,532 @@ +//! Chunk generation throughput and sanity map. +//! +//! chunkgen_bench [--seed S] [--size N] [--threads T] +//! [--center CX CZ] [--verify ] [--no-decorate] +//! [--dimension overworld|the_nether|the_end] +use horizon_core::position::ChunkPos; +use horizon_world::{ + DATA_VERSION, + heightmap::HeightmapType, + nbt::Tag, + registry::BlockRegistry, + worldgen::generator::{ + DecorateStats, GeneratorData, GeneratorWorker, OverworldGenerator, ProtoChunk, StageTimings, + }, +}; +use serde_json::Value; +use std::{ + collections::BTreeMap, + fs, + io::{BufRead, BufReader}, + path::{Path, PathBuf}, + sync::{ + Mutex, + atomic::{AtomicUsize, Ordering}, + }, + time::Instant, +}; + +type Error = Box; + +fn tag(v: &Value) -> Tag { + match v { + Value::String(s) => Tag::String(s.as_str().into()), + Value::Number(n) => Tag::Int(n.as_i64().unwrap() as i32), + Value::Array(a) => Tag::List(a.iter().map(tag).collect()), + Value::Object(o) => { + Tag::Compound(o.iter().map(|(k, v)| (k.as_str().into(), tag(v))).collect()) + } + _ => panic!("invalid registry metadata"), + } +} +fn registry(resources: &Path) -> Result<&'static BlockRegistry, Error> { + let facts: Value = serde_json::from_str(&fs::read_to_string(resources.join("facts.json"))?)?; + let registry = BlockRegistry::from_nbt(&Tag::compound([ + ("DataVersion", Tag::Int(DATA_VERSION)), + ( + "states", + Tag::List( + facts["states"] + .as_array() + .unwrap() + .iter() + .map(|v| tag(&v[4])) + .collect(), + ), + ), + ("defaults", tag(&facts["defaults"])), + ]))?; + Ok(Box::leak(Box::new(registry))) +} + +/// The material-stage fixture's chunk dump format. +fn dump(chunk: &ProtoChunk) -> Vec { + let terrain = &chunk.terrain; + let mut out = Vec::new(); + for section in 0..terrain.height() as usize / 16 { + out.push(format!("section {section}")); + let data = terrain.section(section).unwrap(); + for y in 0..16 { + for z in 0..16 { + let mut line = String::from("blocks"); + for x in 0..16 { + line += &format!(" {}", data.get((y << 8) | (z << 4) | x).unwrap().0); + } + out.push(line); + } + } + } + for kind in [HeightmapType::WorldSurfaceWg, HeightmapType::OceanFloorWg] { + out.push(format!("heightmap {}", kind.name())); + for word in terrain.heightmap(kind).unwrap().raw_data() { + out.push(format!("{word:x}")); + } + } + for (section, offsets) in terrain.postprocessing().iter().enumerate() { + out.push(format!("post {section} {}", offsets.len())); + out.extend(offsets.iter().map(u16::to_string)); + } + out +} + +/// Compare generated chunks with vanilla's post-carver dumps in server.txt. +fn verify(data: &std::sync::Arc, parity: &Path) -> Result<(), Error> { + let cases = [ + (-1i64, -2, 3), + (0x0123_4567_89ab_cdef, 1_875_000, -1_875_000), + ]; + let mut expected = Vec::new(); + for (seed, x, z) in cases { + let generator = OverworldGenerator::without_structures(data.clone(), seed)?; + let lines = dump(&generator.worker().generate_proto(ChunkPos::new(x, z))?); + if let Ok(path) = std::env::var("HORIZON_VERIFY_DUMP") { + fs::write(format!("{path}{seed}.txt"), lines.join("\n") + "\n")?; + } + expected.push((seed, lines)); + } + let mut matched = vec![false; expected.len()]; + let mut lines = BufReader::new(fs::File::open(parity.join("server.txt"))?).lines(); + let mut candidates = 0; + while let Some(line) = lines.next() { + if line? != "generatedcarving ok" { + continue; + } + candidates += 1; + // Each candidate dump is followed by other output; compare per case. + let mut active = (0..expected.len()).collect::>(); + let length = expected.iter().map(|(_, e)| e.len()).max().unwrap_or(0); + for i in 0..length { + let Some(line) = lines.next() else { break }; + let line = line?; + active.retain(|&c| { + let expected = &expected[c].1; + if i == expected.len() { + matched[c] = true; + } + i < expected.len() && expected[i] == line + }); + if active.is_empty() { + break; + } + } + for c in active { + matched[c] = true; + } + } + for ((seed, _), ok) in expected.iter().zip(&matched) { + println!( + "verify seed {seed}: {}", + if *ok { "MATCH" } else { "MISMATCH" } + ); + } + println!("({candidates} vanilla generated-terrain dumps scanned)"); + if matched.iter().all(|m| *m) { + Ok(()) + } else { + Err("generated chunks differ from vanilla".into()) + } +} + +/// Structure starts in the oracle's line format (VanillaStructureStartOracle). +fn dump_starts( + generator: &OverworldGenerator, + seed: i64, + [x0, z0, x1, z1]: [i32; 4], + out: &Path, +) -> Result<(), Error> { + use horizon_world::worldgen::structure::{Rotation, start::Piece}; + let _ = seed; + let mut worker = generator.worker(); + let mut lines = Vec::new(); + let start = Instant::now(); + for cx in x0..=x1 { + for cz in z0..=z1 { + for s in worker.structure_starts(ChunkPos::new(cx, cz)) { + let b = s.bounding_box; + lines.push(format!( + "start {cx} {cz} {} {} {} {} {} {} {} {}", + s.name, + b.min[0], + b.min[1], + b.min[2], + b.max[0], + b.max[1], + b.max[2], + s.pieces.len() + )); + for piece in &s.pieces { + let Piece::Pool(p) = piece else { + let b = piece.bounding_box(); + lines.push(format!( + "piece {} {} {} {} {} {} {}", + piece.type_name(), + b.min[0], + b.min[1], + b.min[2], + b.max[0], + b.max[1], + b.max[2] + )); + continue; + }; + let b = p.bounding_box; + let rotation = match p.rotation { + Rotation::None => "NONE", + Rotation::Clockwise90 => "CLOCKWISE_90", + Rotation::Clockwise180 => "CLOCKWISE_180", + Rotation::Counterclockwise90 => "COUNTERCLOCKWISE_90", + }; + lines.push(format!( + "piece minecraft:jigsaw {} {} {} {} {} {} {} {} {} {rotation} {} {}", + b.min[0], + b.min[1], + b.min[2], + b.max[0], + b.max[1], + b.max[2], + p.position[0], + p.position[1], + p.position[2], + p.ground_level_delta, + p.junctions.len() + )); + } + } + } + } + println!( + "structure starts for {} chunks in {:.2?}", + (x1 - x0 + 1) * (z1 - z0 + 1), + start.elapsed() + ); + fs::write(out, lines.join("\n") + "\n")?; + Ok(()) +} + +/// Process CPU seconds (Linux), robust against other load on shared machines. +fn cpu_seconds() -> f64 { + fs::read_to_string("/proc/self/stat") + .ok() + .and_then(|stat| { + let fields = stat + .rsplit_once(')')? + .1 + .split_whitespace() + .collect::>(); + Some((fields[11].parse::().ok()? + fields[12].parse::().ok()?) / 100.) + }) + .unwrap_or(0.) +} +fn glyph(name: &str) -> char { + let name = name.strip_prefix("minecraft:").unwrap_or(name); + match name { + "water" => '~', + "lava" => '!', + "dirt_path" => '_', + "cobblestone" | "mossy_cobblestone" => 'o', + "hay_block" => 'h', + _ if name.ends_with("planks") || name.ends_with("stairs") || name.ends_with("slab") => 'P', + _ if name.contains("glass") => 'g', + "grass_block" => '"', + "sand" | "suspicious_sand" => '.', + "red_sand" => ',', + "sandstone" | "red_sandstone" => '=', + "stone" | "deepslate" | "andesite" | "diorite" | "granite" | "tuff" => '#', + "gravel" => ':', + "dirt" | "coarse_dirt" | "rooted_dirt" => 'd', + "podzol" => 'p', + "mycelium" => 'm', + "mud" => 'u', + "snow" | "snow_block" | "powder_snow" => 's', + "ice" | "packed_ice" | "blue_ice" => 'i', + "clay" => 'c', + "calcite" => 'C', + _ if name.ends_with("terracotta") => 't', + _ if name.ends_with("leaves") => '*', + _ if name.ends_with("log") || name.ends_with("wood") => '|', + _ if name.contains("grass") || name.contains("fern") || name.contains("flower") => '\'', + _ => '?', + } +} + +fn main() -> Result<(), Error> { + let profile_boot = Instant::now(); + let mut args = std::env::args().skip(1); + let resources = PathBuf::from(args.next().expect("client resource directory")); + let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0)); + let mut parity = None; + let mut decorate = true; + let mut dimension = String::from("minecraft:overworld"); + let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None; + while let Some(arg) = args.next() { + let mut next = || args.next().expect("argument value"); + match arg.as_str() { + "--seed" => seed = next().parse()?, + "--size" => size = next().parse()?, + "--threads" => threads = next().parse()?, + "--center" => center = (next().parse()?, next().parse()?), + "--verify" => parity = Some(PathBuf::from(next())), + "--no-decorate" => decorate = false, + "--dimension" => { + let d = next(); + dimension = if d.contains(':') { + d + } else { + format!("minecraft:{d}") + }; + } + "--starts" => { + starts = Some(( + next().parse()?, + next().parse()?, + next().parse()?, + next().parse()?, + PathBuf::from(next()), + )) + } + _ => return Err(format!("unknown argument {arg}").into()), + } + } + let start = Instant::now(); + let registry = registry(&resources)?; + let data = GeneratorData::load(&resources.join("worldgen"), registry)?; + println!("loaded resources in {:.2?}", start.elapsed()); + if let Some(parity) = parity { + verify(&data, &parity)?; + } + let start = Instant::now(); + let generator = + OverworldGenerator::for_dimension(data.clone(), seed, "minecraft:normal", &dimension)?; + if std::env::var_os("HORIZON_LIST_UNSUPPORTED").is_some() { + for (feature, error) in generator.unsupported_features() { + println!("unsupported {feature}: {error}"); + } + } + println!("seeded generator in {:.2?}", start.elapsed()); + if let Some((x0, z0, x1, z1, out)) = starts { + dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?; + return Ok(()); + } + if std::env::var_os("HORIZON_PROFILE_WARM").is_some() { + let start = Instant::now(); + let mut warm = generator.worker(); + for z in 0..9 { for x in 0..9 { + let _ = warm.generate_proto(ChunkPos::new(center.0 + 64 + x, center.1 + 64 + z))?; + }} + println!("warmup_ms {:.6}", start.elapsed().as_secs_f64() * 1000.0); + } + println!("PROFILE_MEASURE_START {:.9}", profile_boot.elapsed().as_secs_f64()); + let (x0, z0) = (center.0 - size / 2, center.1 - size / 2); + let count = (size * size) as usize; + let next = AtomicUsize::new(0); + let slots: Vec>> = (0..count).map(|_| Mutex::new(None)).collect(); + let timings = Mutex::new(Vec::new()); + let cpu = cpu_seconds(); + let start = Instant::now(); + std::thread::scope(|scope| -> Result<(), Error> { + let handles = (0..threads) + .map(|_| { + scope.spawn(|| -> Result<(), Error> { + let mut worker = generator.worker(); + loop { + let i = next.fetch_add(1, Ordering::Relaxed); + if i >= count { + timings.lock().unwrap().push(worker.stage_timings()); + return Ok(()); + } + let pos = ChunkPos::new(x0 + (i as i32 % size), z0 + (i as i32 / size)); + *slots[i].lock().unwrap() = Some(worker.generate_proto(pos)?); + } + }) + }) + .collect::>(); + handles.into_iter().try_for_each(|h| h.join().unwrap()) + })?; + let elapsed = start.elapsed(); + println!("PROFILE_TERRAIN_END {:.9}", profile_boot.elapsed().as_secs_f64()); + println!( + "generated {count} proto chunks with {threads} threads in {elapsed:.2?}: {:.1} chunks/s ({:.1} ms/chunk/thread)", + count as f64 / elapsed.as_secs_f64(), + elapsed.as_secs_f64() * 1000. * threads as f64 / count as f64 + ); + println!( + " cpu time {:.1} ms/chunk", + (cpu_seconds() - cpu) * 1000. / count as f64 + ); + println!("PROFILE_WALL_MS_CHUNK {:.6}", elapsed.as_secs_f64() * 1000.0 / count as f64); + let timings = timings.into_inner().unwrap(); + let per_chunk = |f: fn(&StageTimings) -> std::time::Duration| { + timings + .iter() + .map(f) + .sum::() + .as_secs_f64() + * 1000. + / count as f64 + }; + println!("PROFILE_STAGES {}", serde_json::json!({ + "chunks": count, "threads": threads, + "biomes": per_chunk(|t| t.biomes), "structures": per_chunk(|t| t.structures), + "noise": per_chunk(|t| t.noise), "surface": per_chunk(|t| t.surface), + "carvers": per_chunk(|t| t.carvers), + "wall_ms_chunk": elapsed.as_secs_f64() * 1000.0 / count as f64, + })); + let mut chunks: Vec> = slots + .into_iter() + .map(|slot| slot.into_inner().unwrap()) + .collect(); + snapshot(&chunks, "terrain")?; + if decorate && size >= 3 { + let totals = Mutex::new(DecorateStats::default()); + let start = Instant::now(); + let mut decorated = 0; + // Disjoint 3×3 regions per phase can be decorated concurrently. + for phase in 0..9 { + let mut regions = Vec::new(); + for z in 1..size - 1 { + for x in 1..size - 1 { + if (x % 3) * 3 + z % 3 != phase { + continue; + } + let mut region = Vec::with_capacity(9); + for dz in -1..=1 { + for dx in -1..=1 { + region + .push(chunks[((z + dz) * size + x + dx) as usize].take().unwrap()); + } + } + regions.push(((x, z), region)); + } + } + decorated += regions.len(); + let queue = Mutex::new(regions); + let done = Mutex::new(Vec::new()); + std::thread::scope(|scope| -> Result<(), Error> { + let handles = (0..threads) + .map(|_| { + scope.spawn(|| -> Result<(), Error> { + let mut worker: GeneratorWorker = generator.worker(); + loop { + let Some((at, region)) = queue.lock().unwrap().pop() else { + return Ok(()); + }; + let mut region: [ProtoChunk; 9] = + region.try_into().map_err(|_| "region size")?; + let stats = worker.decorate(&mut region)?; + let mut totals = totals.lock().unwrap(); + totals.placed += stats.placed; + totals.unsupported += stats.unsupported; + totals.failed += stats.failed; + totals.skipped.extend(stats.skipped); + drop(totals); + done.lock().unwrap().push((at, region)); + } + }) + }) + .collect::>(); + handles.into_iter().try_for_each(|h| h.join().unwrap()) + })?; + for ((x, z), region) in done.into_inner().unwrap() { + for (i, chunk) in region.into_iter().enumerate() { + let (dx, dz) = (i as i32 % 3 - 1, i as i32 / 3 - 1); + chunks[((z + dz) * size + x + dx) as usize] = Some(chunk); + } + } + } + let elapsed = start.elapsed(); + let totals = totals.into_inner().unwrap(); + println!( + "decorated {decorated} chunks in {elapsed:.2?}: {:.1} chunks/s; feature roots placed {}, unsupported {}, failed {}", + decorated as f64 / elapsed.as_secs_f64(), + totals.placed, + totals.unsupported, + totals.failed + ); + if std::env::var_os("HORIZON_FEATURE_ERRORS").is_some() { + for (name, error) in generator.unsupported_features() { + println!("unsupported {name}: {error}"); + } + } + if !totals.skipped.is_empty() { + println!( + "skipped roots: {}", + totals.skipped.into_iter().collect::>().join(" ") + ); + } + } + snapshot(&chunks, "decorated")?; + println!("PROFILE_MEASURE_END {:.9}", profile_boot.elapsed().as_secs_f64()); + Ok(()) +} + +// Diagnostic only: full ordered chunk state, outside performance measurements. +fn snapshot(chunks: &[Option], phase: &str) -> Result<(), Error> { + use std::io::Write; + let path = std::env::var("HORIZON_SNAPSHOT_PATH")?; + let mut out = std::io::BufWriter::new(fs::File::create(format!("{path}-{phase}.bin"))?); + for chunk in chunks.iter().flatten() { + let terrain = &chunk.terrain; + writeln!(out, "chunk {:?} {:?} {} {:?} {:?}", chunk.position(), terrain.generation_stage(), chunk.is_decorated(), chunk.structures(), terrain.below_zero_retrogen().map(|v| v.to_nbt()))?; + writeln!(out, "nonair {:?}", terrain.diagnostic_non_air_counts())?; + for section in 0..terrain.height() as usize / 16 { + let data = terrain.section(section).unwrap(); + writeln!(out, "section {section} {:?}", data.to_nbt()?)?; + for index in 0..4096 { + out.write_all(&data.get(index)?.0.to_le_bytes())?; + } + } + // Compare public reads too, including all-air section behavior. + for y in terrain.min_y()..terrain.min_y()+terrain.height() { + for z in 0..16 { + for x in 0..16 { + out.write_all(&terrain.block(x, y, z).0.to_le_bytes())?; + } + } + } + for y in (terrain.min_y()>>2)..((terrain.min_y()+terrain.height())>>2) { + for z in 0..4 { + for x in 0..4 { + writeln!(out, "biome {}", chunk.biome_at(chunk.position().x*16+x*4, y*4, chunk.position().z*16+z*4))?; + } + } + } + for kind in HeightmapType::ALL { + writeln!(out, "heightmap {kind:?} {:?}", terrain.heightmap(kind).map(|m| m.raw_data()))?; + } + writeln!(out, "post {:?}", terrain.postprocessing())?; + writeln!(out, "blockticks {:?}", terrain.block_ticks().pack(0))?; + writeln!(out, "fluidticks {:?}", terrain.fluid_ticks().pack(0))?; + for (position, tag) in &chunk.block_entities { + writeln!(out, "blockentity {position:?}")?; + let bytes = horizon_world::nbt::write_network(&Tag::Compound(tag.clone()), Default::default())?; + out.write_all(&(bytes.len() as u64).to_le_bytes())?; + out.write_all(&bytes)?; + } + let entities = Tag::List(chunk.entities.iter().cloned().map(Tag::Compound).collect()); + let bytes = horizon_world::nbt::write_network(&entities, Default::default())?; + out.write_all(&(bytes.len() as u64).to_le_bytes())?; + out.write_all(&bytes)?; + } + out.flush()?; + Ok(()) +} diff --git a/noise-aquifer-results/core-final-tests.log b/noise-aquifer-results/core-final-tests.log new file mode 100644 index 000000000..f71df48d8 --- /dev/null +++ b/noise-aquifer-results/core-final-tests.log @@ -0,0 +1,105 @@ + Compiling horizon-core v0.1.0 (/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56/crates/horizon-core) + Finished `fast` profile [optimized] target(s) in 2.46s + Running unittests src/lib.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/horizon_core-79709449cb32c90a) + +running 86 tests +test density::graph::tests::compiler_reduces_uniform_axes_and_preserves_strided_vertical_samples ... ok +test density::graph::tests::failed_parent_preparation_retains_successful_child_and_consumes_new_id_on_retry ... ok +test density::graph::tests::min_range_elimination_is_strict_and_does_not_skip_child_compilation ... ok +test density::graph::tests::interval_threshold_equality_and_hashing_preserve_distinct_cache_inputs ... ok +test density::graph::tests::end_islands_use_the_world_seed_independently_of_the_noise_algorithm ... ok +test density::graph::tests::noise_specialization_requires_literal_positive_zero_shifts ... ok +test density::graph::tests::power_literal_selection_retains_signed_zeros_and_negative_fallback_behavior ... ok +test density::graph::tests::rounding_specializes_only_literal_one_and_preserves_input_on_multiple_failure ... ok +test density::graph::tests::registered_noises_share_ordinary_instances_and_recreate_nether_instances ... ok +test density::graph::tests::spline_coordinates_share_bulk_evaluation_after_graph_rewriting ... ok +test density::graph::tests::spline_range_early_return_does_not_skip_coordinate_validation_during_compilation ... ok +test density::graph::tests::structural_identity_preserves_java_float_keys_and_shared_cache_ids ... ok +test density::tests::blended_fbm_work_bound_rejects_before_random_draws ... ok +test density::tests::bulk_choice_evaluates_in_range_before_a_failing_selector ... ok +test density::tests::cache_returns_filled_failure_buffer_on_the_next_volume_request ... ok +test density::tests::grid_interpolation_keeps_incremental_bulk_rounding ... ok +test density::tests::grid_interpolation_uses_child_bulk_corners_and_preserves_aligned_delegation ... ok +test density::tests::interval_branch_errors_keep_selector_output_and_return_scratch ... ok +test density::tests::invalid_buffer_is_rejected_before_child_evaluation ... ok +test density::tests::monotonic_mapping_skips_nai_and_rejects_nan_after_both_endpoints ... ok +test density::tests::range_arithmetic_and_zero_equality_match_reference_special_cases ... ok +test density::tests::scalar_shortcuts_and_bulk_arithmetic_keep_distinct_results ... ok +test density::tests::scratch_returns_to_context_after_nested_sampling_errors ... ok +test density::tests::shift_b_repeats_each_horizontal_sample_and_preserves_tail ... ok +test density::tests::slices_delegate_matching_volumes_and_isolate_reduced_child_failures ... ok +test density::tests::slices_preserve_reduced_volume_steps_in_cached_children ... ok +test density::tests::spline_coordinate_cache_retries_nan_scalars_but_reuses_nan_volumes ... ok +test density::tests::spline_lazy_branch_failure_preserves_completed_output_and_returns_scratch ... ok +test density::tests::surface_bulk_preserves_upper_bound_writes_and_sliced_error_isolation ... ok +test density::tests::surface_search_fixes_upper_bound_y_and_visits_descending_cell_boundaries ... ok +test density::tests::unary_bulk_keeps_child_failure_writes_and_full_buffer_tail ... ok +test density::tests::tail_writes_follow_the_selected_bulk_sampler ... ok +test density::tests::volume_lookup_requires_exact_lattice_and_preserves_java_overflow ... ok +test geometry::border::tests::invalid_parameters_leave_existing_extent_unchanged ... ok +test geometry::movement::fallible_tests::owned_collision_queries_stop_at_first_failure ... ok +test geometry::movement::tests::floor_height_defers_the_lower_lookup_until_empty ... ok +test geometry::movement::tests::movement_slides_after_a_wall_collision ... ok +test geometry::movement::tests::squared_length_underflow_skips_collection_and_keeps_signed_zero ... ok +test geometry::movement::tests::step_heights_deduplicate_and_exclude_current_y ... ok +test geometry::movement::tests::stepping_requeries_and_clears_a_half_block ... ok +test geometry::shape::create::tests::optimization_restores_composite_shapes ... ok +test geometry::shape::create::tests::quantization_thin_boxes_and_shared_block_identity ... ok +test geometry::shape::create::tests::quantized_empty_boxes_keep_independent_axis_extrema ... ok +test geometry::shape::face::tests::face_cache_is_lazy_shared_and_does_not_retain_parent ... ok +test geometry::shape::join::tests::returned_shapes_preserve_alias_identity ... ok +test geometry::shape::join::tests::signed_zero_list_equality_preserves_first_coordinates ... ok +test geometry::shape::join::tests::unions_intersections_difference_and_rejection ... ok +test geometry::shape::tests::sparse_stair_decomposition ... ok +test geometry::shape::tests::stop_at_obstacle_and_reuse_boxes ... ok +test geometry::sweep::tests::tiny_movement_includes_maximum_faces_and_stops_immediately ... ok +test geometry::tests::numerical_boundaries ... ok +test geometry::tests::ray_faces_and_half_open_bounds ... ok +test geometry::traversal::tests::corner_order_and_early_exit ... ok +test geometry::traversal::tests::miss_zero_identity_and_budget_errors ... ok +test geometry::trig::tests::atan2_matches_the_client_tables ... ok +test geometry::trig::tests::fdlibm_atan2_matches_java_math_atan2 ... ok +test jmath::tests::matches_hotspot_on_aarch64 ... ok +test noise::tests::bulk_accumulation_preserves_tail_and_rejects_short_buffers_before_writes ... ok +test noise::tests::density_dimensions_are_bounded_and_coordinates_wrap ... ok +test noise::tests::normal_noise_reference_values_and_legacy_failure_draws ... ok +test noise::tests::stack_snapshots_share_layers_and_preserve_zero_amplitude_semantics ... ok +test noise::tests::vanilla_seed_zero_samples_and_derivatives ... ok +test paletted::tests::rejects_malformed_wire_data ... ok +test position::iter::tests::ordering_inclusive_faces_and_value_independence ... ok +test paletted::tests::uniform_detection_ignores_stale_palette_entries ... ok +test position::tests::negative_boundaries_use_floor_division ... ok +test paletted::tests::grows_through_vanilla_widths ... ok +test position::tests::coordinate_formats_are_distinct_and_bijective_in_range ... ok +test position::tests::packed_signed_limits_and_java_overflow ... ok +test random::tests::invalid_inputs_preserve_both_streams ... ok +test random::hash::tests::rfc_vectors_and_streaming_padding_boundaries ... ok +test paletted::tests::division_magic_is_exact ... ok +test random::tests::legacy_jdk_sequence_and_sign_extended_low_word ... ok +test random::tests::zero_state_fallback_and_reseed ... ok +test storage::tests::imported_padding_is_preserved_and_invalid_writes_are_atomic ... ok +test storage::tests::padded_words_never_split_entries ... ok +test ticks::tests::callback_scheduling_waits_until_the_next_collection ... ok +test ticks::tests::collection_guards_and_membership_survive_area_mutation ... ok +test ticks::tests::copying_active_ticks_preserves_relative_order_and_wraps ... ok +test ticks::tests::disabled_and_removed_chunks_retain_their_queue ... ok +test ticks::tests::due_chunks_compete_by_priority_not_trigger_time ... ok +test ticks::tests::pending_ticks_keep_list_order_and_java_time_overflow ... ok +test geometry::trig::tests::long_narrowing_and_quadrants ... ok +test storage::tests::all_widths_survive_overwrites_and_unpack ... ok +test paletted::tests::matches_a_plain_array_under_random_edits ... ok +test density::arithmetic::bulk_tests::fixed_operation_loops_preserve_float_bits ... ok + +test result: ok. 86 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/density_world_fields.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/density_world_fields-43fc47aef9e786bd) + +running 6 tests +test absent_fields_use_vanilla_defaults_including_buffer_tails ... ok +test blending_range_and_axes_follow_input_even_for_spatial_providers ... ok +test blending_visits_z_x_y_and_preserves_the_input_tail ... ok +test failed_input_prevents_blender_lookup_and_preserves_partial_writes ... ok +test fields_resolve_through_the_same_context_and_replace_cached_values ... ok +test named_reference_identity_differs_from_direct_value_equality ... ok + +test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s diff --git a/noise-aquifer-results/density-parity.json b/noise-aquifer-results/density-parity.json new file mode 100644 index 000000000..59b272f11 --- /dev/null +++ b/noise-aquifer-results/density-parity.json @@ -0,0 +1,40 @@ +{ + "minecraft": { + "version": "26.3", + "manifest_sha1": "11f1aefe473eefba0af62e3286c33b692807b2eb", + "accepted_manifest_sha1": [ + "4fe1aa1ef8da1cb95c5bad1fb98890ca56dd8ca3", + "702fe59163c6ee6578607daa85811d9bc9c7cc40" + ], + "accepted_manifest_note": "Earlier 26.3 version JSONs Mojang republished: only assetIndex differs (non-English translations), jars and libraries are identical. A launcher may still hold any of them.", + "client_sha1": "e877b6a07acd633fb3bb475002175cec036e7b87", + "server_sha1": "33680f5f2ac32864d6d7cf5e56a705fdb3e05f4c", + "java_major": 25 + }, + "profile": "fast", + "binary_sha256": "c3c042098409f9bb2aa2f3c92bca70c803474e2a4af32c4afc0d9cebeb111ca4", + "inputs_sha256": "3bb59de57994936c7347c504b212900f9ec7c3c3eff1f0e49c051b46d23bed97", + "references": [ + { + "side": "client", + "jar_sha256": "4508d006323f24fa02876310c192d739af56516eb259000ac50f0909a68c9a2d", + "output_sha256": "e1fcf55d697acd4d0f6470079416c5cae2cbc75d524f8f7aee50b5555f2c330d", + "matched_output_lines": 15524627 + }, + { + "side": "server", + "jar_sha256": "a362163eec5d1612d520772bc16e5b39c09e3b234fdc045f56bf544284ee8ae6", + "output_sha256": "e1fcf55d697acd4d0f6470079416c5cae2cbc75d524f8f7aee50b5555f2c330d", + "matched_output_lines": 15524627 + } + ], + "rust_output_sha256": "e1fcf55d697acd4d0f6470079416c5cae2cbc75d524f8f7aee50b5555f2c330d", + "oracle_source_sha256": "0be907c58f2bb35f924b1c42919397cdfc0c38f7be500e26c5d462f46aaf1f08", + "corpus_script_sha256": "ab052eb065a0ae0c0469e95335b952153adbb01f46b5d12ad075fc1a5a8ec0d0", + "runner_sha256": "69b75444b14fd71da7abc89ac5c83992de48c526b6f7723b8a20ed7185e517b4", + "sources_sha256": { + "crates/horizon-core/src/density/arithmetic.rs": "82f521e11756cc4455c31e7cacc4587deba2e4bbe08f8bb16c08d7e1f8d76b4b", + "crates/horizon-core/src/density/tests.rs": "422a3cf804b30c1de5fe4c3527c224dbc39dd2d1999358f21663069a28977dde" + }, + "scope": "Existing corpus authenticated against prior report and unchanged generator/oracle source; candidate and both checksum-pinned Java sides run freshly; density parity, not whole-game parity." +} diff --git a/noise-aquifer-results/environment.json b/noise-aquifer-results/environment.json new file mode 100644 index 000000000..c04765b23 --- /dev/null +++ b/noise-aquifer-results/environment.json @@ -0,0 +1,14 @@ +{ + "baseline_commit": "e4f8154cb4115aa1ee622381d9b12387cdf515d4", + "branch": "t3/optimize-noise-aquifers", + "worktree": "/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)", + "kernel": "Linux-7.2.11-zen1-1-zen-x86_64-with-glibc2.44", + "cpu": "AMD Ryzen 5 5600X, 6 cores / 12 logical CPUs", + "ram": "32 GiB", + "resources": "/srv/bob-data/horizon/.local/horizon-client/26.3", + "target": "/srv/bob-data/horizon-stage3d-target", + "fast_symlink_target": "/tmp/horizon-density-eval/fast-build", + "build": "fast inherits release; LTO false, codegen-units 16, incremental true", + "concurrency": "Builds and benchmarks sequential, no simultaneous benchmarks launched by this task; desktop/background load not isolated" +} diff --git a/noise-aquifer-results/final-codegen-check.json b/noise-aquifer-results/final-codegen-check.json new file mode 100644 index 000000000..610fe7340 --- /dev/null +++ b/noise-aquifer-results/final-codegen-check.json @@ -0,0 +1,21 @@ +[ + { + "build": "measured", + "binary_sha256": "198f60a68b2616aa394861c517297d4a14cc0949e3b56600905b6f86c05e59b8", + ".text": "94d45a6a5d83cc428a43fd871d014b6204b8f3d92ee05b9d16aeecf3e67344a7", + ".rodata": "410e1aa0482533b5927b75ea7c7b2385b697fe4d1d7872744a5dcdf2c0133796", + ".data.rel.ro": "6f5bddbfa8ca9c8bd560a467e73d8b20d17bd0323ad3bc048304464fcc8e3767" + }, + { + "build": "final", + "binary_sha256": "bafd0f9342260b1cac2a1d0f6708dfef721389253cec0472a1ecb4895d71b3af", + ".text": "94d45a6a5d83cc428a43fd871d014b6204b8f3d92ee05b9d16aeecf3e67344a7", + ".rodata": "410e1aa0482533b5927b75ea7c7b2385b697fe4d1d7872744a5dcdf2c0133796", + ".data.rel.ro": "ac71cb66d3b8ecbcd8bee8bd8b6c9fd8ca6ea64651267fb8e352c0d82be76286" + }, + { + "changed_data_rel_ro_u32_words": 12, + "all_decreased_by_four": true, + "interpretation": "Source-location line numbers after removing four diagnostic accessor lines; .text and .rodata byte-identical." + } +] diff --git a/noise-aquifer-results/gate-raw.json b/noise-aquifer-results/gate-raw.json new file mode 100644 index 000000000..8bec366c1 --- /dev/null +++ b/noise-aquifer-results/gate-raw.json @@ -0,0 +1,530 @@ +[ + { + "biomes": 0.43547596875, + "carvers": 0.39140908203125, + "chunks": 256, + "noise": 5.2948666367187505, + "structures": 1.1794168828125, + "surface": 3.37029921484375, + "threads": 1, + "wall_ms_chunk": 10.72101433984375, + "version": "candidate", + "repeat": -1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 503.33, + "combined_ms_chunk": 12.68714715234375, + "terrain_cpu_ms_chunk": 10.5, + "process_user_s": 8.180593, + "process_system_s": 0.28079, + "peak_rss_kib": 787192 + }, + { + "biomes": 0.4439284296875, + "carvers": 0.37917393359375, + "chunks": 256, + "noise": 5.77808341796875, + "structures": 1.1781649609375, + "surface": 4.4398382421875, + "threads": 1, + "wall_ms_chunk": 12.26891484765625, + "version": "baseline", + "repeat": -1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 497.61, + "combined_ms_chunk": 14.21270391015625, + "terrain_cpu_ms_chunk": 12.2, + "process_user_s": 8.713481, + "process_system_s": 0.28895299999999996, + "peak_rss_kib": 786884 + }, + { + "biomes": 0.4295055625, + "carvers": 0.38291098046875, + "chunks": 256, + "noise": 5.773962269531251, + "structures": 1.16812175, + "surface": 4.4673708046875, + "threads": 1, + "wall_ms_chunk": 12.2709350703125, + "version": "baseline", + "repeat": 0, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 504.5, + "combined_ms_chunk": 14.2416381953125, + "terrain_cpu_ms_chunk": 12.2, + "process_user_s": 8.733129, + "process_system_s": 0.27940699999999996, + "peak_rss_kib": 786812 + }, + { + "biomes": 0.421953875, + "carvers": 0.37140534765625, + "chunks": 256, + "noise": 5.1102533515625, + "structures": 1.1586842109375, + "surface": 3.2626291484375, + "threads": 1, + "wall_ms_chunk": 10.37302974609375, + "version": "candidate", + "repeat": 0, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 496.42, + "combined_ms_chunk": 12.31217037109375, + "terrain_cpu_ms_chunk": 10.3, + "process_user_s": 8.237949, + "process_system_s": 0.315424, + "peak_rss_kib": 786412 + }, + { + "biomes": 0.42579529687499995, + "carvers": 0.376251890625, + "chunks": 256, + "noise": 5.187435171875, + "structures": 1.1964910312500001, + "surface": 3.29565119140625, + "threads": 1, + "wall_ms_chunk": 10.53004565234375, + "version": "candidate", + "repeat": 1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 492.9, + "combined_ms_chunk": 12.45543627734375, + "terrain_cpu_ms_chunk": 10.5, + "process_user_s": 8.133229, + "process_system_s": 0.272889, + "peak_rss_kib": 786808 + }, + { + "biomes": 0.4297166484375, + "carvers": 0.37644830078124997, + "chunks": 256, + "noise": 5.772878597656249, + "structures": 1.17804449609375, + "surface": 4.470543871093749, + "threads": 1, + "wall_ms_chunk": 12.276752472656248, + "version": "baseline", + "repeat": 1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 492.99, + "combined_ms_chunk": 14.202494660156248, + "terrain_cpu_ms_chunk": 12.1, + "process_user_s": 8.719636, + "process_system_s": 0.275497, + "peak_rss_kib": 786532 + }, + { + "biomes": 0.44423383203125, + "carvers": 0.37403341015625, + "chunks": 256, + "noise": 5.775249617187501, + "structures": 1.1649090039062502, + "surface": 4.4796617226562505, + "threads": 1, + "wall_ms_chunk": 12.28674475390625, + "version": "baseline", + "repeat": 2, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 497.65, + "combined_ms_chunk": 14.23069006640625, + "terrain_cpu_ms_chunk": 12.3, + "process_user_s": 8.712861, + "process_system_s": 0.30794099999999996, + "peak_rss_kib": 786588 + }, + { + "biomes": 0.42566181640625, + "carvers": 0.38387910937499997, + "chunks": 256, + "noise": 5.246072375, + "structures": 1.1587689218750001, + "surface": 3.3145837343749998, + "threads": 1, + "wall_ms_chunk": 10.57722427734375, + "version": "candidate", + "repeat": 2, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 503.21, + "combined_ms_chunk": 12.542888339843751, + "terrain_cpu_ms_chunk": 10.5, + "process_user_s": 8.121225, + "process_system_s": 0.307971, + "peak_rss_kib": 787072 + }, + { + "biomes": 0.43049873046875003, + "carvers": 0.38391943359375, + "chunks": 256, + "noise": 5.2936765, + "structures": 1.17518914453125, + "surface": 3.3476032148437502, + "threads": 1, + "wall_ms_chunk": 10.67998828515625, + "version": "candidate", + "repeat": 3, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 495.96, + "combined_ms_chunk": 12.61733203515625, + "terrain_cpu_ms_chunk": 10.5, + "process_user_s": 8.111499, + "process_system_s": 0.297967, + "peak_rss_kib": 786604 + }, + { + "biomes": 0.42718302734375, + "carvers": 0.37447686328124996, + "chunks": 256, + "noise": 5.72907546484375, + "structures": 1.16478528515625, + "surface": 4.42239170703125, + "threads": 1, + "wall_ms_chunk": 12.16650178125, + "version": "baseline", + "repeat": 3, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 489.71, + "combined_ms_chunk": 14.07943146875, + "terrain_cpu_ms_chunk": 12.1, + "process_user_s": 8.683186, + "process_system_s": 0.30128, + "peak_rss_kib": 786588 + }, + { + "biomes": 0.426544765625, + "carvers": 0.38605957812499997, + "chunks": 256, + "noise": 5.69790626171875, + "structures": 1.1686023359375, + "surface": 4.42780881640625, + "threads": 1, + "wall_ms_chunk": 12.155565492187499, + "version": "baseline", + "repeat": 4, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 493.98, + "combined_ms_chunk": 14.085174867187499, + "terrain_cpu_ms_chunk": 12.1, + "process_user_s": 8.712038, + "process_system_s": 0.297019, + "peak_rss_kib": 786768 + }, + { + "biomes": 0.42749559765625, + "carvers": 0.38046942578125004, + "chunks": 256, + "noise": 5.22939499609375, + "structures": 1.16468150390625, + "surface": 3.3154809882812497, + "threads": 1, + "wall_ms_chunk": 10.56634626953125, + "version": "candidate", + "repeat": 4, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 505.54, + "combined_ms_chunk": 12.54111189453125, + "terrain_cpu_ms_chunk": 10.5, + "process_user_s": 8.187812, + "process_system_s": 0.294048, + "peak_rss_kib": 786608 + } +] diff --git a/noise-aquifer-results/gate-summary.json b/noise-aquifer-results/gate-summary.json new file mode 100644 index 000000000..eecb49ad2 --- /dev/null +++ b/noise-aquifer-results/gate-summary.json @@ -0,0 +1,42 @@ +[ + { + "dimension": "overworld", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 12.2709350703125, + "candidate": 10.56634626953125, + "reduction_percent": 13.891270640859485 + }, + "combined_ms_chunk": { + "baseline": 14.202494660156248, + "candidate": 12.54111189453125, + "reduction_percent": 11.697823554096097 + }, + "noise": { + "baseline": 5.772878597656249, + "candidate": 5.22939499609375, + "reduction_percent": 9.414429774829324 + }, + "surface": { + "baseline": 4.4673708046875, + "candidate": 3.3145837343749998, + "reduction_percent": 25.804597843163354 + }, + "terrain_cpu_ms_chunk": { + "baseline": 12.1, + "candidate": 10.5, + "reduction_percent": 13.223140495867767 + }, + "peak_rss_kib": { + "baseline": 786588, + "candidate": 786608, + "reduction_percent": -0.0025426271440703394 + } + } +] diff --git a/noise-aquifer-results/initial-shared-inline/binary-hashes.txt b/noise-aquifer-results/initial-shared-inline/binary-hashes.txt new file mode 100644 index 000000000..ae4d2a105 --- /dev/null +++ b/noise-aquifer-results/initial-shared-inline/binary-hashes.txt @@ -0,0 +1,2 @@ +65d134def1e54944b105cf13e28945eea717f75aabf5dfd827f70645b22abc3c /srv/bob-data/horizon-noise-aquifer-e477fa56/baseline +e17373cba69ae2142e81f867b5ff3dbff2c9e56bc6f2c18abdd99b85b0ba7bbe /srv/bob-data/horizon-noise-aquifer-e477fa56/candidate diff --git a/noise-aquifer-results/initial-shared-inline/candidate.patch b/noise-aquifer-results/initial-shared-inline/candidate.patch new file mode 100644 index 000000000..63a21ef2e --- /dev/null +++ b/noise-aquifer-results/initial-shared-inline/candidate.patch @@ -0,0 +1,73 @@ +diff --git a/crates/horizon-core/src/density/arithmetic.rs b/crates/horizon-core/src/density/arithmetic.rs +index f82b96ce..4f1b3a8c 100644 +--- a/crates/horizon-core/src/density/arithmetic.rs ++++ b/crates/horizon-core/src/density/arithmetic.rs +@@ -76,6 +76,7 @@ pub enum UnaryOp { + }, + } + impl UnaryOp { ++ #[inline(always)] + pub(super) fn apply(self, value: f32, bulk: bool) -> f32 { + match self { + Self::Abs => value.abs(), +@@ -138,6 +139,49 @@ impl UnaryOp { + } + } + } ++ /// Dispatch once per volume so each loop has one fixed arithmetic operation. ++ /// Keep the scalar expression shared, including the bulk min/max behavior. ++ fn apply_bulk(self, buffer: &mut [f32]) { ++ macro_rules! apply { ++ ($operation:expr) => { ++ for value in buffer { ++ *value = $operation.apply(*value, true); ++ } ++ }; ++ } ++ match self { ++ Self::Abs => apply!(Self::Abs), ++ Self::Negate => apply!(Self::Negate), ++ Self::Square => apply!(Self::Square), ++ Self::Cube => apply!(Self::Cube), ++ Self::Sqrt => apply!(Self::Sqrt), ++ Self::Log => apply!(Self::Log), ++ Self::PowerBase(base) => apply!(Self::PowerBase(base)), ++ Self::PowerExponent(exponent) => apply!(Self::PowerExponent(exponent)), ++ Self::Reciprocal => apply!(Self::Reciprocal), ++ Self::Sign => apply!(Self::Sign), ++ Self::Squeeze => apply!(Self::Squeeze), ++ Self::LeakyRelu(factor) => apply!(Self::LeakyRelu(factor)), ++ Self::Add(right) => apply!(Self::Add(right)), ++ Self::SubtractFrom(left) => apply!(Self::SubtractFrom(left)), ++ Self::Multiply(right) => apply!(Self::Multiply(right)), ++ Self::DivideInto(left) => apply!(Self::DivideInto(left)), ++ Self::Minimum(right) => apply!(Self::Minimum(right)), ++ Self::Maximum(right) => apply!(Self::Maximum(right)), ++ Self::ConstantRangeChoice { ++ min_inclusive, ++ max_exclusive, ++ inside, ++ outside, ++ } => apply!(Self::ConstantRangeChoice { ++ min_inclusive, ++ max_exclusive, ++ inside, ++ outside ++ }), ++ Self::Clamp { min, max } => apply!(Self::Clamp { min, max }), ++ } ++ } + } + #[derive(Clone, Debug)] + pub struct UnarySampler { +@@ -162,9 +206,7 @@ impl DensitySampler for UnarySampler { + ) -> Result<(), SampleError> { + check_buffer(buffer, volume)?; + self.input.sample_volume(context, buffer, volume)?; +- for value in buffer { +- *value = self.operation.apply(*value, true); +- } ++ self.operation.apply_bulk(buffer); + Ok(()) + } + } diff --git a/noise-aquifer-results/initial-shared-inline/gate-raw.json b/noise-aquifer-results/initial-shared-inline/gate-raw.json new file mode 100644 index 000000000..88c6cd5d1 --- /dev/null +++ b/noise-aquifer-results/initial-shared-inline/gate-raw.json @@ -0,0 +1,530 @@ +[ + { + "biomes": 0.44252540625, + "carvers": 0.37944787890625004, + "chunks": 256, + "noise": 5.37256131640625, + "structures": 1.1899462851562501, + "surface": 3.29317476171875, + "threads": 1, + "wall_ms_chunk": 10.72667368359375, + "version": "candidate", + "repeat": -1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 502.44, + "combined_ms_chunk": 12.68932993359375, + "terrain_cpu_ms_chunk": 10.6, + "process_user_s": 8.13122, + "process_system_s": 0.297359, + "peak_rss_kib": 786896 + }, + { + "biomes": 0.4328324765625, + "carvers": 0.38604471484374997, + "chunks": 256, + "noise": 5.76258115234375, + "structures": 1.1723783828125, + "surface": 4.48618292578125, + "threads": 1, + "wall_ms_chunk": 12.28948091015625, + "version": "baseline", + "repeat": -1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 493.35, + "combined_ms_chunk": 14.21662934765625, + "terrain_cpu_ms_chunk": 12.2, + "process_user_s": 8.735389, + "process_system_s": 0.286565, + "peak_rss_kib": 786496 + }, + { + "biomes": 0.42968594921875003, + "carvers": 0.37386116796874996, + "chunks": 256, + "noise": 5.7501386054687496, + "structures": 1.181537234375, + "surface": 4.4565285, + "threads": 1, + "wall_ms_chunk": 12.24029160546875, + "version": "baseline", + "repeat": 0, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 505.66, + "combined_ms_chunk": 14.21552598046875, + "terrain_cpu_ms_chunk": 12.2, + "process_user_s": 8.701562, + "process_system_s": 0.297948, + "peak_rss_kib": 786856 + }, + { + "biomes": 0.44574032421875004, + "carvers": 0.377108921875, + "chunks": 256, + "noise": 5.295269781250001, + "structures": 1.18742401953125, + "surface": 3.29978081640625, + "threads": 1, + "wall_ms_chunk": 10.65494362109375, + "version": "candidate", + "repeat": 0, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 496.28, + "combined_ms_chunk": 12.593537371093749, + "terrain_cpu_ms_chunk": 10.5, + "process_user_s": 8.179581, + "process_system_s": 0.272086, + "peak_rss_kib": 786752 + }, + { + "biomes": 0.42817503515625, + "carvers": 0.381013015625, + "chunks": 256, + "noise": 5.32803534375, + "structures": 1.1685042265625, + "surface": 3.2901356875000003, + "threads": 1, + "wall_ms_chunk": 10.6447336015625, + "version": "candidate", + "repeat": 1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 496.25, + "combined_ms_chunk": 12.5832101640625, + "terrain_cpu_ms_chunk": 10.6, + "process_user_s": 8.153767, + "process_system_s": 0.31987699999999997, + "peak_rss_kib": 786856 + }, + { + "biomes": 0.42586504296875, + "carvers": 0.374535953125, + "chunks": 256, + "noise": 5.756364796875, + "structures": 1.166495703125, + "surface": 4.41194609375, + "threads": 1, + "wall_ms_chunk": 12.18332252734375, + "version": "baseline", + "repeat": 1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 489.75, + "combined_ms_chunk": 14.09640846484375, + "terrain_cpu_ms_chunk": 12.2, + "process_user_s": 8.698943, + "process_system_s": 0.28009999999999996, + "peak_rss_kib": 787012 + }, + { + "biomes": 0.4276283203125, + "carvers": 0.3754761015625, + "chunks": 256, + "noise": 5.6835061132812505, + "structures": 1.1926860976562499, + "surface": 4.43971352734375, + "threads": 1, + "wall_ms_chunk": 12.1687718515625, + "version": "baseline", + "repeat": 2, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 510.19, + "combined_ms_chunk": 14.1617015390625, + "terrain_cpu_ms_chunk": 12.1, + "process_user_s": 8.694317999999999, + "process_system_s": 0.305902, + "peak_rss_kib": 786752 + }, + { + "biomes": 0.442308890625, + "carvers": 0.37814296875000003, + "chunks": 256, + "noise": 5.4344082109375, + "structures": 1.175275171875, + "surface": 3.30110362890625, + "threads": 1, + "wall_ms_chunk": 10.7801952578125, + "version": "candidate", + "repeat": 2, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 502.83, + "combined_ms_chunk": 12.744374945312499, + "terrain_cpu_ms_chunk": 10.7, + "process_user_s": 8.212731, + "process_system_s": 0.29778899999999997, + "peak_rss_kib": 787696 + }, + { + "biomes": 0.42592785156249996, + "carvers": 0.3739973125, + "chunks": 256, + "noise": 5.29756358984375, + "structures": 1.17243391015625, + "surface": 3.27471499609375, + "threads": 1, + "wall_ms_chunk": 10.5930513671875, + "version": "candidate", + "repeat": 3, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 493.81, + "combined_ms_chunk": 12.5219966796875, + "terrain_cpu_ms_chunk": 10.5, + "process_user_s": 8.153845, + "process_system_s": 0.291358, + "peak_rss_kib": 786816 + }, + { + "biomes": 0.431791, + "carvers": 0.38492897265625003, + "chunks": 256, + "noise": 5.7807356484375, + "structures": 1.1812125625, + "surface": 4.4762462734375, + "threads": 1, + "wall_ms_chunk": 12.30409496875, + "version": "baseline", + "repeat": 3, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 490.8, + "combined_ms_chunk": 14.221282468750001, + "terrain_cpu_ms_chunk": 12.3, + "process_user_s": 8.777226, + "process_system_s": 0.268125, + "peak_rss_kib": 786632 + }, + { + "biomes": 0.42878466015625, + "carvers": 0.37590098828125, + "chunks": 256, + "noise": 5.782410890625, + "structures": 1.1744792343750001, + "surface": 4.490146933593749, + "threads": 1, + "wall_ms_chunk": 12.3003106171875, + "version": "baseline", + "repeat": 4, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 505.11, + "combined_ms_chunk": 14.273396554687501, + "terrain_cpu_ms_chunk": 12.3, + "process_user_s": 8.793776, + "process_system_s": 0.26853699999999997, + "peak_rss_kib": 787692 + }, + { + "biomes": 0.436424984375, + "carvers": 0.37611544921874995, + "chunks": 256, + "noise": 5.2962504453125, + "structures": 1.1786373125, + "surface": 3.2901524921875, + "threads": 1, + "wall_ms_chunk": 10.62593462890625, + "version": "candidate", + "repeat": 4, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 497.11, + "combined_ms_chunk": 12.567770566406251, + "terrain_cpu_ms_chunk": 10.6, + "process_user_s": 8.178847, + "process_system_s": 0.25806599999999996, + "peak_rss_kib": 786636 + } +] diff --git a/noise-aquifer-results/initial-shared-inline/gate-summary.json b/noise-aquifer-results/initial-shared-inline/gate-summary.json new file mode 100644 index 000000000..5412e6902 --- /dev/null +++ b/noise-aquifer-results/initial-shared-inline/gate-summary.json @@ -0,0 +1,42 @@ +[ + { + "dimension": "overworld", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 12.24029160546875, + "candidate": 10.6447336015625, + "reduction_percent": 13.035294054541824 + }, + "combined_ms_chunk": { + "baseline": 14.21552598046875, + "candidate": 12.5832101640625, + "reduction_percent": 11.482626943589354 + }, + "noise": { + "baseline": 5.756364796875, + "candidate": 5.29756358984375, + "reduction_percent": 7.970328900634006 + }, + "surface": { + "baseline": 4.4565285, + "candidate": 3.2901524921875, + "reduction_percent": 26.17229998220588 + }, + "terrain_cpu_ms_chunk": { + "baseline": 12.2, + "candidate": 10.6, + "reduction_percent": 13.114754098360654 + }, + "peak_rss_kib": { + "baseline": 786856, + "candidate": 786816, + "reduction_percent": 0.005083522270911069 + } + } +] diff --git a/noise-aquifer-results/loop-codegen.json b/noise-aquifer-results/loop-codegen.json new file mode 100644 index 000000000..5115b6871 --- /dev/null +++ b/noise-aquifer-results/loop-codegen.json @@ -0,0 +1,30 @@ +[ + { + "binary": "baseline", + "unary_sample_volume_bytes": 128, + "packed_float_instruction_counts": { + "addps": 0, + "subps": 0, + "mulps": 0, + "divps": 0, + "andps": 0, + "xorps": 0, + "maxps": 0, + "minps": 0 + } + }, + { + "binary": "candidate", + "unary_sample_volume_bytes": 4335, + "packed_float_instruction_counts": { + "addps": 3, + "subps": 2, + "mulps": 13, + "divps": 3, + "andps": 26, + "xorps": 11, + "maxps": 2, + "minps": 2 + } + } +] diff --git a/noise-aquifer-results/matrix-raw.json b/noise-aquifer-results/matrix-raw.json new file mode 100644 index 000000000..01731a849 --- /dev/null +++ b/noise-aquifer-results/matrix-raw.json @@ -0,0 +1,4226 @@ +[ + { + "biomes": 0.48353841015625, + "carvers": 0.38574688281249997, + "chunks": 256, + "noise": 5.24437607421875, + "structures": 3.88326049609375, + "surface": 3.35451583984375, + "threads": 4, + "wall_ms_chunk": 3.36460393359375, + "version": "candidate", + "repeat": -1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 145.8, + "combined_ms_chunk": 3.9341351835937504, + "terrain_cpu_ms_chunk": 13.4, + "process_user_s": 8.876343, + "process_system_s": 0.346105, + "peak_rss_kib": 832720 + }, + { + "biomes": 0.507996703125, + "carvers": 0.38738203515625, + "chunks": 256, + "noise": 5.9148067499999994, + "structures": 3.9641258359375002, + "surface": 4.550977078124999, + "threads": 4, + "wall_ms_chunk": 3.8722654296875003, + "version": "baseline", + "repeat": -1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 144.82, + "combined_ms_chunk": 4.4379685546875, + "terrain_cpu_ms_chunk": 15.3, + "process_user_s": 9.517044, + "process_system_s": 0.32989999999999997, + "peak_rss_kib": 832968 + }, + { + "biomes": 0.47814796875, + "carvers": 0.38039311328125003, + "chunks": 256, + "noise": 5.8270603125000004, + "structures": 3.9121094453125, + "surface": 4.50185171875, + "threads": 4, + "wall_ms_chunk": 3.80498315234375, + "version": "baseline", + "repeat": 0, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 149.13, + "combined_ms_chunk": 4.3875222148437505, + "terrain_cpu_ms_chunk": 15.1, + "process_user_s": 9.468122, + "process_system_s": 0.33505199999999996, + "peak_rss_kib": 833136 + }, + { + "biomes": 0.4937317890625, + "carvers": 0.3843886484375, + "chunks": 256, + "noise": 5.25024941015625, + "structures": 3.9599643281250003, + "surface": 3.34837826953125, + "threads": 4, + "wall_ms_chunk": 3.38422338671875, + "version": "candidate", + "repeat": 0, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 149.9, + "combined_ms_chunk": 3.96977026171875, + "terrain_cpu_ms_chunk": 13.4, + "process_user_s": 8.934746, + "process_system_s": 0.32942699999999997, + "peak_rss_kib": 834516 + }, + { + "biomes": 0.49398027734375005, + "carvers": 0.39036689062499996, + "chunks": 256, + "noise": 5.3381976875, + "structures": 3.9302678281250003, + "surface": 3.3764329531249997, + "threads": 4, + "wall_ms_chunk": 3.4084368984375, + "version": "candidate", + "repeat": 1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 148.94, + "combined_ms_chunk": 3.9902337734374997, + "terrain_cpu_ms_chunk": 13.5, + "process_user_s": 8.904913, + "process_system_s": 0.339101, + "peak_rss_kib": 832348 + }, + { + "biomes": 0.49883715625, + "carvers": 0.3843920859375, + "chunks": 256, + "noise": 5.83775421875, + "structures": 3.9925353046875003, + "surface": 4.5059914296875, + "threads": 4, + "wall_ms_chunk": 3.8379385546875, + "version": "baseline", + "repeat": 1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 145.21, + "combined_ms_chunk": 4.4051651171875, + "terrain_cpu_ms_chunk": 15.2, + "process_user_s": 9.500240999999999, + "process_system_s": 0.316909, + "peak_rss_kib": 832416 + }, + { + "biomes": 0.52625087109375, + "carvers": 0.408476265625, + "chunks": 256, + "noise": 5.97718533203125, + "structures": 3.9960438671875003, + "surface": 4.64049345703125, + "threads": 4, + "wall_ms_chunk": 3.910542015625, + "version": "baseline", + "repeat": 2, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 145.64, + "combined_ms_chunk": 4.479448265625, + "terrain_cpu_ms_chunk": 15.5, + "process_user_s": 9.546377, + "process_system_s": 0.328233, + "peak_rss_kib": 834016 + }, + { + "biomes": 0.50042372265625, + "carvers": 0.38988045703124996, + "chunks": 256, + "noise": 5.276447015625, + "structures": 3.92323205859375, + "surface": 3.36673907421875, + "threads": 4, + "wall_ms_chunk": 3.3884105, + "version": "candidate", + "repeat": 2, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 146.12, + "combined_ms_chunk": 3.95919175, + "terrain_cpu_ms_chunk": 13.4, + "process_user_s": 8.896402, + "process_system_s": 0.337939, + "peak_rss_kib": 832812 + }, + { + "biomes": 0.493469734375, + "carvers": 0.39174865625, + "chunks": 256, + "noise": 5.32868657421875, + "structures": 3.94255260546875, + "surface": 3.3803906875000003, + "threads": 4, + "wall_ms_chunk": 3.40974043359375, + "version": "candidate", + "repeat": 3, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 147.93, + "combined_ms_chunk": 3.98759199609375, + "terrain_cpu_ms_chunk": 13.6, + "process_user_s": 8.914977, + "process_system_s": 0.340838, + "peak_rss_kib": 833440 + }, + { + "biomes": 0.5070742578125, + "carvers": 0.37754572265625, + "chunks": 256, + "noise": 5.81842376171875, + "structures": 3.8668252734375, + "surface": 4.51470572265625, + "threads": 4, + "wall_ms_chunk": 3.7974264921875, + "version": "baseline", + "repeat": 3, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 149.44, + "combined_ms_chunk": 4.3811764921875, + "terrain_cpu_ms_chunk": 15.0, + "process_user_s": 9.448119, + "process_system_s": 0.347536, + "peak_rss_kib": 834676 + }, + { + "biomes": 0.5080494531249999, + "carvers": 0.41245346875, + "chunks": 256, + "noise": 5.9831350703125, + "structures": 4.136053929687501, + "surface": 4.68349508203125, + "threads": 4, + "wall_ms_chunk": 3.9580060625, + "version": "baseline", + "repeat": 4, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 142.96, + "combined_ms_chunk": 4.5164435625, + "terrain_cpu_ms_chunk": 15.6, + "process_user_s": 9.631806, + "process_system_s": 0.329736, + "peak_rss_kib": 838848 + }, + { + "biomes": 0.5641761015625, + "carvers": 0.4391998828125, + "chunks": 256, + "noise": 5.7658923046875, + "structures": 4.01309696484375, + "surface": 3.72065009375, + "threads": 4, + "wall_ms_chunk": 3.6553530351562498, + "version": "candidate", + "repeat": 4, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 156.03, + "combined_ms_chunk": 4.26484522265625, + "terrain_cpu_ms_chunk": 14.4, + "process_user_s": 9.039513, + "process_system_s": 0.47204199999999996, + "peak_rss_kib": 834704 + }, + { + "biomes": 0.1370845390625, + "carvers": 0.3497980703125, + "chunks": 256, + "noise": 0.94345969921875, + "structures": 0.16458134375, + "surface": 3.33491193359375, + "threads": 1, + "wall_ms_chunk": 4.94248907421875, + "version": "candidate", + "repeat": -1, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 101.82, + "combined_ms_chunk": 5.34022344921875, + "terrain_cpu_ms_chunk": 4.9, + "process_user_s": 3.206893, + "process_system_s": 0.30306299999999997, + "peak_rss_kib": 766864 + }, + { + "biomes": 0.13770222265625, + "carvers": 0.34120021093749997, + "chunks": 256, + "noise": 1.0184424492187498, + "structures": 0.16421706640625, + "surface": 3.4411157734375, + "threads": 1, + "wall_ms_chunk": 5.11496834375, + "version": "baseline", + "repeat": -1, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 94.76, + "combined_ms_chunk": 5.48512459375, + "terrain_cpu_ms_chunk": 5.0, + "process_user_s": 3.237969, + "process_system_s": 0.292751, + "peak_rss_kib": 767136 + }, + { + "biomes": 0.14043531640625, + "carvers": 0.36789036328124997, + "chunks": 256, + "noise": 1.0311117695312502, + "structures": 0.1879942578125, + "surface": 3.45619487109375, + "threads": 1, + "wall_ms_chunk": 5.1973033515625, + "version": "baseline", + "repeat": 0, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 106.01, + "combined_ms_chunk": 5.6114049140625, + "terrain_cpu_ms_chunk": 5.1, + "process_user_s": 3.288137, + "process_system_s": 0.292925, + "peak_rss_kib": 767880 + }, + { + "biomes": 0.13367842578125, + "carvers": 0.32905148828124997, + "chunks": 256, + "noise": 0.9275919218750001, + "structures": 0.1689590859375, + "surface": 3.271626328125, + "threads": 1, + "wall_ms_chunk": 4.8434115507812505, + "version": "candidate", + "repeat": 0, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 95.18, + "combined_ms_chunk": 5.215208425781251, + "terrain_cpu_ms_chunk": 4.8, + "process_user_s": 3.13267, + "process_system_s": 0.308797, + "peak_rss_kib": 766812 + }, + { + "biomes": 0.1442604140625, + "carvers": 0.3536337109375, + "chunks": 256, + "noise": 0.94859876953125, + "structures": 0.16619854296875, + "surface": 3.32388272265625, + "threads": 1, + "wall_ms_chunk": 4.94954616796875, + "version": "candidate", + "repeat": 1, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 99.28, + "combined_ms_chunk": 5.33735866796875, + "terrain_cpu_ms_chunk": 5.0, + "process_user_s": 3.202046, + "process_system_s": 0.27005799999999996, + "peak_rss_kib": 767156 + }, + { + "biomes": 0.1327677578125, + "carvers": 0.31560908593750003, + "chunks": 256, + "noise": 0.981517796875, + "structures": 0.1627437578125, + "surface": 3.31767320703125, + "threads": 1, + "wall_ms_chunk": 4.92221994140625, + "version": "baseline", + "repeat": 1, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 93.72, + "combined_ms_chunk": 5.28831369140625, + "terrain_cpu_ms_chunk": 4.9, + "process_user_s": 3.222069, + "process_system_s": 0.28943599999999997, + "peak_rss_kib": 767164 + }, + { + "biomes": 0.14044899609375, + "carvers": 0.32908183203125, + "chunks": 256, + "noise": 0.99479630078125, + "structures": 0.1701334296875, + "surface": 3.353920703125, + "threads": 1, + "wall_ms_chunk": 5.00086766796875, + "version": "baseline", + "repeat": 2, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 97.48, + "combined_ms_chunk": 5.38164891796875, + "terrain_cpu_ms_chunk": 5.0, + "process_user_s": 3.211094, + "process_system_s": 0.29006299999999996, + "peak_rss_kib": 767300 + }, + { + "biomes": 0.13222405078125, + "carvers": 0.32014446484375, + "chunks": 256, + "noise": 0.91041137890625, + "structures": 0.1617991640625, + "surface": 3.2442935703125, + "threads": 1, + "wall_ms_chunk": 4.7805691328124995, + "version": "candidate", + "repeat": 2, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 95.14, + "combined_ms_chunk": 5.1522097578125, + "terrain_cpu_ms_chunk": 4.8, + "process_user_s": 3.170429, + "process_system_s": 0.259195, + "peak_rss_kib": 767272 + }, + { + "biomes": 0.131531078125, + "carvers": 0.34777549609374997, + "chunks": 256, + "noise": 0.91020738671875, + "structures": 0.15469105468750002, + "surface": 3.5488251796875, + "threads": 1, + "wall_ms_chunk": 5.104357375, + "version": "candidate", + "repeat": 3, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 102.04, + "combined_ms_chunk": 5.502951125, + "terrain_cpu_ms_chunk": 5.1, + "process_user_s": 3.283283, + "process_system_s": 0.280034, + "peak_rss_kib": 767032 + }, + { + "biomes": 0.13133595703125, + "carvers": 0.3165892109375, + "chunks": 256, + "noise": 0.9789275859375, + "structures": 0.15596676953125, + "surface": 3.317108703125, + "threads": 1, + "wall_ms_chunk": 4.911962765625, + "version": "baseline", + "repeat": 3, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 95.35, + "combined_ms_chunk": 5.284423703124999, + "terrain_cpu_ms_chunk": 4.9, + "process_user_s": 3.207738, + "process_system_s": 0.28896099999999997, + "peak_rss_kib": 767416 + }, + { + "biomes": 0.13852409375000002, + "carvers": 0.355382328125, + "chunks": 256, + "noise": 1.0088826171874998, + "structures": 0.17478964453124998, + "surface": 3.41303796484375, + "threads": 1, + "wall_ms_chunk": 5.103556578125, + "version": "baseline", + "repeat": 4, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 98.59, + "combined_ms_chunk": 5.488673765624999, + "terrain_cpu_ms_chunk": 5.0, + "process_user_s": 3.277378, + "process_system_s": 0.289952, + "peak_rss_kib": 767188 + }, + { + "biomes": 0.13389429687499999, + "carvers": 0.3274005, + "chunks": 256, + "noise": 0.92550525, + "structures": 0.1689537578125, + "surface": 3.24397930078125, + "threads": 1, + "wall_ms_chunk": 4.81162807421875, + "version": "candidate", + "repeat": 4, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 97.23, + "combined_ms_chunk": 5.19143276171875, + "terrain_cpu_ms_chunk": 4.8, + "process_user_s": 3.164104, + "process_system_s": 0.28493399999999997, + "peak_rss_kib": 768256 + }, + { + "biomes": 0.1527002578125, + "carvers": 0.33850889453125005, + "chunks": 256, + "noise": 0.96880138671875, + "structures": 0.46107213671875, + "surface": 3.5827278515625003, + "threads": 4, + "wall_ms_chunk": 1.3955010820312501, + "version": "candidate", + "repeat": -1, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 28.01, + "combined_ms_chunk": 1.50491514453125, + "terrain_cpu_ms_chunk": 5.5, + "process_user_s": 3.296587, + "process_system_s": 0.340603, + "peak_rss_kib": 808284 + }, + { + "biomes": 0.15443550390625, + "carvers": 0.3468451015625, + "chunks": 256, + "noise": 1.04827496484375, + "structures": 0.49296400390625, + "surface": 3.72401240625, + "threads": 4, + "wall_ms_chunk": 1.4611553164062498, + "version": "baseline", + "repeat": -1, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 27.33, + "combined_ms_chunk": 1.5679131289062498, + "terrain_cpu_ms_chunk": 5.7, + "process_user_s": 3.3905, + "process_system_s": 0.326855, + "peak_rss_kib": 807880 + }, + { + "biomes": 0.18705638671875, + "carvers": 0.4266077421875, + "chunks": 256, + "noise": 1.23844333984375, + "structures": 0.65067961328125, + "surface": 4.40769580078125, + "threads": 4, + "wall_ms_chunk": 1.7465659648437502, + "version": "baseline", + "repeat": 0, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 27.39, + "combined_ms_chunk": 1.85355815234375, + "terrain_cpu_ms_chunk": 6.8, + "process_user_s": 3.723568, + "process_system_s": 0.32867999999999997, + "peak_rss_kib": 809068 + }, + { + "biomes": 0.15933355859375, + "carvers": 0.35652209765625004, + "chunks": 256, + "noise": 0.9947946328124999, + "structures": 0.50791763671875, + "surface": 3.69153265234375, + "threads": 4, + "wall_ms_chunk": 1.4419126953124999, + "version": "candidate", + "repeat": 0, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 30.38, + "combined_ms_chunk": 1.5605845703124999, + "terrain_cpu_ms_chunk": 5.7, + "process_user_s": 3.433763, + "process_system_s": 0.34301499999999996, + "peak_rss_kib": 808348 + }, + { + "biomes": 0.15566733593749998, + "carvers": 0.34499826953125, + "chunks": 256, + "noise": 0.97438283984375, + "structures": 0.4888053125, + "surface": 3.62864861328125, + "threads": 4, + "wall_ms_chunk": 1.4162878085937498, + "version": "candidate", + "repeat": 1, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 30.46, + "combined_ms_chunk": 1.5352721835937497, + "terrain_cpu_ms_chunk": 5.5, + "process_user_s": 3.365262, + "process_system_s": 0.31118199999999996, + "peak_rss_kib": 808196 + }, + { + "biomes": 0.15832210546875, + "carvers": 0.34845234765625, + "chunks": 256, + "noise": 1.074776, + "structures": 0.5028568515624999, + "surface": 3.8337320781249997, + "threads": 4, + "wall_ms_chunk": 1.49890619140625, + "version": "baseline", + "repeat": 1, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 28.48, + "combined_ms_chunk": 1.61015619140625, + "terrain_cpu_ms_chunk": 5.9, + "process_user_s": 3.4558299999999997, + "process_system_s": 0.31953699999999996, + "peak_rss_kib": 808144 + }, + { + "biomes": 0.15250269531250002, + "carvers": 0.323113484375, + "chunks": 256, + "noise": 0.9971162070312499, + "structures": 0.46339493359375, + "surface": 3.57196819921875, + "threads": 4, + "wall_ms_chunk": 1.39574041796875, + "version": "baseline", + "repeat": 2, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 26.08, + "combined_ms_chunk": 1.49761541796875, + "terrain_cpu_ms_chunk": 5.5, + "process_user_s": 3.416411, + "process_system_s": 0.312585, + "peak_rss_kib": 808252 + }, + { + "biomes": 0.15030778125, + "carvers": 0.32873496874999997, + "chunks": 256, + "noise": 0.92966758984375, + "structures": 0.45305451171875, + "surface": 3.4792089062500002, + "threads": 4, + "wall_ms_chunk": 1.3537790625, + "version": "candidate", + "repeat": 2, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 27.36, + "combined_ms_chunk": 1.4606540625, + "terrain_cpu_ms_chunk": 5.3, + "process_user_s": 3.269746, + "process_system_s": 0.313003, + "peak_rss_kib": 808268 + }, + { + "biomes": 0.1519560703125, + "carvers": 0.3320248515625, + "chunks": 256, + "noise": 0.94876864453125, + "structures": 0.45117773828125, + "surface": 3.5063635781249998, + "threads": 4, + "wall_ms_chunk": 1.367371890625, + "version": "candidate", + "repeat": 3, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 27.15, + "combined_ms_chunk": 1.473426578125, + "terrain_cpu_ms_chunk": 5.3, + "process_user_s": 3.248692, + "process_system_s": 0.338281, + "peak_rss_kib": 808148 + }, + { + "biomes": 0.1506245234375, + "carvers": 0.31850793359375, + "chunks": 256, + "noise": 0.9919948710937501, + "structures": 0.4453575, + "surface": 3.50541282421875, + "threads": 4, + "wall_ms_chunk": 1.37180578125, + "version": "baseline", + "repeat": 3, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 26.77, + "combined_ms_chunk": 1.47637609375, + "terrain_cpu_ms_chunk": 5.5, + "process_user_s": 3.301759, + "process_system_s": 0.322942, + "peak_rss_kib": 811232 + }, + { + "biomes": 0.14507573046875002, + "carvers": 0.31960434765625, + "chunks": 256, + "noise": 0.9979337929687501, + "structures": 0.47951465625, + "surface": 3.54853605859375, + "threads": 4, + "wall_ms_chunk": 1.3906834335937501, + "version": "baseline", + "repeat": 4, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 26.65, + "combined_ms_chunk": 1.49478499609375, + "terrain_cpu_ms_chunk": 5.5, + "process_user_s": 3.292158, + "process_system_s": 0.339582, + "peak_rss_kib": 808032 + }, + { + "biomes": 0.15106661328124998, + "carvers": 0.32569064453125, + "chunks": 256, + "noise": 0.932149890625, + "structures": 0.43740817578124996, + "surface": 3.4441070625, + "threads": 4, + "wall_ms_chunk": 1.34138928125, + "version": "candidate", + "repeat": 4, + "dimension": "the_nether", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_nether", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 26.57, + "combined_ms_chunk": 1.4451783437499999, + "terrain_cpu_ms_chunk": 5.3, + "process_user_s": 3.287765, + "process_system_s": 0.293301, + "peak_rss_kib": 808148 + }, + { + "biomes": 0.0671063125, + "carvers": 0.0077883203124999995, + "chunks": 256, + "noise": 0.5764382734375001, + "structures": 0.013758625, + "surface": 0.3345908515625, + "threads": 1, + "wall_ms_chunk": 1.02945684375, + "version": "candidate", + "repeat": -1, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 18.83, + "combined_ms_chunk": 1.10301153125, + "terrain_cpu_ms_chunk": 1.0, + "process_user_s": 1.701378, + "process_system_s": 0.28632199999999997, + "peak_rss_kib": 758568 + }, + { + "biomes": 0.06498396484375, + "carvers": 0.00752325, + "chunks": 256, + "noise": 0.6174956406250001, + "structures": 0.01201401953125, + "surface": 0.323810515625, + "threads": 1, + "wall_ms_chunk": 1.05527485546875, + "version": "baseline", + "repeat": -1, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 18.24, + "combined_ms_chunk": 1.1265248554687501, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.7748249999999999, + "process_system_s": 0.25675, + "peak_rss_kib": 758124 + }, + { + "biomes": 0.07141799609375, + "carvers": 0.00903455078125, + "chunks": 256, + "noise": 0.6907069257812499, + "structures": 0.0181156796875, + "surface": 0.359480328125, + "threads": 1, + "wall_ms_chunk": 1.1820680859375001, + "version": "baseline", + "repeat": 0, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 18.97, + "combined_ms_chunk": 1.2561696484375, + "terrain_cpu_ms_chunk": 1.2, + "process_user_s": 1.7840690000000001, + "process_system_s": 0.277493, + "peak_rss_kib": 758420 + }, + { + "biomes": 0.066747515625, + "carvers": 0.007638148437500001, + "chunks": 256, + "noise": 0.56488630859375, + "structures": 0.0124629375, + "surface": 0.33111641015625, + "threads": 1, + "wall_ms_chunk": 1.01261229296875, + "version": "candidate", + "repeat": 0, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 18.16, + "combined_ms_chunk": 1.08354979296875, + "terrain_cpu_ms_chunk": 1.0, + "process_user_s": 1.769447, + "process_system_s": 0.283722, + "peak_rss_kib": 758228 + }, + { + "biomes": 0.0701680859375, + "carvers": 0.00899228515625, + "chunks": 256, + "noise": 0.6042903749999999, + "structures": 0.015031363281250001, + "surface": 0.34355565234374996, + "threads": 1, + "wall_ms_chunk": 1.0740906406250001, + "version": "candidate", + "repeat": 1, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 19.89, + "combined_ms_chunk": 1.151785953125, + "terrain_cpu_ms_chunk": 1.0, + "process_user_s": 1.789218, + "process_system_s": 0.29277, + "peak_rss_kib": 758388 + }, + { + "biomes": 0.06466825390625, + "carvers": 0.007814542968750001, + "chunks": 256, + "noise": 0.62916758203125, + "structures": 0.0120749296875, + "surface": 0.3290578203125, + "threads": 1, + "wall_ms_chunk": 1.07254237890625, + "version": "baseline", + "repeat": 1, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 18.73, + "combined_ms_chunk": 1.14570644140625, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.739302, + "process_system_s": 0.297614, + "peak_rss_kib": 758244 + }, + { + "biomes": 0.06643014453125, + "carvers": 0.00825007421875, + "chunks": 256, + "noise": 0.6371068046875, + "structures": 0.01243977734375, + "surface": 0.3337400390625, + "threads": 1, + "wall_ms_chunk": 1.08787355859375, + "version": "baseline", + "repeat": 2, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 18.87, + "combined_ms_chunk": 1.16158449609375, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.745915, + "process_system_s": 0.284339, + "peak_rss_kib": 758056 + }, + { + "biomes": 0.06733269140625, + "carvers": 0.0078622109375, + "chunks": 256, + "noise": 0.5949901171875001, + "structures": 0.01371746484375, + "surface": 0.34096759374999996, + "threads": 1, + "wall_ms_chunk": 1.05490283984375, + "version": "candidate", + "repeat": 2, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 19.0, + "combined_ms_chunk": 1.12912158984375, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.721397, + "process_system_s": 0.296788, + "peak_rss_kib": 758356 + }, + { + "biomes": 0.06638907031249999, + "carvers": 0.00807542578125, + "chunks": 256, + "noise": 0.588318046875, + "structures": 0.013528765625, + "surface": 0.34993033984375, + "threads": 1, + "wall_ms_chunk": 1.05624013671875, + "version": "candidate", + "repeat": 3, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 18.39, + "combined_ms_chunk": 1.12807607421875, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.731978, + "process_system_s": 0.28312899999999996, + "peak_rss_kib": 758416 + }, + { + "biomes": 0.07069091015625, + "carvers": 0.008381, + "chunks": 256, + "noise": 0.68040130859375, + "structures": 0.01436361328125, + "surface": 0.3577211015625, + "threads": 1, + "wall_ms_chunk": 1.1632215898437501, + "version": "baseline", + "repeat": 3, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 17.0, + "combined_ms_chunk": 1.2296278398437501, + "terrain_cpu_ms_chunk": 1.2, + "process_user_s": 1.752325, + "process_system_s": 0.289176, + "peak_rss_kib": 758588 + }, + { + "biomes": 0.06355004296875, + "carvers": 0.00738161328125, + "chunks": 256, + "noise": 0.6265852265625, + "structures": 0.01202754296875, + "surface": 0.32790377734375004, + "threads": 1, + "wall_ms_chunk": 1.0667404101562499, + "version": "baseline", + "repeat": 4, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 19.8, + "combined_ms_chunk": 1.14408416015625, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.741118, + "process_system_s": 0.275049, + "peak_rss_kib": 758388 + }, + { + "biomes": 0.063774796875, + "carvers": 0.00733364453125, + "chunks": 256, + "noise": 0.56107108203125, + "structures": 0.012083515625000001, + "surface": 0.33038421093750003, + "threads": 1, + "wall_ms_chunk": 1.00400650390625, + "version": "candidate", + "repeat": 4, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 17.54, + "combined_ms_chunk": 1.07252212890625, + "terrain_cpu_ms_chunk": 1.0, + "process_user_s": 1.701422, + "process_system_s": 0.300386, + "peak_rss_kib": 758300 + }, + { + "biomes": 0.07347773437499999, + "carvers": 0.008016730468749999, + "chunks": 256, + "noise": 0.582110890625, + "structures": 0.013846804687499999, + "surface": 0.33808323828125003, + "threads": 4, + "wall_ms_chunk": 0.2648614609375, + "version": "candidate", + "repeat": -1, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 7.15, + "combined_ms_chunk": 0.29279114843750004, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.730079, + "process_system_s": 0.28420799999999996, + "peak_rss_kib": 765316 + }, + { + "biomes": 0.07508191015625, + "carvers": 0.008719144531249999, + "chunks": 256, + "noise": 0.64692200390625, + "structures": 0.01468698046875, + "surface": 0.33883886328124996, + "threads": 4, + "wall_ms_chunk": 0.28209423828125, + "version": "baseline", + "repeat": -1, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 7.86, + "combined_ms_chunk": 0.31279736328125, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.743428, + "process_system_s": 0.280487, + "peak_rss_kib": 764624 + }, + { + "biomes": 0.06968803515625, + "carvers": 0.007994781250000001, + "chunks": 256, + "noise": 0.6300331328125001, + "structures": 0.015125671875, + "surface": 0.32591112109375003, + "threads": 4, + "wall_ms_chunk": 0.272614421875, + "version": "baseline", + "repeat": 0, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 6.68, + "combined_ms_chunk": 0.298708171875, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.71976, + "process_system_s": 0.290218, + "peak_rss_kib": 765464 + }, + { + "biomes": 0.07005374609375001, + "carvers": 0.0081262890625, + "chunks": 256, + "noise": 0.5717398828125, + "structures": 0.016438484375, + "surface": 0.33273578125, + "threads": 4, + "wall_ms_chunk": 0.26043392187500003, + "version": "candidate", + "repeat": 0, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 7.14, + "combined_ms_chunk": 0.28832454687500003, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.7035689999999999, + "process_system_s": 0.290498, + "peak_rss_kib": 764612 + }, + { + "biomes": 0.0744749453125, + "carvers": 0.008645933593749999, + "chunks": 256, + "noise": 0.5800458320312499, + "structures": 0.01345557421875, + "surface": 0.33882638671875, + "threads": 4, + "wall_ms_chunk": 0.26400750781250004, + "version": "candidate", + "repeat": 1, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 7.26, + "combined_ms_chunk": 0.29236688281250006, + "terrain_cpu_ms_chunk": 1.0, + "process_user_s": 1.697073, + "process_system_s": 0.29665199999999997, + "peak_rss_kib": 764000 + }, + { + "biomes": 0.07363709375000001, + "carvers": 0.0083119609375, + "chunks": 256, + "noise": 0.63874593359375, + "structures": 0.01635375, + "surface": 0.33684059765625, + "threads": 4, + "wall_ms_chunk": 0.27894697265625, + "version": "baseline", + "repeat": 1, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 6.99, + "combined_ms_chunk": 0.30625166015625, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.758769, + "process_system_s": 0.280622, + "peak_rss_kib": 764520 + }, + { + "biomes": 0.07276028125, + "carvers": 0.007958566406250001, + "chunks": 256, + "noise": 0.63267321484375, + "structures": 0.01451640234375, + "surface": 0.328659421875, + "threads": 4, + "wall_ms_chunk": 0.2756653046875, + "version": "baseline", + "repeat": 2, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 6.95, + "combined_ms_chunk": 0.3028137421875, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.717258, + "process_system_s": 0.30649, + "peak_rss_kib": 762980 + }, + { + "biomes": 0.06874769140625, + "carvers": 0.008313375000000001, + "chunks": 256, + "noise": 0.56370428125, + "structures": 0.0149923125, + "surface": 0.333879390625, + "threads": 4, + "wall_ms_chunk": 0.25811795703125, + "version": "candidate", + "repeat": 2, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 7.21, + "combined_ms_chunk": 0.28628201953125, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.7176969999999998, + "process_system_s": 0.282541, + "peak_rss_kib": 764900 + }, + { + "biomes": 0.07429515625000001, + "carvers": 0.00880516015625, + "chunks": 256, + "noise": 0.5630588789062501, + "structures": 0.01390212890625, + "surface": 0.33520016796874996, + "threads": 4, + "wall_ms_chunk": 0.25935823046875, + "version": "candidate", + "repeat": 3, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 7.23, + "combined_ms_chunk": 0.28760041796875, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.7362229999999998, + "process_system_s": 0.265471, + "peak_rss_kib": 763552 + }, + { + "biomes": 0.07121080078125, + "carvers": 0.008269808593749999, + "chunks": 256, + "noise": 0.630934875, + "structures": 0.01303702734375, + "surface": 0.32732298046874997, + "threads": 4, + "wall_ms_chunk": 0.2733938359375, + "version": "baseline", + "repeat": 3, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 7.44, + "combined_ms_chunk": 0.3024563359375, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.73318, + "process_system_s": 0.281688, + "peak_rss_kib": 765080 + }, + { + "biomes": 0.07286602734375, + "carvers": 0.0094055390625, + "chunks": 256, + "noise": 0.6326262851562501, + "structures": 0.015354234375000001, + "surface": 0.3275690078125, + "threads": 4, + "wall_ms_chunk": 0.27526291796875, + "version": "baseline", + "repeat": 4, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 7.48, + "combined_ms_chunk": 0.30448166796875004, + "terrain_cpu_ms_chunk": 1.1, + "process_user_s": 1.753609, + "process_system_s": 0.268682, + "peak_rss_kib": 765864 + }, + { + "biomes": 0.07774158984375, + "carvers": 0.01080370703125, + "chunks": 256, + "noise": 0.56824108203125, + "structures": 0.014245484375, + "surface": 0.33717660546875, + "threads": 4, + "wall_ms_chunk": 0.26269167578124997, + "version": "candidate", + "repeat": 4, + "dimension": "the_end", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "4", + "--dimension", + "the_end", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 7.32, + "combined_ms_chunk": 0.29128542578124994, + "terrain_cpu_ms_chunk": 1.0, + "process_user_s": 1.738999, + "process_system_s": 0.28302499999999997, + "peak_rss_kib": 765396 + }, + { + "biomes": 0.39971288671875, + "carvers": 0.37882032812500005, + "chunks": 256, + "noise": 4.8697074296875, + "structures": 0.33850826562499997, + "surface": 3.72384066796875, + "threads": 1, + "wall_ms_chunk": 9.77845378125, + "version": "candidate", + "repeat": -1, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 265.0, + "combined_ms_chunk": 10.81361003125, + "terrain_cpu_ms_chunk": 9.6, + "process_user_s": 7.96157, + "process_system_s": 0.30721, + "peak_rss_kib": 772956 + }, + { + "biomes": 0.4043960390625, + "carvers": 0.38978531250000004, + "chunks": 256, + "noise": 5.4159295078125, + "structures": 0.32797564062499995, + "surface": 4.7684787148437495, + "threads": 1, + "wall_ms_chunk": 11.375514890625, + "version": "baseline", + "repeat": -1, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 261.84, + "combined_ms_chunk": 12.398327390625, + "terrain_cpu_ms_chunk": 11.2, + "process_user_s": 8.549963, + "process_system_s": 0.30344, + "peak_rss_kib": 772996 + }, + { + "biomes": 0.3896178828125, + "carvers": 0.38304418359375, + "chunks": 256, + "noise": 5.459892589843751, + "structures": 0.34342648828125, + "surface": 4.773840847656251, + "threads": 1, + "wall_ms_chunk": 11.417097730468749, + "version": "baseline", + "repeat": 0, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 260.93, + "combined_ms_chunk": 12.436355542968748, + "terrain_cpu_ms_chunk": 11.2, + "process_user_s": 8.548033, + "process_system_s": 0.304259, + "peak_rss_kib": 773404 + }, + { + "biomes": 0.41971255859375, + "carvers": 0.49553131249999993, + "chunks": 256, + "noise": 5.19782119921875, + "structures": 0.35330408984375, + "surface": 3.9784396718750004, + "threads": 1, + "wall_ms_chunk": 10.520365386718751, + "version": "candidate", + "repeat": 0, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 262.28, + "combined_ms_chunk": 11.54489663671875, + "terrain_cpu_ms_chunk": 10.3, + "process_user_s": 8.170402, + "process_system_s": 0.284618, + "peak_rss_kib": 772596 + }, + { + "biomes": 0.37788180078125, + "carvers": 0.385858296875, + "chunks": 256, + "noise": 4.9163363046874995, + "structures": 0.32262048828125, + "surface": 3.7152747382812503, + "threads": 1, + "wall_ms_chunk": 9.78610121484375, + "version": "candidate", + "repeat": 1, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 273.49, + "combined_ms_chunk": 10.85442152734375, + "terrain_cpu_ms_chunk": 9.7, + "process_user_s": 7.974602, + "process_system_s": 0.291122, + "peak_rss_kib": 772916 + }, + { + "biomes": 0.3835026796875, + "carvers": 0.37746702734375004, + "chunks": 256, + "noise": 5.44076811328125, + "structures": 0.32720519531250003, + "surface": 4.7373909296875, + "threads": 1, + "wall_ms_chunk": 11.33398644140625, + "version": "baseline", + "repeat": 1, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 261.83, + "combined_ms_chunk": 12.35675987890625, + "terrain_cpu_ms_chunk": 11.2, + "process_user_s": 8.593916, + "process_system_s": 0.29184, + "peak_rss_kib": 773316 + }, + { + "biomes": 0.3830595625, + "carvers": 0.37499496875, + "chunks": 256, + "noise": 5.3896623671875, + "structures": 0.32856785937500005, + "surface": 4.68694290625, + "threads": 1, + "wall_ms_chunk": 11.230343640625, + "version": "baseline", + "repeat": 2, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 266.3, + "combined_ms_chunk": 12.270578015625, + "terrain_cpu_ms_chunk": 11.2, + "process_user_s": 8.550168, + "process_system_s": 0.28749199999999997, + "peak_rss_kib": 773060 + }, + { + "biomes": 0.382181609375, + "carvers": 0.38298096875, + "chunks": 256, + "noise": 4.92111234765625, + "structures": 0.3278383359375, + "surface": 3.7391728828125, + "threads": 1, + "wall_ms_chunk": 9.8204977578125, + "version": "candidate", + "repeat": 2, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 265.14, + "combined_ms_chunk": 10.8562008828125, + "terrain_cpu_ms_chunk": 9.7, + "process_user_s": 7.943048, + "process_system_s": 0.322827, + "peak_rss_kib": 772968 + }, + { + "biomes": 0.37968522265625, + "carvers": 0.3860081796875, + "chunks": 256, + "noise": 4.83220694921875, + "structures": 0.33047573046875, + "surface": 3.702097984375, + "threads": 1, + "wall_ms_chunk": 9.698412828124999, + "version": "candidate", + "repeat": 3, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 265.32, + "combined_ms_chunk": 10.734819078125, + "terrain_cpu_ms_chunk": 9.5, + "process_user_s": 7.946326, + "process_system_s": 0.279924, + "peak_rss_kib": 772868 + }, + { + "biomes": 0.38765451171875, + "carvers": 0.38096083203125003, + "chunks": 256, + "noise": 5.3804188359375, + "structures": 0.3274572890625, + "surface": 4.7524695390625, + "threads": 1, + "wall_ms_chunk": 11.29669141796875, + "version": "baseline", + "repeat": 3, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 262.62, + "combined_ms_chunk": 12.32255079296875, + "terrain_cpu_ms_chunk": 11.1, + "process_user_s": 8.504037, + "process_system_s": 0.286807, + "peak_rss_kib": 773060 + }, + { + "biomes": 0.38940237890624996, + "carvers": 0.403175671875, + "chunks": 256, + "noise": 5.408727453125, + "structures": 0.33668133203125, + "surface": 4.73514887109375, + "threads": 1, + "wall_ms_chunk": 11.34147396875, + "version": "baseline", + "repeat": 4, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 285.83, + "combined_ms_chunk": 12.45799740625, + "terrain_cpu_ms_chunk": 11.2, + "process_user_s": 8.59844, + "process_system_s": 0.29486799999999996, + "peak_rss_kib": 772728 + }, + { + "biomes": 0.3826321171875, + "carvers": 0.37871958984375, + "chunks": 256, + "noise": 4.8817727968749995, + "structures": 0.33016451953125, + "surface": 3.6934999531250003, + "threads": 1, + "wall_ms_chunk": 9.73411325, + "version": "candidate", + "repeat": 4, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 265.2, + "combined_ms_chunk": 10.77005075, + "terrain_cpu_ms_chunk": 9.6, + "process_user_s": 8.034993, + "process_system_s": 0.298956, + "peak_rss_kib": 772992 + }, + { + "biomes": 0.45672900390625, + "carvers": 0.39450216796875, + "chunks": 256, + "noise": 4.92153640234375, + "structures": 0.7476218554687499, + "surface": 3.9057192890624997, + "threads": 4, + "wall_ms_chunk": 2.6448442617187498, + "version": "candidate", + "repeat": -1, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 75.38, + "combined_ms_chunk": 2.9392973867187497, + "terrain_cpu_ms_chunk": 10.4, + "process_user_s": 8.167949, + "process_system_s": 0.29528699999999997, + "peak_rss_kib": 790580 + }, + { + "biomes": 0.49467384765625005, + "carvers": 0.389857765625, + "chunks": 256, + "noise": 5.44034409765625, + "structures": 0.77604354296875, + "surface": 4.922074714843751, + "threads": 4, + "wall_ms_chunk": 3.0404438671875003, + "version": "baseline", + "repeat": -1, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 76.75, + "combined_ms_chunk": 3.3402485546875003, + "terrain_cpu_ms_chunk": 12.1, + "process_user_s": 8.82059, + "process_system_s": 0.28219099999999997, + "peak_rss_kib": 791200 + }, + { + "biomes": 0.47668708984375, + "carvers": 0.38581653515625003, + "chunks": 256, + "noise": 5.48101804296875, + "structures": 0.771866640625, + "surface": 4.9356213671875, + "threads": 4, + "wall_ms_chunk": 3.0581778515624998, + "version": "baseline", + "repeat": 0, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 76.66, + "combined_ms_chunk": 3.3576309765624996, + "terrain_cpu_ms_chunk": 12.1, + "process_user_s": 8.775314999999999, + "process_system_s": 0.299074, + "peak_rss_kib": 791584 + }, + { + "biomes": 0.44986469921875005, + "carvers": 0.39071975390625, + "chunks": 256, + "noise": 4.8962180859375, + "structures": 0.75393650390625, + "surface": 3.863450953125, + "threads": 4, + "wall_ms_chunk": 2.6212423828125, + "version": "candidate", + "repeat": 0, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 75.84, + "combined_ms_chunk": 2.9174923828125, + "terrain_cpu_ms_chunk": 10.4, + "process_user_s": 8.156316, + "process_system_s": 0.31522, + "peak_rss_kib": 791264 + }, + { + "biomes": 0.44110676953125, + "carvers": 0.39609016796875, + "chunks": 256, + "noise": 4.94947952734375, + "structures": 0.751817375, + "surface": 3.90770424609375, + "threads": 4, + "wall_ms_chunk": 2.6404325039062497, + "version": "candidate", + "repeat": 1, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 76.3, + "combined_ms_chunk": 2.9384793789062496, + "terrain_cpu_ms_chunk": 10.5, + "process_user_s": 8.211497, + "process_system_s": 0.306876, + "peak_rss_kib": 791340 + }, + { + "biomes": 0.492835953125, + "carvers": 0.398993609375, + "chunks": 256, + "noise": 5.56470246484375, + "structures": 0.76127405078125, + "surface": 5.0091022578125, + "threads": 4, + "wall_ms_chunk": 3.0937040703124996, + "version": "baseline", + "repeat": 1, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 76.15, + "combined_ms_chunk": 3.3911650078124995, + "terrain_cpu_ms_chunk": 12.3, + "process_user_s": 8.793621, + "process_system_s": 0.307699, + "peak_rss_kib": 791548 + }, + { + "biomes": 0.47851093359375, + "carvers": 0.3901752578125, + "chunks": 256, + "noise": 5.4432403125, + "structures": 0.78050973828125, + "surface": 4.9168907421875, + "threads": 4, + "wall_ms_chunk": 3.04131756640625, + "version": "baseline", + "repeat": 2, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 75.53, + "combined_ms_chunk": 3.33635662890625, + "terrain_cpu_ms_chunk": 12.0, + "process_user_s": 8.759123, + "process_system_s": 0.304816, + "peak_rss_kib": 791656 + }, + { + "biomes": 0.48506514453125, + "carvers": 0.4126526015625, + "chunks": 256, + "noise": 5.0355008671874995, + "structures": 0.7806489414062501, + "surface": 3.9920479570312497, + "threads": 4, + "wall_ms_chunk": 2.71386270703125, + "version": "candidate", + "repeat": 2, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 76.68, + "combined_ms_chunk": 3.0133939570312505, + "terrain_cpu_ms_chunk": 10.7, + "process_user_s": 8.233895, + "process_system_s": 0.338806, + "peak_rss_kib": 791540 + }, + { + "biomes": 0.443612796875, + "carvers": 0.3934000390625, + "chunks": 256, + "noise": 4.9066040546875, + "structures": 0.7639770234375, + "surface": 3.8894710195312503, + "threads": 4, + "wall_ms_chunk": 2.6345491601562503, + "version": "candidate", + "repeat": 3, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 76.93, + "combined_ms_chunk": 2.93505697265625, + "terrain_cpu_ms_chunk": 10.4, + "process_user_s": 8.192035, + "process_system_s": 0.30294499999999996, + "peak_rss_kib": 791400 + }, + { + "biomes": 0.48976614453125, + "carvers": 0.39066100390624997, + "chunks": 256, + "noise": 5.5047845, + "structures": 0.75296558203125, + "surface": 4.90097797265625, + "threads": 4, + "wall_ms_chunk": 3.0425965546875, + "version": "baseline", + "repeat": 3, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 77.6, + "combined_ms_chunk": 3.3457215546875, + "terrain_cpu_ms_chunk": 12.0, + "process_user_s": 8.767544000000001, + "process_system_s": 0.31026699999999996, + "peak_rss_kib": 791136 + }, + { + "biomes": 0.47240654296875, + "carvers": 0.39175819921875, + "chunks": 256, + "noise": 5.5244557734375, + "structures": 0.76422690625, + "surface": 4.98771640234375, + "threads": 4, + "wall_ms_chunk": 3.07253827734375, + "version": "baseline", + "repeat": 4, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 76.33, + "combined_ms_chunk": 3.37070233984375, + "terrain_cpu_ms_chunk": 12.1, + "process_user_s": 8.784185, + "process_system_s": 0.320637, + "peak_rss_kib": 791064 + }, + { + "biomes": 0.48387860546875, + "carvers": 0.387594328125, + "chunks": 256, + "noise": 4.9102566562500005, + "structures": 0.77066383203125, + "surface": 3.87325848828125, + "threads": 4, + "wall_ms_chunk": 2.639180359375, + "version": "candidate", + "repeat": 4, + "dimension": "overworld", + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "-1", + "--size", + "16", + "--threads", + "4", + "--dimension", + "overworld", + "--center", + "32", + "-32" + ], + "decorated": 196, + "decoration_ms": 77.27, + "combined_ms_chunk": 2.941016296875, + "terrain_cpu_ms_chunk": 10.4, + "process_user_s": 8.217568, + "process_system_s": 0.319042, + "peak_rss_kib": 791800 + }, + { + "biomes": 0.4438934609375, + "carvers": 0.3821054375, + "chunks": 256, + "noise": 5.284275082031249, + "structures": 11.990167101562498, + "surface": 3.3531185156250003, + "threads": 1, + "wall_ms_chunk": 21.5022511875, + "version": "candidate", + "repeat": -1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 510.49, + "combined_ms_chunk": 23.49635275, + "terrain_cpu_ms_chunk": 21.4, + "process_user_s": 7.456922, + "process_system_s": 0.313501, + "peak_rss_kib": 791760 + }, + { + "biomes": 0.44742400390625, + "carvers": 0.37514680078125, + "chunks": 256, + "noise": 5.7688955546875, + "structures": 12.134246640625001, + "surface": 4.45254106640625, + "threads": 1, + "wall_ms_chunk": 23.22758416015625, + "version": "baseline", + "repeat": -1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 497.2, + "combined_ms_chunk": 25.16977166015625, + "terrain_cpu_ms_chunk": 23.0, + "process_user_s": 7.860362, + "process_system_s": 0.304575, + "peak_rss_kib": 791708 + }, + { + "biomes": 0.42875092578125, + "carvers": 0.37716256249999996, + "chunks": 256, + "noise": 5.77808380859375, + "structures": 11.944554960937499, + "surface": 4.46725260546875, + "threads": 1, + "wall_ms_chunk": 23.04948128515625, + "version": "baseline", + "repeat": 0, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 490.6, + "combined_ms_chunk": 24.965887535156252, + "terrain_cpu_ms_chunk": 22.9, + "process_user_s": 7.80915, + "process_system_s": 0.32467599999999996, + "peak_rss_kib": 791460 + }, + { + "biomes": 0.42428901171875, + "carvers": 0.37540554687500005, + "chunks": 256, + "noise": 5.1450133359375005, + "structures": 11.946391109375, + "surface": 3.27860996875, + "threads": 1, + "wall_ms_chunk": 21.21845773046875, + "version": "candidate", + "repeat": 0, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 498.43, + "combined_ms_chunk": 23.16544991796875, + "terrain_cpu_ms_chunk": 21.1, + "process_user_s": 7.407715, + "process_system_s": 0.273721, + "peak_rss_kib": 791520 + }, + { + "biomes": 0.43424169921875, + "carvers": 0.38796527734375, + "chunks": 256, + "noise": 5.2583853203125, + "structures": 12.0325921015625, + "surface": 3.33998081640625, + "threads": 1, + "wall_ms_chunk": 21.5024232734375, + "version": "candidate", + "repeat": 1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 500.76, + "combined_ms_chunk": 23.4585170234375, + "terrain_cpu_ms_chunk": 21.3, + "process_user_s": 7.458846, + "process_system_s": 0.29436, + "peak_rss_kib": 791548 + }, + { + "biomes": 0.42952815234375, + "carvers": 0.3797641328125, + "chunks": 256, + "noise": 5.7598273828124995, + "structures": 11.93062982421875, + "surface": 4.43812640625, + "threads": 1, + "wall_ms_chunk": 22.98697991015625, + "version": "baseline", + "repeat": 1, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 502.62, + "combined_ms_chunk": 24.95033928515625, + "terrain_cpu_ms_chunk": 22.9, + "process_user_s": 7.833855, + "process_system_s": 0.292247, + "peak_rss_kib": 791716 + }, + { + "biomes": 0.44959835546875, + "carvers": 0.3846098828125, + "chunks": 256, + "noise": 5.81859017578125, + "structures": 12.029473570312499, + "surface": 4.49263651171875, + "threads": 1, + "wall_ms_chunk": 23.22414640234375, + "version": "baseline", + "repeat": 2, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 491.88, + "combined_ms_chunk": 25.14555265234375, + "terrain_cpu_ms_chunk": 23.1, + "process_user_s": 7.897718, + "process_system_s": 0.27303499999999997, + "peak_rss_kib": 791336 + }, + { + "biomes": 0.4278602734375, + "carvers": 0.39432846484375, + "chunks": 256, + "noise": 5.247983679687501, + "structures": 12.038747214843749, + "surface": 3.3149803984375, + "threads": 1, + "wall_ms_chunk": 21.47302998828125, + "version": "candidate", + "repeat": 2, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 505.07, + "combined_ms_chunk": 23.44595967578125, + "terrain_cpu_ms_chunk": 21.4, + "process_user_s": 7.454884, + "process_system_s": 0.30172299999999996, + "peak_rss_kib": 791520 + }, + { + "biomes": 0.42846523046874996, + "carvers": 0.37643353515625, + "chunks": 256, + "noise": 5.17840891796875, + "structures": 12.043128320312501, + "surface": 3.32858220703125, + "threads": 1, + "wall_ms_chunk": 21.403842031249997, + "version": "candidate", + "repeat": 3, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 508.55, + "combined_ms_chunk": 23.390365468749998, + "terrain_cpu_ms_chunk": 21.3, + "process_user_s": 7.450079, + "process_system_s": 0.297786, + "peak_rss_kib": 791884 + }, + { + "biomes": 0.42921571484375, + "carvers": 0.37685509765625, + "chunks": 256, + "noise": 5.72198735546875, + "structures": 11.996540234375, + "surface": 4.47116687890625, + "threads": 1, + "wall_ms_chunk": 23.04463336328125, + "version": "baseline", + "repeat": 3, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 496.53, + "combined_ms_chunk": 24.98420367578125, + "terrain_cpu_ms_chunk": 23.0, + "process_user_s": 7.820801, + "process_system_s": 0.31979799999999997, + "peak_rss_kib": 791720 + }, + { + "biomes": 0.44721841406249996, + "carvers": 0.3877746640625, + "chunks": 256, + "noise": 5.77484952734375, + "structures": 11.921109609375, + "surface": 4.48781470703125, + "threads": 1, + "wall_ms_chunk": 23.0679894375, + "version": "baseline", + "repeat": 4, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 509.94, + "combined_ms_chunk": 25.059942562499998, + "terrain_cpu_ms_chunk": 23.0, + "process_user_s": 7.884095, + "process_system_s": 0.287116, + "peak_rss_kib": 791700 + }, + { + "biomes": 0.436166515625, + "carvers": 0.3795897890625, + "chunks": 256, + "noise": 5.3008373359375005, + "structures": 11.988537335937501, + "surface": 3.35912442578125, + "threads": 1, + "wall_ms_chunk": 21.513234070312503, + "version": "candidate", + "repeat": 4, + "dimension": "overworld", + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "cmd": [ + "/usr/bin/python3", + "-c", + "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", + "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", + "/srv/bob-data/horizon/.local/horizon-client/26.3", + "--seed", + "12345", + "--size", + "16", + "--threads", + "1", + "--dimension", + "overworld", + "--center", + "0", + "0" + ], + "decorated": 196, + "decoration_ms": 494.12, + "combined_ms_chunk": 23.443390320312503, + "terrain_cpu_ms_chunk": 21.3, + "process_user_s": 7.404893, + "process_system_s": 0.296075, + "peak_rss_kib": 791344 + } +] diff --git a/noise-aquifer-results/matrix-summary.json b/noise-aquifer-results/matrix-summary.json new file mode 100644 index 000000000..f180e22a2 --- /dev/null +++ b/noise-aquifer-results/matrix-summary.json @@ -0,0 +1,322 @@ +[ + { + "dimension": "overworld", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 3.8379385546875, + "candidate": 3.4084368984375, + "reduction_percent": 11.190946653521179 + }, + "combined_ms_chunk": { + "baseline": 4.4051651171875, + "candidate": 3.98759199609375, + "reduction_percent": 9.479170700424318 + }, + "noise": { + "baseline": 5.83775421875, + "candidate": 5.32868657421875, + "reduction_percent": 8.720265113186848 + }, + "surface": { + "baseline": 4.51470572265625, + "candidate": 3.3764329531249997, + "reduction_percent": 25.21255735050526 + }, + "terrain_cpu_ms_chunk": { + "baseline": 15.2, + "candidate": 13.5, + "reduction_percent": 11.184210526315786 + }, + "peak_rss_kib": { + "baseline": 834016, + "candidate": 833440, + "reduction_percent": 0.06906342324367878 + } + }, + { + "dimension": "the_nether", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 5.00086766796875, + "candidate": 4.8434115507812505, + "reduction_percent": 3.1485759600484484 + }, + "combined_ms_chunk": { + "baseline": 5.38164891796875, + "candidate": 5.215208425781251, + "reduction_percent": 3.0927415504897087 + }, + "noise": { + "baseline": 0.99479630078125, + "candidate": 0.92550525, + "reduction_percent": 6.965350667954161 + }, + "surface": { + "baseline": 3.353920703125, + "candidate": 3.271626328125, + "reduction_percent": 2.4536768243602967 + }, + "terrain_cpu_ms_chunk": { + "baseline": 5.0, + "candidate": 4.8, + "reduction_percent": 4.0000000000000036 + }, + "peak_rss_kib": { + "baseline": 767300, + "candidate": 767156, + "reduction_percent": 0.018767105434640947 + } + }, + { + "dimension": "the_nether", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 1.39574041796875, + "candidate": 1.367371890625, + "reduction_percent": 2.032507404567051 + }, + "combined_ms_chunk": { + "baseline": 1.49761541796875, + "candidate": 1.473426578125, + "reduction_percent": 1.615156972446094 + }, + "noise": { + "baseline": 0.9979337929687501, + "candidate": 0.94876864453125, + "reduction_percent": 4.92669441438984 + }, + "surface": { + "baseline": 3.57196819921875, + "candidate": 3.5063635781249998, + "reduction_percent": 1.8366518802742715 + }, + "terrain_cpu_ms_chunk": { + "baseline": 5.5, + "candidate": 5.3, + "reduction_percent": 3.63636363636364 + }, + "peak_rss_kib": { + "baseline": 808252, + "candidate": 808196, + "reduction_percent": 0.006928532190455452 + } + }, + { + "dimension": "the_end", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 1.08787355859375, + "candidate": 1.05490283984375, + "reduction_percent": 3.0307491610164528 + }, + "combined_ms_chunk": { + "baseline": 1.16158449609375, + "candidate": 1.12807607421875, + "reduction_percent": 2.8847166941091573 + }, + "noise": { + "baseline": 0.6371068046875, + "candidate": 0.588318046875, + "reduction_percent": 7.657861673040965 + }, + "surface": { + "baseline": 0.3337400390625, + "candidate": 0.34096759374999996, + "reduction_percent": -2.165624091074807 + }, + "terrain_cpu_ms_chunk": { + "baseline": 1.1, + "candidate": 1.0, + "reduction_percent": 9.090909090909099 + }, + "peak_rss_kib": { + "baseline": 758388, + "candidate": 758356, + "reduction_percent": 0.004219476046561918 + } + }, + { + "dimension": "the_end", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 0.27526291796875, + "candidate": 0.26043392187500003, + "reduction_percent": 5.387211689528589 + }, + "combined_ms_chunk": { + "baseline": 0.3028137421875, + "candidate": 0.28832454687500003, + "reduction_percent": 4.7848539527404865 + }, + "noise": { + "baseline": 0.6326262851562501, + "candidate": 0.56824108203125, + "reduction_percent": 10.177446722609352 + }, + "surface": { + "baseline": 0.3275690078125, + "candidate": 0.33520016796874996, + "reduction_percent": -2.329634359248677 + }, + "terrain_cpu_ms_chunk": { + "baseline": 1.1, + "candidate": 1.1, + "reduction_percent": 0.0 + }, + "peak_rss_kib": { + "baseline": 765080, + "candidate": 764612, + "reduction_percent": 0.061170073717781145 + } + }, + { + "dimension": "overworld", + "threads": 1, + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 11.33398644140625, + "candidate": 9.78610121484375, + "reduction_percent": 13.657023806801444 + }, + "combined_ms_chunk": { + "baseline": 12.35675987890625, + "candidate": 10.85442152734375, + "reduction_percent": 12.158028207111835 + }, + "noise": { + "baseline": 5.408727453125, + "candidate": 4.9163363046874995, + "reduction_percent": 9.103641340866812 + }, + "surface": { + "baseline": 4.7373909296875, + "candidate": 3.7152747382812503, + "reduction_percent": 21.575508683503834 + }, + "terrain_cpu_ms_chunk": { + "baseline": 11.2, + "candidate": 9.7, + "reduction_percent": 13.392857142857144 + }, + "peak_rss_kib": { + "baseline": 773060, + "candidate": 772916, + "reduction_percent": 0.018627273432851265 + } + }, + { + "dimension": "overworld", + "threads": 4, + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 3.0581778515624998, + "candidate": 2.639180359375, + "reduction_percent": 13.700887015888346 + }, + "combined_ms_chunk": { + "baseline": 3.3576309765624996, + "candidate": 2.9384793789062496, + "reduction_percent": 12.48355166431578 + }, + "noise": { + "baseline": 5.5047845, + "candidate": 4.9102566562500005, + "reduction_percent": 10.80020196521771 + }, + "surface": { + "baseline": 4.9356213671875, + "candidate": 3.8894710195312503, + "reduction_percent": 21.19591982098062 + }, + "terrain_cpu_ms_chunk": { + "baseline": 12.1, + "candidate": 10.4, + "reduction_percent": 14.049586776859499 + }, + "peak_rss_kib": { + "baseline": 791548, + "candidate": 791400, + "reduction_percent": 0.01869753950486894 + } + }, + { + "dimension": "overworld", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "wall_ms_chunk": { + "baseline": 23.04948128515625, + "candidate": 21.47302998828125, + "reduction_percent": 6.839422012894609 + }, + "combined_ms_chunk": { + "baseline": 24.98420367578125, + "candidate": 23.443390320312503, + "reduction_percent": 6.167150154008521 + }, + "noise": { + "baseline": 5.77484952734375, + "candidate": 5.247983679687501, + "reduction_percent": 9.123455860824672 + }, + "surface": { + "baseline": 4.47116687890625, + "candidate": 3.32858220703125, + "reduction_percent": 25.554507420991243 + }, + "terrain_cpu_ms_chunk": { + "baseline": 23.0, + "candidate": 21.3, + "reduction_percent": 7.391304347826084 + }, + "peak_rss_kib": { + "baseline": 791700, + "candidate": 791520, + "reduction_percent": 0.022735884804850323 + } + } +] diff --git a/noise-aquifer-results/parity-binary-hashes.txt b/noise-aquifer-results/parity-binary-hashes.txt new file mode 100644 index 000000000..61ae96328 --- /dev/null +++ b/noise-aquifer-results/parity-binary-hashes.txt @@ -0,0 +1,3 @@ +57c0bf92bc3a01d28d3aa08c916a0b37f5568d7d287b98508516fd0488fae020 /srv/bob-data/horizon-noise-aquifer-e477fa56/snapshot-baseline +a43dc6817c55a55e7f869c2134eec9ac8e0c28505b06bd100c34b4b20ea4dbcd /srv/bob-data/horizon-noise-aquifer-e477fa56/snapshot-candidate +c3c042098409f9bb2aa2f3c92bca70c803474e2a4af32c4afc0d9cebeb111ca4 /srv/bob-data/horizon-noise-aquifer-e477fa56/horizon-density-parity diff --git a/noise-aquifer-results/reference-assessment.md b/noise-aquifer-results/reference-assessment.md new file mode 100644 index 000000000..6576bae1a --- /dev/null +++ b/noise-aquifer-results/reference-assessment.md @@ -0,0 +1,14 @@ +# Reference mechanism and focused feasibility + +Read the explicitly requested [Noisium description](https://modrinth.com/mod/noisium) and upstream source on 2026-10-18. Its performance and parity statements are reference-author claims, not evidence for Horizon. Inspected `NoiseChunkGeneratorMixin`, `ChunkSectionMixin`, and `ChainedBlockSourceMixin` in both source branches: + +- [1.20–1.20.1, c640041c8c932b36753c0ccf43902ac8b0bd252d](https://github.com/Steveplays28/noisium/tree/c640041c8c932b36753c0ccf43902ac8b0bd252d/common/src/main/java/io/github/steveplays28/noisium/mixin) +- [1.21.6, 1f9f2cb876e509130df7307d18e6dbc799875000](https://github.com/Steveplays28/noisium/tree/1f9f2cb876e509130df7307d18e6dbc799875000/common/src/main/java/io/github/steveplays28/noisium/mixin) + +The placement redirect manually increments nonempty-block, nonempty-fluid, and random-ticking-block counts, obtains a palette index (which can grow/replace the backing palette storage), then writes that index into the current packed storage. It avoids obtaining/removing old-state bookkeeping and the general setter abstraction; it is not a dense chunk builder and does not omit all metadata. The later branch additionally changes section lock/unlock iteration. The sampling mixin changes the iteration over an ordered chain of material samplers (indexed list in the older branch, indexed array in the later one), preserving first non-null selection. It does not implement Horizon-style density-volume arithmetic specialization. Biome iteration changes are outside this task. No upstream code was copied into the candidate. + +Horizon uses its own Java 26.3-compatible storage and generation behavior. Its noise fill already skips default air, bulk-samples density, and skips settled heightmap updates. There are no matching section locks to remove. Its generic setter maintains per-palette counts, free slots, packed widths and uniform collapse; its terrain wrapper maintains non-air counts even on existing chunks. Aquifer outputs are queried in Z/X/descending-Y order and can fail after earlier writes, so assuming that all writes merely replace fresh air would change public behavior. The direct-write idea is applicable as a private validated generation writer, not a blind replacement of the setter. + +A materially different writer could pre-resolve common generated states to per-section palette tokens and write packed indices with exact counts, or buffer dense section states and construct palettes afterward. The former still needs old values/counts for nonempty input, palette growth invalidation and required terrain metadata. The latter adds roughly 384 KiB of u32 dense storage for a 384-high chunk, then scans it to build and pack palettes; retaining traversal order requires keeping multiple sections resident, and failure paths must flush exactly the earlier writes. These designs were assessed independently of the previously rejected old-state hash lookup change; that small change does not establish their speed limit. However, the profile's 6.93% inclusive setter share covers all terrain stages, so noise-only setter elimination has less whole-terrain headroom, and neither design removes the density work dominating this profile. No new direct-storage implementation was attempted. + +The selected single optimization is dispatching unary density arithmetic once per bulk buffer. The measured 18.09% terrain self attribution to `UnaryOp::apply` and the actual per-element operation match provide a credible route to test. It does not change sampling calls, aquifer traversal, RNG, float expressions, buffer allocation, storage or scheduling. Scalar dispatch is retained in the scope-corrected version. Non-finite constant operands fall back to original dispatch to preserve NaN payload selection exposed by the new bit-exact differential test. diff --git a/noise-aquifer-results/snapshot-accessor.patch b/noise-aquifer-results/snapshot-accessor.patch new file mode 100644 index 000000000..1787500d5 --- /dev/null +++ b/noise-aquifer-results/snapshot-accessor.patch @@ -0,0 +1,15 @@ +diff --git a/crates/horizon-world/src/worldgen/terrain.rs b/crates/horizon-world/src/worldgen/terrain.rs +index 8ea3b01b..19a28011 100644 +--- a/crates/horizon-world/src/worldgen/terrain.rs ++++ b/crates/horizon-world/src/worldgen/terrain.rs +@@ -235,6 +235,10 @@ impl<'r, B: TerrainBlockStates> TerrainChunk<'r, B> { + pub(crate) fn registry(&self) -> &BlockRegistry { + self.blocks.registry + } ++ #[doc(hidden)] ++ pub fn diagnostic_non_air_counts(&self) -> &[u16] { ++ &self.blocks.non_air ++ } + pub fn highest_filled_section_index(&self) -> Option { + self.blocks.non_air.iter().rposition(|&count| count != 0) + } diff --git a/noise-aquifer-results/summarize.py b/noise-aquifer-results/summarize.py new file mode 100644 index 000000000..922b394fc --- /dev/null +++ b/noise-aquifer-results/summarize.py @@ -0,0 +1,38 @@ +import json,pathlib,statistics,re +root=pathlib.Path(__file__).resolve().parent +rows=[] +for phase in ['gate','matrix']: + rows+=json.loads((root/(phase+'-raw.json')).read_text()) +keys=['dimension','threads','seed','center','warm'] +cases=[] +for row in rows: + case={k:row[k] for k in keys} + if case not in cases:cases.append(case) +summary=[] +for case in cases: + group=[r for r in rows if all(r[k]==v for k,v in case.items()) and r['repeat']>=0] + result=dict(case) + for metric in ['wall_ms_chunk','combined_ms_chunk','noise','surface','biomes','structures','carvers','terrain_cpu_ms_chunk','peak_rss_kib','process_user_s','process_system_s']: + med={v:statistics.median(r[metric] for r in group if r['version']==v) for v in ['baseline','candidate']} + result[metric]={**med,'reduction_percent':100*(med['baseline']-med['candidate'])/med['baseline'] if med['baseline'] else None} + pairs=[] + for repeat in range(5): + b,c=(next(r for r in group if r['repeat']==repeat and r['version']==v) for v in ['baseline','candidate']) + pairs.append(100*(b['wall_ms_chunk']-c['wall_ms_chunk'])/b['wall_ms_chunk']) + result['paired_wall_reduction_percent']=pairs + result['candidate_slower_pairs']=sum(p<0 for p in pairs) + if case['warm']: + warmup={} + for version in ['baseline','candidate']: + times=[] + for row in group: + if row['version']!=version:continue + filename=f"{row['dimension']}-t{row['threads']}-s{row['seed']}-c{row['center'][0]}_{row['center'][1]}-w1-r{row['repeat']}-{version}.log" + times.append(float(re.search(r'warmup_ms ([0-9.]+)',(root/filename).read_text())[1])) + warmup[version]=statistics.median(times) + result['excluded_initialization_ms']=warmup + summary.append(result) +(root/'summary.json').write_text(json.dumps(summary,indent=2)+'\n') +for s in summary: + m=s['wall_ms_chunk'];c=s['combined_ms_chunk'] + print(s['dimension'],s['threads'],s['seed'],s['center'],'initialized' if s['warm'] else 'cold',f"{m['baseline']:.6f} -> {m['candidate']:.6f} ({m['reduction_percent']:.3f}%)",f"combined {c['baseline']:.6f} -> {c['candidate']:.6f} ({c['reduction_percent']:.3f}%)",'slower pairs',s['candidate_slower_pairs']) diff --git a/noise-aquifer-results/summary.json b/noise-aquifer-results/summary.json new file mode 100644 index 000000000..151474176 --- /dev/null +++ b/noise-aquifer-results/summary.json @@ -0,0 +1,691 @@ +[ + { + "dimension": "overworld", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 12.2709350703125, + "candidate": 10.56634626953125, + "reduction_percent": 13.891270640859485 + }, + "combined_ms_chunk": { + "baseline": 14.202494660156248, + "candidate": 12.54111189453125, + "reduction_percent": 11.697823554096097 + }, + "noise": { + "baseline": 5.772878597656249, + "candidate": 5.22939499609375, + "reduction_percent": 9.414429774829324 + }, + "surface": { + "baseline": 4.4673708046875, + "candidate": 3.3145837343749998, + "reduction_percent": 25.804597843163354 + }, + "biomes": { + "baseline": 0.4295055625, + "candidate": 0.42579529687499995, + "reduction_percent": 0.8638457680044695 + }, + "structures": { + "baseline": 1.16812175, + "candidate": 1.16468150390625, + "reduction_percent": 0.29451091838245064 + }, + "carvers": { + "baseline": 0.37644830078124997, + "candidate": 0.38046942578125004, + "reduction_percent": -1.068174565180652 + }, + "terrain_cpu_ms_chunk": { + "baseline": 12.1, + "candidate": 10.5, + "reduction_percent": 13.223140495867767 + }, + "peak_rss_kib": { + "baseline": 786588, + "candidate": 786608, + "reduction_percent": -0.0025426271440703394 + }, + "process_user_s": { + "baseline": 8.712861, + "candidate": 8.133229, + "reduction_percent": 6.6526024000612445 + }, + "process_system_s": { + "baseline": 0.297019, + "candidate": 0.297967, + "reduction_percent": -0.3191715008130808 + }, + "paired_wall_reduction_percent": [ + 15.46667237128831, + 14.2277595333367, + 13.913534551281387, + 12.218084728221882, + 13.074004855452062 + ], + "candidate_slower_pairs": 0, + "excluded_initialization_ms": { + "baseline": 3665.391034, + "candidate": 3507.147807 + } + }, + { + "dimension": "overworld", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 3.8379385546875, + "candidate": 3.4084368984375, + "reduction_percent": 11.190946653521179 + }, + "combined_ms_chunk": { + "baseline": 4.4051651171875, + "candidate": 3.98759199609375, + "reduction_percent": 9.479170700424318 + }, + "noise": { + "baseline": 5.83775421875, + "candidate": 5.32868657421875, + "reduction_percent": 8.720265113186848 + }, + "surface": { + "baseline": 4.51470572265625, + "candidate": 3.3764329531249997, + "reduction_percent": 25.21255735050526 + }, + "biomes": { + "baseline": 0.5070742578125, + "candidate": 0.49398027734375005, + "reduction_percent": 2.582260934569415 + }, + "structures": { + "baseline": 3.9925353046875003, + "candidate": 3.94255260546875, + "reduction_percent": 1.251903750483244 + }, + "carvers": { + "baseline": 0.3843920859375, + "candidate": 0.39036689062499996, + "reduction_percent": -1.5543516388814038 + }, + "terrain_cpu_ms_chunk": { + "baseline": 15.2, + "candidate": 13.5, + "reduction_percent": 11.184210526315786 + }, + "peak_rss_kib": { + "baseline": 834016, + "candidate": 833440, + "reduction_percent": 0.06906342324367878 + }, + "process_user_s": { + "baseline": 9.500240999999999, + "candidate": 8.914977, + "reduction_percent": 6.160517401611167 + }, + "process_system_s": { + "baseline": 0.329736, + "candidate": 0.339101, + "reduction_percent": -2.8401509086056764 + }, + "paired_wall_reduction_percent": [ + 11.058124274895288, + 11.190946653521179, + 13.351896323802842, + 10.209178752803826, + 7.646603430227823 + ], + "candidate_slower_pairs": 0, + "excluded_initialization_ms": { + "baseline": 3637.872295, + "candidate": 3506.494573 + } + }, + { + "dimension": "the_nether", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 5.00086766796875, + "candidate": 4.8434115507812505, + "reduction_percent": 3.1485759600484484 + }, + "combined_ms_chunk": { + "baseline": 5.38164891796875, + "candidate": 5.215208425781251, + "reduction_percent": 3.0927415504897087 + }, + "noise": { + "baseline": 0.99479630078125, + "candidate": 0.92550525, + "reduction_percent": 6.965350667954161 + }, + "surface": { + "baseline": 3.353920703125, + "candidate": 3.271626328125, + "reduction_percent": 2.4536768243602967 + }, + "biomes": { + "baseline": 0.13852409375000002, + "candidate": 0.13367842578125, + "reduction_percent": 3.4980687023985833 + }, + "structures": { + "baseline": 0.1701334296875, + "candidate": 0.16619854296875, + "reduction_percent": 2.312823955866626 + }, + "carvers": { + "baseline": 0.32908183203125, + "candidate": 0.32905148828124997, + "reduction_percent": 0.00922073084762966 + }, + "terrain_cpu_ms_chunk": { + "baseline": 5.0, + "candidate": 4.8, + "reduction_percent": 4.0000000000000036 + }, + "peak_rss_kib": { + "baseline": 767300, + "candidate": 767156, + "reduction_percent": 0.018767105434640947 + }, + "process_user_s": { + "baseline": 3.222069, + "candidate": 3.170429, + "reduction_percent": 1.6026969006560663 + }, + "process_system_s": { + "baseline": 0.289952, + "candidate": 0.280034, + "reduction_percent": 3.4205661626751955 + }, + "paired_wall_reduction_percent": [ + 6.809142681172466, + -0.5551606163029945, + 4.405206251852917, + -3.916858057667301, + 5.720099296195154 + ], + "candidate_slower_pairs": 2, + "excluded_initialization_ms": { + "baseline": 484.217697, + "candidate": 474.51742 + } + }, + { + "dimension": "the_nether", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 1.39574041796875, + "candidate": 1.367371890625, + "reduction_percent": 2.032507404567051 + }, + "combined_ms_chunk": { + "baseline": 1.49761541796875, + "candidate": 1.473426578125, + "reduction_percent": 1.615156972446094 + }, + "noise": { + "baseline": 0.9979337929687501, + "candidate": 0.94876864453125, + "reduction_percent": 4.92669441438984 + }, + "surface": { + "baseline": 3.57196819921875, + "candidate": 3.5063635781249998, + "reduction_percent": 1.8366518802742715 + }, + "biomes": { + "baseline": 0.15250269531250002, + "candidate": 0.1519560703125, + "reduction_percent": 0.35843628788324644 + }, + "structures": { + "baseline": 0.47951465625, + "candidate": 0.45305451171875, + "reduction_percent": 5.518109652409609 + }, + "carvers": { + "baseline": 0.323113484375, + "candidate": 0.3320248515625, + "reduction_percent": -2.757968211923226 + }, + "terrain_cpu_ms_chunk": { + "baseline": 5.5, + "candidate": 5.3, + "reduction_percent": 3.63636363636364 + }, + "peak_rss_kib": { + "baseline": 808252, + "candidate": 808196, + "reduction_percent": 0.006928532190455452 + }, + "process_user_s": { + "baseline": 3.416411, + "candidate": 3.287765, + "reduction_percent": 3.765530552383781 + }, + "process_system_s": { + "baseline": 0.322942, + "candidate": 0.313003, + "reduction_percent": 3.0776424249555743 + }, + "paired_wall_reduction_percent": [ + 17.442986733026423, + 5.511911504948082, + 3.0063867842859606, + 0.32321562466078, + 3.5445990908488927 + ], + "candidate_slower_pairs": 0, + "excluded_initialization_ms": { + "baseline": 500.899628, + "candidate": 475.446214 + } + }, + { + "dimension": "the_end", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 1.08787355859375, + "candidate": 1.05490283984375, + "reduction_percent": 3.0307491610164528 + }, + "combined_ms_chunk": { + "baseline": 1.16158449609375, + "candidate": 1.12807607421875, + "reduction_percent": 2.8847166941091573 + }, + "noise": { + "baseline": 0.6371068046875, + "candidate": 0.588318046875, + "reduction_percent": 7.657861673040965 + }, + "surface": { + "baseline": 0.3337400390625, + "candidate": 0.34096759374999996, + "reduction_percent": -2.165624091074807 + }, + "biomes": { + "baseline": 0.06643014453125, + "candidate": 0.066747515625, + "reduction_percent": -0.47775162313655245 + }, + "structures": { + "baseline": 0.01243977734375, + "candidate": 0.013528765625, + "reduction_percent": -8.754081774599687 + }, + "carvers": { + "baseline": 0.00825007421875, + "candidate": 0.0078622109375, + "reduction_percent": 4.701330811891384 + }, + "terrain_cpu_ms_chunk": { + "baseline": 1.1, + "candidate": 1.0, + "reduction_percent": 9.090909090909099 + }, + "peak_rss_kib": { + "baseline": 758388, + "candidate": 758356, + "reduction_percent": 0.004219476046561918 + }, + "process_user_s": { + "baseline": 1.745915, + "candidate": 1.731978, + "reduction_percent": 0.7982633747920195 + }, + "process_system_s": { + "baseline": 0.284339, + "candidate": 0.29277, + "reduction_percent": -2.965122617720385 + }, + "paired_wall_reduction_percent": [ + 14.335535743218587, + -0.14435436297901683, + 3.0307491610164528, + 9.196996862770614, + 5.880897137927958 + ], + "candidate_slower_pairs": 1, + "excluded_initialization_ms": { + "baseline": 79.999625, + "candidate": 75.211387 + } + }, + { + "dimension": "the_end", + "threads": 4, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 0.27526291796875, + "candidate": 0.26043392187500003, + "reduction_percent": 5.387211689528589 + }, + "combined_ms_chunk": { + "baseline": 0.3028137421875, + "candidate": 0.28832454687500003, + "reduction_percent": 4.7848539527404865 + }, + "noise": { + "baseline": 0.6326262851562501, + "candidate": 0.56824108203125, + "reduction_percent": 10.177446722609352 + }, + "surface": { + "baseline": 0.3275690078125, + "candidate": 0.33520016796874996, + "reduction_percent": -2.329634359248677 + }, + "biomes": { + "baseline": 0.07276028125, + "candidate": 0.07429515625000001, + "reduction_percent": -2.109495694122272 + }, + "structures": { + "baseline": 0.015125671875, + "candidate": 0.014245484375, + "reduction_percent": 5.819162991726601 + }, + "carvers": { + "baseline": 0.008269808593749999, + "candidate": 0.008645933593749999, + "reduction_percent": -4.548170562064283 + }, + "terrain_cpu_ms_chunk": { + "baseline": 1.1, + "candidate": 1.1, + "reduction_percent": 0.0 + }, + "peak_rss_kib": { + "baseline": 765080, + "candidate": 764612, + "reduction_percent": 0.061170073717781145 + }, + "process_user_s": { + "baseline": 1.73318, + "candidate": 1.7176969999999998, + "reduction_percent": 0.8933290252599347 + }, + "process_system_s": { + "baseline": 0.281688, + "candidate": 0.28302499999999997, + "reduction_percent": -0.474638607253407 + }, + "paired_wall_reduction_percent": [ + 4.468032144530132, + 5.355664806644118, + 6.365453815866322, + 5.133841229675215, + 4.566994450348462 + ], + "candidate_slower_pairs": 0, + "excluded_initialization_ms": { + "baseline": 79.670474, + "candidate": 74.569892 + } + }, + { + "dimension": "overworld", + "threads": 1, + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 11.33398644140625, + "candidate": 9.78610121484375, + "reduction_percent": 13.657023806801444 + }, + "combined_ms_chunk": { + "baseline": 12.35675987890625, + "candidate": 10.85442152734375, + "reduction_percent": 12.158028207111835 + }, + "noise": { + "baseline": 5.408727453125, + "candidate": 4.9163363046874995, + "reduction_percent": 9.103641340866812 + }, + "surface": { + "baseline": 4.7373909296875, + "candidate": 3.7152747382812503, + "reduction_percent": 21.575508683503834 + }, + "biomes": { + "baseline": 0.38765451171875, + "candidate": 0.382181609375, + "reduction_percent": 1.4117989545599974 + }, + "structures": { + "baseline": 0.32856785937500005, + "candidate": 0.33016451953125, + "reduction_percent": -0.4859453262674832 + }, + "carvers": { + "baseline": 0.38096083203125003, + "candidate": 0.385858296875, + "reduction_percent": -1.2855560026045512 + }, + "terrain_cpu_ms_chunk": { + "baseline": 11.2, + "candidate": 9.7, + "reduction_percent": 13.392857142857144 + }, + "peak_rss_kib": { + "baseline": 773060, + "candidate": 772916, + "reduction_percent": 0.018627273432851265 + }, + "process_user_s": { + "baseline": 8.550168, + "candidate": 7.974602, + "reduction_percent": 6.73163381117189 + }, + "process_system_s": { + "baseline": 0.29184, + "candidate": 0.291122, + "reduction_percent": 0.2460252192982444 + }, + "paired_wall_reduction_percent": [ + 7.854293314463732, + 13.657023806801444, + 12.553897974345846, + 14.148200837826696, + 14.17241465420526 + ], + "candidate_slower_pairs": 0, + "excluded_initialization_ms": { + "baseline": 4000.613202, + "candidate": 3825.288926 + } + }, + { + "dimension": "overworld", + "threads": 4, + "seed": -1, + "center": [ + 32, + -32 + ], + "warm": true, + "wall_ms_chunk": { + "baseline": 3.0581778515624998, + "candidate": 2.639180359375, + "reduction_percent": 13.700887015888346 + }, + "combined_ms_chunk": { + "baseline": 3.3576309765624996, + "candidate": 2.9384793789062496, + "reduction_percent": 12.48355166431578 + }, + "noise": { + "baseline": 5.5047845, + "candidate": 4.9102566562500005, + "reduction_percent": 10.80020196521771 + }, + "surface": { + "baseline": 4.9356213671875, + "candidate": 3.8894710195312503, + "reduction_percent": 21.19591982098062 + }, + "biomes": { + "baseline": 0.47851093359375, + "candidate": 0.44986469921875005, + "reduction_percent": 5.986537059844964 + }, + "structures": { + "baseline": 0.76422690625, + "candidate": 0.7639770234375, + "reduction_percent": 0.032697463339285075 + }, + "carvers": { + "baseline": 0.39066100390624997, + "candidate": 0.3934000390625, + "reduction_percent": -0.7011283769974958 + }, + "terrain_cpu_ms_chunk": { + "baseline": 12.1, + "candidate": 10.4, + "reduction_percent": 14.049586776859499 + }, + "peak_rss_kib": { + "baseline": 791548, + "candidate": 791400, + "reduction_percent": 0.01869753950486894 + }, + "process_user_s": { + "baseline": 8.775314999999999, + "candidate": 8.211497, + "reduction_percent": 6.4250457106098136 + }, + "process_system_s": { + "baseline": 0.307699, + "candidate": 0.31522, + "reduction_percent": -2.4442718370875434 + }, + "paired_wall_reduction_percent": [ + 14.287444679738247, + 14.651419660848955, + 10.766874955512604, + 13.41115679312138, + 14.104231708494565 + ], + "candidate_slower_pairs": 0, + "excluded_initialization_ms": { + "baseline": 3974.517424, + "candidate": 3822.317993 + } + }, + { + "dimension": "overworld", + "threads": 1, + "seed": 12345, + "center": [ + 0, + 0 + ], + "warm": false, + "wall_ms_chunk": { + "baseline": 23.04948128515625, + "candidate": 21.47302998828125, + "reduction_percent": 6.839422012894609 + }, + "combined_ms_chunk": { + "baseline": 24.98420367578125, + "candidate": 23.443390320312503, + "reduction_percent": 6.167150154008521 + }, + "noise": { + "baseline": 5.77484952734375, + "candidate": 5.247983679687501, + "reduction_percent": 9.123455860824672 + }, + "surface": { + "baseline": 4.47116687890625, + "candidate": 3.32858220703125, + "reduction_percent": 25.554507420991243 + }, + "biomes": { + "baseline": 0.42952815234375, + "candidate": 0.42846523046874996, + "reduction_percent": 0.24746267950078715 + }, + "structures": { + "baseline": 11.944554960937499, + "candidate": 12.0325921015625, + "reduction_percent": -0.7370483112423263 + }, + "carvers": { + "baseline": 0.3797641328125, + "candidate": 0.3795897890625, + "reduction_percent": 0.04590842971630777 + }, + "terrain_cpu_ms_chunk": { + "baseline": 23.0, + "candidate": 21.3, + "reduction_percent": 7.391304347826084 + }, + "peak_rss_kib": { + "baseline": 791700, + "candidate": 791520, + "reduction_percent": 0.022735884804850323 + }, + "process_user_s": { + "baseline": 7.833855, + "candidate": 7.450079, + "reduction_percent": 4.89894183642664 + }, + "process_system_s": { + "baseline": 0.292247, + "candidate": 0.296075, + "reduction_percent": -1.3098509137818346 + }, + "paired_wall_reduction_percent": [ + 7.943881825517138, + 6.458250029021142, + 7.540067926396543, + 7.120058306701677, + 6.7398824305859995 + ], + "candidate_slower_pairs": 0 + } +] diff --git a/noise-aquifer-results/summary.txt b/noise-aquifer-results/summary.txt new file mode 100644 index 000000000..ee7ab0428 --- /dev/null +++ b/noise-aquifer-results/summary.txt @@ -0,0 +1,9 @@ +overworld 1 12345 [0, 0] initialized 12.270935 -> 10.566346 (13.891%) combined 14.202495 -> 12.541112 (11.698%) slower pairs 0 +overworld 4 12345 [0, 0] initialized 3.837939 -> 3.408437 (11.191%) combined 4.405165 -> 3.987592 (9.479%) slower pairs 0 +the_nether 1 12345 [0, 0] initialized 5.000868 -> 4.843412 (3.149%) combined 5.381649 -> 5.215208 (3.093%) slower pairs 2 +the_nether 4 12345 [0, 0] initialized 1.395740 -> 1.367372 (2.033%) combined 1.497615 -> 1.473427 (1.615%) slower pairs 0 +the_end 1 12345 [0, 0] initialized 1.087874 -> 1.054903 (3.031%) combined 1.161584 -> 1.128076 (2.885%) slower pairs 1 +the_end 4 12345 [0, 0] initialized 0.275263 -> 0.260434 (5.387%) combined 0.302814 -> 0.288325 (4.785%) slower pairs 0 +overworld 1 -1 [32, -32] initialized 11.333986 -> 9.786101 (13.657%) combined 12.356760 -> 10.854422 (12.158%) slower pairs 0 +overworld 4 -1 [32, -32] initialized 3.058178 -> 2.639180 (13.701%) combined 3.357631 -> 2.938479 (12.484%) slower pairs 0 +overworld 1 12345 [0, 0] cold 23.049481 -> 21.473030 (6.839%) combined 24.984204 -> 23.443390 (6.167%) slower pairs 0 diff --git a/noise-aquifer-results/symbols.json b/noise-aquifer-results/symbols.json new file mode 100644 index 000000000..e5cfc44ff --- /dev/null +++ b/noise-aquifer-results/symbols.json @@ -0,0 +1,25 @@ +[ + { + "binary": "baseline", + "symbols": [ + "0000000000499f60 0000000000000364 t ::apply", + "000000000049ca70 000000000000006b T ::sample_value", + "000000000049cae0 0000000000000080 T ::sample_volume" + ] + }, + { + "binary": "candidate", + "symbols": [ + "0000000000470b60 0000000000000364 t ::apply", + "0000000000471ad0 000000000000006b T ::sample_value", + "0000000000471b40 00000000000010ef T ::sample_volume" + ] + }, + { + "binary": "initial-shared-inline", + "symbols": [ + "000000000047c390 0000000000000351 T ::sample_value", + "000000000047c6f0 0000000000000e48 T ::sample_volume" + ] + } +] diff --git a/noise-aquifer-results/terrain-parity.json b/noise-aquifer-results/terrain-parity.json new file mode 100644 index 000000000..37c143936 --- /dev/null +++ b/noise-aquifer-results/terrain-parity.json @@ -0,0 +1,424 @@ +{ + "schema": 1, + "minecraft": "26.3", + "manifest_sha1": "11f1aefe473eefba0af62e3286c33b692807b2eb", + "platform": "Linux-7.2.11-zen1-1-zen-x86_64-with-glibc2.44", + "java": "openjdk 25.0.4.1 2026-08-18", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)", + "block_states": 35723, + "block_tag_files": 300, + "fixtures": 114, + "fill_calls": 200, + "noise_aquifer_fixtures": 61, + "structure_density_fixtures": 24, + "sources_sha256": { + "mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTerrainOracle.java": "47887c16a4106e6a9ef4d665fd4603ea23b62e38491376bcf9038b904e39b406", + "mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeightmapOracle.java": "145c943637ed177cc4ef8a85f2484da8afd164868e84a8463882feec1653a860", + "tools/test_terrain_parity.py": "8bb8e716e957ef07d1117ed9939fab1b551ebab94d20e48d11f64bc477e4571f", + "tools/test_rust_parity.py": "ce7c94225311e6f90508c3934d6e67c407619b964653bc60ff8139f421320f4b", + "tools/test_worldgen_parity.py": "b40972ab2ad222aa6d77537cc36b434a217baa1f1b56bbaad945d6e12fe776af", + "tools/lab.py": "aef2feb5484b1e73527be272a59d87a69fdddc95bf01d1530f021e29e5c327ff", + "Cargo.toml": "0d7082d8eca4c7fbe93d21bed27a81d3fe29cf563f8be8beb8aaef1c433370ba", + "Cargo.lock": "ab32aebd14140b5e338c485987671b3f7d6e5d14ad4b40764b98bde309ab6bf6", + "crates/horizon-core/Cargo.toml": "e87ac28a37062f16ca532f2bce335c90a84129bdaa69d6c2d1b691809e596fb4", + "crates/horizon-world/Cargo.toml": "939cd091292643abb192b856dc41d8111a1a19d8cf9278be15f804bbc592ec7c", + "crates/horizon-core/src/bin/density_parity.rs": "e5b1dd33b7d01306c73cf072629b4fb186e9ab87b672a00108999d1a72263fd0", + "crates/horizon-core/src/bin/float_log_parity.rs": "4a655fcf8822ee7668c4bd126bc84d0b118864a6fc7f5a6aeee667d8bf2590b1", + "crates/horizon-core/src/bin/geometry_parity.rs": "27f6c09fe5018ac3de8e70e0f0bbf78f9abb14f5e4783bcaf46e8ca87b9c6f8a", + "crates/horizon-core/src/bin/noise_parity.rs": "c135bfc708d853e7061e81487d2cfe10de64b2f65677d3b4837cbfe0b8341010", + "crates/horizon-core/src/bin/parity.rs": "f35d928c66f958de39fac5e7e836a657eed95f83599e84899f7ea7a5802ba481", + "crates/horizon-core/src/bin/tick_parity.rs": "a54c164fe4814034d369947a887f5273966f5a878ba849204b80d1c729526a8f", + "crates/horizon-core/src/biome/seed_hash.rs": "5afbb4921c750826b395a08bf06f382fc7f01b5759a93de02a2749c523e2a317", + "crates/horizon-core/src/biome.rs": "908efa8cd4aa0a7adf1cb5e1a222e3dfb640eed5e9172e0fe7f0d1287afae7e8", + "crates/horizon-core/src/carving/ellipsoid.rs": "09232a7588610e8a9176fd9c62d40afb1fb89f2ecab6d555536a1d847b142d86", + "crates/horizon-core/src/carving.rs": "0aa3093caa0437868a8c0ed52a6c6e1993bd51c03583c670a2837e749eae5426", + "crates/horizon-core/src/density/arithmetic.rs": "82f521e11756cc4455c31e7cacc4587deba2e4bbe08f8bb16c08d7e1f8d76b4b", + "crates/horizon-core/src/density/beardifier.rs": "24fb2ed66128574a610d7df070534551007eb5c89b08cdcda5db444297d750b6", + "crates/horizon-core/src/density/cache.rs": "38d0b6c9dd04ffef979fdad3f29cfebf98d331c8c9d430be5f39aa34f6c30975", + "crates/horizon-core/src/density/end_islands.rs": "168b9384237bd2e41d0ae5a74e944da4dc74e493bdec31fb73184c9a49e3de55", + "crates/horizon-core/src/density/graph/compiler.rs": "ac67deeb16f16d0859aa20e5a165811a29aca0b910037ee6bf5098211f3a6ede", + "crates/horizon-core/src/density/graph/mod.rs": "b776e7da934cb03051a3053d56d461c71e9978e084922fe4194147aa580c07bf", + "crates/horizon-core/src/density/graph/seeded.rs": "6bcdcaa3dffcfa9df673bbbea35120057a16ba3d2b506c52709c36cf8976b74a", + "crates/horizon-core/src/density/graph/tests.rs": "6bfb8cbff462587dd147b0775ea01d370abbd97544b9bd596c792df1b5f7e634", + "crates/horizon-core/src/density/interpolation.rs": "8c890f52b6467f38a94c654986a6a484b8e0b296ab98c398e60a6ce465b5b010", + "crates/horizon-core/src/density/interval.rs": "f12852fcbeecf944a737eb13bc55d9958832624811f2f443adeb579810378b33", + "crates/horizon-core/src/density/mod.rs": "ca0d77d3282e3746ddcbc92bee97dbf640b9a56214e6ac1537f51f9a5b63d6e7", + "crates/horizon-core/src/density/power.rs": "d5b7270a128d4264268cd772109ad16d71a8ec3ff2d3b63b84cb985296d54a91", + "crates/horizon-core/src/density/rounding.rs": "71840c5206ff8d218ac29bf6f66915d5212764ba270c675711a866ba5b55a7a6", + "crates/horizon-core/src/density/selection.rs": "0dd26af2e85004ec5e053039ad11c384c17c56ace9ab45eb3f5cb3503c0b0330", + "crates/horizon-core/src/density/slice.rs": "5d77605573c0deda47778f1f78f7fa3fbf1944d8f5efbcc65cf589181cadf80b", + "crates/horizon-core/src/density/spline.rs": "6bb2e40f940fc6544d6fb09cb0b8cac722be03bc663dbdfb0f61faae207400bc", + "crates/horizon-core/src/density/surface.rs": "159e0e69cda74f870e80ea64fe523c4397e64af4ccb861bb9fd07b2c3cb91b00", + "crates/horizon-core/src/density/terrain_noise.rs": "8d0059d25eb5d248cb97a4c5a2e670d61528928ea151495c004f25adb723fe3e", + "crates/horizon-core/src/density/tests.rs": "422a3cf804b30c1de5fe4c3527c224dbc39dd2d1999358f21663069a28977dde", + "crates/horizon-core/src/density/world_fields.rs": "c1ce305cb8046b384d90c564cafb24af7365d580389637910f3d8b0cc18eb583", + "crates/horizon-core/src/geometry/border.rs": "9e5b104d1ae9389fd10cc57d213a6e59ef28561c9671bf79841217fc1753a93f", + "crates/horizon-core/src/geometry/mod.rs": "c650386f9860e44a96c55f18c8f1428ca715fcb0bc5c2434db5b1caa43df27fe", + "crates/horizon-core/src/geometry/movement.rs": "bcfb452752940ce53ae6dc267a3c4eb29459046a063c1f884684ab4f4bd0068f", + "crates/horizon-core/src/geometry/shape/create.rs": "189812b91d5e0e3ad963afcd1a6e2831b31b8188df91a904ef27061e644806ad", + "crates/horizon-core/src/geometry/shape/face.rs": "f243bce81384040a95ce7984b02b5699206c596c537b2713097e86005b4d3a5c", + "crates/horizon-core/src/geometry/shape/join.rs": "f1b51887b7bf9482557e3ffa99e136f2e5db07ceeb05fdb116adf45e87129075", + "crates/horizon-core/src/geometry/shape.rs": "e8d88a763de1525f77a30b99591641e8a8b80946263acbde035a9bcc356df960", + "crates/horizon-core/src/geometry/sweep.rs": "abd6009c61555161ef2f18b431b2aa384b126c0871cae8b96a62358498a56a1d", + "crates/horizon-core/src/geometry/traversal.rs": "77a3da570a0b85582b669cf4d841cba4b06327006dda26d4a26df4e8ce05bae4", + "crates/horizon-core/src/geometry/trig.rs": "c55f184ae606997985f188f2219aea7c673523358a0eea5b20b473335a42453e", + "crates/horizon-core/src/jmath.rs": "d6d77517605b37e1696cb9b01bb23ec097111a01acc9f0d4946b0aef8acff6c6", + "crates/horizon-core/src/lib.rs": "d823a203ddccbfc4c1a29cc25533d94b93e95777f1fa2d466526a1e1d86e5305", + "crates/horizon-core/src/noise/mod.rs": "1dab5a713abf702402e69ace1bf9e476bba544b0ede5a61c3c3afc60af0a03f3", + "crates/horizon-core/src/noise/normal.rs": "e9e7a46472a54a02c98c46da819842090567153b32fe0c84249009ef19af7aad", + "crates/horizon-core/src/noise/perlin.rs": "e73815447432eab7542f67366cb3f1b368d164e33f6c9cdbd045ac8e4db0932a", + "crates/horizon-core/src/noise/simplex.rs": "6c0dbc15b2b7510195dd28fceca01dcaac1847ccc4a84d299c351589c642fe7a", + "crates/horizon-core/src/noise/stack.rs": "7f6ef0e7d920139ef1a6ad3ec5640f92765715f86dcc5ec29f1a149984f45fa3", + "crates/horizon-core/src/noise/volume.rs": "3f05d2b1780acfdfee60037677d309937a5033b45ef428fc2d540942d4b56b43", + "crates/horizon-core/src/paletted.rs": "4b02dd67a51f1561eae36cd9cf90975f5dc0ad0078ee796e065fa392003d84da", + "crates/horizon-core/src/position/iter.rs": "32d2d8e74821cc4e49e3354202d35d3120e4415bfdda9375a73f2137ef651129", + "crates/horizon-core/src/position.rs": "e10101088e6902386b9b6d27773d44312f1ff72bebb19e57967a54945dde9dcd", + "crates/horizon-core/src/random/hash.rs": "0f88a127a1ba2705d3d6c0ebd009324d6ba86ffa2d27edf2d2a84765e690e4a3", + "crates/horizon-core/src/random/positional.rs": "35494745e5d4cf89e282c3ae0ee245e9f2640ddbbc03bc0055df742006a9c862", + "crates/horizon-core/src/random/worldgen.rs": "f518fdc8e3b67a286b28790cfc8c048317004404e6a6b2a4f51bb97cfae15d09", + "crates/horizon-core/src/random.rs": "96815e1a7fbaa44b70e55955f9d1383fc38cc6233f6d6df16d9efc3ea5d61dcc", + "crates/horizon-core/src/storage.rs": "f6c32201c64aefde06e57a2c767be46918df613548a322801546b133799cc33d", + "crates/horizon-core/src/text.rs": "e6553ddb5db5039e8dc4614b6a6dc9f35a26dc3d1673b68a04e72e7983b67abb", + "crates/horizon-core/src/ticks/generation.rs": "be1237e790693f633a61714ddae68c6506a777588a8a3ab5efbe53a35774dbd2", + "crates/horizon-core/src/ticks/heap.rs": "bf28afab8af77c3d243aa96cd8a1fb8d934140a4dbd07dbfdbf4e7908bb4b845", + "crates/horizon-core/src/ticks/index.rs": "1f1a6a568c2a30eafecb020ca4d5f5fc414860de85b8b381fc419a2e3e65c24a", + "crates/horizon-core/src/ticks/mod.rs": "01634630668172516b8b79d0907bad47f6e2c543a6d499c2fa4b201823b375cb", + "crates/horizon-world/src/active_effect_tick.rs": "88f19cfc3532c47a58c646bb3e9d99ff239a900752302b6a444dda3013e95cbf", + "crates/horizon-world/src/active_effects.rs": "daaf352a69511a7d69fb329997f783b86585e486e0379c84ab0a55641771646c", + "crates/horizon-world/src/attribute_health.rs": "1420a80787d10dd2e2954a3ee6193ff313289d00c7c78ca26ece8bafa21f4380", + "crates/horizon-world/src/attribute_map.rs": "3d871cd530f5c035e0753f3ba065c2b9c5b49cdee75d4119f7dd584b22af67e6", + "crates/horizon-world/src/attribute_updates.rs": "4cb322d75a50d222298994607097ba7f7e6674021128fa02a98a74c057ad05f1", + "crates/horizon-world/src/attributes/entity.rs": "64ac99682a3aa06b1fb94b776b47794234c76b1cf70f1f54933d51e545e69279", + "crates/horizon-world/src/attributes/live.rs": "8198c45134f69135d48ef203e71b6e702529568fd1ed9174d0aa843570bbf9e7", + "crates/horizon-world/src/attributes/mod.rs": "5c2fcbbde58c19261874d227ea98332f00336c9fa53446da2e9adb6aa64a5e5a", + "crates/horizon-world/src/attributes/operation_map.rs": "fc5bc8921d78ea6721a2eaa915e67483e2a33683927467bdba24f0492356ad97", + "crates/horizon-world/src/bin/worldgen_parity.rs": "3143ceb9b56eecfd7667e5feb5f9f0cd13cfb8754b38d4ea338dbba97f2819da", + "crates/horizon-world/src/block_collision.rs": "d129887e43b883e3377763d9ffcad33aa54a63dbea4453e05878e3ea74acd4ca", + "crates/horizon-world/src/block_collision_scan.rs": "4d38621a647e0489e61d531635eb5ff3dfc3a1bc92f8d1158e5155cf9b8eb7ae", + "crates/horizon-world/src/block_entities.rs": "a9deae92e6e5a1fcf4f0476c33ea4d170ddad6fd4b3303e1bb66d933973d5e06", + "crates/horizon-world/src/block_entity_push.rs": "12ee91bf604946234b24a0da4333f07d1830ab9743a422d41c8d0afac7d49cfd", + "crates/horizon-world/src/block_landing.rs": "33083fe39266fbefec1b3ea1a19f2afc609791d189da247c895e116ad6eb266a", + "crates/horizon-world/src/block_placement.rs": "524f4892d50bab77b7d89d19f7b048ffe746996f2ed7f376db2c6ab00ed75c24", + "crates/horizon-world/src/block_properties.rs": "b0bd8a983336c48e488a20caa77dd5c39b1a74bbd14ebc03b3b64556a1c864fc", + "crates/horizon-world/src/block_render.rs": "468734cedb6e2002bb12299ef6b028e443914f7a56b6d15d31786e4906b14896", + "crates/horizon-world/src/block_support.rs": "ade4fbd47284b450dabdd682dc86138b2ac05a0fd379525d7110648908245476", + "crates/horizon-world/src/block_survival.rs": "28ce64375e09819a4f13da9cfbe37c08b5ad0daf01b289c1c360b4567e50e811", + "crates/horizon-world/src/blocking_item_damage.rs": "afea3cb5761e8b82ee4d9bb4ef3c6fd10182a324dbaec99e6c9ebfac255dda09", + "crates/horizon-world/src/blocking_rules.rs": "83c5e2105cec56a90182ce582e1c67ade2b189be6de1a34d08035000cc07c492", + "crates/horizon-world/src/bundle_weight.rs": "a0e7b0587ab5d46cd55588f25d55a088b7a4725099c13ba6df146957be36014c", + "crates/horizon-world/src/chunk.rs": "37953481dc35724c5672c6b74d3b470058a64e9cc4a34280f2dfa6d8ff408a95", + "crates/horizon-world/src/chunk_status.rs": "dbb8583cfa775203c544d24d69e03720385428f15a267a561356c21f5025e9c7", + "crates/horizon-world/src/climbing.rs": "6cd2f919872ff0b726effddaa57eccb805b8eae43f9d01144716010853891879", + "crates/horizon-world/src/collision.rs": "a749794d5c27ccd6c0d964ad02f9dc31d49d9f4fe4b7366cd4bd8155e681b00b", + "crates/horizon-world/src/collision_context.rs": "2176c7034e07f547510a8327cdad9d3b63f26e4754032b76b7d5fe13166c333c", + "crates/horizon-world/src/combat_rules.rs": "01131f70d1acdd96a910e7f96deaa12e51a1e3bb9208085f04e3ec7b657d3cd4", + "crates/horizon-world/src/component_durability.rs": "37a46e184f95bc5027e2b9af72ff52f729ad03601d08e1827f181fca383a35af", + "crates/horizon-world/src/component_patch.rs": "f6f8992f241dfb25e012a06a7ba3fecab8d958686dddd096595a4806e56f0ab3", + "crates/horizon-world/src/compression.rs": "4db73e6ca9a0d552d415ce60e7e88b89c9cf2b7d060a669ff8328f518316e101", + "crates/horizon-world/src/consumable.rs": "ba3575cb85866cb940f33a1ac86455d71cf0cc6395b848588a8ee1fe33f5c326", + "crates/horizon-world/src/consume_effect.rs": "03f2aac6879ce133347d42f6f6667d62c06d956ff9faac5dc14182a788b6a236", + "crates/horizon-world/src/damage_immunity.rs": "fd39c41124d694e755cf7faadcf93c636df4042c78ec345092a856b5f952dbcf", + "crates/horizon-world/src/damage_reduction.rs": "f5a599ab11e077f526237018aeda803ea3c420c5b35c78ae9d85e32267e23bf3", + "crates/horizon-world/src/damage_source.rs": "24945e397a926d34695652980923609e4723e02fe6b6e56d4aaf673e45d759f7", + "crates/horizon-world/src/datafix/block_state_data.rs": "f5a80cf99851b96fc172d844ef2c900a5e605258ca37bbad04f69fb8d2aa10ce", + "crates/horizon-world/src/datafix/chunk_flatten.rs": "f695996b05306519adeaa51e7311903642c01f841851eb918796665e06dd5ae0", + "crates/horizon-world/src/datafix/chunk_leaves.rs": "284a1748cb93a33bacde8b2087bd17dfe9b991f05cb5f0029e10fc472b9d33f4", + "crates/horizon-world/src/datafix/dynamic.rs": "2b7828eb446f2ee3febb02392d435a3c8a2224f6ff7dc9d84bd97fc126351a66", + "crates/horizon-world/src/datafix/files.rs": "5169f7828e73f65ff0acec7f3e9eb9dff5aa1ab1d619618eeffc20d1ee2dde60", + "crates/horizon-world/src/datafix/fixes_a.rs": "95fce5222d62c43020217928b406d11be0d874307e28d395b52001b8e50368f7", + "crates/horizon-world/src/datafix/fixes_b.rs": "166867d935fc5310e4ab153f4de756c7e082f8346342cc7e74a6729315cc0575", + "crates/horizon-world/src/datafix/fixes_c.rs": "e21fb0538ae4fd8bbb3b952f4b0b9852c511083fbe67c21e693db932d28083ef", + "crates/horizon-world/src/datafix/fixes_cliffs.rs": "7d6cd28ab79215ed66629d4fac0c008f468b491d68439f88153f03bca0930fb6", + "crates/horizon-world/src/datafix/fixes_flat.rs": "17ee1a005d5eccae7be42a02e1b54c9348488970f5787345ee3d09c72292e850", + "crates/horizon-world/src/datafix/fixes_legacy.rs": "8f7f40bbbe9fb59b18fc08c2931197ed5634a70246974fbcbe033e455616b1e0", + "crates/horizon-world/src/datafix/fixes_mid.rs": "f9aa4f403fa2a8dc47bf71a36bf1a52abe06967f89a7a185888993ef56f2f60d", + "crates/horizon-world/src/datafix/fixes_old.rs": "1e15a096c9111f62ebb169c4639c19b767706c7be15a661a6936df2fd47b0a38", + "crates/horizon-world/src/datafix/flat_tables.rs": "2bd77d383645faeafaba161df696fbbdaa3fb49e464a64ecb3d6e7b60d6bdbf1", + "crates/horizon-world/src/datafix/items.rs": "9a4f2ad3d962e0711f3958bdf2c73491b4c5f747784ac613abda0cb35fbbd3b1", + "crates/horizon-world/src/datafix/json.rs": "1209e8d63b5d6a7806b0aaf058512e4db0edc4d8923c289cc0e576e3e514db34", + "crates/horizon-world/src/datafix/mod.rs": "3f595bd662835e2c04fe262cfda09a3a7701f42e77e53570b473cadb2da1da3b", + "crates/horizon-world/src/datafix/schema.rs": "c88a72ea1f15a971842156a029a07cc86c7b0fb62eaceda194a30873a1d9890c", + "crates/horizon-world/src/datafix/schema_flat.rs": "53f3b361bc38dcc22510c039bbb9aa7092eb6ccbd5cdfc92f4b7a331434adf6c", + "crates/horizon-world/src/datafix/tests.rs": "9587afc979fc02158ece9704f96129c1f96c8acb93d2734d3bb5515169faac7b", + "crates/horizon-world/src/datafix/text.rs": "4c17bde03df678370fc2043c3a1daed592c5f99c8855c71b6f3773d207d871c8", + "crates/horizon-world/src/dynamic_support.rs": "5996bc1c436fb6215d8fc3d0bb4de5dd9b966d842d432580d624195771697fb8", + "crates/horizon-world/src/edge_backoff.rs": "5259d7aa44e64f88351d1556c44dd0edcad3b400a099c659755792efba7b5773", + "crates/horizon-world/src/effect_attribute_modifiers.rs": "0bc7ab63d0f3f34a7133fe20364cae0ec1fdbd3773cba90faa1f08e0d63a5646", + "crates/horizon-world/src/effect_notifications.rs": "ea66bfa010d6d44aee97b9672902f41cd99d0d80239f41c6d4eae5c9a9472d3d", + "crates/horizon-world/src/effect_particles.rs": "a42dc4ec55929dce1db0f22f8816ecf7621fdce1cd2ac0c90f6a57fea4e0afd2", + "crates/horizon-world/src/effect_sync.rs": "1388d4a69b42a14ff4cd474f5e36f0fad5a2874031e64fa2b19b2ea179deed2b", + "crates/horizon-world/src/entity_collision.rs": "09f2fd7f6cd56fc282f468ecfa765a94506929e9684bd3a5c90123e5b51cd627", + "crates/horizon-world/src/entity_fluid.rs": "f34ba29522a72ca6853f56139bfd53e0a7ceb0af2bb6d8e54a79d8352b043e88", + "crates/horizon-world/src/entity_fluid_tick.rs": "4f9e070b88a73c98a4e2e659360ddd6edee636bca29377f1ea9011fd5a556f64", + "crates/horizon-world/src/entity_move.rs": "a40a50d3e841625a75d4cfbb7c2630ab5a62a574456567e7234f401ae8441b32", + "crates/horizon-world/src/entity_obstruction.rs": "a4b28a19bf83b23611c59d94535c488db37e4aee24b22c973c545910894a809f", + "crates/horizon-world/src/extra_items.rs": "6eba0a0c795d5fd841d31471708e78324b4852adebb2e6ed700dcc0caab668cd", + "crates/horizon-world/src/fall_damage.rs": "8c28e2933493569fe05dea22332024287d28b0746b514dd465681040b003296b", + "crates/horizon-world/src/fluid.rs": "e672e7403145287b74f36721b59bd633f17a30daba37441160c76d9b7c2c4be8", + "crates/horizon-world/src/fluid_box.rs": "b586af72b1c04a9354fe66205c28dc8b619e205ab9ea19a68232722e4b6e96c1", + "crates/horizon-world/src/fluid_flow.rs": "7c7e486b5c565df3602799648b37b879bcca51414337f607962d6c7951b86d05", + "crates/horizon-world/src/fluid_occupancy.rs": "26037579caeef6c8a5a2bde2c3d142d278558b76d77ebff401cee6e35f2ea961", + "crates/horizon-world/src/fluid_shape.rs": "28bb65a72f5bd074a354ba38a1b1707fcb0947537977a11540bba0adb85995c2", + "crates/horizon-world/src/food.rs": "3cf416fa632a5555a8116bb528a6e80bcb5b6b754b0748b4959ed310102418d3", + "crates/horizon-world/src/food_properties.rs": "0926fa3f3bc3d0608c45d02f564355825ca3c3526a82bf9c1375c7a191fa5e12", + "crates/horizon-world/src/food_storage.rs": "58c433801a285efcc973638c11d694a41f85dc96703a3a7ce8d3673f3eb31d52", + "crates/horizon-world/src/free_space.rs": "913536bf4c85ddeeb378d76d1b5110b4175f5688e1a749f32fe6a6d86fbb478e", + "crates/horizon-world/src/ground_support.rs": "3e371d74ecede4d30beef0a7e8a2ee33463584a5b1ed3d852b394efcce1ffbe0", + "crates/horizon-world/src/heightmap.rs": "a5edef082b5af40d814421ea17e129b3b06d70abee6434ed263e4bba58571698", + "crates/horizon-world/src/identifier.rs": "37c921889c4f5d91f7c09ab2ee68d1a5e5a3c4fb1c49b4b189c987b4615fd2d6", + "crates/horizon-world/src/interaction_shapes.rs": "f321284ddab440a394372b6dedc8b5cc29a653c0745251a9e96c650f21c33dea", + "crates/horizon-world/src/inventory_pickup.rs": "ea830c7916e7f2d95c6db7ef48be1e876e6ebafcb438e47fc72f9a5bd7c37d07", + "crates/horizon-world/src/inventory_tick.rs": "293a3d57a1689337cfd58e5a73dcdbed4cb360f94d98ff5458f0df92de387365", + "crates/horizon-world/src/inventory_use.rs": "6a6c2ecc73c83dda4cd798c0304df12ace6096eb110d899f4f0c7ffd852bf001", + "crates/horizon-world/src/item_after_use.rs": "2b6598ce5b7b304dea2c8057b4a1eb6530264ac4d0546c3da0c76deed9609da5", + "crates/horizon-world/src/item_blocking.rs": "f6eee0d6d177cc3148960122327ba1b459a2f0e85241c1d9a3e40f0b8c169296", + "crates/horizon-world/src/item_cooldowns.rs": "7b625868509ab3c51e72db0ac714bb0e7ec5e2610d37271005a1a737f4d14431", + "crates/horizon-world/src/item_durability.rs": "9fdf835e5c7bd0e1dd63ef2ba0076b770cdd4d6d14cdcd11de27690f0702f94e", + "crates/horizon-world/src/item_particles.rs": "861b14f65adb9b14f8158fe9f0b7128beac3df8107b1337c31b8b9b49434ba3f", + "crates/horizon-world/src/item_stack_refs.rs": "18d3ca85cac0daf59200857513761359e5690f719cb3f7f64ae552f0c4169ea3", + "crates/horizon-world/src/item_stack_storage.rs": "b4dcb83dcaa346848c5484161feb3e2cf08e83f7793d7ed83be25b14b9d12884", + "crates/horizon-world/src/item_template.rs": "dc80025215d1867e656924ea2a9d273aacbcaea21293d986ba42d0004ee93b69", + "crates/horizon-world/src/item_use.rs": "b1c79428986efbf9dd5ede703a39eb387fb6dcc7d9950f0e49243a353a5b8070", + "crates/horizon-world/src/item_use_catalog.rs": "a9b53d2e816583239a75c3c61e78dacc5e3b27dee595be34b1c7fa169f17a571", + "crates/horizon-world/src/item_use_lifecycle.rs": "4639b70440cf811e79de09c48a3e035143fcb6be8a64c2f61b10ae55a2f133b7", + "crates/horizon-world/src/item_use_start.rs": "a84092dfb8b8f0a89d0928bb2f8ac252bd9bfd3f8d74fce1a7f7a5b3c3f4f50b", + "crates/horizon-world/src/java_hash_map.rs": "955502e696d7b0b33bae3ec485c8eb1453a8956116aad68226cf1fc67d60babc", + "crates/horizon-world/src/level/bonemeal.rs": "4f7339252251387eb400263c43652a7086905fd82541aaddfb7e9af6c1a355a6", + "crates/horizon-world/src/level/buckets.rs": "ac19649dda818c1cd836f7b07d4233636db8b61174e6e71fa98e664b6046b049", + "crates/horizon-world/src/level/classes.rs": "9814231b93d03a735f25779e3c17fb02a3681b95e06c56c31e1f8a839b0c14b7", + "crates/horizon-world/src/level/creaking.rs": "10d55ff63bfb3d6fcc7e1394da6a3582dbd75397e11f013e3c66ab54eaf38418", + "crates/horizon-world/src/level/data/cache.rs": "e92c168b4a65f392da5c318a49abe88bce7073ed2846539638375ea8d3182ea3", + "crates/horizon-world/src/level/data.rs": "de0136bbf01e3ed2860a4fad44cf1a778cb3ee2a75b85d5525913ae0862319a5", + "crates/horizon-world/src/level/falling.rs": "9cb8995267eed1f8df8b650d6ca2fa287892a2d87a1c525d330e1f3c5eb18199", + "crates/horizon-world/src/level/feature_world.rs": "8be92a674e4620c78d00e77e57289a673f4f831f5d08214c1a2d82720f10d4de", + "crates/horizon-world/src/level/fluids.rs": "f7a77ab6b7dadfa1e125c2f62219607b7f7bf734f9df422d6b88e1aad3e9b498", + "crates/horizon-world/src/level/growth.rs": "70c26d2b54d52d89332ed2d8833e5f872c6b4fb80735460fda50a3eb3a6b6e5d", + "crates/horizon-world/src/level/growth_tests.rs": "c420d2f0c81a6e79b5889a4d0750770c1466950f271674af452b85a06721786c", + "crates/horizon-world/src/level/hooks.rs": "d58d56bbb094eba6b2053f61d8fad34c82922743924de175c3a3d18515e048ac", + "crates/horizon-world/src/level/interact.rs": "8e04f0f41517890c5ec03d9347d1f3852ad0f4bcd010fd9a870de24a4a19080e", + "crates/horizon-world/src/level/mod.rs": "c56bc05dd501aeb208821430477541d180309228caee23bf2abaa188dbcc6516", + "crates/horizon-world/src/level/pistons.rs": "acb3b95ca6ae6e9ae12a10c28668136877a44af1724ca0535e34a98320aca0f9", + "crates/horizon-world/src/level/place.rs": "4e9e91a1fbc8748f46223a9f82655382ffded57997048d9539adb039255f75f8", + "crates/horizon-world/src/level/portal.rs": "b6d51b8cc94d1d46ed8d54bc3fedefe27c66cc436f5c6fd6d986c41293906986", + "crates/horizon-world/src/level/portal_travel.rs": "f311d0055a39ca42b6a8637255bdad6a15ab3568b9820eeaf5bbb01983090367", + "crates/horizon-world/src/level/query.rs": "661d986cebe3f51f894e68c0512f8932c369e24049ba29c7017cfce725df98b4", + "crates/horizon-world/src/level/rails.rs": "fd4b3ba90579da61278fc1b1bbd8e25e5a51f4f23b209f4aea45c542b7aa74ec", + "crates/horizon-world/src/level/redstone.rs": "6a2d0e27da9c5bce78163259e12c3edab47fbd89f42d1fe3688c35728355c358", + "crates/horizon-world/src/level/removal.rs": "d5d6c856835182c8790686e11b96acba48f4b31c66395325c68d0b867d85e96d", + "crates/horizon-world/src/level/sculk.rs": "56552807f82efd87b896b3dcaecff2ccab9bea876f5c2da79ff9fc56b4468a1d", + "crates/horizon-world/src/level/shapes.rs": "cbf211893cf188fcebf4cf94d41d06308431e4bed0036d30c8f40f4a72a939ba", + "crates/horizon-world/src/level/shelf.rs": "326f10a0ee92f27f454c1f33dfaf736f1648de7e0678dc9e28ef14e3ff31dbd6", + "crates/horizon-world/src/level/signals.rs": "dcb15b9c190ee0086f445e1dca4ba45c6f5b92e11cd91def917ff4c1ab4395c8", + "crates/horizon-world/src/level/speleothem.rs": "34a9c9806436728bfb38c6543fdc8a4bfa728f53ff995943192680e74a9e5988", + "crates/horizon-world/src/level/states.rs": "1aa28828ae5de24956db140068639d411bfb7bff1ed46d1cd60a5ca4303568b6", + "crates/horizon-world/src/level/survive.rs": "fe37fc9719424e984b1ecfe698f71d658400c5307c124d3901e8b9beab63de59", + "crates/horizon-world/src/level/tests.rs": "1c8c110126755649d61e1cf5a6dfe9b610c0e6250082413f125be8ef9521484e", + "crates/horizon-world/src/level/tick.rs": "e4c894fd03eff3d0cd67d7ea2271e6b4b4679fc546072e6e60f83edc4e208783", + "crates/horizon-world/src/level/ticks.rs": "f7bc741977d4a7ae2260fb57715f6f4febcca4ab1452e3fd2a7d59cdd794ca94", + "crates/horizon-world/src/level/timeline.rs": "cb4359749a594b77f8793a397b40a57e0c7cdc1a6971c8dc99e89e52c4d3b004", + "crates/horizon-world/src/level/update.rs": "0f9559e5d0338ac1cf4a662e4967f8f6aa9e379b97279cc8d5a183e2551341bb", + "crates/horizon-world/src/level/weather.rs": "b9c18ee56e4e731cef6a6f29a084f89a0bddb3f7edd68f21201c8f61db62f2e6", + "crates/horizon-world/src/lib.rs": "59959cae2c5cb5ae42bf3f255c12055487d899b75e7303dad06d88347dfeccec", + "crates/horizon-world/src/liquid_collision.rs": "0f0a83b04e5a5bc9d98ed05fde4d6584ba69642e93522e726e4cfc325d6fcb1d", + "crates/horizon-world/src/live_attribute_updates.rs": "778171faaaf7077deb0b62c4cc1db16351eba41adb8bb07656ba65e827056199", + "crates/horizon-world/src/living_air.rs": "b2de36bb50bed15e2808fe4a874fcef07f9fea0d2c96385b7b5e8ee9560d4442", + "crates/horizon-world/src/living_damage.rs": "2b448209629b9bf2e678d667ad0d6c7fa22146892dd106b169d96b31b0df12bb", + "crates/horizon-world/src/living_fall.rs": "da0f176f4731e1c86e08bfeee8167742fd1b86380ff0e9304c13c1ce3f1c67ab", + "crates/horizon-world/src/living_fluid.rs": "d7cd914cfb2a1f4876ce0ae95e999bf0ff1af732cce3ab4a3aa2d1ab881c7339", + "crates/horizon-world/src/living_health.rs": "221659f85552424e937d503bba6d8003006b106ced042b32d3a6f6cc23e12ed0", + "crates/horizon-world/src/living_hurt.rs": "844239ad7d15c39629bb3cfc06ebae6d1cff20b7627468f26e0ee8dff3abdcb8", + "crates/horizon-world/src/living_landing.rs": "8bca4eb7977abc2b14fb7174be4ea355352106ea1e76ff5f3ad8696969d9eefd", + "crates/horizon-world/src/living_motion.rs": "56f8c84cfbe205a7a69912d5f76b52ef1efca149c1b6801d4684e25fb179aeb9", + "crates/horizon-world/src/living_use_flags.rs": "826f4fdeba7e208368cbbf910fa408db0afbc6442d842d178a70fae53e0d0ea6", + "crates/horizon-world/src/loot.rs": "4452a14c44b7cb3ac78ce41b9238c32d470a2b85c49d36755df28ff7f37b04d5", + "crates/horizon-world/src/main.rs": "fce57418b8c22a6a0a9044baa89ed3d9c243bc2e8413fea3ff0f32985daba021", + "crates/horizon-world/src/movement_emission.rs": "76e7d6f5b19c94676190f54389f9c4ce12cf89945ccfcb9c750de473223e7753", + "crates/horizon-world/src/movement_properties.rs": "6f01ab920b376a13f5ae12c3718f4dd067e1dff2b829585af00a8b2100f3775d", + "crates/horizon-world/src/movement_restitution.rs": "04b4fe0947e7e52576145bd8ed15920278e8a538afcc74d125eaca513dffa0ef", + "crates/horizon-world/src/movement_statistics.rs": "fe28061e29c41f8f399d29cce8c468a63854613702b5aa525c0f0fd98cb87f9a", + "crates/horizon-world/src/movement_support.rs": "02d85cf572847f2e60b5a7f9d60b856888a67b3c1f4df03e81998c66fdf874be", + "crates/horizon-world/src/nbt.rs": "d2f3aba100974d034ba71dd3955e5aa0e38801ad0693b5ac3e2765fe897bb6a7", + "crates/horizon-world/src/object_open_map.rs": "b4934a9cc38df93ed206ab0bc3bbc4499acd8e40b41b7def7d47067b7170065b", + "crates/horizon-world/src/object_open_set.rs": "d3e0373bf1b652dd054345d5a8e25ec828e06dd7cad65aada35163c95df4e637", + "crates/horizon-world/src/piston_movement.rs": "7a3fd2549a582b5f3a5c21aa05d67d944d62ca1105856679e100ac5b44e9a52f", + "crates/horizon-world/src/piston_shape.rs": "399c2337103b8e7e0eb5667227c5aa14f9549d6a467b7be7da3d0717f0263500", + "crates/horizon-world/src/player_equipment.rs": "1fa8c53e67624c4641246249d79a800a28a4858c62482bd880b4e3b866b936ef", + "crates/horizon-world/src/player_food.rs": "f188dc110745bcc7acc15e6c521db943b06b404f69cd251bf74a345516070304", + "crates/horizon-world/src/player_health.rs": "8155b315453c569db2fbe46228886c5881d1fd55eb095c5849e69bdb500ba2bd", + "crates/horizon-world/src/player_hurt.rs": "99c9bbd8587ec2dc287806049897b8034d2f5349ad47fc497b70d54148844a36", + "crates/horizon-world/src/player_inventory.rs": "f4f67d8312793f25930626c4ac06db688fcf2e2292d6675071d105fb1708d952", + "crates/horizon-world/src/player_travel.rs": "6841a677a900495eb6223031ef3ebe8d859bb98908dda0e2209e5f28839dc593", + "crates/horizon-world/src/powder_snow_collision.rs": "7289946a21478d11abfd2bdcdddff3d7f98e25bf6a68564fed45c3cc01ac2a36", + "crates/horizon-world/src/region.rs": "c339cc89220071766c1ecb18121c84f4d373f716815b179faf9c8dd70c2bc6c5", + "crates/horizon-world/src/registry/json.rs": "7a683afcd1742c5307756927d7f0aa779c7d7992af87d8d371dd98108728e235", + "crates/horizon-world/src/registry.rs": "7afcd2e364aad5d6df103d4a6d0ac3fd8e779f8b414bacd447d040cb150ac36b", + "crates/horizon-world/src/registry_collision_scan.rs": "97cc950a9a4ba387b78e368f36d595f8664ab7730d132900d220ce23b92826ea", + "crates/horizon-world/src/registry_fall_ray.rs": "52935436132df505691144840dcbd858b15d00d8305997284e3a542ecf6bc0dc", + "crates/horizon-world/src/registry_fluid.rs": "b8959c05850cfeaaad1e4de8ca7c7d0d6ac56da9b2c1de3ebefa5871a11ed35e", + "crates/horizon-world/src/retrogen.rs": "6efd36a6293756688c1990a7965bd65609d7c5e2bf2a5f4f01d54932d2b9386b", + "crates/horizon-world/src/server_player_combat.rs": "0a94885c4b7a0d294ba7f4cee18b96ee59649b50112988250b53cc224059a979", + "crates/horizon-world/src/server_player_damage.rs": "29af22dec321fe01776cee5334f050c5bc3e27a688f99c8c3da4c0ad8bc8254e", + "crates/horizon-world/src/simple_container.rs": "0fedbc7e974b1db79b88bd6aff977654189a5d553cf42852fe8bf0885cf90b30", + "crates/horizon-world/src/status_effect.rs": "588bfcf4d93f50be86cb89545bd5c431edbc71771f704ff55cb52906b1964c37", + "crates/horizon-world/src/stored_consume.rs": "621a52c9fba447c393e561f881a16cf1f97d336e3a0ce493725ef51e2db12ffd", + "crates/horizon-world/src/stored_effect_attributes.rs": "c79f6a52d3cfee1a5288225bf8fa91a7bf3ea8cd21faea9f6dc748ecefc6309a", + "crates/horizon-world/src/suffocation.rs": "bed219dd5bbab6263b98fbe3d0eb512cb96c52ae847210efe49514d05f22f11e", + "crates/horizon-world/src/swimming.rs": "49d2dae13c109b37ff832cde98a857944ff45247b864a527b9c4f03ecca7a7b7", + "crates/horizon-world/src/synced_floats.rs": "0152f2752bafaf68769d56dbc88494a976496a680c6b113d6b48a446158ba072", + "crates/horizon-world/src/synced_values.rs": "a1d4b53ae77d1899ba2b4ead67c9ec1e3c96615558e446f9d0760c1b4a520169", + "crates/horizon-world/src/teleport_consume.rs": "d6a53bbb6ac4dbbd4c0591d0646017898a95beb8ef093dc5d81b9833963be6c3", + "crates/horizon-world/src/tick_data.rs": "f8d04a69ea263f4168bce33f92e5b4ee2fe07d7caf50a1621c6b3ef6eb2479f3", + "crates/horizon-world/src/use_remainder.rs": "f555335afeca7970888131a6da2f5a614a73253b631185d1ba804593a349535e", + "crates/horizon-world/src/view_direction.rs": "e18120ae26dc5cf702b29fc4c8487088bab133c8ce5abce01226833fafb0d5a4", + "crates/horizon-world/src/water_splash.rs": "e0461ae1b2e8c851cca6e3251a188334293292201d7f80dc9e7d60fd1815f4d1", + "crates/horizon-world/src/world_movement.rs": "f8fe9e34f2395d2a04c839d1c8ba78e09ce493c26de6f6e4e237b9c19c061da5", + "crates/horizon-world/src/world_ray.rs": "879bdbbe12f56deb705cc183933431489e840b71eade40c33391eed5949c2e61", + "crates/horizon-world/src/worldgen/anchor.rs": "d156b8a0b147a274cdd143409b441f4f43edecde6e8ee14ef9cf0309f743143a", + "crates/horizon-world/src/worldgen/aquifer/config.rs": "fcd2cc3a520c1527c88f095a3b5d38487e7ebb1ccecc5f757f93d04a069add4f", + "crates/horizon-world/src/worldgen/aquifer/noise_based.rs": "74daaa389b5c3dfdc99214dfff256a9e172f83548d2326cbc941d9637cc53fb7", + "crates/horizon-world/src/worldgen/aquifer.rs": "cb4b66d87de3f9f79ae6ffe4badd6f0f44886cd42ad9de2771b8b56c4f1e28c7", + "crates/horizon-world/src/worldgen/bamboo.rs": "d9b47113c99be34256e58308bc6f40072ff25c579d6bf995182aa862c0006102", + "crates/horizon-world/src/worldgen/biome.rs": "3fe316b875aa32683759c337dc71f624910faf0812a2d6d83b8098d6d0bac7a0", + "crates/horizon-world/src/worldgen/biome_chunk.rs": "8fdfe6ebe3ffeca97611fd5991a5bc6b2783ea1c62f4d8ef3b2dd53c04a5dc1d", + "crates/horizon-world/src/worldgen/biome_predicate.rs": "bfc581bc40077cc74ffda43e990a55fe997adc04c7130f98e039c3305ca79aac", + "crates/horizon-world/src/worldgen/biome_source/codec.rs": "2b9e4f5d679eb444cb73174f511e3b9f32e9eb138248ab12cffc6cfd76adf3a8", + "crates/horizon-world/src/worldgen/biome_source/runtime.rs": "f0b02c1521178e4d0377c6ca62694604b6a773f1f234f070ff0cde4685911d45", + "crates/horizon-world/src/worldgen/biome_source.rs": "e181e1736f3e0b75f7091a24c88de3fd116e01b98424d02382aea7a503d1eb54", + "crates/horizon-world/src/worldgen/biome_temperature.rs": "cde4bbab5e260c4065b113376c423b8511ade93c5aa5fd976e245ee8a58b5ad1", + "crates/horizon-world/src/worldgen/biome_weather.rs": "96b1f9494559ed31d06257b83d604d00cc069ccc8c7b68094117e034b4a71bd7", + "crates/horizon-world/src/worldgen/block_blob.rs": "c608c57b3d77279646ecb89e50677dd8e452b0422ffd357ba755536c5589eb89", + "crates/horizon-world/src/worldgen/block_column.rs": "f72c21a9066ee0aa68c2fb79fba436d05afb14c6ef5a2cb012f1ed35fc17cd22", + "crates/horizon-world/src/worldgen/block_feature.rs": "78abf6c0768b7123ae7acb8f83980a91c4373bb8002c61387c98e4113aa47170", + "crates/horizon-world/src/worldgen/block_pile.rs": "623e369b77e0526ed2756485a6c0bb09683cd28ad8876dea907360ca6665b39d", + "crates/horizon-world/src/worldgen/block_predicate.rs": "074c692367e3f2191a1bb28d87b23402430a843c246bd30a4ea838ee3500280e", + "crates/horizon-world/src/worldgen/blue_ice.rs": "eedd77bdaff808330b864166d303378096daa5c7d235e925770b171c05109247", + "crates/horizon-world/src/worldgen/bonus_chest.rs": "05d0f63fbc7412f13ba1fa37a7238114b8f70bfff318beb2dece590482d49cc0", + "crates/horizon-world/src/worldgen/bulk_section.rs": "eecf61532d7793f853884c5a18a7f436a59835c7b13d3ec9075804511553c9ba", + "crates/horizon-world/src/worldgen/carver/canyon.rs": "509c4d5a9d689849e98e894ab14a9fbf82d10707d38e9cc688ded3c4778df3e2", + "crates/horizon-world/src/worldgen/carver/generation.rs": "a4498d0d1457536de3922a08e9c40ccce8d2ef9cc263801c15a412327513c098", + "crates/horizon-world/src/worldgen/carver.rs": "46b251e28225fe1250de38f49dec5dacda4e2c4ba1e556e21e6d1e14e2651fc3", + "crates/horizon-world/src/worldgen/carving.rs": "4e77d4e5c4a0ca55ca3563b9bdf6f379342e0bdf9d019d60f7bc57ce4afb5fbd", + "crates/horizon-world/src/worldgen/cave.rs": "d4efcdf209d871a8b09423f3721e045f247c1f2302f501d342ca510733192d69", + "crates/horizon-world/src/worldgen/chorus_plant.rs": "29224c164ede919e280a65a68f155c873e2c8fd0aa7d7e244d8fa9e468760250", + "crates/horizon-world/src/worldgen/climate/codec.rs": "d567adeb5d837816fca69102db51d790f71aec1b51c09298230d24612e400a14", + "crates/horizon-world/src/worldgen/climate/index.rs": "c5ce61679a5f0e0f2f0af2a373424effa124d0cce8250609eff38b7034650756", + "crates/horizon-world/src/worldgen/climate.rs": "1b9ad44407f40aee4c1cd5357a5c9c443c1b105728f01cf5c644072f99f8357e", + "crates/horizon-world/src/worldgen/decoration.rs": "d355b68067f0c96389d95500af06d3ced1c525ed15fedd9cfba2afa827087c55", + "crates/horizon-world/src/worldgen/decoration_order.rs": "7271fd3bdfadd33e392ed931a1ba4d3c2c0072ffe85d911b7fdb0d10d88c2aad", + "crates/horizon-world/src/worldgen/delta.rs": "c2bf49ddf3231d28c109e68871429bc13d76a7bebe14eb33e84aa856bdd66145", + "crates/horizon-world/src/worldgen/density.rs": "65a98c156a290a6b374ef670d28cd5dfbe0aa93171824d1bbd96422536273f84", + "crates/horizon-world/src/worldgen/disk.rs": "6f8f9e059755af44c9bfa1b91eba54a7d13fad811dce31717c5502d7f6df33d7", + "crates/horizon-world/src/worldgen/dripstone.rs": "48e4f10ad7640d94d54d625fea37b9051acaf9abe8d12ebce6c106fa6467725f", + "crates/horizon-world/src/worldgen/end_gateway.rs": "f53fde77d6a36a525cd15d890003b2c129d0689a4cbfa2cf443a0c2e3acae040", + "crates/horizon-world/src/worldgen/end_podium.rs": "8f6d0d6d60ff0fde63de5781e867239db321f82cf12639f0537d410a3731ee1d", + "crates/horizon-world/src/worldgen/end_spike.rs": "6046eefa30b0cac230fac43f37cd280d246647a379d52c9e13f1ef74c47259b7", + "crates/horizon-world/src/worldgen/feature.rs": "40500af71ee6628dfb27518262d99f08d0383ae6c7b9397452feef0c213eadd9", + "crates/horizon-world/src/worldgen/feature_catalog.rs": "5eff54d06ff4f136381e7abb044a4414dcc3bfb490c2e004b83d0e77d81256aa", + "crates/horizon-world/src/worldgen/feature_graph.rs": "d4c03fa371093194840a0d6df5a0e044febe749ad916f4f092c6f0768948f806", + "crates/horizon-world/src/worldgen/feature_region.rs": "c4b35e910fba60789cf516b9115e37b2c53edd379b127bf1b8ae68f763ab19a6", + "crates/horizon-world/src/worldgen/feature_sort.rs": "3488a093dfe1321aaa29d8a30cfb115d8e666a81bf195514e87b170de626835c", + "crates/horizon-world/src/worldgen/fluid_predicate.rs": "64197c9e63bebf1ce04bc280bfe980bb6c1b9aa887ca5cded904aeb0d9ae6c46", + "crates/horizon-world/src/worldgen/fungus.rs": "e5d9836db4212f2c9ae4dfb9f8b7bfa21ca0ec9db7a13a4035ae5f115189bd4b", + "crates/horizon-world/src/worldgen/generator.rs": "36088c0ad7138f9e5a6017be7eb0aaea21c91ff887308a2618488ee35c79c5ec", + "crates/horizon-world/src/worldgen/generator_blocks.rs": "9fbc12a05dab15fe12531cb9d2fb2d3636efb5e64074960196df251e72aec699", + "crates/horizon-world/src/worldgen/generator_decoration.rs": "ebb4f70b7da768726f10c1edacf7993d52e1907529e44fbef101a67f30a39de2", + "crates/horizon-world/src/worldgen/generator_structures.rs": "1f281d0264bbb46e161594249a5267572b1e00e001fcedbd293d5fcd66d3d9ee", + "crates/horizon-world/src/worldgen/height_provider.rs": "368d4dc119854742a045c4a717679c921456da681fc5f71aa9b37102d6f33b47", + "crates/horizon-world/src/worldgen/iceberg.rs": "4112535f540fe46627a3604d59e0c25e778d4deffccfbc7a663729d1a03a4d12", + "crates/horizon-world/src/worldgen/live.rs": "697e8a40432806e63fb6b8d6072175355a1f443ad5c7a2a5fd9d80bbe5429de6", + "crates/horizon-world/src/worldgen/long_set.rs": "d81e21822655a02a19a28271bb0ed33b60c9e5c11327bad8ec1637fc807f9974", + "crates/horizon-world/src/worldgen/material_condition/codec.rs": "09b909bc384472f76d163c8069ec6b507c7d5c6a028a36d5e0e3df20deff7b3b", + "crates/horizon-world/src/worldgen/material_condition/density.rs": "df9d0761e978e5010663ae8b44f2d6c1ecb4907331e333bdb6a2b487c1e107de", + "crates/horizon-world/src/worldgen/material_condition/library.rs": "a55534c5da97575a819af5a7dc0dbec9069993fa8b2619c6c9d5576946e683fa", + "crates/horizon-world/src/worldgen/material_condition/noise.rs": "ffb59cc6be2275d7a5621bf7d768527e74a8326ed7ad78618746711540921675", + "crates/horizon-world/src/worldgen/material_condition/rule.rs": "fed643352efbcb1f68f29b6241896617db889fc7c577a6247564e01922fec1fe", + "crates/horizon-world/src/worldgen/material_condition.rs": "d638dcb8cbcb5da20b3cb29602b0ae6a86c4fdf9d8c0fb725de8ec5fc108717e", + "crates/horizon-world/src/worldgen/material_extensions.rs": "ab806eb679d5116e1aebb64fca70e1499ae71f83c9507a8cb4c3201c2b1bf037", + "crates/horizon-world/src/worldgen/material_stage.rs": "698cbc786eff13c246e2bc2ea062401918cd4265899fbc3d53abc87e45a8e7a1", + "crates/horizon-world/src/worldgen/material_surface.rs": "5d37b90099df3d6da0845dab164e71469fb287019c2ee74bc6714f3b9d6d6d5b", + "crates/horizon-world/src/worldgen/ore_feature.rs": "9b5ce4c5303b73098265c530c627ca3e94e82640a9438cf4bfe892e7efa0f6c9", + "crates/horizon-world/src/worldgen/placement/chain.rs": "9218399b4d3757f7bbc550d7729a7201f32a1c83a7030865e0c12aab8a80d116", + "crates/horizon-world/src/worldgen/placement/context.rs": "4b589b153d8f03cfc983017c7e81503dddd5b18f725de7fa18cfb3e597fa6e4c", + "crates/horizon-world/src/worldgen/placement/layer.rs": "a0f5ca776f33f9d4f72b8fdcd163426152e5e43cb4a7572fc1d4fc57bf965de1", + "crates/horizon-world/src/worldgen/placement.rs": "b0397e5818fae84358546193a95f84bcb0b5bffafce909e6fcb3386179ee8023", + "crates/horizon-world/src/worldgen/projected.rs": "a546daf30acfdb01fb21aa40636958739b19f662c5b4645d9c4e8472bd44d646", + "crates/horizon-world/src/worldgen/replace_blobs.rs": "bf3377d86d2570cd15288ba69dde64a2cf67c5bcbb9a31d0c23421964af74afa", + "crates/horizon-world/src/worldgen/root_system.rs": "d6fa50238ec6915b527900080dc4ee65727f9d0de4f2e02190768e18cead71ce", + "crates/horizon-world/src/worldgen/router.rs": "2cee7cf15a0d2ada12be6b39d83e78177fd3033922e4f4cce87a64073cec2847", + "crates/horizon-world/src/worldgen/rule_test.rs": "d1662ec492489ebaa4b87e20f9a8c809dcf3a223a151211bd65ec241a63692fc", + "crates/horizon-world/src/worldgen/sculk.rs": "cfab1fa9acf0f6745e1edd1e95810ccbba0f2adb35de08ce8192b21c81e2b214", + "crates/horizon-world/src/worldgen/settings.rs": "a8fe87752e1982ef11cb67f8d80d8e3428b2c27db178044cb425ba803e689e59", + "crates/horizon-world/src/worldgen/simple_block.rs": "9ba1a88d5db4925f8c37366557887f776c805f9a6444781615b5dbaff52e92a4", + "crates/horizon-world/src/worldgen/snow_freeze.rs": "9040be3d5c7f8f0fd812d2df45e154bf8a9eeef038530b83fa4159d246eac35f", + "crates/horizon-world/src/worldgen/spawn_finder.rs": "768c550ea60271d9628836f7dbd6778a89923765c5521698dc56aebdacf0c629", + "crates/horizon-world/src/worldgen/speleothem.rs": "c71651c1c97818a8a85863e14414d6139ea3bdeb897fa422043bcc1499d99aae", + "crates/horizon-world/src/worldgen/spike.rs": "eacf0d9d3d2bc3d4bcf62bc87555f90031138236a5bfef0eb5270204f7c2a4fc", + "crates/horizon-world/src/worldgen/spring.rs": "830849e9b89fcdf09e9b06fbefdcdebe3c8c3f82804f60b8bd5de04ba303cb62", + "crates/horizon-world/src/worldgen/state_provider/catalog.rs": "c8687e15a4887a9200c8d365857d801efaa8f90e669eee3e600a1db4905119eb", + "crates/horizon-world/src/worldgen/state_provider/noise.rs": "7ee369c2a032e5620cb9bdf9ee7adad1f70870fb0a27efb7b7c514d92f83491f", + "crates/horizon-world/src/worldgen/state_provider/properties.rs": "b67b5ebde681a5282677b5317621e9d828466ffc1e041de24ca58bd867e6dc70", + "crates/horizon-world/src/worldgen/state_provider.rs": "f0f98a681b88f5934e7fd6cd703b5786ff4c5e2c5cd70f5ba2bf1b7ff7ab2c80", + "crates/horizon-world/src/worldgen/structure/end_city.rs": "a7461eb30cb47e3a8d1fd6238bb6a904c537312f59ce582c92940b4f6791c64e", + "crates/horizon-world/src/worldgen/structure/features.rs": "b67cc0b901192230c21aa657a3e679f39597f0e4a6d4d17f17a64f05bb4434d5", + "crates/horizon-world/src/worldgen/structure/fortress.rs": "c3313a91a192dbf133d579ec96cd61de6c24fe6d84b35f9ee88d5294fced5069", + "crates/horizon-world/src/worldgen/structure/jigsaw.rs": "60be3fc344d7a8a1b684e2205684aa670551b0ba362ff987d9e82c54f2937ad9", + "crates/horizon-world/src/worldgen/structure/legacy.rs": "94a6f372aac8738fb4bd102c3d60bea43522fc8db296cc2ea4793210972eaafe", + "crates/horizon-world/src/worldgen/structure/mansion.rs": "9019a9c229e4d050ed5335b5a9bbde902fc3d7cc935539c0497d954b93e0d0d7", + "crates/horizon-world/src/worldgen/structure/mineshaft.rs": "21922ab09879817510ef0ed4b1a494f9a73e8aedd66c5e81684bfa58285aacbc", + "crates/horizon-world/src/worldgen/structure/monument.rs": "8a1069e11165c7cc8539537fa392d218b8098a861d3caf7c1d187b488a166732", + "crates/horizon-world/src/worldgen/structure/nether_fossil.rs": "98877223961c64b48c03bd9a0a6dd7f3f34d0a3e922b364a4a9ad16a1d9355fa", + "crates/horizon-world/src/worldgen/structure/ocean_ruin.rs": "284550daf599344c1f0bcbd6c25a6ce764d66c0f610dc5b1a1bf9f2f8e730464", + "crates/horizon-world/src/worldgen/structure/processor.rs": "9c4bcf5b0086e027b262436b9f1228a35aa262a5b704570256e459a742a8a1ee", + "crates/horizon-world/src/worldgen/structure/ruined_portal.rs": "bb016156b97232a88f09f5f31a88b00af6e5e3527d74420c8f033ae2005b1d3d", + "crates/horizon-world/src/worldgen/structure/simple.rs": "e31c6d032da36a9b79dfe7551ea1e1e3d83466225d45205d71deb65cd70dfb9b", + "crates/horizon-world/src/worldgen/structure/start.rs": "b9b05c167a316a0eb6cde29cb339c9220c8650909125d243146b25e217b84db3", + "crates/horizon-world/src/worldgen/structure/stronghold.rs": "7b0727cb5e29587bbc83331fbeb8cfe3e3091cbcf4c4d68aa1abc2a91a1ad3a7", + "crates/horizon-world/src/worldgen/structure/template.rs": "e7d555292777e86fe887c2dbaaee9a9bb2edb48420b056c0ebbfbc080659b179", + "crates/horizon-world/src/worldgen/structure/temple.rs": "ffc9a610cc87c287e5dd2953b66e40ef653a0cbb2b727cfbfc75baf5d60b1327", + "crates/horizon-world/src/worldgen/structure.rs": "2e61637e3a06f06ea2485c5eea2e1055f2aa28e71c60aaa626d060d0e49b9d92", + "crates/horizon-world/src/worldgen/tags.rs": "74e4110fb19c4c4047192fd65c38015b8afc7f9fc50404d75380b5063808148c", + "crates/horizon-world/src/worldgen/terrain.rs": "2fd34855f3dfffff307e24082a9a29fb3bcf2c5d99550148a3e724fb89a19fe0", + "crates/horizon-world/src/worldgen/tree/decorator.rs": "145df5e1220355215fb021fea83382e8794255b27d1533f3faca5d0320e3c91c", + "crates/horizon-world/src/worldgen/tree/fallen.rs": "ff29c68ef7ff339c0862fae5f46b3bd1fae22b58c9562fcb038d7e9937d42625", + "crates/horizon-world/src/worldgen/tree/foliage.rs": "47ecf142f786083a250019b5aa55d0ff1114c924d53baf3ba3c16b2e1399c56a", + "crates/horizon-world/src/worldgen/tree/trunk.rs": "ba249287c25c2c156120e005a2432323e608f646f2635438135d9fcb6cac6c43", + "crates/horizon-world/src/worldgen/tree.rs": "bf4d5cf3ba210fdafdb701c0bea8be29e62f2186b7834d486a5a42eb4189173a", + "crates/horizon-world/src/worldgen/tree_blocks.rs": "bd72371a2c8caf9919dfdcc79d695cb4a1037d4ec3b094718f5be8bced90c6fc", + "crates/horizon-world/src/worldgen/underwater_magma.rs": "7317e40af5ee5a9780f90ce358fa5d3e7f5b3d513b731df6ff97754d9c2a0154", + "crates/horizon-world/src/worldgen/value_provider.rs": "b69be331b0baf9c7d4118f096a1eaca2e535676970a8638a9edb311f0a7d73b8", + "crates/horizon-world/src/worldgen/vegetation.rs": "175430dd525da6c2510f64dbc498d647deeed34428f7a4c3b0d600edd86667aa", + "crates/horizon-world/src/worldgen/vines.rs": "ee9b79b65012bd86a838241d2ef708680f7fe8eafc8aa656dae9cf2abf3c6418", + "crates/horizon-world/src/worldgen/weighted.rs": "839840aae25302933bbd97a81a2336330e2d03a0ad1684e1e16ac769ed408e6b", + "crates/horizon-world/src/worldgen/write_zone.rs": "8e17a179764d3f68c05882aef35f6810c28a0000f9a83e58bd6030660b76e64e", + "crates/horizon-world/src/worldgen.rs": "1c6de22dbbde5c8f484ec1818738301aced524a711132c03a2e0894850ec47d0", + "crates/horizon-world/examples/terrain_fixture.rs": "eb521404a3e850be522f3bda2f7c724c7d1b66e154e1bc53121b4e7511e5b1bd" + }, + "fixtures_sha256": { + "noise-aquifer-results/private-parity/rust-terrain-parity/inputs.txt": "a9ddccd711b0b6bdcae612a21f2b0dc143e156c9c97f47fce33071c7ceb660bd", + "noise-aquifer-results/private-parity/rust-terrain-parity/registries.json": "2a4e6b29a707ebbb7261f978b9e0dcd372f0c8548e2fb7e00c6bebb043bc49b9", + "noise-aquifer-results/private-parity/rust-terrain-parity/facts-client.json": "1d24883ee807b0b71473f0bbf8ed548ddaf712148caeb3fcc7aa13ab973a97b0", + "noise-aquifer-results/private-parity/rust-terrain-parity/facts-server.json": "1d24883ee807b0b71473f0bbf8ed548ddaf712148caeb3fcc7aa13ab973a97b0" + }, + "rust_output_sha256": "ff3612b2d998278b65c1b453b9df73ecf198151b8d094c150c16872106212bfc", + "references": [ + { + "side": "client", + "jar_sha256": "4508d006323f24fa02876310c192d739af56516eb259000ac50f0909a68c9a2d", + "output_sha256": "ff3612b2d998278b65c1b453b9df73ecf198151b8d094c150c16872106212bfc", + "matched_output_lines": 7950873 + }, + { + "side": "server", + "jar_sha256": "a362163eec5d1612d520772bc16e5b39c09e3b234fdc045f56bf544284ee8ae6", + "output_sha256": "ff3612b2d998278b65c1b453b9df73ecf198151b8d094c150c16872106212bfc", + "matched_output_lines": 7950873 + } + ], + "scope": "Noise-stage filling only, using actual vanilla NoiseBasedChunkGenerator.doFill and NoiseChunk with empty blending and empty or supplied rigid-piece/junction structure fields. Independently authenticated client/server registry resources and exported block identities/properties/air/fluid facts must agree. Rust compiles the final density and optional aquifer through a shared compiler/context, writes resident block sections, updates ocean-floor/world-surface worldgen heightmaps and records ordered per-section fluid postprocessing offsets. Comparisons cover every raw section state, heightmap word and postprocessing offset after each fill, all bundled routers/aquifers, both seeded random factories, synthetic roots, prefilled chunks, partial vertical volumes, repeated fills and structure-density bindings in final-density/aquifer graphs. Block behavior facts remain imported; actual biome properties and material rules are not evaluated. Surface/material/carver/feature/structure stages, nonempty blending and live structure discovery, complete generated worlds and gameplay/rendering remain pending.", + "harness_adjustments": { + "profile": "fast", + "storage": "/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56/noise-aquifer-results/private-parity", + "runner_sha256": "c9307ea06a7eecd0d9b78d500e114123d6342eaeaf4419614d5c49f7493b13ea", + "original_harness_sha256": "8bb8e716e957ef07d1117ed9939fab1b551ebab94d20e48d11f64bc477e4571f" + } +} diff --git a/noise-aquifer-results/validate_chunks.py b/noise-aquifer-results/validate_chunks.py new file mode 100644 index 000000000..da7a0a87e --- /dev/null +++ b/noise-aquifer-results/validate_chunks.py @@ -0,0 +1,28 @@ +"""Compare every terrain/decorated chunk and the extra diagnostic metadata exactly.""" +import subprocess,os,json,pathlib,hashlib,filecmp +root=pathlib.Path(__file__).resolve().parent +work=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56') +resources='/srv/bob-data/horizon/.local/horizon-client/26.3' +rows=[] +for dim in ['overworld','the_nether','the_end']: + for threads in [1,4]: + for seed,cx,cz in [(12345,0,0),(-1,32,-32)]: + label=f'{dim}-t{threads}-s{seed}-c{cx}_{cz}' + outputs={} + for version in ['baseline','candidate']: + path=work/('snap-'+label+'-'+version) + env=dict(os.environ,HORIZON_PROFILE_WARM='1',HORIZON_SNAPSHOT_PATH=str(path)) + cmd=[str(work/('snapshot-'+version)),resources,'--seed',str(seed),'--size','9','--threads',str(threads),'--dimension',dim,'--center',str(cx),str(cz)] + result=subprocess.run(cmd,env=env,text=True,capture_output=True,check=True) + (root/('parity-'+label+'-'+version+'.log')).write_text(result.stdout+result.stderr) + outputs[version]={phase:pathlib.Path(str(path)+'-'+phase+'.bin') for phase in ['terrain','decorated']} + for phase in ['terrain','decorated']: + a,b=(outputs[v][phase] for v in ['baseline','candidate']) + equal=filecmp.cmp(a,b,shallow=False) + row=dict(dimension=dim,threads=threads,seed=seed,center=[cx,cz],phase=phase,terrain_chunks=81,decorated_chunks=49 if phase=='decorated' else 0,baseline_path=str(a),candidate_path=str(b),baseline_bytes=a.stat().st_size,candidate_bytes=b.stat().st_size,equal=equal) + for version,p in [('baseline',a),('candidate',b)]: + with p.open('rb') as f:row[version+'_sha256']=hashlib.file_digest(f,'sha256').hexdigest() + rows.append(row) + (root/'chunk-parity.json').write_text(json.dumps(rows,indent=2)+'\n') + print(label,phase,'MATCH' if equal else 'MISMATCH',flush=True) + if not equal:raise SystemExit('Chunk differential failed; snapshots retained') diff --git a/noise-aquifer-results/validate_density.py b/noise-aquifer-results/validate_density.py new file mode 100644 index 000000000..e9abca121 --- /dev/null +++ b/noise-aquifer-results/validate_density.py @@ -0,0 +1,33 @@ +"""Run the existing pinned density corpus with a fast-profile candidate and fresh Java oracles.""" +import sys,os,json,pathlib,subprocess,hashlib +root=pathlib.Path(__file__).resolve().parents[1] +sys.path.insert(0,str(root/'tools')) +import lab,test_rust_parity as base +work=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56/parity') +work.mkdir(parents=True,exist_ok=True) +(work/'minecraft').symlink_to('/srv/bob-data/horizon/.local/minecraft',target_is_directory=True) if not (work/'minecraft').exists() else None +lab.LOCAL=work +lock,jars,libraries=base.verify_artifacts() +shared=pathlib.Path('/srv/bob-data/horizon/.local/rust-density-parity') +prior=json.loads((shared/'report.json').read_text()) +inputs=shared/'inputs.txt' +assert lab.digest(inputs,'sha256')==prior['inputs_sha256'] +for name in ['mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDensityOracle.java','tools/test_density_parity.py','tools/test_rust_parity.py','tools/lab.py']: + assert lab.digest(root/name,'sha256')==prior['sources_sha256'][name], name +classes=work/'classes';classes.mkdir(exist_ok=True) +dependency_path=os.pathsep.join(map(str,libraries)) +source=root/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDensityOracle.java' +subprocess.run(['javac','--release',str(lock['minecraft']['java_major']),'-proc:none','-cp',str(jars['server'])+os.pathsep+dependency_path,'-d',str(classes),str(source)],check=True) +binary=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56/horizon-density-parity') +rust=work/'density-rust.txt' +with inputs.open('rb') as stdin,rust.open('wb') as stdout: + subprocess.run([str(binary)],stdin=stdin,stdout=stdout,check=True) +references=[] +for side,jar in jars.items(): + output=work/f'density-{side}.txt' + subprocess.run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jar),dependency_path]),'dev.horizonlab.parity.VanillaDensityOracle',str(inputs),str(output)],check=True) + lines=base.compare(output,rust) + references.append(dict(side=side,jar_sha256=lab.digest(jar,'sha256'),output_sha256=lab.digest(output,'sha256'),matched_output_lines=lines)) + print(side,lines,'lines match',flush=True) +report=dict(minecraft=lock['minecraft'],profile='fast',binary_sha256=lab.digest(binary,'sha256'),inputs_sha256=lab.digest(inputs,'sha256'),references=references,rust_output_sha256=lab.digest(rust,'sha256'),oracle_source_sha256=lab.digest(source,'sha256'),corpus_script_sha256=lab.digest(root/'tools/test_density_parity.py','sha256'),runner_sha256=lab.digest(pathlib.Path(__file__),'sha256'),sources_sha256=base.source_hashes([root/'crates/horizon-core/src/density/arithmetic.rs',root/'crates/horizon-core/src/density/tests.rs']),scope='Existing corpus authenticated against prior report and unchanged generator/oracle source; candidate and both checksum-pinned Java sides run freshly; density parity, not whole-game parity.') +(pathlib.Path(__file__).parent/'density-parity.json').write_text(json.dumps(report,indent=2)+'\n') diff --git a/noise-aquifer-results/validate_terrain.py b/noise-aquifer-results/validate_terrain.py new file mode 100644 index 000000000..a49cb909f --- /dev/null +++ b/noise-aquifer-results/validate_terrain.py @@ -0,0 +1,27 @@ +"""Run the repository's complete terrain-fill parity harness in isolated storage. + +Only the Rust build profile/path changes from release to fast. Oracle, corpus, +source authentication and exact comparison logic remain the repository's own. +""" +import pathlib,sys,json,hashlib +root=pathlib.Path(__file__).resolve().parents[1] +sys.path.insert(0,str(root/'tools')) +import lab +private=pathlib.Path(__file__).parent/'private-parity' +private.mkdir(exist_ok=True) +if not (private/'minecraft').exists(): + (private/'minecraft').symlink_to('/srv/bob-data/horizon/.local/minecraft',target_is_directory=True) +lab.LOCAL=private +script=root/'tools/test_terrain_parity.py' +source=script.read_text() +old='["cargo","build","--release","-p","horizon-world","--example","terrain_fixture"]' +assert source.count(old)==1 +source=source.replace(old,'["cargo","build","--profile","fast","-p","horizon-world","--example","terrain_fixture"]') +assert source.count('/"release/examples"/')==1 +source=source.replace('/"release/examples"/','/"fast/examples"/') +namespace={'__file__':str(script),'__name__':'horizon_terrain_fast_validation'} +exec(compile(source,str(script),'exec'),namespace) +namespace['main']() +report=json.loads((private/'rust-terrain-parity/report.json').read_text()) +report['harness_adjustments']={'profile':'fast','storage':str(private),'runner_sha256':hashlib.sha256(pathlib.Path(__file__).read_bytes()).hexdigest(),'original_harness_sha256':hashlib.sha256(script.read_bytes()).hexdigest()} +(pathlib.Path(__file__).parent/'terrain-parity.json').write_text(json.dumps(report,indent=2)+'\n') diff --git a/noise-aquifer-results/workloads.json b/noise-aquifer-results/workloads.json new file mode 100644 index 000000000..a9c12e0a7 --- /dev/null +++ b/noise-aquifer-results/workloads.json @@ -0,0 +1,12 @@ +{ + "declared_before_candidate": true, + "baseline": "e4f8154cb4115aa1ee622381d9b12387cdf515d4", + "build_profile": "fast", + "primary_gate": {"dimension":"overworld", "seed":12345, "center":[0,0], "size":16, "threads":1}, + "qualification_matrix": {"dimensions":["overworld","the_nether","the_end"], "threads":[1,4], "seed":12345, "center":[0,0], "size":16}, + "cross_site_if_gate_passes": {"dimension":"overworld", "threads":[1,4], "seed":-1, "center":[32,-32], "size":16}, + "initialization":"discard offset 9x9 region center+(64,64) using same seeded generator before timing", + "measurement":"one discarded initialized process per executable per case, then five alternating baseline/candidate pairs; terrain+decoration normalized by 256 terrain chunks, 196 decorated interior chunks", + "cold":"separate one-worker overworld five alternating pairs without offset initialization if primary gate passes", + "early_stop":"stop after primary gate if no repeatable >=5% whole-terrain reduction" +} diff --git a/noise-aquifer-results/world-final-tests.log b/noise-aquifer-results/world-final-tests.log new file mode 100644 index 000000000..2f030d916 --- /dev/null +++ b/noise-aquifer-results/world-final-tests.log @@ -0,0 +1,137 @@ + Compiling horizon-core v0.1.0 (/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56/crates/horizon-core) + Compiling horizon-world v0.1.0 (/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56/crates/horizon-world) + Finished `fast` profile [optimized] target(s) in 31.04s + Running unittests src/lib.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/horizon_world-383ae1a2b1e80bbc) + +running 91 tests +test chunk::tests::invalid_palette_data_fails_before_access ... ok +test datafix::json::tests::java_floating_point_strings ... ok +test datafix::json::tests::numbers_become_the_smallest_tag ... ok +test datafix::json::tests::lenient_reads_what_strict_refuses ... ok +test datafix::json::tests::stable_strings_sort_keys ... ok +test datafix::tests::current_data_is_left_alone ... ok +test datafix::tests::block_states_take_their_new_field_names ... ok +test datafix::text::tests::click_events_take_their_new_fields ... ok +test datafix::tests::level_data_of_1_20_moves_to_the_new_fields ... ok +test datafix::text::tests::legacy_hover_events_become_text ... ok +test level::data::cache::tests::cache_invalidates_sources_and_recovers_from_corruption ... ok +test level::data::cache::tests::resolved_snapshot_roundtrips_all_fields ... ok +test compression::tests::checksums_reject_corruption ... ok +test level::growth_tests::azalea_and_mangrove_grow ... ok +test level::growth_tests::crops_age_with_bone_meal ... ok +test level::growth_tests::eyeblossoms_open_at_night_and_wake_neighbours ... ok +test level::growth_tests::grass_bone_meal_places_grass_and_flowers ... ok +test level::growth_tests::huge_mushroom_and_fungus_grow ... ok +test level::growth_tests::lone_dark_oak_sapling_cannot_grow ... ok +test level::growth_tests::oak_sapling_grows_with_bone_meal ... ok +test level::growth_tests::random_ticks_advance_sapling_stage_then_grow ... ok +test level::growth_tests::single_saplings_grow ... ok +test level::growth_tests::sniffer_eggs_crack_twice_then_hatch_a_snifflet ... ok +test level::growth_tests::snowy_biomes_freeze_and_snow ... ok +test level::growth_tests::tall_flowers_and_seagrass ... ok +test level::growth_tests::turtle_eggs_crack_at_dawn_on_sand ... ok +test level::growth_tests::two_by_two_saplings_grow ... ok +test level::tests::bucket_source_removal_drains_spread_water ... ok +test level::tests::calibrated_sensor_is_active_for_ten_ticks ... ok +test datafix::tests::item_stacks_of_1_20_take_components ... ok +test level::tests::catalyst_bloom_lasts_eight_ticks ... ok +test level::tests::creaking_heart_follows_its_logs_and_the_night ... ok +test level::tests::crops_grow_and_leaves_decay ... ok +test level::tests::dispenser_buckets_pick_up_and_empty ... ok +test level::tests::doors_beds_and_plants_place_both_halves ... ok +test level::tests::dripstone_fills_cauldrons ... ok +test level::tests::fences_connect_and_disconnect ... ok +test level::tests::lava_meets_water ... ok +test level::tests::levers_power_wire_through_interaction ... ok +test level::tests::mining_lights_redstone_ore_until_its_random_tick ... ok +test level::tests::pistons_pop_fragile_blocks_and_refuse_obsidian ... ok +test level::tests::pistons_push_and_sticky_pistons_pull ... ok +test level::tests::placement_merges_slabs_and_stacks ... ok +test level::tests::placement_orients_blocks ... ok +test level::tests::placing_and_breaking_report_the_affected_state ... ok +test level::tests::player_breaks_fire_with_extinguish_not_generic_break_event ... ok +test level::tests::redstone_lever_wire_and_lamp ... ok +test level::tests::repeater_delays_and_torch_inverts ... ok +test level::tests::sand_falls_and_concrete_solidifies ... ok +test level::tests::sculk_charge_spreads_veins_and_sculk ... ok +test level::tests::sculk_sensor_phases_and_signal ... ok +test level::tests::shrieker_responds_when_the_shriek_ends ... ok +test level::tests::snowy_grass_and_chests_pair ... ok +test level::tests::stairs_form_corners ... ok +test level::tests::state_table_matches_registry ... ok +test level::tests::torch_and_door_halves_break_with_support ... ok +test level::tests::walls_and_panes_connect ... ok +test level::tests::water_falls_and_makes_sources ... ok +test level::tests::water_spreads_on_a_floor ... ok +test level::tests::waterlogged_blocks_schedule_water ... ok +test nbt::tests::duplicate_keys_last_wins_and_nan_output_is_canonical ... ok +test nbt::tests::modified_utf_and_mixed_lists_preserve_java_values ... ok +test nbt::tests::malformed_lengths_truncation_limits_and_utf_are_rejected ... ok +test nbt::tests::snbt_parses_typed_values ... ok +test nbt::tests::wire_node_budget_includes_mixed_list_wrappers ... ok +test nbt::tests::depth_boundary_and_every_truncated_prefix ... ok +test worldgen::aquifer::config::tests::bindings_share_named_cache_and_failed_decode_is_atomic ... ok +test worldgen::density::tests::codec_validation_rejects_invalid_gradients_intervals_and_splines ... ok +test worldgen::density::tests::forward_references_share_named_holders_and_reject_cycles_or_missing_values ... ok +test worldgen::density::tests::numeric_tokens_keep_negative_zero_and_avoid_double_rounding ... ok +test worldgen::end_spike::tests::spike_layout_is_a_permutation_of_sizes ... ok +test worldgen::decoration_order::tests::decorated_chunks_keep_their_place ... ok +test worldgen::generator::tests::ring_positions_are_shared_by_seed_and_dimension ... ok +test worldgen::generator::tests::parameter_reports_quantize_like_vanilla ... ok +test worldgen::long_set::tests::every_key_is_visited_once_after_growth ... ok +test worldgen::decoration_order::tests::blocked_by_lower_ranks_within_two ... ok +test worldgen::long_set::tests::single_and_zero_keys ... ok +test worldgen::spawn_finder::tests::the_closest_fitting_column_wins ... ok +test worldgen::material_condition::codec::tests::forward_references_are_stable_and_invalid_graphs_fail_atomically ... ok +test worldgen::tests::decimal_integers_wrap_without_floating_point_conversion ... ok +test worldgen::material_condition::library::tests::forward_rule_holders_and_invalid_graphs_are_atomic ... ok +test worldgen::tests::codec_defaults_and_empty_modifiers_match_explicit_parameters ... ok +test worldgen::router::tests::roots_share_holder_cache_and_failed_router_leaves_graph_unchanged ... ok +test worldgen::tags::tests::required_edges_precede_optional_edges_and_missing_tags_do_not_poison_siblings ... ok +test worldgen::tags::tests::invalid_replacement_keeps_entries_and_codec_error_can_create_empty_tag ... ok +test worldgen::tree_blocks::tests::fisher_yates_matches_native_draw_order ... ok +test worldgen::tree_blocks::tests::pos_set_iterates_in_java_hash_bucket_order ... ok +test worldgen::decoration_order::tests::first_wave_matches_vanilla ... ok +test compression::tests::all_codecs_roundtrip_and_enforce_limits ... ok +test chunk::tests::palette_grows_across_word_widths_and_compacts_to_uniform ... ok +test worldgen::generator_structures::tests::ring_work_shared_between_threads_matches_serial_search ... ok + +test result: ok. 91 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.03s + + Running tests/biome_region.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/biome_region-2a454048d1e169a1) + +running 1 test +test resident_biomes_track_replacement_fills_and_reject_ambiguous_chunks ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/carving_stage.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/carving_stage-57246acdef3b0341) + +running 1 test +test filters_and_uncarvable_blocks_precede_aquifers_and_failures_keep_surface_restoration ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/material_stage.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/material_stage-7e3fca6c83435cb1) + +running 2 tests +test top_material_retains_context_on_failure_and_ignores_possible_biome_shortcuts ... ok +test density_context_survives_success_binding_failure_and_partial_chunk_failure ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/retrogen_biomes.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/retrogen_biomes-4141ee3648931f67) + +running 2 tests +test candidates_precede_old_columns_and_errors_short_circuit ... ok +test upgrade_fill_preserves_columns_and_section_atomicity ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/tick_data.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/tick_data-34687dfe40490ea0) + +running 2 tests +test numeric_codec_narrowing_and_malformed_data ... ok +test saved_chunk_ticks_filter_coordinates_and_write_atomically ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s From eb3789038e3184c98a1459fe638947200217d360 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Sun, 18 Oct 2026 02:28:17 +0100 Subject: [PATCH 04/28] Record repository PR self-check --- docs/noise-aquifer-benchmark.md | 2 +- noise-aquifer-results/pr-ready.md | 17 +++++++++++++++++ 2 files changed, 18 insertions(+), 1 deletion(-) create mode 100644 noise-aquifer-results/pr-ready.md diff --git a/docs/noise-aquifer-benchmark.md b/docs/noise-aquifer-benchmark.md index 080a0bcc5..5124d2778 100644 --- a/docs/noise-aquifer-benchmark.md +++ b/docs/noise-aquifer-benchmark.md @@ -48,7 +48,7 @@ An initial variant additionally forced the shared scalar helper inline. Its excl - Fresh scoped terrain-fill parity matches **7,950,873 lines on each Java side**: 114 fixtures, 200 fills, 61 noise-aquifer fixtures and 24 structure-density fixtures. This covers actual noise fill, prefilled sections, partial vertical volumes, repeated fills, both seeded factories, bundled routers/aquifers, raw section states, WG heightmaps and ordered postprocessing. The repository harness was changed only in memory to use `fast` build/profile paths and isolated private output storage; the adaptation script and its hashes are saved. - Full baseline/candidate chunk differential: 12 cases (three dimensions × two seeds/sites × one/four workers), each with 81 terrain chunks and 49 interior decorations. All 81 retained chunks, including borders, are compared both after terrain and after decoration: **24/24 exact byte comparisons pass**, covering 1,317,207,694 bytes per revision. Snapshots include raw and public block reads, section palettes/storage, all quart biomes, block entities and entities (binary NBT preserving numeric bits and order), complete saved block/fluid ticks including delay/priority, all six heightmaps with presence/raw words, ordered postprocessing and actual non-air counts. Chunk status, decoration flag, retrogen metadata and structure identities/bounds are included. - Snapshot builds use the same temporary read-only accessor for actual non-air counts on both revisions. It is removed from production source. The final production-only benchmark rebuild has byte-identical `.text` and `.rodata` to the measured candidate; the twelve changed read-only relocation-data words are source-location line numbers decreasing by four after removing the accessor. Binary/codegen hashes are saved. -- `git diff --check` passes. +- `git diff --check` passes. The repository PR self-check (`pr_ready.py --quick`) also passes: public-tree validation, 236 Python tests, workspace rustfmt, workspace/all-target clippy with warnings denied, and 94 full core-crate tests. Java parity was run separately as detailed above. The self-check size warning counts generated raw measurement/validation artifacts; the production/test Rust diff is 227 changed lines in two files. See `noise-aquifer-results/pr-ready.md`. Validation is scoped to these workloads and corpora, not every seed, biome or future compiler. Whole-chunk parity is a complete comparison of the listed generated fields against the baseline; it is not a claim that every untested generation behavior matches Java. Full-chunk Java gameplay, lighting, meshing, saving and streaming were not benchmarked. No required affected metadata was omitted from the baseline/candidate differential. diff --git a/noise-aquifer-results/pr-ready.md b/noise-aquifer-results/pr-ready.md new file mode 100644 index 000000000..686fa9470 --- /dev/null +++ b/noise-aquifer-results/pr-ready.md @@ -0,0 +1,17 @@ +**pr_ready** (`tools/pr_ready.py --quick` on archlinux, against origin/main at e4f8154cb, 54 s) + +| Check | Result | +| --- | --- | +| Scope | ⚠️ 39 files, +9538 −6; 9450 lines of code: over 500, split it if it can ship in parts | +| Cargo.lock | ✅ unchanged | +| Public tree | ✅ | +| Python tests | ✅ 236 passed (18 s) | +| rustfmt | ✅ (5 s) | +| clippy | ✅ (29 s) | +| tests: horizon-core | ✅ 94 passed (1 s) | +| tokens.css up to date | ➖ theme untouched | +| launcher rustfmt | ➖ launcher untouched | +| launcher clippy | ➖ launcher untouched | +| launcher tests | ➖ launcher untouched | +| Parity | ➖ not run (--quick): CI's parity job picks the affected harnesses | +| Label | player-facing: `feature` if players get something new, no label for a fix (`release-now` if urgent) | From 594b50278044df6b72b641cd02d5050925c86203 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Sun, 18 Oct 2026 03:10:26 +0100 Subject: [PATCH 05/28] Remove generated noise benchmark artifacts from PR --- docs/noise-aquifer-benchmark.md | 79 +- noise-aquifer-results/.gitignore | 5 - noise-aquifer-results/bench.py | 40 - noise-aquifer-results/binary-hashes.txt | 2 - noise-aquifer-results/binary-size.txt | 3 - noise-aquifer-results/build_snapshots.py | 22 - noise-aquifer-results/candidate.patch | 264 - noise-aquifer-results/chunk-parity.json | 458 -- noise-aquifer-results/chunkgen_profile.rs | 478 -- noise-aquifer-results/chunkgen_snapshot.rs | 532 --- noise-aquifer-results/core-final-tests.log | 105 - noise-aquifer-results/density-parity.json | 40 - noise-aquifer-results/environment.json | 14 - .../final-codegen-check.json | 21 - noise-aquifer-results/gate-raw.json | 530 --- noise-aquifer-results/gate-summary.json | 42 - .../initial-shared-inline/binary-hashes.txt | 2 - .../initial-shared-inline/candidate.patch | 73 - .../initial-shared-inline/gate-raw.json | 530 --- .../initial-shared-inline/gate-summary.json | 42 - noise-aquifer-results/loop-codegen.json | 30 - noise-aquifer-results/matrix-raw.json | 4226 ----------------- noise-aquifer-results/matrix-summary.json | 322 -- .../parity-binary-hashes.txt | 3 - noise-aquifer-results/pr-ready.md | 17 - noise-aquifer-results/reference-assessment.md | 14 - noise-aquifer-results/snapshot-accessor.patch | 15 - noise-aquifer-results/summarize.py | 38 - noise-aquifer-results/summary.json | 691 --- noise-aquifer-results/summary.txt | 9 - noise-aquifer-results/symbols.json | 25 - noise-aquifer-results/terrain-parity.json | 424 -- noise-aquifer-results/validate_chunks.py | 28 - noise-aquifer-results/validate_density.py | 33 - noise-aquifer-results/validate_terrain.py | 27 - noise-aquifer-results/workloads.json | 12 - noise-aquifer-results/world-final-tests.log | 137 - 37 files changed, 6 insertions(+), 9327 deletions(-) delete mode 100644 noise-aquifer-results/.gitignore delete mode 100644 noise-aquifer-results/bench.py delete mode 100644 noise-aquifer-results/binary-hashes.txt delete mode 100644 noise-aquifer-results/binary-size.txt delete mode 100644 noise-aquifer-results/build_snapshots.py delete mode 100644 noise-aquifer-results/candidate.patch delete mode 100644 noise-aquifer-results/chunk-parity.json delete mode 100644 noise-aquifer-results/chunkgen_profile.rs delete mode 100644 noise-aquifer-results/chunkgen_snapshot.rs delete mode 100644 noise-aquifer-results/core-final-tests.log delete mode 100644 noise-aquifer-results/density-parity.json delete mode 100644 noise-aquifer-results/environment.json delete mode 100644 noise-aquifer-results/final-codegen-check.json delete mode 100644 noise-aquifer-results/gate-raw.json delete mode 100644 noise-aquifer-results/gate-summary.json delete mode 100644 noise-aquifer-results/initial-shared-inline/binary-hashes.txt delete mode 100644 noise-aquifer-results/initial-shared-inline/candidate.patch delete mode 100644 noise-aquifer-results/initial-shared-inline/gate-raw.json delete mode 100644 noise-aquifer-results/initial-shared-inline/gate-summary.json delete mode 100644 noise-aquifer-results/loop-codegen.json delete mode 100644 noise-aquifer-results/matrix-raw.json delete mode 100644 noise-aquifer-results/matrix-summary.json delete mode 100644 noise-aquifer-results/parity-binary-hashes.txt delete mode 100644 noise-aquifer-results/pr-ready.md delete mode 100644 noise-aquifer-results/reference-assessment.md delete mode 100644 noise-aquifer-results/snapshot-accessor.patch delete mode 100644 noise-aquifer-results/summarize.py delete mode 100644 noise-aquifer-results/summary.json delete mode 100644 noise-aquifer-results/summary.txt delete mode 100644 noise-aquifer-results/symbols.json delete mode 100644 noise-aquifer-results/terrain-parity.json delete mode 100644 noise-aquifer-results/validate_chunks.py delete mode 100644 noise-aquifer-results/validate_density.py delete mode 100644 noise-aquifer-results/validate_terrain.py delete mode 100644 noise-aquifer-results/workloads.json delete mode 100644 noise-aquifer-results/world-final-tests.log diff --git a/docs/noise-aquifer-benchmark.md b/docs/noise-aquifer-benchmark.md index 5124d2778..a9634c743 100644 --- a/docs/noise-aquifer-benchmark.md +++ b/docs/noise-aquifer-benchmark.md @@ -1,80 +1,13 @@ # Bulk unary density evaluation benchmark -**Qualification: yes for the representative initialized Overworld workloads.** One focused bulk density arithmetic change reduces whole-terrain wall time by 13.891% with one worker and 11.191% with four workers at the primary site. A predeclared second seed/site improves 13.657% and 13.701%. These are whole-region terrain elapsed / input chunk count, not stage-only or microbenchmark results. Terrain plus decoration also exceeds 5% at both Overworld sites and worker counts. Nether/End results are smaller and are reported below. +Dispatching unary operations once per bulk buffer reduced initialized Overworld terrain generation from 12.271 to 10.566 ms/input chunk (13.89%) with one worker and from 3.838 to 3.408 (11.19%) with four. Terrain plus decoration improved 11.70% and 9.48%. A second seed/site improved terrain 13.66% and 13.70%. These are incremental results against baseline `e4f8154cb4115aa1ee622381d9b12387cdf515d4`. -Baseline: `e4f8154cb4115aa1ee622381d9b12387cdf515d4`. Candidate: that baseline plus `noise-aquifer-results/candidate.patch` (the scoped production change and its tests). Branch `t3/optimize-noise-aquifers`, isolated checkout `/home/bob/.t3/worktrees/horizon/t3-e477fa56` (physical `/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56`). No other checkout was changed. +Each case used one discarded pair and five measured alternating baseline/candidate pairs. The primary case used seed 12345, center (0,0), 256 terrain chunks and 196 decorated interior chunks. An offset 9×9 generation pass initialized the seeded generator without pre-generating target chunks. The second site used seed -1 at (32,-32). Timing is complete terrain wall time divided by input count; combined results retain border work. Cold initialization was measured separately. -## Focus and feasibility +Nether terrain medians improved 3.15% / 2.03% with one/four workers; End improved 3.03% / 5.39%. Some individual Nether/End pairs regressed or had large favorable outliers. Gains are workload-dependent and should not be generalized to every seed, biome, compiler, or platform. Peak RSS was effectively unchanged and no new heap buffer was introduced. -The existing initialized profile attributed 18.09% terrain self CPU to unary density arithmetic. Inspection found an operation match and function call for each buffer element. The candidate dispatches once per bulk buffer, allowing fixed-operation loops and compiler vectorization. Scalar arithmetic retains its existing dispatch; all arithmetic expressions have one shared definition. Non-finite constant operands retain the original per-element path because specialization can select a different NaN operand payload. Sampling calls, child-failure propagation, complete buffer-tail transformation, floating-point expressions and buffer allocation remain the same. +Measured on AMD Ryzen 5 5600X, 32 GiB RAM, Linux, Rust 1.99.0, optimized `fast` profile (release optimization, LTO off, 16 codegen units). Builds and measurements ran sequentially; background desktop activity was not isolated. The benchmark used the existing chunkgen benchmark with identical optional initialization and exact elapsed-time instrumentation on both revisions. `crates/horizon-world/examples/chunkgen_bench.rs` provides the standard workload entry point; its human-readable thread-multiplied ms/chunk display must not be mistaken for elapsed/count. -The requested reference was inspected on its oldest and newest supported source branches. Its direct palette write still maintains section counters and resolves/grows the palette. Horizon already bypasses several generic costs, while exact old-state/count and partial-write behavior still matters. A validated palette-token writer and dense palette construction were assessed as materially different designs; neither was rejected merely because an earlier small hash change failed. The profile provided a stronger focused opportunity in unary arithmetic, so no storage rewrite was attempted. See [reference mechanism and applicability](../noise-aquifer-results/reference-assessment.md) for pinned source links and details. +Validation passed: 191 targeted Rust tests; fresh pinned Java client/server density parity (15,524,627 lines each); terrain-fill parity (114 fixtures, 200 fills, 7,950,873 lines per Java side); and 24 exact terrain/decorated region comparisons across three dimensions, two seeds/sites, and one/four workers. Snapshots included block states and palettes, quart biomes, entities/block entities, scheduled ticks, all six heightmaps, ordered postprocessing, non-air counts, and chunk metadata. This establishes parity within the declared corpus, not complete gameplay parity. -This shared density kernel also accelerates bulk material-density preparation. At the primary one-worker site the noise bracket improves 5.772879 → 5.229395 ms/chunk (9.414%), while surface improves 4.467371 → 3.314584 (25.805%). The 13.891% whole-terrain result must not be described as a noise-only stage improvement. No surface rules, traversal, decoration, structures, scheduling or caches were edited. - -## Declared method - -Workloads were fixed in `noise-aquifer-results/workloads.json` before candidate editing: 16×16 terrain chunks (256), 14×14 decorated interior (196), seed 12345 / center (0,0), all three dimensions at one and four workers. The second Overworld site uses seed -1 / center (32,-32), also at one and four workers. Each initialized process first generates and discards the same offset 9×9 region at center+(64,64), using the same seeded generator, before timing starts; measured workers are newly created. This excludes initial ring work without pre-generating measured chunks. Initialization timings remain in the logs/summary. - -Each case has one discarded process pair, then five measured pairs alternating baseline/candidate order. Processes, builds and benchmarks were sequential. The cold one-worker Overworld case omits initialization and is reported separately. Wall timing is the diagnostic’s exact elapsed / 256 JSON field, never the thread-multiplied human display. Combined timing is (terrain elapsed + complete existing phased decoration elapsed) / 256, retaining identical border and stage work. Decoration duration comes from the unchanged diagnostic’s printed duration, with its original rounding. - -Machine: AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM, Linux 7.2.11-zen1-1-zen, Rust 1.99.0. `fast` inherits release with LTO disabled, 16 codegen units and incremental compilation; no extra Rust flags were set. Prepared 26.3 resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Reused Cargo target `/srv/bob-data/horizon-stage3d-target`, preserving its `fast` symlink to `/tmp/horizon-density-eval/fast-build`. Both baseline and candidate were freshly built and copied to private versioned executables. Desktop/background activity was not isolated. - -## All measured medians - -Values are baseline → candidate, ms per input terrain chunk; parentheses are percent reduction. Negative individual-pair reductions mean regressions. - -- **overworld, 1 worker(s), seed 12345, center (0, 0), initialized:** terrain 12.270935 → 10.566346 (13.891%); combined 14.202495 → 12.541112 (11.698%). Paired terrain range 12.218% to 15.467%; candidate slower in 0/5 pairs. -- **overworld, 4 worker(s), seed 12345, center (0, 0), initialized:** terrain 3.837939 → 3.408437 (11.191%); combined 4.405165 → 3.987592 (9.479%). Paired terrain range 7.647% to 13.352%; candidate slower in 0/5 pairs. -- **the_nether, 1 worker(s), seed 12345, center (0, 0), initialized:** terrain 5.000868 → 4.843412 (3.149%); combined 5.381649 → 5.215208 (3.093%). Paired terrain range -3.917% to 6.809%; candidate slower in 2/5 pairs. -- **the_nether, 4 worker(s), seed 12345, center (0, 0), initialized:** terrain 1.395740 → 1.367372 (2.033%); combined 1.497615 → 1.473427 (1.615%). Paired terrain range 0.323% to 17.443%; candidate slower in 0/5 pairs. -- **the_end, 1 worker(s), seed 12345, center (0, 0), initialized:** terrain 1.087874 → 1.054903 (3.031%); combined 1.161584 → 1.128076 (2.885%). Paired terrain range -0.144% to 14.336%; candidate slower in 1/5 pairs. -- **the_end, 4 worker(s), seed 12345, center (0, 0), initialized:** terrain 0.275263 → 0.260434 (5.387%); combined 0.302814 → 0.288325 (4.785%). Paired terrain range 4.468% to 6.365%; candidate slower in 0/5 pairs. -- **overworld, 1 worker(s), seed -1, center (32, -32), initialized:** terrain 11.333986 → 9.786101 (13.657%); combined 12.356760 → 10.854422 (12.158%). Paired terrain range 7.854% to 14.172%; candidate slower in 0/5 pairs. -- **overworld, 4 worker(s), seed -1, center (32, -32), initialized:** terrain 3.058178 → 2.639180 (13.701%); combined 3.357631 → 2.938479 (12.484%). Paired terrain range 10.767% to 14.651%; candidate slower in 0/5 pairs. -- **overworld, 1 worker(s), seed 12345, center (0, 0), cold:** terrain 23.049481 → 21.473030 (6.839%); combined 24.984204 → 23.443390 (6.167%). Paired terrain range 6.458% to 7.944%; candidate slower in 0/5 pairs. - -Nether one-worker repeats 1 and 3 regress 0.555% and 3.917%; End one-worker repeat 1 regresses 0.144%. Nether four-worker and End one-worker have large favorable outliers (paired improvements up to 17.443% and 14.336%), so their small median gains should not be generalized. All Overworld initialized pairs exceed 5%; the smallest is 7.647% at the primary four-worker site. No case was removed or selected after seeing timings. Cold results include startup and are not used to establish the recurring improvement. - -Primary terrain process CPU medians: 12.1 → 10.5 ms/input chunk at one worker, 15.2 → 13.5 at four workers. This existing `/proc` accounting has 100 Hz quantization and a rounded display. Aggregate stage worker elapsed is not an exclusive CPU share. Primary peak process RSS: 786588 → 786608 KiB (one worker), 834016 → 833440 KiB (four workers), effectively unchanged. All workload CPU/RSS medians are in `summary.json`; process CPU additionally includes initialization/other phases where explicitly named. No new heap buffer is introduced. Executable `.text` grows 2860 bytes, 5164975 → 5167835 bytes. Compiler output shows packed float instructions in the specialized bulk method; the original bulk method had none. - -An initial variant additionally forced the shared scalar helper inline. Its excluded five-pair primary result was 12.240292 → 10.644734 ms/chunk (13.035%). This broader variant was not used for qualification; the narrowed bulk-only candidate independently reproduced the benefit. The early hypothesis that scalar inlining explained the surface gain was disproved by the narrowed result and inspection of material-density bulk preparation. Initial raw data/patch/hashes are retained under `noise-aquifer-results/initial-shared-inline/`. - -## Correctness - -- 191 final optimized unit/integration tests pass: 86 core library, 91 world library, 6 context/world-field integration tests, and 8 integration tests covering material stages, carving, ticks, retrogen biomes and biome regions. Storage/palette randomized editing, packing, invalid-write atomicity, density caches/errors and interpolation tests are included. -- New bit-exact tests cover every unary operation, signed zeros, subnormals, infinities, NaN payloads, 4096 deterministic random float patterns, multiple buffer lengths and varied constants. A new child-error test verifies partial input writes survive without applying the operation and verifies complete oversized-buffer tails on success. An initial non-finite-operand NaN payload failure was fixed by retaining original dispatch for those constants; the strict assertion was retained. -- Fresh candidate and Java client/server density runs each match **15,524,627 output lines**. The existing input corpus was authenticated against its recorded checksum and unchanged corpus/oracle source; both Java sides were freshly compiled/run against independently checksum-verified pinned JARs. -- Fresh scoped terrain-fill parity matches **7,950,873 lines on each Java side**: 114 fixtures, 200 fills, 61 noise-aquifer fixtures and 24 structure-density fixtures. This covers actual noise fill, prefilled sections, partial vertical volumes, repeated fills, both seeded factories, bundled routers/aquifers, raw section states, WG heightmaps and ordered postprocessing. The repository harness was changed only in memory to use `fast` build/profile paths and isolated private output storage; the adaptation script and its hashes are saved. -- Full baseline/candidate chunk differential: 12 cases (three dimensions × two seeds/sites × one/four workers), each with 81 terrain chunks and 49 interior decorations. All 81 retained chunks, including borders, are compared both after terrain and after decoration: **24/24 exact byte comparisons pass**, covering 1,317,207,694 bytes per revision. Snapshots include raw and public block reads, section palettes/storage, all quart biomes, block entities and entities (binary NBT preserving numeric bits and order), complete saved block/fluid ticks including delay/priority, all six heightmaps with presence/raw words, ordered postprocessing and actual non-air counts. Chunk status, decoration flag, retrogen metadata and structure identities/bounds are included. -- Snapshot builds use the same temporary read-only accessor for actual non-air counts on both revisions. It is removed from production source. The final production-only benchmark rebuild has byte-identical `.text` and `.rodata` to the measured candidate; the twelve changed read-only relocation-data words are source-location line numbers decreasing by four after removing the accessor. Binary/codegen hashes are saved. -- `git diff --check` passes. The repository PR self-check (`pr_ready.py --quick`) also passes: public-tree validation, 236 Python tests, workspace rustfmt, workspace/all-target clippy with warnings denied, and 94 full core-crate tests. Java parity was run separately as detailed above. The self-check size warning counts generated raw measurement/validation artifacts; the production/test Rust diff is 227 changed lines in two files. See `noise-aquifer-results/pr-ready.md`. - -Validation is scoped to these workloads and corpora, not every seed, biome or future compiler. Whole-chunk parity is a complete comparison of the listed generated fields against the baseline; it is not a claim that every untested generation behavior matches Java. Full-chunk Java gameplay, lighting, meshing, saving and streaming were not benchmarked. No required affected metadata was omitted from the baseline/candidate differential. - -## Evidence and reproduction - -Public evidence is under `noise-aquifer-results/`: `workloads.json`, `environment.json`, `binary-hashes.txt`, `parity-binary-hashes.txt`, `final-codegen-check.json`, `gate-raw.json`, `matrix-raw.json`, `summary.json`, `density-parity.json`, `terrain-parity.json`, `chunk-parity.json`, test logs, diagnostic sources and runners. Raw measurements include discarded warmups, exact commands and every measured pair; summaries exclude only the declared warmups. Private executables, density outputs and full chunk snapshots are under `/srv/bob-data/horizon-noise-aquifer-e477fa56/`; noise-fill fixture data is ignored under `noise-aquifer-results/private-parity/`. No private fixtures, chunk dumps, game resources or Java binaries are committed. - -For fresh baseline/candidate performance builds in this isolated checkout, use the saved `chunkgen_profile.rs` as `crates/horizon-world/examples/chunkgen_profile.rs`, build each source variant with the command below, and copy its executable to the matching `baseline` or `candidate` path expected by `bench.py`. Baseline is the pinned commit; the candidate patch is saved independently. The measured candidate also had the unused diagnostic accessor available; it emits no benchmark code. Remove copied example/accessor support afterward. - -```sh -CARGO_TARGET_DIR=/srv/bob-data/horizon-stage3d-target cargo build --profile fast -p horizon-world --example chunkgen_profile -python3 noise-aquifer-results/bench.py gate -python3 noise-aquifer-results/bench.py matrix -python3 noise-aquifer-results/summarize.py -``` - -For differential snapshots, copy `chunkgen_snapshot.rs` into the examples directory and apply `snapshot-accessor.patch`, then run `python3 noise-aquifer-results/build_snapshots.py` (it saves/restores the candidate arithmetic source and builds both variants). Run `validate_chunks.py`, then remove the temporary accessor and copied examples. The density runner expects a fast `horizon-density-parity` binary copied to the private executable directory; `build_snapshots.py` also produces it. Run `validate_density.py`. Run the scoped terrain oracle with `CARGO_TARGET_DIR=/srv/bob-data/horizon-stage3d-target python3 noise-aquifer-results/validate_terrain.py`; its fixtures stay in ignored private storage. The paths are intentionally explicit and can be adjusted together on another machine. - -Final unit/integration commands: - -```sh -CARGO_TARGET_DIR=/srv/bob-data/horizon-stage3d-target cargo test --profile fast -p horizon-core --lib --test density_world_fields -CARGO_TARGET_DIR=/srv/bob-data/horizon-stage3d-target cargo test --profile fast -p horizon-world --lib --test material_stage --test carving_stage --test tick_data --test retrogen_biomes --test biome_region -git diff --check -``` - -## Advice for the surface task - -Reprofile with this change present before evaluating a separate surface optimization. Shared bulk density preparation already accounts for about 1.15 ms/chunk of the primary surface-bracket saving; do not count it again as a later task’s improvement. Compiled rule evaluation and remaining column traversal are unchanged. No task in another area was started. +The repository quick PR check also passed public-tree validation, Python tests, formatting, clippy, and core tests. Generated timing files, diagnostic runners, patches, and validation logs are retained locally outside the repository and are not part of this PR. diff --git a/noise-aquifer-results/.gitignore b/noise-aquifer-results/.gitignore deleted file mode 100644 index b32d8cc68..000000000 --- a/noise-aquifer-results/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -/private-parity/ -/__pycache__/ -*.log -!core-final-tests.log -!world-final-tests.log diff --git a/noise-aquifer-results/bench.py b/noise-aquifer-results/bench.py deleted file mode 100644 index ac2288e01..000000000 --- a/noise-aquifer-results/bench.py +++ /dev/null @@ -1,40 +0,0 @@ -import subprocess,os,json,pathlib,re,statistics,sys -root=pathlib.Path(__file__).resolve().parent -bins=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56') -resources='/srv/bob-data/horizon/.local/horizon-client/26.3' -phase=sys.argv[1] if len(sys.argv)>1 else 'gate' -cases=[('overworld',1,12345,0,0,True)] if phase=='gate' else [(d,t,12345,0,0,True) for d in ['overworld','the_nether','the_end'] for t in [1,4] if (d,t)!=('overworld',1)]+[('overworld',t,-1,32,-32,True) for t in [1,4]]+[('overworld',1,12345,0,0,False)] -rows=[] -for dim,threads,seed,cx,cz,warm in cases: - for repeat in range(-1,5): - order=['baseline','candidate'] if repeat%2==0 else ['candidate','baseline'] - for version in order: - name=f'{dim}-t{threads}-s{seed}-c{cx}_{cz}-w{int(warm)}-r{repeat}-{version}' - cmd=[sys.executable,'-c',"import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)",str(bins/version),resources,'--seed',str(seed),'--size','16','--threads',str(threads),'--dimension',dim,'--center',str(cx),str(cz)] - env=dict(os.environ) - env.pop('HORIZON_PROFILE_SIGNAL',None);env.pop('HORIZON_PROFILE_WARM',None) - if warm:env['HORIZON_PROFILE_WARM']='1' - r=subprocess.run(cmd,text=True,capture_output=True,env=env,check=True) - (root/(name+'.log')).write_text(r.stdout+r.stderr) - row=json.loads(next(x.split(' ',1)[1] for x in r.stdout.splitlines() if x.startswith('PROFILE_STAGES '))) - m=re.search(r'decorated (\d+) chunks in ([0-9.]+)(ms|s)',r.stdout) - deco=float(m[2])*(1 if m[3]=='ms' else 1000) - # Parent diagnostic prints rounded decoration duration, retain this precision limit. - row.update(version=version,repeat=repeat,dimension=dim,seed=seed,center=[cx,cz],warm=warm,cmd=cmd,decorated=int(m[1]),decoration_ms=deco,combined_ms_chunk=row['wall_ms_chunk']+deco/row['chunks']) - cpu=re.search(r'cpu time ([0-9.]+) ms/chunk',r.stdout) - resource=re.search(r'RESOURCE ([0-9.]+) ([0-9.]+) (\d+)',r.stderr) - row.update(terrain_cpu_ms_chunk=float(cpu[1]),process_user_s=float(resource[1]),process_system_s=float(resource[2]),peak_rss_kib=int(resource[3])) - rows.append(row) - (root/(phase+'-raw.json')).write_text(json.dumps(rows,indent=2)+'\n') - print(name,round(row['wall_ms_chunk'],6),flush=True) -summary=[] -for case in cases: - dim,threads,seed,cx,cz,warm=case - rs=[r for r in rows if (r['dimension'],r['threads'],r['seed'],*r['center'],r['warm'])==case and r['repeat']>=0] - out=dict(dimension=dim,threads=threads,seed=seed,center=[cx,cz],warm=warm) - for metric in ['wall_ms_chunk','combined_ms_chunk','noise','surface','terrain_cpu_ms_chunk','peak_rss_kib']: - med={v:statistics.median(r[metric] for r in rs if r['version']==v) for v in ['baseline','candidate']} - out[metric]={**med,'reduction_percent':100*(med['baseline']-med['candidate'])/med['baseline']} - summary.append(out) -(root/(phase+'-summary.json')).write_text(json.dumps(summary,indent=2)+'\n') -print(json.dumps(summary,indent=2)) diff --git a/noise-aquifer-results/binary-hashes.txt b/noise-aquifer-results/binary-hashes.txt deleted file mode 100644 index 778f9e2bc..000000000 --- a/noise-aquifer-results/binary-hashes.txt +++ /dev/null @@ -1,2 +0,0 @@ -65d134def1e54944b105cf13e28945eea717f75aabf5dfd827f70645b22abc3c /srv/bob-data/horizon-noise-aquifer-e477fa56/baseline -198f60a68b2616aa394861c517297d4a14cc0949e3b56600905b6f86c05e59b8 /srv/bob-data/horizon-noise-aquifer-e477fa56/candidate diff --git a/noise-aquifer-results/binary-size.txt b/noise-aquifer-results/binary-size.txt deleted file mode 100644 index 268cb840a..000000000 --- a/noise-aquifer-results/binary-size.txt +++ /dev/null @@ -1,3 +0,0 @@ - text data bss dec hex filename -5164975 130720 3344 5299039 50db5f /srv/bob-data/horizon-noise-aquifer-e477fa56/baseline -5167835 130640 576 5299051 50db6b /srv/bob-data/horizon-noise-aquifer-e477fa56/candidate diff --git a/noise-aquifer-results/build_snapshots.py b/noise-aquifer-results/build_snapshots.py deleted file mode 100644 index 3d3bd0d33..000000000 --- a/noise-aquifer-results/build_snapshots.py +++ /dev/null @@ -1,22 +0,0 @@ -"""Build diagnostic snapshots for both revisions, restoring candidate sources on exit.""" -import os,pathlib,subprocess,shutil -root=pathlib.Path(__file__).resolve().parents[1] -results=pathlib.Path(__file__).parent -work=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56') -target=pathlib.Path('/srv/bob-data/horizon-stage3d-target') -env=dict(os.environ,CARGO_TARGET_DIR=str(target)) -arithmetic=root/'crates/horizon-core/src/density/arithmetic.rs' -candidate=arithmetic.read_bytes() -(work/'candidate-arithmetic.rs').write_bytes(candidate) -def build(args,log): - with (results/log).open('w') as f:subprocess.run(['cargo','build','--profile','fast',*args],cwd=root,env=env,stdout=f,stderr=subprocess.STDOUT,check=True) -try: - build(['-p','horizon-world','--example','chunkgen_snapshot'],'snapshot-candidate-build.log') - shutil.copy2(target/'fast/examples/chunkgen_snapshot',work/'snapshot-candidate') - build(['-p','horizon-core','--bin','horizon-density-parity'],'density-build.log') - shutil.copy2(target/'fast/horizon-density-parity',work/'horizon-density-parity') - arithmetic.write_bytes(subprocess.check_output(['git','show','e4f8154cb4115aa1ee622381d9b12387cdf515d4:crates/horizon-core/src/density/arithmetic.rs'],cwd=root)) - build(['-p','horizon-world','--example','chunkgen_snapshot'],'snapshot-baseline-build.log') - shutil.copy2(target/'fast/examples/chunkgen_snapshot',work/'snapshot-baseline') -finally: - arithmetic.write_bytes(candidate) diff --git a/noise-aquifer-results/candidate.patch b/noise-aquifer-results/candidate.patch deleted file mode 100644 index 17a45e3aa..000000000 --- a/noise-aquifer-results/candidate.patch +++ /dev/null @@ -1,264 +0,0 @@ -diff --git a/crates/horizon-core/src/density/arithmetic.rs b/crates/horizon-core/src/density/arithmetic.rs -index f82b96ce..7961adf0 100644 ---- a/crates/horizon-core/src/density/arithmetic.rs -+++ b/crates/horizon-core/src/density/arithmetic.rs -@@ -75,9 +75,12 @@ pub enum UnaryOp { - max: f32, - }, - } --impl UnaryOp { -- pub(super) fn apply(self, value: f32, bulk: bool) -> f32 { -- match self { -+// One expression definition for scalar dispatch and specialized bulk loops. -+macro_rules! unary_apply { -+ ($operation:expr, $value:expr, $bulk:expr) => {{ -+ let value = $value; -+ let bulk = $bulk; -+ match $operation { - Self::Abs => value.abs(), - Self::Negate => -value, - Self::Square => value * value, -@@ -137,6 +140,85 @@ impl UnaryOp { - } - } - } -+ }}; -+} -+impl UnaryOp { -+ pub(super) fn apply(self, value: f32, bulk: bool) -> f32 { -+ unary_apply!(self, value, bulk) -+ } -+ /// Dispatch once per volume so each loop has one fixed arithmetic operation. -+ /// Keep the scalar expression shared, including the bulk min/max behavior. -+ fn apply_bulk(self, buffer: &mut [f32]) { -+ // Specialization can reverse which NaN operand supplies the payload. -+ // Retain the original dispatch for non-finite constant operands. -+ let non_finite = match self { -+ Self::PowerBase(value) | Self::PowerExponent(value) => !value.is_finite(), -+ Self::LeakyRelu(value) -+ | Self::Add(value) -+ | Self::SubtractFrom(value) -+ | Self::Multiply(value) -+ | Self::DivideInto(value) -+ | Self::Minimum(value) -+ | Self::Maximum(value) => !value.is_finite(), -+ Self::Clamp { min, max } => !min.is_finite() || !max.is_finite(), -+ Self::ConstantRangeChoice { -+ min_inclusive, -+ max_exclusive, -+ inside, -+ outside, -+ } => { -+ !min_inclusive.is_finite() -+ || !max_exclusive.is_finite() -+ || !inside.is_finite() -+ || !outside.is_finite() -+ } -+ _ => false, -+ }; -+ if non_finite { -+ for value in buffer { -+ *value = self.apply(*value, true); -+ } -+ return; -+ } -+ macro_rules! apply { -+ ($operation:expr) => { -+ for value in buffer { -+ *value = unary_apply!($operation, *value, true); -+ } -+ }; -+ } -+ match self { -+ Self::Abs => apply!(Self::Abs), -+ Self::Negate => apply!(Self::Negate), -+ Self::Square => apply!(Self::Square), -+ Self::Cube => apply!(Self::Cube), -+ Self::Sqrt => apply!(Self::Sqrt), -+ Self::Log => apply!(Self::Log), -+ Self::PowerBase(base) => apply!(Self::PowerBase(base)), -+ Self::PowerExponent(exponent) => apply!(Self::PowerExponent(exponent)), -+ Self::Reciprocal => apply!(Self::Reciprocal), -+ Self::Sign => apply!(Self::Sign), -+ Self::Squeeze => apply!(Self::Squeeze), -+ Self::LeakyRelu(factor) => apply!(Self::LeakyRelu(factor)), -+ Self::Add(right) => apply!(Self::Add(right)), -+ Self::SubtractFrom(left) => apply!(Self::SubtractFrom(left)), -+ Self::Multiply(right) => apply!(Self::Multiply(right)), -+ Self::DivideInto(left) => apply!(Self::DivideInto(left)), -+ Self::Minimum(right) => apply!(Self::Minimum(right)), -+ Self::Maximum(right) => apply!(Self::Maximum(right)), -+ Self::ConstantRangeChoice { -+ min_inclusive, -+ max_exclusive, -+ inside, -+ outside, -+ } => apply!(Self::ConstantRangeChoice { -+ min_inclusive, -+ max_exclusive, -+ inside, -+ outside -+ }), -+ Self::Clamp { min, max } => apply!(Self::Clamp { min, max }), -+ } - } - } - #[derive(Clone, Debug)] -@@ -162,9 +244,7 @@ impl DensitySampler for UnarySampler { - ) -> Result<(), SampleError> { - check_buffer(buffer, volume)?; - self.input.sample_volume(context, buffer, volume)?; -- for value in buffer { -- *value = self.operation.apply(*value, true); -- } -+ self.operation.apply_bulk(buffer); - Ok(()) - } - } -@@ -246,3 +326,98 @@ impl DensitySampler for BinarySampler { - }) - } - } -+ -+#[cfg(test)] -+mod bulk_tests { -+ use super::*; -+ -+ #[inline(never)] -+ fn dispatched_reference(operation: UnaryOp, value: f32) -> f32 { -+ operation.apply(value, true) -+ } -+ -+ #[test] -+ fn fixed_operation_loops_preserve_float_bits() { -+ let mut operations = vec![ -+ UnaryOp::Abs, -+ UnaryOp::Negate, -+ UnaryOp::Square, -+ UnaryOp::Cube, -+ UnaryOp::Sqrt, -+ UnaryOp::Log, -+ UnaryOp::Reciprocal, -+ UnaryOp::Sign, -+ UnaryOp::Squeeze, -+ ]; -+ for factor in [0.0, -0.0, 0.5, -1.0, f32::INFINITY, f32::NAN] { -+ operations.extend([ -+ UnaryOp::LeakyRelu(factor), -+ UnaryOp::Add(factor), -+ UnaryOp::SubtractFrom(factor), -+ UnaryOp::Multiply(factor), -+ UnaryOp::DivideInto(factor), -+ UnaryOp::Minimum(factor), -+ UnaryOp::Maximum(factor), -+ UnaryOp::Clamp { -+ min: -factor, -+ max: factor, -+ }, -+ UnaryOp::ConstantRangeChoice { -+ min_inclusive: -factor, -+ max_exclusive: factor, -+ inside: -0.0, -+ outside: 17.0, -+ }, -+ ]); -+ } -+ for exponent in [0.0, -0.0, 0.5, -1.0, 2.0, 3.0, f64::INFINITY, f64::NAN] { -+ operations.extend([ -+ UnaryOp::PowerBase(exponent), -+ UnaryOp::PowerExponent(exponent), -+ ]); -+ } -+ let mut values: Vec = [ -+ 0, -+ 0x8000_0000, -+ 1, -+ 0x8000_0001, -+ 0x007f_ffff, -+ 0x0080_0000, -+ 0x3f00_0000, -+ 0xbf00_0000, -+ 0x3f80_0000, -+ 0xbf80_0000, -+ 0x7f7f_ffff, -+ 0xff7f_ffff, -+ 0x7f80_0000, -+ 0xff80_0000, -+ 0x7fc0_0000, -+ 0x7fa0_0001, -+ 0xffc0_1234, -+ ] -+ .into_iter() -+ .map(f32::from_bits) -+ .collect(); -+ let mut bits = 0x484f_5249u32; -+ for _ in 0..4096 { -+ bits ^= bits << 13; -+ bits ^= bits >> 17; -+ bits ^= bits << 5; -+ values.push(f32::from_bits(bits)); -+ } -+ for operation in operations { -+ for length in [0, 1, 3, 16, 257, values.len()] { -+ let mut actual = values[..length].to_vec(); -+ operation.apply_bulk(&mut actual); -+ for (i, (&input, actual)) in values.iter().zip(actual).enumerate() { -+ let expected = dispatched_reference(operation, input); -+ assert_eq!( -+ actual.to_bits(), -+ expected.to_bits(), -+ "{operation:?}, index {i}, input {input:?}" -+ ); -+ } -+ } -+ } -+ } -+} -diff --git a/crates/horizon-core/src/density/tests.rs b/crates/horizon-core/src/density/tests.rs -index 77a64309..f94b9535 100644 ---- a/crates/horizon-core/src/density/tests.rs -+++ b/crates/horizon-core/src/density/tests.rs -@@ -755,3 +755,43 @@ fn spline_lazy_branch_failure_preserves_completed_output_and_returns_scratch() { - assert_eq!(context.scratch.len(), 2); - assert_eq!(sampler.sample_value(&mut context, [0; 3]), Ok(7.0)); - } -+ -+#[test] -+fn unary_bulk_keeps_child_failure_writes_and_full_buffer_tail() { -+ #[derive(Debug)] -+ struct PartialInput; -+ impl DensitySampler for PartialInput { -+ fn sample_value(&self, _: &mut SamplerContext, _: [i32; 3]) -> Result { -+ Err(SampleError::ZeroGradientPeriod) -+ } -+ fn sample_volume( -+ &self, -+ _: &mut SamplerContext, -+ buffer: &mut [f32], -+ _: DensityVolume, -+ ) -> Result<(), SampleError> { -+ buffer[0] = -3.0; -+ Err(SampleError::ZeroGradientPeriod) -+ } -+ } -+ let volume = DensityVolume::new([1; 3], [0; 3], [1; 3]).unwrap(); -+ let mut context = SamplerContext::default(); -+ let mut buffer = [17.0; 3]; -+ let sampler = UnarySampler { -+ input: Arc::new(PartialInput), -+ operation: UnaryOp::Square, -+ }; -+ assert_eq!( -+ sampler.sample_volume(&mut context, &mut buffer, volume), -+ Err(SampleError::ZeroGradientPeriod) -+ ); -+ assert_eq!(buffer, [-3.0, 17.0, 17.0]); -+ let sampler = UnarySampler { -+ input: Arc::new(ConstantSampler(-3.0)), -+ operation: UnaryOp::Square, -+ }; -+ sampler -+ .sample_volume(&mut context, &mut buffer, volume) -+ .unwrap(); -+ assert_eq!(buffer, [9.0; 3]); -+} diff --git a/noise-aquifer-results/chunk-parity.json b/noise-aquifer-results/chunk-parity.json deleted file mode 100644 index 4fdbfdbeb..000000000 --- a/noise-aquifer-results/chunk-parity.json +++ /dev/null @@ -1,458 +0,0 @@ -[ - { - "dimension": "overworld", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s12345-c0_0-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s12345-c0_0-candidate-terrain.bin", - "baseline_bytes": 70871678, - "candidate_bytes": 70871678, - "equal": true, - "baseline_sha256": "2ad69a09980586e9bd293e58cffa02212bbc30a1a21a83cb85bb289b6cd85aa8", - "candidate_sha256": "2ad69a09980586e9bd293e58cffa02212bbc30a1a21a83cb85bb289b6cd85aa8" - }, - { - "dimension": "overworld", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s12345-c0_0-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s12345-c0_0-candidate-decorated.bin", - "baseline_bytes": 72477690, - "candidate_bytes": 72477690, - "equal": true, - "baseline_sha256": "68c21c8c5ff5d227ff715c186c95278eb44169821b9295e35b550f0c3a4941ae", - "candidate_sha256": "68c21c8c5ff5d227ff715c186c95278eb44169821b9295e35b550f0c3a4941ae" - }, - { - "dimension": "overworld", - "threads": 1, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s-1-c32_-32-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s-1-c32_-32-candidate-terrain.bin", - "baseline_bytes": 70926924, - "candidate_bytes": 70926924, - "equal": true, - "baseline_sha256": "7cea600cfb8151fa97adcf55a192dab1465487fd86db098d115c82b27de4ae75", - "candidate_sha256": "7cea600cfb8151fa97adcf55a192dab1465487fd86db098d115c82b27de4ae75" - }, - { - "dimension": "overworld", - "threads": 1, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s-1-c32_-32-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t1-s-1-c32_-32-candidate-decorated.bin", - "baseline_bytes": 71982927, - "candidate_bytes": 71982927, - "equal": true, - "baseline_sha256": "ed77837ac1031f3eee0a4646fdeb2b71f0d7a6671e5042a76e849ce6431b28e4", - "candidate_sha256": "ed77837ac1031f3eee0a4646fdeb2b71f0d7a6671e5042a76e849ce6431b28e4" - }, - { - "dimension": "overworld", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s12345-c0_0-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s12345-c0_0-candidate-terrain.bin", - "baseline_bytes": 70871678, - "candidate_bytes": 70871678, - "equal": true, - "baseline_sha256": "2ad69a09980586e9bd293e58cffa02212bbc30a1a21a83cb85bb289b6cd85aa8", - "candidate_sha256": "2ad69a09980586e9bd293e58cffa02212bbc30a1a21a83cb85bb289b6cd85aa8" - }, - { - "dimension": "overworld", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s12345-c0_0-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s12345-c0_0-candidate-decorated.bin", - "baseline_bytes": 72477690, - "candidate_bytes": 72477690, - "equal": true, - "baseline_sha256": "68c21c8c5ff5d227ff715c186c95278eb44169821b9295e35b550f0c3a4941ae", - "candidate_sha256": "68c21c8c5ff5d227ff715c186c95278eb44169821b9295e35b550f0c3a4941ae" - }, - { - "dimension": "overworld", - "threads": 4, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s-1-c32_-32-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s-1-c32_-32-candidate-terrain.bin", - "baseline_bytes": 70926924, - "candidate_bytes": 70926924, - "equal": true, - "baseline_sha256": "7cea600cfb8151fa97adcf55a192dab1465487fd86db098d115c82b27de4ae75", - "candidate_sha256": "7cea600cfb8151fa97adcf55a192dab1465487fd86db098d115c82b27de4ae75" - }, - { - "dimension": "overworld", - "threads": 4, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s-1-c32_-32-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-overworld-t4-s-1-c32_-32-candidate-decorated.bin", - "baseline_bytes": 71982927, - "candidate_bytes": 71982927, - "equal": true, - "baseline_sha256": "ed77837ac1031f3eee0a4646fdeb2b71f0d7a6671e5042a76e849ce6431b28e4", - "candidate_sha256": "ed77837ac1031f3eee0a4646fdeb2b71f0d7a6671e5042a76e849ce6431b28e4" - }, - { - "dimension": "the_nether", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s12345-c0_0-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s12345-c0_0-candidate-terrain.bin", - "baseline_bytes": 47625247, - "candidate_bytes": 47625247, - "equal": true, - "baseline_sha256": "a406f643b6acc121f7f0b48497c5ed2a479a9d64528bd210714ddd6666ce9c22", - "candidate_sha256": "a406f643b6acc121f7f0b48497c5ed2a479a9d64528bd210714ddd6666ce9c22" - }, - { - "dimension": "the_nether", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s12345-c0_0-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s12345-c0_0-candidate-decorated.bin", - "baseline_bytes": 48076401, - "candidate_bytes": 48076401, - "equal": true, - "baseline_sha256": "b754a8bc209b8b6587288692edcdc6e1c920d87d5bbb31b600c4f5fc16bee894", - "candidate_sha256": "b754a8bc209b8b6587288692edcdc6e1c920d87d5bbb31b600c4f5fc16bee894" - }, - { - "dimension": "the_nether", - "threads": 1, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s-1-c32_-32-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s-1-c32_-32-candidate-terrain.bin", - "baseline_bytes": 47483043, - "candidate_bytes": 47483043, - "equal": true, - "baseline_sha256": "70aa070734aeda158baf10746d92bc3d4c86bd2b77704223964ec0a54ee6e5f0", - "candidate_sha256": "70aa070734aeda158baf10746d92bc3d4c86bd2b77704223964ec0a54ee6e5f0" - }, - { - "dimension": "the_nether", - "threads": 1, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s-1-c32_-32-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t1-s-1-c32_-32-candidate-decorated.bin", - "baseline_bytes": 47748532, - "candidate_bytes": 47748532, - "equal": true, - "baseline_sha256": "e12f60fef0afb86cc8d1a357dac46938bf560c326cd1dc8f75b48b337b6ce6e3", - "candidate_sha256": "e12f60fef0afb86cc8d1a357dac46938bf560c326cd1dc8f75b48b337b6ce6e3" - }, - { - "dimension": "the_nether", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s12345-c0_0-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s12345-c0_0-candidate-terrain.bin", - "baseline_bytes": 47625247, - "candidate_bytes": 47625247, - "equal": true, - "baseline_sha256": "a406f643b6acc121f7f0b48497c5ed2a479a9d64528bd210714ddd6666ce9c22", - "candidate_sha256": "a406f643b6acc121f7f0b48497c5ed2a479a9d64528bd210714ddd6666ce9c22" - }, - { - "dimension": "the_nether", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s12345-c0_0-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s12345-c0_0-candidate-decorated.bin", - "baseline_bytes": 48076401, - "candidate_bytes": 48076401, - "equal": true, - "baseline_sha256": "b754a8bc209b8b6587288692edcdc6e1c920d87d5bbb31b600c4f5fc16bee894", - "candidate_sha256": "b754a8bc209b8b6587288692edcdc6e1c920d87d5bbb31b600c4f5fc16bee894" - }, - { - "dimension": "the_nether", - "threads": 4, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s-1-c32_-32-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s-1-c32_-32-candidate-terrain.bin", - "baseline_bytes": 47483043, - "candidate_bytes": 47483043, - "equal": true, - "baseline_sha256": "70aa070734aeda158baf10746d92bc3d4c86bd2b77704223964ec0a54ee6e5f0", - "candidate_sha256": "70aa070734aeda158baf10746d92bc3d4c86bd2b77704223964ec0a54ee6e5f0" - }, - { - "dimension": "the_nether", - "threads": 4, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s-1-c32_-32-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_nether-t4-s-1-c32_-32-candidate-decorated.bin", - "baseline_bytes": 47748532, - "candidate_bytes": 47748532, - "equal": true, - "baseline_sha256": "e12f60fef0afb86cc8d1a357dac46938bf560c326cd1dc8f75b48b337b6ce6e3", - "candidate_sha256": "e12f60fef0afb86cc8d1a357dac46938bf560c326cd1dc8f75b48b337b6ce6e3" - }, - { - "dimension": "the_end", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s12345-c0_0-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s12345-c0_0-candidate-terrain.bin", - "baseline_bytes": 45817706, - "candidate_bytes": 45817706, - "equal": true, - "baseline_sha256": "a9ff378aabcaa78e3fe83174759583e6b91dfdce287ef5b5770d73ffe490ed76", - "candidate_sha256": "a9ff378aabcaa78e3fe83174759583e6b91dfdce287ef5b5770d73ffe490ed76" - }, - { - "dimension": "the_end", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s12345-c0_0-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s12345-c0_0-candidate-decorated.bin", - "baseline_bytes": 45993605, - "candidate_bytes": 45993605, - "equal": true, - "baseline_sha256": "4253a573b8710684556955c3c6e0c3b4a6175156dd79da8da1635baf97890e2f", - "candidate_sha256": "4253a573b8710684556955c3c6e0c3b4a6175156dd79da8da1635baf97890e2f" - }, - { - "dimension": "the_end", - "threads": 1, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s-1-c32_-32-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s-1-c32_-32-candidate-terrain.bin", - "baseline_bytes": 44800047, - "candidate_bytes": 44800047, - "equal": true, - "baseline_sha256": "7626139e9b822d4439770629794ec658fb7b8238c51090541513aa518cabeee2", - "candidate_sha256": "7626139e9b822d4439770629794ec658fb7b8238c51090541513aa518cabeee2" - }, - { - "dimension": "the_end", - "threads": 1, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s-1-c32_-32-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t1-s-1-c32_-32-candidate-decorated.bin", - "baseline_bytes": 44800047, - "candidate_bytes": 44800047, - "equal": true, - "baseline_sha256": "747b4c3a207bdc115b264a0bf41e97231bb9311f57e5a7ae1e104a14359bbed0", - "candidate_sha256": "747b4c3a207bdc115b264a0bf41e97231bb9311f57e5a7ae1e104a14359bbed0" - }, - { - "dimension": "the_end", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s12345-c0_0-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s12345-c0_0-candidate-terrain.bin", - "baseline_bytes": 45817706, - "candidate_bytes": 45817706, - "equal": true, - "baseline_sha256": "a9ff378aabcaa78e3fe83174759583e6b91dfdce287ef5b5770d73ffe490ed76", - "candidate_sha256": "a9ff378aabcaa78e3fe83174759583e6b91dfdce287ef5b5770d73ffe490ed76" - }, - { - "dimension": "the_end", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s12345-c0_0-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s12345-c0_0-candidate-decorated.bin", - "baseline_bytes": 45993605, - "candidate_bytes": 45993605, - "equal": true, - "baseline_sha256": "4253a573b8710684556955c3c6e0c3b4a6175156dd79da8da1635baf97890e2f", - "candidate_sha256": "4253a573b8710684556955c3c6e0c3b4a6175156dd79da8da1635baf97890e2f" - }, - { - "dimension": "the_end", - "threads": 4, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "terrain", - "terrain_chunks": 81, - "decorated_chunks": 0, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s-1-c32_-32-baseline-terrain.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s-1-c32_-32-candidate-terrain.bin", - "baseline_bytes": 44800047, - "candidate_bytes": 44800047, - "equal": true, - "baseline_sha256": "7626139e9b822d4439770629794ec658fb7b8238c51090541513aa518cabeee2", - "candidate_sha256": "7626139e9b822d4439770629794ec658fb7b8238c51090541513aa518cabeee2" - }, - { - "dimension": "the_end", - "threads": 4, - "seed": -1, - "center": [ - 32, - -32 - ], - "phase": "decorated", - "terrain_chunks": 81, - "decorated_chunks": 49, - "baseline_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s-1-c32_-32-baseline-decorated.bin", - "candidate_path": "/srv/bob-data/horizon-noise-aquifer-e477fa56/snap-the_end-t4-s-1-c32_-32-candidate-decorated.bin", - "baseline_bytes": 44800047, - "candidate_bytes": 44800047, - "equal": true, - "baseline_sha256": "747b4c3a207bdc115b264a0bf41e97231bb9311f57e5a7ae1e104a14359bbed0", - "candidate_sha256": "747b4c3a207bdc115b264a0bf41e97231bb9311f57e5a7ae1e104a14359bbed0" - } -] diff --git a/noise-aquifer-results/chunkgen_profile.rs b/noise-aquifer-results/chunkgen_profile.rs deleted file mode 100644 index eaeab5f99..000000000 --- a/noise-aquifer-results/chunkgen_profile.rs +++ /dev/null @@ -1,478 +0,0 @@ -//! Chunk generation throughput and sanity map. -//! -//! chunkgen_bench [--seed S] [--size N] [--threads T] -//! [--center CX CZ] [--verify ] [--no-decorate] -//! [--dimension overworld|the_nether|the_end] -use horizon_core::position::ChunkPos; -use horizon_world::{ - DATA_VERSION, - heightmap::HeightmapType, - nbt::Tag, - registry::BlockRegistry, - worldgen::generator::{ - DecorateStats, GeneratorData, GeneratorWorker, OverworldGenerator, ProtoChunk, StageTimings, - }, -}; -use serde_json::Value; -use std::{ - collections::BTreeMap, - fs, - io::{BufRead, BufReader}, - path::{Path, PathBuf}, - sync::{ - Mutex, - atomic::{AtomicUsize, Ordering}, - }, - time::Instant, -}; - -type Error = Box; - -fn tag(v: &Value) -> Tag { - match v { - Value::String(s) => Tag::String(s.as_str().into()), - Value::Number(n) => Tag::Int(n.as_i64().unwrap() as i32), - Value::Array(a) => Tag::List(a.iter().map(tag).collect()), - Value::Object(o) => { - Tag::Compound(o.iter().map(|(k, v)| (k.as_str().into(), tag(v))).collect()) - } - _ => panic!("invalid registry metadata"), - } -} -fn registry(resources: &Path) -> Result<&'static BlockRegistry, Error> { - let facts: Value = serde_json::from_str(&fs::read_to_string(resources.join("facts.json"))?)?; - let registry = BlockRegistry::from_nbt(&Tag::compound([ - ("DataVersion", Tag::Int(DATA_VERSION)), - ( - "states", - Tag::List( - facts["states"] - .as_array() - .unwrap() - .iter() - .map(|v| tag(&v[4])) - .collect(), - ), - ), - ("defaults", tag(&facts["defaults"])), - ]))?; - Ok(Box::leak(Box::new(registry))) -} - -/// The material-stage fixture's chunk dump format. -fn dump(chunk: &ProtoChunk) -> Vec { - let terrain = &chunk.terrain; - let mut out = Vec::new(); - for section in 0..terrain.height() as usize / 16 { - out.push(format!("section {section}")); - let data = terrain.section(section).unwrap(); - for y in 0..16 { - for z in 0..16 { - let mut line = String::from("blocks"); - for x in 0..16 { - line += &format!(" {}", data.get((y << 8) | (z << 4) | x).unwrap().0); - } - out.push(line); - } - } - } - for kind in [HeightmapType::WorldSurfaceWg, HeightmapType::OceanFloorWg] { - out.push(format!("heightmap {}", kind.name())); - for word in terrain.heightmap(kind).unwrap().raw_data() { - out.push(format!("{word:x}")); - } - } - for (section, offsets) in terrain.postprocessing().iter().enumerate() { - out.push(format!("post {section} {}", offsets.len())); - out.extend(offsets.iter().map(u16::to_string)); - } - out -} - -/// Compare generated chunks with vanilla's post-carver dumps in server.txt. -fn verify(data: &std::sync::Arc, parity: &Path) -> Result<(), Error> { - let cases = [ - (-1i64, -2, 3), - (0x0123_4567_89ab_cdef, 1_875_000, -1_875_000), - ]; - let mut expected = Vec::new(); - for (seed, x, z) in cases { - let generator = OverworldGenerator::without_structures(data.clone(), seed)?; - let lines = dump(&generator.worker().generate_proto(ChunkPos::new(x, z))?); - if let Ok(path) = std::env::var("HORIZON_VERIFY_DUMP") { - fs::write(format!("{path}{seed}.txt"), lines.join("\n") + "\n")?; - } - expected.push((seed, lines)); - } - let mut matched = vec![false; expected.len()]; - let mut lines = BufReader::new(fs::File::open(parity.join("server.txt"))?).lines(); - let mut candidates = 0; - while let Some(line) = lines.next() { - if line? != "generatedcarving ok" { - continue; - } - candidates += 1; - // Each candidate dump is followed by other output; compare per case. - let mut active = (0..expected.len()).collect::>(); - let length = expected.iter().map(|(_, e)| e.len()).max().unwrap_or(0); - for i in 0..length { - let Some(line) = lines.next() else { break }; - let line = line?; - active.retain(|&c| { - let expected = &expected[c].1; - if i == expected.len() { - matched[c] = true; - } - i < expected.len() && expected[i] == line - }); - if active.is_empty() { - break; - } - } - for c in active { - matched[c] = true; - } - } - for ((seed, _), ok) in expected.iter().zip(&matched) { - println!( - "verify seed {seed}: {}", - if *ok { "MATCH" } else { "MISMATCH" } - ); - } - println!("({candidates} vanilla generated-terrain dumps scanned)"); - if matched.iter().all(|m| *m) { - Ok(()) - } else { - Err("generated chunks differ from vanilla".into()) - } -} - -/// Structure starts in the oracle's line format (VanillaStructureStartOracle). -fn dump_starts( - generator: &OverworldGenerator, - seed: i64, - [x0, z0, x1, z1]: [i32; 4], - out: &Path, -) -> Result<(), Error> { - use horizon_world::worldgen::structure::{Rotation, start::Piece}; - let _ = seed; - let mut worker = generator.worker(); - let mut lines = Vec::new(); - let start = Instant::now(); - for cx in x0..=x1 { - for cz in z0..=z1 { - for s in worker.structure_starts(ChunkPos::new(cx, cz)) { - let b = s.bounding_box; - lines.push(format!( - "start {cx} {cz} {} {} {} {} {} {} {} {}", - s.name, - b.min[0], - b.min[1], - b.min[2], - b.max[0], - b.max[1], - b.max[2], - s.pieces.len() - )); - for piece in &s.pieces { - let Piece::Pool(p) = piece else { - let b = piece.bounding_box(); - lines.push(format!( - "piece {} {} {} {} {} {} {}", - piece.type_name(), - b.min[0], - b.min[1], - b.min[2], - b.max[0], - b.max[1], - b.max[2] - )); - continue; - }; - let b = p.bounding_box; - let rotation = match p.rotation { - Rotation::None => "NONE", - Rotation::Clockwise90 => "CLOCKWISE_90", - Rotation::Clockwise180 => "CLOCKWISE_180", - Rotation::Counterclockwise90 => "COUNTERCLOCKWISE_90", - }; - lines.push(format!( - "piece minecraft:jigsaw {} {} {} {} {} {} {} {} {} {rotation} {} {}", - b.min[0], - b.min[1], - b.min[2], - b.max[0], - b.max[1], - b.max[2], - p.position[0], - p.position[1], - p.position[2], - p.ground_level_delta, - p.junctions.len() - )); - } - } - } - } - println!( - "structure starts for {} chunks in {:.2?}", - (x1 - x0 + 1) * (z1 - z0 + 1), - start.elapsed() - ); - fs::write(out, lines.join("\n") + "\n")?; - Ok(()) -} - -/// Process CPU seconds (Linux), robust against other load on shared machines. -fn cpu_seconds() -> f64 { - fs::read_to_string("/proc/self/stat") - .ok() - .and_then(|stat| { - let fields = stat - .rsplit_once(')')? - .1 - .split_whitespace() - .collect::>(); - Some((fields[11].parse::().ok()? + fields[12].parse::().ok()?) / 100.) - }) - .unwrap_or(0.) -} -fn glyph(name: &str) -> char { - let name = name.strip_prefix("minecraft:").unwrap_or(name); - match name { - "water" => '~', - "lava" => '!', - "dirt_path" => '_', - "cobblestone" | "mossy_cobblestone" => 'o', - "hay_block" => 'h', - _ if name.ends_with("planks") || name.ends_with("stairs") || name.ends_with("slab") => 'P', - _ if name.contains("glass") => 'g', - "grass_block" => '"', - "sand" | "suspicious_sand" => '.', - "red_sand" => ',', - "sandstone" | "red_sandstone" => '=', - "stone" | "deepslate" | "andesite" | "diorite" | "granite" | "tuff" => '#', - "gravel" => ':', - "dirt" | "coarse_dirt" | "rooted_dirt" => 'd', - "podzol" => 'p', - "mycelium" => 'm', - "mud" => 'u', - "snow" | "snow_block" | "powder_snow" => 's', - "ice" | "packed_ice" | "blue_ice" => 'i', - "clay" => 'c', - "calcite" => 'C', - _ if name.ends_with("terracotta") => 't', - _ if name.ends_with("leaves") => '*', - _ if name.ends_with("log") || name.ends_with("wood") => '|', - _ if name.contains("grass") || name.contains("fern") || name.contains("flower") => '\'', - _ => '?', - } -} - -fn main() -> Result<(), Error> { - let profile_boot = Instant::now(); - let mut args = std::env::args().skip(1); - let resources = PathBuf::from(args.next().expect("client resource directory")); - let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0)); - let mut parity = None; - let mut decorate = true; - let mut dimension = String::from("minecraft:overworld"); - let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None; - while let Some(arg) = args.next() { - let mut next = || args.next().expect("argument value"); - match arg.as_str() { - "--seed" => seed = next().parse()?, - "--size" => size = next().parse()?, - "--threads" => threads = next().parse()?, - "--center" => center = (next().parse()?, next().parse()?), - "--verify" => parity = Some(PathBuf::from(next())), - "--no-decorate" => decorate = false, - "--dimension" => { - let d = next(); - dimension = if d.contains(':') { - d - } else { - format!("minecraft:{d}") - }; - } - "--starts" => { - starts = Some(( - next().parse()?, - next().parse()?, - next().parse()?, - next().parse()?, - PathBuf::from(next()), - )) - } - _ => return Err(format!("unknown argument {arg}").into()), - } - } - let start = Instant::now(); - let registry = registry(&resources)?; - let data = GeneratorData::load(&resources.join("worldgen"), registry)?; - println!("loaded resources in {:.2?}", start.elapsed()); - if let Some(parity) = parity { - verify(&data, &parity)?; - } - let start = Instant::now(); - let generator = - OverworldGenerator::for_dimension(data.clone(), seed, "minecraft:normal", &dimension)?; - if std::env::var_os("HORIZON_LIST_UNSUPPORTED").is_some() { - for (feature, error) in generator.unsupported_features() { - println!("unsupported {feature}: {error}"); - } - } - println!("seeded generator in {:.2?}", start.elapsed()); - if let Some((x0, z0, x1, z1, out)) = starts { - dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?; - return Ok(()); - } - if std::env::var_os("HORIZON_PROFILE_WARM").is_some() { - let start = Instant::now(); - let mut warm = generator.worker(); - for z in 0..9 { for x in 0..9 { - let _ = warm.generate_proto(ChunkPos::new(center.0 + 64 + x, center.1 + 64 + z))?; - }} - println!("warmup_ms {:.6}", start.elapsed().as_secs_f64() * 1000.0); - } - println!("PROFILE_MEASURE_START {:.9}", profile_boot.elapsed().as_secs_f64()); - let (x0, z0) = (center.0 - size / 2, center.1 - size / 2); - let count = (size * size) as usize; - let next = AtomicUsize::new(0); - let slots: Vec>> = (0..count).map(|_| Mutex::new(None)).collect(); - let timings = Mutex::new(Vec::new()); - let cpu = cpu_seconds(); - let start = Instant::now(); - std::thread::scope(|scope| -> Result<(), Error> { - let handles = (0..threads) - .map(|_| { - scope.spawn(|| -> Result<(), Error> { - let mut worker = generator.worker(); - loop { - let i = next.fetch_add(1, Ordering::Relaxed); - if i >= count { - timings.lock().unwrap().push(worker.stage_timings()); - return Ok(()); - } - let pos = ChunkPos::new(x0 + (i as i32 % size), z0 + (i as i32 / size)); - *slots[i].lock().unwrap() = Some(worker.generate_proto(pos)?); - } - }) - }) - .collect::>(); - handles.into_iter().try_for_each(|h| h.join().unwrap()) - })?; - let elapsed = start.elapsed(); - println!("PROFILE_TERRAIN_END {:.9}", profile_boot.elapsed().as_secs_f64()); - println!( - "generated {count} proto chunks with {threads} threads in {elapsed:.2?}: {:.1} chunks/s ({:.1} ms/chunk/thread)", - count as f64 / elapsed.as_secs_f64(), - elapsed.as_secs_f64() * 1000. * threads as f64 / count as f64 - ); - println!( - " cpu time {:.1} ms/chunk", - (cpu_seconds() - cpu) * 1000. / count as f64 - ); - println!("PROFILE_WALL_MS_CHUNK {:.6}", elapsed.as_secs_f64() * 1000.0 / count as f64); - let timings = timings.into_inner().unwrap(); - let per_chunk = |f: fn(&StageTimings) -> std::time::Duration| { - timings - .iter() - .map(f) - .sum::() - .as_secs_f64() - * 1000. - / count as f64 - }; - println!("PROFILE_STAGES {}", serde_json::json!({ - "chunks": count, "threads": threads, - "biomes": per_chunk(|t| t.biomes), "structures": per_chunk(|t| t.structures), - "noise": per_chunk(|t| t.noise), "surface": per_chunk(|t| t.surface), - "carvers": per_chunk(|t| t.carvers), - "wall_ms_chunk": elapsed.as_secs_f64() * 1000.0 / count as f64, - })); - let mut chunks: Vec> = slots - .into_iter() - .map(|slot| slot.into_inner().unwrap()) - .collect(); - if decorate && size >= 3 { - let totals = Mutex::new(DecorateStats::default()); - let start = Instant::now(); - let mut decorated = 0; - // Disjoint 3×3 regions per phase can be decorated concurrently. - for phase in 0..9 { - let mut regions = Vec::new(); - for z in 1..size - 1 { - for x in 1..size - 1 { - if (x % 3) * 3 + z % 3 != phase { - continue; - } - let mut region = Vec::with_capacity(9); - for dz in -1..=1 { - for dx in -1..=1 { - region - .push(chunks[((z + dz) * size + x + dx) as usize].take().unwrap()); - } - } - regions.push(((x, z), region)); - } - } - decorated += regions.len(); - let queue = Mutex::new(regions); - let done = Mutex::new(Vec::new()); - std::thread::scope(|scope| -> Result<(), Error> { - let handles = (0..threads) - .map(|_| { - scope.spawn(|| -> Result<(), Error> { - let mut worker: GeneratorWorker = generator.worker(); - loop { - let Some((at, region)) = queue.lock().unwrap().pop() else { - return Ok(()); - }; - let mut region: [ProtoChunk; 9] = - region.try_into().map_err(|_| "region size")?; - let stats = worker.decorate(&mut region)?; - let mut totals = totals.lock().unwrap(); - totals.placed += stats.placed; - totals.unsupported += stats.unsupported; - totals.failed += stats.failed; - totals.skipped.extend(stats.skipped); - drop(totals); - done.lock().unwrap().push((at, region)); - } - }) - }) - .collect::>(); - handles.into_iter().try_for_each(|h| h.join().unwrap()) - })?; - for ((x, z), region) in done.into_inner().unwrap() { - for (i, chunk) in region.into_iter().enumerate() { - let (dx, dz) = (i as i32 % 3 - 1, i as i32 / 3 - 1); - chunks[((z + dz) * size + x + dx) as usize] = Some(chunk); - } - } - } - let elapsed = start.elapsed(); - let totals = totals.into_inner().unwrap(); - println!( - "decorated {decorated} chunks in {elapsed:.2?}: {:.1} chunks/s; feature roots placed {}, unsupported {}, failed {}", - decorated as f64 / elapsed.as_secs_f64(), - totals.placed, - totals.unsupported, - totals.failed - ); - if std::env::var_os("HORIZON_FEATURE_ERRORS").is_some() { - for (name, error) in generator.unsupported_features() { - println!("unsupported {name}: {error}"); - } - } - if !totals.skipped.is_empty() { - println!( - "skipped roots: {}", - totals.skipped.into_iter().collect::>().join(" ") - ); - } - } - println!("PROFILE_MEASURE_END {:.9}", profile_boot.elapsed().as_secs_f64()); - Ok(()) -} diff --git a/noise-aquifer-results/chunkgen_snapshot.rs b/noise-aquifer-results/chunkgen_snapshot.rs deleted file mode 100644 index 4411fc972..000000000 --- a/noise-aquifer-results/chunkgen_snapshot.rs +++ /dev/null @@ -1,532 +0,0 @@ -//! Chunk generation throughput and sanity map. -//! -//! chunkgen_bench [--seed S] [--size N] [--threads T] -//! [--center CX CZ] [--verify ] [--no-decorate] -//! [--dimension overworld|the_nether|the_end] -use horizon_core::position::ChunkPos; -use horizon_world::{ - DATA_VERSION, - heightmap::HeightmapType, - nbt::Tag, - registry::BlockRegistry, - worldgen::generator::{ - DecorateStats, GeneratorData, GeneratorWorker, OverworldGenerator, ProtoChunk, StageTimings, - }, -}; -use serde_json::Value; -use std::{ - collections::BTreeMap, - fs, - io::{BufRead, BufReader}, - path::{Path, PathBuf}, - sync::{ - Mutex, - atomic::{AtomicUsize, Ordering}, - }, - time::Instant, -}; - -type Error = Box; - -fn tag(v: &Value) -> Tag { - match v { - Value::String(s) => Tag::String(s.as_str().into()), - Value::Number(n) => Tag::Int(n.as_i64().unwrap() as i32), - Value::Array(a) => Tag::List(a.iter().map(tag).collect()), - Value::Object(o) => { - Tag::Compound(o.iter().map(|(k, v)| (k.as_str().into(), tag(v))).collect()) - } - _ => panic!("invalid registry metadata"), - } -} -fn registry(resources: &Path) -> Result<&'static BlockRegistry, Error> { - let facts: Value = serde_json::from_str(&fs::read_to_string(resources.join("facts.json"))?)?; - let registry = BlockRegistry::from_nbt(&Tag::compound([ - ("DataVersion", Tag::Int(DATA_VERSION)), - ( - "states", - Tag::List( - facts["states"] - .as_array() - .unwrap() - .iter() - .map(|v| tag(&v[4])) - .collect(), - ), - ), - ("defaults", tag(&facts["defaults"])), - ]))?; - Ok(Box::leak(Box::new(registry))) -} - -/// The material-stage fixture's chunk dump format. -fn dump(chunk: &ProtoChunk) -> Vec { - let terrain = &chunk.terrain; - let mut out = Vec::new(); - for section in 0..terrain.height() as usize / 16 { - out.push(format!("section {section}")); - let data = terrain.section(section).unwrap(); - for y in 0..16 { - for z in 0..16 { - let mut line = String::from("blocks"); - for x in 0..16 { - line += &format!(" {}", data.get((y << 8) | (z << 4) | x).unwrap().0); - } - out.push(line); - } - } - } - for kind in [HeightmapType::WorldSurfaceWg, HeightmapType::OceanFloorWg] { - out.push(format!("heightmap {}", kind.name())); - for word in terrain.heightmap(kind).unwrap().raw_data() { - out.push(format!("{word:x}")); - } - } - for (section, offsets) in terrain.postprocessing().iter().enumerate() { - out.push(format!("post {section} {}", offsets.len())); - out.extend(offsets.iter().map(u16::to_string)); - } - out -} - -/// Compare generated chunks with vanilla's post-carver dumps in server.txt. -fn verify(data: &std::sync::Arc, parity: &Path) -> Result<(), Error> { - let cases = [ - (-1i64, -2, 3), - (0x0123_4567_89ab_cdef, 1_875_000, -1_875_000), - ]; - let mut expected = Vec::new(); - for (seed, x, z) in cases { - let generator = OverworldGenerator::without_structures(data.clone(), seed)?; - let lines = dump(&generator.worker().generate_proto(ChunkPos::new(x, z))?); - if let Ok(path) = std::env::var("HORIZON_VERIFY_DUMP") { - fs::write(format!("{path}{seed}.txt"), lines.join("\n") + "\n")?; - } - expected.push((seed, lines)); - } - let mut matched = vec![false; expected.len()]; - let mut lines = BufReader::new(fs::File::open(parity.join("server.txt"))?).lines(); - let mut candidates = 0; - while let Some(line) = lines.next() { - if line? != "generatedcarving ok" { - continue; - } - candidates += 1; - // Each candidate dump is followed by other output; compare per case. - let mut active = (0..expected.len()).collect::>(); - let length = expected.iter().map(|(_, e)| e.len()).max().unwrap_or(0); - for i in 0..length { - let Some(line) = lines.next() else { break }; - let line = line?; - active.retain(|&c| { - let expected = &expected[c].1; - if i == expected.len() { - matched[c] = true; - } - i < expected.len() && expected[i] == line - }); - if active.is_empty() { - break; - } - } - for c in active { - matched[c] = true; - } - } - for ((seed, _), ok) in expected.iter().zip(&matched) { - println!( - "verify seed {seed}: {}", - if *ok { "MATCH" } else { "MISMATCH" } - ); - } - println!("({candidates} vanilla generated-terrain dumps scanned)"); - if matched.iter().all(|m| *m) { - Ok(()) - } else { - Err("generated chunks differ from vanilla".into()) - } -} - -/// Structure starts in the oracle's line format (VanillaStructureStartOracle). -fn dump_starts( - generator: &OverworldGenerator, - seed: i64, - [x0, z0, x1, z1]: [i32; 4], - out: &Path, -) -> Result<(), Error> { - use horizon_world::worldgen::structure::{Rotation, start::Piece}; - let _ = seed; - let mut worker = generator.worker(); - let mut lines = Vec::new(); - let start = Instant::now(); - for cx in x0..=x1 { - for cz in z0..=z1 { - for s in worker.structure_starts(ChunkPos::new(cx, cz)) { - let b = s.bounding_box; - lines.push(format!( - "start {cx} {cz} {} {} {} {} {} {} {} {}", - s.name, - b.min[0], - b.min[1], - b.min[2], - b.max[0], - b.max[1], - b.max[2], - s.pieces.len() - )); - for piece in &s.pieces { - let Piece::Pool(p) = piece else { - let b = piece.bounding_box(); - lines.push(format!( - "piece {} {} {} {} {} {} {}", - piece.type_name(), - b.min[0], - b.min[1], - b.min[2], - b.max[0], - b.max[1], - b.max[2] - )); - continue; - }; - let b = p.bounding_box; - let rotation = match p.rotation { - Rotation::None => "NONE", - Rotation::Clockwise90 => "CLOCKWISE_90", - Rotation::Clockwise180 => "CLOCKWISE_180", - Rotation::Counterclockwise90 => "COUNTERCLOCKWISE_90", - }; - lines.push(format!( - "piece minecraft:jigsaw {} {} {} {} {} {} {} {} {} {rotation} {} {}", - b.min[0], - b.min[1], - b.min[2], - b.max[0], - b.max[1], - b.max[2], - p.position[0], - p.position[1], - p.position[2], - p.ground_level_delta, - p.junctions.len() - )); - } - } - } - } - println!( - "structure starts for {} chunks in {:.2?}", - (x1 - x0 + 1) * (z1 - z0 + 1), - start.elapsed() - ); - fs::write(out, lines.join("\n") + "\n")?; - Ok(()) -} - -/// Process CPU seconds (Linux), robust against other load on shared machines. -fn cpu_seconds() -> f64 { - fs::read_to_string("/proc/self/stat") - .ok() - .and_then(|stat| { - let fields = stat - .rsplit_once(')')? - .1 - .split_whitespace() - .collect::>(); - Some((fields[11].parse::().ok()? + fields[12].parse::().ok()?) / 100.) - }) - .unwrap_or(0.) -} -fn glyph(name: &str) -> char { - let name = name.strip_prefix("minecraft:").unwrap_or(name); - match name { - "water" => '~', - "lava" => '!', - "dirt_path" => '_', - "cobblestone" | "mossy_cobblestone" => 'o', - "hay_block" => 'h', - _ if name.ends_with("planks") || name.ends_with("stairs") || name.ends_with("slab") => 'P', - _ if name.contains("glass") => 'g', - "grass_block" => '"', - "sand" | "suspicious_sand" => '.', - "red_sand" => ',', - "sandstone" | "red_sandstone" => '=', - "stone" | "deepslate" | "andesite" | "diorite" | "granite" | "tuff" => '#', - "gravel" => ':', - "dirt" | "coarse_dirt" | "rooted_dirt" => 'd', - "podzol" => 'p', - "mycelium" => 'm', - "mud" => 'u', - "snow" | "snow_block" | "powder_snow" => 's', - "ice" | "packed_ice" | "blue_ice" => 'i', - "clay" => 'c', - "calcite" => 'C', - _ if name.ends_with("terracotta") => 't', - _ if name.ends_with("leaves") => '*', - _ if name.ends_with("log") || name.ends_with("wood") => '|', - _ if name.contains("grass") || name.contains("fern") || name.contains("flower") => '\'', - _ => '?', - } -} - -fn main() -> Result<(), Error> { - let profile_boot = Instant::now(); - let mut args = std::env::args().skip(1); - let resources = PathBuf::from(args.next().expect("client resource directory")); - let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0)); - let mut parity = None; - let mut decorate = true; - let mut dimension = String::from("minecraft:overworld"); - let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None; - while let Some(arg) = args.next() { - let mut next = || args.next().expect("argument value"); - match arg.as_str() { - "--seed" => seed = next().parse()?, - "--size" => size = next().parse()?, - "--threads" => threads = next().parse()?, - "--center" => center = (next().parse()?, next().parse()?), - "--verify" => parity = Some(PathBuf::from(next())), - "--no-decorate" => decorate = false, - "--dimension" => { - let d = next(); - dimension = if d.contains(':') { - d - } else { - format!("minecraft:{d}") - }; - } - "--starts" => { - starts = Some(( - next().parse()?, - next().parse()?, - next().parse()?, - next().parse()?, - PathBuf::from(next()), - )) - } - _ => return Err(format!("unknown argument {arg}").into()), - } - } - let start = Instant::now(); - let registry = registry(&resources)?; - let data = GeneratorData::load(&resources.join("worldgen"), registry)?; - println!("loaded resources in {:.2?}", start.elapsed()); - if let Some(parity) = parity { - verify(&data, &parity)?; - } - let start = Instant::now(); - let generator = - OverworldGenerator::for_dimension(data.clone(), seed, "minecraft:normal", &dimension)?; - if std::env::var_os("HORIZON_LIST_UNSUPPORTED").is_some() { - for (feature, error) in generator.unsupported_features() { - println!("unsupported {feature}: {error}"); - } - } - println!("seeded generator in {:.2?}", start.elapsed()); - if let Some((x0, z0, x1, z1, out)) = starts { - dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?; - return Ok(()); - } - if std::env::var_os("HORIZON_PROFILE_WARM").is_some() { - let start = Instant::now(); - let mut warm = generator.worker(); - for z in 0..9 { for x in 0..9 { - let _ = warm.generate_proto(ChunkPos::new(center.0 + 64 + x, center.1 + 64 + z))?; - }} - println!("warmup_ms {:.6}", start.elapsed().as_secs_f64() * 1000.0); - } - println!("PROFILE_MEASURE_START {:.9}", profile_boot.elapsed().as_secs_f64()); - let (x0, z0) = (center.0 - size / 2, center.1 - size / 2); - let count = (size * size) as usize; - let next = AtomicUsize::new(0); - let slots: Vec>> = (0..count).map(|_| Mutex::new(None)).collect(); - let timings = Mutex::new(Vec::new()); - let cpu = cpu_seconds(); - let start = Instant::now(); - std::thread::scope(|scope| -> Result<(), Error> { - let handles = (0..threads) - .map(|_| { - scope.spawn(|| -> Result<(), Error> { - let mut worker = generator.worker(); - loop { - let i = next.fetch_add(1, Ordering::Relaxed); - if i >= count { - timings.lock().unwrap().push(worker.stage_timings()); - return Ok(()); - } - let pos = ChunkPos::new(x0 + (i as i32 % size), z0 + (i as i32 / size)); - *slots[i].lock().unwrap() = Some(worker.generate_proto(pos)?); - } - }) - }) - .collect::>(); - handles.into_iter().try_for_each(|h| h.join().unwrap()) - })?; - let elapsed = start.elapsed(); - println!("PROFILE_TERRAIN_END {:.9}", profile_boot.elapsed().as_secs_f64()); - println!( - "generated {count} proto chunks with {threads} threads in {elapsed:.2?}: {:.1} chunks/s ({:.1} ms/chunk/thread)", - count as f64 / elapsed.as_secs_f64(), - elapsed.as_secs_f64() * 1000. * threads as f64 / count as f64 - ); - println!( - " cpu time {:.1} ms/chunk", - (cpu_seconds() - cpu) * 1000. / count as f64 - ); - println!("PROFILE_WALL_MS_CHUNK {:.6}", elapsed.as_secs_f64() * 1000.0 / count as f64); - let timings = timings.into_inner().unwrap(); - let per_chunk = |f: fn(&StageTimings) -> std::time::Duration| { - timings - .iter() - .map(f) - .sum::() - .as_secs_f64() - * 1000. - / count as f64 - }; - println!("PROFILE_STAGES {}", serde_json::json!({ - "chunks": count, "threads": threads, - "biomes": per_chunk(|t| t.biomes), "structures": per_chunk(|t| t.structures), - "noise": per_chunk(|t| t.noise), "surface": per_chunk(|t| t.surface), - "carvers": per_chunk(|t| t.carvers), - "wall_ms_chunk": elapsed.as_secs_f64() * 1000.0 / count as f64, - })); - let mut chunks: Vec> = slots - .into_iter() - .map(|slot| slot.into_inner().unwrap()) - .collect(); - snapshot(&chunks, "terrain")?; - if decorate && size >= 3 { - let totals = Mutex::new(DecorateStats::default()); - let start = Instant::now(); - let mut decorated = 0; - // Disjoint 3×3 regions per phase can be decorated concurrently. - for phase in 0..9 { - let mut regions = Vec::new(); - for z in 1..size - 1 { - for x in 1..size - 1 { - if (x % 3) * 3 + z % 3 != phase { - continue; - } - let mut region = Vec::with_capacity(9); - for dz in -1..=1 { - for dx in -1..=1 { - region - .push(chunks[((z + dz) * size + x + dx) as usize].take().unwrap()); - } - } - regions.push(((x, z), region)); - } - } - decorated += regions.len(); - let queue = Mutex::new(regions); - let done = Mutex::new(Vec::new()); - std::thread::scope(|scope| -> Result<(), Error> { - let handles = (0..threads) - .map(|_| { - scope.spawn(|| -> Result<(), Error> { - let mut worker: GeneratorWorker = generator.worker(); - loop { - let Some((at, region)) = queue.lock().unwrap().pop() else { - return Ok(()); - }; - let mut region: [ProtoChunk; 9] = - region.try_into().map_err(|_| "region size")?; - let stats = worker.decorate(&mut region)?; - let mut totals = totals.lock().unwrap(); - totals.placed += stats.placed; - totals.unsupported += stats.unsupported; - totals.failed += stats.failed; - totals.skipped.extend(stats.skipped); - drop(totals); - done.lock().unwrap().push((at, region)); - } - }) - }) - .collect::>(); - handles.into_iter().try_for_each(|h| h.join().unwrap()) - })?; - for ((x, z), region) in done.into_inner().unwrap() { - for (i, chunk) in region.into_iter().enumerate() { - let (dx, dz) = (i as i32 % 3 - 1, i as i32 / 3 - 1); - chunks[((z + dz) * size + x + dx) as usize] = Some(chunk); - } - } - } - let elapsed = start.elapsed(); - let totals = totals.into_inner().unwrap(); - println!( - "decorated {decorated} chunks in {elapsed:.2?}: {:.1} chunks/s; feature roots placed {}, unsupported {}, failed {}", - decorated as f64 / elapsed.as_secs_f64(), - totals.placed, - totals.unsupported, - totals.failed - ); - if std::env::var_os("HORIZON_FEATURE_ERRORS").is_some() { - for (name, error) in generator.unsupported_features() { - println!("unsupported {name}: {error}"); - } - } - if !totals.skipped.is_empty() { - println!( - "skipped roots: {}", - totals.skipped.into_iter().collect::>().join(" ") - ); - } - } - snapshot(&chunks, "decorated")?; - println!("PROFILE_MEASURE_END {:.9}", profile_boot.elapsed().as_secs_f64()); - Ok(()) -} - -// Diagnostic only: full ordered chunk state, outside performance measurements. -fn snapshot(chunks: &[Option], phase: &str) -> Result<(), Error> { - use std::io::Write; - let path = std::env::var("HORIZON_SNAPSHOT_PATH")?; - let mut out = std::io::BufWriter::new(fs::File::create(format!("{path}-{phase}.bin"))?); - for chunk in chunks.iter().flatten() { - let terrain = &chunk.terrain; - writeln!(out, "chunk {:?} {:?} {} {:?} {:?}", chunk.position(), terrain.generation_stage(), chunk.is_decorated(), chunk.structures(), terrain.below_zero_retrogen().map(|v| v.to_nbt()))?; - writeln!(out, "nonair {:?}", terrain.diagnostic_non_air_counts())?; - for section in 0..terrain.height() as usize / 16 { - let data = terrain.section(section).unwrap(); - writeln!(out, "section {section} {:?}", data.to_nbt()?)?; - for index in 0..4096 { - out.write_all(&data.get(index)?.0.to_le_bytes())?; - } - } - // Compare public reads too, including all-air section behavior. - for y in terrain.min_y()..terrain.min_y()+terrain.height() { - for z in 0..16 { - for x in 0..16 { - out.write_all(&terrain.block(x, y, z).0.to_le_bytes())?; - } - } - } - for y in (terrain.min_y()>>2)..((terrain.min_y()+terrain.height())>>2) { - for z in 0..4 { - for x in 0..4 { - writeln!(out, "biome {}", chunk.biome_at(chunk.position().x*16+x*4, y*4, chunk.position().z*16+z*4))?; - } - } - } - for kind in HeightmapType::ALL { - writeln!(out, "heightmap {kind:?} {:?}", terrain.heightmap(kind).map(|m| m.raw_data()))?; - } - writeln!(out, "post {:?}", terrain.postprocessing())?; - writeln!(out, "blockticks {:?}", terrain.block_ticks().pack(0))?; - writeln!(out, "fluidticks {:?}", terrain.fluid_ticks().pack(0))?; - for (position, tag) in &chunk.block_entities { - writeln!(out, "blockentity {position:?}")?; - let bytes = horizon_world::nbt::write_network(&Tag::Compound(tag.clone()), Default::default())?; - out.write_all(&(bytes.len() as u64).to_le_bytes())?; - out.write_all(&bytes)?; - } - let entities = Tag::List(chunk.entities.iter().cloned().map(Tag::Compound).collect()); - let bytes = horizon_world::nbt::write_network(&entities, Default::default())?; - out.write_all(&(bytes.len() as u64).to_le_bytes())?; - out.write_all(&bytes)?; - } - out.flush()?; - Ok(()) -} diff --git a/noise-aquifer-results/core-final-tests.log b/noise-aquifer-results/core-final-tests.log deleted file mode 100644 index f71df48d8..000000000 --- a/noise-aquifer-results/core-final-tests.log +++ /dev/null @@ -1,105 +0,0 @@ - Compiling horizon-core v0.1.0 (/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56/crates/horizon-core) - Finished `fast` profile [optimized] target(s) in 2.46s - Running unittests src/lib.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/horizon_core-79709449cb32c90a) - -running 86 tests -test density::graph::tests::compiler_reduces_uniform_axes_and_preserves_strided_vertical_samples ... ok -test density::graph::tests::failed_parent_preparation_retains_successful_child_and_consumes_new_id_on_retry ... ok -test density::graph::tests::min_range_elimination_is_strict_and_does_not_skip_child_compilation ... ok -test density::graph::tests::interval_threshold_equality_and_hashing_preserve_distinct_cache_inputs ... ok -test density::graph::tests::end_islands_use_the_world_seed_independently_of_the_noise_algorithm ... ok -test density::graph::tests::noise_specialization_requires_literal_positive_zero_shifts ... ok -test density::graph::tests::power_literal_selection_retains_signed_zeros_and_negative_fallback_behavior ... ok -test density::graph::tests::rounding_specializes_only_literal_one_and_preserves_input_on_multiple_failure ... ok -test density::graph::tests::registered_noises_share_ordinary_instances_and_recreate_nether_instances ... ok -test density::graph::tests::spline_coordinates_share_bulk_evaluation_after_graph_rewriting ... ok -test density::graph::tests::spline_range_early_return_does_not_skip_coordinate_validation_during_compilation ... ok -test density::graph::tests::structural_identity_preserves_java_float_keys_and_shared_cache_ids ... ok -test density::tests::blended_fbm_work_bound_rejects_before_random_draws ... ok -test density::tests::bulk_choice_evaluates_in_range_before_a_failing_selector ... ok -test density::tests::cache_returns_filled_failure_buffer_on_the_next_volume_request ... ok -test density::tests::grid_interpolation_keeps_incremental_bulk_rounding ... ok -test density::tests::grid_interpolation_uses_child_bulk_corners_and_preserves_aligned_delegation ... ok -test density::tests::interval_branch_errors_keep_selector_output_and_return_scratch ... ok -test density::tests::invalid_buffer_is_rejected_before_child_evaluation ... ok -test density::tests::monotonic_mapping_skips_nai_and_rejects_nan_after_both_endpoints ... ok -test density::tests::range_arithmetic_and_zero_equality_match_reference_special_cases ... ok -test density::tests::scalar_shortcuts_and_bulk_arithmetic_keep_distinct_results ... ok -test density::tests::scratch_returns_to_context_after_nested_sampling_errors ... ok -test density::tests::shift_b_repeats_each_horizontal_sample_and_preserves_tail ... ok -test density::tests::slices_delegate_matching_volumes_and_isolate_reduced_child_failures ... ok -test density::tests::slices_preserve_reduced_volume_steps_in_cached_children ... ok -test density::tests::spline_coordinate_cache_retries_nan_scalars_but_reuses_nan_volumes ... ok -test density::tests::spline_lazy_branch_failure_preserves_completed_output_and_returns_scratch ... ok -test density::tests::surface_bulk_preserves_upper_bound_writes_and_sliced_error_isolation ... ok -test density::tests::surface_search_fixes_upper_bound_y_and_visits_descending_cell_boundaries ... ok -test density::tests::unary_bulk_keeps_child_failure_writes_and_full_buffer_tail ... ok -test density::tests::tail_writes_follow_the_selected_bulk_sampler ... ok -test density::tests::volume_lookup_requires_exact_lattice_and_preserves_java_overflow ... ok -test geometry::border::tests::invalid_parameters_leave_existing_extent_unchanged ... ok -test geometry::movement::fallible_tests::owned_collision_queries_stop_at_first_failure ... ok -test geometry::movement::tests::floor_height_defers_the_lower_lookup_until_empty ... ok -test geometry::movement::tests::movement_slides_after_a_wall_collision ... ok -test geometry::movement::tests::squared_length_underflow_skips_collection_and_keeps_signed_zero ... ok -test geometry::movement::tests::step_heights_deduplicate_and_exclude_current_y ... ok -test geometry::movement::tests::stepping_requeries_and_clears_a_half_block ... ok -test geometry::shape::create::tests::optimization_restores_composite_shapes ... ok -test geometry::shape::create::tests::quantization_thin_boxes_and_shared_block_identity ... ok -test geometry::shape::create::tests::quantized_empty_boxes_keep_independent_axis_extrema ... ok -test geometry::shape::face::tests::face_cache_is_lazy_shared_and_does_not_retain_parent ... ok -test geometry::shape::join::tests::returned_shapes_preserve_alias_identity ... ok -test geometry::shape::join::tests::signed_zero_list_equality_preserves_first_coordinates ... ok -test geometry::shape::join::tests::unions_intersections_difference_and_rejection ... ok -test geometry::shape::tests::sparse_stair_decomposition ... ok -test geometry::shape::tests::stop_at_obstacle_and_reuse_boxes ... ok -test geometry::sweep::tests::tiny_movement_includes_maximum_faces_and_stops_immediately ... ok -test geometry::tests::numerical_boundaries ... ok -test geometry::tests::ray_faces_and_half_open_bounds ... ok -test geometry::traversal::tests::corner_order_and_early_exit ... ok -test geometry::traversal::tests::miss_zero_identity_and_budget_errors ... ok -test geometry::trig::tests::atan2_matches_the_client_tables ... ok -test geometry::trig::tests::fdlibm_atan2_matches_java_math_atan2 ... ok -test jmath::tests::matches_hotspot_on_aarch64 ... ok -test noise::tests::bulk_accumulation_preserves_tail_and_rejects_short_buffers_before_writes ... ok -test noise::tests::density_dimensions_are_bounded_and_coordinates_wrap ... ok -test noise::tests::normal_noise_reference_values_and_legacy_failure_draws ... ok -test noise::tests::stack_snapshots_share_layers_and_preserve_zero_amplitude_semantics ... ok -test noise::tests::vanilla_seed_zero_samples_and_derivatives ... ok -test paletted::tests::rejects_malformed_wire_data ... ok -test position::iter::tests::ordering_inclusive_faces_and_value_independence ... ok -test paletted::tests::uniform_detection_ignores_stale_palette_entries ... ok -test position::tests::negative_boundaries_use_floor_division ... ok -test paletted::tests::grows_through_vanilla_widths ... ok -test position::tests::coordinate_formats_are_distinct_and_bijective_in_range ... ok -test position::tests::packed_signed_limits_and_java_overflow ... ok -test random::tests::invalid_inputs_preserve_both_streams ... ok -test random::hash::tests::rfc_vectors_and_streaming_padding_boundaries ... ok -test paletted::tests::division_magic_is_exact ... ok -test random::tests::legacy_jdk_sequence_and_sign_extended_low_word ... ok -test random::tests::zero_state_fallback_and_reseed ... ok -test storage::tests::imported_padding_is_preserved_and_invalid_writes_are_atomic ... ok -test storage::tests::padded_words_never_split_entries ... ok -test ticks::tests::callback_scheduling_waits_until_the_next_collection ... ok -test ticks::tests::collection_guards_and_membership_survive_area_mutation ... ok -test ticks::tests::copying_active_ticks_preserves_relative_order_and_wraps ... ok -test ticks::tests::disabled_and_removed_chunks_retain_their_queue ... ok -test ticks::tests::due_chunks_compete_by_priority_not_trigger_time ... ok -test ticks::tests::pending_ticks_keep_list_order_and_java_time_overflow ... ok -test geometry::trig::tests::long_narrowing_and_quadrants ... ok -test storage::tests::all_widths_survive_overwrites_and_unpack ... ok -test paletted::tests::matches_a_plain_array_under_random_edits ... ok -test density::arithmetic::bulk_tests::fixed_operation_loops_preserve_float_bits ... ok - -test result: ok. 86 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running tests/density_world_fields.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/density_world_fields-43fc47aef9e786bd) - -running 6 tests -test absent_fields_use_vanilla_defaults_including_buffer_tails ... ok -test blending_range_and_axes_follow_input_even_for_spatial_providers ... ok -test blending_visits_z_x_y_and_preserves_the_input_tail ... ok -test failed_input_prevents_blender_lookup_and_preserves_partial_writes ... ok -test fields_resolve_through_the_same_context_and_replace_cached_values ... ok -test named_reference_identity_differs_from_direct_value_equality ... ok - -test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s diff --git a/noise-aquifer-results/density-parity.json b/noise-aquifer-results/density-parity.json deleted file mode 100644 index 59b272f11..000000000 --- a/noise-aquifer-results/density-parity.json +++ /dev/null @@ -1,40 +0,0 @@ -{ - "minecraft": { - "version": "26.3", - "manifest_sha1": "11f1aefe473eefba0af62e3286c33b692807b2eb", - "accepted_manifest_sha1": [ - "4fe1aa1ef8da1cb95c5bad1fb98890ca56dd8ca3", - "702fe59163c6ee6578607daa85811d9bc9c7cc40" - ], - "accepted_manifest_note": "Earlier 26.3 version JSONs Mojang republished: only assetIndex differs (non-English translations), jars and libraries are identical. A launcher may still hold any of them.", - "client_sha1": "e877b6a07acd633fb3bb475002175cec036e7b87", - "server_sha1": "33680f5f2ac32864d6d7cf5e56a705fdb3e05f4c", - "java_major": 25 - }, - "profile": "fast", - "binary_sha256": "c3c042098409f9bb2aa2f3c92bca70c803474e2a4af32c4afc0d9cebeb111ca4", - "inputs_sha256": "3bb59de57994936c7347c504b212900f9ec7c3c3eff1f0e49c051b46d23bed97", - "references": [ - { - "side": "client", - "jar_sha256": "4508d006323f24fa02876310c192d739af56516eb259000ac50f0909a68c9a2d", - "output_sha256": "e1fcf55d697acd4d0f6470079416c5cae2cbc75d524f8f7aee50b5555f2c330d", - "matched_output_lines": 15524627 - }, - { - "side": "server", - "jar_sha256": "a362163eec5d1612d520772bc16e5b39c09e3b234fdc045f56bf544284ee8ae6", - "output_sha256": "e1fcf55d697acd4d0f6470079416c5cae2cbc75d524f8f7aee50b5555f2c330d", - "matched_output_lines": 15524627 - } - ], - "rust_output_sha256": "e1fcf55d697acd4d0f6470079416c5cae2cbc75d524f8f7aee50b5555f2c330d", - "oracle_source_sha256": "0be907c58f2bb35f924b1c42919397cdfc0c38f7be500e26c5d462f46aaf1f08", - "corpus_script_sha256": "ab052eb065a0ae0c0469e95335b952153adbb01f46b5d12ad075fc1a5a8ec0d0", - "runner_sha256": "69b75444b14fd71da7abc89ac5c83992de48c526b6f7723b8a20ed7185e517b4", - "sources_sha256": { - "crates/horizon-core/src/density/arithmetic.rs": "82f521e11756cc4455c31e7cacc4587deba2e4bbe08f8bb16c08d7e1f8d76b4b", - "crates/horizon-core/src/density/tests.rs": "422a3cf804b30c1de5fe4c3527c224dbc39dd2d1999358f21663069a28977dde" - }, - "scope": "Existing corpus authenticated against prior report and unchanged generator/oracle source; candidate and both checksum-pinned Java sides run freshly; density parity, not whole-game parity." -} diff --git a/noise-aquifer-results/environment.json b/noise-aquifer-results/environment.json deleted file mode 100644 index c04765b23..000000000 --- a/noise-aquifer-results/environment.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "baseline_commit": "e4f8154cb4115aa1ee622381d9b12387cdf515d4", - "branch": "t3/optimize-noise-aquifers", - "worktree": "/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56", - "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)", - "kernel": "Linux-7.2.11-zen1-1-zen-x86_64-with-glibc2.44", - "cpu": "AMD Ryzen 5 5600X, 6 cores / 12 logical CPUs", - "ram": "32 GiB", - "resources": "/srv/bob-data/horizon/.local/horizon-client/26.3", - "target": "/srv/bob-data/horizon-stage3d-target", - "fast_symlink_target": "/tmp/horizon-density-eval/fast-build", - "build": "fast inherits release; LTO false, codegen-units 16, incremental true", - "concurrency": "Builds and benchmarks sequential, no simultaneous benchmarks launched by this task; desktop/background load not isolated" -} diff --git a/noise-aquifer-results/final-codegen-check.json b/noise-aquifer-results/final-codegen-check.json deleted file mode 100644 index 610fe7340..000000000 --- a/noise-aquifer-results/final-codegen-check.json +++ /dev/null @@ -1,21 +0,0 @@ -[ - { - "build": "measured", - "binary_sha256": "198f60a68b2616aa394861c517297d4a14cc0949e3b56600905b6f86c05e59b8", - ".text": "94d45a6a5d83cc428a43fd871d014b6204b8f3d92ee05b9d16aeecf3e67344a7", - ".rodata": "410e1aa0482533b5927b75ea7c7b2385b697fe4d1d7872744a5dcdf2c0133796", - ".data.rel.ro": "6f5bddbfa8ca9c8bd560a467e73d8b20d17bd0323ad3bc048304464fcc8e3767" - }, - { - "build": "final", - "binary_sha256": "bafd0f9342260b1cac2a1d0f6708dfef721389253cec0472a1ecb4895d71b3af", - ".text": "94d45a6a5d83cc428a43fd871d014b6204b8f3d92ee05b9d16aeecf3e67344a7", - ".rodata": "410e1aa0482533b5927b75ea7c7b2385b697fe4d1d7872744a5dcdf2c0133796", - ".data.rel.ro": "ac71cb66d3b8ecbcd8bee8bd8b6c9fd8ca6ea64651267fb8e352c0d82be76286" - }, - { - "changed_data_rel_ro_u32_words": 12, - "all_decreased_by_four": true, - "interpretation": "Source-location line numbers after removing four diagnostic accessor lines; .text and .rodata byte-identical." - } -] diff --git a/noise-aquifer-results/gate-raw.json b/noise-aquifer-results/gate-raw.json deleted file mode 100644 index 8bec366c1..000000000 --- a/noise-aquifer-results/gate-raw.json +++ /dev/null @@ -1,530 +0,0 @@ -[ - { - "biomes": 0.43547596875, - "carvers": 0.39140908203125, - "chunks": 256, - "noise": 5.2948666367187505, - "structures": 1.1794168828125, - "surface": 3.37029921484375, - "threads": 1, - "wall_ms_chunk": 10.72101433984375, - "version": "candidate", - "repeat": -1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 503.33, - "combined_ms_chunk": 12.68714715234375, - "terrain_cpu_ms_chunk": 10.5, - "process_user_s": 8.180593, - "process_system_s": 0.28079, - "peak_rss_kib": 787192 - }, - { - "biomes": 0.4439284296875, - "carvers": 0.37917393359375, - "chunks": 256, - "noise": 5.77808341796875, - "structures": 1.1781649609375, - "surface": 4.4398382421875, - "threads": 1, - "wall_ms_chunk": 12.26891484765625, - "version": "baseline", - "repeat": -1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 497.61, - "combined_ms_chunk": 14.21270391015625, - "terrain_cpu_ms_chunk": 12.2, - "process_user_s": 8.713481, - "process_system_s": 0.28895299999999996, - "peak_rss_kib": 786884 - }, - { - "biomes": 0.4295055625, - "carvers": 0.38291098046875, - "chunks": 256, - "noise": 5.773962269531251, - "structures": 1.16812175, - "surface": 4.4673708046875, - "threads": 1, - "wall_ms_chunk": 12.2709350703125, - "version": "baseline", - "repeat": 0, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 504.5, - "combined_ms_chunk": 14.2416381953125, - "terrain_cpu_ms_chunk": 12.2, - "process_user_s": 8.733129, - "process_system_s": 0.27940699999999996, - "peak_rss_kib": 786812 - }, - { - "biomes": 0.421953875, - "carvers": 0.37140534765625, - "chunks": 256, - "noise": 5.1102533515625, - "structures": 1.1586842109375, - "surface": 3.2626291484375, - "threads": 1, - "wall_ms_chunk": 10.37302974609375, - "version": "candidate", - "repeat": 0, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 496.42, - "combined_ms_chunk": 12.31217037109375, - "terrain_cpu_ms_chunk": 10.3, - "process_user_s": 8.237949, - "process_system_s": 0.315424, - "peak_rss_kib": 786412 - }, - { - "biomes": 0.42579529687499995, - "carvers": 0.376251890625, - "chunks": 256, - "noise": 5.187435171875, - "structures": 1.1964910312500001, - "surface": 3.29565119140625, - "threads": 1, - "wall_ms_chunk": 10.53004565234375, - "version": "candidate", - "repeat": 1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 492.9, - "combined_ms_chunk": 12.45543627734375, - "terrain_cpu_ms_chunk": 10.5, - "process_user_s": 8.133229, - "process_system_s": 0.272889, - "peak_rss_kib": 786808 - }, - { - "biomes": 0.4297166484375, - "carvers": 0.37644830078124997, - "chunks": 256, - "noise": 5.772878597656249, - "structures": 1.17804449609375, - "surface": 4.470543871093749, - "threads": 1, - "wall_ms_chunk": 12.276752472656248, - "version": "baseline", - "repeat": 1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 492.99, - "combined_ms_chunk": 14.202494660156248, - "terrain_cpu_ms_chunk": 12.1, - "process_user_s": 8.719636, - "process_system_s": 0.275497, - "peak_rss_kib": 786532 - }, - { - "biomes": 0.44423383203125, - "carvers": 0.37403341015625, - "chunks": 256, - "noise": 5.775249617187501, - "structures": 1.1649090039062502, - "surface": 4.4796617226562505, - "threads": 1, - "wall_ms_chunk": 12.28674475390625, - "version": "baseline", - "repeat": 2, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 497.65, - "combined_ms_chunk": 14.23069006640625, - "terrain_cpu_ms_chunk": 12.3, - "process_user_s": 8.712861, - "process_system_s": 0.30794099999999996, - "peak_rss_kib": 786588 - }, - { - "biomes": 0.42566181640625, - "carvers": 0.38387910937499997, - "chunks": 256, - "noise": 5.246072375, - "structures": 1.1587689218750001, - "surface": 3.3145837343749998, - "threads": 1, - "wall_ms_chunk": 10.57722427734375, - "version": "candidate", - "repeat": 2, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 503.21, - "combined_ms_chunk": 12.542888339843751, - "terrain_cpu_ms_chunk": 10.5, - "process_user_s": 8.121225, - "process_system_s": 0.307971, - "peak_rss_kib": 787072 - }, - { - "biomes": 0.43049873046875003, - "carvers": 0.38391943359375, - "chunks": 256, - "noise": 5.2936765, - "structures": 1.17518914453125, - "surface": 3.3476032148437502, - "threads": 1, - "wall_ms_chunk": 10.67998828515625, - "version": "candidate", - "repeat": 3, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 495.96, - "combined_ms_chunk": 12.61733203515625, - "terrain_cpu_ms_chunk": 10.5, - "process_user_s": 8.111499, - "process_system_s": 0.297967, - "peak_rss_kib": 786604 - }, - { - "biomes": 0.42718302734375, - "carvers": 0.37447686328124996, - "chunks": 256, - "noise": 5.72907546484375, - "structures": 1.16478528515625, - "surface": 4.42239170703125, - "threads": 1, - "wall_ms_chunk": 12.16650178125, - "version": "baseline", - "repeat": 3, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 489.71, - "combined_ms_chunk": 14.07943146875, - "terrain_cpu_ms_chunk": 12.1, - "process_user_s": 8.683186, - "process_system_s": 0.30128, - "peak_rss_kib": 786588 - }, - { - "biomes": 0.426544765625, - "carvers": 0.38605957812499997, - "chunks": 256, - "noise": 5.69790626171875, - "structures": 1.1686023359375, - "surface": 4.42780881640625, - "threads": 1, - "wall_ms_chunk": 12.155565492187499, - "version": "baseline", - "repeat": 4, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 493.98, - "combined_ms_chunk": 14.085174867187499, - "terrain_cpu_ms_chunk": 12.1, - "process_user_s": 8.712038, - "process_system_s": 0.297019, - "peak_rss_kib": 786768 - }, - { - "biomes": 0.42749559765625, - "carvers": 0.38046942578125004, - "chunks": 256, - "noise": 5.22939499609375, - "structures": 1.16468150390625, - "surface": 3.3154809882812497, - "threads": 1, - "wall_ms_chunk": 10.56634626953125, - "version": "candidate", - "repeat": 4, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 505.54, - "combined_ms_chunk": 12.54111189453125, - "terrain_cpu_ms_chunk": 10.5, - "process_user_s": 8.187812, - "process_system_s": 0.294048, - "peak_rss_kib": 786608 - } -] diff --git a/noise-aquifer-results/gate-summary.json b/noise-aquifer-results/gate-summary.json deleted file mode 100644 index eecb49ad2..000000000 --- a/noise-aquifer-results/gate-summary.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - { - "dimension": "overworld", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 12.2709350703125, - "candidate": 10.56634626953125, - "reduction_percent": 13.891270640859485 - }, - "combined_ms_chunk": { - "baseline": 14.202494660156248, - "candidate": 12.54111189453125, - "reduction_percent": 11.697823554096097 - }, - "noise": { - "baseline": 5.772878597656249, - "candidate": 5.22939499609375, - "reduction_percent": 9.414429774829324 - }, - "surface": { - "baseline": 4.4673708046875, - "candidate": 3.3145837343749998, - "reduction_percent": 25.804597843163354 - }, - "terrain_cpu_ms_chunk": { - "baseline": 12.1, - "candidate": 10.5, - "reduction_percent": 13.223140495867767 - }, - "peak_rss_kib": { - "baseline": 786588, - "candidate": 786608, - "reduction_percent": -0.0025426271440703394 - } - } -] diff --git a/noise-aquifer-results/initial-shared-inline/binary-hashes.txt b/noise-aquifer-results/initial-shared-inline/binary-hashes.txt deleted file mode 100644 index ae4d2a105..000000000 --- a/noise-aquifer-results/initial-shared-inline/binary-hashes.txt +++ /dev/null @@ -1,2 +0,0 @@ -65d134def1e54944b105cf13e28945eea717f75aabf5dfd827f70645b22abc3c /srv/bob-data/horizon-noise-aquifer-e477fa56/baseline -e17373cba69ae2142e81f867b5ff3dbff2c9e56bc6f2c18abdd99b85b0ba7bbe /srv/bob-data/horizon-noise-aquifer-e477fa56/candidate diff --git a/noise-aquifer-results/initial-shared-inline/candidate.patch b/noise-aquifer-results/initial-shared-inline/candidate.patch deleted file mode 100644 index 63a21ef2e..000000000 --- a/noise-aquifer-results/initial-shared-inline/candidate.patch +++ /dev/null @@ -1,73 +0,0 @@ -diff --git a/crates/horizon-core/src/density/arithmetic.rs b/crates/horizon-core/src/density/arithmetic.rs -index f82b96ce..4f1b3a8c 100644 ---- a/crates/horizon-core/src/density/arithmetic.rs -+++ b/crates/horizon-core/src/density/arithmetic.rs -@@ -76,6 +76,7 @@ pub enum UnaryOp { - }, - } - impl UnaryOp { -+ #[inline(always)] - pub(super) fn apply(self, value: f32, bulk: bool) -> f32 { - match self { - Self::Abs => value.abs(), -@@ -138,6 +139,49 @@ impl UnaryOp { - } - } - } -+ /// Dispatch once per volume so each loop has one fixed arithmetic operation. -+ /// Keep the scalar expression shared, including the bulk min/max behavior. -+ fn apply_bulk(self, buffer: &mut [f32]) { -+ macro_rules! apply { -+ ($operation:expr) => { -+ for value in buffer { -+ *value = $operation.apply(*value, true); -+ } -+ }; -+ } -+ match self { -+ Self::Abs => apply!(Self::Abs), -+ Self::Negate => apply!(Self::Negate), -+ Self::Square => apply!(Self::Square), -+ Self::Cube => apply!(Self::Cube), -+ Self::Sqrt => apply!(Self::Sqrt), -+ Self::Log => apply!(Self::Log), -+ Self::PowerBase(base) => apply!(Self::PowerBase(base)), -+ Self::PowerExponent(exponent) => apply!(Self::PowerExponent(exponent)), -+ Self::Reciprocal => apply!(Self::Reciprocal), -+ Self::Sign => apply!(Self::Sign), -+ Self::Squeeze => apply!(Self::Squeeze), -+ Self::LeakyRelu(factor) => apply!(Self::LeakyRelu(factor)), -+ Self::Add(right) => apply!(Self::Add(right)), -+ Self::SubtractFrom(left) => apply!(Self::SubtractFrom(left)), -+ Self::Multiply(right) => apply!(Self::Multiply(right)), -+ Self::DivideInto(left) => apply!(Self::DivideInto(left)), -+ Self::Minimum(right) => apply!(Self::Minimum(right)), -+ Self::Maximum(right) => apply!(Self::Maximum(right)), -+ Self::ConstantRangeChoice { -+ min_inclusive, -+ max_exclusive, -+ inside, -+ outside, -+ } => apply!(Self::ConstantRangeChoice { -+ min_inclusive, -+ max_exclusive, -+ inside, -+ outside -+ }), -+ Self::Clamp { min, max } => apply!(Self::Clamp { min, max }), -+ } -+ } - } - #[derive(Clone, Debug)] - pub struct UnarySampler { -@@ -162,9 +206,7 @@ impl DensitySampler for UnarySampler { - ) -> Result<(), SampleError> { - check_buffer(buffer, volume)?; - self.input.sample_volume(context, buffer, volume)?; -- for value in buffer { -- *value = self.operation.apply(*value, true); -- } -+ self.operation.apply_bulk(buffer); - Ok(()) - } - } diff --git a/noise-aquifer-results/initial-shared-inline/gate-raw.json b/noise-aquifer-results/initial-shared-inline/gate-raw.json deleted file mode 100644 index 88c6cd5d1..000000000 --- a/noise-aquifer-results/initial-shared-inline/gate-raw.json +++ /dev/null @@ -1,530 +0,0 @@ -[ - { - "biomes": 0.44252540625, - "carvers": 0.37944787890625004, - "chunks": 256, - "noise": 5.37256131640625, - "structures": 1.1899462851562501, - "surface": 3.29317476171875, - "threads": 1, - "wall_ms_chunk": 10.72667368359375, - "version": "candidate", - "repeat": -1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 502.44, - "combined_ms_chunk": 12.68932993359375, - "terrain_cpu_ms_chunk": 10.6, - "process_user_s": 8.13122, - "process_system_s": 0.297359, - "peak_rss_kib": 786896 - }, - { - "biomes": 0.4328324765625, - "carvers": 0.38604471484374997, - "chunks": 256, - "noise": 5.76258115234375, - "structures": 1.1723783828125, - "surface": 4.48618292578125, - "threads": 1, - "wall_ms_chunk": 12.28948091015625, - "version": "baseline", - "repeat": -1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 493.35, - "combined_ms_chunk": 14.21662934765625, - "terrain_cpu_ms_chunk": 12.2, - "process_user_s": 8.735389, - "process_system_s": 0.286565, - "peak_rss_kib": 786496 - }, - { - "biomes": 0.42968594921875003, - "carvers": 0.37386116796874996, - "chunks": 256, - "noise": 5.7501386054687496, - "structures": 1.181537234375, - "surface": 4.4565285, - "threads": 1, - "wall_ms_chunk": 12.24029160546875, - "version": "baseline", - "repeat": 0, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 505.66, - "combined_ms_chunk": 14.21552598046875, - "terrain_cpu_ms_chunk": 12.2, - "process_user_s": 8.701562, - "process_system_s": 0.297948, - "peak_rss_kib": 786856 - }, - { - "biomes": 0.44574032421875004, - "carvers": 0.377108921875, - "chunks": 256, - "noise": 5.295269781250001, - "structures": 1.18742401953125, - "surface": 3.29978081640625, - "threads": 1, - "wall_ms_chunk": 10.65494362109375, - "version": "candidate", - "repeat": 0, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 496.28, - "combined_ms_chunk": 12.593537371093749, - "terrain_cpu_ms_chunk": 10.5, - "process_user_s": 8.179581, - "process_system_s": 0.272086, - "peak_rss_kib": 786752 - }, - { - "biomes": 0.42817503515625, - "carvers": 0.381013015625, - "chunks": 256, - "noise": 5.32803534375, - "structures": 1.1685042265625, - "surface": 3.2901356875000003, - "threads": 1, - "wall_ms_chunk": 10.6447336015625, - "version": "candidate", - "repeat": 1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 496.25, - "combined_ms_chunk": 12.5832101640625, - "terrain_cpu_ms_chunk": 10.6, - "process_user_s": 8.153767, - "process_system_s": 0.31987699999999997, - "peak_rss_kib": 786856 - }, - { - "biomes": 0.42586504296875, - "carvers": 0.374535953125, - "chunks": 256, - "noise": 5.756364796875, - "structures": 1.166495703125, - "surface": 4.41194609375, - "threads": 1, - "wall_ms_chunk": 12.18332252734375, - "version": "baseline", - "repeat": 1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 489.75, - "combined_ms_chunk": 14.09640846484375, - "terrain_cpu_ms_chunk": 12.2, - "process_user_s": 8.698943, - "process_system_s": 0.28009999999999996, - "peak_rss_kib": 787012 - }, - { - "biomes": 0.4276283203125, - "carvers": 0.3754761015625, - "chunks": 256, - "noise": 5.6835061132812505, - "structures": 1.1926860976562499, - "surface": 4.43971352734375, - "threads": 1, - "wall_ms_chunk": 12.1687718515625, - "version": "baseline", - "repeat": 2, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 510.19, - "combined_ms_chunk": 14.1617015390625, - "terrain_cpu_ms_chunk": 12.1, - "process_user_s": 8.694317999999999, - "process_system_s": 0.305902, - "peak_rss_kib": 786752 - }, - { - "biomes": 0.442308890625, - "carvers": 0.37814296875000003, - "chunks": 256, - "noise": 5.4344082109375, - "structures": 1.175275171875, - "surface": 3.30110362890625, - "threads": 1, - "wall_ms_chunk": 10.7801952578125, - "version": "candidate", - "repeat": 2, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 502.83, - "combined_ms_chunk": 12.744374945312499, - "terrain_cpu_ms_chunk": 10.7, - "process_user_s": 8.212731, - "process_system_s": 0.29778899999999997, - "peak_rss_kib": 787696 - }, - { - "biomes": 0.42592785156249996, - "carvers": 0.3739973125, - "chunks": 256, - "noise": 5.29756358984375, - "structures": 1.17243391015625, - "surface": 3.27471499609375, - "threads": 1, - "wall_ms_chunk": 10.5930513671875, - "version": "candidate", - "repeat": 3, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 493.81, - "combined_ms_chunk": 12.5219966796875, - "terrain_cpu_ms_chunk": 10.5, - "process_user_s": 8.153845, - "process_system_s": 0.291358, - "peak_rss_kib": 786816 - }, - { - "biomes": 0.431791, - "carvers": 0.38492897265625003, - "chunks": 256, - "noise": 5.7807356484375, - "structures": 1.1812125625, - "surface": 4.4762462734375, - "threads": 1, - "wall_ms_chunk": 12.30409496875, - "version": "baseline", - "repeat": 3, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 490.8, - "combined_ms_chunk": 14.221282468750001, - "terrain_cpu_ms_chunk": 12.3, - "process_user_s": 8.777226, - "process_system_s": 0.268125, - "peak_rss_kib": 786632 - }, - { - "biomes": 0.42878466015625, - "carvers": 0.37590098828125, - "chunks": 256, - "noise": 5.782410890625, - "structures": 1.1744792343750001, - "surface": 4.490146933593749, - "threads": 1, - "wall_ms_chunk": 12.3003106171875, - "version": "baseline", - "repeat": 4, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 505.11, - "combined_ms_chunk": 14.273396554687501, - "terrain_cpu_ms_chunk": 12.3, - "process_user_s": 8.793776, - "process_system_s": 0.26853699999999997, - "peak_rss_kib": 787692 - }, - { - "biomes": 0.436424984375, - "carvers": 0.37611544921874995, - "chunks": 256, - "noise": 5.2962504453125, - "structures": 1.1786373125, - "surface": 3.2901524921875, - "threads": 1, - "wall_ms_chunk": 10.62593462890625, - "version": "candidate", - "repeat": 4, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 497.11, - "combined_ms_chunk": 12.567770566406251, - "terrain_cpu_ms_chunk": 10.6, - "process_user_s": 8.178847, - "process_system_s": 0.25806599999999996, - "peak_rss_kib": 786636 - } -] diff --git a/noise-aquifer-results/initial-shared-inline/gate-summary.json b/noise-aquifer-results/initial-shared-inline/gate-summary.json deleted file mode 100644 index 5412e6902..000000000 --- a/noise-aquifer-results/initial-shared-inline/gate-summary.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - { - "dimension": "overworld", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 12.24029160546875, - "candidate": 10.6447336015625, - "reduction_percent": 13.035294054541824 - }, - "combined_ms_chunk": { - "baseline": 14.21552598046875, - "candidate": 12.5832101640625, - "reduction_percent": 11.482626943589354 - }, - "noise": { - "baseline": 5.756364796875, - "candidate": 5.29756358984375, - "reduction_percent": 7.970328900634006 - }, - "surface": { - "baseline": 4.4565285, - "candidate": 3.2901524921875, - "reduction_percent": 26.17229998220588 - }, - "terrain_cpu_ms_chunk": { - "baseline": 12.2, - "candidate": 10.6, - "reduction_percent": 13.114754098360654 - }, - "peak_rss_kib": { - "baseline": 786856, - "candidate": 786816, - "reduction_percent": 0.005083522270911069 - } - } -] diff --git a/noise-aquifer-results/loop-codegen.json b/noise-aquifer-results/loop-codegen.json deleted file mode 100644 index 5115b6871..000000000 --- a/noise-aquifer-results/loop-codegen.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - { - "binary": "baseline", - "unary_sample_volume_bytes": 128, - "packed_float_instruction_counts": { - "addps": 0, - "subps": 0, - "mulps": 0, - "divps": 0, - "andps": 0, - "xorps": 0, - "maxps": 0, - "minps": 0 - } - }, - { - "binary": "candidate", - "unary_sample_volume_bytes": 4335, - "packed_float_instruction_counts": { - "addps": 3, - "subps": 2, - "mulps": 13, - "divps": 3, - "andps": 26, - "xorps": 11, - "maxps": 2, - "minps": 2 - } - } -] diff --git a/noise-aquifer-results/matrix-raw.json b/noise-aquifer-results/matrix-raw.json deleted file mode 100644 index 01731a849..000000000 --- a/noise-aquifer-results/matrix-raw.json +++ /dev/null @@ -1,4226 +0,0 @@ -[ - { - "biomes": 0.48353841015625, - "carvers": 0.38574688281249997, - "chunks": 256, - "noise": 5.24437607421875, - "structures": 3.88326049609375, - "surface": 3.35451583984375, - "threads": 4, - "wall_ms_chunk": 3.36460393359375, - "version": "candidate", - "repeat": -1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 145.8, - "combined_ms_chunk": 3.9341351835937504, - "terrain_cpu_ms_chunk": 13.4, - "process_user_s": 8.876343, - "process_system_s": 0.346105, - "peak_rss_kib": 832720 - }, - { - "biomes": 0.507996703125, - "carvers": 0.38738203515625, - "chunks": 256, - "noise": 5.9148067499999994, - "structures": 3.9641258359375002, - "surface": 4.550977078124999, - "threads": 4, - "wall_ms_chunk": 3.8722654296875003, - "version": "baseline", - "repeat": -1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 144.82, - "combined_ms_chunk": 4.4379685546875, - "terrain_cpu_ms_chunk": 15.3, - "process_user_s": 9.517044, - "process_system_s": 0.32989999999999997, - "peak_rss_kib": 832968 - }, - { - "biomes": 0.47814796875, - "carvers": 0.38039311328125003, - "chunks": 256, - "noise": 5.8270603125000004, - "structures": 3.9121094453125, - "surface": 4.50185171875, - "threads": 4, - "wall_ms_chunk": 3.80498315234375, - "version": "baseline", - "repeat": 0, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 149.13, - "combined_ms_chunk": 4.3875222148437505, - "terrain_cpu_ms_chunk": 15.1, - "process_user_s": 9.468122, - "process_system_s": 0.33505199999999996, - "peak_rss_kib": 833136 - }, - { - "biomes": 0.4937317890625, - "carvers": 0.3843886484375, - "chunks": 256, - "noise": 5.25024941015625, - "structures": 3.9599643281250003, - "surface": 3.34837826953125, - "threads": 4, - "wall_ms_chunk": 3.38422338671875, - "version": "candidate", - "repeat": 0, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 149.9, - "combined_ms_chunk": 3.96977026171875, - "terrain_cpu_ms_chunk": 13.4, - "process_user_s": 8.934746, - "process_system_s": 0.32942699999999997, - "peak_rss_kib": 834516 - }, - { - "biomes": 0.49398027734375005, - "carvers": 0.39036689062499996, - "chunks": 256, - "noise": 5.3381976875, - "structures": 3.9302678281250003, - "surface": 3.3764329531249997, - "threads": 4, - "wall_ms_chunk": 3.4084368984375, - "version": "candidate", - "repeat": 1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 148.94, - "combined_ms_chunk": 3.9902337734374997, - "terrain_cpu_ms_chunk": 13.5, - "process_user_s": 8.904913, - "process_system_s": 0.339101, - "peak_rss_kib": 832348 - }, - { - "biomes": 0.49883715625, - "carvers": 0.3843920859375, - "chunks": 256, - "noise": 5.83775421875, - "structures": 3.9925353046875003, - "surface": 4.5059914296875, - "threads": 4, - "wall_ms_chunk": 3.8379385546875, - "version": "baseline", - "repeat": 1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 145.21, - "combined_ms_chunk": 4.4051651171875, - "terrain_cpu_ms_chunk": 15.2, - "process_user_s": 9.500240999999999, - "process_system_s": 0.316909, - "peak_rss_kib": 832416 - }, - { - "biomes": 0.52625087109375, - "carvers": 0.408476265625, - "chunks": 256, - "noise": 5.97718533203125, - "structures": 3.9960438671875003, - "surface": 4.64049345703125, - "threads": 4, - "wall_ms_chunk": 3.910542015625, - "version": "baseline", - "repeat": 2, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 145.64, - "combined_ms_chunk": 4.479448265625, - "terrain_cpu_ms_chunk": 15.5, - "process_user_s": 9.546377, - "process_system_s": 0.328233, - "peak_rss_kib": 834016 - }, - { - "biomes": 0.50042372265625, - "carvers": 0.38988045703124996, - "chunks": 256, - "noise": 5.276447015625, - "structures": 3.92323205859375, - "surface": 3.36673907421875, - "threads": 4, - "wall_ms_chunk": 3.3884105, - "version": "candidate", - "repeat": 2, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 146.12, - "combined_ms_chunk": 3.95919175, - "terrain_cpu_ms_chunk": 13.4, - "process_user_s": 8.896402, - "process_system_s": 0.337939, - "peak_rss_kib": 832812 - }, - { - "biomes": 0.493469734375, - "carvers": 0.39174865625, - "chunks": 256, - "noise": 5.32868657421875, - "structures": 3.94255260546875, - "surface": 3.3803906875000003, - "threads": 4, - "wall_ms_chunk": 3.40974043359375, - "version": "candidate", - "repeat": 3, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 147.93, - "combined_ms_chunk": 3.98759199609375, - "terrain_cpu_ms_chunk": 13.6, - "process_user_s": 8.914977, - "process_system_s": 0.340838, - "peak_rss_kib": 833440 - }, - { - "biomes": 0.5070742578125, - "carvers": 0.37754572265625, - "chunks": 256, - "noise": 5.81842376171875, - "structures": 3.8668252734375, - "surface": 4.51470572265625, - "threads": 4, - "wall_ms_chunk": 3.7974264921875, - "version": "baseline", - "repeat": 3, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 149.44, - "combined_ms_chunk": 4.3811764921875, - "terrain_cpu_ms_chunk": 15.0, - "process_user_s": 9.448119, - "process_system_s": 0.347536, - "peak_rss_kib": 834676 - }, - { - "biomes": 0.5080494531249999, - "carvers": 0.41245346875, - "chunks": 256, - "noise": 5.9831350703125, - "structures": 4.136053929687501, - "surface": 4.68349508203125, - "threads": 4, - "wall_ms_chunk": 3.9580060625, - "version": "baseline", - "repeat": 4, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 142.96, - "combined_ms_chunk": 4.5164435625, - "terrain_cpu_ms_chunk": 15.6, - "process_user_s": 9.631806, - "process_system_s": 0.329736, - "peak_rss_kib": 838848 - }, - { - "biomes": 0.5641761015625, - "carvers": 0.4391998828125, - "chunks": 256, - "noise": 5.7658923046875, - "structures": 4.01309696484375, - "surface": 3.72065009375, - "threads": 4, - "wall_ms_chunk": 3.6553530351562498, - "version": "candidate", - "repeat": 4, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 156.03, - "combined_ms_chunk": 4.26484522265625, - "terrain_cpu_ms_chunk": 14.4, - "process_user_s": 9.039513, - "process_system_s": 0.47204199999999996, - "peak_rss_kib": 834704 - }, - { - "biomes": 0.1370845390625, - "carvers": 0.3497980703125, - "chunks": 256, - "noise": 0.94345969921875, - "structures": 0.16458134375, - "surface": 3.33491193359375, - "threads": 1, - "wall_ms_chunk": 4.94248907421875, - "version": "candidate", - "repeat": -1, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 101.82, - "combined_ms_chunk": 5.34022344921875, - "terrain_cpu_ms_chunk": 4.9, - "process_user_s": 3.206893, - "process_system_s": 0.30306299999999997, - "peak_rss_kib": 766864 - }, - { - "biomes": 0.13770222265625, - "carvers": 0.34120021093749997, - "chunks": 256, - "noise": 1.0184424492187498, - "structures": 0.16421706640625, - "surface": 3.4411157734375, - "threads": 1, - "wall_ms_chunk": 5.11496834375, - "version": "baseline", - "repeat": -1, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 94.76, - "combined_ms_chunk": 5.48512459375, - "terrain_cpu_ms_chunk": 5.0, - "process_user_s": 3.237969, - "process_system_s": 0.292751, - "peak_rss_kib": 767136 - }, - { - "biomes": 0.14043531640625, - "carvers": 0.36789036328124997, - "chunks": 256, - "noise": 1.0311117695312502, - "structures": 0.1879942578125, - "surface": 3.45619487109375, - "threads": 1, - "wall_ms_chunk": 5.1973033515625, - "version": "baseline", - "repeat": 0, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 106.01, - "combined_ms_chunk": 5.6114049140625, - "terrain_cpu_ms_chunk": 5.1, - "process_user_s": 3.288137, - "process_system_s": 0.292925, - "peak_rss_kib": 767880 - }, - { - "biomes": 0.13367842578125, - "carvers": 0.32905148828124997, - "chunks": 256, - "noise": 0.9275919218750001, - "structures": 0.1689590859375, - "surface": 3.271626328125, - "threads": 1, - "wall_ms_chunk": 4.8434115507812505, - "version": "candidate", - "repeat": 0, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 95.18, - "combined_ms_chunk": 5.215208425781251, - "terrain_cpu_ms_chunk": 4.8, - "process_user_s": 3.13267, - "process_system_s": 0.308797, - "peak_rss_kib": 766812 - }, - { - "biomes": 0.1442604140625, - "carvers": 0.3536337109375, - "chunks": 256, - "noise": 0.94859876953125, - "structures": 0.16619854296875, - "surface": 3.32388272265625, - "threads": 1, - "wall_ms_chunk": 4.94954616796875, - "version": "candidate", - "repeat": 1, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 99.28, - "combined_ms_chunk": 5.33735866796875, - "terrain_cpu_ms_chunk": 5.0, - "process_user_s": 3.202046, - "process_system_s": 0.27005799999999996, - "peak_rss_kib": 767156 - }, - { - "biomes": 0.1327677578125, - "carvers": 0.31560908593750003, - "chunks": 256, - "noise": 0.981517796875, - "structures": 0.1627437578125, - "surface": 3.31767320703125, - "threads": 1, - "wall_ms_chunk": 4.92221994140625, - "version": "baseline", - "repeat": 1, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 93.72, - "combined_ms_chunk": 5.28831369140625, - "terrain_cpu_ms_chunk": 4.9, - "process_user_s": 3.222069, - "process_system_s": 0.28943599999999997, - "peak_rss_kib": 767164 - }, - { - "biomes": 0.14044899609375, - "carvers": 0.32908183203125, - "chunks": 256, - "noise": 0.99479630078125, - "structures": 0.1701334296875, - "surface": 3.353920703125, - "threads": 1, - "wall_ms_chunk": 5.00086766796875, - "version": "baseline", - "repeat": 2, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 97.48, - "combined_ms_chunk": 5.38164891796875, - "terrain_cpu_ms_chunk": 5.0, - "process_user_s": 3.211094, - "process_system_s": 0.29006299999999996, - "peak_rss_kib": 767300 - }, - { - "biomes": 0.13222405078125, - "carvers": 0.32014446484375, - "chunks": 256, - "noise": 0.91041137890625, - "structures": 0.1617991640625, - "surface": 3.2442935703125, - "threads": 1, - "wall_ms_chunk": 4.7805691328124995, - "version": "candidate", - "repeat": 2, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 95.14, - "combined_ms_chunk": 5.1522097578125, - "terrain_cpu_ms_chunk": 4.8, - "process_user_s": 3.170429, - "process_system_s": 0.259195, - "peak_rss_kib": 767272 - }, - { - "biomes": 0.131531078125, - "carvers": 0.34777549609374997, - "chunks": 256, - "noise": 0.91020738671875, - "structures": 0.15469105468750002, - "surface": 3.5488251796875, - "threads": 1, - "wall_ms_chunk": 5.104357375, - "version": "candidate", - "repeat": 3, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 102.04, - "combined_ms_chunk": 5.502951125, - "terrain_cpu_ms_chunk": 5.1, - "process_user_s": 3.283283, - "process_system_s": 0.280034, - "peak_rss_kib": 767032 - }, - { - "biomes": 0.13133595703125, - "carvers": 0.3165892109375, - "chunks": 256, - "noise": 0.9789275859375, - "structures": 0.15596676953125, - "surface": 3.317108703125, - "threads": 1, - "wall_ms_chunk": 4.911962765625, - "version": "baseline", - "repeat": 3, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 95.35, - "combined_ms_chunk": 5.284423703124999, - "terrain_cpu_ms_chunk": 4.9, - "process_user_s": 3.207738, - "process_system_s": 0.28896099999999997, - "peak_rss_kib": 767416 - }, - { - "biomes": 0.13852409375000002, - "carvers": 0.355382328125, - "chunks": 256, - "noise": 1.0088826171874998, - "structures": 0.17478964453124998, - "surface": 3.41303796484375, - "threads": 1, - "wall_ms_chunk": 5.103556578125, - "version": "baseline", - "repeat": 4, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 98.59, - "combined_ms_chunk": 5.488673765624999, - "terrain_cpu_ms_chunk": 5.0, - "process_user_s": 3.277378, - "process_system_s": 0.289952, - "peak_rss_kib": 767188 - }, - { - "biomes": 0.13389429687499999, - "carvers": 0.3274005, - "chunks": 256, - "noise": 0.92550525, - "structures": 0.1689537578125, - "surface": 3.24397930078125, - "threads": 1, - "wall_ms_chunk": 4.81162807421875, - "version": "candidate", - "repeat": 4, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 97.23, - "combined_ms_chunk": 5.19143276171875, - "terrain_cpu_ms_chunk": 4.8, - "process_user_s": 3.164104, - "process_system_s": 0.28493399999999997, - "peak_rss_kib": 768256 - }, - { - "biomes": 0.1527002578125, - "carvers": 0.33850889453125005, - "chunks": 256, - "noise": 0.96880138671875, - "structures": 0.46107213671875, - "surface": 3.5827278515625003, - "threads": 4, - "wall_ms_chunk": 1.3955010820312501, - "version": "candidate", - "repeat": -1, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 28.01, - "combined_ms_chunk": 1.50491514453125, - "terrain_cpu_ms_chunk": 5.5, - "process_user_s": 3.296587, - "process_system_s": 0.340603, - "peak_rss_kib": 808284 - }, - { - "biomes": 0.15443550390625, - "carvers": 0.3468451015625, - "chunks": 256, - "noise": 1.04827496484375, - "structures": 0.49296400390625, - "surface": 3.72401240625, - "threads": 4, - "wall_ms_chunk": 1.4611553164062498, - "version": "baseline", - "repeat": -1, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 27.33, - "combined_ms_chunk": 1.5679131289062498, - "terrain_cpu_ms_chunk": 5.7, - "process_user_s": 3.3905, - "process_system_s": 0.326855, - "peak_rss_kib": 807880 - }, - { - "biomes": 0.18705638671875, - "carvers": 0.4266077421875, - "chunks": 256, - "noise": 1.23844333984375, - "structures": 0.65067961328125, - "surface": 4.40769580078125, - "threads": 4, - "wall_ms_chunk": 1.7465659648437502, - "version": "baseline", - "repeat": 0, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 27.39, - "combined_ms_chunk": 1.85355815234375, - "terrain_cpu_ms_chunk": 6.8, - "process_user_s": 3.723568, - "process_system_s": 0.32867999999999997, - "peak_rss_kib": 809068 - }, - { - "biomes": 0.15933355859375, - "carvers": 0.35652209765625004, - "chunks": 256, - "noise": 0.9947946328124999, - "structures": 0.50791763671875, - "surface": 3.69153265234375, - "threads": 4, - "wall_ms_chunk": 1.4419126953124999, - "version": "candidate", - "repeat": 0, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 30.38, - "combined_ms_chunk": 1.5605845703124999, - "terrain_cpu_ms_chunk": 5.7, - "process_user_s": 3.433763, - "process_system_s": 0.34301499999999996, - "peak_rss_kib": 808348 - }, - { - "biomes": 0.15566733593749998, - "carvers": 0.34499826953125, - "chunks": 256, - "noise": 0.97438283984375, - "structures": 0.4888053125, - "surface": 3.62864861328125, - "threads": 4, - "wall_ms_chunk": 1.4162878085937498, - "version": "candidate", - "repeat": 1, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 30.46, - "combined_ms_chunk": 1.5352721835937497, - "terrain_cpu_ms_chunk": 5.5, - "process_user_s": 3.365262, - "process_system_s": 0.31118199999999996, - "peak_rss_kib": 808196 - }, - { - "biomes": 0.15832210546875, - "carvers": 0.34845234765625, - "chunks": 256, - "noise": 1.074776, - "structures": 0.5028568515624999, - "surface": 3.8337320781249997, - "threads": 4, - "wall_ms_chunk": 1.49890619140625, - "version": "baseline", - "repeat": 1, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 28.48, - "combined_ms_chunk": 1.61015619140625, - "terrain_cpu_ms_chunk": 5.9, - "process_user_s": 3.4558299999999997, - "process_system_s": 0.31953699999999996, - "peak_rss_kib": 808144 - }, - { - "biomes": 0.15250269531250002, - "carvers": 0.323113484375, - "chunks": 256, - "noise": 0.9971162070312499, - "structures": 0.46339493359375, - "surface": 3.57196819921875, - "threads": 4, - "wall_ms_chunk": 1.39574041796875, - "version": "baseline", - "repeat": 2, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 26.08, - "combined_ms_chunk": 1.49761541796875, - "terrain_cpu_ms_chunk": 5.5, - "process_user_s": 3.416411, - "process_system_s": 0.312585, - "peak_rss_kib": 808252 - }, - { - "biomes": 0.15030778125, - "carvers": 0.32873496874999997, - "chunks": 256, - "noise": 0.92966758984375, - "structures": 0.45305451171875, - "surface": 3.4792089062500002, - "threads": 4, - "wall_ms_chunk": 1.3537790625, - "version": "candidate", - "repeat": 2, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 27.36, - "combined_ms_chunk": 1.4606540625, - "terrain_cpu_ms_chunk": 5.3, - "process_user_s": 3.269746, - "process_system_s": 0.313003, - "peak_rss_kib": 808268 - }, - { - "biomes": 0.1519560703125, - "carvers": 0.3320248515625, - "chunks": 256, - "noise": 0.94876864453125, - "structures": 0.45117773828125, - "surface": 3.5063635781249998, - "threads": 4, - "wall_ms_chunk": 1.367371890625, - "version": "candidate", - "repeat": 3, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 27.15, - "combined_ms_chunk": 1.473426578125, - "terrain_cpu_ms_chunk": 5.3, - "process_user_s": 3.248692, - "process_system_s": 0.338281, - "peak_rss_kib": 808148 - }, - { - "biomes": 0.1506245234375, - "carvers": 0.31850793359375, - "chunks": 256, - "noise": 0.9919948710937501, - "structures": 0.4453575, - "surface": 3.50541282421875, - "threads": 4, - "wall_ms_chunk": 1.37180578125, - "version": "baseline", - "repeat": 3, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 26.77, - "combined_ms_chunk": 1.47637609375, - "terrain_cpu_ms_chunk": 5.5, - "process_user_s": 3.301759, - "process_system_s": 0.322942, - "peak_rss_kib": 811232 - }, - { - "biomes": 0.14507573046875002, - "carvers": 0.31960434765625, - "chunks": 256, - "noise": 0.9979337929687501, - "structures": 0.47951465625, - "surface": 3.54853605859375, - "threads": 4, - "wall_ms_chunk": 1.3906834335937501, - "version": "baseline", - "repeat": 4, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 26.65, - "combined_ms_chunk": 1.49478499609375, - "terrain_cpu_ms_chunk": 5.5, - "process_user_s": 3.292158, - "process_system_s": 0.339582, - "peak_rss_kib": 808032 - }, - { - "biomes": 0.15106661328124998, - "carvers": 0.32569064453125, - "chunks": 256, - "noise": 0.932149890625, - "structures": 0.43740817578124996, - "surface": 3.4441070625, - "threads": 4, - "wall_ms_chunk": 1.34138928125, - "version": "candidate", - "repeat": 4, - "dimension": "the_nether", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_nether", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 26.57, - "combined_ms_chunk": 1.4451783437499999, - "terrain_cpu_ms_chunk": 5.3, - "process_user_s": 3.287765, - "process_system_s": 0.293301, - "peak_rss_kib": 808148 - }, - { - "biomes": 0.0671063125, - "carvers": 0.0077883203124999995, - "chunks": 256, - "noise": 0.5764382734375001, - "structures": 0.013758625, - "surface": 0.3345908515625, - "threads": 1, - "wall_ms_chunk": 1.02945684375, - "version": "candidate", - "repeat": -1, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 18.83, - "combined_ms_chunk": 1.10301153125, - "terrain_cpu_ms_chunk": 1.0, - "process_user_s": 1.701378, - "process_system_s": 0.28632199999999997, - "peak_rss_kib": 758568 - }, - { - "biomes": 0.06498396484375, - "carvers": 0.00752325, - "chunks": 256, - "noise": 0.6174956406250001, - "structures": 0.01201401953125, - "surface": 0.323810515625, - "threads": 1, - "wall_ms_chunk": 1.05527485546875, - "version": "baseline", - "repeat": -1, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 18.24, - "combined_ms_chunk": 1.1265248554687501, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.7748249999999999, - "process_system_s": 0.25675, - "peak_rss_kib": 758124 - }, - { - "biomes": 0.07141799609375, - "carvers": 0.00903455078125, - "chunks": 256, - "noise": 0.6907069257812499, - "structures": 0.0181156796875, - "surface": 0.359480328125, - "threads": 1, - "wall_ms_chunk": 1.1820680859375001, - "version": "baseline", - "repeat": 0, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 18.97, - "combined_ms_chunk": 1.2561696484375, - "terrain_cpu_ms_chunk": 1.2, - "process_user_s": 1.7840690000000001, - "process_system_s": 0.277493, - "peak_rss_kib": 758420 - }, - { - "biomes": 0.066747515625, - "carvers": 0.007638148437500001, - "chunks": 256, - "noise": 0.56488630859375, - "structures": 0.0124629375, - "surface": 0.33111641015625, - "threads": 1, - "wall_ms_chunk": 1.01261229296875, - "version": "candidate", - "repeat": 0, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 18.16, - "combined_ms_chunk": 1.08354979296875, - "terrain_cpu_ms_chunk": 1.0, - "process_user_s": 1.769447, - "process_system_s": 0.283722, - "peak_rss_kib": 758228 - }, - { - "biomes": 0.0701680859375, - "carvers": 0.00899228515625, - "chunks": 256, - "noise": 0.6042903749999999, - "structures": 0.015031363281250001, - "surface": 0.34355565234374996, - "threads": 1, - "wall_ms_chunk": 1.0740906406250001, - "version": "candidate", - "repeat": 1, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 19.89, - "combined_ms_chunk": 1.151785953125, - "terrain_cpu_ms_chunk": 1.0, - "process_user_s": 1.789218, - "process_system_s": 0.29277, - "peak_rss_kib": 758388 - }, - { - "biomes": 0.06466825390625, - "carvers": 0.007814542968750001, - "chunks": 256, - "noise": 0.62916758203125, - "structures": 0.0120749296875, - "surface": 0.3290578203125, - "threads": 1, - "wall_ms_chunk": 1.07254237890625, - "version": "baseline", - "repeat": 1, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 18.73, - "combined_ms_chunk": 1.14570644140625, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.739302, - "process_system_s": 0.297614, - "peak_rss_kib": 758244 - }, - { - "biomes": 0.06643014453125, - "carvers": 0.00825007421875, - "chunks": 256, - "noise": 0.6371068046875, - "structures": 0.01243977734375, - "surface": 0.3337400390625, - "threads": 1, - "wall_ms_chunk": 1.08787355859375, - "version": "baseline", - "repeat": 2, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 18.87, - "combined_ms_chunk": 1.16158449609375, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.745915, - "process_system_s": 0.284339, - "peak_rss_kib": 758056 - }, - { - "biomes": 0.06733269140625, - "carvers": 0.0078622109375, - "chunks": 256, - "noise": 0.5949901171875001, - "structures": 0.01371746484375, - "surface": 0.34096759374999996, - "threads": 1, - "wall_ms_chunk": 1.05490283984375, - "version": "candidate", - "repeat": 2, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 19.0, - "combined_ms_chunk": 1.12912158984375, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.721397, - "process_system_s": 0.296788, - "peak_rss_kib": 758356 - }, - { - "biomes": 0.06638907031249999, - "carvers": 0.00807542578125, - "chunks": 256, - "noise": 0.588318046875, - "structures": 0.013528765625, - "surface": 0.34993033984375, - "threads": 1, - "wall_ms_chunk": 1.05624013671875, - "version": "candidate", - "repeat": 3, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 18.39, - "combined_ms_chunk": 1.12807607421875, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.731978, - "process_system_s": 0.28312899999999996, - "peak_rss_kib": 758416 - }, - { - "biomes": 0.07069091015625, - "carvers": 0.008381, - "chunks": 256, - "noise": 0.68040130859375, - "structures": 0.01436361328125, - "surface": 0.3577211015625, - "threads": 1, - "wall_ms_chunk": 1.1632215898437501, - "version": "baseline", - "repeat": 3, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 17.0, - "combined_ms_chunk": 1.2296278398437501, - "terrain_cpu_ms_chunk": 1.2, - "process_user_s": 1.752325, - "process_system_s": 0.289176, - "peak_rss_kib": 758588 - }, - { - "biomes": 0.06355004296875, - "carvers": 0.00738161328125, - "chunks": 256, - "noise": 0.6265852265625, - "structures": 0.01202754296875, - "surface": 0.32790377734375004, - "threads": 1, - "wall_ms_chunk": 1.0667404101562499, - "version": "baseline", - "repeat": 4, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 19.8, - "combined_ms_chunk": 1.14408416015625, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.741118, - "process_system_s": 0.275049, - "peak_rss_kib": 758388 - }, - { - "biomes": 0.063774796875, - "carvers": 0.00733364453125, - "chunks": 256, - "noise": 0.56107108203125, - "structures": 0.012083515625000001, - "surface": 0.33038421093750003, - "threads": 1, - "wall_ms_chunk": 1.00400650390625, - "version": "candidate", - "repeat": 4, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 17.54, - "combined_ms_chunk": 1.07252212890625, - "terrain_cpu_ms_chunk": 1.0, - "process_user_s": 1.701422, - "process_system_s": 0.300386, - "peak_rss_kib": 758300 - }, - { - "biomes": 0.07347773437499999, - "carvers": 0.008016730468749999, - "chunks": 256, - "noise": 0.582110890625, - "structures": 0.013846804687499999, - "surface": 0.33808323828125003, - "threads": 4, - "wall_ms_chunk": 0.2648614609375, - "version": "candidate", - "repeat": -1, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 7.15, - "combined_ms_chunk": 0.29279114843750004, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.730079, - "process_system_s": 0.28420799999999996, - "peak_rss_kib": 765316 - }, - { - "biomes": 0.07508191015625, - "carvers": 0.008719144531249999, - "chunks": 256, - "noise": 0.64692200390625, - "structures": 0.01468698046875, - "surface": 0.33883886328124996, - "threads": 4, - "wall_ms_chunk": 0.28209423828125, - "version": "baseline", - "repeat": -1, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 7.86, - "combined_ms_chunk": 0.31279736328125, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.743428, - "process_system_s": 0.280487, - "peak_rss_kib": 764624 - }, - { - "biomes": 0.06968803515625, - "carvers": 0.007994781250000001, - "chunks": 256, - "noise": 0.6300331328125001, - "structures": 0.015125671875, - "surface": 0.32591112109375003, - "threads": 4, - "wall_ms_chunk": 0.272614421875, - "version": "baseline", - "repeat": 0, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 6.68, - "combined_ms_chunk": 0.298708171875, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.71976, - "process_system_s": 0.290218, - "peak_rss_kib": 765464 - }, - { - "biomes": 0.07005374609375001, - "carvers": 0.0081262890625, - "chunks": 256, - "noise": 0.5717398828125, - "structures": 0.016438484375, - "surface": 0.33273578125, - "threads": 4, - "wall_ms_chunk": 0.26043392187500003, - "version": "candidate", - "repeat": 0, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 7.14, - "combined_ms_chunk": 0.28832454687500003, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.7035689999999999, - "process_system_s": 0.290498, - "peak_rss_kib": 764612 - }, - { - "biomes": 0.0744749453125, - "carvers": 0.008645933593749999, - "chunks": 256, - "noise": 0.5800458320312499, - "structures": 0.01345557421875, - "surface": 0.33882638671875, - "threads": 4, - "wall_ms_chunk": 0.26400750781250004, - "version": "candidate", - "repeat": 1, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 7.26, - "combined_ms_chunk": 0.29236688281250006, - "terrain_cpu_ms_chunk": 1.0, - "process_user_s": 1.697073, - "process_system_s": 0.29665199999999997, - "peak_rss_kib": 764000 - }, - { - "biomes": 0.07363709375000001, - "carvers": 0.0083119609375, - "chunks": 256, - "noise": 0.63874593359375, - "structures": 0.01635375, - "surface": 0.33684059765625, - "threads": 4, - "wall_ms_chunk": 0.27894697265625, - "version": "baseline", - "repeat": 1, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 6.99, - "combined_ms_chunk": 0.30625166015625, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.758769, - "process_system_s": 0.280622, - "peak_rss_kib": 764520 - }, - { - "biomes": 0.07276028125, - "carvers": 0.007958566406250001, - "chunks": 256, - "noise": 0.63267321484375, - "structures": 0.01451640234375, - "surface": 0.328659421875, - "threads": 4, - "wall_ms_chunk": 0.2756653046875, - "version": "baseline", - "repeat": 2, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 6.95, - "combined_ms_chunk": 0.3028137421875, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.717258, - "process_system_s": 0.30649, - "peak_rss_kib": 762980 - }, - { - "biomes": 0.06874769140625, - "carvers": 0.008313375000000001, - "chunks": 256, - "noise": 0.56370428125, - "structures": 0.0149923125, - "surface": 0.333879390625, - "threads": 4, - "wall_ms_chunk": 0.25811795703125, - "version": "candidate", - "repeat": 2, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 7.21, - "combined_ms_chunk": 0.28628201953125, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.7176969999999998, - "process_system_s": 0.282541, - "peak_rss_kib": 764900 - }, - { - "biomes": 0.07429515625000001, - "carvers": 0.00880516015625, - "chunks": 256, - "noise": 0.5630588789062501, - "structures": 0.01390212890625, - "surface": 0.33520016796874996, - "threads": 4, - "wall_ms_chunk": 0.25935823046875, - "version": "candidate", - "repeat": 3, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 7.23, - "combined_ms_chunk": 0.28760041796875, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.7362229999999998, - "process_system_s": 0.265471, - "peak_rss_kib": 763552 - }, - { - "biomes": 0.07121080078125, - "carvers": 0.008269808593749999, - "chunks": 256, - "noise": 0.630934875, - "structures": 0.01303702734375, - "surface": 0.32732298046874997, - "threads": 4, - "wall_ms_chunk": 0.2733938359375, - "version": "baseline", - "repeat": 3, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 7.44, - "combined_ms_chunk": 0.3024563359375, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.73318, - "process_system_s": 0.281688, - "peak_rss_kib": 765080 - }, - { - "biomes": 0.07286602734375, - "carvers": 0.0094055390625, - "chunks": 256, - "noise": 0.6326262851562501, - "structures": 0.015354234375000001, - "surface": 0.3275690078125, - "threads": 4, - "wall_ms_chunk": 0.27526291796875, - "version": "baseline", - "repeat": 4, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 7.48, - "combined_ms_chunk": 0.30448166796875004, - "terrain_cpu_ms_chunk": 1.1, - "process_user_s": 1.753609, - "process_system_s": 0.268682, - "peak_rss_kib": 765864 - }, - { - "biomes": 0.07774158984375, - "carvers": 0.01080370703125, - "chunks": 256, - "noise": 0.56824108203125, - "structures": 0.014245484375, - "surface": 0.33717660546875, - "threads": 4, - "wall_ms_chunk": 0.26269167578124997, - "version": "candidate", - "repeat": 4, - "dimension": "the_end", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "4", - "--dimension", - "the_end", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 7.32, - "combined_ms_chunk": 0.29128542578124994, - "terrain_cpu_ms_chunk": 1.0, - "process_user_s": 1.738999, - "process_system_s": 0.28302499999999997, - "peak_rss_kib": 765396 - }, - { - "biomes": 0.39971288671875, - "carvers": 0.37882032812500005, - "chunks": 256, - "noise": 4.8697074296875, - "structures": 0.33850826562499997, - "surface": 3.72384066796875, - "threads": 1, - "wall_ms_chunk": 9.77845378125, - "version": "candidate", - "repeat": -1, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 265.0, - "combined_ms_chunk": 10.81361003125, - "terrain_cpu_ms_chunk": 9.6, - "process_user_s": 7.96157, - "process_system_s": 0.30721, - "peak_rss_kib": 772956 - }, - { - "biomes": 0.4043960390625, - "carvers": 0.38978531250000004, - "chunks": 256, - "noise": 5.4159295078125, - "structures": 0.32797564062499995, - "surface": 4.7684787148437495, - "threads": 1, - "wall_ms_chunk": 11.375514890625, - "version": "baseline", - "repeat": -1, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 261.84, - "combined_ms_chunk": 12.398327390625, - "terrain_cpu_ms_chunk": 11.2, - "process_user_s": 8.549963, - "process_system_s": 0.30344, - "peak_rss_kib": 772996 - }, - { - "biomes": 0.3896178828125, - "carvers": 0.38304418359375, - "chunks": 256, - "noise": 5.459892589843751, - "structures": 0.34342648828125, - "surface": 4.773840847656251, - "threads": 1, - "wall_ms_chunk": 11.417097730468749, - "version": "baseline", - "repeat": 0, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 260.93, - "combined_ms_chunk": 12.436355542968748, - "terrain_cpu_ms_chunk": 11.2, - "process_user_s": 8.548033, - "process_system_s": 0.304259, - "peak_rss_kib": 773404 - }, - { - "biomes": 0.41971255859375, - "carvers": 0.49553131249999993, - "chunks": 256, - "noise": 5.19782119921875, - "structures": 0.35330408984375, - "surface": 3.9784396718750004, - "threads": 1, - "wall_ms_chunk": 10.520365386718751, - "version": "candidate", - "repeat": 0, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 262.28, - "combined_ms_chunk": 11.54489663671875, - "terrain_cpu_ms_chunk": 10.3, - "process_user_s": 8.170402, - "process_system_s": 0.284618, - "peak_rss_kib": 772596 - }, - { - "biomes": 0.37788180078125, - "carvers": 0.385858296875, - "chunks": 256, - "noise": 4.9163363046874995, - "structures": 0.32262048828125, - "surface": 3.7152747382812503, - "threads": 1, - "wall_ms_chunk": 9.78610121484375, - "version": "candidate", - "repeat": 1, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 273.49, - "combined_ms_chunk": 10.85442152734375, - "terrain_cpu_ms_chunk": 9.7, - "process_user_s": 7.974602, - "process_system_s": 0.291122, - "peak_rss_kib": 772916 - }, - { - "biomes": 0.3835026796875, - "carvers": 0.37746702734375004, - "chunks": 256, - "noise": 5.44076811328125, - "structures": 0.32720519531250003, - "surface": 4.7373909296875, - "threads": 1, - "wall_ms_chunk": 11.33398644140625, - "version": "baseline", - "repeat": 1, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 261.83, - "combined_ms_chunk": 12.35675987890625, - "terrain_cpu_ms_chunk": 11.2, - "process_user_s": 8.593916, - "process_system_s": 0.29184, - "peak_rss_kib": 773316 - }, - { - "biomes": 0.3830595625, - "carvers": 0.37499496875, - "chunks": 256, - "noise": 5.3896623671875, - "structures": 0.32856785937500005, - "surface": 4.68694290625, - "threads": 1, - "wall_ms_chunk": 11.230343640625, - "version": "baseline", - "repeat": 2, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 266.3, - "combined_ms_chunk": 12.270578015625, - "terrain_cpu_ms_chunk": 11.2, - "process_user_s": 8.550168, - "process_system_s": 0.28749199999999997, - "peak_rss_kib": 773060 - }, - { - "biomes": 0.382181609375, - "carvers": 0.38298096875, - "chunks": 256, - "noise": 4.92111234765625, - "structures": 0.3278383359375, - "surface": 3.7391728828125, - "threads": 1, - "wall_ms_chunk": 9.8204977578125, - "version": "candidate", - "repeat": 2, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 265.14, - "combined_ms_chunk": 10.8562008828125, - "terrain_cpu_ms_chunk": 9.7, - "process_user_s": 7.943048, - "process_system_s": 0.322827, - "peak_rss_kib": 772968 - }, - { - "biomes": 0.37968522265625, - "carvers": 0.3860081796875, - "chunks": 256, - "noise": 4.83220694921875, - "structures": 0.33047573046875, - "surface": 3.702097984375, - "threads": 1, - "wall_ms_chunk": 9.698412828124999, - "version": "candidate", - "repeat": 3, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 265.32, - "combined_ms_chunk": 10.734819078125, - "terrain_cpu_ms_chunk": 9.5, - "process_user_s": 7.946326, - "process_system_s": 0.279924, - "peak_rss_kib": 772868 - }, - { - "biomes": 0.38765451171875, - "carvers": 0.38096083203125003, - "chunks": 256, - "noise": 5.3804188359375, - "structures": 0.3274572890625, - "surface": 4.7524695390625, - "threads": 1, - "wall_ms_chunk": 11.29669141796875, - "version": "baseline", - "repeat": 3, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 262.62, - "combined_ms_chunk": 12.32255079296875, - "terrain_cpu_ms_chunk": 11.1, - "process_user_s": 8.504037, - "process_system_s": 0.286807, - "peak_rss_kib": 773060 - }, - { - "biomes": 0.38940237890624996, - "carvers": 0.403175671875, - "chunks": 256, - "noise": 5.408727453125, - "structures": 0.33668133203125, - "surface": 4.73514887109375, - "threads": 1, - "wall_ms_chunk": 11.34147396875, - "version": "baseline", - "repeat": 4, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 285.83, - "combined_ms_chunk": 12.45799740625, - "terrain_cpu_ms_chunk": 11.2, - "process_user_s": 8.59844, - "process_system_s": 0.29486799999999996, - "peak_rss_kib": 772728 - }, - { - "biomes": 0.3826321171875, - "carvers": 0.37871958984375, - "chunks": 256, - "noise": 4.8817727968749995, - "structures": 0.33016451953125, - "surface": 3.6934999531250003, - "threads": 1, - "wall_ms_chunk": 9.73411325, - "version": "candidate", - "repeat": 4, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 265.2, - "combined_ms_chunk": 10.77005075, - "terrain_cpu_ms_chunk": 9.6, - "process_user_s": 8.034993, - "process_system_s": 0.298956, - "peak_rss_kib": 772992 - }, - { - "biomes": 0.45672900390625, - "carvers": 0.39450216796875, - "chunks": 256, - "noise": 4.92153640234375, - "structures": 0.7476218554687499, - "surface": 3.9057192890624997, - "threads": 4, - "wall_ms_chunk": 2.6448442617187498, - "version": "candidate", - "repeat": -1, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 75.38, - "combined_ms_chunk": 2.9392973867187497, - "terrain_cpu_ms_chunk": 10.4, - "process_user_s": 8.167949, - "process_system_s": 0.29528699999999997, - "peak_rss_kib": 790580 - }, - { - "biomes": 0.49467384765625005, - "carvers": 0.389857765625, - "chunks": 256, - "noise": 5.44034409765625, - "structures": 0.77604354296875, - "surface": 4.922074714843751, - "threads": 4, - "wall_ms_chunk": 3.0404438671875003, - "version": "baseline", - "repeat": -1, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 76.75, - "combined_ms_chunk": 3.3402485546875003, - "terrain_cpu_ms_chunk": 12.1, - "process_user_s": 8.82059, - "process_system_s": 0.28219099999999997, - "peak_rss_kib": 791200 - }, - { - "biomes": 0.47668708984375, - "carvers": 0.38581653515625003, - "chunks": 256, - "noise": 5.48101804296875, - "structures": 0.771866640625, - "surface": 4.9356213671875, - "threads": 4, - "wall_ms_chunk": 3.0581778515624998, - "version": "baseline", - "repeat": 0, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 76.66, - "combined_ms_chunk": 3.3576309765624996, - "terrain_cpu_ms_chunk": 12.1, - "process_user_s": 8.775314999999999, - "process_system_s": 0.299074, - "peak_rss_kib": 791584 - }, - { - "biomes": 0.44986469921875005, - "carvers": 0.39071975390625, - "chunks": 256, - "noise": 4.8962180859375, - "structures": 0.75393650390625, - "surface": 3.863450953125, - "threads": 4, - "wall_ms_chunk": 2.6212423828125, - "version": "candidate", - "repeat": 0, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 75.84, - "combined_ms_chunk": 2.9174923828125, - "terrain_cpu_ms_chunk": 10.4, - "process_user_s": 8.156316, - "process_system_s": 0.31522, - "peak_rss_kib": 791264 - }, - { - "biomes": 0.44110676953125, - "carvers": 0.39609016796875, - "chunks": 256, - "noise": 4.94947952734375, - "structures": 0.751817375, - "surface": 3.90770424609375, - "threads": 4, - "wall_ms_chunk": 2.6404325039062497, - "version": "candidate", - "repeat": 1, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 76.3, - "combined_ms_chunk": 2.9384793789062496, - "terrain_cpu_ms_chunk": 10.5, - "process_user_s": 8.211497, - "process_system_s": 0.306876, - "peak_rss_kib": 791340 - }, - { - "biomes": 0.492835953125, - "carvers": 0.398993609375, - "chunks": 256, - "noise": 5.56470246484375, - "structures": 0.76127405078125, - "surface": 5.0091022578125, - "threads": 4, - "wall_ms_chunk": 3.0937040703124996, - "version": "baseline", - "repeat": 1, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 76.15, - "combined_ms_chunk": 3.3911650078124995, - "terrain_cpu_ms_chunk": 12.3, - "process_user_s": 8.793621, - "process_system_s": 0.307699, - "peak_rss_kib": 791548 - }, - { - "biomes": 0.47851093359375, - "carvers": 0.3901752578125, - "chunks": 256, - "noise": 5.4432403125, - "structures": 0.78050973828125, - "surface": 4.9168907421875, - "threads": 4, - "wall_ms_chunk": 3.04131756640625, - "version": "baseline", - "repeat": 2, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 75.53, - "combined_ms_chunk": 3.33635662890625, - "terrain_cpu_ms_chunk": 12.0, - "process_user_s": 8.759123, - "process_system_s": 0.304816, - "peak_rss_kib": 791656 - }, - { - "biomes": 0.48506514453125, - "carvers": 0.4126526015625, - "chunks": 256, - "noise": 5.0355008671874995, - "structures": 0.7806489414062501, - "surface": 3.9920479570312497, - "threads": 4, - "wall_ms_chunk": 2.71386270703125, - "version": "candidate", - "repeat": 2, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 76.68, - "combined_ms_chunk": 3.0133939570312505, - "terrain_cpu_ms_chunk": 10.7, - "process_user_s": 8.233895, - "process_system_s": 0.338806, - "peak_rss_kib": 791540 - }, - { - "biomes": 0.443612796875, - "carvers": 0.3934000390625, - "chunks": 256, - "noise": 4.9066040546875, - "structures": 0.7639770234375, - "surface": 3.8894710195312503, - "threads": 4, - "wall_ms_chunk": 2.6345491601562503, - "version": "candidate", - "repeat": 3, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 76.93, - "combined_ms_chunk": 2.93505697265625, - "terrain_cpu_ms_chunk": 10.4, - "process_user_s": 8.192035, - "process_system_s": 0.30294499999999996, - "peak_rss_kib": 791400 - }, - { - "biomes": 0.48976614453125, - "carvers": 0.39066100390624997, - "chunks": 256, - "noise": 5.5047845, - "structures": 0.75296558203125, - "surface": 4.90097797265625, - "threads": 4, - "wall_ms_chunk": 3.0425965546875, - "version": "baseline", - "repeat": 3, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 77.6, - "combined_ms_chunk": 3.3457215546875, - "terrain_cpu_ms_chunk": 12.0, - "process_user_s": 8.767544000000001, - "process_system_s": 0.31026699999999996, - "peak_rss_kib": 791136 - }, - { - "biomes": 0.47240654296875, - "carvers": 0.39175819921875, - "chunks": 256, - "noise": 5.5244557734375, - "structures": 0.76422690625, - "surface": 4.98771640234375, - "threads": 4, - "wall_ms_chunk": 3.07253827734375, - "version": "baseline", - "repeat": 4, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 76.33, - "combined_ms_chunk": 3.37070233984375, - "terrain_cpu_ms_chunk": 12.1, - "process_user_s": 8.784185, - "process_system_s": 0.320637, - "peak_rss_kib": 791064 - }, - { - "biomes": 0.48387860546875, - "carvers": 0.387594328125, - "chunks": 256, - "noise": 4.9102566562500005, - "structures": 0.77066383203125, - "surface": 3.87325848828125, - "threads": 4, - "wall_ms_chunk": 2.639180359375, - "version": "candidate", - "repeat": 4, - "dimension": "overworld", - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "-1", - "--size", - "16", - "--threads", - "4", - "--dimension", - "overworld", - "--center", - "32", - "-32" - ], - "decorated": 196, - "decoration_ms": 77.27, - "combined_ms_chunk": 2.941016296875, - "terrain_cpu_ms_chunk": 10.4, - "process_user_s": 8.217568, - "process_system_s": 0.319042, - "peak_rss_kib": 791800 - }, - { - "biomes": 0.4438934609375, - "carvers": 0.3821054375, - "chunks": 256, - "noise": 5.284275082031249, - "structures": 11.990167101562498, - "surface": 3.3531185156250003, - "threads": 1, - "wall_ms_chunk": 21.5022511875, - "version": "candidate", - "repeat": -1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 510.49, - "combined_ms_chunk": 23.49635275, - "terrain_cpu_ms_chunk": 21.4, - "process_user_s": 7.456922, - "process_system_s": 0.313501, - "peak_rss_kib": 791760 - }, - { - "biomes": 0.44742400390625, - "carvers": 0.37514680078125, - "chunks": 256, - "noise": 5.7688955546875, - "structures": 12.134246640625001, - "surface": 4.45254106640625, - "threads": 1, - "wall_ms_chunk": 23.22758416015625, - "version": "baseline", - "repeat": -1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 497.2, - "combined_ms_chunk": 25.16977166015625, - "terrain_cpu_ms_chunk": 23.0, - "process_user_s": 7.860362, - "process_system_s": 0.304575, - "peak_rss_kib": 791708 - }, - { - "biomes": 0.42875092578125, - "carvers": 0.37716256249999996, - "chunks": 256, - "noise": 5.77808380859375, - "structures": 11.944554960937499, - "surface": 4.46725260546875, - "threads": 1, - "wall_ms_chunk": 23.04948128515625, - "version": "baseline", - "repeat": 0, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 490.6, - "combined_ms_chunk": 24.965887535156252, - "terrain_cpu_ms_chunk": 22.9, - "process_user_s": 7.80915, - "process_system_s": 0.32467599999999996, - "peak_rss_kib": 791460 - }, - { - "biomes": 0.42428901171875, - "carvers": 0.37540554687500005, - "chunks": 256, - "noise": 5.1450133359375005, - "structures": 11.946391109375, - "surface": 3.27860996875, - "threads": 1, - "wall_ms_chunk": 21.21845773046875, - "version": "candidate", - "repeat": 0, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 498.43, - "combined_ms_chunk": 23.16544991796875, - "terrain_cpu_ms_chunk": 21.1, - "process_user_s": 7.407715, - "process_system_s": 0.273721, - "peak_rss_kib": 791520 - }, - { - "biomes": 0.43424169921875, - "carvers": 0.38796527734375, - "chunks": 256, - "noise": 5.2583853203125, - "structures": 12.0325921015625, - "surface": 3.33998081640625, - "threads": 1, - "wall_ms_chunk": 21.5024232734375, - "version": "candidate", - "repeat": 1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 500.76, - "combined_ms_chunk": 23.4585170234375, - "terrain_cpu_ms_chunk": 21.3, - "process_user_s": 7.458846, - "process_system_s": 0.29436, - "peak_rss_kib": 791548 - }, - { - "biomes": 0.42952815234375, - "carvers": 0.3797641328125, - "chunks": 256, - "noise": 5.7598273828124995, - "structures": 11.93062982421875, - "surface": 4.43812640625, - "threads": 1, - "wall_ms_chunk": 22.98697991015625, - "version": "baseline", - "repeat": 1, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 502.62, - "combined_ms_chunk": 24.95033928515625, - "terrain_cpu_ms_chunk": 22.9, - "process_user_s": 7.833855, - "process_system_s": 0.292247, - "peak_rss_kib": 791716 - }, - { - "biomes": 0.44959835546875, - "carvers": 0.3846098828125, - "chunks": 256, - "noise": 5.81859017578125, - "structures": 12.029473570312499, - "surface": 4.49263651171875, - "threads": 1, - "wall_ms_chunk": 23.22414640234375, - "version": "baseline", - "repeat": 2, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 491.88, - "combined_ms_chunk": 25.14555265234375, - "terrain_cpu_ms_chunk": 23.1, - "process_user_s": 7.897718, - "process_system_s": 0.27303499999999997, - "peak_rss_kib": 791336 - }, - { - "biomes": 0.4278602734375, - "carvers": 0.39432846484375, - "chunks": 256, - "noise": 5.247983679687501, - "structures": 12.038747214843749, - "surface": 3.3149803984375, - "threads": 1, - "wall_ms_chunk": 21.47302998828125, - "version": "candidate", - "repeat": 2, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 505.07, - "combined_ms_chunk": 23.44595967578125, - "terrain_cpu_ms_chunk": 21.4, - "process_user_s": 7.454884, - "process_system_s": 0.30172299999999996, - "peak_rss_kib": 791520 - }, - { - "biomes": 0.42846523046874996, - "carvers": 0.37643353515625, - "chunks": 256, - "noise": 5.17840891796875, - "structures": 12.043128320312501, - "surface": 3.32858220703125, - "threads": 1, - "wall_ms_chunk": 21.403842031249997, - "version": "candidate", - "repeat": 3, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 508.55, - "combined_ms_chunk": 23.390365468749998, - "terrain_cpu_ms_chunk": 21.3, - "process_user_s": 7.450079, - "process_system_s": 0.297786, - "peak_rss_kib": 791884 - }, - { - "biomes": 0.42921571484375, - "carvers": 0.37685509765625, - "chunks": 256, - "noise": 5.72198735546875, - "structures": 11.996540234375, - "surface": 4.47116687890625, - "threads": 1, - "wall_ms_chunk": 23.04463336328125, - "version": "baseline", - "repeat": 3, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 496.53, - "combined_ms_chunk": 24.98420367578125, - "terrain_cpu_ms_chunk": 23.0, - "process_user_s": 7.820801, - "process_system_s": 0.31979799999999997, - "peak_rss_kib": 791720 - }, - { - "biomes": 0.44721841406249996, - "carvers": 0.3877746640625, - "chunks": 256, - "noise": 5.77484952734375, - "structures": 11.921109609375, - "surface": 4.48781470703125, - "threads": 1, - "wall_ms_chunk": 23.0679894375, - "version": "baseline", - "repeat": 4, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/baseline", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 509.94, - "combined_ms_chunk": 25.059942562499998, - "terrain_cpu_ms_chunk": 23.0, - "process_user_s": 7.884095, - "process_system_s": 0.287116, - "peak_rss_kib": 791700 - }, - { - "biomes": 0.436166515625, - "carvers": 0.3795897890625, - "chunks": 256, - "noise": 5.3008373359375005, - "structures": 11.988537335937501, - "surface": 3.35912442578125, - "threads": 1, - "wall_ms_chunk": 21.513234070312503, - "version": "candidate", - "repeat": 4, - "dimension": "overworld", - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "cmd": [ - "/usr/bin/python3", - "-c", - "import resource,subprocess,sys; r=subprocess.run(sys.argv[1:]); u=resource.getrusage(resource.RUSAGE_CHILDREN); print(f'RESOURCE {u.ru_utime} {u.ru_stime} {u.ru_maxrss}',file=sys.stderr); sys.exit(r.returncode)", - "/srv/bob-data/horizon-noise-aquifer-e477fa56/candidate", - "/srv/bob-data/horizon/.local/horizon-client/26.3", - "--seed", - "12345", - "--size", - "16", - "--threads", - "1", - "--dimension", - "overworld", - "--center", - "0", - "0" - ], - "decorated": 196, - "decoration_ms": 494.12, - "combined_ms_chunk": 23.443390320312503, - "terrain_cpu_ms_chunk": 21.3, - "process_user_s": 7.404893, - "process_system_s": 0.296075, - "peak_rss_kib": 791344 - } -] diff --git a/noise-aquifer-results/matrix-summary.json b/noise-aquifer-results/matrix-summary.json deleted file mode 100644 index f180e22a2..000000000 --- a/noise-aquifer-results/matrix-summary.json +++ /dev/null @@ -1,322 +0,0 @@ -[ - { - "dimension": "overworld", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 3.8379385546875, - "candidate": 3.4084368984375, - "reduction_percent": 11.190946653521179 - }, - "combined_ms_chunk": { - "baseline": 4.4051651171875, - "candidate": 3.98759199609375, - "reduction_percent": 9.479170700424318 - }, - "noise": { - "baseline": 5.83775421875, - "candidate": 5.32868657421875, - "reduction_percent": 8.720265113186848 - }, - "surface": { - "baseline": 4.51470572265625, - "candidate": 3.3764329531249997, - "reduction_percent": 25.21255735050526 - }, - "terrain_cpu_ms_chunk": { - "baseline": 15.2, - "candidate": 13.5, - "reduction_percent": 11.184210526315786 - }, - "peak_rss_kib": { - "baseline": 834016, - "candidate": 833440, - "reduction_percent": 0.06906342324367878 - } - }, - { - "dimension": "the_nether", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 5.00086766796875, - "candidate": 4.8434115507812505, - "reduction_percent": 3.1485759600484484 - }, - "combined_ms_chunk": { - "baseline": 5.38164891796875, - "candidate": 5.215208425781251, - "reduction_percent": 3.0927415504897087 - }, - "noise": { - "baseline": 0.99479630078125, - "candidate": 0.92550525, - "reduction_percent": 6.965350667954161 - }, - "surface": { - "baseline": 3.353920703125, - "candidate": 3.271626328125, - "reduction_percent": 2.4536768243602967 - }, - "terrain_cpu_ms_chunk": { - "baseline": 5.0, - "candidate": 4.8, - "reduction_percent": 4.0000000000000036 - }, - "peak_rss_kib": { - "baseline": 767300, - "candidate": 767156, - "reduction_percent": 0.018767105434640947 - } - }, - { - "dimension": "the_nether", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 1.39574041796875, - "candidate": 1.367371890625, - "reduction_percent": 2.032507404567051 - }, - "combined_ms_chunk": { - "baseline": 1.49761541796875, - "candidate": 1.473426578125, - "reduction_percent": 1.615156972446094 - }, - "noise": { - "baseline": 0.9979337929687501, - "candidate": 0.94876864453125, - "reduction_percent": 4.92669441438984 - }, - "surface": { - "baseline": 3.57196819921875, - "candidate": 3.5063635781249998, - "reduction_percent": 1.8366518802742715 - }, - "terrain_cpu_ms_chunk": { - "baseline": 5.5, - "candidate": 5.3, - "reduction_percent": 3.63636363636364 - }, - "peak_rss_kib": { - "baseline": 808252, - "candidate": 808196, - "reduction_percent": 0.006928532190455452 - } - }, - { - "dimension": "the_end", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 1.08787355859375, - "candidate": 1.05490283984375, - "reduction_percent": 3.0307491610164528 - }, - "combined_ms_chunk": { - "baseline": 1.16158449609375, - "candidate": 1.12807607421875, - "reduction_percent": 2.8847166941091573 - }, - "noise": { - "baseline": 0.6371068046875, - "candidate": 0.588318046875, - "reduction_percent": 7.657861673040965 - }, - "surface": { - "baseline": 0.3337400390625, - "candidate": 0.34096759374999996, - "reduction_percent": -2.165624091074807 - }, - "terrain_cpu_ms_chunk": { - "baseline": 1.1, - "candidate": 1.0, - "reduction_percent": 9.090909090909099 - }, - "peak_rss_kib": { - "baseline": 758388, - "candidate": 758356, - "reduction_percent": 0.004219476046561918 - } - }, - { - "dimension": "the_end", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 0.27526291796875, - "candidate": 0.26043392187500003, - "reduction_percent": 5.387211689528589 - }, - "combined_ms_chunk": { - "baseline": 0.3028137421875, - "candidate": 0.28832454687500003, - "reduction_percent": 4.7848539527404865 - }, - "noise": { - "baseline": 0.6326262851562501, - "candidate": 0.56824108203125, - "reduction_percent": 10.177446722609352 - }, - "surface": { - "baseline": 0.3275690078125, - "candidate": 0.33520016796874996, - "reduction_percent": -2.329634359248677 - }, - "terrain_cpu_ms_chunk": { - "baseline": 1.1, - "candidate": 1.1, - "reduction_percent": 0.0 - }, - "peak_rss_kib": { - "baseline": 765080, - "candidate": 764612, - "reduction_percent": 0.061170073717781145 - } - }, - { - "dimension": "overworld", - "threads": 1, - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 11.33398644140625, - "candidate": 9.78610121484375, - "reduction_percent": 13.657023806801444 - }, - "combined_ms_chunk": { - "baseline": 12.35675987890625, - "candidate": 10.85442152734375, - "reduction_percent": 12.158028207111835 - }, - "noise": { - "baseline": 5.408727453125, - "candidate": 4.9163363046874995, - "reduction_percent": 9.103641340866812 - }, - "surface": { - "baseline": 4.7373909296875, - "candidate": 3.7152747382812503, - "reduction_percent": 21.575508683503834 - }, - "terrain_cpu_ms_chunk": { - "baseline": 11.2, - "candidate": 9.7, - "reduction_percent": 13.392857142857144 - }, - "peak_rss_kib": { - "baseline": 773060, - "candidate": 772916, - "reduction_percent": 0.018627273432851265 - } - }, - { - "dimension": "overworld", - "threads": 4, - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 3.0581778515624998, - "candidate": 2.639180359375, - "reduction_percent": 13.700887015888346 - }, - "combined_ms_chunk": { - "baseline": 3.3576309765624996, - "candidate": 2.9384793789062496, - "reduction_percent": 12.48355166431578 - }, - "noise": { - "baseline": 5.5047845, - "candidate": 4.9102566562500005, - "reduction_percent": 10.80020196521771 - }, - "surface": { - "baseline": 4.9356213671875, - "candidate": 3.8894710195312503, - "reduction_percent": 21.19591982098062 - }, - "terrain_cpu_ms_chunk": { - "baseline": 12.1, - "candidate": 10.4, - "reduction_percent": 14.049586776859499 - }, - "peak_rss_kib": { - "baseline": 791548, - "candidate": 791400, - "reduction_percent": 0.01869753950486894 - } - }, - { - "dimension": "overworld", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "wall_ms_chunk": { - "baseline": 23.04948128515625, - "candidate": 21.47302998828125, - "reduction_percent": 6.839422012894609 - }, - "combined_ms_chunk": { - "baseline": 24.98420367578125, - "candidate": 23.443390320312503, - "reduction_percent": 6.167150154008521 - }, - "noise": { - "baseline": 5.77484952734375, - "candidate": 5.247983679687501, - "reduction_percent": 9.123455860824672 - }, - "surface": { - "baseline": 4.47116687890625, - "candidate": 3.32858220703125, - "reduction_percent": 25.554507420991243 - }, - "terrain_cpu_ms_chunk": { - "baseline": 23.0, - "candidate": 21.3, - "reduction_percent": 7.391304347826084 - }, - "peak_rss_kib": { - "baseline": 791700, - "candidate": 791520, - "reduction_percent": 0.022735884804850323 - } - } -] diff --git a/noise-aquifer-results/parity-binary-hashes.txt b/noise-aquifer-results/parity-binary-hashes.txt deleted file mode 100644 index 61ae96328..000000000 --- a/noise-aquifer-results/parity-binary-hashes.txt +++ /dev/null @@ -1,3 +0,0 @@ -57c0bf92bc3a01d28d3aa08c916a0b37f5568d7d287b98508516fd0488fae020 /srv/bob-data/horizon-noise-aquifer-e477fa56/snapshot-baseline -a43dc6817c55a55e7f869c2134eec9ac8e0c28505b06bd100c34b4b20ea4dbcd /srv/bob-data/horizon-noise-aquifer-e477fa56/snapshot-candidate -c3c042098409f9bb2aa2f3c92bca70c803474e2a4af32c4afc0d9cebeb111ca4 /srv/bob-data/horizon-noise-aquifer-e477fa56/horizon-density-parity diff --git a/noise-aquifer-results/pr-ready.md b/noise-aquifer-results/pr-ready.md deleted file mode 100644 index 686fa9470..000000000 --- a/noise-aquifer-results/pr-ready.md +++ /dev/null @@ -1,17 +0,0 @@ -**pr_ready** (`tools/pr_ready.py --quick` on archlinux, against origin/main at e4f8154cb, 54 s) - -| Check | Result | -| --- | --- | -| Scope | ⚠️ 39 files, +9538 −6; 9450 lines of code: over 500, split it if it can ship in parts | -| Cargo.lock | ✅ unchanged | -| Public tree | ✅ | -| Python tests | ✅ 236 passed (18 s) | -| rustfmt | ✅ (5 s) | -| clippy | ✅ (29 s) | -| tests: horizon-core | ✅ 94 passed (1 s) | -| tokens.css up to date | ➖ theme untouched | -| launcher rustfmt | ➖ launcher untouched | -| launcher clippy | ➖ launcher untouched | -| launcher tests | ➖ launcher untouched | -| Parity | ➖ not run (--quick): CI's parity job picks the affected harnesses | -| Label | player-facing: `feature` if players get something new, no label for a fix (`release-now` if urgent) | diff --git a/noise-aquifer-results/reference-assessment.md b/noise-aquifer-results/reference-assessment.md deleted file mode 100644 index 6576bae1a..000000000 --- a/noise-aquifer-results/reference-assessment.md +++ /dev/null @@ -1,14 +0,0 @@ -# Reference mechanism and focused feasibility - -Read the explicitly requested [Noisium description](https://modrinth.com/mod/noisium) and upstream source on 2026-10-18. Its performance and parity statements are reference-author claims, not evidence for Horizon. Inspected `NoiseChunkGeneratorMixin`, `ChunkSectionMixin`, and `ChainedBlockSourceMixin` in both source branches: - -- [1.20–1.20.1, c640041c8c932b36753c0ccf43902ac8b0bd252d](https://github.com/Steveplays28/noisium/tree/c640041c8c932b36753c0ccf43902ac8b0bd252d/common/src/main/java/io/github/steveplays28/noisium/mixin) -- [1.21.6, 1f9f2cb876e509130df7307d18e6dbc799875000](https://github.com/Steveplays28/noisium/tree/1f9f2cb876e509130df7307d18e6dbc799875000/common/src/main/java/io/github/steveplays28/noisium/mixin) - -The placement redirect manually increments nonempty-block, nonempty-fluid, and random-ticking-block counts, obtains a palette index (which can grow/replace the backing palette storage), then writes that index into the current packed storage. It avoids obtaining/removing old-state bookkeeping and the general setter abstraction; it is not a dense chunk builder and does not omit all metadata. The later branch additionally changes section lock/unlock iteration. The sampling mixin changes the iteration over an ordered chain of material samplers (indexed list in the older branch, indexed array in the later one), preserving first non-null selection. It does not implement Horizon-style density-volume arithmetic specialization. Biome iteration changes are outside this task. No upstream code was copied into the candidate. - -Horizon uses its own Java 26.3-compatible storage and generation behavior. Its noise fill already skips default air, bulk-samples density, and skips settled heightmap updates. There are no matching section locks to remove. Its generic setter maintains per-palette counts, free slots, packed widths and uniform collapse; its terrain wrapper maintains non-air counts even on existing chunks. Aquifer outputs are queried in Z/X/descending-Y order and can fail after earlier writes, so assuming that all writes merely replace fresh air would change public behavior. The direct-write idea is applicable as a private validated generation writer, not a blind replacement of the setter. - -A materially different writer could pre-resolve common generated states to per-section palette tokens and write packed indices with exact counts, or buffer dense section states and construct palettes afterward. The former still needs old values/counts for nonempty input, palette growth invalidation and required terrain metadata. The latter adds roughly 384 KiB of u32 dense storage for a 384-high chunk, then scans it to build and pack palettes; retaining traversal order requires keeping multiple sections resident, and failure paths must flush exactly the earlier writes. These designs were assessed independently of the previously rejected old-state hash lookup change; that small change does not establish their speed limit. However, the profile's 6.93% inclusive setter share covers all terrain stages, so noise-only setter elimination has less whole-terrain headroom, and neither design removes the density work dominating this profile. No new direct-storage implementation was attempted. - -The selected single optimization is dispatching unary density arithmetic once per bulk buffer. The measured 18.09% terrain self attribution to `UnaryOp::apply` and the actual per-element operation match provide a credible route to test. It does not change sampling calls, aquifer traversal, RNG, float expressions, buffer allocation, storage or scheduling. Scalar dispatch is retained in the scope-corrected version. Non-finite constant operands fall back to original dispatch to preserve NaN payload selection exposed by the new bit-exact differential test. diff --git a/noise-aquifer-results/snapshot-accessor.patch b/noise-aquifer-results/snapshot-accessor.patch deleted file mode 100644 index 1787500d5..000000000 --- a/noise-aquifer-results/snapshot-accessor.patch +++ /dev/null @@ -1,15 +0,0 @@ -diff --git a/crates/horizon-world/src/worldgen/terrain.rs b/crates/horizon-world/src/worldgen/terrain.rs -index 8ea3b01b..19a28011 100644 ---- a/crates/horizon-world/src/worldgen/terrain.rs -+++ b/crates/horizon-world/src/worldgen/terrain.rs -@@ -235,6 +235,10 @@ impl<'r, B: TerrainBlockStates> TerrainChunk<'r, B> { - pub(crate) fn registry(&self) -> &BlockRegistry { - self.blocks.registry - } -+ #[doc(hidden)] -+ pub fn diagnostic_non_air_counts(&self) -> &[u16] { -+ &self.blocks.non_air -+ } - pub fn highest_filled_section_index(&self) -> Option { - self.blocks.non_air.iter().rposition(|&count| count != 0) - } diff --git a/noise-aquifer-results/summarize.py b/noise-aquifer-results/summarize.py deleted file mode 100644 index 922b394fc..000000000 --- a/noise-aquifer-results/summarize.py +++ /dev/null @@ -1,38 +0,0 @@ -import json,pathlib,statistics,re -root=pathlib.Path(__file__).resolve().parent -rows=[] -for phase in ['gate','matrix']: - rows+=json.loads((root/(phase+'-raw.json')).read_text()) -keys=['dimension','threads','seed','center','warm'] -cases=[] -for row in rows: - case={k:row[k] for k in keys} - if case not in cases:cases.append(case) -summary=[] -for case in cases: - group=[r for r in rows if all(r[k]==v for k,v in case.items()) and r['repeat']>=0] - result=dict(case) - for metric in ['wall_ms_chunk','combined_ms_chunk','noise','surface','biomes','structures','carvers','terrain_cpu_ms_chunk','peak_rss_kib','process_user_s','process_system_s']: - med={v:statistics.median(r[metric] for r in group if r['version']==v) for v in ['baseline','candidate']} - result[metric]={**med,'reduction_percent':100*(med['baseline']-med['candidate'])/med['baseline'] if med['baseline'] else None} - pairs=[] - for repeat in range(5): - b,c=(next(r for r in group if r['repeat']==repeat and r['version']==v) for v in ['baseline','candidate']) - pairs.append(100*(b['wall_ms_chunk']-c['wall_ms_chunk'])/b['wall_ms_chunk']) - result['paired_wall_reduction_percent']=pairs - result['candidate_slower_pairs']=sum(p<0 for p in pairs) - if case['warm']: - warmup={} - for version in ['baseline','candidate']: - times=[] - for row in group: - if row['version']!=version:continue - filename=f"{row['dimension']}-t{row['threads']}-s{row['seed']}-c{row['center'][0]}_{row['center'][1]}-w1-r{row['repeat']}-{version}.log" - times.append(float(re.search(r'warmup_ms ([0-9.]+)',(root/filename).read_text())[1])) - warmup[version]=statistics.median(times) - result['excluded_initialization_ms']=warmup - summary.append(result) -(root/'summary.json').write_text(json.dumps(summary,indent=2)+'\n') -for s in summary: - m=s['wall_ms_chunk'];c=s['combined_ms_chunk'] - print(s['dimension'],s['threads'],s['seed'],s['center'],'initialized' if s['warm'] else 'cold',f"{m['baseline']:.6f} -> {m['candidate']:.6f} ({m['reduction_percent']:.3f}%)",f"combined {c['baseline']:.6f} -> {c['candidate']:.6f} ({c['reduction_percent']:.3f}%)",'slower pairs',s['candidate_slower_pairs']) diff --git a/noise-aquifer-results/summary.json b/noise-aquifer-results/summary.json deleted file mode 100644 index 151474176..000000000 --- a/noise-aquifer-results/summary.json +++ /dev/null @@ -1,691 +0,0 @@ -[ - { - "dimension": "overworld", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 12.2709350703125, - "candidate": 10.56634626953125, - "reduction_percent": 13.891270640859485 - }, - "combined_ms_chunk": { - "baseline": 14.202494660156248, - "candidate": 12.54111189453125, - "reduction_percent": 11.697823554096097 - }, - "noise": { - "baseline": 5.772878597656249, - "candidate": 5.22939499609375, - "reduction_percent": 9.414429774829324 - }, - "surface": { - "baseline": 4.4673708046875, - "candidate": 3.3145837343749998, - "reduction_percent": 25.804597843163354 - }, - "biomes": { - "baseline": 0.4295055625, - "candidate": 0.42579529687499995, - "reduction_percent": 0.8638457680044695 - }, - "structures": { - "baseline": 1.16812175, - "candidate": 1.16468150390625, - "reduction_percent": 0.29451091838245064 - }, - "carvers": { - "baseline": 0.37644830078124997, - "candidate": 0.38046942578125004, - "reduction_percent": -1.068174565180652 - }, - "terrain_cpu_ms_chunk": { - "baseline": 12.1, - "candidate": 10.5, - "reduction_percent": 13.223140495867767 - }, - "peak_rss_kib": { - "baseline": 786588, - "candidate": 786608, - "reduction_percent": -0.0025426271440703394 - }, - "process_user_s": { - "baseline": 8.712861, - "candidate": 8.133229, - "reduction_percent": 6.6526024000612445 - }, - "process_system_s": { - "baseline": 0.297019, - "candidate": 0.297967, - "reduction_percent": -0.3191715008130808 - }, - "paired_wall_reduction_percent": [ - 15.46667237128831, - 14.2277595333367, - 13.913534551281387, - 12.218084728221882, - 13.074004855452062 - ], - "candidate_slower_pairs": 0, - "excluded_initialization_ms": { - "baseline": 3665.391034, - "candidate": 3507.147807 - } - }, - { - "dimension": "overworld", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 3.8379385546875, - "candidate": 3.4084368984375, - "reduction_percent": 11.190946653521179 - }, - "combined_ms_chunk": { - "baseline": 4.4051651171875, - "candidate": 3.98759199609375, - "reduction_percent": 9.479170700424318 - }, - "noise": { - "baseline": 5.83775421875, - "candidate": 5.32868657421875, - "reduction_percent": 8.720265113186848 - }, - "surface": { - "baseline": 4.51470572265625, - "candidate": 3.3764329531249997, - "reduction_percent": 25.21255735050526 - }, - "biomes": { - "baseline": 0.5070742578125, - "candidate": 0.49398027734375005, - "reduction_percent": 2.582260934569415 - }, - "structures": { - "baseline": 3.9925353046875003, - "candidate": 3.94255260546875, - "reduction_percent": 1.251903750483244 - }, - "carvers": { - "baseline": 0.3843920859375, - "candidate": 0.39036689062499996, - "reduction_percent": -1.5543516388814038 - }, - "terrain_cpu_ms_chunk": { - "baseline": 15.2, - "candidate": 13.5, - "reduction_percent": 11.184210526315786 - }, - "peak_rss_kib": { - "baseline": 834016, - "candidate": 833440, - "reduction_percent": 0.06906342324367878 - }, - "process_user_s": { - "baseline": 9.500240999999999, - "candidate": 8.914977, - "reduction_percent": 6.160517401611167 - }, - "process_system_s": { - "baseline": 0.329736, - "candidate": 0.339101, - "reduction_percent": -2.8401509086056764 - }, - "paired_wall_reduction_percent": [ - 11.058124274895288, - 11.190946653521179, - 13.351896323802842, - 10.209178752803826, - 7.646603430227823 - ], - "candidate_slower_pairs": 0, - "excluded_initialization_ms": { - "baseline": 3637.872295, - "candidate": 3506.494573 - } - }, - { - "dimension": "the_nether", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 5.00086766796875, - "candidate": 4.8434115507812505, - "reduction_percent": 3.1485759600484484 - }, - "combined_ms_chunk": { - "baseline": 5.38164891796875, - "candidate": 5.215208425781251, - "reduction_percent": 3.0927415504897087 - }, - "noise": { - "baseline": 0.99479630078125, - "candidate": 0.92550525, - "reduction_percent": 6.965350667954161 - }, - "surface": { - "baseline": 3.353920703125, - "candidate": 3.271626328125, - "reduction_percent": 2.4536768243602967 - }, - "biomes": { - "baseline": 0.13852409375000002, - "candidate": 0.13367842578125, - "reduction_percent": 3.4980687023985833 - }, - "structures": { - "baseline": 0.1701334296875, - "candidate": 0.16619854296875, - "reduction_percent": 2.312823955866626 - }, - "carvers": { - "baseline": 0.32908183203125, - "candidate": 0.32905148828124997, - "reduction_percent": 0.00922073084762966 - }, - "terrain_cpu_ms_chunk": { - "baseline": 5.0, - "candidate": 4.8, - "reduction_percent": 4.0000000000000036 - }, - "peak_rss_kib": { - "baseline": 767300, - "candidate": 767156, - "reduction_percent": 0.018767105434640947 - }, - "process_user_s": { - "baseline": 3.222069, - "candidate": 3.170429, - "reduction_percent": 1.6026969006560663 - }, - "process_system_s": { - "baseline": 0.289952, - "candidate": 0.280034, - "reduction_percent": 3.4205661626751955 - }, - "paired_wall_reduction_percent": [ - 6.809142681172466, - -0.5551606163029945, - 4.405206251852917, - -3.916858057667301, - 5.720099296195154 - ], - "candidate_slower_pairs": 2, - "excluded_initialization_ms": { - "baseline": 484.217697, - "candidate": 474.51742 - } - }, - { - "dimension": "the_nether", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 1.39574041796875, - "candidate": 1.367371890625, - "reduction_percent": 2.032507404567051 - }, - "combined_ms_chunk": { - "baseline": 1.49761541796875, - "candidate": 1.473426578125, - "reduction_percent": 1.615156972446094 - }, - "noise": { - "baseline": 0.9979337929687501, - "candidate": 0.94876864453125, - "reduction_percent": 4.92669441438984 - }, - "surface": { - "baseline": 3.57196819921875, - "candidate": 3.5063635781249998, - "reduction_percent": 1.8366518802742715 - }, - "biomes": { - "baseline": 0.15250269531250002, - "candidate": 0.1519560703125, - "reduction_percent": 0.35843628788324644 - }, - "structures": { - "baseline": 0.47951465625, - "candidate": 0.45305451171875, - "reduction_percent": 5.518109652409609 - }, - "carvers": { - "baseline": 0.323113484375, - "candidate": 0.3320248515625, - "reduction_percent": -2.757968211923226 - }, - "terrain_cpu_ms_chunk": { - "baseline": 5.5, - "candidate": 5.3, - "reduction_percent": 3.63636363636364 - }, - "peak_rss_kib": { - "baseline": 808252, - "candidate": 808196, - "reduction_percent": 0.006928532190455452 - }, - "process_user_s": { - "baseline": 3.416411, - "candidate": 3.287765, - "reduction_percent": 3.765530552383781 - }, - "process_system_s": { - "baseline": 0.322942, - "candidate": 0.313003, - "reduction_percent": 3.0776424249555743 - }, - "paired_wall_reduction_percent": [ - 17.442986733026423, - 5.511911504948082, - 3.0063867842859606, - 0.32321562466078, - 3.5445990908488927 - ], - "candidate_slower_pairs": 0, - "excluded_initialization_ms": { - "baseline": 500.899628, - "candidate": 475.446214 - } - }, - { - "dimension": "the_end", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 1.08787355859375, - "candidate": 1.05490283984375, - "reduction_percent": 3.0307491610164528 - }, - "combined_ms_chunk": { - "baseline": 1.16158449609375, - "candidate": 1.12807607421875, - "reduction_percent": 2.8847166941091573 - }, - "noise": { - "baseline": 0.6371068046875, - "candidate": 0.588318046875, - "reduction_percent": 7.657861673040965 - }, - "surface": { - "baseline": 0.3337400390625, - "candidate": 0.34096759374999996, - "reduction_percent": -2.165624091074807 - }, - "biomes": { - "baseline": 0.06643014453125, - "candidate": 0.066747515625, - "reduction_percent": -0.47775162313655245 - }, - "structures": { - "baseline": 0.01243977734375, - "candidate": 0.013528765625, - "reduction_percent": -8.754081774599687 - }, - "carvers": { - "baseline": 0.00825007421875, - "candidate": 0.0078622109375, - "reduction_percent": 4.701330811891384 - }, - "terrain_cpu_ms_chunk": { - "baseline": 1.1, - "candidate": 1.0, - "reduction_percent": 9.090909090909099 - }, - "peak_rss_kib": { - "baseline": 758388, - "candidate": 758356, - "reduction_percent": 0.004219476046561918 - }, - "process_user_s": { - "baseline": 1.745915, - "candidate": 1.731978, - "reduction_percent": 0.7982633747920195 - }, - "process_system_s": { - "baseline": 0.284339, - "candidate": 0.29277, - "reduction_percent": -2.965122617720385 - }, - "paired_wall_reduction_percent": [ - 14.335535743218587, - -0.14435436297901683, - 3.0307491610164528, - 9.196996862770614, - 5.880897137927958 - ], - "candidate_slower_pairs": 1, - "excluded_initialization_ms": { - "baseline": 79.999625, - "candidate": 75.211387 - } - }, - { - "dimension": "the_end", - "threads": 4, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 0.27526291796875, - "candidate": 0.26043392187500003, - "reduction_percent": 5.387211689528589 - }, - "combined_ms_chunk": { - "baseline": 0.3028137421875, - "candidate": 0.28832454687500003, - "reduction_percent": 4.7848539527404865 - }, - "noise": { - "baseline": 0.6326262851562501, - "candidate": 0.56824108203125, - "reduction_percent": 10.177446722609352 - }, - "surface": { - "baseline": 0.3275690078125, - "candidate": 0.33520016796874996, - "reduction_percent": -2.329634359248677 - }, - "biomes": { - "baseline": 0.07276028125, - "candidate": 0.07429515625000001, - "reduction_percent": -2.109495694122272 - }, - "structures": { - "baseline": 0.015125671875, - "candidate": 0.014245484375, - "reduction_percent": 5.819162991726601 - }, - "carvers": { - "baseline": 0.008269808593749999, - "candidate": 0.008645933593749999, - "reduction_percent": -4.548170562064283 - }, - "terrain_cpu_ms_chunk": { - "baseline": 1.1, - "candidate": 1.1, - "reduction_percent": 0.0 - }, - "peak_rss_kib": { - "baseline": 765080, - "candidate": 764612, - "reduction_percent": 0.061170073717781145 - }, - "process_user_s": { - "baseline": 1.73318, - "candidate": 1.7176969999999998, - "reduction_percent": 0.8933290252599347 - }, - "process_system_s": { - "baseline": 0.281688, - "candidate": 0.28302499999999997, - "reduction_percent": -0.474638607253407 - }, - "paired_wall_reduction_percent": [ - 4.468032144530132, - 5.355664806644118, - 6.365453815866322, - 5.133841229675215, - 4.566994450348462 - ], - "candidate_slower_pairs": 0, - "excluded_initialization_ms": { - "baseline": 79.670474, - "candidate": 74.569892 - } - }, - { - "dimension": "overworld", - "threads": 1, - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 11.33398644140625, - "candidate": 9.78610121484375, - "reduction_percent": 13.657023806801444 - }, - "combined_ms_chunk": { - "baseline": 12.35675987890625, - "candidate": 10.85442152734375, - "reduction_percent": 12.158028207111835 - }, - "noise": { - "baseline": 5.408727453125, - "candidate": 4.9163363046874995, - "reduction_percent": 9.103641340866812 - }, - "surface": { - "baseline": 4.7373909296875, - "candidate": 3.7152747382812503, - "reduction_percent": 21.575508683503834 - }, - "biomes": { - "baseline": 0.38765451171875, - "candidate": 0.382181609375, - "reduction_percent": 1.4117989545599974 - }, - "structures": { - "baseline": 0.32856785937500005, - "candidate": 0.33016451953125, - "reduction_percent": -0.4859453262674832 - }, - "carvers": { - "baseline": 0.38096083203125003, - "candidate": 0.385858296875, - "reduction_percent": -1.2855560026045512 - }, - "terrain_cpu_ms_chunk": { - "baseline": 11.2, - "candidate": 9.7, - "reduction_percent": 13.392857142857144 - }, - "peak_rss_kib": { - "baseline": 773060, - "candidate": 772916, - "reduction_percent": 0.018627273432851265 - }, - "process_user_s": { - "baseline": 8.550168, - "candidate": 7.974602, - "reduction_percent": 6.73163381117189 - }, - "process_system_s": { - "baseline": 0.29184, - "candidate": 0.291122, - "reduction_percent": 0.2460252192982444 - }, - "paired_wall_reduction_percent": [ - 7.854293314463732, - 13.657023806801444, - 12.553897974345846, - 14.148200837826696, - 14.17241465420526 - ], - "candidate_slower_pairs": 0, - "excluded_initialization_ms": { - "baseline": 4000.613202, - "candidate": 3825.288926 - } - }, - { - "dimension": "overworld", - "threads": 4, - "seed": -1, - "center": [ - 32, - -32 - ], - "warm": true, - "wall_ms_chunk": { - "baseline": 3.0581778515624998, - "candidate": 2.639180359375, - "reduction_percent": 13.700887015888346 - }, - "combined_ms_chunk": { - "baseline": 3.3576309765624996, - "candidate": 2.9384793789062496, - "reduction_percent": 12.48355166431578 - }, - "noise": { - "baseline": 5.5047845, - "candidate": 4.9102566562500005, - "reduction_percent": 10.80020196521771 - }, - "surface": { - "baseline": 4.9356213671875, - "candidate": 3.8894710195312503, - "reduction_percent": 21.19591982098062 - }, - "biomes": { - "baseline": 0.47851093359375, - "candidate": 0.44986469921875005, - "reduction_percent": 5.986537059844964 - }, - "structures": { - "baseline": 0.76422690625, - "candidate": 0.7639770234375, - "reduction_percent": 0.032697463339285075 - }, - "carvers": { - "baseline": 0.39066100390624997, - "candidate": 0.3934000390625, - "reduction_percent": -0.7011283769974958 - }, - "terrain_cpu_ms_chunk": { - "baseline": 12.1, - "candidate": 10.4, - "reduction_percent": 14.049586776859499 - }, - "peak_rss_kib": { - "baseline": 791548, - "candidate": 791400, - "reduction_percent": 0.01869753950486894 - }, - "process_user_s": { - "baseline": 8.775314999999999, - "candidate": 8.211497, - "reduction_percent": 6.4250457106098136 - }, - "process_system_s": { - "baseline": 0.307699, - "candidate": 0.31522, - "reduction_percent": -2.4442718370875434 - }, - "paired_wall_reduction_percent": [ - 14.287444679738247, - 14.651419660848955, - 10.766874955512604, - 13.41115679312138, - 14.104231708494565 - ], - "candidate_slower_pairs": 0, - "excluded_initialization_ms": { - "baseline": 3974.517424, - "candidate": 3822.317993 - } - }, - { - "dimension": "overworld", - "threads": 1, - "seed": 12345, - "center": [ - 0, - 0 - ], - "warm": false, - "wall_ms_chunk": { - "baseline": 23.04948128515625, - "candidate": 21.47302998828125, - "reduction_percent": 6.839422012894609 - }, - "combined_ms_chunk": { - "baseline": 24.98420367578125, - "candidate": 23.443390320312503, - "reduction_percent": 6.167150154008521 - }, - "noise": { - "baseline": 5.77484952734375, - "candidate": 5.247983679687501, - "reduction_percent": 9.123455860824672 - }, - "surface": { - "baseline": 4.47116687890625, - "candidate": 3.32858220703125, - "reduction_percent": 25.554507420991243 - }, - "biomes": { - "baseline": 0.42952815234375, - "candidate": 0.42846523046874996, - "reduction_percent": 0.24746267950078715 - }, - "structures": { - "baseline": 11.944554960937499, - "candidate": 12.0325921015625, - "reduction_percent": -0.7370483112423263 - }, - "carvers": { - "baseline": 0.3797641328125, - "candidate": 0.3795897890625, - "reduction_percent": 0.04590842971630777 - }, - "terrain_cpu_ms_chunk": { - "baseline": 23.0, - "candidate": 21.3, - "reduction_percent": 7.391304347826084 - }, - "peak_rss_kib": { - "baseline": 791700, - "candidate": 791520, - "reduction_percent": 0.022735884804850323 - }, - "process_user_s": { - "baseline": 7.833855, - "candidate": 7.450079, - "reduction_percent": 4.89894183642664 - }, - "process_system_s": { - "baseline": 0.292247, - "candidate": 0.296075, - "reduction_percent": -1.3098509137818346 - }, - "paired_wall_reduction_percent": [ - 7.943881825517138, - 6.458250029021142, - 7.540067926396543, - 7.120058306701677, - 6.7398824305859995 - ], - "candidate_slower_pairs": 0 - } -] diff --git a/noise-aquifer-results/summary.txt b/noise-aquifer-results/summary.txt deleted file mode 100644 index ee7ab0428..000000000 --- a/noise-aquifer-results/summary.txt +++ /dev/null @@ -1,9 +0,0 @@ -overworld 1 12345 [0, 0] initialized 12.270935 -> 10.566346 (13.891%) combined 14.202495 -> 12.541112 (11.698%) slower pairs 0 -overworld 4 12345 [0, 0] initialized 3.837939 -> 3.408437 (11.191%) combined 4.405165 -> 3.987592 (9.479%) slower pairs 0 -the_nether 1 12345 [0, 0] initialized 5.000868 -> 4.843412 (3.149%) combined 5.381649 -> 5.215208 (3.093%) slower pairs 2 -the_nether 4 12345 [0, 0] initialized 1.395740 -> 1.367372 (2.033%) combined 1.497615 -> 1.473427 (1.615%) slower pairs 0 -the_end 1 12345 [0, 0] initialized 1.087874 -> 1.054903 (3.031%) combined 1.161584 -> 1.128076 (2.885%) slower pairs 1 -the_end 4 12345 [0, 0] initialized 0.275263 -> 0.260434 (5.387%) combined 0.302814 -> 0.288325 (4.785%) slower pairs 0 -overworld 1 -1 [32, -32] initialized 11.333986 -> 9.786101 (13.657%) combined 12.356760 -> 10.854422 (12.158%) slower pairs 0 -overworld 4 -1 [32, -32] initialized 3.058178 -> 2.639180 (13.701%) combined 3.357631 -> 2.938479 (12.484%) slower pairs 0 -overworld 1 12345 [0, 0] cold 23.049481 -> 21.473030 (6.839%) combined 24.984204 -> 23.443390 (6.167%) slower pairs 0 diff --git a/noise-aquifer-results/symbols.json b/noise-aquifer-results/symbols.json deleted file mode 100644 index e5cfc44ff..000000000 --- a/noise-aquifer-results/symbols.json +++ /dev/null @@ -1,25 +0,0 @@ -[ - { - "binary": "baseline", - "symbols": [ - "0000000000499f60 0000000000000364 t ::apply", - "000000000049ca70 000000000000006b T ::sample_value", - "000000000049cae0 0000000000000080 T ::sample_volume" - ] - }, - { - "binary": "candidate", - "symbols": [ - "0000000000470b60 0000000000000364 t ::apply", - "0000000000471ad0 000000000000006b T ::sample_value", - "0000000000471b40 00000000000010ef T ::sample_volume" - ] - }, - { - "binary": "initial-shared-inline", - "symbols": [ - "000000000047c390 0000000000000351 T ::sample_value", - "000000000047c6f0 0000000000000e48 T ::sample_volume" - ] - } -] diff --git a/noise-aquifer-results/terrain-parity.json b/noise-aquifer-results/terrain-parity.json deleted file mode 100644 index 37c143936..000000000 --- a/noise-aquifer-results/terrain-parity.json +++ /dev/null @@ -1,424 +0,0 @@ -{ - "schema": 1, - "minecraft": "26.3", - "manifest_sha1": "11f1aefe473eefba0af62e3286c33b692807b2eb", - "platform": "Linux-7.2.11-zen1-1-zen-x86_64-with-glibc2.44", - "java": "openjdk 25.0.4.1 2026-08-18", - "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)", - "block_states": 35723, - "block_tag_files": 300, - "fixtures": 114, - "fill_calls": 200, - "noise_aquifer_fixtures": 61, - "structure_density_fixtures": 24, - "sources_sha256": { - "mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTerrainOracle.java": "47887c16a4106e6a9ef4d665fd4603ea23b62e38491376bcf9038b904e39b406", - "mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeightmapOracle.java": "145c943637ed177cc4ef8a85f2484da8afd164868e84a8463882feec1653a860", - "tools/test_terrain_parity.py": "8bb8e716e957ef07d1117ed9939fab1b551ebab94d20e48d11f64bc477e4571f", - "tools/test_rust_parity.py": "ce7c94225311e6f90508c3934d6e67c407619b964653bc60ff8139f421320f4b", - "tools/test_worldgen_parity.py": "b40972ab2ad222aa6d77537cc36b434a217baa1f1b56bbaad945d6e12fe776af", - "tools/lab.py": "aef2feb5484b1e73527be272a59d87a69fdddc95bf01d1530f021e29e5c327ff", - "Cargo.toml": "0d7082d8eca4c7fbe93d21bed27a81d3fe29cf563f8be8beb8aaef1c433370ba", - "Cargo.lock": "ab32aebd14140b5e338c485987671b3f7d6e5d14ad4b40764b98bde309ab6bf6", - "crates/horizon-core/Cargo.toml": "e87ac28a37062f16ca532f2bce335c90a84129bdaa69d6c2d1b691809e596fb4", - "crates/horizon-world/Cargo.toml": "939cd091292643abb192b856dc41d8111a1a19d8cf9278be15f804bbc592ec7c", - "crates/horizon-core/src/bin/density_parity.rs": "e5b1dd33b7d01306c73cf072629b4fb186e9ab87b672a00108999d1a72263fd0", - "crates/horizon-core/src/bin/float_log_parity.rs": "4a655fcf8822ee7668c4bd126bc84d0b118864a6fc7f5a6aeee667d8bf2590b1", - "crates/horizon-core/src/bin/geometry_parity.rs": "27f6c09fe5018ac3de8e70e0f0bbf78f9abb14f5e4783bcaf46e8ca87b9c6f8a", - "crates/horizon-core/src/bin/noise_parity.rs": "c135bfc708d853e7061e81487d2cfe10de64b2f65677d3b4837cbfe0b8341010", - "crates/horizon-core/src/bin/parity.rs": "f35d928c66f958de39fac5e7e836a657eed95f83599e84899f7ea7a5802ba481", - "crates/horizon-core/src/bin/tick_parity.rs": "a54c164fe4814034d369947a887f5273966f5a878ba849204b80d1c729526a8f", - "crates/horizon-core/src/biome/seed_hash.rs": "5afbb4921c750826b395a08bf06f382fc7f01b5759a93de02a2749c523e2a317", - "crates/horizon-core/src/biome.rs": "908efa8cd4aa0a7adf1cb5e1a222e3dfb640eed5e9172e0fe7f0d1287afae7e8", - "crates/horizon-core/src/carving/ellipsoid.rs": "09232a7588610e8a9176fd9c62d40afb1fb89f2ecab6d555536a1d847b142d86", - "crates/horizon-core/src/carving.rs": "0aa3093caa0437868a8c0ed52a6c6e1993bd51c03583c670a2837e749eae5426", - "crates/horizon-core/src/density/arithmetic.rs": "82f521e11756cc4455c31e7cacc4587deba2e4bbe08f8bb16c08d7e1f8d76b4b", - "crates/horizon-core/src/density/beardifier.rs": "24fb2ed66128574a610d7df070534551007eb5c89b08cdcda5db444297d750b6", - "crates/horizon-core/src/density/cache.rs": "38d0b6c9dd04ffef979fdad3f29cfebf98d331c8c9d430be5f39aa34f6c30975", - "crates/horizon-core/src/density/end_islands.rs": "168b9384237bd2e41d0ae5a74e944da4dc74e493bdec31fb73184c9a49e3de55", - "crates/horizon-core/src/density/graph/compiler.rs": "ac67deeb16f16d0859aa20e5a165811a29aca0b910037ee6bf5098211f3a6ede", - "crates/horizon-core/src/density/graph/mod.rs": "b776e7da934cb03051a3053d56d461c71e9978e084922fe4194147aa580c07bf", - "crates/horizon-core/src/density/graph/seeded.rs": "6bcdcaa3dffcfa9df673bbbea35120057a16ba3d2b506c52709c36cf8976b74a", - "crates/horizon-core/src/density/graph/tests.rs": "6bfb8cbff462587dd147b0775ea01d370abbd97544b9bd596c792df1b5f7e634", - "crates/horizon-core/src/density/interpolation.rs": "8c890f52b6467f38a94c654986a6a484b8e0b296ab98c398e60a6ce465b5b010", - "crates/horizon-core/src/density/interval.rs": "f12852fcbeecf944a737eb13bc55d9958832624811f2f443adeb579810378b33", - "crates/horizon-core/src/density/mod.rs": "ca0d77d3282e3746ddcbc92bee97dbf640b9a56214e6ac1537f51f9a5b63d6e7", - "crates/horizon-core/src/density/power.rs": "d5b7270a128d4264268cd772109ad16d71a8ec3ff2d3b63b84cb985296d54a91", - "crates/horizon-core/src/density/rounding.rs": "71840c5206ff8d218ac29bf6f66915d5212764ba270c675711a866ba5b55a7a6", - "crates/horizon-core/src/density/selection.rs": "0dd26af2e85004ec5e053039ad11c384c17c56ace9ab45eb3f5cb3503c0b0330", - "crates/horizon-core/src/density/slice.rs": "5d77605573c0deda47778f1f78f7fa3fbf1944d8f5efbcc65cf589181cadf80b", - "crates/horizon-core/src/density/spline.rs": "6bb2e40f940fc6544d6fb09cb0b8cac722be03bc663dbdfb0f61faae207400bc", - "crates/horizon-core/src/density/surface.rs": "159e0e69cda74f870e80ea64fe523c4397e64af4ccb861bb9fd07b2c3cb91b00", - "crates/horizon-core/src/density/terrain_noise.rs": "8d0059d25eb5d248cb97a4c5a2e670d61528928ea151495c004f25adb723fe3e", - "crates/horizon-core/src/density/tests.rs": "422a3cf804b30c1de5fe4c3527c224dbc39dd2d1999358f21663069a28977dde", - "crates/horizon-core/src/density/world_fields.rs": "c1ce305cb8046b384d90c564cafb24af7365d580389637910f3d8b0cc18eb583", - "crates/horizon-core/src/geometry/border.rs": "9e5b104d1ae9389fd10cc57d213a6e59ef28561c9671bf79841217fc1753a93f", - "crates/horizon-core/src/geometry/mod.rs": "c650386f9860e44a96c55f18c8f1428ca715fcb0bc5c2434db5b1caa43df27fe", - "crates/horizon-core/src/geometry/movement.rs": "bcfb452752940ce53ae6dc267a3c4eb29459046a063c1f884684ab4f4bd0068f", - "crates/horizon-core/src/geometry/shape/create.rs": "189812b91d5e0e3ad963afcd1a6e2831b31b8188df91a904ef27061e644806ad", - "crates/horizon-core/src/geometry/shape/face.rs": "f243bce81384040a95ce7984b02b5699206c596c537b2713097e86005b4d3a5c", - "crates/horizon-core/src/geometry/shape/join.rs": "f1b51887b7bf9482557e3ffa99e136f2e5db07ceeb05fdb116adf45e87129075", - "crates/horizon-core/src/geometry/shape.rs": "e8d88a763de1525f77a30b99591641e8a8b80946263acbde035a9bcc356df960", - "crates/horizon-core/src/geometry/sweep.rs": "abd6009c61555161ef2f18b431b2aa384b126c0871cae8b96a62358498a56a1d", - "crates/horizon-core/src/geometry/traversal.rs": "77a3da570a0b85582b669cf4d841cba4b06327006dda26d4a26df4e8ce05bae4", - "crates/horizon-core/src/geometry/trig.rs": "c55f184ae606997985f188f2219aea7c673523358a0eea5b20b473335a42453e", - "crates/horizon-core/src/jmath.rs": "d6d77517605b37e1696cb9b01bb23ec097111a01acc9f0d4946b0aef8acff6c6", - "crates/horizon-core/src/lib.rs": "d823a203ddccbfc4c1a29cc25533d94b93e95777f1fa2d466526a1e1d86e5305", - "crates/horizon-core/src/noise/mod.rs": "1dab5a713abf702402e69ace1bf9e476bba544b0ede5a61c3c3afc60af0a03f3", - "crates/horizon-core/src/noise/normal.rs": "e9e7a46472a54a02c98c46da819842090567153b32fe0c84249009ef19af7aad", - "crates/horizon-core/src/noise/perlin.rs": "e73815447432eab7542f67366cb3f1b368d164e33f6c9cdbd045ac8e4db0932a", - "crates/horizon-core/src/noise/simplex.rs": "6c0dbc15b2b7510195dd28fceca01dcaac1847ccc4a84d299c351589c642fe7a", - "crates/horizon-core/src/noise/stack.rs": "7f6ef0e7d920139ef1a6ad3ec5640f92765715f86dcc5ec29f1a149984f45fa3", - "crates/horizon-core/src/noise/volume.rs": "3f05d2b1780acfdfee60037677d309937a5033b45ef428fc2d540942d4b56b43", - "crates/horizon-core/src/paletted.rs": "4b02dd67a51f1561eae36cd9cf90975f5dc0ad0078ee796e065fa392003d84da", - "crates/horizon-core/src/position/iter.rs": "32d2d8e74821cc4e49e3354202d35d3120e4415bfdda9375a73f2137ef651129", - "crates/horizon-core/src/position.rs": "e10101088e6902386b9b6d27773d44312f1ff72bebb19e57967a54945dde9dcd", - "crates/horizon-core/src/random/hash.rs": "0f88a127a1ba2705d3d6c0ebd009324d6ba86ffa2d27edf2d2a84765e690e4a3", - "crates/horizon-core/src/random/positional.rs": "35494745e5d4cf89e282c3ae0ee245e9f2640ddbbc03bc0055df742006a9c862", - "crates/horizon-core/src/random/worldgen.rs": "f518fdc8e3b67a286b28790cfc8c048317004404e6a6b2a4f51bb97cfae15d09", - "crates/horizon-core/src/random.rs": "96815e1a7fbaa44b70e55955f9d1383fc38cc6233f6d6df16d9efc3ea5d61dcc", - "crates/horizon-core/src/storage.rs": "f6c32201c64aefde06e57a2c767be46918df613548a322801546b133799cc33d", - "crates/horizon-core/src/text.rs": "e6553ddb5db5039e8dc4614b6a6dc9f35a26dc3d1673b68a04e72e7983b67abb", - "crates/horizon-core/src/ticks/generation.rs": "be1237e790693f633a61714ddae68c6506a777588a8a3ab5efbe53a35774dbd2", - "crates/horizon-core/src/ticks/heap.rs": "bf28afab8af77c3d243aa96cd8a1fb8d934140a4dbd07dbfdbf4e7908bb4b845", - "crates/horizon-core/src/ticks/index.rs": "1f1a6a568c2a30eafecb020ca4d5f5fc414860de85b8b381fc419a2e3e65c24a", - "crates/horizon-core/src/ticks/mod.rs": "01634630668172516b8b79d0907bad47f6e2c543a6d499c2fa4b201823b375cb", - "crates/horizon-world/src/active_effect_tick.rs": "88f19cfc3532c47a58c646bb3e9d99ff239a900752302b6a444dda3013e95cbf", - "crates/horizon-world/src/active_effects.rs": "daaf352a69511a7d69fb329997f783b86585e486e0379c84ab0a55641771646c", - "crates/horizon-world/src/attribute_health.rs": "1420a80787d10dd2e2954a3ee6193ff313289d00c7c78ca26ece8bafa21f4380", - "crates/horizon-world/src/attribute_map.rs": "3d871cd530f5c035e0753f3ba065c2b9c5b49cdee75d4119f7dd584b22af67e6", - "crates/horizon-world/src/attribute_updates.rs": "4cb322d75a50d222298994607097ba7f7e6674021128fa02a98a74c057ad05f1", - "crates/horizon-world/src/attributes/entity.rs": "64ac99682a3aa06b1fb94b776b47794234c76b1cf70f1f54933d51e545e69279", - "crates/horizon-world/src/attributes/live.rs": "8198c45134f69135d48ef203e71b6e702529568fd1ed9174d0aa843570bbf9e7", - "crates/horizon-world/src/attributes/mod.rs": "5c2fcbbde58c19261874d227ea98332f00336c9fa53446da2e9adb6aa64a5e5a", - "crates/horizon-world/src/attributes/operation_map.rs": "fc5bc8921d78ea6721a2eaa915e67483e2a33683927467bdba24f0492356ad97", - "crates/horizon-world/src/bin/worldgen_parity.rs": "3143ceb9b56eecfd7667e5feb5f9f0cd13cfb8754b38d4ea338dbba97f2819da", - "crates/horizon-world/src/block_collision.rs": "d129887e43b883e3377763d9ffcad33aa54a63dbea4453e05878e3ea74acd4ca", - "crates/horizon-world/src/block_collision_scan.rs": "4d38621a647e0489e61d531635eb5ff3dfc3a1bc92f8d1158e5155cf9b8eb7ae", - "crates/horizon-world/src/block_entities.rs": "a9deae92e6e5a1fcf4f0476c33ea4d170ddad6fd4b3303e1bb66d933973d5e06", - "crates/horizon-world/src/block_entity_push.rs": "12ee91bf604946234b24a0da4333f07d1830ab9743a422d41c8d0afac7d49cfd", - "crates/horizon-world/src/block_landing.rs": "33083fe39266fbefec1b3ea1a19f2afc609791d189da247c895e116ad6eb266a", - "crates/horizon-world/src/block_placement.rs": "524f4892d50bab77b7d89d19f7b048ffe746996f2ed7f376db2c6ab00ed75c24", - "crates/horizon-world/src/block_properties.rs": "b0bd8a983336c48e488a20caa77dd5c39b1a74bbd14ebc03b3b64556a1c864fc", - "crates/horizon-world/src/block_render.rs": "468734cedb6e2002bb12299ef6b028e443914f7a56b6d15d31786e4906b14896", - "crates/horizon-world/src/block_support.rs": "ade4fbd47284b450dabdd682dc86138b2ac05a0fd379525d7110648908245476", - "crates/horizon-world/src/block_survival.rs": "28ce64375e09819a4f13da9cfbe37c08b5ad0daf01b289c1c360b4567e50e811", - "crates/horizon-world/src/blocking_item_damage.rs": "afea3cb5761e8b82ee4d9bb4ef3c6fd10182a324dbaec99e6c9ebfac255dda09", - "crates/horizon-world/src/blocking_rules.rs": "83c5e2105cec56a90182ce582e1c67ade2b189be6de1a34d08035000cc07c492", - "crates/horizon-world/src/bundle_weight.rs": "a0e7b0587ab5d46cd55588f25d55a088b7a4725099c13ba6df146957be36014c", - "crates/horizon-world/src/chunk.rs": "37953481dc35724c5672c6b74d3b470058a64e9cc4a34280f2dfa6d8ff408a95", - "crates/horizon-world/src/chunk_status.rs": "dbb8583cfa775203c544d24d69e03720385428f15a267a561356c21f5025e9c7", - "crates/horizon-world/src/climbing.rs": "6cd2f919872ff0b726effddaa57eccb805b8eae43f9d01144716010853891879", - "crates/horizon-world/src/collision.rs": "a749794d5c27ccd6c0d964ad02f9dc31d49d9f4fe4b7366cd4bd8155e681b00b", - "crates/horizon-world/src/collision_context.rs": "2176c7034e07f547510a8327cdad9d3b63f26e4754032b76b7d5fe13166c333c", - "crates/horizon-world/src/combat_rules.rs": "01131f70d1acdd96a910e7f96deaa12e51a1e3bb9208085f04e3ec7b657d3cd4", - "crates/horizon-world/src/component_durability.rs": "37a46e184f95bc5027e2b9af72ff52f729ad03601d08e1827f181fca383a35af", - "crates/horizon-world/src/component_patch.rs": "f6f8992f241dfb25e012a06a7ba3fecab8d958686dddd096595a4806e56f0ab3", - "crates/horizon-world/src/compression.rs": "4db73e6ca9a0d552d415ce60e7e88b89c9cf2b7d060a669ff8328f518316e101", - "crates/horizon-world/src/consumable.rs": "ba3575cb85866cb940f33a1ac86455d71cf0cc6395b848588a8ee1fe33f5c326", - "crates/horizon-world/src/consume_effect.rs": "03f2aac6879ce133347d42f6f6667d62c06d956ff9faac5dc14182a788b6a236", - "crates/horizon-world/src/damage_immunity.rs": "fd39c41124d694e755cf7faadcf93c636df4042c78ec345092a856b5f952dbcf", - "crates/horizon-world/src/damage_reduction.rs": "f5a599ab11e077f526237018aeda803ea3c420c5b35c78ae9d85e32267e23bf3", - "crates/horizon-world/src/damage_source.rs": "24945e397a926d34695652980923609e4723e02fe6b6e56d4aaf673e45d759f7", - "crates/horizon-world/src/datafix/block_state_data.rs": "f5a80cf99851b96fc172d844ef2c900a5e605258ca37bbad04f69fb8d2aa10ce", - "crates/horizon-world/src/datafix/chunk_flatten.rs": "f695996b05306519adeaa51e7311903642c01f841851eb918796665e06dd5ae0", - "crates/horizon-world/src/datafix/chunk_leaves.rs": "284a1748cb93a33bacde8b2087bd17dfe9b991f05cb5f0029e10fc472b9d33f4", - "crates/horizon-world/src/datafix/dynamic.rs": "2b7828eb446f2ee3febb02392d435a3c8a2224f6ff7dc9d84bd97fc126351a66", - "crates/horizon-world/src/datafix/files.rs": "5169f7828e73f65ff0acec7f3e9eb9dff5aa1ab1d619618eeffc20d1ee2dde60", - "crates/horizon-world/src/datafix/fixes_a.rs": "95fce5222d62c43020217928b406d11be0d874307e28d395b52001b8e50368f7", - "crates/horizon-world/src/datafix/fixes_b.rs": "166867d935fc5310e4ab153f4de756c7e082f8346342cc7e74a6729315cc0575", - "crates/horizon-world/src/datafix/fixes_c.rs": "e21fb0538ae4fd8bbb3b952f4b0b9852c511083fbe67c21e693db932d28083ef", - "crates/horizon-world/src/datafix/fixes_cliffs.rs": "7d6cd28ab79215ed66629d4fac0c008f468b491d68439f88153f03bca0930fb6", - "crates/horizon-world/src/datafix/fixes_flat.rs": "17ee1a005d5eccae7be42a02e1b54c9348488970f5787345ee3d09c72292e850", - "crates/horizon-world/src/datafix/fixes_legacy.rs": "8f7f40bbbe9fb59b18fc08c2931197ed5634a70246974fbcbe033e455616b1e0", - "crates/horizon-world/src/datafix/fixes_mid.rs": "f9aa4f403fa2a8dc47bf71a36bf1a52abe06967f89a7a185888993ef56f2f60d", - "crates/horizon-world/src/datafix/fixes_old.rs": "1e15a096c9111f62ebb169c4639c19b767706c7be15a661a6936df2fd47b0a38", - "crates/horizon-world/src/datafix/flat_tables.rs": "2bd77d383645faeafaba161df696fbbdaa3fb49e464a64ecb3d6e7b60d6bdbf1", - "crates/horizon-world/src/datafix/items.rs": "9a4f2ad3d962e0711f3958bdf2c73491b4c5f747784ac613abda0cb35fbbd3b1", - "crates/horizon-world/src/datafix/json.rs": "1209e8d63b5d6a7806b0aaf058512e4db0edc4d8923c289cc0e576e3e514db34", - "crates/horizon-world/src/datafix/mod.rs": "3f595bd662835e2c04fe262cfda09a3a7701f42e77e53570b473cadb2da1da3b", - "crates/horizon-world/src/datafix/schema.rs": "c88a72ea1f15a971842156a029a07cc86c7b0fb62eaceda194a30873a1d9890c", - "crates/horizon-world/src/datafix/schema_flat.rs": "53f3b361bc38dcc22510c039bbb9aa7092eb6ccbd5cdfc92f4b7a331434adf6c", - "crates/horizon-world/src/datafix/tests.rs": "9587afc979fc02158ece9704f96129c1f96c8acb93d2734d3bb5515169faac7b", - "crates/horizon-world/src/datafix/text.rs": "4c17bde03df678370fc2043c3a1daed592c5f99c8855c71b6f3773d207d871c8", - "crates/horizon-world/src/dynamic_support.rs": "5996bc1c436fb6215d8fc3d0bb4de5dd9b966d842d432580d624195771697fb8", - "crates/horizon-world/src/edge_backoff.rs": "5259d7aa44e64f88351d1556c44dd0edcad3b400a099c659755792efba7b5773", - "crates/horizon-world/src/effect_attribute_modifiers.rs": "0bc7ab63d0f3f34a7133fe20364cae0ec1fdbd3773cba90faa1f08e0d63a5646", - "crates/horizon-world/src/effect_notifications.rs": "ea66bfa010d6d44aee97b9672902f41cd99d0d80239f41c6d4eae5c9a9472d3d", - "crates/horizon-world/src/effect_particles.rs": "a42dc4ec55929dce1db0f22f8816ecf7621fdce1cd2ac0c90f6a57fea4e0afd2", - "crates/horizon-world/src/effect_sync.rs": "1388d4a69b42a14ff4cd474f5e36f0fad5a2874031e64fa2b19b2ea179deed2b", - "crates/horizon-world/src/entity_collision.rs": "09f2fd7f6cd56fc282f468ecfa765a94506929e9684bd3a5c90123e5b51cd627", - "crates/horizon-world/src/entity_fluid.rs": "f34ba29522a72ca6853f56139bfd53e0a7ceb0af2bb6d8e54a79d8352b043e88", - "crates/horizon-world/src/entity_fluid_tick.rs": "4f9e070b88a73c98a4e2e659360ddd6edee636bca29377f1ea9011fd5a556f64", - "crates/horizon-world/src/entity_move.rs": "a40a50d3e841625a75d4cfbb7c2630ab5a62a574456567e7234f401ae8441b32", - "crates/horizon-world/src/entity_obstruction.rs": "a4b28a19bf83b23611c59d94535c488db37e4aee24b22c973c545910894a809f", - "crates/horizon-world/src/extra_items.rs": "6eba0a0c795d5fd841d31471708e78324b4852adebb2e6ed700dcc0caab668cd", - "crates/horizon-world/src/fall_damage.rs": "8c28e2933493569fe05dea22332024287d28b0746b514dd465681040b003296b", - "crates/horizon-world/src/fluid.rs": "e672e7403145287b74f36721b59bd633f17a30daba37441160c76d9b7c2c4be8", - "crates/horizon-world/src/fluid_box.rs": "b586af72b1c04a9354fe66205c28dc8b619e205ab9ea19a68232722e4b6e96c1", - "crates/horizon-world/src/fluid_flow.rs": "7c7e486b5c565df3602799648b37b879bcca51414337f607962d6c7951b86d05", - "crates/horizon-world/src/fluid_occupancy.rs": "26037579caeef6c8a5a2bde2c3d142d278558b76d77ebff401cee6e35f2ea961", - "crates/horizon-world/src/fluid_shape.rs": "28bb65a72f5bd074a354ba38a1b1707fcb0947537977a11540bba0adb85995c2", - "crates/horizon-world/src/food.rs": "3cf416fa632a5555a8116bb528a6e80bcb5b6b754b0748b4959ed310102418d3", - "crates/horizon-world/src/food_properties.rs": "0926fa3f3bc3d0608c45d02f564355825ca3c3526a82bf9c1375c7a191fa5e12", - "crates/horizon-world/src/food_storage.rs": "58c433801a285efcc973638c11d694a41f85dc96703a3a7ce8d3673f3eb31d52", - "crates/horizon-world/src/free_space.rs": "913536bf4c85ddeeb378d76d1b5110b4175f5688e1a749f32fe6a6d86fbb478e", - "crates/horizon-world/src/ground_support.rs": "3e371d74ecede4d30beef0a7e8a2ee33463584a5b1ed3d852b394efcce1ffbe0", - "crates/horizon-world/src/heightmap.rs": "a5edef082b5af40d814421ea17e129b3b06d70abee6434ed263e4bba58571698", - "crates/horizon-world/src/identifier.rs": "37c921889c4f5d91f7c09ab2ee68d1a5e5a3c4fb1c49b4b189c987b4615fd2d6", - "crates/horizon-world/src/interaction_shapes.rs": "f321284ddab440a394372b6dedc8b5cc29a653c0745251a9e96c650f21c33dea", - "crates/horizon-world/src/inventory_pickup.rs": "ea830c7916e7f2d95c6db7ef48be1e876e6ebafcb438e47fc72f9a5bd7c37d07", - "crates/horizon-world/src/inventory_tick.rs": "293a3d57a1689337cfd58e5a73dcdbed4cb360f94d98ff5458f0df92de387365", - "crates/horizon-world/src/inventory_use.rs": "6a6c2ecc73c83dda4cd798c0304df12ace6096eb110d899f4f0c7ffd852bf001", - "crates/horizon-world/src/item_after_use.rs": "2b6598ce5b7b304dea2c8057b4a1eb6530264ac4d0546c3da0c76deed9609da5", - "crates/horizon-world/src/item_blocking.rs": "f6eee0d6d177cc3148960122327ba1b459a2f0e85241c1d9a3e40f0b8c169296", - "crates/horizon-world/src/item_cooldowns.rs": "7b625868509ab3c51e72db0ac714bb0e7ec5e2610d37271005a1a737f4d14431", - "crates/horizon-world/src/item_durability.rs": "9fdf835e5c7bd0e1dd63ef2ba0076b770cdd4d6d14cdcd11de27690f0702f94e", - "crates/horizon-world/src/item_particles.rs": "861b14f65adb9b14f8158fe9f0b7128beac3df8107b1337c31b8b9b49434ba3f", - "crates/horizon-world/src/item_stack_refs.rs": "18d3ca85cac0daf59200857513761359e5690f719cb3f7f64ae552f0c4169ea3", - "crates/horizon-world/src/item_stack_storage.rs": "b4dcb83dcaa346848c5484161feb3e2cf08e83f7793d7ed83be25b14b9d12884", - "crates/horizon-world/src/item_template.rs": "dc80025215d1867e656924ea2a9d273aacbcaea21293d986ba42d0004ee93b69", - "crates/horizon-world/src/item_use.rs": "b1c79428986efbf9dd5ede703a39eb387fb6dcc7d9950f0e49243a353a5b8070", - "crates/horizon-world/src/item_use_catalog.rs": "a9b53d2e816583239a75c3c61e78dacc5e3b27dee595be34b1c7fa169f17a571", - "crates/horizon-world/src/item_use_lifecycle.rs": "4639b70440cf811e79de09c48a3e035143fcb6be8a64c2f61b10ae55a2f133b7", - "crates/horizon-world/src/item_use_start.rs": "a84092dfb8b8f0a89d0928bb2f8ac252bd9bfd3f8d74fce1a7f7a5b3c3f4f50b", - "crates/horizon-world/src/java_hash_map.rs": "955502e696d7b0b33bae3ec485c8eb1453a8956116aad68226cf1fc67d60babc", - "crates/horizon-world/src/level/bonemeal.rs": "4f7339252251387eb400263c43652a7086905fd82541aaddfb7e9af6c1a355a6", - "crates/horizon-world/src/level/buckets.rs": "ac19649dda818c1cd836f7b07d4233636db8b61174e6e71fa98e664b6046b049", - "crates/horizon-world/src/level/classes.rs": "9814231b93d03a735f25779e3c17fb02a3681b95e06c56c31e1f8a839b0c14b7", - "crates/horizon-world/src/level/creaking.rs": "10d55ff63bfb3d6fcc7e1394da6a3582dbd75397e11f013e3c66ab54eaf38418", - "crates/horizon-world/src/level/data/cache.rs": "e92c168b4a65f392da5c318a49abe88bce7073ed2846539638375ea8d3182ea3", - "crates/horizon-world/src/level/data.rs": "de0136bbf01e3ed2860a4fad44cf1a778cb3ee2a75b85d5525913ae0862319a5", - "crates/horizon-world/src/level/falling.rs": "9cb8995267eed1f8df8b650d6ca2fa287892a2d87a1c525d330e1f3c5eb18199", - "crates/horizon-world/src/level/feature_world.rs": "8be92a674e4620c78d00e77e57289a673f4f831f5d08214c1a2d82720f10d4de", - "crates/horizon-world/src/level/fluids.rs": "f7a77ab6b7dadfa1e125c2f62219607b7f7bf734f9df422d6b88e1aad3e9b498", - "crates/horizon-world/src/level/growth.rs": "70c26d2b54d52d89332ed2d8833e5f872c6b4fb80735460fda50a3eb3a6b6e5d", - "crates/horizon-world/src/level/growth_tests.rs": "c420d2f0c81a6e79b5889a4d0750770c1466950f271674af452b85a06721786c", - "crates/horizon-world/src/level/hooks.rs": "d58d56bbb094eba6b2053f61d8fad34c82922743924de175c3a3d18515e048ac", - "crates/horizon-world/src/level/interact.rs": "8e04f0f41517890c5ec03d9347d1f3852ad0f4bcd010fd9a870de24a4a19080e", - "crates/horizon-world/src/level/mod.rs": "c56bc05dd501aeb208821430477541d180309228caee23bf2abaa188dbcc6516", - "crates/horizon-world/src/level/pistons.rs": "acb3b95ca6ae6e9ae12a10c28668136877a44af1724ca0535e34a98320aca0f9", - "crates/horizon-world/src/level/place.rs": "4e9e91a1fbc8748f46223a9f82655382ffded57997048d9539adb039255f75f8", - "crates/horizon-world/src/level/portal.rs": "b6d51b8cc94d1d46ed8d54bc3fedefe27c66cc436f5c6fd6d986c41293906986", - "crates/horizon-world/src/level/portal_travel.rs": "f311d0055a39ca42b6a8637255bdad6a15ab3568b9820eeaf5bbb01983090367", - "crates/horizon-world/src/level/query.rs": "661d986cebe3f51f894e68c0512f8932c369e24049ba29c7017cfce725df98b4", - "crates/horizon-world/src/level/rails.rs": "fd4b3ba90579da61278fc1b1bbd8e25e5a51f4f23b209f4aea45c542b7aa74ec", - "crates/horizon-world/src/level/redstone.rs": "6a2d0e27da9c5bce78163259e12c3edab47fbd89f42d1fe3688c35728355c358", - "crates/horizon-world/src/level/removal.rs": "d5d6c856835182c8790686e11b96acba48f4b31c66395325c68d0b867d85e96d", - "crates/horizon-world/src/level/sculk.rs": "56552807f82efd87b896b3dcaecff2ccab9bea876f5c2da79ff9fc56b4468a1d", - "crates/horizon-world/src/level/shapes.rs": "cbf211893cf188fcebf4cf94d41d06308431e4bed0036d30c8f40f4a72a939ba", - "crates/horizon-world/src/level/shelf.rs": "326f10a0ee92f27f454c1f33dfaf736f1648de7e0678dc9e28ef14e3ff31dbd6", - "crates/horizon-world/src/level/signals.rs": "dcb15b9c190ee0086f445e1dca4ba45c6f5b92e11cd91def917ff4c1ab4395c8", - "crates/horizon-world/src/level/speleothem.rs": "34a9c9806436728bfb38c6543fdc8a4bfa728f53ff995943192680e74a9e5988", - "crates/horizon-world/src/level/states.rs": "1aa28828ae5de24956db140068639d411bfb7bff1ed46d1cd60a5ca4303568b6", - "crates/horizon-world/src/level/survive.rs": "fe37fc9719424e984b1ecfe698f71d658400c5307c124d3901e8b9beab63de59", - "crates/horizon-world/src/level/tests.rs": "1c8c110126755649d61e1cf5a6dfe9b610c0e6250082413f125be8ef9521484e", - "crates/horizon-world/src/level/tick.rs": "e4c894fd03eff3d0cd67d7ea2271e6b4b4679fc546072e6e60f83edc4e208783", - "crates/horizon-world/src/level/ticks.rs": "f7bc741977d4a7ae2260fb57715f6f4febcca4ab1452e3fd2a7d59cdd794ca94", - "crates/horizon-world/src/level/timeline.rs": "cb4359749a594b77f8793a397b40a57e0c7cdc1a6971c8dc99e89e52c4d3b004", - "crates/horizon-world/src/level/update.rs": "0f9559e5d0338ac1cf4a662e4967f8f6aa9e379b97279cc8d5a183e2551341bb", - "crates/horizon-world/src/level/weather.rs": "b9c18ee56e4e731cef6a6f29a084f89a0bddb3f7edd68f21201c8f61db62f2e6", - "crates/horizon-world/src/lib.rs": "59959cae2c5cb5ae42bf3f255c12055487d899b75e7303dad06d88347dfeccec", - "crates/horizon-world/src/liquid_collision.rs": "0f0a83b04e5a5bc9d98ed05fde4d6584ba69642e93522e726e4cfc325d6fcb1d", - "crates/horizon-world/src/live_attribute_updates.rs": "778171faaaf7077deb0b62c4cc1db16351eba41adb8bb07656ba65e827056199", - "crates/horizon-world/src/living_air.rs": "b2de36bb50bed15e2808fe4a874fcef07f9fea0d2c96385b7b5e8ee9560d4442", - "crates/horizon-world/src/living_damage.rs": "2b448209629b9bf2e678d667ad0d6c7fa22146892dd106b169d96b31b0df12bb", - "crates/horizon-world/src/living_fall.rs": "da0f176f4731e1c86e08bfeee8167742fd1b86380ff0e9304c13c1ce3f1c67ab", - "crates/horizon-world/src/living_fluid.rs": "d7cd914cfb2a1f4876ce0ae95e999bf0ff1af732cce3ab4a3aa2d1ab881c7339", - "crates/horizon-world/src/living_health.rs": "221659f85552424e937d503bba6d8003006b106ced042b32d3a6f6cc23e12ed0", - "crates/horizon-world/src/living_hurt.rs": "844239ad7d15c39629bb3cfc06ebae6d1cff20b7627468f26e0ee8dff3abdcb8", - "crates/horizon-world/src/living_landing.rs": "8bca4eb7977abc2b14fb7174be4ea355352106ea1e76ff5f3ad8696969d9eefd", - "crates/horizon-world/src/living_motion.rs": "56f8c84cfbe205a7a69912d5f76b52ef1efca149c1b6801d4684e25fb179aeb9", - "crates/horizon-world/src/living_use_flags.rs": "826f4fdeba7e208368cbbf910fa408db0afbc6442d842d178a70fae53e0d0ea6", - "crates/horizon-world/src/loot.rs": "4452a14c44b7cb3ac78ce41b9238c32d470a2b85c49d36755df28ff7f37b04d5", - "crates/horizon-world/src/main.rs": "fce57418b8c22a6a0a9044baa89ed3d9c243bc2e8413fea3ff0f32985daba021", - "crates/horizon-world/src/movement_emission.rs": "76e7d6f5b19c94676190f54389f9c4ce12cf89945ccfcb9c750de473223e7753", - "crates/horizon-world/src/movement_properties.rs": "6f01ab920b376a13f5ae12c3718f4dd067e1dff2b829585af00a8b2100f3775d", - "crates/horizon-world/src/movement_restitution.rs": "04b4fe0947e7e52576145bd8ed15920278e8a538afcc74d125eaca513dffa0ef", - "crates/horizon-world/src/movement_statistics.rs": "fe28061e29c41f8f399d29cce8c468a63854613702b5aa525c0f0fd98cb87f9a", - "crates/horizon-world/src/movement_support.rs": "02d85cf572847f2e60b5a7f9d60b856888a67b3c1f4df03e81998c66fdf874be", - "crates/horizon-world/src/nbt.rs": "d2f3aba100974d034ba71dd3955e5aa0e38801ad0693b5ac3e2765fe897bb6a7", - "crates/horizon-world/src/object_open_map.rs": "b4934a9cc38df93ed206ab0bc3bbc4499acd8e40b41b7def7d47067b7170065b", - "crates/horizon-world/src/object_open_set.rs": "d3e0373bf1b652dd054345d5a8e25ec828e06dd7cad65aada35163c95df4e637", - "crates/horizon-world/src/piston_movement.rs": "7a3fd2549a582b5f3a5c21aa05d67d944d62ca1105856679e100ac5b44e9a52f", - "crates/horizon-world/src/piston_shape.rs": "399c2337103b8e7e0eb5667227c5aa14f9549d6a467b7be7da3d0717f0263500", - "crates/horizon-world/src/player_equipment.rs": "1fa8c53e67624c4641246249d79a800a28a4858c62482bd880b4e3b866b936ef", - "crates/horizon-world/src/player_food.rs": "f188dc110745bcc7acc15e6c521db943b06b404f69cd251bf74a345516070304", - "crates/horizon-world/src/player_health.rs": "8155b315453c569db2fbe46228886c5881d1fd55eb095c5849e69bdb500ba2bd", - "crates/horizon-world/src/player_hurt.rs": "99c9bbd8587ec2dc287806049897b8034d2f5349ad47fc497b70d54148844a36", - "crates/horizon-world/src/player_inventory.rs": "f4f67d8312793f25930626c4ac06db688fcf2e2292d6675071d105fb1708d952", - "crates/horizon-world/src/player_travel.rs": "6841a677a900495eb6223031ef3ebe8d859bb98908dda0e2209e5f28839dc593", - "crates/horizon-world/src/powder_snow_collision.rs": "7289946a21478d11abfd2bdcdddff3d7f98e25bf6a68564fed45c3cc01ac2a36", - "crates/horizon-world/src/region.rs": "c339cc89220071766c1ecb18121c84f4d373f716815b179faf9c8dd70c2bc6c5", - "crates/horizon-world/src/registry/json.rs": "7a683afcd1742c5307756927d7f0aa779c7d7992af87d8d371dd98108728e235", - "crates/horizon-world/src/registry.rs": "7afcd2e364aad5d6df103d4a6d0ac3fd8e779f8b414bacd447d040cb150ac36b", - "crates/horizon-world/src/registry_collision_scan.rs": "97cc950a9a4ba387b78e368f36d595f8664ab7730d132900d220ce23b92826ea", - "crates/horizon-world/src/registry_fall_ray.rs": "52935436132df505691144840dcbd858b15d00d8305997284e3a542ecf6bc0dc", - "crates/horizon-world/src/registry_fluid.rs": "b8959c05850cfeaaad1e4de8ca7c7d0d6ac56da9b2c1de3ebefa5871a11ed35e", - "crates/horizon-world/src/retrogen.rs": "6efd36a6293756688c1990a7965bd65609d7c5e2bf2a5f4f01d54932d2b9386b", - "crates/horizon-world/src/server_player_combat.rs": "0a94885c4b7a0d294ba7f4cee18b96ee59649b50112988250b53cc224059a979", - "crates/horizon-world/src/server_player_damage.rs": "29af22dec321fe01776cee5334f050c5bc3e27a688f99c8c3da4c0ad8bc8254e", - "crates/horizon-world/src/simple_container.rs": "0fedbc7e974b1db79b88bd6aff977654189a5d553cf42852fe8bf0885cf90b30", - "crates/horizon-world/src/status_effect.rs": "588bfcf4d93f50be86cb89545bd5c431edbc71771f704ff55cb52906b1964c37", - "crates/horizon-world/src/stored_consume.rs": "621a52c9fba447c393e561f881a16cf1f97d336e3a0ce493725ef51e2db12ffd", - "crates/horizon-world/src/stored_effect_attributes.rs": "c79f6a52d3cfee1a5288225bf8fa91a7bf3ea8cd21faea9f6dc748ecefc6309a", - "crates/horizon-world/src/suffocation.rs": "bed219dd5bbab6263b98fbe3d0eb512cb96c52ae847210efe49514d05f22f11e", - "crates/horizon-world/src/swimming.rs": "49d2dae13c109b37ff832cde98a857944ff45247b864a527b9c4f03ecca7a7b7", - "crates/horizon-world/src/synced_floats.rs": "0152f2752bafaf68769d56dbc88494a976496a680c6b113d6b48a446158ba072", - "crates/horizon-world/src/synced_values.rs": "a1d4b53ae77d1899ba2b4ead67c9ec1e3c96615558e446f9d0760c1b4a520169", - "crates/horizon-world/src/teleport_consume.rs": "d6a53bbb6ac4dbbd4c0591d0646017898a95beb8ef093dc5d81b9833963be6c3", - "crates/horizon-world/src/tick_data.rs": "f8d04a69ea263f4168bce33f92e5b4ee2fe07d7caf50a1621c6b3ef6eb2479f3", - "crates/horizon-world/src/use_remainder.rs": "f555335afeca7970888131a6da2f5a614a73253b631185d1ba804593a349535e", - "crates/horizon-world/src/view_direction.rs": "e18120ae26dc5cf702b29fc4c8487088bab133c8ce5abce01226833fafb0d5a4", - "crates/horizon-world/src/water_splash.rs": "e0461ae1b2e8c851cca6e3251a188334293292201d7f80dc9e7d60fd1815f4d1", - "crates/horizon-world/src/world_movement.rs": "f8fe9e34f2395d2a04c839d1c8ba78e09ce493c26de6f6e4e237b9c19c061da5", - "crates/horizon-world/src/world_ray.rs": "879bdbbe12f56deb705cc183933431489e840b71eade40c33391eed5949c2e61", - "crates/horizon-world/src/worldgen/anchor.rs": "d156b8a0b147a274cdd143409b441f4f43edecde6e8ee14ef9cf0309f743143a", - "crates/horizon-world/src/worldgen/aquifer/config.rs": "fcd2cc3a520c1527c88f095a3b5d38487e7ebb1ccecc5f757f93d04a069add4f", - "crates/horizon-world/src/worldgen/aquifer/noise_based.rs": "74daaa389b5c3dfdc99214dfff256a9e172f83548d2326cbc941d9637cc53fb7", - "crates/horizon-world/src/worldgen/aquifer.rs": "cb4b66d87de3f9f79ae6ffe4badd6f0f44886cd42ad9de2771b8b56c4f1e28c7", - "crates/horizon-world/src/worldgen/bamboo.rs": "d9b47113c99be34256e58308bc6f40072ff25c579d6bf995182aa862c0006102", - "crates/horizon-world/src/worldgen/biome.rs": "3fe316b875aa32683759c337dc71f624910faf0812a2d6d83b8098d6d0bac7a0", - "crates/horizon-world/src/worldgen/biome_chunk.rs": "8fdfe6ebe3ffeca97611fd5991a5bc6b2783ea1c62f4d8ef3b2dd53c04a5dc1d", - "crates/horizon-world/src/worldgen/biome_predicate.rs": "bfc581bc40077cc74ffda43e990a55fe997adc04c7130f98e039c3305ca79aac", - "crates/horizon-world/src/worldgen/biome_source/codec.rs": "2b9e4f5d679eb444cb73174f511e3b9f32e9eb138248ab12cffc6cfd76adf3a8", - "crates/horizon-world/src/worldgen/biome_source/runtime.rs": "f0b02c1521178e4d0377c6ca62694604b6a773f1f234f070ff0cde4685911d45", - "crates/horizon-world/src/worldgen/biome_source.rs": "e181e1736f3e0b75f7091a24c88de3fd116e01b98424d02382aea7a503d1eb54", - "crates/horizon-world/src/worldgen/biome_temperature.rs": "cde4bbab5e260c4065b113376c423b8511ade93c5aa5fd976e245ee8a58b5ad1", - "crates/horizon-world/src/worldgen/biome_weather.rs": "96b1f9494559ed31d06257b83d604d00cc069ccc8c7b68094117e034b4a71bd7", - "crates/horizon-world/src/worldgen/block_blob.rs": "c608c57b3d77279646ecb89e50677dd8e452b0422ffd357ba755536c5589eb89", - "crates/horizon-world/src/worldgen/block_column.rs": "f72c21a9066ee0aa68c2fb79fba436d05afb14c6ef5a2cb012f1ed35fc17cd22", - "crates/horizon-world/src/worldgen/block_feature.rs": "78abf6c0768b7123ae7acb8f83980a91c4373bb8002c61387c98e4113aa47170", - "crates/horizon-world/src/worldgen/block_pile.rs": "623e369b77e0526ed2756485a6c0bb09683cd28ad8876dea907360ca6665b39d", - "crates/horizon-world/src/worldgen/block_predicate.rs": "074c692367e3f2191a1bb28d87b23402430a843c246bd30a4ea838ee3500280e", - "crates/horizon-world/src/worldgen/blue_ice.rs": "eedd77bdaff808330b864166d303378096daa5c7d235e925770b171c05109247", - "crates/horizon-world/src/worldgen/bonus_chest.rs": "05d0f63fbc7412f13ba1fa37a7238114b8f70bfff318beb2dece590482d49cc0", - "crates/horizon-world/src/worldgen/bulk_section.rs": "eecf61532d7793f853884c5a18a7f436a59835c7b13d3ec9075804511553c9ba", - "crates/horizon-world/src/worldgen/carver/canyon.rs": "509c4d5a9d689849e98e894ab14a9fbf82d10707d38e9cc688ded3c4778df3e2", - "crates/horizon-world/src/worldgen/carver/generation.rs": "a4498d0d1457536de3922a08e9c40ccce8d2ef9cc263801c15a412327513c098", - "crates/horizon-world/src/worldgen/carver.rs": "46b251e28225fe1250de38f49dec5dacda4e2c4ba1e556e21e6d1e14e2651fc3", - "crates/horizon-world/src/worldgen/carving.rs": "4e77d4e5c4a0ca55ca3563b9bdf6f379342e0bdf9d019d60f7bc57ce4afb5fbd", - "crates/horizon-world/src/worldgen/cave.rs": "d4efcdf209d871a8b09423f3721e045f247c1f2302f501d342ca510733192d69", - "crates/horizon-world/src/worldgen/chorus_plant.rs": "29224c164ede919e280a65a68f155c873e2c8fd0aa7d7e244d8fa9e468760250", - "crates/horizon-world/src/worldgen/climate/codec.rs": "d567adeb5d837816fca69102db51d790f71aec1b51c09298230d24612e400a14", - "crates/horizon-world/src/worldgen/climate/index.rs": "c5ce61679a5f0e0f2f0af2a373424effa124d0cce8250609eff38b7034650756", - "crates/horizon-world/src/worldgen/climate.rs": "1b9ad44407f40aee4c1cd5357a5c9c443c1b105728f01cf5c644072f99f8357e", - "crates/horizon-world/src/worldgen/decoration.rs": "d355b68067f0c96389d95500af06d3ced1c525ed15fedd9cfba2afa827087c55", - "crates/horizon-world/src/worldgen/decoration_order.rs": "7271fd3bdfadd33e392ed931a1ba4d3c2c0072ffe85d911b7fdb0d10d88c2aad", - "crates/horizon-world/src/worldgen/delta.rs": "c2bf49ddf3231d28c109e68871429bc13d76a7bebe14eb33e84aa856bdd66145", - "crates/horizon-world/src/worldgen/density.rs": "65a98c156a290a6b374ef670d28cd5dfbe0aa93171824d1bbd96422536273f84", - "crates/horizon-world/src/worldgen/disk.rs": "6f8f9e059755af44c9bfa1b91eba54a7d13fad811dce31717c5502d7f6df33d7", - "crates/horizon-world/src/worldgen/dripstone.rs": "48e4f10ad7640d94d54d625fea37b9051acaf9abe8d12ebce6c106fa6467725f", - "crates/horizon-world/src/worldgen/end_gateway.rs": "f53fde77d6a36a525cd15d890003b2c129d0689a4cbfa2cf443a0c2e3acae040", - "crates/horizon-world/src/worldgen/end_podium.rs": "8f6d0d6d60ff0fde63de5781e867239db321f82cf12639f0537d410a3731ee1d", - "crates/horizon-world/src/worldgen/end_spike.rs": "6046eefa30b0cac230fac43f37cd280d246647a379d52c9e13f1ef74c47259b7", - "crates/horizon-world/src/worldgen/feature.rs": "40500af71ee6628dfb27518262d99f08d0383ae6c7b9397452feef0c213eadd9", - "crates/horizon-world/src/worldgen/feature_catalog.rs": "5eff54d06ff4f136381e7abb044a4414dcc3bfb490c2e004b83d0e77d81256aa", - "crates/horizon-world/src/worldgen/feature_graph.rs": "d4c03fa371093194840a0d6df5a0e044febe749ad916f4f092c6f0768948f806", - "crates/horizon-world/src/worldgen/feature_region.rs": "c4b35e910fba60789cf516b9115e37b2c53edd379b127bf1b8ae68f763ab19a6", - "crates/horizon-world/src/worldgen/feature_sort.rs": "3488a093dfe1321aaa29d8a30cfb115d8e666a81bf195514e87b170de626835c", - "crates/horizon-world/src/worldgen/fluid_predicate.rs": "64197c9e63bebf1ce04bc280bfe980bb6c1b9aa887ca5cded904aeb0d9ae6c46", - "crates/horizon-world/src/worldgen/fungus.rs": "e5d9836db4212f2c9ae4dfb9f8b7bfa21ca0ec9db7a13a4035ae5f115189bd4b", - "crates/horizon-world/src/worldgen/generator.rs": "36088c0ad7138f9e5a6017be7eb0aaea21c91ff887308a2618488ee35c79c5ec", - "crates/horizon-world/src/worldgen/generator_blocks.rs": "9fbc12a05dab15fe12531cb9d2fb2d3636efb5e64074960196df251e72aec699", - "crates/horizon-world/src/worldgen/generator_decoration.rs": "ebb4f70b7da768726f10c1edacf7993d52e1907529e44fbef101a67f30a39de2", - "crates/horizon-world/src/worldgen/generator_structures.rs": "1f281d0264bbb46e161594249a5267572b1e00e001fcedbd293d5fcd66d3d9ee", - "crates/horizon-world/src/worldgen/height_provider.rs": "368d4dc119854742a045c4a717679c921456da681fc5f71aa9b37102d6f33b47", - "crates/horizon-world/src/worldgen/iceberg.rs": "4112535f540fe46627a3604d59e0c25e778d4deffccfbc7a663729d1a03a4d12", - "crates/horizon-world/src/worldgen/live.rs": "697e8a40432806e63fb6b8d6072175355a1f443ad5c7a2a5fd9d80bbe5429de6", - "crates/horizon-world/src/worldgen/long_set.rs": "d81e21822655a02a19a28271bb0ed33b60c9e5c11327bad8ec1637fc807f9974", - "crates/horizon-world/src/worldgen/material_condition/codec.rs": "09b909bc384472f76d163c8069ec6b507c7d5c6a028a36d5e0e3df20deff7b3b", - "crates/horizon-world/src/worldgen/material_condition/density.rs": "df9d0761e978e5010663ae8b44f2d6c1ecb4907331e333bdb6a2b487c1e107de", - "crates/horizon-world/src/worldgen/material_condition/library.rs": "a55534c5da97575a819af5a7dc0dbec9069993fa8b2619c6c9d5576946e683fa", - "crates/horizon-world/src/worldgen/material_condition/noise.rs": "ffb59cc6be2275d7a5621bf7d768527e74a8326ed7ad78618746711540921675", - "crates/horizon-world/src/worldgen/material_condition/rule.rs": "fed643352efbcb1f68f29b6241896617db889fc7c577a6247564e01922fec1fe", - "crates/horizon-world/src/worldgen/material_condition.rs": "d638dcb8cbcb5da20b3cb29602b0ae6a86c4fdf9d8c0fb725de8ec5fc108717e", - "crates/horizon-world/src/worldgen/material_extensions.rs": "ab806eb679d5116e1aebb64fca70e1499ae71f83c9507a8cb4c3201c2b1bf037", - "crates/horizon-world/src/worldgen/material_stage.rs": "698cbc786eff13c246e2bc2ea062401918cd4265899fbc3d53abc87e45a8e7a1", - "crates/horizon-world/src/worldgen/material_surface.rs": "5d37b90099df3d6da0845dab164e71469fb287019c2ee74bc6714f3b9d6d6d5b", - "crates/horizon-world/src/worldgen/ore_feature.rs": "9b5ce4c5303b73098265c530c627ca3e94e82640a9438cf4bfe892e7efa0f6c9", - "crates/horizon-world/src/worldgen/placement/chain.rs": "9218399b4d3757f7bbc550d7729a7201f32a1c83a7030865e0c12aab8a80d116", - "crates/horizon-world/src/worldgen/placement/context.rs": "4b589b153d8f03cfc983017c7e81503dddd5b18f725de7fa18cfb3e597fa6e4c", - "crates/horizon-world/src/worldgen/placement/layer.rs": "a0f5ca776f33f9d4f72b8fdcd163426152e5e43cb4a7572fc1d4fc57bf965de1", - "crates/horizon-world/src/worldgen/placement.rs": "b0397e5818fae84358546193a95f84bcb0b5bffafce909e6fcb3386179ee8023", - "crates/horizon-world/src/worldgen/projected.rs": "a546daf30acfdb01fb21aa40636958739b19f662c5b4645d9c4e8472bd44d646", - "crates/horizon-world/src/worldgen/replace_blobs.rs": "bf3377d86d2570cd15288ba69dde64a2cf67c5bcbb9a31d0c23421964af74afa", - "crates/horizon-world/src/worldgen/root_system.rs": "d6fa50238ec6915b527900080dc4ee65727f9d0de4f2e02190768e18cead71ce", - "crates/horizon-world/src/worldgen/router.rs": "2cee7cf15a0d2ada12be6b39d83e78177fd3033922e4f4cce87a64073cec2847", - "crates/horizon-world/src/worldgen/rule_test.rs": "d1662ec492489ebaa4b87e20f9a8c809dcf3a223a151211bd65ec241a63692fc", - "crates/horizon-world/src/worldgen/sculk.rs": "cfab1fa9acf0f6745e1edd1e95810ccbba0f2adb35de08ce8192b21c81e2b214", - "crates/horizon-world/src/worldgen/settings.rs": "a8fe87752e1982ef11cb67f8d80d8e3428b2c27db178044cb425ba803e689e59", - "crates/horizon-world/src/worldgen/simple_block.rs": "9ba1a88d5db4925f8c37366557887f776c805f9a6444781615b5dbaff52e92a4", - "crates/horizon-world/src/worldgen/snow_freeze.rs": "9040be3d5c7f8f0fd812d2df45e154bf8a9eeef038530b83fa4159d246eac35f", - "crates/horizon-world/src/worldgen/spawn_finder.rs": "768c550ea60271d9628836f7dbd6778a89923765c5521698dc56aebdacf0c629", - "crates/horizon-world/src/worldgen/speleothem.rs": "c71651c1c97818a8a85863e14414d6139ea3bdeb897fa422043bcc1499d99aae", - "crates/horizon-world/src/worldgen/spike.rs": "eacf0d9d3d2bc3d4bcf62bc87555f90031138236a5bfef0eb5270204f7c2a4fc", - "crates/horizon-world/src/worldgen/spring.rs": "830849e9b89fcdf09e9b06fbefdcdebe3c8c3f82804f60b8bd5de04ba303cb62", - "crates/horizon-world/src/worldgen/state_provider/catalog.rs": "c8687e15a4887a9200c8d365857d801efaa8f90e669eee3e600a1db4905119eb", - "crates/horizon-world/src/worldgen/state_provider/noise.rs": "7ee369c2a032e5620cb9bdf9ee7adad1f70870fb0a27efb7b7c514d92f83491f", - "crates/horizon-world/src/worldgen/state_provider/properties.rs": "b67b5ebde681a5282677b5317621e9d828466ffc1e041de24ca58bd867e6dc70", - "crates/horizon-world/src/worldgen/state_provider.rs": "f0f98a681b88f5934e7fd6cd703b5786ff4c5e2c5cd70f5ba2bf1b7ff7ab2c80", - "crates/horizon-world/src/worldgen/structure/end_city.rs": "a7461eb30cb47e3a8d1fd6238bb6a904c537312f59ce582c92940b4f6791c64e", - "crates/horizon-world/src/worldgen/structure/features.rs": "b67cc0b901192230c21aa657a3e679f39597f0e4a6d4d17f17a64f05bb4434d5", - "crates/horizon-world/src/worldgen/structure/fortress.rs": "c3313a91a192dbf133d579ec96cd61de6c24fe6d84b35f9ee88d5294fced5069", - "crates/horizon-world/src/worldgen/structure/jigsaw.rs": "60be3fc344d7a8a1b684e2205684aa670551b0ba362ff987d9e82c54f2937ad9", - "crates/horizon-world/src/worldgen/structure/legacy.rs": "94a6f372aac8738fb4bd102c3d60bea43522fc8db296cc2ea4793210972eaafe", - "crates/horizon-world/src/worldgen/structure/mansion.rs": "9019a9c229e4d050ed5335b5a9bbde902fc3d7cc935539c0497d954b93e0d0d7", - "crates/horizon-world/src/worldgen/structure/mineshaft.rs": "21922ab09879817510ef0ed4b1a494f9a73e8aedd66c5e81684bfa58285aacbc", - "crates/horizon-world/src/worldgen/structure/monument.rs": "8a1069e11165c7cc8539537fa392d218b8098a861d3caf7c1d187b488a166732", - "crates/horizon-world/src/worldgen/structure/nether_fossil.rs": "98877223961c64b48c03bd9a0a6dd7f3f34d0a3e922b364a4a9ad16a1d9355fa", - "crates/horizon-world/src/worldgen/structure/ocean_ruin.rs": "284550daf599344c1f0bcbd6c25a6ce764d66c0f610dc5b1a1bf9f2f8e730464", - "crates/horizon-world/src/worldgen/structure/processor.rs": "9c4bcf5b0086e027b262436b9f1228a35aa262a5b704570256e459a742a8a1ee", - "crates/horizon-world/src/worldgen/structure/ruined_portal.rs": "bb016156b97232a88f09f5f31a88b00af6e5e3527d74420c8f033ae2005b1d3d", - "crates/horizon-world/src/worldgen/structure/simple.rs": "e31c6d032da36a9b79dfe7551ea1e1e3d83466225d45205d71deb65cd70dfb9b", - "crates/horizon-world/src/worldgen/structure/start.rs": "b9b05c167a316a0eb6cde29cb339c9220c8650909125d243146b25e217b84db3", - "crates/horizon-world/src/worldgen/structure/stronghold.rs": "7b0727cb5e29587bbc83331fbeb8cfe3e3091cbcf4c4d68aa1abc2a91a1ad3a7", - "crates/horizon-world/src/worldgen/structure/template.rs": "e7d555292777e86fe887c2dbaaee9a9bb2edb48420b056c0ebbfbc080659b179", - "crates/horizon-world/src/worldgen/structure/temple.rs": "ffc9a610cc87c287e5dd2953b66e40ef653a0cbb2b727cfbfc75baf5d60b1327", - "crates/horizon-world/src/worldgen/structure.rs": "2e61637e3a06f06ea2485c5eea2e1055f2aa28e71c60aaa626d060d0e49b9d92", - "crates/horizon-world/src/worldgen/tags.rs": "74e4110fb19c4c4047192fd65c38015b8afc7f9fc50404d75380b5063808148c", - "crates/horizon-world/src/worldgen/terrain.rs": "2fd34855f3dfffff307e24082a9a29fb3bcf2c5d99550148a3e724fb89a19fe0", - "crates/horizon-world/src/worldgen/tree/decorator.rs": "145df5e1220355215fb021fea83382e8794255b27d1533f3faca5d0320e3c91c", - "crates/horizon-world/src/worldgen/tree/fallen.rs": "ff29c68ef7ff339c0862fae5f46b3bd1fae22b58c9562fcb038d7e9937d42625", - "crates/horizon-world/src/worldgen/tree/foliage.rs": "47ecf142f786083a250019b5aa55d0ff1114c924d53baf3ba3c16b2e1399c56a", - "crates/horizon-world/src/worldgen/tree/trunk.rs": "ba249287c25c2c156120e005a2432323e608f646f2635438135d9fcb6cac6c43", - "crates/horizon-world/src/worldgen/tree.rs": "bf4d5cf3ba210fdafdb701c0bea8be29e62f2186b7834d486a5a42eb4189173a", - "crates/horizon-world/src/worldgen/tree_blocks.rs": "bd72371a2c8caf9919dfdcc79d695cb4a1037d4ec3b094718f5be8bced90c6fc", - "crates/horizon-world/src/worldgen/underwater_magma.rs": "7317e40af5ee5a9780f90ce358fa5d3e7f5b3d513b731df6ff97754d9c2a0154", - "crates/horizon-world/src/worldgen/value_provider.rs": "b69be331b0baf9c7d4118f096a1eaca2e535676970a8638a9edb311f0a7d73b8", - "crates/horizon-world/src/worldgen/vegetation.rs": "175430dd525da6c2510f64dbc498d647deeed34428f7a4c3b0d600edd86667aa", - "crates/horizon-world/src/worldgen/vines.rs": "ee9b79b65012bd86a838241d2ef708680f7fe8eafc8aa656dae9cf2abf3c6418", - "crates/horizon-world/src/worldgen/weighted.rs": "839840aae25302933bbd97a81a2336330e2d03a0ad1684e1e16ac769ed408e6b", - "crates/horizon-world/src/worldgen/write_zone.rs": "8e17a179764d3f68c05882aef35f6810c28a0000f9a83e58bd6030660b76e64e", - "crates/horizon-world/src/worldgen.rs": "1c6de22dbbde5c8f484ec1818738301aced524a711132c03a2e0894850ec47d0", - "crates/horizon-world/examples/terrain_fixture.rs": "eb521404a3e850be522f3bda2f7c724c7d1b66e154e1bc53121b4e7511e5b1bd" - }, - "fixtures_sha256": { - "noise-aquifer-results/private-parity/rust-terrain-parity/inputs.txt": "a9ddccd711b0b6bdcae612a21f2b0dc143e156c9c97f47fce33071c7ceb660bd", - "noise-aquifer-results/private-parity/rust-terrain-parity/registries.json": "2a4e6b29a707ebbb7261f978b9e0dcd372f0c8548e2fb7e00c6bebb043bc49b9", - "noise-aquifer-results/private-parity/rust-terrain-parity/facts-client.json": "1d24883ee807b0b71473f0bbf8ed548ddaf712148caeb3fcc7aa13ab973a97b0", - "noise-aquifer-results/private-parity/rust-terrain-parity/facts-server.json": "1d24883ee807b0b71473f0bbf8ed548ddaf712148caeb3fcc7aa13ab973a97b0" - }, - "rust_output_sha256": "ff3612b2d998278b65c1b453b9df73ecf198151b8d094c150c16872106212bfc", - "references": [ - { - "side": "client", - "jar_sha256": "4508d006323f24fa02876310c192d739af56516eb259000ac50f0909a68c9a2d", - "output_sha256": "ff3612b2d998278b65c1b453b9df73ecf198151b8d094c150c16872106212bfc", - "matched_output_lines": 7950873 - }, - { - "side": "server", - "jar_sha256": "a362163eec5d1612d520772bc16e5b39c09e3b234fdc045f56bf544284ee8ae6", - "output_sha256": "ff3612b2d998278b65c1b453b9df73ecf198151b8d094c150c16872106212bfc", - "matched_output_lines": 7950873 - } - ], - "scope": "Noise-stage filling only, using actual vanilla NoiseBasedChunkGenerator.doFill and NoiseChunk with empty blending and empty or supplied rigid-piece/junction structure fields. Independently authenticated client/server registry resources and exported block identities/properties/air/fluid facts must agree. Rust compiles the final density and optional aquifer through a shared compiler/context, writes resident block sections, updates ocean-floor/world-surface worldgen heightmaps and records ordered per-section fluid postprocessing offsets. Comparisons cover every raw section state, heightmap word and postprocessing offset after each fill, all bundled routers/aquifers, both seeded random factories, synthetic roots, prefilled chunks, partial vertical volumes, repeated fills and structure-density bindings in final-density/aquifer graphs. Block behavior facts remain imported; actual biome properties and material rules are not evaluated. Surface/material/carver/feature/structure stages, nonempty blending and live structure discovery, complete generated worlds and gameplay/rendering remain pending.", - "harness_adjustments": { - "profile": "fast", - "storage": "/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56/noise-aquifer-results/private-parity", - "runner_sha256": "c9307ea06a7eecd0d9b78d500e114123d6342eaeaf4419614d5c49f7493b13ea", - "original_harness_sha256": "8bb8e716e957ef07d1117ed9939fab1b551ebab94d20e48d11f64bc477e4571f" - } -} diff --git a/noise-aquifer-results/validate_chunks.py b/noise-aquifer-results/validate_chunks.py deleted file mode 100644 index da7a0a87e..000000000 --- a/noise-aquifer-results/validate_chunks.py +++ /dev/null @@ -1,28 +0,0 @@ -"""Compare every terrain/decorated chunk and the extra diagnostic metadata exactly.""" -import subprocess,os,json,pathlib,hashlib,filecmp -root=pathlib.Path(__file__).resolve().parent -work=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56') -resources='/srv/bob-data/horizon/.local/horizon-client/26.3' -rows=[] -for dim in ['overworld','the_nether','the_end']: - for threads in [1,4]: - for seed,cx,cz in [(12345,0,0),(-1,32,-32)]: - label=f'{dim}-t{threads}-s{seed}-c{cx}_{cz}' - outputs={} - for version in ['baseline','candidate']: - path=work/('snap-'+label+'-'+version) - env=dict(os.environ,HORIZON_PROFILE_WARM='1',HORIZON_SNAPSHOT_PATH=str(path)) - cmd=[str(work/('snapshot-'+version)),resources,'--seed',str(seed),'--size','9','--threads',str(threads),'--dimension',dim,'--center',str(cx),str(cz)] - result=subprocess.run(cmd,env=env,text=True,capture_output=True,check=True) - (root/('parity-'+label+'-'+version+'.log')).write_text(result.stdout+result.stderr) - outputs[version]={phase:pathlib.Path(str(path)+'-'+phase+'.bin') for phase in ['terrain','decorated']} - for phase in ['terrain','decorated']: - a,b=(outputs[v][phase] for v in ['baseline','candidate']) - equal=filecmp.cmp(a,b,shallow=False) - row=dict(dimension=dim,threads=threads,seed=seed,center=[cx,cz],phase=phase,terrain_chunks=81,decorated_chunks=49 if phase=='decorated' else 0,baseline_path=str(a),candidate_path=str(b),baseline_bytes=a.stat().st_size,candidate_bytes=b.stat().st_size,equal=equal) - for version,p in [('baseline',a),('candidate',b)]: - with p.open('rb') as f:row[version+'_sha256']=hashlib.file_digest(f,'sha256').hexdigest() - rows.append(row) - (root/'chunk-parity.json').write_text(json.dumps(rows,indent=2)+'\n') - print(label,phase,'MATCH' if equal else 'MISMATCH',flush=True) - if not equal:raise SystemExit('Chunk differential failed; snapshots retained') diff --git a/noise-aquifer-results/validate_density.py b/noise-aquifer-results/validate_density.py deleted file mode 100644 index e9abca121..000000000 --- a/noise-aquifer-results/validate_density.py +++ /dev/null @@ -1,33 +0,0 @@ -"""Run the existing pinned density corpus with a fast-profile candidate and fresh Java oracles.""" -import sys,os,json,pathlib,subprocess,hashlib -root=pathlib.Path(__file__).resolve().parents[1] -sys.path.insert(0,str(root/'tools')) -import lab,test_rust_parity as base -work=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56/parity') -work.mkdir(parents=True,exist_ok=True) -(work/'minecraft').symlink_to('/srv/bob-data/horizon/.local/minecraft',target_is_directory=True) if not (work/'minecraft').exists() else None -lab.LOCAL=work -lock,jars,libraries=base.verify_artifacts() -shared=pathlib.Path('/srv/bob-data/horizon/.local/rust-density-parity') -prior=json.loads((shared/'report.json').read_text()) -inputs=shared/'inputs.txt' -assert lab.digest(inputs,'sha256')==prior['inputs_sha256'] -for name in ['mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDensityOracle.java','tools/test_density_parity.py','tools/test_rust_parity.py','tools/lab.py']: - assert lab.digest(root/name,'sha256')==prior['sources_sha256'][name], name -classes=work/'classes';classes.mkdir(exist_ok=True) -dependency_path=os.pathsep.join(map(str,libraries)) -source=root/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDensityOracle.java' -subprocess.run(['javac','--release',str(lock['minecraft']['java_major']),'-proc:none','-cp',str(jars['server'])+os.pathsep+dependency_path,'-d',str(classes),str(source)],check=True) -binary=pathlib.Path('/srv/bob-data/horizon-noise-aquifer-e477fa56/horizon-density-parity') -rust=work/'density-rust.txt' -with inputs.open('rb') as stdin,rust.open('wb') as stdout: - subprocess.run([str(binary)],stdin=stdin,stdout=stdout,check=True) -references=[] -for side,jar in jars.items(): - output=work/f'density-{side}.txt' - subprocess.run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jar),dependency_path]),'dev.horizonlab.parity.VanillaDensityOracle',str(inputs),str(output)],check=True) - lines=base.compare(output,rust) - references.append(dict(side=side,jar_sha256=lab.digest(jar,'sha256'),output_sha256=lab.digest(output,'sha256'),matched_output_lines=lines)) - print(side,lines,'lines match',flush=True) -report=dict(minecraft=lock['minecraft'],profile='fast',binary_sha256=lab.digest(binary,'sha256'),inputs_sha256=lab.digest(inputs,'sha256'),references=references,rust_output_sha256=lab.digest(rust,'sha256'),oracle_source_sha256=lab.digest(source,'sha256'),corpus_script_sha256=lab.digest(root/'tools/test_density_parity.py','sha256'),runner_sha256=lab.digest(pathlib.Path(__file__),'sha256'),sources_sha256=base.source_hashes([root/'crates/horizon-core/src/density/arithmetic.rs',root/'crates/horizon-core/src/density/tests.rs']),scope='Existing corpus authenticated against prior report and unchanged generator/oracle source; candidate and both checksum-pinned Java sides run freshly; density parity, not whole-game parity.') -(pathlib.Path(__file__).parent/'density-parity.json').write_text(json.dumps(report,indent=2)+'\n') diff --git a/noise-aquifer-results/validate_terrain.py b/noise-aquifer-results/validate_terrain.py deleted file mode 100644 index a49cb909f..000000000 --- a/noise-aquifer-results/validate_terrain.py +++ /dev/null @@ -1,27 +0,0 @@ -"""Run the repository's complete terrain-fill parity harness in isolated storage. - -Only the Rust build profile/path changes from release to fast. Oracle, corpus, -source authentication and exact comparison logic remain the repository's own. -""" -import pathlib,sys,json,hashlib -root=pathlib.Path(__file__).resolve().parents[1] -sys.path.insert(0,str(root/'tools')) -import lab -private=pathlib.Path(__file__).parent/'private-parity' -private.mkdir(exist_ok=True) -if not (private/'minecraft').exists(): - (private/'minecraft').symlink_to('/srv/bob-data/horizon/.local/minecraft',target_is_directory=True) -lab.LOCAL=private -script=root/'tools/test_terrain_parity.py' -source=script.read_text() -old='["cargo","build","--release","-p","horizon-world","--example","terrain_fixture"]' -assert source.count(old)==1 -source=source.replace(old,'["cargo","build","--profile","fast","-p","horizon-world","--example","terrain_fixture"]') -assert source.count('/"release/examples"/')==1 -source=source.replace('/"release/examples"/','/"fast/examples"/') -namespace={'__file__':str(script),'__name__':'horizon_terrain_fast_validation'} -exec(compile(source,str(script),'exec'),namespace) -namespace['main']() -report=json.loads((private/'rust-terrain-parity/report.json').read_text()) -report['harness_adjustments']={'profile':'fast','storage':str(private),'runner_sha256':hashlib.sha256(pathlib.Path(__file__).read_bytes()).hexdigest(),'original_harness_sha256':hashlib.sha256(script.read_bytes()).hexdigest()} -(pathlib.Path(__file__).parent/'terrain-parity.json').write_text(json.dumps(report,indent=2)+'\n') diff --git a/noise-aquifer-results/workloads.json b/noise-aquifer-results/workloads.json deleted file mode 100644 index a9c12e0a7..000000000 --- a/noise-aquifer-results/workloads.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "declared_before_candidate": true, - "baseline": "e4f8154cb4115aa1ee622381d9b12387cdf515d4", - "build_profile": "fast", - "primary_gate": {"dimension":"overworld", "seed":12345, "center":[0,0], "size":16, "threads":1}, - "qualification_matrix": {"dimensions":["overworld","the_nether","the_end"], "threads":[1,4], "seed":12345, "center":[0,0], "size":16}, - "cross_site_if_gate_passes": {"dimension":"overworld", "threads":[1,4], "seed":-1, "center":[32,-32], "size":16}, - "initialization":"discard offset 9x9 region center+(64,64) using same seeded generator before timing", - "measurement":"one discarded initialized process per executable per case, then five alternating baseline/candidate pairs; terrain+decoration normalized by 256 terrain chunks, 196 decorated interior chunks", - "cold":"separate one-worker overworld five alternating pairs without offset initialization if primary gate passes", - "early_stop":"stop after primary gate if no repeatable >=5% whole-terrain reduction" -} diff --git a/noise-aquifer-results/world-final-tests.log b/noise-aquifer-results/world-final-tests.log deleted file mode 100644 index 2f030d916..000000000 --- a/noise-aquifer-results/world-final-tests.log +++ /dev/null @@ -1,137 +0,0 @@ - Compiling horizon-core v0.1.0 (/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56/crates/horizon-core) - Compiling horizon-world v0.1.0 (/srv/bob-data/.t3/worktrees/horizon/t3-e477fa56/crates/horizon-world) - Finished `fast` profile [optimized] target(s) in 31.04s - Running unittests src/lib.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/horizon_world-383ae1a2b1e80bbc) - -running 91 tests -test chunk::tests::invalid_palette_data_fails_before_access ... ok -test datafix::json::tests::java_floating_point_strings ... ok -test datafix::json::tests::numbers_become_the_smallest_tag ... ok -test datafix::json::tests::lenient_reads_what_strict_refuses ... ok -test datafix::json::tests::stable_strings_sort_keys ... ok -test datafix::tests::current_data_is_left_alone ... ok -test datafix::tests::block_states_take_their_new_field_names ... ok -test datafix::text::tests::click_events_take_their_new_fields ... ok -test datafix::tests::level_data_of_1_20_moves_to_the_new_fields ... ok -test datafix::text::tests::legacy_hover_events_become_text ... ok -test level::data::cache::tests::cache_invalidates_sources_and_recovers_from_corruption ... ok -test level::data::cache::tests::resolved_snapshot_roundtrips_all_fields ... ok -test compression::tests::checksums_reject_corruption ... ok -test level::growth_tests::azalea_and_mangrove_grow ... ok -test level::growth_tests::crops_age_with_bone_meal ... ok -test level::growth_tests::eyeblossoms_open_at_night_and_wake_neighbours ... ok -test level::growth_tests::grass_bone_meal_places_grass_and_flowers ... ok -test level::growth_tests::huge_mushroom_and_fungus_grow ... ok -test level::growth_tests::lone_dark_oak_sapling_cannot_grow ... ok -test level::growth_tests::oak_sapling_grows_with_bone_meal ... ok -test level::growth_tests::random_ticks_advance_sapling_stage_then_grow ... ok -test level::growth_tests::single_saplings_grow ... ok -test level::growth_tests::sniffer_eggs_crack_twice_then_hatch_a_snifflet ... ok -test level::growth_tests::snowy_biomes_freeze_and_snow ... ok -test level::growth_tests::tall_flowers_and_seagrass ... ok -test level::growth_tests::turtle_eggs_crack_at_dawn_on_sand ... ok -test level::growth_tests::two_by_two_saplings_grow ... ok -test level::tests::bucket_source_removal_drains_spread_water ... ok -test level::tests::calibrated_sensor_is_active_for_ten_ticks ... ok -test datafix::tests::item_stacks_of_1_20_take_components ... ok -test level::tests::catalyst_bloom_lasts_eight_ticks ... ok -test level::tests::creaking_heart_follows_its_logs_and_the_night ... ok -test level::tests::crops_grow_and_leaves_decay ... ok -test level::tests::dispenser_buckets_pick_up_and_empty ... ok -test level::tests::doors_beds_and_plants_place_both_halves ... ok -test level::tests::dripstone_fills_cauldrons ... ok -test level::tests::fences_connect_and_disconnect ... ok -test level::tests::lava_meets_water ... ok -test level::tests::levers_power_wire_through_interaction ... ok -test level::tests::mining_lights_redstone_ore_until_its_random_tick ... ok -test level::tests::pistons_pop_fragile_blocks_and_refuse_obsidian ... ok -test level::tests::pistons_push_and_sticky_pistons_pull ... ok -test level::tests::placement_merges_slabs_and_stacks ... ok -test level::tests::placement_orients_blocks ... ok -test level::tests::placing_and_breaking_report_the_affected_state ... ok -test level::tests::player_breaks_fire_with_extinguish_not_generic_break_event ... ok -test level::tests::redstone_lever_wire_and_lamp ... ok -test level::tests::repeater_delays_and_torch_inverts ... ok -test level::tests::sand_falls_and_concrete_solidifies ... ok -test level::tests::sculk_charge_spreads_veins_and_sculk ... ok -test level::tests::sculk_sensor_phases_and_signal ... ok -test level::tests::shrieker_responds_when_the_shriek_ends ... ok -test level::tests::snowy_grass_and_chests_pair ... ok -test level::tests::stairs_form_corners ... ok -test level::tests::state_table_matches_registry ... ok -test level::tests::torch_and_door_halves_break_with_support ... ok -test level::tests::walls_and_panes_connect ... ok -test level::tests::water_falls_and_makes_sources ... ok -test level::tests::water_spreads_on_a_floor ... ok -test level::tests::waterlogged_blocks_schedule_water ... ok -test nbt::tests::duplicate_keys_last_wins_and_nan_output_is_canonical ... ok -test nbt::tests::modified_utf_and_mixed_lists_preserve_java_values ... ok -test nbt::tests::malformed_lengths_truncation_limits_and_utf_are_rejected ... ok -test nbt::tests::snbt_parses_typed_values ... ok -test nbt::tests::wire_node_budget_includes_mixed_list_wrappers ... ok -test nbt::tests::depth_boundary_and_every_truncated_prefix ... ok -test worldgen::aquifer::config::tests::bindings_share_named_cache_and_failed_decode_is_atomic ... ok -test worldgen::density::tests::codec_validation_rejects_invalid_gradients_intervals_and_splines ... ok -test worldgen::density::tests::forward_references_share_named_holders_and_reject_cycles_or_missing_values ... ok -test worldgen::density::tests::numeric_tokens_keep_negative_zero_and_avoid_double_rounding ... ok -test worldgen::end_spike::tests::spike_layout_is_a_permutation_of_sizes ... ok -test worldgen::decoration_order::tests::decorated_chunks_keep_their_place ... ok -test worldgen::generator::tests::ring_positions_are_shared_by_seed_and_dimension ... ok -test worldgen::generator::tests::parameter_reports_quantize_like_vanilla ... ok -test worldgen::long_set::tests::every_key_is_visited_once_after_growth ... ok -test worldgen::decoration_order::tests::blocked_by_lower_ranks_within_two ... ok -test worldgen::long_set::tests::single_and_zero_keys ... ok -test worldgen::spawn_finder::tests::the_closest_fitting_column_wins ... ok -test worldgen::material_condition::codec::tests::forward_references_are_stable_and_invalid_graphs_fail_atomically ... ok -test worldgen::tests::decimal_integers_wrap_without_floating_point_conversion ... ok -test worldgen::material_condition::library::tests::forward_rule_holders_and_invalid_graphs_are_atomic ... ok -test worldgen::tests::codec_defaults_and_empty_modifiers_match_explicit_parameters ... ok -test worldgen::router::tests::roots_share_holder_cache_and_failed_router_leaves_graph_unchanged ... ok -test worldgen::tags::tests::required_edges_precede_optional_edges_and_missing_tags_do_not_poison_siblings ... ok -test worldgen::tags::tests::invalid_replacement_keeps_entries_and_codec_error_can_create_empty_tag ... ok -test worldgen::tree_blocks::tests::fisher_yates_matches_native_draw_order ... ok -test worldgen::tree_blocks::tests::pos_set_iterates_in_java_hash_bucket_order ... ok -test worldgen::decoration_order::tests::first_wave_matches_vanilla ... ok -test compression::tests::all_codecs_roundtrip_and_enforce_limits ... ok -test chunk::tests::palette_grows_across_word_widths_and_compacts_to_uniform ... ok -test worldgen::generator_structures::tests::ring_work_shared_between_threads_matches_serial_search ... ok - -test result: ok. 91 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.03s - - Running tests/biome_region.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/biome_region-2a454048d1e169a1) - -running 1 test -test resident_biomes_track_replacement_fills_and_reject_ambiguous_chunks ... ok - -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running tests/carving_stage.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/carving_stage-57246acdef3b0341) - -running 1 test -test filters_and_uncarvable_blocks_precede_aquifers_and_failures_keep_surface_restoration ... ok - -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running tests/material_stage.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/material_stage-7e3fca6c83435cb1) - -running 2 tests -test top_material_retains_context_on_failure_and_ignores_possible_biome_shortcuts ... ok -test density_context_survives_success_binding_failure_and_partial_chunk_failure ... ok - -test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running tests/retrogen_biomes.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/retrogen_biomes-4141ee3648931f67) - -running 2 tests -test candidates_precede_old_columns_and_errors_short_circuit ... ok -test upgrade_fill_preserves_columns_and_section_atomicity ... ok - -test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s - - Running tests/tick_data.rs (/srv/bob-data/horizon-stage3d-target/fast/deps/tick_data-34687dfe40490ea0) - -running 2 tests -test numeric_codec_narrowing_and_malformed_data ... ok -test saved_chunk_ticks_filter_coordinates_and_write_atomically ... ok - -test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s From c47b30fcf0db87b8023e6784d941a4f06524b453 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Sun, 18 Oct 2026 03:49:02 +0100 Subject: [PATCH 06/28] Optimize binary density, Beardifier and Perlin sampling --- crates/horizon-core/src/density/arithmetic.rs | 91 ++++++++++++++++++- crates/horizon-core/src/density/beardifier.rs | 11 ++- crates/horizon-core/src/density/tests.rs | 72 +++++++++++++++ crates/horizon-core/src/noise/perlin.rs | 29 ++++-- docs/noise-aquifer-benchmark.md | 52 +++++++++-- 5 files changed, 233 insertions(+), 22 deletions(-) diff --git a/crates/horizon-core/src/density/arithmetic.rs b/crates/horizon-core/src/density/arithmetic.rs index 7961adf04..51892ffc7 100644 --- a/crates/horizon-core/src/density/arithmetic.rs +++ b/crates/horizon-core/src/density/arithmetic.rs @@ -283,6 +283,23 @@ impl BinaryOp { } } } + fn apply_bulk(self, buffer: &mut [f32], right: &[f32]) { + macro_rules! apply { + ($operation:expr) => { + for (left, &right) in buffer.iter_mut().zip(right) { + *left = ($operation)(*left, right); + } + }; + } + match self { + Self::Add => apply!(|left, right| left + right), + Self::Subtract => apply!(|left, right| left - right), + Self::Multiply => apply!(|left, right| left * right), + Self::Divide => apply!(|left, right| left / right), + Self::Minimum { .. } => apply!(|left, right| if right < left { right } else { left }), + Self::Maximum { .. } => apply!(|left, right| if right > left { right } else { left }), + } + } } #[derive(Clone, Debug)] pub struct BinarySampler { @@ -319,9 +336,7 @@ impl DensitySampler for BinarySampler { self.left.sample_volume(context, buffer, volume)?; context.with_buffer(volume.size(), |context, right| { self.right.sample_volume(context, right, volume)?; - for (left, right) in buffer.iter_mut().zip(right) { - *left = self.operation.apply(*left, *right, true); - } + self.operation.apply_bulk(buffer, right); Ok(()) }) } @@ -420,4 +435,74 @@ mod bulk_tests { } } } + + #[inline(never)] + fn dispatched_binary_reference(operation: BinaryOp, left: f32, right: f32) -> f32 { + operation.apply(left, right, true) + } + + #[test] + fn fixed_binary_loops_preserve_float_bits() { + let edges = [ + 0, + 0x8000_0000, + 1, + 0x8000_0001, + 0x007f_ffff, + 0x0080_0000, + 0x3f80_0000, + 0xbf80_0000, + 0x7f7f_ffff, + 0xff7f_ffff, + 0x7f80_0000, + 0xff80_0000, + 0x7fc0_0000, + 0x7fa0_0001, + 0xffc0_1234, + ]; + let mut left = Vec::new(); + let mut right = Vec::new(); + for a in edges { + for b in edges { + left.push(f32::from_bits(a)); + right.push(f32::from_bits(b)); + } + } + let mut bits = 0x484f_5249u32; + for _ in 0..8192 { + bits ^= bits << 13; + bits ^= bits >> 17; + bits ^= bits << 5; + left.push(f32::from_bits(bits)); + bits ^= bits << 13; + bits ^= bits >> 17; + bits ^= bits << 5; + right.push(f32::from_bits(bits)); + } + for operation in [ + BinaryOp::Add, + BinaryOp::Subtract, + BinaryOp::Multiply, + BinaryOp::Divide, + BinaryOp::Minimum { + right_min: f32::NEG_INFINITY, + }, + BinaryOp::Maximum { + right_max: f32::INFINITY, + }, + ] { + for length in [0, 1, 3, 16, 257, left.len()] { + let mut actual = left[..length].to_vec(); + operation.apply_bulk(&mut actual, &right[..length]); + for (i, actual) in actual.into_iter().enumerate() { + let expected = dispatched_binary_reference(operation, left[i], right[i]); + assert_eq!( + actual.to_bits(), + expected.to_bits(), + "{operation:?}, index {i}" + ); + } + } + } + } } diff --git a/crates/horizon-core/src/density/beardifier.rs b/crates/horizon-core/src/density/beardifier.rs index 73b94a066..2e2868fb8 100644 --- a/crates/horizon-core/src/density/beardifier.rs +++ b/crates/horizon-core/src/density/beardifier.rs @@ -77,6 +77,9 @@ impl Beardifier { } fn sample_unchecked(&self, [x, y, z]: [i32; 3]) -> f32 { let mut value = 0.; + // The kernel is a process-wide constant; resolving it once keeps the + // per-piece and per-junction beard evaluations off the OnceLock. + let kernel = kernel(); for piece in &self.pieces { let low = piece.bounds.minimum; let high = piece.bounds.maximum; @@ -98,7 +101,7 @@ impl Beardifier { TerrainAdjustment::None => 0., TerrainAdjustment::Bury => bury(dx as f32, distance_y as f32 / 2., dz as f32), TerrainAdjustment::BeardThin | TerrainAdjustment::BeardBox => { - beard(dx, distance_y, dz, dy) * 0.8 + beard(kernel, dx, distance_y, dz, dy) * 0.8 } TerrainAdjustment::Encapsulate => { bury(dx as f32 / 2., distance_y as f32 / 2., dz as f32 / 2.) * 0.8 @@ -109,7 +112,7 @@ impl Beardifier { let dx = x.wrapping_sub(junction.source_x); let dy = y.wrapping_sub(junction.source_ground_y); let dz = z.wrapping_sub(junction.source_z); - value += beard(dx, dy, dz, dy) * 0.4; + value += beard(kernel, dx, dy, dz, dy) * 0.4; } value } @@ -184,7 +187,7 @@ fn bury(x: f32, y: f32, z: f32) -> f32 { 1. - squared.sqrt() / 6. } } -fn beard(x: i32, y: i32, z: i32, ground_delta: i32) -> f32 { +fn beard(kernel: &[f32; 13824], x: i32, y: i32, z: i32, ground_delta: i32) -> f32 { let indices = [x, y, z].map(|v| v.wrapping_add(12)); if indices.iter().any(|v| !(0..24).contains(v)) { return 0.; @@ -192,7 +195,7 @@ fn beard(x: i32, y: i32, z: i32, ground_delta: i32) -> f32 { let vertical = ground_delta as f32 + 0.5; let squared = (x as f32 * x as f32 + vertical * vertical) + z as f32 * z as f32; let factor = (-vertical * fast_inverse_sqrt(f64::from(squared / 2.)) as f32) / 2.; - factor * kernel()[((indices[2] * 24 + indices[0]) * 24 + indices[1]) as usize] + factor * kernel[((indices[2] * 24 + indices[0]) * 24 + indices[1]) as usize] } fn fast_inverse_sqrt(value: f64) -> f64 { let half = 0.5 * value; diff --git a/crates/horizon-core/src/density/tests.rs b/crates/horizon-core/src/density/tests.rs index f94b95356..1c0497d68 100644 --- a/crates/horizon-core/src/density/tests.rs +++ b/crates/horizon-core/src/density/tests.rs @@ -795,3 +795,75 @@ fn unary_bulk_keeps_child_failure_writes_and_full_buffer_tail() { .unwrap(); assert_eq!(buffer, [9.0; 3]); } + +#[test] +fn binary_bulk_preserves_child_failure_order_and_output() { + #[derive(Debug)] + struct Input { + name: &'static str, + value: f32, + fail: bool, + calls: Arc>>, + } + impl DensitySampler for Input { + fn sample_value(&self, _: &mut SamplerContext, _: [i32; 3]) -> Result { + unreachable!("bulk-only fixture") + } + fn sample_volume( + &self, + _: &mut SamplerContext, + buffer: &mut [f32], + _: DensityVolume, + ) -> Result<(), SampleError> { + self.calls.lock().unwrap().push(self.name); + buffer.fill(self.value); + if self.fail { + Err(SampleError::ZeroGradientPeriod) + } else { + Ok(()) + } + } + } + let volume = DensityVolume::new([1; 3], [0; 3], [1; 3]).unwrap(); + for left_fails in [true, false] { + let calls = Arc::new(std::sync::Mutex::new(Vec::new())); + let sampler = BinarySampler { + left: Arc::new(Input { + name: "left", + value: 3.0, + fail: left_fails, + calls: calls.clone(), + }), + right: Arc::new(Input { + name: "right", + value: 7.0, + fail: true, + calls: calls.clone(), + }), + operation: BinaryOp::Multiply, + }; + let mut context = SamplerContext::default(); + let mut wrong_size = [17.0; 2]; + assert!( + sampler + .sample_volume(&mut context, &mut wrong_size, volume) + .is_err() + ); + assert_eq!(wrong_size, [17.0; 2]); + assert!(calls.lock().unwrap().is_empty()); + let mut output = [17.0]; + assert_eq!( + sampler.sample_volume(&mut context, &mut output, volume), + Err(SampleError::ZeroGradientPeriod) + ); + assert_eq!(output, [3.0]); + assert_eq!( + *calls.lock().unwrap(), + if left_fails { + vec!["left"] + } else { + vec!["left", "right"] + } + ); + } +} diff --git a/crates/horizon-core/src/noise/perlin.rs b/crates/horizon-core/src/noise/perlin.rs index 101ded427..725373eff 100644 --- a/crates/horizon-core/src/noise/perlin.rs +++ b/crates/horizon-core/src/noise/perlin.rs @@ -40,18 +40,29 @@ impl PerlinNoise { } fn gradients(&self, cell: [i32; 3]) -> [[i32; 3]; 8] { - let p = self.table.permute(cell[0]); - let q = self.table.permute(cell[0].wrapping_add(1)); - let lower = self.table.permute(p.wrapping_add(cell[1])); - let upper = self.table.permute(p.wrapping_add(cell[1]).wrapping_add(1)); - let lower_x = self.table.permute(q.wrapping_add(cell[1])); - let upper_x = self.table.permute(q.wrapping_add(cell[1]).wrapping_add(1)); + self.gradients_at( + self.table.permute(cell[0]), + self.table.permute(cell[0].wrapping_add(1)), + cell[1], + cell[2], + ) + } + + /// Corner gradients for a Y cell, with the X column's permutation already + /// resolved. `add_volume` reuses one X column across every Y, so hoisting + /// the two X permutes out of that loop avoids repeating them per Y. + #[inline] + fn gradients_at(&self, p: i32, q: i32, cell_y: i32, cell_z: i32) -> [[i32; 3]; 8] { + let lower = self.table.permute(p.wrapping_add(cell_y)); + let upper = self.table.permute(p.wrapping_add(cell_y).wrapping_add(1)); + let lower_x = self.table.permute(q.wrapping_add(cell_y)); + let upper_x = self.table.permute(q.wrapping_add(cell_y).wrapping_add(1)); let rows = [ lower, lower_x, upper, upper_x, lower, lower_x, upper, upper_x, ]; std::array::from_fn(|i| { self.table - .gradient(rows[i].wrapping_add(cell[2]).wrapping_add((i / 4) as i32)) + .gradient(rows[i].wrapping_add(cell_z).wrapping_add((i / 4) as i32)) }) } @@ -166,6 +177,8 @@ impl PerlinNoise { let cell_x = floor_i32(shifted_x); let dx = (shifted_x - f64::from(cell_x)) as f32; let fade_x = smoothstep(dx); + let p = self.table.permute(cell_x); + let q = self.table.permute(cell_x.wrapping_add(1)); let mut previous_y = i32::MIN; let mut xz_dots = [0.0_f32; 8]; let mut y_gradients = [0.0_f32; 8]; @@ -176,7 +189,7 @@ impl PerlinNoise { let dy = shifted_y - f64::from(cell_y); let fade_y = smoothstep(dy as f32); if previous_y != cell_y { - let gradients = self.gradients([cell_x, cell_y, cell_z]); + let gradients = self.gradients_at(p, q, cell_y, cell_z); for i in 0..8 { xz_dots[i] = gradients[i][0] as f32 * (dx - (i & 1) as f32) + gradients[i][2] as f32 * (dz - ((i >> 2) & 1) as f32); diff --git a/docs/noise-aquifer-benchmark.md b/docs/noise-aquifer-benchmark.md index a9634c743..e14645247 100644 --- a/docs/noise-aquifer-benchmark.md +++ b/docs/noise-aquifer-benchmark.md @@ -1,13 +1,51 @@ -# Bulk unary density evaluation benchmark +# Bulk density and noise generation benchmark -Dispatching unary operations once per bulk buffer reduced initialized Overworld terrain generation from 12.271 to 10.566 ms/input chunk (13.89%) with one worker and from 3.838 to 3.408 (11.19%) with four. Terrain plus decoration improved 11.70% and 9.48%. A second seed/site improved terrain 13.66% and 13.70%. These are incremental results against baseline `e4f8154cb4115aa1ee622381d9b12387cdf515d4`. +The PR dispatches unary and binary density operations once per bulk buffer, resolves the shared Beardifier kernel once per sampled position, and reuses Perlin X-column permutations across the Y loop. Binary bit-exact tests cover every operation, distinct NaN payloads, signed zeros, infinities, subnormals, random float pairs and SIMD/tail-sized buffers. Child-failure tests retain left/right evaluation order and partial output. Scalar shortcuts, arithmetic expressions, RNG consumption and generation traversal are preserved. -Each case used one discarded pair and five measured alternating baseline/candidate pairs. The primary case used seed 12345, center (0,0), 256 terrain chunks and 196 decorated interior chunks. An offset 9×9 generation pass initialized the seeded generator without pre-generating target chunks. The second site used seed -1 at (32,-32). Timing is complete terrain wall time divided by input count; combined results retain border work. Cold initialization was measured separately. +## Whole-terrain measurements -Nether terrain medians improved 3.15% / 2.03% with one/four workers; End improved 3.03% / 5.39%. Some individual Nether/End pairs regressed or had large favorable outliers. Gains are workload-dependent and should not be generalized to every seed, biome, compiler, or platform. Peak RSS was effectively unchanged and no new heap buffer was introduced. +**Times below are complete terrain wall elapsed divided by 256 input chunks, with no thread multiplier.** Four-worker figures are elapsed latency/throughput measurements, not per-thread CPU costs. Combined time adds the complete decoration phase, still divided by 256; 196 interior chunks are decorated with unchanged border work. At the primary site, 256 terrain chunks take about 2.578 seconds with one worker versus 0.860 seconds with four: approximately 3.00× throughput, or 75% of ideal fourfold scaling. Two/eight-worker behavior was not measured. -Measured on AMD Ryzen 5 5600X, 32 GiB RAM, Linux, Rust 1.99.0, optimized `fast` profile (release optimization, LTO off, 16 codegen units). Builds and measurements ran sequentially; background desktop activity was not isolated. The benchmark used the existing chunkgen benchmark with identical optional initialization and exact elapsed-time instrumentation on both revisions. `crates/horizon-world/examples/chunkgen_bench.rs` provides the standard workload entry point; its human-readable thread-multiplied ms/chunk display must not be mistaken for elapsed/count. +Fresh equivalent optimized builds compare baseline `e4f8154cb4115aa1ee622381d9b12387cdf515d4` with the extended candidate. Every case has one discarded process pair, then five measured pairs alternating baseline/candidate order. Initialized processes first generate and discard the same offset 9×9 region at center+(64,64), using the same seeded generator, before timing fresh measured workers. This excludes lazy ring initialization without pre-generating target chunks. All cases use size 16; primary seed/site is 12345/(0,0), second Overworld seed/site is -1/(32,-32). -Validation passed: 191 targeted Rust tests; fresh pinned Java client/server density parity (15,524,627 lines each); terrain-fill parity (114 fixtures, 200 fills, 7,950,873 lines per Java side); and 24 exact terrain/decorated region comparisons across three dimensions, two seeds/sites, and one/four workers. Snapshots included block states and palettes, quart biomes, entities/block entities, scheduled ticks, all six heightmaps, ordered postprocessing, non-air counts, and chunk metadata. This establishes parity within the declared corpus, not complete gameplay parity. +Medians below are baseline → extended candidate, ms/input chunk, followed by percent reduction. -The repository quick PR check also passed public-tree validation, Python tests, formatting, clippy, and core tests. Generated timing files, diagnostic runners, patches, and validation logs are retained locally outside the repository and are not part of this PR. +- **overworld, 1 worker(s):** terrain 12.685400 → 10.069365 (20.62%); combined 14.696298 → 12.105007 (17.63%). +- **overworld, 4 worker(s):** terrain 4.045564 → 3.359536 (16.96%); combined 4.663124 → 3.944952 (15.40%). +- **the_nether, 1 worker(s):** terrain 5.088375 → 4.848149 (4.72%); combined 5.481617 → 5.239165 (4.42%). +- **the_nether, 4 worker(s):** terrain 1.446298 → 1.366468 (5.52%); combined 1.574890 → 1.472913 (6.48%). +- **the_end, 1 worker(s):** terrain 1.085323 → 0.980046 (9.70%); combined 1.161651 → 1.053080 (9.35%). +- **the_end, 4 worker(s):** terrain 0.281733 → 0.259724 (7.81%); combined 0.312280 → 0.288982 (7.46%). +- **overworld, 1 worker(s), second site:** terrain 11.585829 → 9.079823 (21.63%); combined 12.650823 → 10.145760 (19.80%). +- **overworld, 4 worker(s), second site:** terrain 3.105819 → 2.519504 (18.88%); combined 3.410155 → 2.812551 (17.52%). +- **overworld, 1 worker(s), non-initialized generator:** terrain 23.429316 → 20.942006 (10.62%); combined 25.599745 → 23.005476 (10.13%). + +The non-initialized case retains lazy startup work and is separate from recurring-cost qualification; resource loading is outside all terrain brackets. All 45 measured terrain pairs improved, but Nether one-worker median terrain improvement remains below 5%. Results are workload-dependent. The primary one-worker noise bracket improves 5.901774 → 4.773963 ms/chunk (19.11%); shared bulk material-density work also improves, with surface 4.576660 → 3.181641 (30.48%). Whole-terrain gains must not be described as noise-stage-only gains. Parallel stage brackets are aggregate worker elapsed and are not exclusive CPU shares. + +## Added benefit beyond unary dispatch + +A separate five-pair alternating comparison uses the existing unary-only PR revision `594b50278044df6b72b641cd02d5050925c86203` as baseline. It uses the same initialized primary workload and fresh builds. These numbers measure the binary/Beardifier/Perlin additions together; they do not assign a separate speedup to each addition. + +- **1 worker(s):** terrain 10.913267 → 10.034900 (8.05%); combined 12.867017 → 12.079432 (6.12%). +- **4 worker(s):** terrain 3.536831 → 3.312338 (6.35%); combined 4.110268 → 3.897104 (5.19%). + +All ten incremental terrain pairs improved. Pair reductions ranged 4.72–9.93% with one worker and 2.10–8.61% with four, so not every individual pair exceeds 5%. A preliminary gate was excluded in its entirety because a concurrent Horizon client consumed roughly seven cores. Its raw samples remain in `contended-gate/`; all qualification runs began after the client was closed. No individual samples were selectively removed from the restarted runs. + +## Machine and validation + +AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM, Linux, Rust 1.99.0. Optimized `fast` profile: release optimization, LTO disabled, 16 codegen units. Builds and timed processes were sequential; ordinary desktop activity was not isolated. Primary terrain process CPU medians are 12.4 → 10.0 ms/input chunk (one worker) and 15.9 → 13.2 (four), using coarse 100 Hz accounting. Peak RSS is effectively unchanged: 786288 → 786256 KiB and 833496 → 833528 KiB. No new heap buffer is introduced. Executable text increases 1804 bytes against the original baseline and decreases 1056 bytes against the unary-only revision. + +Validation of the extended candidate passed: + +- 193 targeted optimized Rust unit/integration tests, including binary floating-point and failure-order tests, density/world fields, storage/palettes, material/carving stages, biome regions, retrogen and ticks. +- Fresh pinned Java client/server density parity: 15,524,627 output lines per side. +- Dedicated noise parity: 1,443,539 lines per side, covering Perlin/smeared bulk paths, strided/wrapped volumes, buffer tails, constructor RNG and derivatives. +- Dedicated Beardifier/structure-density parity: 183 fixtures, 1,360,095 lines per side. +- Terrain-fill parity: 114 fixtures, 200 fills, 7,950,873 lines per side, including prefilled chunks, repeated fills, partial vertical volumes, aquifers, WG heightmaps and ordered postprocessing. +- 24/24 exact region phase comparisons: three dimensions × two seeds/sites × one/four workers, each with 81 retained chunks and 49 interior decorations. Every retained chunk is compared before and after decoration, including borders. Snapshots include raw/public block reads and palettes, quart biomes, entities/block entities as binary NBT, complete scheduled ticks, all six heightmaps, ordered postprocessing, actual non-air counts and chunk metadata. Temporary diagnostic accessors were removed from production source. + +This validates the declared corpora and sites, not every possible seed, biome or platform. Lighting, meshing, saving, streaming and full application startup were not benchmarked. + +The existing `crates/horizon-world/examples/chunkgen_bench.rs` is the standard workload entry point. Both performance builds used the same saved diagnostic source adding optional generator initialization and exact elapsed/count output; its thread-multiplied human display was not used. Diagnostic builds use `CARGO_TARGET_DIR=/srv/bob-data/horizon-stage3d-target cargo build --profile fast -p horizon-world --example chunkgen_profile`. Raw timings, exact commands, binary/source hashes, scripts and parity outputs are retained outside Git at `/srv/bob-data/horizon-noise-aquifer-e477fa56/extension/`: `gate-raw.json`, `matrix-raw.json`, `summary.json`, `marginal/marginal-raw.json`, `binary-hashes.json`, and the `*-parity.json` reports. Prepared resources are `/srv/bob-data/horizon/.local/horizon-client/26.3`. Generated artifacts and private fixtures remain outside the PR. + +The repository quick PR self-check also passes: public-tree validation, workspace rustfmt, workspace/all-target clippy with warnings denied, and 96 full core-crate tests. Relevant pinned Java suites were run separately as listed above. A production-only rebuild after removing diagnostic support has byte-identical executable instructions and read-only constants to the measured candidate. From 0b5f0a3edf49eddbf010d34ce416e1f0a2a40b77 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Sun, 18 Oct 2026 03:56:31 +0100 Subject: [PATCH 07/28] Document 1 2 4 and 8 worker scaling measurements --- docs/noise-aquifer-benchmark.md | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/docs/noise-aquifer-benchmark.md b/docs/noise-aquifer-benchmark.md index e14645247..a68f18f2d 100644 --- a/docs/noise-aquifer-benchmark.md +++ b/docs/noise-aquifer-benchmark.md @@ -4,7 +4,7 @@ The PR dispatches unary and binary density operations once per bulk buffer, reso ## Whole-terrain measurements -**Times below are complete terrain wall elapsed divided by 256 input chunks, with no thread multiplier.** Four-worker figures are elapsed latency/throughput measurements, not per-thread CPU costs. Combined time adds the complete decoration phase, still divided by 256; 196 interior chunks are decorated with unchanged border work. At the primary site, 256 terrain chunks take about 2.578 seconds with one worker versus 0.860 seconds with four: approximately 3.00× throughput, or 75% of ideal fourfold scaling. Two/eight-worker behavior was not measured. +**Times below are complete terrain wall elapsed divided by 256 input chunks, with no thread multiplier.** Four-worker figures are elapsed latency/throughput measurements, not per-thread CPU costs. Combined time adds the complete decoration phase, still divided by 256; 196 interior chunks are decorated with unchanged border work. At the primary site, 256 terrain chunks take about 2.578 seconds with one worker versus 0.860 seconds with four: approximately 3.00× throughput, or 75% of ideal fourfold scaling. A subsequent 1/2/4/8-worker scaling experiment is reported below. Fresh equivalent optimized builds compare baseline `e4f8154cb4115aa1ee622381d9b12387cdf515d4` with the extended candidate. Every case has one discarded process pair, then five measured pairs alternating baseline/candidate order. Initialized processes first generate and discard the same offset 9×9 region at center+(64,64), using the same seeded generator, before timing fresh measured workers. This excludes lazy ring initialization without pre-generating target chunks. All cases use size 16; primary seed/site is 12345/(0,0), second Overworld seed/site is -1/(32,-32). @@ -31,6 +31,19 @@ A separate five-pair alternating comparison uses the existing unary-only PR revi All ten incremental terrain pairs improved. Pair reductions ranged 4.72–9.93% with one worker and 2.10–8.61% with four, so not every individual pair exceeds 5%. A preliminary gate was excluded in its entirety because a concurrent Horizon client consumed roughly seven cores. Its raw samples remain in `contended-gate/`; all qualification runs began after the client was closed. No individual samples were selectively removed from the restarted runs. +## Worker scaling follow-up + +Candidate revision `c47b30fcf0db87b8023e6784d941a4f06524b453` was tested at 1, 2, 4 and 8 workers on the same primary initialized Overworld workload. The saved `final-candidate` optimized binary is used without rebuilding or changing instrumentation. After one discarded process per worker count, eight measured processes per count run sequentially. Worker orders `[1,2,4,8]`, `[2,8,1,4]`, `[4,1,8,2]`, `[8,4,2,1]` repeat twice, placing each count in each order position twice. Every process initializes its generator using the same offset 9×9 region before measuring 256 terrain chunks and 196 interior decorations. No baseline comparison or new correctness claim is inferred from this scaling experiment. + +| Workers | Terrain median ms/chunk (min–max) | Terrain chunks/s | Speedup | Efficiency | Combined median ms/chunk | Combined speedup | +| --- | --- | --- | --- | --- | --- | --- | +| 1 | 9.994644 (9.842544–10.312603) | 100.05 | 1.000× | 100.0% | 11.950737 | 1.000× | +| 2 | 5.580046 (5.499388–5.772284) | 179.21 | 1.791× | 89.6% | 6.644499 | 1.799× | +| 4 | 3.405281 (3.238112–3.525516) | 293.66 | 2.935× | 73.4% | 3.996531 | 2.990× | +| 8 | 2.750915 (2.662450–2.915874) | 363.52 | 3.633× | 45.4% | 3.220818 | 3.710× | + +Speedup is the one-worker median divided by the respective median; efficiency divides speedup by worker count. Eight workers give 23.8% more terrain throughput than four workers, with 19.2% lower wall ms/chunk. This is sublinear scaling on this machine and site; eight workers exceed the six physical cores, and this experiment does not identify the causes of diminishing returns. Ordinary desktop activity was not isolated. All 32 measured runs are retained. Raw samples, per-process logs, binary SHA-256, protocol, runnable script and combined ranges are in `/srv/bob-data/horizon-noise-aquifer-e477fa56/extension/scaling/` (`raw.json`, `summary.json`, `protocol.json`, `run.py`). Run with `python /srv/bob-data/horizon-noise-aquifer-e477fa56/extension/scaling/run.py`; the script uses the prepared resources and saved optimized binary, requiring no build. The earlier comparison medians above remain unchanged. + ## Machine and validation AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM, Linux, Rust 1.99.0. Optimized `fast` profile: release optimization, LTO disabled, 16 codegen units. Builds and timed processes were sequential; ordinary desktop activity was not isolated. Primary terrain process CPU medians are 12.4 → 10.0 ms/input chunk (one worker) and 15.9 → 13.2 (four), using coarse 100 Hz accounting. Peak RSS is effectively unchanged: 786288 → 786256 KiB and 833496 → 833528 KiB. No new heap buffer is introduced. Executable text increases 1804 bytes against the original baseline and decreases 1056 bytes against the unary-only revision. From fde95ff20e31a6503b4885ba8503301dc9dc100b Mon Sep 17 00:00:00 2001 From: Cosmic <84875247+Online5277@users.noreply.github.com> Date: Sun, 18 Oct 2026 05:30:56 -0400 Subject: [PATCH 08/28] Build distant terrain from sparse seed samples and layered voxel columns --- crates/horizon-client/src/fog.rs | 47 + crates/horizon-client/src/game.rs | 83 +- crates/horizon-client/src/game/control.rs | 5 + crates/horizon-client/src/game/remote.rs | 3 + crates/horizon-client/src/game/render_tick.rs | 1 + crates/horizon-client/src/lod.rs | 1622 +++++++++++++---- crates/horizon-client/src/lod/mesh.rs | 1102 +++++++++++ crates/horizon-client/src/save.rs | 475 ++++- crates/horizon-client/src/streaming.rs | 29 + crates/horizon-client/src/vanillagen.rs | 44 +- crates/horizon-client/src/vanillagen/lod.rs | 700 +++++++ .../src/vanillagen/lod/vegetation.rs | 309 ++++ crates/horizon-core/src/density/cache.rs | 8 + .../horizon-core/src/density/interpolation.rs | 12 + crates/horizon-core/src/density/mod.rs | 1 + crates/horizon-core/src/density/tests.rs | 22 + .../horizon-world/src/worldgen/generator.rs | 370 +++- docs/graphics.md | 12 +- docs/shader-packs.md | 2 +- 19 files changed, 4326 insertions(+), 521 deletions(-) create mode 100644 crates/horizon-client/src/lod/mesh.rs create mode 100644 crates/horizon-client/src/vanillagen/lod.rs create mode 100644 crates/horizon-client/src/vanillagen/lod/vegetation.rs diff --git a/crates/horizon-client/src/fog.rs b/crates/horizon-client/src/fog.rs index 83f1a8bf5..0716f3e77 100644 --- a/crates/horizon-client/src/fog.rs +++ b/crates/horizon-client/src/fog.rs @@ -180,6 +180,8 @@ pub struct FogInputs<'a> { pub water_fog_color: [f32; 3], pub biome: u16, pub render_distance_chunks: i32, + /// Extend ordinary Overworld atmosphere for terrain beyond vanilla's range. + pub distant_terrain: bool, /// The Cloud Distance option, in chunks. pub cloud_range_chunks: i32, pub camera_y: f64, @@ -336,6 +338,18 @@ pub fn setup_fog(tables: &FogTables, state: &FogState, input: &FogInputs) -> Fog let span = (rd / 10.0).clamp(4.0, 64.0); fog.render_distance_start = rd - span; fog.render_distance_end = rd; + if input.distant_terrain + && input.skybox + && input.fog_type == FogType::Atmospheric + && input.blindness.is_none() + && input.darkness.is_none() + && !input.boss_world_fog + && sky.fog_end >= 1024.0 + { + let scale = (rd / 1024.0).max(1.0); + fog.environmental_start *= scale; + fog.environmental_end *= scale; + } fog } /// `AtmosphericFogEnvironment.updateRainFogState`. @@ -368,6 +382,7 @@ mod tests { water_fog_color: [0.0, 0.0, 0.2], biome: 0, render_distance_chunks: 12, + distant_terrain: false, cloud_range_chunks: 128, camera_y: 70.0, min_y: -64, @@ -446,6 +461,38 @@ mod tests { assert_eq!(fog.sky_end, 192.0); } #[test] + fn distant_atmosphere_extends_without_extending_environmental_overrides() { + let sky = Sky { + fog_end: 1024., + ..Sky::default() + }; + let tables = FogTables { + water_fog_end: vec![1.], + }; + let mut input = inputs(&sky); + input.render_distance_chunks = 1024; + input.distant_terrain = true; + let fog = setup_fog(&tables, &FogState::default(), &input); + assert_eq!(fog.environmental_end, 16384.); + input.fog_type = FogType::Water; + assert_eq!( + setup_fog(&tables, &FogState::default(), &input).environmental_end, + 24. + ); + input.fog_type = FogType::Atmospheric; + input.darkness = Some(1.); + assert_eq!( + setup_fog(&tables, &FogState::default(), &input).environmental_end, + 15. + ); + input.darkness = None; + input.boss_world_fog = true; + assert_eq!( + setup_fog(&tables, &FogState::default(), &input).environmental_end, + 96. + ); + } + #[test] fn cloud_fog_ends_at_the_cloud_distance() { let sky = Sky { fog_end: 1024.0, diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1151339a8..4060a1691 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -6446,6 +6446,7 @@ impl Game<'_> { self.screen = Screen::Playing; self.title = None; self.clear_lod(); + self.pending_uploads.clear(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -6596,6 +6597,7 @@ impl Game<'_> { self.orbs.clear(); self.mining = None; self.clear_lod(); + self.pending_uploads.clear(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -6775,6 +6777,7 @@ impl Game<'_> { self.clear_entities(); self.screen = Screen::Playing; self.clear_lod(); + self.pending_uploads.clear(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -8738,7 +8741,13 @@ impl Game<'_> { fog: Some({ let mut fog = self.frame_fog(camera, &sky, biome); // Horizon's fog setting: no distance fog (fluids keep theirs). - if !self.settings.horizon.fog && !underwater && fog.environmental_end >= distance { + if !self.settings.horizon.fog + && !underwater + && self.darkness_fog().is_none() + && !self.dragon_bar_shown() + && self.potions.effects.get("blindness").is_none() + && fog.environmental_end >= (self.streaming.radius * 16) as f32 + { (fog.render_distance_start, fog.render_distance_end) = (1e9, 2e9); (fog.environmental_start, fog.environmental_end) = (1e9, 2e9); } @@ -9112,9 +9121,9 @@ impl Game<'_> { } Ok(()) } - /// Only surface LOD worlds extend the renderer's range, never simulation. + /// Only enabled LOD worlds extend the renderer's range, never simulation. fn terrain_distance(&self) -> i32 { - if self.lod.is_some() && self.dim != Dim::Nether { + if self.lod.is_some() { self.streaming .radius .max(self.settings.horizon.lod_distance.min(1024) as i32) @@ -9132,7 +9141,6 @@ impl Game<'_> { } fn prepare_lod(&mut self) { let enabled = self.settings.horizon.lod_distance > 0 - && self.dim != Dim::Nether && self.renderer.is_some() && self.player.is_some() && self.title.is_none() @@ -9181,14 +9189,16 @@ impl Game<'_> { self.lod_observe .extend(uploads.iter().map(|(key, _)| (key.0, key.2))); for chunk in &unloaded { - lod.observe(chunk, &self.res.facts); + horizon_client::spans::time("lod_observe", || lod.observe(chunk, &self.res.facts)); self.lod_observe.remove(&(chunk.x, chunk.z)); } let observe: Vec<_> = self.lod_observe.iter().copied().take(2).collect(); for key in observe { self.lod_observe.remove(&key); if let Some(chunk) = self.world.chunks.get(&key) { - lod.observe(chunk, &self.res.facts); + horizon_client::spans::time("lod_observe", || { + lod.observe(chunk, &self.res.facts) + }); } } } @@ -9219,39 +9229,37 @@ impl Game<'_> { } if let Some(renderer) = self.renderer.as_mut() { let g = &self.settings.horizon; - let budgeted = g.chunk_updates > 0 || g.upload_budget_kib > 0; - if !budgeted && self.pending_uploads.is_empty() { - horizon_client::spans::time("upload", || { - for (key, mesh) in uploads { - renderer.upload(key, &mesh); - } - }); - } else { + // Even unlimited count/byte settings must yield during a join's + // upload burst; draining it all blocked input/rendering for seconds. + horizon_client::spans::time("upload", || { // Horizon's chunk-update and upload budgets: the nearest // sections go first, the rest wait for later frames; a newer // mesh of a waiting section replaces it. let pending = &mut self.pending_uploads; let fresh: horizon_client::fast_hash::FxHashSet<(i32, i32, i32)> = uploads.iter().map(|(k, _)| *k).collect(); - let gone: horizon_client::fast_hash::FxHashSet<(i32, i32)> = - unloaded.iter().map(|c| (c.x, c.z)).collect(); - pending.retain(|(k, _)| !fresh.contains(k) && !gone.contains(&(k.0, k.2))); - pending.extend(uploads); + let chunks = &self.world.chunks; + pending.retain(|(k, _)| !fresh.contains(k) && chunks.contains_key(&(k.0, k.2))); + pending.extend( + uploads + .into_iter() + .filter(|(k, _)| chunks.contains_key(&(k.0, k.2))), + ); let centre = self.streaming.center; let far = |k: &(i32, i32, i32)| (k.0 - centre.0).pow(2) + (k.2 - centre.1).pow(2); pending.sort_unstable_by_key(|(k, _)| std::cmp::Reverse(far(k))); - let (limit, budget) = if budgeted { - ( - g.chunk_updates as usize, - u64::from(g.upload_budget_kib) * 1024, - ) - } else { - (0, 0) - }; + let (limit, budget) = ( + g.chunk_updates as usize, + u64::from(g.upload_budget_kib) * 1024, + ); let (mut count, mut bytes) = (0, 0u64); + let upload_started = Instant::now(); while let Some((_, mesh)) = pending.last() { - let size = ((mesh.solid.len() + mesh.translucent.len()) * 32) as u64; - if (limit > 0 && count >= limit) + let size = ((mesh.solid.len() + mesh.translucent.len()) + * std::mem::size_of::()) + as u64; + if (count > 0 && upload_started.elapsed() >= Duration::from_millis(4)) + || (limit > 0 && count >= limit) || (budget > 0 && bytes > 0 && bytes + size > budget) { break; @@ -9261,7 +9269,7 @@ impl Game<'_> { count += 1; bytes += size; } - } + }); for c in unloaded { for sy in 0..(HEIGHT / 16) { renderer.remove((c.x, sy, c.z)); @@ -9279,13 +9287,16 @@ impl Game<'_> { ) }) .collect(); - for (key, mesh) in lod.update( - [player.position.x, player.position.y, player.position.z], - self.streaming.radius, - self.settings.horizon.lod_distance, - covered, - ) { - renderer.upload_lod(key, &mesh); + for (key, mesh) in horizon_client::spans::time("lod_update", || { + lod.update( + [player.position.x, player.position.y, player.position.z], + self.yaw, + self.streaming.radius, + self.settings.horizon.lod_distance, + covered, + ) + }) { + horizon_client::spans::time("lod_upload", || renderer.upload_lod(key, &mesh)); } for key in lod.removed() { renderer.remove_lod(key); diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index c94e31626..51abdebed 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -717,6 +717,7 @@ impl Game<'_> { "active_tiles": self.lod.as_ref().map_or(0, |lod| lod.stats().0), "cached_tiles": self.lod.as_ref().map_or(0, |lod| lod.stats().1), "pending_observations": self.lod_observe.len(), + "refined_samples": self.lod.as_ref().map_or(0, |lod| lod.refined_samples()), }); let mut status = json!({ "screen": self.screen_name(), @@ -777,6 +778,10 @@ impl Game<'_> { .map(|e| self.shown_name_tags(glam::DVec3::from_array(e))), }); status["lod"] = lod; + let (target, sampled) = self.lod.as_ref().map_or((0, 0), |lod| lod.progress()); + status["lod"]["target_tiles"] = target.into(); + status["lod"]["sampled_target_tiles"] = sampled.into(); + status["pending_uploads"] = self.pending_uploads.len().into(); status["physical_keys"] = json!(physical_keys); status } diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 67322c90a..fd2517e7f 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -260,6 +260,7 @@ impl Game<'_> { self.title = None; self.dim = Dim::Overworld; self.clear_lod(); + self.pending_uploads.clear(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -365,6 +366,7 @@ impl Game<'_> { self.screen = Screen::Playing; self.container = None; self.clear_lod(); + self.pending_uploads.clear(); if let Some(r) = self.renderer.as_mut() { r.clear_sections(); } @@ -613,6 +615,7 @@ impl Game<'_> { r.chunk_center = (0, 0); } self.clear_lod(); + self.pending_uploads.clear(); if let Some(renderer) = self.renderer.as_mut() { renderer.clear_sections(); } diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index fad4f7352..e0431dabe 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -86,6 +86,7 @@ impl Game<'_> { ], biome, render_distance_chunks: self.terrain_distance(), + distant_terrain: self.lod.is_some(), cloud_range_chunks: self.settings.cloud_range, camera_y: camera.y, // level.getMinY(): the Nether and the End start at y 0. diff --git a/crates/horizon-client/src/lod.rs b/crates/horizon-client/src/lod.rs index 59adc4e7e..3863b26cb 100644 --- a/crates/horizon-client/src/lod.rs +++ b/crates/horizon-client/src/lod.rs @@ -1,13 +1,13 @@ -//! Bounded surface terrain for distances beyond the resident chunk area. +//! Bounded voxel-column terrain for distances beyond the resident chunk area. //! Far tiles never enter World, lighting, simulation or the section cave graph. use crate::{ - blocks::{BlockFacts, Fluid}, - chunk::{Chunk, HEIGHT, MIN_Y}, + blocks::BlockFacts, + chunk::{Chunk, MIN_Y}, fast_hash::{FxHashMap, FxHashSet}, - mesher::{FaceGroups, SectionMesh, TerrainVertex}, - streaming::{LodSource, WorkerContext}, + mesher::SectionMesh, + streaming::{LodDetail, LodSource, WorkerContext}, }; -use horizon_core::position::BlockPos; +mod mesh; use horizon_world::registry::BlockStateId; use std::{ collections::VecDeque, @@ -20,7 +20,8 @@ use std::{ }; const CELLS: usize = 16; -const MAX_SAVED: usize = 8192; +const MAX_SAVED: usize = 1024; +const SAMPLE_JOBS: usize = 4; /// Top solid face and optional fluid face, in absolute block coordinates. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Surface { @@ -29,6 +30,203 @@ pub struct Surface { pub water: Option<(i32, BlockStateId)>, pub biome: u16, } +/// A half-open material run; gaps between runs remain air. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Span { + pub min: i16, + pub max: i16, + pub state: BlockStateId, + pub biome: u16, + pub light: u16, +} +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct Column { + pub surface: Option, + pub spans: Vec, +} +impl Column { + /// Reduce an entire horizontal footprint, rather than inflating its corner + /// column (a single leaf used to become a whole distant tree-sized slab). + pub(crate) fn reduced(columns: &[Column; 256], x: usize, z: usize, width: usize) -> Self { + if width == 1 { + return columns[z * 16 + x].clone(); + } + let mut events = Vec::new(); + for dz in z..z + width { + for dx in x..x + width { + for span in &columns[dz * 16 + dx].spans { + let material = (span.state, span.biome, span.light); + events.push((span.min, material, 1)); + events.push((span.max, material, -1)); + } + } + } + events.sort_unstable_by_key(|event| event.0); + let mut result = Self::default(); + let mut votes = Vec::<((BlockStateId, u16), i32)>::new(); + let mut sky = [0i32; 16]; + let mut block = [0i32; 16]; + let mut occupied = 0; + let mut bottom = MIN_Y as i16; + for (y, material, change) in events { + if bottom < y { + if occupied * 2 >= (width * width) as i32 + && let Some(&((state, biome), _)) = + votes.iter().max_by_key(|&(material, count)| { + (*count, std::cmp::Reverse((material.0.0, material.1))) + }) + { + // Lighting must not split votes for the same material. + // Reduction can expose buried faces; retain the brightest + // actual light in this occupied footprint, per channel. + let light = (sky.iter().rposition(|&n| n > 0).unwrap_or(0) << 4) + | (block.iter().rposition(|&n| n > 0).unwrap_or(0) << 12); + result.push(Span { + min: bottom, + max: y, + state, + biome, + light: light as u16, + }); + } + bottom = y; + } + occupied += change; + sky[usize::from((material.2 >> 4) & 15)] += change; + block[usize::from((material.2 >> 12) & 15)] += change; + let material = (material.0, material.1); + if let Some(vote) = votes.iter_mut().find(|vote| vote.0 == material) { + vote.1 += change; + } else { + votes.push((material, change)); + } + } + result + } + pub fn from_surface(surface: Option) -> Self { + let mut column = Self { + surface, + spans: Vec::new(), + }; + if let Some(s) = surface { + if s.height > MIN_Y { + column.spans.push(Span { + min: MIN_Y as i16, + max: s.height as i16, + state: s.state, + biome: s.biome, + light: 240, + }); + } + if let Some((height, state)) = s.water { + column.spans.push(Span { + min: s.height as i16, + max: height as i16, + state, + biome: s.biome, + light: 240, + }); + } + } + column + } + pub(crate) fn push(&mut self, span: Span) { + if let Some(last) = self.spans.last_mut() + && last.max == span.min + && last.state == span.state + && last.biome == span.biome + && last.light == span.light + { + last.max = span.max; + } else { + self.spans.push(span); + } + } + fn from_chunk(chunk: &Chunk, facts: &BlockFacts, x: i32, z: i32) -> Self { + let face_light = |y: i32| { + let mut sky = 0; + let mut block = 0; + for (dx, dy, dz) in [ + (0, 0, 0), + (-1, 0, 0), + (1, 0, 0), + (0, -1, 0), + (0, 1, 0), + (0, 0, -1), + (0, 0, 1), + ] { + if !(0..16).contains(&(x + dx)) || !(0..16).contains(&(z + dz)) { + continue; + } + let value = chunk.light(x + dx, y + dy, z + dz); + sky = sky.max(value & 0xf0); + block = block.max(value & 15); + } + sky | block + }; + let mut column = Self::default(); + for (sy, section) in chunk.sections.iter().enumerate() { + let min = MIN_Y + sy as i32 * 16; + let uniform = section.blocks.bits() == 0 + && section.biomes.bits() == 0 + && matches!(section.light, crate::chunk::Light::Uniform(_)); + let uniform = uniform + && face_light(min) == chunk.light(x, min, z) + && face_light(min + 15) == chunk.light(x, min, z); + let step = if uniform { 16 } else { 1 }; + for offset in (0..16).step_by(step) { + let y = min + offset; + let state = BlockStateId(chunk.get(x, y, z)); + let f = facts.get(state); + if facts.is_air(state) + || !(f.solid_render + || f.full_collision + || f.name.ends_with("_leaves") + || matches!(&*f.name, "minecraft:water" | "minecraft:lava")) + { + continue; + } + let light = face_light(y); + column.push(Span { + min: y as i16, + max: (y + step as i32) as i16, + state, + biome: chunk.biome(x, y, z), + light: u16::from(light & 0xf0) + | (u16::from((light & 15).max(f.emission)) << 12), + }); + } + } + let mut water = None; + for span in column.spans.iter().rev() { + if matches!( + &*facts.get(span.state).name, + "minecraft:water" | "minecraft:lava" + ) { + water.get_or_insert((i32::from(span.max), span.state)); + } else { + column.surface = Some(Surface { + height: i32::from(span.max), + state: span.state, + water, + biome: span.biome, + }); + break; + } + } + if column.surface.is_none() + && let Some((height, state)) = water + { + column.surface = Some(Surface { + height: MIN_Y, + state: facts.air, + water: Some((height, state)), + biome: chunk.biome(x, height - 1, z), + }); + } + column + } +} #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] pub struct TileKey { pub x: i32, @@ -37,7 +235,7 @@ pub struct TileKey { } impl TileKey { pub fn size(self) -> i32 { - 64 << self.level + 16 << self.level } pub fn origin(self) -> [i32; 3] { [self.x * self.size(), 0, self.z * self.size()] @@ -57,72 +255,107 @@ impl TileKey { .max(camera[1] - z - self.size()) .max(0) } + fn in_view(self, camera: [i32; 2], yaw: f32) -> bool { + let [x, _, z] = self.origin(); + let (sin, cos) = yaw.sin_cos(); + let mut forward = f32::NEG_INFINITY; + let mut left = f32::NEG_INFINITY; + let mut right = f32::NEG_INFINITY; + for (dx, dz) in [ + (0, 0), + (self.size(), 0), + (0, self.size()), + (self.size(), self.size()), + ] { + let (x, z) = ((x + dx - camera[0]) as f32, (z + dz - camera[1]) as f32); + let f = -x * sin + z * cos; + let side = x * cos + z * sin; + forward = forward.max(f); + left = left.max(f * 0.866 + side * 0.5); + right = right.max(f * 0.866 - side * 0.5); + } + forward > 0. && left > 0. && right > 0. + } } #[derive(Default)] struct Plan { roots: Vec, nodes: FxHashSet, split: FxHashSet, + elevation: i32, } impl Plan { + #[cfg(test)] fn new(camera: [i32; 2], detail: i32, distance: u32) -> Self { + Self::with_previous(camera, detail, distance, &Self::default(), 0) + } + fn with_previous( + camera: [i32; 2], + detail: i32, + distance: u32, + previous: &Self, + elevation: i32, + ) -> Self { let range = distance.min(1024) as i32 * 16; let mut level = 0; - while (64 << level) < range { + while (16 << level) < range { level += 1; } - let size = 64 << level; - let mut result = Self::default(); + let size = 16 << level; + let mut result = Self { + elevation, + ..Self::default() + }; for z in (camera[1] - range).div_euclid(size)..=(camera[1] + range).div_euclid(size) { for x in (camera[0] - range).div_euclid(size)..=(camera[0] + range).div_euclid(size) { let key = TileKey { x, z, level }; result.roots.push(key); - result.visit(key, camera, detail, range); + result.visit(key, camera, detail, range, previous); } } result } - fn visit(&mut self, key: TileKey, camera: [i32; 2], detail: i32, range: i32) { + fn visit(&mut self, key: TileKey, camera: [i32; 2], detail: i32, range: i32, previous: &Self) { if key.distance(camera) > range { return; } self.nodes.insert(key); - // Inside the near area, stride4 divides chunk boundaries exactly. - if key.level > 0 && key.distance(camera) < (key.size() * 2).max(detail * 16 + 64) { + // Keep distant cells small on screen; finest tiles retain individual blocks. + let threshold = key.size() * if previous.split.contains(&key) { 10 } else { 8 }; + if key.level > 0 + && (key.distance(camera) < detail * 16 + 16 + || key.distance(camera).max(self.elevation) < threshold) + { self.split.insert(key); for child in key.children() { - self.visit(child, camera, detail, range); + self.visit(child, camera, detail, range, previous); } } } fn select( &self, key: TileKey, - ready: &FxHashMap>>, + ready: &FxHashMap>, out: &mut Vec, ) -> bool { if !self.nodes.contains(&key) { return true; } if self.split.contains(&key) { - let start = out.len(); - if key + // Visit every child: a missing sibling must not hide ready detail. + let complete = key .children() .into_iter() - .all(|child| self.select(child, ready, out)) - { + .map(|child| self.select(child, ready, out)) + .fold(true, |complete, child| complete & child); + if complete { return true; } if ready.contains_key(&key) { - out.truncate(start); + // Its mesh is clipped around every selected finer tile. out.push(key); return true; } - // Keep any children already available while the parent is loading. - out.truncate(start); - for child in key.children() { - self.select(child, ready, out); - } false } else if ready.contains_key(&key) { out.push(key); @@ -132,44 +365,96 @@ impl Plan { } } } -struct Job { +struct MeshInput { key: TileKey, + columns: Vec, + neighbors: [Vec; 4], + finer: Vec, } -struct Done { - key: TileKey, - samples: Vec>, +struct ReducedColumns { + columns: Arc<[Column; 256]>, + levels: [Vec; 4], +} +impl ReducedColumns { + fn new(columns: Arc<[Column; 256]>) -> Self { + let levels = std::array::from_fn(|level| { + let width = 2 << level; + (0..16 / width) + .flat_map(|z| { + let columns = &columns; + (0..16 / width) + .map(move |x| Column::reduced(columns, x * width, z * width, width)) + }) + .collect() + }); + Self { columns, levels } + } + fn get(&self, x: usize, z: usize, width: usize) -> &Column { + if width == 1 { + &self.columns[z * 16 + x] + } else { + &self.levels[width.trailing_zeros() as usize - 1] + [(z / width) * (16 / width) + x / width] + } + } +} +enum Job { + Sample(TileKey), + Reduce(LodDetail), + RequestDetail { + chunks: Vec<(i32, i32)>, + center: [i32; 2], + }, + Mesh { + active: FxHashSet, + inputs: Vec, + covered: FxHashSet<(i32, i32)>, + bounds: Option<[i32; 4]>, + }, +} +enum Done { + Detail((i32, i32), ReducedColumns), + DetailRequested, + Sample { + key: TileKey, + samples: Vec, + }, + Mesh { + active: FxHashSet, + meshes: Vec<(TileKey, SectionMesh)>, + }, } struct Shared { jobs: Mutex>, wake: Condvar, stop: AtomicBool, } -#[derive(Clone, Copy)] -struct Style { - layer: u16, - tint: i32, - translucent: bool, - light: u16, -} /// One background worker and at most two outstanding sample jobs. Only the /// current view's quadtree and a bounded set of visited summaries are retained. pub struct Lod { shared: Arc, thread: Option>, results: mpsc::Receiver, + #[cfg(test)] context: Arc, - area: Option<([i32; 2], i32, u32)>, + meshing: bool, + invalidated: FxHashSet<(i32, i32)>, + area: Option<([i32; 2], i32, u32, i32)>, plan: Plan, pending: FxHashSet, - ready: FxHashMap>>, + sample_nearby: bool, + detail_masks: FxHashMap, + detail_request_pending: bool, + detail_request_at: std::time::Instant, + ready: FxHashMap>, active: FxHashSet, dirty: FxHashSet, removed: Vec, covered: FxHashSet<(i32, i32)>, covered_bounds: Option<[i32; 4]>, - saved: FxHashMap<(i32, i32), [Option; 16]>, + saved: FxHashMap<(i32, i32), Arc<[Column; 256]>>, + reduced: FxHashMap<(i32, i32), ReducedColumns>, saved_order: VecDeque<(i32, i32)>, - styles: FxHashMap, } impl Lod { pub fn new(source: Arc, context: Arc) -> Self { @@ -179,55 +464,159 @@ impl Lod { stop: AtomicBool::new(false), }); let worker = shared.clone(); + let mesh_context = context.clone(); let (tx, results) = mpsc::channel(); let handle = thread::Builder::new() .name("Far terrain".into()) .spawn(move || { let mut sampler = source.sampler(); - loop { + let count = thread::available_parallelism() + .map_or(1, |n| n.get() / 4) + .clamp(1, 3); + let mut sampling = Vec::new(); + for _ in 0..count { + let Some(mut sample) = sampler.fork() else { + break; + }; + let shared = worker.clone(); + let tx = tx.clone(); + sampling.push( + thread::Builder::new() + .name("Far sampling".into()) + .spawn(move || { + loop { + let key = { + let mut jobs = shared.jobs.lock().unwrap(); + loop { + if shared.stop.load(Ordering::Relaxed) { + return; + } + if let Some(index) = jobs + .iter() + .position(|job| matches!(job, Job::Sample(_))) + { + let Some(Job::Sample(key)) = jobs.remove(index) + else { + unreachable!() + }; + break key; + } + jobs = shared.wake.wait(jobs).unwrap(); + } + }; + let [x, _, z] = key.origin(); + let samples = + sample.grid(x, z, key.size() / CELLS as i32, CELLS); + if shared.stop.load(Ordering::Relaxed) { + return; + } + if tx.send(Done::Sample { key, samples }).is_err() { + return; + } + } + }) + .expect("far sampling worker"), + ); + } + let mut mesher = mesh::Mesher::default(); + 'work: loop { + for (key, columns) in sampler.drain_details() { + if tx + .send(Done::Detail(key, ReducedColumns::new(columns))) + .is_err() + { + break 'work; + } + } let job = { let mut jobs = worker.jobs.lock().unwrap(); - while jobs.is_empty() && !worker.stop.load(Ordering::Relaxed) { - jobs = worker.wake.wait(jobs).unwrap(); + if (jobs.is_empty() + || (!sampling.is_empty() + && jobs.iter().all(|job| matches!(job, Job::Sample(_))))) + && !worker.stop.load(Ordering::Relaxed) + { + jobs = worker + .wake + .wait_timeout(jobs, std::time::Duration::from_millis(100)) + .unwrap() + .0; } if worker.stop.load(Ordering::Relaxed) { break; } - jobs.pop_front().unwrap() + if sampling.is_empty() { + jobs.pop_front() + } else { + jobs.iter() + .position(|job| !matches!(job, Job::Sample(_))) + .and_then(|index| jobs.remove(index)) + } }; - let [x, _, z] = job.key.origin(); - let stride = job.key.size() / CELLS as i32; - let mut samples = Vec::with_capacity(CELLS * CELLS); - for dz in 0..CELLS { - if worker.stop.load(Ordering::Relaxed) { - break; + let Some(job) = job else { continue }; + let done = match job { + Job::Reduce((key, columns)) => { + Done::Detail(key, ReducedColumns::new(columns)) } - for dx in 0..CELLS { - samples.push( - sampler.sample(x + dx as i32 * stride, z + dz as i32 * stride), - ); + Job::RequestDetail { chunks, center } => { + sampler.request_detail(&chunks, center); + Done::DetailRequested } - } - if tx - .send(Done { - key: job.key, - samples, - }) - .is_err() - { + Job::Sample(key) => { + let [x, _, z] = key.origin(); + let samples = sampler.grid(x, z, key.size() / CELLS as i32, CELLS); + Done::Sample { key, samples } + } + Job::Mesh { + active, + inputs, + covered, + bounds, + } => { + let mut meshes = Vec::with_capacity(inputs.len()); + for input in inputs { + if worker.stop.load(Ordering::Relaxed) { + break 'work; + } + let mesh = mesher.mesh( + input.key, + &input.columns, + &covered, + bounds, + &mesh_context, + &input.neighbors, + &input.finer, + ); + meshes.push((input.key, mesh)); + } + Done::Mesh { active, meshes } + } + }; + if tx.send(done).is_err() { break; } } + worker.stop.store(true, Ordering::Relaxed); + worker.wake.notify_all(); + for handle in sampling { + let _ = handle.join(); + } }) .expect("far terrain worker"); Self { shared, thread: Some(handle), results, + #[cfg(test)] context, + meshing: false, + invalidated: FxHashSet::default(), area: None, plan: Plan::default(), pending: FxHashSet::default(), + sample_nearby: true, + detail_masks: FxHashMap::default(), + detail_request_pending: false, + detail_request_at: std::time::Instant::now(), ready: FxHashMap::default(), active: FxHashSet::default(), dirty: FxHashSet::default(), @@ -235,61 +624,55 @@ impl Lod { covered: FxHashSet::default(), covered_bounds: None, saved: FxHashMap::default(), + reduced: FxHashMap::default(), saved_order: VecDeque::new(), - styles: FxHashMap::default(), } } pub fn stats(&self) -> (usize, usize) { (self.active.len(), self.ready.len()) } + pub fn progress(&self) -> (usize, usize) { + let mut desired = 0; + let mut sampled = 0; + for key in &self.plan.nodes { + if !self.plan.split.contains(key) { + desired += 1; + sampled += usize::from(self.ready.contains_key(key)); + } + } + (desired, sampled) + } + pub fn refined_samples(&self) -> usize { + self.active + .iter() + .filter_map(|key| self.detail_masks.get(key)) + .flat_map(|mask| mask.iter()) + .map(|bits| bits.count_ones() as usize) + .sum() + } pub fn removed(&mut self) -> Vec { std::mem::take(&mut self.removed) } pub fn invalidate_chunk(&mut self, x: i32, z: i32) { + if self.meshing { + self.invalidated.insert((x, z)); + } for &key in &self.active { let [ox, _, oz] = key.origin(); - if x * 16 < ox + key.size() - && (x + 1) * 16 > ox - && z * 16 < oz + key.size() - && (z + 1) * 16 > oz + if x * 16 <= ox + key.size() + && (x + 1) * 16 >= ox + && z * 16 <= oz + key.size() + && (z + 1) * 16 >= oz { self.dirty.insert(key); } } } - /// Sample only sixteen columns, from current block storage (heightmaps can - /// be stale after edits). Memory stays bounded while exploring indefinitely. + /// Capture actual block columns, including canopy gaps and material layers. pub fn observe(&mut self, chunk: &Chunk, facts: &BlockFacts) { - let values = std::array::from_fn(|i| { - let x = (i & 3) as i32 * 4; - let z = (i >> 2) as i32 * 4; - let mut water = None; - for y in (MIN_Y..MIN_Y + HEIGHT).rev() { - let state = BlockStateId(chunk.get(x, y, z)); - if facts.is_air(state) { - continue; - } - let f = facts.get(state); - if !matches!(f.fluid, Fluid::None) { - if water.is_none() { - water = Some((y + 1, state)); - } - } else if f.solid_render || f.name.ends_with("_leaves") { - return Some(Surface { - height: y + 1, - state, - water, - biome: chunk.biome(x, y, z), - }); - } - } - water.map(|(y, state)| Surface { - height: MIN_Y, - state: facts.air, - water: Some((y, state)), - biome: chunk.biome(x, y - 1, z), - }) - }); + let values = Arc::new(std::array::from_fn(|i| { + Column::from_chunk(chunk, facts, (i & 15) as i32, (i >> 4) as i32) + })); let key = (chunk.x, chunk.z); if self.saved.get(&key) == Some(&values) { return; @@ -298,36 +681,210 @@ impl Lod { while self.saved.len() >= MAX_SAVED { if let Some(old) = self.saved_order.pop_front() { self.saved.remove(&old); + self.reduced.remove(&old); } } self.saved_order.push_back(key); } - self.saved.insert(key, values); + self.apply_fine(key, &values); + self.saved.insert(key, values.clone()); + self.reduced.remove(&key); + let mut jobs = self.shared.jobs.lock().unwrap(); + // Coalesce edits and drop jobs whose bounded visited cache was evicted. + jobs.retain(|job| !matches!(job, Job::Reduce((at, _)) if *at == key || !self.saved.contains_key(at))); + jobs.push_back(Job::Reduce((key, values))); + drop(jobs); + self.shared.wake.notify_all(); self.invalidate_chunk(chunk.x, chunk.z); } + fn apply_fine(&mut self, (cx, cz): (i32, i32), columns: &[Column; 256]) { + let fine = TileKey { + x: cx, + z: cz, + level: 0, + }; + if self.plan.nodes.contains(&fine) || self.ready.contains_key(&fine) { + self.ready.insert(fine, columns.to_vec()); + self.detail_masks.insert(fine, [u64::MAX; 4]); + } + } + fn apply_detail(&mut self, (cx, cz): (i32, i32), columns: &ReducedColumns) { + self.apply_fine((cx, cz), &columns.columns); + for (&key, samples) in &mut self.ready { + let [ox, _, oz] = key.origin(); + let stride = key.size() / 16; + // A single generated chunk cannot describe a larger cell's area. + if stride > 16 { + continue; + } + let x0 = ((cx * 16 - ox + stride - 1).div_euclid(stride)).clamp(0, 16); + let x1 = (((cx + 1) * 16 - ox + stride - 1).div_euclid(stride)).clamp(0, 16); + let z0 = ((cz * 16 - oz + stride - 1).div_euclid(stride)).clamp(0, 16); + let z1 = (((cz + 1) * 16 - oz + stride - 1).div_euclid(stride)).clamp(0, 16); + if x0 == x1 || z0 == z1 { + continue; + } + let mask = self.detail_masks.entry(key).or_default(); + for z in z0..z1 { + for x in x0..x1 { + let index = (z * 16 + x) as usize; + samples[index] = columns + .get( + (ox + x * stride).rem_euclid(16) as usize, + (oz + z * stride).rem_euclid(16) as usize, + stride as usize, + ) + .clone(); + mask[index / 64] |= 1 << (index % 64); + } + } + } + } + fn finish_sample(&mut self, key: TileKey, samples: Vec) { + self.pending.remove(&key); + if self.plan.nodes.contains(&key) && samples.len() == CELLS * CELLS { + let mut samples = samples; + if let (Some(old), Some(mask)) = (self.ready.get(&key), self.detail_masks.get(&key)) { + for i in 0..256 { + if mask[i / 64] & (1 << (i % 64)) != 0 { + samples[i] = old[i].clone(); + } + } + } + self.ready.insert(key, samples); + } + } + fn finish_detail(&mut self, key: (i32, i32), columns: ReducedColumns) { + if let Some(visited) = self.saved.get(&key).cloned() + && !Arc::ptr_eq(&visited, &columns.columns) + { + // Its latest reduction is queued; never restore old edits or seed data. + self.apply_fine(key, &visited); + return; + } + self.apply_detail(key, &columns); + if self.saved.contains_key(&key) { + self.reduced.insert(key, columns); + } + self.invalidate_chunk(key.0, key.1); + } + fn request_detail(&mut self, camera: [i32; 2]) { + if self.detail_request_pending + || self.detail_request_at.elapsed() < std::time::Duration::from_millis(250) + { + return; + } + self.detail_request_at = std::time::Instant::now(); + let mut keys: Vec<_> = self + .active + .iter() + .filter(|key| { + key.level <= 1 + && !self.plan.split.contains(key) + && !(key.level == 0 && self.covered.contains(&(key.x, key.z))) + && self.detail_masks.get(key) != Some(&[u64::MAX; 4]) + }) + .copied() + .collect(); + keys.sort_unstable_by_key(|key| (key.distance(camera), *key)); + let mut chunks = FxHashSet::default(); + for key in keys { + let [ox, _, oz] = key.origin(); + let stride = key.size() / 16; + let mask = self.detail_masks.get(&key).copied().unwrap_or_default(); + for index in 0..256 { + if mask[index / 64] & (1 << (index % 64)) == 0 { + let chunk = ( + (ox + (index as i32 % 16) * stride).div_euclid(16), + (oz + (index as i32 / 16) * stride).div_euclid(16), + ); + if self.covered.contains(&chunk) { + self.detail_masks.entry(key).or_default()[index / 64] |= 1 << (index % 64); + } else { + chunks.insert(chunk); + } + } + } + if chunks.len() >= 32 { + break; + } + } + let mut chunks: Vec<_> = chunks.into_iter().collect(); + chunks.sort_unstable_by_key(|&(x, z)| { + let dx = i64::from(x * 16 + 8 - camera[0]); + let dz = i64::from(z * 16 + 8 - camera[1]); + dx * dx + dz * dz + }); + chunks.truncate(32); + if !chunks.is_empty() { + self.detail_request_pending = true; + self.shared + .jobs + .lock() + .unwrap() + .push_back(Job::RequestDetail { + chunks, + center: camera, + }); + self.shared.wake.notify_all(); + } + } pub fn update( &mut self, camera: [f64; 3], + yaw: f32, detail: i32, distance: u32, covered: FxHashSet<(i32, i32)>, ) -> Vec<(TileKey, SectionMesh)> { + let elevation = + (((camera[1] - f64::from(MIN_Y + crate::chunk::HEIGHT)).clamp(0., 16384.)) as i32 / 32) + * 32; let camera = [camera[0].floor() as i32, camera[2].floor() as i32]; + // Fill the view ahead first; a nearest-only ring spends most work out + // of sight while visible forests remain undecorated noise terrain. + let ahead = (detail * 16 + 128).max(elevation * 2).min(4096) as f32; + let yaw = yaw.to_radians(); + let focus = [ + camera[0] - (yaw.sin() * ahead) as i32, + camera[1] + (yaw.cos() * ahead) as i32, + ]; // Replan at chunk boundaries, not on every camera movement. let area = ( [camera[0].div_euclid(16), camera[1].div_euclid(16)], detail, distance, + elevation, ); if self.area != Some(area) { self.area = Some(area); - self.plan = Plan::new(camera, detail, distance); + self.plan = Plan::with_previous(camera, detail, distance, &self.plan, elevation); self.ready.retain(|key, _| self.plan.nodes.contains(key)); + self.detail_masks + .retain(|key, _| self.plan.nodes.contains(key)); } + let mut meshes = Vec::new(); while let Ok(done) = self.results.try_recv() { - self.pending.remove(&done.key); - if self.plan.nodes.contains(&done.key) && done.samples.len() == CELLS * CELLS { - self.ready.insert(done.key, done.samples); + match done { + Done::Detail(key, columns) => { + crate::spans::time("lod_detail", || self.finish_detail(key, columns)) + } + Done::DetailRequested => self.detail_request_pending = false, + Done::Sample { key, samples } => self.finish_sample(key, samples), + Done::Mesh { + active, + meshes: completed, + } => { + // Retire parents only when the entire replacement is ready. + self.removed + .extend(self.active.difference(&active).copied()); + self.active = active; + self.meshing = false; + for (x, z) in std::mem::take(&mut self.invalidated) { + self.invalidate_chunk(x, z); + } + meshes.extend(completed); + } } } if self.covered != covered { @@ -352,262 +909,244 @@ impl Lod { }); self.covered = covered; } - let mut selected = Vec::new(); - for &key in &self.plan.roots { - self.plan.select(key, &self.ready, &mut selected); - } - let next: FxHashSet<_> = selected.iter().copied().collect(); - self.removed.extend(self.active.difference(&next).copied()); - self.dirty.extend(next.difference(&self.active).copied()); - self.active = next; - self.dirty.retain(|key| self.active.contains(key)); - let keys: Vec<_> = self.dirty.drain().collect(); - let meshes = keys.into_iter().map(|key| (key, self.mesh(key))).collect(); - let mut wanted: Vec<_> = self - .plan - .nodes - .iter() - .copied() - .filter(|key| !self.ready.contains_key(key) && !self.pending.contains(key)) - .collect(); - // Coarse ancestors first: cover the horizon quickly, then refine. - wanted - .sort_unstable_by_key(|key| (std::cmp::Reverse(key.level), key.distance(camera), *key)); - let mut jobs = self.shared.jobs.lock().unwrap(); - for key in wanted - .into_iter() - .take(2usize.saturating_sub(self.pending.len())) - { - self.pending.insert(key); - jobs.push_back(Job { key }); - } - self.shared.wake.notify_one(); - meshes - } - fn style(&mut self, state: BlockStateId) -> Style { - if let Some(style) = self.styles.get(&state) { - return *style; - } - let registry = self.context.assets.registry; - let name = registry.state(state).map(|s| s.name.as_str()).unwrap_or(""); - let fluid = match name { - "minecraft:water" | "minecraft:bubble_column" => Some(("block/water_still", true, -2)), - "minecraft:lava" => Some(("block/lava_still", false, -1)), - _ => None, - }; - let light = - 240 | (u16::from(self.context.tables.facts(state).map_or(0, |f| f.emission)) << 12); - let style = if let Some((sprite, translucent, tint)) = fluid { - Style { - layer: self - .context - .assets - .sprite_layers - .get(sprite) - .or_else(|| { - self.context - .assets - .sprite_layers - .get(&format!("minecraft:{sprite}")) - }) - .copied() - .unwrap_or(0) as u16, - tint, - translucent, - light, + // Complete resident columns need no duplicate noise work. Their real + // summaries are retained when the full-detail chunks leave the view. + for &key in &self.plan.nodes { + if key.level == 0 && self.covered.contains(&(key.x, key.z)) { + self.ready + .entry(key) + .or_insert_with(|| vec![Column::default(); CELLS * CELLS]); } - } else { - let models = self - .context - .assets - .model_catalog - .collect(state, BlockPos::new(0, 0, 0)) - .ok(); - let face = models.as_ref().and_then(|m| { - m.iter() - .flat_map(|(_, m)| &m.faces) - .find(|f| f.quad.facing == horizon_assets::model::Direction::Up) - }); - Style { - layer: face.map_or(0, |f| f.layer as u16), - tint: if face.is_some_and(|f| f.quad.tint_index >= 0) { - if name.contains("leaves") { -3 } else { 0 } - } else { - -1 - }, - translucent: face.is_some_and(|f| f.translucent), - light, + } + if !self.meshing { + let mut selected = Vec::new(); + for &key in &self.plan.roots { + self.plan.select(key, &self.ready, &mut selected); } - }; - self.styles.insert(state, style); - style - } - fn mesh(&mut self, key: TileKey) -> SectionMesh { - let mut mesh = SectionMesh::default(); - let stride = key.size() / CELLS as i32; - let [ox, _, oz] = key.origin(); - let mut samples = self.ready[&key].clone(); - for z in 0..CELLS { - for x in 0..CELLS { - let (wx, wz) = (ox + x as i32 * stride, oz + z as i32 * stride); - if let Some(saved) = self.saved.get(&(wx.div_euclid(16), wz.div_euclid(16))) { - samples[z * CELLS + x] = - saved[((wz.rem_euclid(16) / 4) * 4 + wx.rem_euclid(16) / 4) as usize]; + // Their normal meshes already provide coverage. Empty stand-ins + // must not become hundreds of redundant fallback clipping masks. + selected.retain(|key| key.level != 0 || !self.covered.contains(&(key.x, key.z))); + let next: FxHashSet<_> = selected.iter().copied().collect(); + let changed: Vec<_> = self.active.symmetric_difference(&next).copied().collect(); + for &tile in &next { + let [x, _, z] = tile.origin(); + let size = tile.size(); + if changed.iter().any(|other| { + let [ox, _, oz] = other.origin(); + let os = other.size(); + (x < ox + os && ox < x + size && z < oz + os && oz < z + size) + || (((x + size == ox) || (ox + os == x)) && z < oz + os && oz < z + size) + || (((z + size == oz) || (oz + os == z)) && x < ox + os && ox < x + size) + }) { + self.dirty.insert(tile); } } - } - for z in 0..CELLS { - for x in 0..CELLS { - let (wx, wz) = (ox + x as i32 * stride, oz + z as i32 * stride); - let Some(sample) = samples[z * CELLS + x] else { - continue; - }; - // Only fine cells overlap near chunks; coarse parent fallbacks - // also clip individual chunk-sized pieces while children load. - let overlaps = self.covered_bounds.is_some_and(|[x0, z0, x1, z1]| { - wx < x1 && wx + stride > x0 && wz < z1 && wz + stride > z0 + self.dirty.extend(next.difference(&self.active).copied()); + self.dirty.retain(|key| next.contains(key)); + if !self.dirty.is_empty() || next != self.active { + let inputs = self + .dirty + .iter() + .map(|&key| crate::spans::time("lod_input", || self.mesh_input(key, &next))) + .collect(); + self.dirty.clear(); + self.meshing = true; + self.shared.jobs.lock().unwrap().push_front(Job::Mesh { + active: next, + inputs, + covered: self.covered.clone(), + bounds: self.covered_bounds, }); - let step = if overlaps { stride.min(16) } else { stride }; - for dz in (0..stride).step_by(step as usize) { - for dx in (0..stride).step_by(step as usize) { - if self - .covered - .contains(&((wx + dx).div_euclid(16), (wz + dz).div_euclid(16))) - { - continue; - } - let (x0, z0, x1, z1) = ( - (x as i32 * stride + dx) as f32, - (z as i32 * stride + dz) as f32, - (x as i32 * stride + dx + step) as f32, - (z as i32 * stride + dz + step) as f32, - ); - let y = sample.height as f32; - if y > MIN_Y as f32 { - let style = self.style(sample.state); - let color = self.color(style, sample.biome); - quad( - &mut mesh, - style, - color, - [[x0, y, z1], [x1, y, z1], [x1, y, z0], [x0, y, z0]], - 1.0, - ); - for (nx, nz, cell_edge, neighbor, points, shade) in [ - ( - x as i32 - 1, - z as i32, - dx == 0, - [wx + dx - 1, wz + dz], - [[x0, y, z0], [x0, y, z1], [x0, 0.0, z1], [x0, 0.0, z0]], - 0.6, - ), - ( - x as i32 + 1, - z as i32, - dx + step == stride, - [wx + dx + step, wz + dz], - [[x1, y, z1], [x1, y, z0], [x1, 0.0, z0], [x1, 0.0, z1]], - 0.6, - ), - ( - x as i32, - z as i32 - 1, - dz == 0, - [wx + dx, wz + dz - 1], - [[x1, y, z0], [x0, y, z0], [x0, 0.0, z0], [x1, 0.0, z0]], - 0.8, - ), - ( - x as i32, - z as i32 + 1, - dz + step == stride, - [wx + dx, wz + dz + step], - [[x0, y, z1], [x1, y, z1], [x1, 0.0, z1], [x0, 0.0, z1]], - 0.8, - ), - ] { - let cut_edge = self.covered.contains(&( - neighbor[0].div_euclid(16), - neighbor[1].div_euclid(16), - )); - let floor = if cut_edge { - // Near terrain may be below the coarse top; - // close the cut instead of exposing its underside. - MIN_Y - } else if !cell_edge { - continue; - } else if (0..CELLS as i32).contains(&nx) - && (0..CELLS as i32).contains(&nz) - { - samples[(nz as usize) * CELLS + nx as usize] - .map_or(MIN_Y, |s| s.height) - } else { - MIN_Y - }; - if floor < sample.height { - let mut p = points; - p[2][1] = floor as f32; - p[3][1] = floor as f32; - p.reverse(); - quad(&mut mesh, style, color, p, shade); - } - } - } - if let Some((height, state)) = sample.water { - let style = self.style(state); - let color = self.color(style, sample.biome); - let y = height as f32 - 1.0 / 9.0; - quad( - &mut mesh, - style, - color, - [[x0, y, z1], [x1, y, z1], [x1, y, z0], [x0, y, z0]], - 1.0, - ); - } + } + } + // Load desired nearby leaves directly, alongside broad fallback coverage. + // Waiting for every ancestor/sibling made full detail take minutes to appear. + let mut wanted = Vec::new(); + for &root in &self.plan.roots { + if self.plan.nodes.contains(&root) && !self.ready.contains_key(&root) { + wanted.push((0, 0, root)); + } + } + for &key in &self.plan.nodes { + if !self.plan.split.contains(&key) && !self.ready.contains_key(&key) { + wanted.push(( + if key.in_view(camera, yaw) { 1 } else { 3 }, + i64::from(key.distance(focus)) * 4 + i64::from(key.distance(camera)), + key, + )); + } + } + let mut fallback = Vec::new(); + for &parent in &self.active { + if self.plan.split.contains(&parent) { + for child in parent.children() { + if self.plan.nodes.contains(&child) && !self.ready.contains_key(&child) { + // Covered near terrain bounds projected error. Using + // zero distance for a parent touching the camera kept + // refining it while huge visible walls waited elsewhere. + let priority = + i64::from(child.distance(camera).max((detail * 16).max(elevation))) + * 1024 + / i64::from(child.size()); + fallback.push(( + if child.in_view(camera, yaw) { 2 } else { 4 }, + priority, + child, + )); } } } } - mesh.faces = FaceGroups::group(&mut mesh.solid); - mesh + wanted.sort_unstable(); + fallback.sort_unstable(); + // Alternate one nearby final tile with one broad refinement tile. + if let Some(fallback) = fallback + .into_iter() + .find(|(_, _, k)| !self.pending.contains(k)) + { + let index = if self.sample_nearby { + wanted + .iter() + .position(|(_, _, k)| !self.pending.contains(k)) + .map_or(0, |i| i + 1) + } else { + 0 + }; + wanted.insert(index, fallback); + } + let mut unique = FxHashSet::default(); + let wanted: Vec<_> = wanted + .into_iter() + .map(|(_, _, key)| key) + .filter(|key| !self.pending.contains(key) && unique.insert(*key)) + .collect(); + self.request_detail(focus); + let mut jobs = self.shared.jobs.lock().unwrap(); + for key in wanted + .into_iter() + .take(SAMPLE_JOBS.saturating_sub(self.pending.len())) + { + self.pending.insert(key); + self.sample_nearby = !self.sample_nearby; + jobs.push_back(Job::Sample(key)); + } + self.shared.wake.notify_all(); + meshes } - fn color(&self, style: Style, biome: u16) -> u32 { - let b = self.context.biomes.get(biome); - match style.tint { - -2 => b.water, - -3 => b.foliage, - 0 => b.grass, - _ => 0xffffff, + fn visited_column(&self, wx: i32, wz: i32, width: i32) -> Option<&Column> { + let key = (wx.div_euclid(16), wz.div_euclid(16)); + if width == 1 { + self.saved + .get(&key) + .map(|columns| &columns[(wz.rem_euclid(16) * 16 + wx.rem_euclid(16)) as usize]) + } else if width <= 16 { + self.reduced.get(&key).map(|columns| { + columns.get( + wx.rem_euclid(16) as usize, + wz.rem_euclid(16) as usize, + width as usize, + ) + }) + } else { + None } } -} -fn quad(mesh: &mut SectionMesh, style: Style, color: u32, points: [[f32; 3]; 4], shade: f32) { - let channel = |shift: u32| (((color >> shift) & 255u32) as f32 * shade) as u32; - let color = channel(16) | (channel(8) << 8) | (channel(0) << 16) | 0xff000000; - let out = if style.translucent { - &mut mesh.translucent - } else { - &mut mesh.solid - }; - out.extend( - points - .into_iter() - .zip([[0., 1.], [1., 1.], [1., 0.], [0., 0.]]) - .map(|(pos, uv)| TerrainVertex { - pos, - uv, - layer: style.layer, - light: style.light, - color, - }), - ); + fn neighbor(&self, wx: i32, wz: i32, active: &FxHashSet) -> Option<(Column, i32)> { + for level in 0..=10 { + let size = 16 << level; + let key = TileKey { + x: wx.div_euclid(size), + z: wz.div_euclid(size), + level, + }; + if !active.contains(&key) { + continue; + } + let stride = 1 << level; + let [ox, _, oz] = key.origin(); + let x = (wx - ox) / stride; + let z = (wz - oz) / stride; + let (sx, sz) = (ox + x * stride, oz + z * stride); + if let Some(column) = self.visited_column(sx, sz, stride) { + return Some((column.clone(), stride)); + } + return Some((self.ready[&key][(z * 16 + x) as usize].clone(), stride)); + } + None + } + fn mesh_input(&self, key: TileKey, active: &FxHashSet) -> MeshInput { + let stride = key.size() / CELLS as i32; + let [ox, _, oz] = key.origin(); + let mut columns = self.ready[&key].clone(); + for z in 0..CELLS { + for x in 0..CELLS { + let (wx, wz) = (ox + x as i32 * stride, oz + z as i32 * stride); + if let Some(column) = self.visited_column(wx, wz, stride) { + columns[z * CELLS + x] = column.clone(); + } + } + } + let neighbors = std::array::from_fn(|direction| { + let mut edge = Vec::new(); + let mut offset = 0; + while offset < key.size() { + let (wx, wz) = match direction { + 0 => (ox - 1, oz + offset), + 1 => (ox + key.size(), oz + offset), + 2 => (ox + offset, oz - 1), + _ => (ox + offset, oz + key.size()), + }; + let (column, neighbor_stride) = self + .neighbor(wx, wz, active) + .unwrap_or_else(|| (Column::default(), stride)); + let coordinate = if direction < 2 { wz } else { wx }; + let width = (neighbor_stride - coordinate.rem_euclid(neighbor_stride)) + .min(key.size() - offset); + edge.push(mesh::EdgeColumn { + start: offset, + end: offset + width, + column, + }); + offset += width; + } + edge + }); + MeshInput { + key, + columns, + neighbors, + finer: active + .iter() + .copied() + .filter(|other| { + let [x, _, z] = other.origin(); + other.level < key.level + && x >= ox + && z >= oz + && x + other.size() <= ox + key.size() + && z + other.size() <= oz + key.size() + }) + .collect(), + } + } + #[cfg(test)] + fn mesh(&self, key: TileKey) -> SectionMesh { + let input = self.mesh_input(key, &self.active); + mesh::Mesher::default().mesh( + key, + &input.columns, + &self.covered, + self.covered_bounds, + &self.context, + &input.neighbors, + &input.finer, + ) + } } impl Drop for Lod { fn drop(&mut self) { self.shared.stop.store(true, Ordering::Relaxed); - self.shared.wake.notify_one(); + self.shared.wake.notify_all(); if let Some(thread) = self.thread.take() { let _ = thread.join(); } @@ -616,12 +1155,13 @@ impl Drop for Lod { #[cfg(test)] mod tests { use super::*; + use crate::mesher::TerrainVertex; #[test] fn far_plan_is_bounded_and_near_tiles_align_with_chunks() { for camera in [[0, 0], [-1, -17], [1023, -4097]] { for distance in [64, 256, 1024] { let plan = Plan::new(camera, 12, distance); - assert!(plan.nodes.len() < 2500, "{} nodes", plan.nodes.len()); + assert!(plan.nodes.len() < 12000, "{} nodes", plan.nodes.len()); for key in &plan.nodes { if !plan.split.contains(key) && key.distance(camera) < 12 * 16 { assert_eq!(key.level, 0); @@ -632,7 +1172,7 @@ mod tests { .iter() .filter(|k| !plan.split.contains(k)) .count(); - assert!(cells < 2000); + assert!(cells < 10000); } } assert_eq!( @@ -642,11 +1182,33 @@ mod tests { level: 1 } .origin(), - [-128, 0, -256] + [-32, 0, -64] ); } #[test] - fn parent_covers_missing_children_then_retires_without_overlap() { + fn aerial_distance_avoids_unseen_full_detail_outside_the_near_area() { + let ground = Plan::new([0, 0], 12, 1024); + let high = Plan::with_previous([0, 0], 12, 1024, &Plan::default(), 1024); + assert!(high.nodes.len() < ground.nodes.len()); + assert!( + high.nodes.contains(&TileKey { + x: 0, + z: 0, + level: 0 + }), + "near full-detail footprint stays exact" + ); + assert!( + !high.nodes.contains(&TileKey { + x: 20, + z: 0, + level: 0 + }), + "far terrain viewed from high above needs distance-appropriate detail" + ); + } + #[test] + fn late_parent_keeps_ready_detail_and_only_fills_missing_children() { let parent = TileKey { x: -1, z: 0, @@ -661,8 +1223,13 @@ mod tests { ready.insert(parent, vec![]); ready.insert(parent.children()[0], vec![]); let mut selected = Vec::new(); + ready.remove(&parent); + assert!(!plan.select(parent, &ready, &mut selected)); + assert_eq!(selected, [parent.children()[0]]); + ready.insert(parent, vec![]); + selected.clear(); assert!(plan.select(parent, &ready, &mut selected)); - assert_eq!(selected, [parent]); + assert_eq!(selected, [parent.children()[0], parent]); for child in parent.children() { ready.insert(child, vec![]); } @@ -671,36 +1238,89 @@ mod tests { assert_eq!(selected, parent.children()); } #[test] - fn coarse_quad_keeps_winding_light_and_transparency() { - let mut mesh = SectionMesh::default(); - let style = Style { - layer: 7, - tint: -1, - translucent: true, + fn detail_survives_movement_across_a_split_threshold() { + let before = Plan::new([0, 0], 2, 256); + let after = Plan::with_previous([16, 0], 2, 256, &before, 0); + let mut retained = 0; + for key in &before.split { + if key.distance([16, 0]) < key.size() * 10 { + assert!(after.split.contains(key)); + retained += 1; + } + } + assert!(retained > 100); + assert!(after.nodes.len() < 16000); + } + #[test] + fn reduced_material_votes_ignore_light_and_retain_exposure() { + let mut columns: [Column; 256] = std::array::from_fn(|_| Column::default()); + for i in 0..16 { + columns[(i / 4) * 16 + i % 4].spans.push(Span { + min: 60, + max: 64, + state: BlockStateId(if i < 10 { 2 } else { 1 }), + biome: 0, + light: if i < 10 { (i as u16 + 6) << 4 } else { 0 }, + }); + } + let coarse = Column::reduced(&columns, 0, 0, 4); + assert_eq!(coarse.spans.len(), 1); + assert_eq!( + coarse.spans[0].state, + BlockStateId(2), + "majority grass must beat dark dirt" + ); + assert_eq!(coarse.spans[0].light, 240, "retain sampled sky exposure"); + for column in &mut columns { + for span in &mut column.spans { + span.light = 0; + } + } + assert_eq!( + Column::reduced(&columns, 0, 0, 4).spans[0].light, + 0, + "unlit caves stay unlit" + ); + columns[0].spans[0].light = 7 << 12; + assert_eq!( + Column::reduced(&columns, 0, 0, 4).spans[0].light, + 7 << 12, + "block light does not invent skylight" + ); + } + #[test] + fn coarse_voxels_reduce_the_area_instead_of_inflating_one_leaf() { + let span = |min, max, state| Span { + min, + max, + state: BlockStateId(state), + biome: 0, light: 240, }; - quad( - &mut mesh, - style, - 0x123456, - [ - [0., 70., 64.], - [64., 70., 64.], - [64., 70., 0.], - [0., 70., 0.], - ], - 1., + let mut columns = std::array::from_fn(|_| Column { + surface: None, + spans: vec![span(0, 4, 1)], + }); + columns[0].spans.push(span(8, 10, 2)); + assert_eq!(Column::reduced(&columns, 0, 0, 4).spans, [span(0, 4, 1)]); + for z in 0..4 { + for x in 0..4 { + columns[z * 16 + x].spans.push(span(12, 14, 3)); + } + } + assert_eq!( + Column::reduced(&columns, 0, 0, 4).spans, + [span(0, 4, 1), span(12, 14, 3)] ); - assert!(mesh.solid.is_empty()); - assert_eq!(mesh.translucent.len(), 4); - assert_eq!(mesh.translucent[0].color, 0xff563412); - let q = &mesh.translucent; - assert!( - (glam::Vec3::from(q[1].pos) - glam::Vec3::from(q[0].pos)) - .cross(glam::Vec3::from(q[2].pos) - glam::Vec3::from(q[0].pos)) - .y - > 0. + assert_eq!(Column::reduced(&columns, 0, 0, 1), columns[0]); + let reduced = ReducedColumns::new(Arc::new(columns)); + assert_eq!( + reduced.get(0, 0, 1).spans, + [span(0, 4, 1), span(8, 10, 2), span(12, 14, 3)] ); + assert_eq!(reduced.get(0, 0, 4).spans, [span(0, 4, 1), span(12, 14, 3)]); + assert_eq!(reduced.get(4, 8, 4).spans, [span(0, 4, 1)]); + assert_eq!(reduced.get(0, 0, 16).spans, [span(0, 4, 1)]); } #[test] #[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"] @@ -733,17 +1353,17 @@ mod tests { let key = TileKey { x: -1, z: -1, - level: 3, + level: 5, }; lod.ready.insert( key, vec![ - Some(Surface { + Column::from_surface(Some(Surface { height: 70, state: stone, water: Some((80, water)), biome: biomes.id("minecraft:plains"), - }); + })); CELLS * CELLS ], ); @@ -839,10 +1459,244 @@ mod tests { } lod.observe(&chunk, &facts); let observed = &lod.saved[&(-1, -1)]; - assert_eq!(observed[0].unwrap().height, 121); - assert_eq!(observed[0].unwrap().state, stone); - assert_eq!(observed[5].unwrap().height, 55); - assert_eq!(observed[5].unwrap().water, Some((64, water))); + assert_eq!(observed[0].surface.unwrap().height, 121); + assert_eq!(observed[0].surface.unwrap().state, stone); + assert_eq!(observed[68].surface.unwrap().height, 55); + assert_eq!(observed[68].surface.unwrap().water, Some((64, water))); + + let fine = TileKey { + x: -1, + z: -1, + level: 0, + }; + lod.ready.insert(fine, vec![Column::default(); 256]); + lod.finish_detail( + (-1, -1), + ReducedColumns::new(Arc::new(std::array::from_fn(|_| Column::default()))), + ); + assert_eq!( + lod.ready[&fine][0].surface.unwrap().height, + 121, + "late seed generation cannot overwrite a visited build" + ); + assert_eq!(lod.detail_masks[&fine], [u64::MAX; 4]); + lod.plan.nodes.insert(fine); + lod.pending.insert(fine); + lod.finish_sample(fine, vec![Column::default(); 256]); + assert_eq!( + lod.ready[&fine][0].surface.unwrap().height, + 121, + "a late coarse sampling job cannot erase completed detail" + ); + assert_eq!(lod.detail_masks[&fine], [u64::MAX; 4]); + lod.plan.nodes.remove(&fine); + + // Real worker results populate the reusable pyramid; an older result + // must never put a previous edit back into that cache. + let receive_reduction = |lod: &mut Lod| { + let Done::Detail(key, columns) = lod + .results + .recv_timeout(std::time::Duration::from_secs(5)) + .unwrap() + else { + panic!("expected queued visited reduction"); + }; + lod.finish_detail(key, columns); + }; + receive_reduction(&mut lod); + assert!(Arc::ptr_eq( + &lod.reduced[&(-1, -1)].columns, + &lod.saved[&(-1, -1)] + )); + assert!(lod.visited_column(-16, -16, 2).unwrap().spans.is_empty()); + let old = lod.saved[&(-1, -1)].clone(); + chunk.set(0, 130, 0, stone.0); + lod.observe(&chunk, &facts); + assert!(!lod.reduced.contains_key(&(-1, -1))); + lod.finish_detail((-1, -1), ReducedColumns::new(old)); + assert!(!lod.reduced.contains_key(&(-1, -1))); + assert_eq!(lod.ready[&fine][0].surface.unwrap().height, 131); + receive_reduction(&mut lod); + assert!(Arc::ptr_eq( + &lod.reduced[&(-1, -1)].columns, + &lod.saved[&(-1, -1)] + )); + + // Exercise the actual worker/update seam: a parent stays displayed + // until all four child meshes can replace it in the same update. + let camera = [-256.0, 100.0, -256.0]; + lod.area = Some(([-16, -16], 2, 64, 0)); + lod.plan.roots = vec![key]; + lod.plan.nodes.insert(key); + let await_meshes = |lod: &mut Lod| { + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5); + loop { + let meshes = lod.update(camera, 0.0, 2, 64, lod.covered.clone()); + if !meshes.is_empty() { + return meshes; + } + assert!(std::time::Instant::now() < deadline, "mesh worker stalled"); + std::thread::sleep(std::time::Duration::from_millis(1)); + } + }; + let uploaded = await_meshes(&mut lod); + assert_eq!(uploaded.len(), 1); + assert_eq!(uploaded[0].0, key); + assert!(lod.active.contains(&key)); + lod.plan.split.insert(key); + for child in key.children() { + lod.plan.nodes.insert(child); + lod.ready.insert(child, lod.ready[&key].clone()); + } + assert!( + lod.update(camera, 0.0, 2, 64, lod.covered.clone()) + .is_empty() + ); + assert!( + lod.active.contains(&key), + "parent retired before child meshes" + ); + assert!(lod.removed().is_empty()); + let uploaded = await_meshes(&mut lod); + assert_eq!(uploaded.len(), 4); + assert!( + key.children() + .iter() + .all(|child| lod.active.contains(child)) + ); + assert_eq!(lod.removed(), [key]); + + let covered_fine = TileKey { + x: -1, + z: -2, + level: 0, + }; + lod.plan = Plan::default(); + lod.plan.roots.push(covered_fine); + lod.plan.nodes.insert(covered_fine); + lod.ready.insert(covered_fine, vec![Column::default(); 256]); + lod.covered.insert((-1, -2)); + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5); + loop { + lod.update(camera, 0., 2, 64, lod.covered.clone()); + if !lod.meshing && lod.active.is_empty() { + break; + } + assert!( + std::time::Instant::now() < deadline, + "covered normal chunk remained an active LOD mask" + ); + std::thread::sleep(std::time::Duration::from_millis(1)); + } + assert_eq!(lod.progress(), (1, 1)); + + // Keep one sample outstanding, as on ordinary frames. Completing just + // one job at a time must still let both loading queues make progress. + lod.shared.stop.store(true, Ordering::Relaxed); + lod.shared.wake.notify_all(); + lod.thread.take().unwrap().join().unwrap(); + while lod.results.try_recv().is_ok() {} + lod.shared.jobs.lock().unwrap().clear(); + lod.plan = Plan::new([-256, -256], 2, 64); + let parent = TileKey { + x: -2, + z: -2, + level: 3, + }; + lod.plan.roots = vec![parent]; + lod.ready.clear(); + lod.ready.insert(parent, vec![Column::default(); 256]); + lod.active = [parent].into_iter().collect(); + lod.pending = (0..SAMPLE_JOBS - 1) + .map(|i| TileKey { + x: 999 + i as i32, + z: 999, + level: 0, + }) + .collect(); + lod.sample_nearby = true; + lod.detail_request_pending = true; + lod.meshing = true; + lod.update(camera, 0.0, 2, 64, FxHashSet::default()); + let Some(Job::Sample(nearby)) = lod.shared.jobs.lock().unwrap().pop_front() else { + panic!("nearby detail was not scheduled"); + }; + assert_eq!(nearby.level, 0); + assert!( + nearby.origin()[2] > -256 + 64, + "detail should load ahead of the view" + ); + lod.finish_sample(nearby, vec![Column::default(); 256]); + lod.update(camera, 0.0, 2, 64, FxHashSet::default()); + let Some(Job::Sample(fallback)) = lod.shared.jobs.lock().unwrap().pop_front() else { + panic!("fallback refinement was starved"); + }; + assert!(fallback.level > 0); + lod.pending.remove(&fallback); + lod.sample_nearby = true; + lod.update(camera, 90.0, 2, 64, FxHashSet::default()); + let Some(Job::Sample(turned)) = lod.shared.jobs.lock().unwrap().pop_front() else { + panic!("turned view was not scheduled"); + }; + assert!( + turned.origin()[0] < -256 - 64, + "loading priority should follow a turn" + ); + lod.shared.jobs.lock().unwrap().clear(); + let near = TileKey { + x: -4, + z: -4, + level: 2, + }; + let far = TileKey { + x: 0, + z: 0, + level: 6, + }; + lod.plan = Plan::default(); + lod.plan.roots = vec![near, far]; + lod.ready.clear(); + for parent in [near, far] { + lod.plan.nodes.insert(parent); + lod.plan.split.insert(parent); + lod.plan.nodes.extend(parent.children()); + lod.ready.insert(parent, vec![Column::default(); 256]); + } + lod.active = [near, far].into_iter().collect(); + lod.shared.jobs.lock().unwrap().clear(); + lod.pending = (0..SAMPLE_JOBS - 1) + .map(|i| TileKey { + x: 999 + i as i32, + z: 999, + level: 0, + }) + .collect(); + lod.sample_nearby = false; + lod.update(camera, 0., 2, 64, FxHashSet::default()); + let Some(Job::Sample(broad)) = lod.shared.jobs.lock().unwrap().pop_front() else { + panic!("projected-error refinement missing") + }; + assert_eq!( + broad.level, 5, + "a near tile touching the camera must not starve a huge visible distant tile" + ); + lod.shared.jobs.lock().unwrap().clear(); + lod.active = (0..40).map(|x| TileKey { x, z: 0, level: 0 }).collect(); + lod.plan.split.clear(); + lod.detail_masks.clear(); + lod.covered = [(0, 0)].into_iter().collect(); + lod.detail_request_pending = false; + lod.detail_request_at = std::time::Instant::now() - std::time::Duration::from_secs(1); + lod.request_detail([0, 0]); + let Some(Job::RequestDetail { chunks, .. }) = lod.shared.jobs.lock().unwrap().pop_front() + else { + panic!("detail batch was not requested"); + }; + assert_eq!( + chunks, + (1..=32).map(|x| (x, 0)).collect::>(), + "one unfinished fine tile must not starve neighbouring requests" + ); Ok(()) } } diff --git a/crates/horizon-client/src/lod/mesh.rs b/crates/horizon-client/src/lod/mesh.rs new file mode 100644 index 000000000..82636e1d1 --- /dev/null +++ b/crates/horizon-client/src/lod/mesh.rs @@ -0,0 +1,1102 @@ +//! Exposed voxel-column faces, merged without changing their block-scale UVs. +use super::{Column, Span, TileKey}; +use crate::{ + fast_hash::{FxHashMap, FxHashSet}, + mesher::{FaceGroups, OPAQUE_LAYER, SectionMesh, TerrainVertex}, + streaming::WorkerContext, +}; +use horizon_assets::model::Direction; +use horizon_core::position::BlockPos; +use horizon_world::registry::BlockStateId; +use std::collections::BTreeMap; + +const CELLS: usize = 16; + +pub(super) struct EdgeColumn { + pub start: i32, + pub end: i32, + pub column: Column, +} + +#[derive(Clone, Copy)] +enum Tint { + None, + Grass, + Foliage, + Dry, + Water, + Constant(u32), +} +#[derive(Clone, Copy)] +struct Style { + layer: u16, + tint: Tint, + translucent: bool, +} +#[derive(Clone, Copy)] +struct Styles { + faces: [Option