From c7e6991ccb4d711c381915d551b6707b355ef1a2 Mon Sep 17 00:00:00 2001 From: Erich Gubler Date: Thu, 10 Oct 2024 14:28:42 -0400 Subject: [PATCH] refactor: s/once_cell::Lazy/std::sync::LazyLock Weaken our dependence on the `once_cell` crate by using functionality from `std` instead that was upstreamed from `once_cell`, this time with what's available in Rust 1.80+. It's not yet possible to eliminate this dependency entirely, but do what we can for now. --- Cargo.lock | 2 -- benches/Cargo.toml | 1 - benches/benches/computepass.rs | 12 ++++++------ benches/benches/renderpass.rs | 12 ++++++------ benches/benches/resource_creation.rs | 6 +++--- wgpu-hal/Cargo.toml | 1 - wgpu-hal/src/gles/egl.rs | 7 ++++--- wgpu-hal/src/gles/wgl.rs | 7 +++---- 8 files changed, 22 insertions(+), 26 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 927cec23f3..9de68eae86 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3609,7 +3609,6 @@ dependencies = [ "criterion", "naga", "nanorand", - "once_cell", "pollster", "profiling", "rayon", @@ -3706,7 +3705,6 @@ dependencies = [ "naga", "ndk-sys", "objc", - "once_cell", "parking_lot", "profiling", "range-alloc", diff --git a/benches/Cargo.toml b/benches/Cargo.toml index ba47bc1b6a..d3e4966502 100644 --- a/benches/Cargo.toml +++ b/benches/Cargo.toml @@ -43,7 +43,6 @@ naga = { workspace = true, features = [ "wgsl-out", ] } nanorand.workspace = true -once_cell.workspace = true pollster.workspace = true profiling.workspace = true rayon.workspace = true diff --git a/benches/benches/computepass.rs b/benches/benches/computepass.rs index 719f84696e..7c39801f61 100644 --- a/benches/benches/computepass.rs +++ b/benches/benches/computepass.rs @@ -5,8 +5,8 @@ use std::{ use criterion::{criterion_group, Criterion, Throughput}; use nanorand::{Rng, WyRand}; -use once_cell::sync::Lazy; use rayon::iter::{IntoParallelIterator, ParallelIterator}; +use std::sync::LazyLock; use crate::DeviceState; @@ -424,7 +424,7 @@ impl ComputepassState { } fn run_bench(ctx: &mut Criterion) { - let state = Lazy::new(ComputepassState::new); + let state = LazyLock::new(ComputepassState::new); let dispatch_count = dispatch_count(); let dispatch_count_bindless = dispatch_count_bindless(); @@ -449,7 +449,7 @@ fn run_bench(ctx: &mut Criterion) { group.bench_function( format!("{cpasses} computepasses x {dispatch_per_pass} dispatches ({label})"), |b| { - Lazy::force(&state); + LazyLock::force(&state); b.iter_custom(|iters| { profiling::scope!("benchmark invocation"); @@ -498,7 +498,7 @@ fn run_bench(ctx: &mut Criterion) { group.bench_function( format!("{threads} threads x {dispatch_per_pass} dispatch"), |b| { - Lazy::force(&state); + LazyLock::force(&state); b.iter_custom(|iters| { profiling::scope!("benchmark invocation"); @@ -538,7 +538,7 @@ fn run_bench(ctx: &mut Criterion) { group.throughput(Throughput::Elements(dispatch_count_bindless as _)); group.bench_function(format!("{dispatch_count_bindless} dispatch"), |b| { - Lazy::force(&state); + LazyLock::force(&state); b.iter_custom(|iters| { profiling::scope!("benchmark invocation"); @@ -579,7 +579,7 @@ fn run_bench(ctx: &mut Criterion) { texture_count + storage_texture_count + storage_buffer_count ), |b| { - Lazy::force(&state); + LazyLock::force(&state); b.iter(|| state.device_state.queue.submit([])); }, diff --git a/benches/benches/renderpass.rs b/benches/benches/renderpass.rs index fe23aa62be..93ba32e966 100644 --- a/benches/benches/renderpass.rs +++ b/benches/benches/renderpass.rs @@ -5,8 +5,8 @@ use std::{ use criterion::{criterion_group, Criterion, Throughput}; use nanorand::{Rng, WyRand}; -use once_cell::sync::Lazy; use rayon::iter::{IntoParallelIterator, ParallelIterator}; +use std::sync::LazyLock; use crate::DeviceState; @@ -427,7 +427,7 @@ impl RenderpassState { } fn run_bench(ctx: &mut Criterion) { - let state = Lazy::new(RenderpassState::new); + let state = LazyLock::new(RenderpassState::new); let draw_count = draw_count(); let vertex_buffer_count = draw_count * VERTEX_BUFFERS_PER_DRAW; @@ -450,7 +450,7 @@ fn run_bench(ctx: &mut Criterion) { group.bench_function( format!("{rpasses} renderpasses x {draws_per_pass} draws ({label})"), |b| { - Lazy::force(&state); + LazyLock::force(&state); b.iter_custom(|iters| { profiling::scope!("benchmark invocation"); @@ -502,7 +502,7 @@ fn run_bench(ctx: &mut Criterion) { for threads in [2, 4, 8] { let draws_per_pass = draw_count / threads; group.bench_function(format!("{threads} threads x {draws_per_pass} draws"), |b| { - Lazy::force(&state); + LazyLock::force(&state); b.iter_custom(|iters| { profiling::scope!("benchmark invocation"); @@ -541,7 +541,7 @@ fn run_bench(ctx: &mut Criterion) { group.throughput(Throughput::Elements(draw_count as _)); group.bench_function(format!("{draw_count} draws"), |b| { - Lazy::force(&state); + LazyLock::force(&state); b.iter_custom(|iters| { profiling::scope!("benchmark invocation"); @@ -577,7 +577,7 @@ fn run_bench(ctx: &mut Criterion) { texture_count + vertex_buffer_count ), |b| { - Lazy::force(&state); + LazyLock::force(&state); b.iter(|| state.device_state.queue.submit([])); }, diff --git a/benches/benches/resource_creation.rs b/benches/benches/resource_creation.rs index da0c79a406..8423192ddc 100644 --- a/benches/benches/resource_creation.rs +++ b/benches/benches/resource_creation.rs @@ -1,13 +1,13 @@ use std::time::{Duration, Instant}; use criterion::{criterion_group, Criterion, Throughput}; -use once_cell::sync::Lazy; use rayon::iter::{IntoParallelIterator, ParallelIterator}; +use std::sync::LazyLock; use crate::DeviceState; fn run_bench(ctx: &mut Criterion) { - let state = Lazy::new(DeviceState::new); + let state = LazyLock::new(DeviceState::new); const RESOURCES_TO_CREATE: usize = 8; @@ -19,7 +19,7 @@ fn run_bench(ctx: &mut Criterion) { group.bench_function( format!("{threads} threads x {resources_per_thread} resource"), |b| { - Lazy::force(&state); + LazyLock::force(&state); b.iter_custom(|iters| { profiling::scope!("benchmark invocation"); diff --git a/wgpu-hal/Cargo.toml b/wgpu-hal/Cargo.toml index e4666b4418..3dfcbbc6fe 100644 --- a/wgpu-hal/Cargo.toml +++ b/wgpu-hal/Cargo.toml @@ -122,7 +122,6 @@ parking_lot.workspace = true profiling = { workspace = true, default-features = false } raw-window-handle.workspace = true thiserror.workspace = true -once_cell.workspace = true # backends common arrayvec.workspace = true diff --git a/wgpu-hal/src/gles/egl.rs b/wgpu-hal/src/gles/egl.rs index 42aec2b253..9fc800cf5c 100644 --- a/wgpu-hal/src/gles/egl.rs +++ b/wgpu-hal/src/gles/egl.rs @@ -1,9 +1,9 @@ use glow::HasContext; -use once_cell::sync::Lazy; use parking_lot::{MappedMutexGuard, Mutex, MutexGuard, RwLock}; use std::{ - collections::HashMap, ffi, mem::ManuallyDrop, os::raw, ptr, rc::Rc, sync::Arc, time::Duration, + collections::HashMap, ffi, mem::ManuallyDrop, os::raw, ptr, rc::Rc, sync::Arc, sync::LazyLock, + time::Duration, }; /// The amount of time to wait while trying to obtain a lock to the adapter context @@ -466,7 +466,8 @@ struct Inner { // Different calls to `eglGetPlatformDisplay` may return the same `Display`, making it a global // state of all our `EglContext`s. This forces us to track the number of such context to prevent // terminating the display if it's currently used by another `EglContext`. -static DISPLAYS_REFERENCE_COUNT: Lazy>> = Lazy::new(Default::default); +static DISPLAYS_REFERENCE_COUNT: LazyLock>> = + LazyLock::new(Default::default); fn initialize_display( egl: &EglInstance, diff --git a/wgpu-hal/src/gles/wgl.rs b/wgpu-hal/src/gles/wgl.rs index dfb7bf25db..c94e0727d4 100644 --- a/wgpu-hal/src/gles/wgl.rs +++ b/wgpu-hal/src/gles/wgl.rs @@ -6,7 +6,7 @@ use std::{ ptr, sync::{ mpsc::{sync_channel, SyncSender}, - Arc, + Arc, LazyLock, }, thread, time::Duration, @@ -17,7 +17,6 @@ use glutin_wgl_sys::wgl_extra::{ Wgl, CONTEXT_CORE_PROFILE_BIT_ARB, CONTEXT_DEBUG_BIT_ARB, CONTEXT_FLAGS_ARB, CONTEXT_PROFILE_MASK_ARB, }; -use once_cell::sync::Lazy; use parking_lot::{Mutex, MutexGuard, RwLock}; use raw_window_handle::{RawDisplayHandle, RawWindowHandle}; use wgt::InstanceFlags; @@ -319,8 +318,8 @@ fn create_global_window_class() -> Result { } fn get_global_window_class() -> Result { - static GLOBAL: Lazy> = - Lazy::new(create_global_window_class); + static GLOBAL: LazyLock> = + LazyLock::new(create_global_window_class); GLOBAL.clone() }