std: replace LazyBox with OnceBox

This PR replaces the `LazyBox` wrapper used to allocate the pthread primitives with `OnceBox`, which has a more familiar API mirroring that of `OnceLock`. This cleans up the code in preparation for larger changes like #128184 (from which this PR was split) and allows some neat optimizations, like avoid an acquire-load of the allocation pointer in `Mutex::unlock`, where the initialization of the allocation must have already been observed.
Additionally, I've gotten rid of the TEEOS `Condvar` code, it's just a duplicate of the pthread one anyway and I didn't want to repeat myself.

Author: joboet

library/std/src/sys/sync/condvar/mod.rs

@@ -12,7 +12,10 @@ cfg_if::cfg_if! {
 ))]{
 mod futex;
 pubuse futex::Condvar;
-} else if #[cfg(target_family = "unix")]{
+} else if #[cfg(any(
+ target_family = "unix",
+ target_os = "teeos",
+))]{
 mod pthread;
 pubuse pthread::Condvar;
 } else if #[cfg(all(target_os = "windows", target_vendor = "win7"))]{
@@ -24,9 +27,6 @@ cfg_if::cfg_if! {
 } else if #[cfg(target_os = "solid_asp3")]{
 mod itron;
 pubuse itron::Condvar;
-} else if #[cfg(target_os = "teeos")]{
-mod teeos;
-pubuse teeos::Condvar;
 } else if #[cfg(target_os = "xous")]{
 mod xous;
 pubuse xous::Condvar;

library/std/src/sys/sync/condvar/pthread.rs

@@ -2,31 +2,25 @@ use crate::cell::UnsafeCell;
 usecrate::ptr;
 usecrate::sync::atomic::AtomicPtr;
 usecrate::sync::atomic::Ordering::Relaxed;
-usecrate::sys::sync::{Mutex,mutex};
+usecrate::sys::sync::{Mutex,OnceBox};
 #[cfg(not(target_os = "nto"))]
 usecrate::sys::time::TIMESPEC_MAX;
 #[cfg(target_os = "nto")]
 usecrate::sys::time::TIMESPEC_MAX_CAPPED;
-usecrate::sys_common::lazy_box::{LazyBox,LazyInit};
 usecrate::time::Duration;
 
 structAllocatedCondvar(UnsafeCell<libc::pthread_cond_t>);
 
 pubstructCondvar{
-inner:LazyBox<AllocatedCondvar>,
+inner:OnceBox<AllocatedCondvar>,
 mutex:AtomicPtr<libc::pthread_mutex_t>,
 }
 
-#[inline]
-fnraw(c:&Condvar) -> *mut libc::pthread_cond_t{
- c.inner.0.get()
-}
-
 unsafeimplSendforAllocatedCondvar{}
 unsafeimplSyncforAllocatedCondvar{}
 
