Compiler Explorer

Source code

#![allow(bad_style)]
use std::sync::atomic::{*, Ordering::*};

#[repr(C)]
#[derive(Copy, Clone)]
pub struct mach_timebase_info {
    numer: u32,
    denom: u32,
}
type mach_timebase_info_t = *mut mach_timebase_info;
type kern_return_t = std::os::raw::c_int;

pub fn info_new() -> mach_timebase_info {
    // INFO_BITS conceptually is an `Option<mach_timebase_info>`. We can do
    // this in 64 bits because we know 0 is never a valid value for the
    // `denom` field.
    //
    // Encoding this as a single `AtomicU64` allows us to use `Relaxed`
    // operations, as we are only interested in in the effects on a single
    // memory location.
    static INFO_BITS: AtomicU64 = AtomicU64::new(0);
    let info_bits = INFO_BITS.load(Ordering::Relaxed);

// If a previous thread has filled in INFO_BITS, use that.
    if info_bits != 0 {
        return info_from_bits(info_bits)
    }

// ... otherwise learn for ourselves ...
    extern "C" {
        fn mach_timebase_info(info: mach_timebase_info_t) -> kern_return_t;
    }

let mut info = info_from_bits(0);
    unsafe {
        mach_timebase_info(&mut info);
    }
    debug_assert!(info.denom != 0);
    INFO_BITS.store(info_to_bits(info), Ordering::Relaxed);
    info
}

pub fn info_less_new() -> mach_timebase_info {
    static INITIALIZED: AtomicBool = AtomicBool::new(false);
    static INFO_BITS: AtomicU64 = AtomicU64::new(0);

// If a previous thread has filled in this global INITIALIZED, use that.
    if INITIALIZED.load(Ordering::Acquire) {
        // The Acquire/Release pair used for INITIALIZED ensures that this
        // load can see the corresponding `INFO_BITS` store, despite them
        // both being Relaxed.
        return info_from_bits(INFO_BITS.load(Ordering::Relaxed));
    }

// ... otherwise learn for ourselves ...
    extern "C" {
        fn mach_timebase_info(info: mach_timebase_info_t) -> kern_return_t;
    }

let mut info = info_from_bits(0);
    unsafe {
        mach_timebase_info(&mut info);
    }

// Note: This is racy, but the race is against other threads trying to
    // write the same value.
    INFO_BITS.store(info_to_bits(info), Ordering::Relaxed);

// The `Release` here "publishes" the store of `INFO_BITS` to other
    // threads (which do a `INITIALIZED.load(Acquire)`) despite it being
    // read/written w/ `Relaxed`.
    INITIALIZED.store(true, Ordering::Release);
    info
}

#[inline]
fn info_to_bits(info: mach_timebase_info) -> u64 {
    ((info.denom as u64) << 32) | (info.numer as u64)
}

#[inline]
fn info_from_bits(bits: u64) -> mach_timebase_info {
    mach_timebase_info {
        numer: bits as u32,
        denom: (bits >> 32) as u32,
    }
}

pub fn info_original() -> mach_timebase_info {
    static mut INFO: mach_timebase_info = mach_timebase_info { numer: 0, denom: 0 };
    static STATE: AtomicUsize = AtomicUsize::new(0);

unsafe {
        // If a previous thread has filled in this global state, use that.
        if STATE.load(SeqCst) == 2 {
            return INFO;
        }

// ... otherwise learn for ourselves ...
        let mut info = std::mem::zeroed();
        extern "C" {
            fn mach_timebase_info(info: mach_timebase_info_t) -> kern_return_t;
        }

mach_timebase_info(&mut info);

// ... and attempt to be the one thread that stores it globally for
        // all other threads
        if STATE.compare_exchange(0, 1, SeqCst, SeqCst).is_ok() {
            INFO = info;
            STATE.store(2, SeqCst);
        }
        return info;
    }
}

pub fn info_orig_but_better_orderings() -> mach_timebase_info {
    static mut INFO: mach_timebase_info = mach_timebase_info { numer: 0, denom: 0 };
    static STATE: AtomicUsize = AtomicUsize::new(0);

unsafe {
        // If a previous thread has filled in this global state, use that.
        if STATE.load(Acquire) == 2 {
            return INFO;
        }

// ... otherwise learn for ourselves ...
        let mut info = std::mem::zeroed();
        extern "C" {
            fn mach_timebase_info(info: mach_timebase_info_t) -> kern_return_t;
        }

mach_timebase_info(&mut info);

// ... and attempt to be the one thread that stores it globally for
        // all other threads

// Relaxed/Relaxed is fine (I hope?) because we don't need to
        // observe values from other threads
        if STATE.compare_exchange(0, 1, Relaxed, Relaxed).is_ok() {
            INFO = info;
            STATE.store(2, Release);
        }
        return info;
    }
}