Merge pull request #2481 from ludovic111/perf/prefetch-world-data
🤖 Agent: verify passed (incl. Linux clippy for the glibc malloc_trim path); chunk_generation, worldgen, worldgen_random, save_roundtrip and world_reopen pass on this head; pr_ready --quick green. Preload starts on world select per the orchestrator's decision. Perf fix, no label.
This commit is contained in:
@@ -8081,6 +8081,7 @@ impl Game<'_> {
|
||||
creative: bool,
|
||||
create: Option<&horizon_client::title::WorldOptions>,
|
||||
) -> Result<()> {
|
||||
world_loading::world_data_used();
|
||||
if self.defer_world_entry(PendingWorldEntry::Local {
|
||||
folder: folder.to_owned(),
|
||||
name: name.map(str::to_owned),
|
||||
@@ -13045,6 +13046,17 @@ impl Game<'_> {
|
||||
if self.rest_loader.is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
let on_world_screens = self.title.as_ref().is_some_and(|title| {
|
||||
!matches!(
|
||||
title.mode,
|
||||
horizon_client::title::Mode::Main | horizon_client::title::Mode::Multiplayer(_)
|
||||
)
|
||||
});
|
||||
world_loading::preload_world_data(
|
||||
on_world_screens,
|
||||
&self.options.resources,
|
||||
self.pack.assets.registry,
|
||||
);
|
||||
if std::mem::take(&mut self.pending_pack_reload) {
|
||||
self.reload_packs();
|
||||
}
|
||||
|
||||
@@ -24,11 +24,24 @@ use horizon_protocol::{
|
||||
};
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
sync::{Arc, OnceLock},
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
|
||||
/// The registries and tags are the same for every world: load them once.
|
||||
static SYNC: OnceLock<std::result::Result<Arc<SyncData>, String>> = OnceLock::new();
|
||||
static SYNC: Mutex<Option<std::result::Result<Arc<SyncData>, String>>> = Mutex::new(None);
|
||||
|
||||
/// The registries and tags a server sends, loaded from `root` the first time.
|
||||
pub(super) fn sync_data(root: &std::path::Path) -> std::result::Result<Arc<SyncData>, String> {
|
||||
let mut sync = SYNC.lock().unwrap_or_else(|e| e.into_inner());
|
||||
sync.get_or_insert_with(|| SyncData::load(root).map(Arc::new))
|
||||
.clone()
|
||||
}
|
||||
|
||||
/// Let go of what `sync_data` loaded: for a preload no world used
|
||||
/// (game/world_loading.rs).
|
||||
pub(super) fn forget_sync_data() {
|
||||
*SYNC.lock().unwrap_or_else(|e| e.into_inner()) = None;
|
||||
}
|
||||
|
||||
/// The settings of the open world (WorldOptionsScreen's multiplayer section).
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
@@ -562,10 +575,7 @@ impl Game<'_> {
|
||||
config: HubConfig,
|
||||
host: Option<u128>,
|
||||
) -> Result<()> {
|
||||
let root = self.options.resources.clone();
|
||||
let sync = SYNC
|
||||
.get_or_init(|| SyncData::load(&root).map(Arc::new))
|
||||
.clone()?;
|
||||
let sync = sync_data(&self.options.resources)?;
|
||||
let biome_names: Vec<String> = self
|
||||
.res
|
||||
.biomes()
|
||||
|
||||
@@ -196,6 +196,82 @@ impl WorldLoader {
|
||||
}
|
||||
}
|
||||
|
||||
/// How long the preloaded world data outlives the world screens: a player
|
||||
/// who goes back to the title or to Multiplayer and opens no world for this
|
||||
/// long gets the memory back.
|
||||
const PRELOAD_KEPT: std::time::Duration = std::time::Duration::from_secs(60);
|
||||
|
||||
enum Preload {
|
||||
Idle,
|
||||
/// Read, or being read, on the "World data preload" thread. `left`: when
|
||||
/// the player last left the world screens.
|
||||
Started {
|
||||
thread: std::thread::JoinHandle<()>,
|
||||
left: Option<std::time::Instant>,
|
||||
},
|
||||
/// A world opened: the data is the world's now, and stays.
|
||||
Used,
|
||||
}
|
||||
|
||||
static PRELOAD: std::sync::Mutex<Preload> = std::sync::Mutex::new(Preload::Idle);
|
||||
|
||||
/// Each frame of the title: read what every world opening loads and keeps
|
||||
/// for the rest of the process (the worldgen bundle, the loot tables and the
|
||||
/// registries the server sends) on a helper thread while the player is on the
|
||||
/// world screens (`on_world_screens`: Singleplayer, Create World and their
|
||||
/// dialogs), so it overlaps the time spent choosing a world. A world opened
|
||||
/// meanwhile waits for the part being read instead of reading it again. Not
|
||||
/// at the title screen itself: many players only go to Multiplayer, and
|
||||
/// small machines need the memory. Dropped after `PRELOAD_KEPT` away from
|
||||
/// the world screens without a world opening.
|
||||
pub(super) fn preload_world_data(
|
||||
on_world_screens: bool,
|
||||
resources: &std::path::Path,
|
||||
registry: &'static horizon_world::registry::BlockRegistry,
|
||||
) {
|
||||
let mut preload = PRELOAD.lock().unwrap_or_else(|e| e.into_inner());
|
||||
match &mut *preload {
|
||||
Preload::Used => {}
|
||||
Preload::Idle if on_world_screens => {
|
||||
let resources = resources.to_owned();
|
||||
let spawned = std::thread::Builder::new()
|
||||
.name("World data preload".into())
|
||||
.spawn(move || {
|
||||
horizon_threads::behind_server();
|
||||
// Errors are left for the world opening to report.
|
||||
let _ = horizon_client::vanillagen::shared_data(
|
||||
&resources.join("worldgen"),
|
||||
registry,
|
||||
);
|
||||
let _ = horizon_client::structure_blocks::loot_data(&resources);
|
||||
let _ = super::lan::sync_data(&resources);
|
||||
});
|
||||
match spawned {
|
||||
Ok(thread) => *preload = Preload::Started { thread, left: None },
|
||||
Err(e) => log::warn!("Horizon: world data preload: {e}"),
|
||||
}
|
||||
}
|
||||
Preload::Idle => {}
|
||||
Preload::Started { left, .. } if on_world_screens => *left = None,
|
||||
Preload::Started { thread, left } => {
|
||||
let left = *left.get_or_insert_with(std::time::Instant::now);
|
||||
if left.elapsed() >= PRELOAD_KEPT && thread.is_finished() {
|
||||
horizon_client::vanillagen::forget_shared_data();
|
||||
horizon_client::structure_blocks::forget_loot_data();
|
||||
super::lan::forget_sync_data();
|
||||
horizon_threads::release_free_memory();
|
||||
*preload = Preload::Idle;
|
||||
log::info!("Horizon: preloaded world data dropped, no world opened");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A world opens: what `preload_world_data` read is the world's from now on.
|
||||
pub(super) fn world_data_used() {
|
||||
*PRELOAD.lock().unwrap_or_else(|e| e.into_inner()) = Preload::Used;
|
||||
}
|
||||
|
||||
pub(super) fn make_streaming(
|
||||
res: &Resources,
|
||||
pack: &PackResources,
|
||||
|
||||
@@ -9,7 +9,7 @@ use horizon_world::{
|
||||
};
|
||||
use std::{
|
||||
path::Path,
|
||||
sync::{Arc, OnceLock},
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
|
||||
/// The `custom_data` key holding an exploration map's search until the game
|
||||
@@ -114,11 +114,13 @@ pub fn has_pending_map(item: &ItemStack) -> bool {
|
||||
})
|
||||
}
|
||||
|
||||
static LOOT: OnceLock<Option<Arc<LootData>>> = OnceLock::new();
|
||||
/// None until `loot_data` runs; `Some(None)` when the tables failed to load.
|
||||
static LOOT: Mutex<Option<Option<Arc<LootData>>>> = Mutex::new(None);
|
||||
|
||||
/// Loot data of the resource root, loaded once per process.
|
||||
pub fn loot_data(root: &Path) -> Option<Arc<LootData>> {
|
||||
LOOT.get_or_init(|| match LootData::load(root) {
|
||||
let mut loot = LOOT.lock().unwrap_or_else(|e| e.into_inner());
|
||||
loot.get_or_insert_with(|| match LootData::load(root) {
|
||||
Ok(data) => Some(Arc::new(data)),
|
||||
Err(e) => {
|
||||
log::warn!("Horizon: loot tables unavailable, structure containers stay empty: {e}");
|
||||
@@ -130,7 +132,16 @@ pub fn loot_data(root: &Path) -> Option<Arc<LootData>> {
|
||||
|
||||
/// The loot data `loot_data` loaded, if it ran.
|
||||
pub fn loaded_loot_data() -> Option<Arc<LootData>> {
|
||||
LOOT.get().cloned().flatten()
|
||||
LOOT.lock()
|
||||
.unwrap_or_else(|e| e.into_inner())
|
||||
.clone()
|
||||
.flatten()
|
||||
}
|
||||
|
||||
/// Let go of the loot data: for a preload no world used
|
||||
/// (game/world_loading.rs). The next `loot_data` loads it again.
|
||||
pub fn forget_loot_data() {
|
||||
*LOOT.lock().unwrap_or_else(|e| e.into_inner()) = None;
|
||||
}
|
||||
|
||||
/// `RandomizableContainer.unpackLootTable` of a container at `pos`: `table`
|
||||
|
||||
@@ -333,15 +333,23 @@ impl VanillaTerrain {
|
||||
u64::try_from(self.created.elapsed().as_millis()).unwrap_or(u64::MAX)
|
||||
}
|
||||
}
|
||||
static SHARED_DATA: std::sync::Mutex<Vec<(std::path::PathBuf, Arc<GeneratorData>)>> =
|
||||
std::sync::Mutex::new(Vec::new());
|
||||
/// Let go of the bundles `shared_data` loaded: for a preload no world used
|
||||
/// (game/world_loading.rs). A generator that holds one keeps it.
|
||||
pub fn forget_shared_data() {
|
||||
SHARED_DATA
|
||||
.lock()
|
||||
.unwrap_or_else(|e| e.into_inner())
|
||||
.clear();
|
||||
}
|
||||
/// The worldgen bundle at `dir`, loaded once and shared by every generator
|
||||
/// and by live feature placement (sapling growth, bone meal).
|
||||
pub fn shared_data(
|
||||
dir: &Path,
|
||||
registry: &'static BlockRegistry,
|
||||
) -> crate::Result<Arc<GeneratorData>> {
|
||||
static CACHE: std::sync::Mutex<Vec<(std::path::PathBuf, Arc<GeneratorData>)>> =
|
||||
std::sync::Mutex::new(Vec::new());
|
||||
let mut cache = CACHE.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let mut cache = SHARED_DATA.lock().unwrap_or_else(|e| e.into_inner());
|
||||
if let Some((_, data)) = cache.iter().find(|(path, _)| path == dir) {
|
||||
return Ok(data.clone());
|
||||
}
|
||||
|
||||
@@ -126,6 +126,38 @@ fn idle() -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Give back to the OS the memory the allocator holds free, after something
|
||||
/// large was dropped: glibc keeps freed pages in the arena of the thread that
|
||||
/// allocated them, and macOS in its zones until memory runs short. Nothing
|
||||
/// elsewhere.
|
||||
pub fn release_free_memory() {
|
||||
release();
|
||||
}
|
||||
|
||||
#[cfg(all(target_os = "linux", target_env = "gnu"))]
|
||||
fn release() {
|
||||
// SAFETY: returns free heap pages of every arena to the OS; no live
|
||||
// allocation moves.
|
||||
unsafe {
|
||||
libc::malloc_trim(0);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_vendor = "apple")]
|
||||
fn release() {
|
||||
unsafe extern "C" {
|
||||
fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
|
||||
}
|
||||
// SAFETY: a null zone means every zone and a goal of 0 as much as it can;
|
||||
// it frees only pages no allocation uses.
|
||||
unsafe {
|
||||
malloc_zone_pressure_relief(std::ptr::null_mut(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(any(all(target_os = "linux", target_env = "gnu"), target_vendor = "apple")))]
|
||||
fn release() {}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
/// The hint holds on the platforms that take it.
|
||||
|
||||
Reference in New Issue
Block a user