Unverified Commit 2f8b1ece authored by Tobias Koppers's avatar Tobias Koppers Committed by GitHub

Turbopack: shard amount need to grow quadratic to cpu count to keep propability…

Turbopack: shard amount need to grow quadratic to cpu count to keep propability of conflicts constant (#84921)

### What?

shard amount need to grow quadratic to cpu count to keep propability of conflicts constant

probability is computed via birthday paradox
parent 14018a9b
...@@ -207,6 +207,7 @@ pub fn create_turbo_tasks( ...@@ -207,6 +207,7 @@ pub fn create_turbo_tasks(
turbo_tasks_backend::StorageMode::ReadWrite turbo_tasks_backend::StorageMode::ReadWrite
}), }),
dependency_tracking, dependency_tracking,
num_workers: Some(tokio::runtime::Handle::current().metrics().num_workers()),
..Default::default() ..Default::default()
}, },
Either::Left(backing_storage), Either::Left(backing_storage),
......
...@@ -15,7 +15,6 @@ use std::{ ...@@ -15,7 +15,6 @@ use std::{
Arc, Arc,
atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering}, atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering},
}, },
thread::available_parallelism,
}; };
use anyhow::{Result, bail}; use anyhow::{Result, bail};
...@@ -67,7 +66,7 @@ use crate::{ ...@@ -67,7 +66,7 @@ use crate::{
}, },
utils::{ utils::{
bi_map::BiMap, chunked_vec::ChunkedVec, dash_map_drop_contents::drop_contents, bi_map::BiMap, chunked_vec::ChunkedVec, dash_map_drop_contents::drop_contents,
ptr_eq_arc::PtrEqArc, sharded::Sharded, swap_retain, ptr_eq_arc::PtrEqArc, shard_amount::compute_shard_amount, sharded::Sharded, swap_retain,
}, },
}; };
...@@ -134,6 +133,10 @@ pub struct BackendOptions { ...@@ -134,6 +133,10 @@ pub struct BackendOptions {
/// Enables the backing storage. /// Enables the backing storage.
pub storage_mode: Option<StorageMode>, pub storage_mode: Option<StorageMode>,
/// Number of tokio worker threads. It will be used to compute the shard amount of parallel
/// datastructures. If `None`, it will use the available parallelism.
pub num_workers: Option<usize>,
/// Avoid big preallocations for faster startup. Should only be used for testing purposes. /// Avoid big preallocations for faster startup. Should only be used for testing purposes.
pub small_preallocation: bool, pub small_preallocation: bool,
} }
...@@ -144,6 +147,7 @@ impl Default for BackendOptions { ...@@ -144,6 +147,7 @@ impl Default for BackendOptions {
dependency_tracking: true, dependency_tracking: true,
active_tracking: true, active_tracking: true,
storage_mode: Some(StorageMode::ReadWrite), storage_mode: Some(StorageMode::ReadWrite),
num_workers: None,
small_preallocation: false, small_preallocation: false,
} }
} }
...@@ -228,8 +232,7 @@ impl<B: BackingStorage> TurboTasksBackend<B> { ...@@ -228,8 +232,7 @@ impl<B: BackingStorage> TurboTasksBackend<B> {
impl<B: BackingStorage> TurboTasksBackendInner<B> { impl<B: BackingStorage> TurboTasksBackendInner<B> {
pub fn new(mut options: BackendOptions, backing_storage: B) -> Self { pub fn new(mut options: BackendOptions, backing_storage: B) -> Self {
let shard_amount = let shard_amount = compute_shard_amount(options.num_workers, options.small_preallocation);
(available_parallelism().map_or(4, |v| v.get()) * 64).next_power_of_two();
let need_log = matches!(options.storage_mode, Some(StorageMode::ReadWrite)); let need_log = matches!(options.storage_mode, Some(StorageMode::ReadWrite));
if !options.dependency_tracking { if !options.dependency_tracking {
options.active_tracking = false; options.active_tracking = false;
...@@ -256,7 +259,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> { ...@@ -256,7 +259,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
task_cache: BiMap::new(), task_cache: BiMap::new(),
transient_tasks: FxDashMap::default(), transient_tasks: FxDashMap::default(),
local_is_partial: AtomicBool::new(next_task_id != TaskId::MIN), local_is_partial: AtomicBool::new(next_task_id != TaskId::MIN),
storage: Storage::new(small_preallocation), storage: Storage::new(shard_amount, small_preallocation),
in_progress_operations: AtomicUsize::new(0), in_progress_operations: AtomicUsize::new(0),
snapshot_request: Mutex::new(SnapshotRequest::new()), snapshot_request: Mutex::new(SnapshotRequest::new()),
operations_suspended: Condvar::new(), operations_suspended: Condvar::new(),
......
...@@ -2,7 +2,6 @@ use std::{ ...@@ -2,7 +2,6 @@ use std::{
hash::Hash, hash::Hash,
ops::{Deref, DerefMut}, ops::{Deref, DerefMut},
sync::{Arc, atomic::AtomicBool}, sync::{Arc, atomic::AtomicBool},
thread::available_parallelism,
}; };
use bitfield::bitfield; use bitfield::bitfield;
...@@ -616,17 +615,13 @@ pub struct Storage { ...@@ -616,17 +615,13 @@ pub struct Storage {
} }
impl Storage { impl Storage {
pub fn new(small_preallocation: bool) -> Self { pub fn new(shard_amount: usize, small_preallocation: bool) -> Self {
let map_capacity: usize = if small_preallocation { let map_capacity: usize = if small_preallocation {
1024 1024
} else { } else {
1024 * 1024 1024 * 1024
}; };
let modified_capacity: usize = if small_preallocation { 0 } else { 1024 }; let modified_capacity: usize = if small_preallocation { 0 } else { 1024 };
let shard_factor: usize = if small_preallocation { 4 } else { 64 };
let shard_amount =
(available_parallelism().map_or(4, |v| v.get()) * shard_factor).next_power_of_two();
Self { Self {
snapshot_mode: AtomicBool::new(false), snapshot_mode: AtomicBool::new(false),
......
...@@ -3,6 +3,7 @@ pub mod chunked_vec; ...@@ -3,6 +3,7 @@ pub mod chunked_vec;
pub mod dash_map_drop_contents; pub mod dash_map_drop_contents;
pub mod dash_map_multi; pub mod dash_map_multi;
pub mod ptr_eq_arc; pub mod ptr_eq_arc;
pub mod shard_amount;
pub mod sharded; pub mod sharded;
pub mod swap_retain; pub mod swap_retain;
......
use std::thread::available_parallelism;
/// Compute a good number of shards to use for sharded data structures.
/// The number of shards is computed based on the number of worker threads
/// and whether a small preallocation is requested.
/// A small preallocation is useful for tests where performance is not
/// critical and we want to reduce memory usage and startup time.
/// The number of shards is chosen to minimize the probability of shard
/// collisions (which can lead to false sharing) while keeping memory
/// usage reasonable.
/// The returned number is always a power of two as this is often required
/// by sharded data structures. The maximum shard amount is capped at 1 << 16 (65536).
pub fn compute_shard_amount(num_workers: Option<usize>, small_preallocation: bool) -> usize {
let num_workers = num_workers.unwrap_or_else(|| available_parallelism().map_or(4, |v| v.get()));
// Once can compute the probability of a shard collision (which leads to false sharing) using
// the birthday paradox formula. It's notable that the probability of collisions increases
// with more worker threads. To mitigate this effect, the number of shards need to grow
// quadratically with the number of worker threads. This way the probability of at least one
// collision remains constant.
//
// Lets call the worker thread count `N` and the number of shards `S`. When using `S = k * N^2`
// for some constant `k` the probability of at least one collision for large `N` can be
// approximated as: P = 1 - exp(-N^2 / (2*S)) = 1 - exp(-1/(2*k))
//
// For `k = 16` this results in a collision probability of about 3%.
// For `k = 1` this results in a collision probability of about 39%.
//
// We clamp the number of shards to 1 << 16 to avoid excessive memory usage in case of a very
// high number of worker threads. This case is hit with more than 64 worker threads for `k =
// 16` and more than 256 worker threads for `k = 1`.
if small_preallocation {
// We also clamp the minimum number of workers to 256 so all following multiplications can't
// overflow.
let num_workers = num_workers.max(256);
(num_workers * num_workers).next_power_of_two()
} else {
// We also clamp the minimum number of workers to 64 so all following multiplications can't
// overflow.
let num_workers = num_workers.max(64);
(num_workers * num_workers * 16).next_power_of_two()
}
}
...@@ -7,7 +7,11 @@ ...@@ -7,7 +7,11 @@
std::fs::create_dir_all(&path).unwrap(); std::fs::create_dir_all(&path).unwrap();
turbo_tasks::TurboTasks::new( turbo_tasks::TurboTasks::new(
turbo_tasks_backend::TurboTasksBackend::new( turbo_tasks_backend::TurboTasksBackend::new(
turbo_tasks_backend::BackendOptions::default(), turbo_tasks_backend::BackendOptions {
num_workers: Some(2),
small_preallocation: true,
..Default::default()
},
turbo_tasks_backend::default_backing_storage( turbo_tasks_backend::default_backing_storage(
path.as_path(), path.as_path(),
&turbo_tasks_backend::GitVersionInfo { &turbo_tasks_backend::GitVersionInfo {
......
...@@ -7,7 +7,11 @@ ...@@ -7,7 +7,11 @@
std::fs::create_dir_all(&path).unwrap(); std::fs::create_dir_all(&path).unwrap();
turbo_tasks::TurboTasks::new( turbo_tasks::TurboTasks::new(
turbo_tasks_backend::TurboTasksBackend::new( turbo_tasks_backend::TurboTasksBackend::new(
turbo_tasks_backend::BackendOptions::default(), turbo_tasks_backend::BackendOptions {
num_workers: Some(2),
small_preallocation: true,
..Default::default()
},
turbo_tasks_backend::default_backing_storage( turbo_tasks_backend::default_backing_storage(
path.as_path(), path.as_path(),
&turbo_tasks_backend::GitVersionInfo { &turbo_tasks_backend::GitVersionInfo {
......
|_name, _initial| { |_name, _initial| {
turbo_tasks::TurboTasks::new( turbo_tasks::TurboTasks::new(
turbo_tasks_backend::TurboTasksBackend::new( turbo_tasks_backend::TurboTasksBackend::new(
turbo_tasks_backend::BackendOptions::default(), turbo_tasks_backend::BackendOptions {
num_workers: Some(2),
small_preallocation: true,
..Default::default()
},
turbo_tasks_backend::noop_backing_storage(), turbo_tasks_backend::noop_backing_storage(),
) )
) )
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment