From 4ffb073b59f5cef20426efcea088c5d0f57e6b90 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 19 Oct 2026 18:31:52 +0100 Subject: [PATCH] Prepare startup handoff CPU resources on the loader worker --- crates/horizon-client/src/game.rs | 190 ++++++++++++++++--- crates/horizon-client/src/game/integrated.rs | 2 +- crates/horizon-client/src/gfx.rs | 111 +++++++++-- docs/performance/startup-stage-3.md | 22 +++ 4 files changed, 281 insertions(+), 44 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 6baab9863..8d5897e53 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -8362,6 +8362,7 @@ impl Game<'_> { pack, gui, self.renderer.as_ref(), + None, self.settings.horizon.api, ) } @@ -10799,6 +10800,7 @@ impl<'a> Game<'a> { options: Options, settings: Settings, audio: Audio, + prepared: Option, ) -> Result { let root = options.resources.clone(); let registry = pack.assets.registry; @@ -10815,15 +10817,9 @@ impl<'a> Game<'a> { .join("saves") .join(".horizon-title"), )); - // These batches share the exported document instead of reparsing it per layer. - let (armor_stand_assets, boat_models, cart_models) = { - let document = horizon_client::mobs::EntityModelDocument::load(&root).ok(); - ( - armor_stands::ArmorStandAssets::load(&root, document.as_ref()), - boats::BoatModels::load(document.as_ref()), - minecarts::CartModels::load(document.as_ref()), - ) - }; + let prepared = prepared + .map(Ok) + .unwrap_or_else(|| GameCpuResources::load(&root))?; let world = World::new(res.facts().air, 0); let creative = options.creative; let inventory = vec![None; 36]; @@ -11004,18 +11000,18 @@ impl<'a> Game<'a> { level_events: Vec::new(), falling: Vec::new(), paintings: Vec::new(), - painting_variants: paintings::PaintingVariants::load(&root), + painting_variants: prepared.painting_variants, item_frames: Vec::new(), - frame_model: frames::bake_frame(&root, "item_frame"), - glow_frame_model: frames::bake_frame(&root, "glow_item_frame"), - map_frame_model: frames::bake_frame(&root, "item_frame_map"), - glow_map_frame_model: frames::bake_frame(&root, "glow_item_frame_map"), + frame_model: prepared.frame_model, + glow_frame_model: prepared.glow_frame_model, + map_frame_model: prepared.map_frame_model, + glow_map_frame_model: prepared.glow_map_frame_model, armor_stands: Vec::new(), others: Vec::new(), - armor_stand_assets, + armor_stand_assets: prepared.armor_stand_assets, boats: Vec::new(), - boat_models, - crystal_model: horizon_client::mobs::load_model(&root, "minecraft:end_crystal#main"), + boat_models: prepared.boat_models, + crystal_model: prepared.crystal_model, carts: Vec::new(), jukebox_sounds: HashMap::new(), bolts: Vec::new(), @@ -11025,7 +11021,7 @@ impl<'a> Game<'a> { crystals: Vec::new(), dragon_fireballs: Vec::new(), breath_clouds: Vec::new(), - dragon_model: horizon_client::mobs::load_model(&root, "minecraft:ender_dragon#main"), + dragon_model: prepared.dragon_model, map_patches: Vec::new(), skin_downloads: horizon_client::skins::Downloader::new( std::env::current_dir() @@ -11033,7 +11029,7 @@ impl<'a> Game<'a> { .join("assets/skins"), ), skin_slots: Vec::new(), - cart_models, + cart_models: prepared.cart_models, riding: None, ender_items: vec![None; 27], ender_open: None, @@ -11047,11 +11043,11 @@ impl<'a> Game<'a> { ominous_spawners: Vec::new(), creaking: Default::default(), spawners: Default::default(), - trident_model: horizon_client::mobs::load_model(&root, "minecraft:trident#main"), - arrow_model: horizon_client::mobs::load_model(&root, "minecraft:arrow#main"), + trident_model: prepared.trident_model, + arrow_model: prepared.arrow_model, tnts: Vec::new(), hoppers: HashMap::new(), - creative_screen: Creative::load(&root)?, + creative_screen: prepared.creative_screen, control: None, frame_stats: Default::default(), perf: Default::default(), @@ -11126,8 +11122,49 @@ impl<'a> Game<'a> { } } +/// CPU-only startup data, owned by one loader generation. No file reads or +/// model baking are needed when the event loop installs this bundle. +struct GameCpuResources { + painting_variants: paintings::PaintingVariants, + frame_model: frames::FrameModel, + glow_frame_model: frames::FrameModel, + map_frame_model: frames::FrameModel, + glow_map_frame_model: frames::FrameModel, + armor_stand_assets: armor_stands::ArmorStandAssets, + boat_models: boats::BoatModels, + cart_models: minecarts::CartModels, + crystal_model: Option, + dragon_model: Option, + arrow_model: Option, + trident_model: Option, + creative_screen: Creative, +} +impl GameCpuResources { + fn load(root: &std::path::Path) -> Result { + let document = horizon_client::mobs::EntityModelDocument::load(root).ok(); + let model = |key| document.as_ref().and_then(|document| document.model(key)); + Ok(Self { + painting_variants: paintings::PaintingVariants::load(root), + frame_model: frames::bake_frame(root, "item_frame"), + glow_frame_model: frames::bake_frame(root, "glow_item_frame"), + map_frame_model: frames::bake_frame(root, "item_frame_map"), + glow_map_frame_model: frames::bake_frame(root, "glow_item_frame_map"), + armor_stand_assets: armor_stands::ArmorStandAssets::load(root, document.as_ref()), + boat_models: boats::BoatModels::load(document.as_ref()), + cart_models: minecarts::CartModels::load(document.as_ref()), + crystal_model: model("minecraft:end_crystal#main"), + dragon_model: model("minecraft:ender_dragon#main"), + arrow_model: model("minecraft:arrow#main"), + trident_model: model("minecraft:trident#main"), + creative_screen: Creative::load(root)?, + }) + } +} + /// The data the background loader produces for `Game::new`. struct Loaded { + game_cpu: Option, + renderer_cpu: Option, root: PathBuf, pack_error: Option, resources: Arc, @@ -11451,6 +11488,17 @@ fn load_resources( started.elapsed().as_millis() ); } + // Finish fallible CPU preparation before starting the tail, so an error + // cannot detach a tail worker that races the next pack-loader generation. + let prepared_at = Instant::now(); + let game_cpu = menu.then(|| GameCpuResources::load(&root)).transpose()?; + let renderer_cpu = menu.then(|| prepare_renderer_textures(&pack)); + if menu { + log::info!( + "Horizon: handoff CPU resources prepared on worker in {} ms", + prepared_at.elapsed().as_millis() + ); + } let rest_loader = if menu { let resources = resources.clone(); let root = root.clone(); @@ -11502,6 +11550,8 @@ fn load_resources( None }; Ok(Loaded { + game_cpu, + renderer_cpu, root, pack_error, resources, @@ -11580,14 +11630,26 @@ fn load_world_rest( }) } -/// The renderer from a pack's block sprites, its shared atlas and its border -/// texture; `previous` shares the device and window surface with an old one. +/// CPU mip chains for the block sprites and world border. +fn prepare_renderer_textures(pack: &PackResources) -> horizon_client::gfx::PreparedTextures { + let assets = &pack.render; + horizon_client::gfx::PreparedTextures::new( + &assets.pixels, + assets.sprite_size, + assets.texture_layers, + &assets.sprite_mips, + (&pack.forcefield.2, pack.forcefield.0), + ) +} + +/// Upload pack textures and create the renderer on the window's device. fn build_renderer( window: Arc, offscreen: bool, pack: &PackResources, gui: &UiResources, previous: Option<&Renderer>, + prepared: Option, api: horizon_client::graphics::GraphicsApi, ) -> Result { let assets = &pack.render; @@ -11604,6 +11666,7 @@ fn build_renderer( (&atlas.pixels, atlas.width, atlas.height), (&pack.forcefield.2, pack.forcefield.0), &gui.panorama, + prepared, previous, api, ))?; @@ -11649,6 +11712,7 @@ fn loading_renderer( (pixels, width, height), (&FORCEFIELD[..], 1), panorama, + None, previous, api, ))?; @@ -11728,9 +11792,17 @@ fn start_game<'a>( vanilla_root: PathBuf, started: Instant, rest_loader: Option, + settings: Option, + prepared: Option, ) -> Result>> { - let mut settings = Settings::load(&std::env::current_dir()?.join("options.txt")); - horizon_client::ui_theme::load_preferences(&std::env::current_dir()?); + let handoff = prepared.is_some(); + let mut settings = match settings { + Some(settings) => settings, + None => { + horizon_client::ui_theme::load_preferences(&std::env::current_dir()?); + Settings::load(&std::env::current_dir()?.join("options.txt")) + } + }; // Scripted and frame-limited runs (the parity harnesses) see vanilla's // screens unless HORIZON_MENU_STYLE asks otherwise. if (options.frames.is_some() || options.control.is_some()) @@ -11741,7 +11813,7 @@ fn start_game<'a>( if let Some(d) = options.distance_override { settings.render_distance = d; } - let mut game = Game::new(res, pack, gui, options, settings, audio)?; + let mut game = Game::new(res, pack, gui, options, settings, audio, prepared)?; game.rest_loader = rest_loader; game.ui.vanilla_root = vanilla_root; if let Some(error) = pack_error { @@ -11819,6 +11891,7 @@ fn start_game<'a>( let (seed, creative) = (game.options.seed, game.options.creative); game.open_world(&folder, None, Some(seed), creative, None)?; } + None if handoff => {} None => { let mut title = Title::new( std::env::current_dir()?.join("saves"), @@ -12025,6 +12098,7 @@ impl Loading { } } fn finish(&mut self, loaded: Loaded) -> Result>> { + let handoff_at = Instant::now(); let mut options = self.options.take().ok_or("loading already finished")?; options.resources = loaded.root.clone(); // StartupMenu owns world selection until it can hand it to Game. @@ -12036,18 +12110,21 @@ impl Loading { if let Some(renderer) = &mut self.renderer { renderer.release_surface(); } + let renderer_at = Instant::now(); let renderer = build_renderer( window.clone(), options.offscreen, &loaded.pack, &gui, self.renderer.as_ref(), + loaded.renderer_cpu, self.settings.horizon.api, )?; log::info!( "Horizon: world renderer ready after {} ms", self.started.elapsed().as_millis() ); + let renderer_ms = renderer_at.elapsed().as_millis(); // Audio is created on the main thread, after the core is ready. let audio = if options.dedicated.is_some() { Audio::silent(&options.resources) @@ -12058,6 +12135,7 @@ impl Loading { // The game borrows its shared resources for the process's lifetime, // like the single copy an integrated server would share. let res: &'static Arc = Box::leak(Box::new(loaded.resources)); + let game_at = Instant::now(); let Some(mut game) = start_game( res, loaded.pack, @@ -12068,18 +12146,26 @@ impl Loading { self.vanilla_root.clone(), self.started, loaded.rest_loader, + Some(self.settings.clone()), + loaded.game_cpu, )? else { return Ok(None); }; + let game_ms = game_at.elapsed().as_millis(); game.window = Some(window); game.renderer = Some(renderer); game.world_renderer_ready = true; game.fullscreen = self.fullscreen; self.menu.handoff(&mut game); - game.settings = self.settings.clone(); game.apply_settings(); game.previous = Instant::now(); + log::info!( + "Horizon: startup handoff {} ms (renderer {} ms, start_game {} ms)", + handoff_at.elapsed().as_millis(), + renderer_ms, + game_ms + ); Ok(Some(game)) } } @@ -12266,6 +12352,8 @@ pub fn run() -> Result<()> { vanilla_root, started, loaded.rest_loader, + None, + None, )?; if let Some(game) = game { run_event_loop(game)?; @@ -12289,6 +12377,52 @@ fn reset_world_progress(adv: &mut advancements::AdvState, stats: &mut stats::Sta *stats = Default::default(); } +#[cfg(test)] +mod startup_cpu_tests { + use super::*; + + #[test] + fn worker_prepares_owned_models_and_inventory_before_handoff() { + let root = std::env::temp_dir().join(format!("horizon-startup-cpu-{}", std::process::id())); + std::fs::create_dir_all(&root).unwrap(); + std::fs::write( + root.join("entity-models.json"), + r#"{ + "minecraft:end_crystal#main": {}, "minecraft:ender_dragon#main": {}, + "minecraft:arrow#main": {}, "minecraft:trident#main": {}, + "minecraft:armor_stand#main": {} + }"#, + ) + .unwrap(); + std::fs::write( + root.join("creative-tabs.json"), + r#"[{ + "id":"minecraft:building_blocks", "items":["minecraft:stone"] + }]"#, + ) + .unwrap(); + let worker_root = root.clone(); + let prepared = std::thread::spawn(move || { + GameCpuResources::load(&worker_root).map_err(|error| error.to_string()) + }) + .join() + .unwrap() + .unwrap(); + std::fs::remove_dir_all(&root).unwrap(); + assert!(prepared.crystal_model.is_some()); + assert!(prepared.dragon_model.is_some()); + assert!(prepared.arrow_model.is_some()); + assert!(prepared.trident_model.is_some()); + assert!(prepared.armor_stand_assets.main.is_some()); + assert_eq!( + prepared.creative_screen.tabs[0].items[0].item.as_ref(), + "minecraft:stone" + ); + // No documents from the old generation remain available to reload. + assert!(GameCpuResources::load(&root).is_err()); + } +} + #[cfg(test)] mod runtime_reset_tests { use super::*; diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index bfbc8d66c..ff28ba258 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -660,6 +660,6 @@ fn serve( }), }; let audio = Audio::silent(&options.resources); - let mut server = Game::new(res, pack, gui, options, settings, audio)?; + let mut server = Game::new(res, pack, gui, options, settings, audio, None)?; server.run_integrated(launch, flags, tasks, ready) } diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 34e2a366c..e8d2aaab2 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -524,6 +524,46 @@ fn terrain_group( ], }) } +/// CPU texture uploads prepared by the resource worker. Consumed by renderer +/// construction so the temporary mip chains are released after GPU upload. +pub struct PreparedTextures { + sprites: Vec<(Vec, u32)>, + forcefield: (Vec, u32), +} +impl PreparedTextures { + pub fn new( + pixels: &[u8], + size: u32, + layers: u32, + settings: &[crate::mipmap::Settings], + forcefield: (&[u8], u32), + ) -> Self { + Self::with_split(pixels, size, layers, settings, forcefield, sprite_split()) + } + + fn with_split( + pixels: &[u8], + size: u32, + layers: u32, + settings: &[crate::mipmap::Settings], + forcefield: (&[u8], u32), + split: u32, + ) -> Self { + let layer_bytes = (size * size * 4) as usize; + Self { + sprites: (0..layers.div_ceil(split).max(1)) + .map(|array| { + let first = array * split; + let count = layers.saturating_sub(first).clamp(1, split); + let start = (first as usize * layer_bytes).min(pixels.len()); + mip_chain(&pixels[start..], size, settings, first, count) + }) + .collect(), + forcefield: mip_chain(forcefield.0, forcefield.1, &[], 0, 1), + } + } +} + fn mip_chain( pixels: &[u8], size: u32, @@ -807,6 +847,7 @@ impl Renderer { hud_atlas: (&[u8], u32, u32), forcefield: (&[u8], u32), panorama_faces: &panorama::Faces, + prepared: Option, previous: Option<&Self>, api: GraphicsApi, ) -> Result { @@ -1180,20 +1221,17 @@ impl Renderer { usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }); - let layer_bytes = (sprite_size * sprite_size * 4) as usize; + let prepared = prepared.unwrap_or_else(|| { + PreparedTextures::new(sprite_pixels, sprite_size, layers, sprite_mips, forcefield) + }); let mut mip_levels = 1; - let sprite_textures: Vec = (0..sprite_arrays) - .map(|array| { - let first = array * split; + let sprite_textures: Vec = prepared + .sprites + .into_iter() + .enumerate() + .map(|(array, (mips, levels))| { + let first = array as u32 * split; let count = layers.saturating_sub(first).clamp(1, split); - let start = (first as usize * layer_bytes).min(sprite_pixels.len()); - let (mips, levels) = mip_chain( - &sprite_pixels[start..], - sprite_size, - sprite_mips, - first, - count, - ); mip_levels = levels; device.create_texture_with_data( &queue, @@ -1654,9 +1692,8 @@ impl Renderer { }); // WorldBorderRenderer: misc/forcefield.png as a MipmappedTexture // (repeat, linear minification with mipmaps, nearest magnification). - let (forcefield_pixels, forcefield_size) = forcefield; - let (forcefield_mips, forcefield_levels) = - mip_chain(forcefield_pixels, forcefield_size, &[], 0, 1); + let forcefield_size = forcefield.1; + let (forcefield_mips, forcefield_levels) = prepared.forcefield; let forcefield_texture = device.create_texture_with_data( &queue, &wgpu::TextureDescriptor { @@ -4540,6 +4577,50 @@ mod sprite_upload_tests { } } + #[test] + fn prepared_texture_uploads_preserve_layer_order_and_settings() { + let size = 4; + let layers = 5; + let pixels: Vec = (0..size * size * layers) + .flat_map(|i| [i as u8, (i * 3) as u8, 99, if i % 3 == 0 { 0 } else { 255 }]) + .collect(); + let settings: Vec<_> = (0..layers) + .map(|i| crate::mipmap::Settings { + strategy: if i % 2 == 0 { + crate::mipmap::Strategy::Mean + } else { + crate::mipmap::Strategy::StrictCutout + }, + ..Default::default() + }) + .collect(); + let border = [20, 30, 40, 128].repeat(16); + let expected = mip_chain(&pixels, size, &settings, 0, layers); + // A partial final array and an exact boundary exercise the global + // layer offset used to select each sprite's mipmap settings. + for split in [1, 2, 5, 8] { + let prepared = PreparedTextures::with_split( + &pixels, + size, + layers, + &settings, + (&border, size), + split, + ); + assert_eq!(prepared.sprites.len(), layers.div_ceil(split) as usize); + let actual: Vec<_> = prepared + .sprites + .iter() + .flat_map(|(bytes, levels)| { + assert_eq!(*levels, expected.1); + bytes.iter().copied() + }) + .collect(); + assert_eq!(actual, expected.0); + assert_eq!(prepared.forcefield, mip_chain(&border, size, &[], 0, 1)); + } + } + #[test] fn mip_chain_allocates_exactly_its_size() { for size in [16, 64] { diff --git a/docs/performance/startup-stage-3.md b/docs/performance/startup-stage-3.md index 28013e87c..b3258aada 100644 --- a/docs/performance/startup-stage-3.md +++ b/docs/performance/startup-stage-3.md @@ -16,6 +16,28 @@ The menu still needs its own artwork and renderer before interaction. The core h Regression coverage publishes menu artwork while a fake core worker is blocked, edits a world draft, replaces fallback artwork without losing it, queues entry and draws progress, and checks that loader failure reaches the app. Additional checks cover server identity and cancelled-entry timing. +## CPU preparation before handoff + +The resource loader now prepares the game's entity models, item-frame models, +painting variants and creative inventory, plus the block-sprite and world-border +mip chains, before publishing `Loaded`. All startup entity models share one parsed +`entity-models.json` document. Each loader generation owns its prepared data; +restarting after a pack change discards that generation's models and uploads. +Fallible preparation finishes before the world-rest worker starts, so preparation +failure cannot leave a detached tail writing into the next loader generation. + +The event-loop handoff consumes the prepared game data and mip chains. GPU +pipeline creation, texture uploads, surface operations and audio initialization +still run on the main thread. Upload buffers are released after construction. +The handoff uses the current menu settings and title object directly, avoiding +another options-file read, theme-preference load and temporary title construction. +Synchronous harnesses and integrated servers prepare their game data inline. + +Logs now report worker CPU preparation time and the handoff's total, renderer and +`start_game` times separately. The reported 245 ms handoff (103 ms renderer, +118 ms `start_game`) predates this change; the new timings should be compared in +an otherwise identical build and GPU environment. + ## Render facts assessment `MeshTables::new` reads names, registry properties, class membership, collision shape flags, fluid and render properties from `BlockFacts`. `LightTables::new/load` reads emission, dampening, occlusion and shape-occlusion flags; geometry comes from `occlusion.nbt`. Neither table needs recipes, item data, AI or the other tail tables.