Merge #140

140: Improve `imp_pl` size r=matklad a=quininer

I have observed that the program size has increased a lot after enabling the `parking_lot` feature.

`parking_lot` will actively inline methods, which leads to some unnecessary duplication of code. see Amanieu/parking_lot#236

This PR introduces an `InlineLessRawMutex` wrapper to avoid this problem. `initialize` is a cold path, I don't think this will cause performance problems.

Co-authored-by: quininer <quininer@live.com>

Author: bors[bot]

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## 1.7.1
 
 - Fix `race::OnceBox<T>` to also impl `Default` even if `T` doesn't impl `Default`.
+- Improve code size.
 
 ## 1.7.0
 

src/imp_pl.rs

@@ -46,8 +46,10 @@ impl<T> OnceCell<T> {
     where
         F: FnOnce() -> Result<T, E>,
     {
-        let _guard = self.mutex.lock();
-        if !self.is_initialized() {
+        let mut f = Some(f);
+        let mut res: Result<(), E> = Ok(());
+        let slot: *mut Option<T> = self.value.get();
+        initialize_inner(&self.mutex, &self.is_initialized, &mut || {
             // We are calling user-supplied function and need to be careful.
             // - if it returns Err, we unlock mutex and return without touching anything
             // - if it panics, we unlock mutex and propagate panic without touching anything
@@ -56,15 +58,22 @@ impl<T> OnceCell<T> {
             //   but that is more complicated
             // - finally, if it returns Ok, we store the value and store the flag with
             //   `Release`, which synchronizes with `Acquire`s.
-            let value = f()?;
-            // Safe b/c we have a unique access and no panic may happen
-            // until the cell is marked as initialized.
-            let slot: &mut Option<T> = unsafe { &mut *self.value.get() };
-            debug_assert!(slot.is_none());
-            *slot = Some(value);
-            self.is_initialized.store(true, Ordering::Release);
-        }
-        Ok(())
+            let f = f.take().unwrap_or_else(|| unsafe { hint::unreachable_unchecked() });
+            match f() {
+                Ok(value) => unsafe {
+                    // Safe b/c we have a unique access and no panic may happen
+                    // until the cell is marked as initialized.
+                    debug_assert!((*slot).is_none());
+                    *slot = Some(value);
+                    true
+                },
+                Err(err) => {
+                    res = Err(err);
+                    false
+                }
+            }
+        });
+        res
     }
 
     /// Get the reference to the underlying value, without checking if the cell
@@ -102,6 +111,18 @@ impl<T> OnceCell<T> {
     }
 }
 
+// Note: this is intentionally monomorphic
+#[inline(never)]
+fn initialize_inner(mutex: &Mutex<()>, is_initialized: &AtomicBool, init: &mut dyn FnMut() -> bool) {
+    let _guard = mutex.lock();
+
+    if !is_initialized.load(Ordering::Acquire) {
+        if init() {
+            is_initialized.store(true, Ordering::Release);
+        }
+    }
+}
+
 #[test]
 fn test_size() {
     use std::mem::size_of;

src/imp_std.rs

@@ -89,7 +89,7 @@ impl<T> OnceCell<T> {
         let mut res: Result<(), E> = Ok(());
         let slot: *mut Option<T> = self.value.get();
         initialize_inner(&self.state_and_queue, &mut || {
-            let f = f.take().unwrap();
+            let f = f.take().unwrap_or_else(|| unsafe { unreachable_unchecked() });
             match f() {
                 Ok(value) => {
                     unsafe { *slot = Some(value) };
@@ -144,6 +144,7 @@ impl<T> OnceCell<T> {
 
 // Corresponds to `std::sync::Once::call_inner`
 // Note: this is intentionally monomorphic
+#[inline(never)]
 fn initialize_inner(my_state_and_queue: &AtomicUsize, init: &mut dyn FnMut() -> bool) -> bool {
     let mut state_and_queue = my_state_and_queue.load(Ordering::Acquire);