From 815625e54731ee41e2dd2ffda887689220c2a99b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 20 Oct 2026 23:56:08 +0200 Subject: [PATCH] Advancement triggers test only the criteria that can pass; the log writes on its own thread Two main-thread costs from the hub tick (found on the companion branch with HORIZON_SPIKES, commit 060c795e; its companion and metering parts stay there): - Every inventory change tested all ~1,900 inventory_changed criteria, and every recipe unlocked (an iron ingot unlocks dozens) all ~1,300 recipe_unlocked ones: 1.5-5 ms on such a tick. The tree now indexes inventory_changed criteria by the items that can pass them (tags resolved; the few without an item list are always tried) and recipe_unlocked criteria by recipe, so a change tests the 20-40 that could match. Same answers: a criterion with an item-limited predicate can only pass with one of those items held. - Each log line was an unbuffered stderr write plus a latest.log write under a mutex on the calling thread; a full pipe or a slow disk held the tick. The logger now formats the line and keeps it for crash reports on the calling thread and hands the I/O to a "Log writer" thread; flush() waits for it (crash report, exit). (cherry picked from commit 060c795e, companion parts left out) Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/advancements.rs | 191 ++++++++++++++++++ .../horizon-client/src/game/advancements.rs | 59 +++++- crates/horizon-client/src/logging.rs | 158 +++++++++++---- 3 files changed, 362 insertions(+), 46 deletions(-) diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs index 16028e220..484fbfcf2 100644 --- a/crates/horizon-client/src/advancements.rs +++ b/crates/horizon-client/src/advancements.rs @@ -53,6 +53,10 @@ pub struct Tree { pub by_id: HashMap, /// trigger id -> (advancement index, criterion index). pub by_trigger: HashMap>, + /// `recipe_unlocked` criteria by the recipe they name (`index_recipes`); + /// those naming none in `recipes_any`. + by_recipe: HashMap>, + recipes_any: Vec<(usize, usize)>, } fn frame(v: &Value) -> Frame { match v.as_str() { @@ -93,12 +97,111 @@ impl Tree { tree.list.push(a); } } + tree.index_recipes(); tree } + /// Index the `recipe_unlocked` criteria by recipe: a grant that unlocks + /// twenty recipes tested every one of the ~1,300 recipe advancements' + /// criteria for each (several ms in one tick). + pub fn index_recipes(&mut self) { + self.by_recipe.clear(); + self.recipes_any.clear(); + for &(ai, ci) in self + .by_trigger + .get("minecraft:recipe_unlocked") + .into_iter() + .flatten() + { + match self.list[ai].criteria[ci].conditions["recipes"].as_str() { + Some(r) => self + .by_recipe + .entry(r.to_owned()) + .or_default() + .push((ai, ci)), + None => self.recipes_any.push((ai, ci)), + } + } + } + /// The `recipe_unlocked` criteria that could pass for `recipe`, in tree + /// order (the others name another recipe). + pub fn recipe_criteria(&self, recipe: &str) -> Vec<(usize, usize)> { + let mut out = self.recipes_any.clone(); + out.extend(self.by_recipe.get(recipe).into_iter().flatten()); + out.sort_unstable(); + out + } pub fn get(&self, id: &str) -> Option<&Advancement> { self.by_id.get(id).map(|&i| &self.list[i]) } } + +/// The `inventory_changed` criteria by the items they need. A criterion whose +/// item predicates include one limited to some items (an id, a `#tag`, a +/// list) can only pass with one of those in the inventory, so an inventory +/// change tests only the criteria of the items it holds, plus those that +/// need no particular item. The same answers as testing them all: the ~1,300 +/// recipe advancements each have one, and testing every one of them cost a +/// player 1–4 ms on every tick its inventory changed. +#[derive(Default)] +pub struct InventoryIndex { + by_item: HashMap>, + any: Vec<(usize, usize)>, +} +impl InventoryIndex { + /// `tag` gives a `#tag`'s item ids (none for a tag that doesn't exist, + /// which matches nothing). + pub fn build<'t>(tree: &Tree, tag: impl Fn(&str) -> Vec<&'t str>) -> Self { + fn ids<'t>(v: &Value, tag: &impl Fn(&str) -> Vec<&'t str>, out: &mut Vec) { + match v { + Value::String(s) => match s.strip_prefix('#') { + Some(t) => out.extend(tag(t).into_iter().map(str::to_owned)), + None => out.push(s.clone()), + }, + Value::Array(a) => a.iter().for_each(|x| ids(x, tag, out)), + _ => {} + } + } + let mut index = Self::default(); + let Some(list) = tree.by_trigger.get("minecraft:inventory_changed") else { + return index; + }; + for &(ai, ci) in list { + let items = &tree.list[ai].criteria[ci].conditions["items"]; + // `id_matches`: only a string or a list limits the items. + let limited = items.as_array().and_then(|a| { + a.iter() + .map(|p| &p["items"]) + .find(|v| v.is_string() || v.is_array()) + }); + match limited { + Some(v) => { + let mut out = Vec::new(); + ids(v, &tag, &mut out); + out.sort(); + out.dedup(); + for id in out { + index.by_item.entry(id).or_default().push((ai, ci)); + } + } + None => index.any.push((ai, ci)), + } + } + index + } + /// The criteria an inventory holding these item ids could pass, in + /// tree order. + pub fn candidates<'a>(&self, held: impl IntoIterator) -> Vec<(usize, usize)> { + let mut out = self.any.clone(); + for id in held { + if let Some(list) = self.by_item.get(id) { + out.extend_from_slice(list); + } + } + out.sort_unstable(); + out.dedup(); + out + } +} fn collect(root: &Path, dir: &Path, ns: &str, out: &mut Vec<(String, std::path::PathBuf)>) { let Ok(entries) = std::fs::read_dir(dir) else { return; @@ -1090,6 +1193,94 @@ mod tests { stack.id = "minecraft:tnt".into(); } } + /// Only the criteria the held items could pass are tested; those that + /// need no particular item always are. + #[test] + fn inventory_index_keeps_the_criteria_the_items_could_pass() { + let criteria = [ + serde_json::json!({"items": [{"items": "minecraft:diamond"}]}), + serde_json::json!({"items": [{"items": "#minecraft:planks"}]}), + serde_json::json!({"items": [{"count": {"min": 2}}]}), + serde_json::json!({"items": [{"count": 1}, {"items": ["minecraft:stick", "minecraft:apple"]}]}), + serde_json::json!({"slots": {"empty": 0}}), + serde_json::json!({"items": [{"items": "#minecraft:no_such_tag"}]}), + ]; + let mut tree = Tree::default(); + for (i, conditions) in criteria.into_iter().enumerate() { + tree.list.push(Advancement { + id: format!("test:{i}"), + parent: None, + display: None, + criteria: vec![Criterion { + name: "c".into(), + trigger: "minecraft:inventory_changed".into(), + conditions, + }], + requirements: vec![vec!["c".into()]], + rewards: Rewards::default(), + }); + tree.by_trigger + .entry("minecraft:inventory_changed".into()) + .or_default() + .push((i, 0)); + } + let index = InventoryIndex::build(&tree, |tag| match tag { + "minecraft:planks" => vec!["minecraft:oak_planks", "minecraft:birch_planks"], + _ => Vec::new(), + }); + let found = |held: &[&str]| -> Vec { + index + .candidates(held.iter().copied()) + .into_iter() + .map(|(ai, _)| ai) + .collect() + }; + assert_eq!(found(&[]), [2, 4]); + assert_eq!(found(&["minecraft:dirt"]), [2, 4]); + assert_eq!( + found(&["minecraft:oak_planks", "minecraft:diamond"]), + [0, 1, 2, 4] + ); + assert_eq!(found(&["minecraft:apple", "minecraft:apple"]), [2, 3, 4]); + } + /// A recipe unlocked tests only the criteria that name it. + #[test] + fn recipe_index_keeps_the_criteria_of_the_recipe() { + let mut tree = Tree::default(); + for (i, conditions) in [ + serde_json::json!({"recipes": "minecraft:oak_planks"}), + serde_json::json!({"recipes": "minecraft:stick"}), + serde_json::json!({}), + serde_json::json!({"recipes": "minecraft:oak_planks"}), + ] + .into_iter() + .enumerate() + { + tree.list.push(Advancement { + id: format!("test:{i}"), + parent: None, + display: None, + criteria: vec![Criterion { + name: "c".into(), + trigger: "minecraft:recipe_unlocked".into(), + conditions, + }], + requirements: vec![vec!["c".into()]], + rewards: Rewards::default(), + }); + tree.by_trigger + .entry("minecraft:recipe_unlocked".into()) + .or_default() + .push((i, 0)); + } + tree.index_recipes(); + assert_eq!( + tree.recipe_criteria("minecraft:oak_planks"), + [(0, 0), (2, 0), (3, 0)] + ); + assert_eq!(tree.recipe_criteria("minecraft:stick"), [(1, 0), (2, 0)]); + assert_eq!(tree.recipe_criteria("minecraft:torch"), [(2, 0)]); + } #[test] fn bucket_axolotl_block_advancements_require_the_placed_block() { let ctx = Entities { diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index d13ed6b13..b0f948c5d 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -91,6 +91,8 @@ pub(super) struct AdvState { /// The tree being read on another thread since the world opened /// (`prefetch_advancement_tree`), taken by the first `advancement_tree`. pub(super) pending_tree: Option>, + /// `inventory_changed`'s criteria by item, built for `tree`. + inventory_index: Option<(Arc, Arc)>, } /// The game's world for predicates. struct View<'a, 'g>(&'a Game<'g>); @@ -229,9 +231,31 @@ impl Game<'_> { _ => Tree::load(&self.options.resources.join("data")), }; self.adv.tree = Arc::new(tree); + // With the tree, while the world loads: built on the first + // inventory change it cost that tick ~10 ms. + self.inventory_index(); } self.adv.tree.clone() } + /// `inventory_changed`'s criteria by item, for the tree in place. + fn inventory_index(&mut self) -> Arc { + let tree = self.adv.tree.clone(); + if let Some((built, index)) = &self.adv.inventory_index + && Arc::ptr_eq(built, &tree) + { + return index.clone(); + } + let items = self.res.items(); + let index = Arc::new(adv::InventoryIndex::build(&tree, |tag| { + items + .item_tags + .get(tag) + .map(|t| t.iter().map(String::as_str).collect()) + .unwrap_or_default() + })); + self.adv.inventory_index = Some((tree, index.clone())); + index + } /// Start reading the advancement files on another thread while the world /// loads. The first tick's first criterion trigger used to read and parse /// all of them on the game thread (about 60 ms). @@ -394,6 +418,16 @@ impl Game<'_> { let Some(list) = tree.by_trigger.get(name) else { return; }; + self.trigger_criteria(&tree, list, test); + } + /// `trigger` for some of a trigger's criteria: (advancement, criterion) + /// indexes in `tree`, in tree order. + fn trigger_criteria( + &mut self, + tree: &Tree, + list: &[(usize, usize)], + test: impl Fn(&Value, &dyn adv::World) -> bool, + ) { let mut hits = Vec::new(); { let view = View(self); @@ -437,9 +471,14 @@ impl Game<'_> { } else { self.recipe_toast(unlocked); } + if unlocked.is_empty() || self.remote.is_some() || self.no_player_here() { + return; + } + self.load_advancements(); + let tree = self.adv.tree.clone(); for r in unlocked { - let r = r.clone(); - self.trigger("minecraft:recipe_unlocked", move |c, _| { + let list = tree.recipe_criteria(r); + self.trigger_criteria(&tree, &list, |c, _| { c["recipes"].as_str() == Some(r.as_str()) }); } @@ -560,7 +599,15 @@ impl Game<'_> { .is_some_and(|i| s.count >= i.max_stack) }) .count() as f64; - self.trigger("minecraft:inventory_changed", move |c, w| { + // Only the criteria the items held could pass (`InventoryIndex`). + if self.remote.is_some() || self.no_player_here() { + return; + } + self.load_advancements(); + let tree = self.adv.tree.clone(); + let index = self.inventory_index(); + let list = index.candidates(stacks.iter().map(|s| s.id.as_str())); + self.trigger_criteria(&tree, &list, move |c, w| { let slots = &c["slots"]; let range = |k: &str, v: f64| { let r = &slots[k]; @@ -965,10 +1012,8 @@ impl Game<'_> { }); positions.push((a.x, a.y)); } - let mut tree = Tree { - list, - ..Tree::default() - }; + let mut tree = Tree::default(); + tree.list = list; for (i, a) in tree.list.iter().enumerate() { tree.by_id.insert(a.id.clone(), i); } diff --git a/crates/horizon-client/src/logging.rs b/crates/horizon-client/src/logging.rs index cb7638f26..282831f67 100644 --- a/crates/horizon-client/src/logging.rs +++ b/crates/horizon-client/src/logging.rs @@ -12,7 +12,7 @@ use std::collections::VecDeque; use std::fs::{self, File, OpenOptions}; use std::io::{self, Read, Seek, SeekFrom, Write}; use std::path::{Path, PathBuf}; -use std::sync::Mutex; +use std::sync::{Mutex, mpsc}; use chrono::{DateTime, Local, NaiveDate}; @@ -201,16 +201,74 @@ pub fn open_latest(dir: &Path) -> io::Result> { Ok(Some(Latest { file, _lock: lock })) } -struct State { +/// What the writer thread is told. +enum Out { + /// Lines for the file, dated, and the message for stderr (Horizon's own). + Write { + date: NaiveDate, + lines: Vec, + stderr: Option, + }, + /// Answer once everything before is written. + Flush(mpsc::SyncSender<()>), +} + +/// The file side of the log, on its own thread: a line costs the thread that logs it a +/// format and a channel send, never a write that can wait (a full stderr pipe, a slow disk): +/// written on the game thread, a line could hold the tick for milliseconds while the CPU sat +/// idle. +struct Writer { file: Option, dir: PathBuf, /// The day the open file's lines belong to. date: NaiveDate, - recent: VecDeque, +} + +impl Writer { + fn run(mut self, out: mpsc::Receiver) { + let stderr = io::stderr(); + for msg in out { + match msg { + Out::Write { + date, + lines, + stderr: message, + } => { + if let Some(message) = message { + let _ = writeln!(stderr.lock(), "{message}"); + } + if date != self.date { + if let Some(latest) = &mut self.file + && let Err(e) = roll(&mut latest.file, &self.dir, self.date) + { + let _ = writeln!( + stderr.lock(), + "Horizon: could not roll over the log: {e}" + ); + } + self.date = date; + } + if let Some(latest) = &mut self.file { + let mut text = lines.join("\n"); + text.push('\n'); + let _ = latest.file.write_all(text.as_bytes()); + } + } + Out::Flush(done) => { + if let Some(latest) = &mut self.file { + let _ = latest.file.flush(); + } + let _ = done.send(()); + } + } + } + } } struct Logger { - state: Mutex, + out: mpsc::Sender, + /// The last lines, kept here (not on the writer) so a crash report has them at once. + recent: Mutex>, /// What the main thread is called in the log: "Render thread", or "Server thread" for the /// dedicated server, as in vanilla. main_thread: &'static str, @@ -233,53 +291,66 @@ impl log::Log for Logger { return; } let message = record.args().to_string(); - if ours(record.target()) { - eprintln!("{message}"); - } let current = std::thread::current(); let thread = match current.name() { Some("main") => self.main_thread, Some(name) => name, None => "unnamed", }; - self.write(thread, record.level(), &message); + let stderr = ours(record.target()).then(|| message.clone()); + self.send(thread, record.level(), &message, stderr); } + /// Waits (a second at most) until every line logged before is in the file. fn flush(&self) { - if let Some(latest) = &mut self.state.lock().unwrap_or_else(|e| e.into_inner()).file { - let _ = latest.file.flush(); + let (done, wait) = mpsc::sync_channel(1); + if self.out.send(Out::Flush(done)).is_ok() { + let _ = wait.recv_timeout(std::time::Duration::from_secs(1)); } } } impl Logger { fn write(&self, thread: &str, level: log::Level, message: &str) { + self.send(thread, level, message, None); + } + + fn send(&self, thread: &str, level: log::Level, message: &str, stderr: Option) { let now = Local::now(); - let mut state = self.state.lock().unwrap_or_else(|e| e.into_inner()); - let state = &mut *state; - if now.date_naive() != state.date { - if let Some(latest) = &mut state.file - && let Err(e) = roll(&mut latest.file, &state.dir, state.date) - { - eprintln!("Horizon: could not roll over the log: {e}"); - } - state.date = now.date_naive(); - } // As log4j writes a multi-line message: the pattern once, the rest as it is. - for (i, line) in message.lines().enumerate() { - let line = if i == 0 { - format_line(&now, thread, level, line) - } else { - line.to_owned() - }; - if let Some(latest) = &mut state.file { - let _ = writeln!(latest.file, "{line}"); - } - state.recent.push_back(line); - if state.recent.len() > RECENT { - state.recent.pop_front(); + let lines: Vec = message + .lines() + .enumerate() + .map(|(i, line)| { + if i == 0 { + format_line(&now, thread, level, line) + } else { + line.to_owned() + } + }) + .collect(); + { + let mut recent = self.recent.lock().unwrap_or_else(|e| e.into_inner()); + for line in &lines { + if recent.len() == RECENT { + recent.pop_front(); + } + recent.push_back(line.clone()); } } + let msg = Out::Write { + date: now.date_naive(), + lines, + stderr, + }; + if let Err(mpsc::SendError(Out::Write { + stderr: Some(message), + .. + })) = self.out.send(msg) + { + // No writer (it could not start): the terminal still gets Horizon's messages. + eprintln!("{message}"); + } } } @@ -304,14 +375,24 @@ pub fn init(home: &Path, main_thread: &'static str) { None } }; - let logger = LOGGER.get_or_init(|| Logger { - state: Mutex::new(State { + let logger = LOGGER.get_or_init(|| { + let (out, receive) = mpsc::channel(); + let writer = Writer { file, dir, date: Local::now().date_naive(), - recent: VecDeque::new(), - }), - main_thread, + }; + if let Err(e) = std::thread::Builder::new() + .name("Log writer".into()) + .spawn(move || writer.run(receive)) + { + eprintln!("Horizon: could not start the log writer: {e}"); + } + Logger { + out, + recent: Mutex::new(VecDeque::new()), + main_thread, + } }); if log::set_logger(logger).is_ok() { log::set_max_level(log::LevelFilter::Info); @@ -341,10 +422,9 @@ pub fn write_as(thread: &str, level: log::Level, message: &str) { /// The last lines written, oldest first (for crash reports). pub fn recent_lines() -> Vec { LOGGER.get().map_or_else(Vec::new, |l| { - l.state + l.recent .lock() .unwrap_or_else(|e| e.into_inner()) - .recent .iter() .cloned() .collect()