VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Part of #4516: Windows renders start workers only for the cores the process may use
dotCooCoo4e785b40ce1d
diff --git a/Cargo.lock b/Cargo.lockindex 62f084afc..ff1d18be2 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -6065,6 +6065,7 @@ dependencies = ["smithay-clipboard","socket2","vectorcraft-engine",+ "vectorcraft-render","vectorcraft-text","vectorcraft-ui-egui","wayland-backend",diff --git a/apps/vectorcraft-cli/Cargo.toml b/apps/vectorcraft-cli/Cargo.tomlindex cb9183315..8f39e3b58 100644--- a/apps/vectorcraft-cli/Cargo.toml+++ b/apps/vectorcraft-cli/Cargo.toml@@ -34,8 +34,9 @@ winsafe = { version = "0.0.29", default-features = false, features = ["kernel",# DirectWrite's system font collection and GDI's font list (the desktop app's src/system_fonts.rs,# shared): fonts that font services such as Adobe Fonts load in place (#579, #1258). MIT OR-# Apache-2.0.-windows = { version = "0.62", features = ["Win32_Graphics_DirectWrite", "Win32_Graphics_Gdi"] }+# Apache-2.0. Win32_System_Threading has `GetProcessAffinityMask`, which the desktop app's+# src/windows_cores.rs, shared, uses to count the cores the process may run on.+windows = { version = "0.62", features = ["Win32_Graphics_DirectWrite", "Win32_Graphics_Gdi", "Win32_System_Threading"] }# CoreText's font manager (the desktop app's src/mac_fonts.rs, shared): fonts that apps and font# managers register from their own folders (#579). Zlib OR Apache-2.0 OR MIT.diff --git a/apps/vectorcraft-cli/src/main.rs b/apps/vectorcraft-cli/src/main.rsindex bba1976c1..b7334586c 100644--- a/apps/vectorcraft-cli/src/main.rs+++ b/apps/vectorcraft-cli/src/main.rs@@ -49,6 +49,10 @@ mod prefs_dir;#[cfg(windows)]#[path = "../../vectorcraft/src/system_fonts.rs"]mod system_fonts;+/// The desktop app's affinity-mask reader, shared: renders start workers only for usable cores.+#[cfg(windows)]+#[path = "../../vectorcraft/src/windows_cores.rs"]+mod windows_cores;use serde_json::{Value, json};use vectorcraft_engine::file_access::{self, AutomationRoots};@@ -161,6 +165,9 @@ fn help() -> Result<(), String> {}fn main() -> ExitCode {+ // Before the first render: the cores the process may run on.+ #[cfg(windows)]+ windows_cores::install();// Before any font lookup: the fonts font services load (#579).#[cfg(windows)]system_fonts::install();diff --git a/apps/vectorcraft/Cargo.toml b/apps/vectorcraft/Cargo.tomlindex 0657c93c8..7af8c51ef 100644--- a/apps/vectorcraft/Cargo.toml+++ b/apps/vectorcraft/Cargo.toml@@ -54,7 +54,11 @@ pollster = "1"# Win32_UI_WindowsAndMessaging has `MSG` and `WM_POINTERDOWN`, which src/windows_stylus.rs uses to# read a pen's barrel button from its pointer messages. Win32_UI_Input_Pointer has# `GetPointerPenInfo`, which it uses to read the pen's pressure and which end of the pen is down.-windows = { version = "0.62", features = ["Win32_Graphics_DirectWrite", "Win32_Graphics_Gdi", "Win32_UI_Input_Pointer", "Win32_UI_WindowsAndMessaging"] }+# Win32_System_Threading has `GetProcessAffinityMask`, which src/windows_cores.rs uses to count the+# cores the process may run on.+windows = { version = "0.62", features = ["Win32_Graphics_DirectWrite", "Win32_Graphics_Gdi", "Win32_System_Threading", "Win32_UI_Input_Pointer", "Win32_UI_WindowsAndMessaging"] }+# The renderer's worker count follows those cores (src/windows_cores.rs).+vectorcraft-render = { workspace = true }[target.'cfg(target_os = "macos")'.dependencies]# The macOS menu bar (src/mac_menu.rs): Tauri's menu crate, AppKit menus behind a safe API (no GTKdiff --git a/apps/vectorcraft/src/main.rs b/apps/vectorcraft/src/main.rsindex e90977726..1e2ab4fae 100644--- a/apps/vectorcraft/src/main.rs+++ b/apps/vectorcraft/src/main.rs@@ -50,6 +50,8 @@ mod system_fonts;mod tablet;mod window;mod window_frame;+#[cfg(windows)]+mod windows_cores;mod windows_stylus;mod xwayland;@@ -184,6 +186,9 @@ fn main() -> std::process::ExitCode {// Before desktop services, so every start-up warning is recorded (`logging`).let logger = logging::install();vectorcraft_ui_egui::i18n::detect_system_lang_in_background();+ // Before the first render: the cores the process may run on.+ #[cfg(windows)]+ windows_cores::install();// Before the first font scan (the app's start): the fonts font services load (#579).#[cfg(windows)]system_fonts::install();diff --git a/apps/vectorcraft/src/windows_cores.rs b/apps/vectorcraft/src/windows_cores.rsnew file mode 100644index 000000000..97d040550--- /dev/null+++ b/apps/vectorcraft/src/windows_cores.rs@@ -0,0 +1,59 @@+//! Windows: the cores the process may run on, from its affinity mask, for the renderer's worker+//! count (`vectorcraft_render::set_usable_cores`). `available_parallelism` counts every processor+//! in the machine, also when the process may run on fewer (started with `start /affinity`, or+//! pinned by a launcher). The desktop app and `vectorcraft-cli` (exports, MCP) both install it; the+//! CLI shares this file.+//!+//! `GetProcessAffinityMask` is a C API with no safe binding, hence the scoped `unsafe_code`+//! allowance.+#![allow(unsafe_code)]++use windows::Win32::System::Threading::{GetCurrentProcess, GetProcessAffinityMask};++/// Tells the renderer how many cores the process may run on.+pub fn install() {+ vectorcraft_render::set_usable_cores(usable_cores());+}++/// The number of cores in the process's affinity mask, or `None` when Windows reports none (a+/// process with threads in more than one processor group).+fn usable_cores() -> Option<usize> {+ let (mut process, mut system) = (0usize, 0usize);+ // SAFETY: `GetCurrentProcess` returns a pseudo-handle that needs no closing, and both pointers+ // point at live `usize`s for the length of the call.+ unsafe { GetProcessAffinityMask(GetCurrentProcess(), &mut process, &mut system) }.ok()?;+ (process != 0).then(|| process.count_ones() as usize)+}++#[cfg(test)]+mod tests {+ /// A process that may run on one core renders on the calling thread. With workers, the+ /// renderer's flush spins on that core while the workers it waits for get no time, and a render+ /// crawls or stalls.+ #[test]+ fn a_process_limited_to_one_core_starts_no_render_workers() {+ const CHILD: &str = "VECTORCRAFT_TEST_ONE_CORE";+ const NAME: &str = "windows_cores::tests::a_process_limited_to_one_core_starts_no_render_workers";+ if std::env::var_os(CHILD).is_some() {+ assert_eq!(super::usable_cores(), Some(1));+ super::install();+ assert_eq!(vectorcraft_render::default_threads(), 0);+ return;+ }+ // `start /affinity 1` runs this test again in a process allowed only the first core.+ use std::os::windows::process::CommandExt;+ let exe = std::env::current_exe().unwrap();+ let output = std::process::Command::new("cmd")+ .raw_arg(format!("/C start \"\" /affinity 1 /wait /b \"{}\" --exact {NAME} --nocapture", exe.display()))+ .env(CHILD, "1")+ .env_remove("VECTORCRAFT_RENDER_THREADS")+ .output()+ .unwrap();+ let stdout = String::from_utf8_lossy(&output.stdout);+ assert!(+ output.status.success() && stdout.contains("test result: ok. 1 passed; 0 failed;"),+ "one-core test failed:\n{stdout}\n{}",+ String::from_utf8_lossy(&output.stderr),+ );+ }+}diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rsindex d5c601dc1..8bf6b0d23 100644--- a/crates/render/src/lib.rs+++ b/crates/render/src/lib.rs@@ -227,6 +227,6 @@ pub(crate) use text_geom::is_opentype_alternate;#[cfg(test)]use text_geom::text_geom;pub(crate) use threads::single_threaded_context;-pub use threads::{default_threads, set_default_threads};+pub use threads::{default_threads, set_default_threads, set_usable_cores};#[cfg(test)]mod tests;diff --git a/crates/render/src/threads.rs b/crates/render/src/threads.rsindex eb1fb66ea..dfd6bf757 100644--- a/crates/render/src/threads.rs+++ b/crates/render/src/threads.rs@@ -9,14 +9,25 @@ pub(crate) fn single_threaded_context(w: u16, h: u16) -> RenderContext {/// Preferred rasterizer thread count set by the app (Preferences → Performance); negative = automatic.static THREADS_OVERRIDE: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1);+/// The cores the process may run on, as the app read them from the system; 0 = not known.+static USABLE_CORES: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);+/// Override the worker-thread count used by renderers created from now on (`None` = automatic).pub fn set_default_threads(n: Option<u16>) {THREADS_OVERRIDE.store(n.map_or(-1, i32::from), std::sync::atomic::Ordering::Relaxed);}-/// Rasterizer worker threads: 0 on wasm; otherwise one per core up to 8, leaving a core free. On a-/// 10-core machine 8 workers render a 50,000-path page 1.4× faster than 4 (9 are slower again);-/// the pixels don't depend on the count (`pixels_do_not_depend_on_the_thread_count`).+/// The number of cores the process may run on, when the app knows a smaller number than+/// `available_parallelism` gives (`None` = not known). On Windows `available_parallelism` counts+/// every processor in the machine, also when the process's affinity mask allows fewer.+pub fn set_usable_cores(n: Option<usize>) {+ USABLE_CORES.store(n.unwrap_or(0), std::sync::atomic::Ordering::Relaxed);+}++/// Rasterizer worker threads: 0 on wasm; otherwise one per core the process may run on, up to 8,+/// leaving a core free. On a 10-core machine 8 workers render a 50,000-path page 1.4× faster than 4+/// (9 are slower again); the pixels don't depend on the count+/// (`pixels_do_not_depend_on_the_thread_count`).pub fn default_threads() -> u16 {#[cfg(target_arch = "wasm32")]{@@ -31,6 +42,31 @@ pub fn default_threads() -> u16 {if std::env::var_os("VECTORCRAFT_RENDER_THREADS").is_some() {return std::env::var("VECTORCRAFT_RENDER_THREADS").ok().and_then(|v| v.parse().ok()).unwrap_or(0);}- std::thread::available_parallelism().map(|n| (n.get().saturating_sub(1)).min(8) as u16).unwrap_or(0)+ let usable = USABLE_CORES.load(std::sync::atomic::Ordering::Relaxed);+ std::thread::available_parallelism().map(|n| automatic_threads(n.get(), usable)).unwrap_or(0)+ }+}++/// [`default_threads`] when automatic, on `cpus` processors of which the process may use `usable`+/// (0 = all).+fn automatic_threads(cpus: usize, usable: usize) -> u16 {+ let cores = if usable == 0 { cpus } else { cpus.min(usable) };+ (cores.saturating_sub(1)).min(8) as u16+}++#[cfg(test)]+mod tests {+ use super::automatic_threads;++ /// A process that may run on one core renders on the calling thread. With workers, vello_cpu's+ /// flush spins on that core while the workers it waits for get no time, and a render crawls or+ /// stalls.+ #[test]+ fn workers_follow_the_cores_the_process_may_use() {+ assert_eq!(automatic_threads(24, 0), 8);+ assert_eq!(automatic_threads(24, 1), 0);+ assert_eq!(automatic_threads(24, 4), 3);+ assert_eq!(automatic_threads(4, 16), 3);+ assert_eq!(automatic_threads(1, 0), 0);}}