forked from mirrors/gecko-dev
d7b3b5e676
Backed out changeset b4fdddaf2639 (bug 1892204) Backed out changeset 2841d6df03fe (bug 1892204)
101 lines
3.6 KiB
Rust
101 lines
3.6 KiB
Rust
// Copyright 2019 Developers of the Rand project.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
#![allow(dead_code)]
|
|
use core::{
|
|
mem::MaybeUninit,
|
|
ptr,
|
|
sync::atomic::{AtomicUsize, Ordering::Relaxed},
|
|
};
|
|
|
|
// This structure represents a lazily initialized static usize value. Useful
|
|
// when it is preferable to just rerun initialization instead of locking.
|
|
// Both unsync_init and sync_init will invoke an init() function until it
|
|
// succeeds, then return the cached value for future calls.
|
|
//
|
|
// Both methods support init() "failing". If the init() method returns UNINIT,
|
|
// that value will be returned as normal, but will not be cached.
|
|
//
|
|
// Users should only depend on the _value_ returned by init() functions.
|
|
// Specifically, for the following init() function:
|
|
// fn init() -> usize {
|
|
// a();
|
|
// let v = b();
|
|
// c();
|
|
// v
|
|
// }
|
|
// the effects of c() or writes to shared memory will not necessarily be
|
|
// observed and additional synchronization methods with be needed.
|
|
pub struct LazyUsize(AtomicUsize);
|
|
|
|
impl LazyUsize {
|
|
pub const fn new() -> Self {
|
|
Self(AtomicUsize::new(Self::UNINIT))
|
|
}
|
|
|
|
// The initialization is not completed.
|
|
pub const UNINIT: usize = usize::max_value();
|
|
|
|
// Runs the init() function at least once, returning the value of some run
|
|
// of init(). Multiple callers can run their init() functions in parallel.
|
|
// init() should always return the same value, if it succeeds.
|
|
pub fn unsync_init(&self, init: impl FnOnce() -> usize) -> usize {
|
|
// Relaxed ordering is fine, as we only have a single atomic variable.
|
|
let mut val = self.0.load(Relaxed);
|
|
if val == Self::UNINIT {
|
|
val = init();
|
|
self.0.store(val, Relaxed);
|
|
}
|
|
val
|
|
}
|
|
}
|
|
|
|
// Identical to LazyUsize except with bool instead of usize.
|
|
pub struct LazyBool(LazyUsize);
|
|
|
|
impl LazyBool {
|
|
pub const fn new() -> Self {
|
|
Self(LazyUsize::new())
|
|
}
|
|
|
|
pub fn unsync_init(&self, init: impl FnOnce() -> bool) -> bool {
|
|
self.0.unsync_init(|| init() as usize) != 0
|
|
}
|
|
}
|
|
|
|
/// Polyfill for `maybe_uninit_slice` feature's
|
|
/// `MaybeUninit::slice_assume_init_mut`. Every element of `slice` must have
|
|
/// been initialized.
|
|
#[inline(always)]
|
|
pub unsafe fn slice_assume_init_mut<T>(slice: &mut [MaybeUninit<T>]) -> &mut [T] {
|
|
// SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.
|
|
&mut *(slice as *mut [MaybeUninit<T>] as *mut [T])
|
|
}
|
|
|
|
#[inline]
|
|
pub fn uninit_slice_fill_zero(slice: &mut [MaybeUninit<u8>]) -> &mut [u8] {
|
|
unsafe { ptr::write_bytes(slice.as_mut_ptr(), 0, slice.len()) };
|
|
unsafe { slice_assume_init_mut(slice) }
|
|
}
|
|
|
|
#[inline(always)]
|
|
pub fn slice_as_uninit<T>(slice: &[T]) -> &[MaybeUninit<T>] {
|
|
// SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.
|
|
// There is no risk of writing a `MaybeUninit<T>` into the result since
|
|
// the result isn't mutable.
|
|
unsafe { &*(slice as *const [T] as *const [MaybeUninit<T>]) }
|
|
}
|
|
|
|
/// View an mutable initialized array as potentially-uninitialized.
|
|
///
|
|
/// This is unsafe because it allows assigning uninitialized values into
|
|
/// `slice`, which would be undefined behavior.
|
|
#[inline(always)]
|
|
pub unsafe fn slice_as_uninit_mut<T>(slice: &mut [T]) -> &mut [MaybeUninit<T>] {
|
|
// SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.
|
|
&mut *(slice as *mut [T] as *mut [MaybeUninit<T>])
|
|
}
|