-implLazyInitforAllocatedCondvar{
-fninit() -> Box<Self>{
+implAllocatedCondvar{
+fnnew() -> Box<Self>{
 let condvar = Box::new(AllocatedCondvar(UnsafeCell::new(libc::PTHREAD_COND_INITIALIZER)));
 
  cfg_if::cfg_if! {
@@ -37,7 +31,7 @@ impl LazyInit for AllocatedCondvar {
  target_vendor = "apple",
 ))]{
 // `pthread_condattr_setclock` is unfortunately not supported on these platforms.
-} else if #[cfg(any(target_os = "espidf", target_os = "horizon"))]{
+} else if #[cfg(any(target_os = "espidf", target_os = "horizon", target_os = "teeos"))]{
 // NOTE: ESP-IDF's PTHREAD_COND_INITIALIZER support is not released yet
 // So on that platform, init() should always be called
 // Moreover, that platform does not have pthread_condattr_setclock support,
@@ -82,7 +76,11 @@ impl Drop for AllocatedCondvar {
 
 implCondvar{
 pubconstfnnew() -> Condvar{
-Condvar{inner:LazyBox::new(),mutex:AtomicPtr::new(ptr::null_mut())}
+Condvar{inner:OnceBox::new(),mutex:AtomicPtr::new(ptr::null_mut())}
+}
+
+fnget(&self) -> *mut libc::pthread_cond_t{
+self.inner.get_or_init(AllocatedCondvar::new).0.get()
 }
 
 #[inline]
@@ -98,21 +96,21 @@ impl Condvar {
 
 #[inline]
 pubfnnotify_one(&self){
-let r = unsafe{ libc::pthread_cond_signal(raw(self))};
+let r = unsafe{ libc::pthread_cond_signal(self.get())};
 debug_assert_eq!(r,0);
 }
 
 #[inline]
 pubfnnotify_all(&self){
-let r = unsafe{ libc::pthread_cond_broadcast(raw(self))};
+let r = unsafe{ libc::pthread_cond_broadcast(self.get())};
 debug_assert_eq!(r,0);
 }
 
 #[inline]
 pubunsafefnwait(&self,mutex:&Mutex){
-let mutex = mutex::raw(mutex);
+let mutex = mutex.get_assert_locked();
 self.verify(mutex);
-let r = libc::pthread_cond_wait(raw(self), mutex);
+let r = libc::pthread_cond_wait(self.get(), mutex);
 debug_assert_eq!(r,0);
 }
 
@@ -129,7 +127,7 @@ impl Condvar {
 pubunsafefnwait_timeout(&self,mutex:&Mutex,dur:Duration) -> bool{
 usecrate::sys::time::Timespec;
 
-let mutex = mutex::raw(mutex);
+let mutex = mutex.get_assert_locked();
 self.verify(mutex);
 
 #[cfg(not(target_os = "nto"))]
@@ -144,7 +142,7 @@ impl Condvar {
 .and_then(|t| t.to_timespec_capped())
 .unwrap_or(TIMESPEC_MAX_CAPPED);
 
-let r = libc::pthread_cond_timedwait(raw(self), mutex,&timeout);
+let r = libc::pthread_cond_timedwait(self.get(), mutex,&timeout);
 assert!(r == libc::ETIMEDOUT || r == 0);
  r == 0
 }
@@ -162,7 +160,7 @@ impl Condvar {
 usecrate::sys::time::SystemTime;
 usecrate::time::Instant;
 
-let mutex = mutex::raw(mutex);
+let mutex = mutex.get_assert_locked();
 self.verify(mutex);
 
 // OSX implementation of `pthread_cond_timedwait` is buggy
@@ -188,7 +186,7 @@ impl Condvar {
 .and_then(|t| t.to_timespec())
 .unwrap_or(TIMESPEC_MAX);
 
-let r = libc::pthread_cond_timedwait(raw(self), mutex,&timeout);
+let r = libc::pthread_cond_timedwait(self.get(), mutex,&timeout);
 debug_assert!(r == libc::ETIMEDOUT || r == 0);
 
 // ETIMEDOUT is not a totally reliable method of determining timeout due

library/std/src/sys/sync/condvar/sgx.rs

@@ -1,44 +1,39 @@
 usecrate::sys::pal::waitqueue::{SpinMutex,WaitQueue,WaitVariable};
-usecrate::sys::sync::Mutex;
-usecrate::sys_common::lazy_box::{LazyBox,LazyInit};
+usecrate::sys::sync::{Mutex,OnceBox};
 usecrate::time::Duration;
 
-/// FIXME: `UnsafeList` is not movable.
-structAllocatedCondvar(SpinMutex<WaitVariable<()>>);
-
 pubstructCondvar{
-inner:LazyBox<AllocatedCondvar>,
-}
-
-implLazyInitforAllocatedCondvar{
-fninit() -> Box<Self>{
-Box::new(AllocatedCondvar(SpinMutex::new(WaitVariable::new(()))))
-}
+// FIXME: `UnsafeList` is not movable.
+inner:OnceBox<SpinMutex<WaitVariable<()>>>,
 }
 
 implCondvar{
 pubconstfnnew() -> Condvar{
-Condvar{inner:LazyBox::new()}
+Condvar{inner:OnceBox::new()}
+}
+
+fnget(&self) -> &SpinMutex<WaitVariable<()>>{
+self.inner.get_or_init(|| Box::new(SpinMutex::new(WaitVariable::new(()))))
 }
 
 #[inline]
 pubfnnotify_one(&self){
-let _ = WaitQueue::notify_one(self.inner.0.lock());
+let _ = WaitQueue::notify_one(self.get().lock());
 }
 
 #[inline]
 pubfnnotify_all(&self){
-let _ = WaitQueue::notify_all(self.inner.0.lock());
+let _ = WaitQueue::notify_all(self.get().lock());
 }
 
 pubunsafefnwait(&self,mutex:&Mutex){
-let guard = self.inner.0.lock();
+let guard = self.get().lock();
 WaitQueue::wait(guard, || unsafe{ mutex.unlock()});
  mutex.lock()
 }
 
 pubunsafefnwait_timeout(&self,mutex:&Mutex,dur:Duration) -> bool{
-let success = WaitQueue::wait_timeout(&self.inner.0, dur, || unsafe{ mutex.unlock()});
+let success = WaitQueue::wait_timeout(self.get(), dur, || unsafe{ mutex.unlock()});
  mutex.lock();
  success
 }

library/std/src/sys/sync/condvar/teeos.rs

@@ -1,11 +1,14 @@
 mod condvar;
 mod mutex;
 mod once;
+mod once_box;
 mod rwlock;
 mod thread_parking;
 
 pubuse condvar::Condvar;
 pubuse mutex::Mutex;
 pubuse once::{Once,OnceState};
+#[allow(unused)]// Only used on some platforms.
+use once_box::OnceBox;
 pubuse rwlock::RwLock;
 pubuse thread_parking::Parker;

library/std/src/sys/sync/mod.rs

@@ -19,7 +19,7 @@ cfg_if::cfg_if! {
  target_os = "teeos",
 ))]{
 mod pthread;
-pubuse pthread::{Mutex, raw};
+pubuse pthread::Mutex;
 } else if #[cfg(all(target_os = "windows", target_vendor = "win7"))]{
 mod windows7;
 pubuse windows7::{Mutex, raw};