fix(port_std): replace std::lazy::SyncOnceCell with std::sync::OnceLock

Author: yvt

src/r3_port_std/src/lib.rs

@@ -22,8 +22,7 @@ use r3_kernel::{KernelTraits, Port, PortToKernel, System, TaskCb, UTicks};
 use spin::Mutex as SpinMutex;
 use std::{
     cell::Cell,
-    lazy::SyncOnceCell,
-    sync::mpsc,
+    sync::{mpsc, OnceLock},
     time::{Duration, Instant},
 };
 
@@ -97,7 +96,7 @@ pub unsafe trait PortInstance:
 /// the corresponding trait methods of `Port*`.
 #[doc(hidden)]
 pub struct State {
-    thread_group: SyncOnceCell<ums::ThreadGroup<sched::SchedState>>,
+    thread_group: OnceLock<ums::ThreadGroup<sched::SchedState>>,
     timer_cmd_send: SpinMutex<Option<mpsc::Sender<TimerCmd>>>,
     origin: AtomicRef<'static, Instant>,
 }
@@ -206,7 +205,7 @@ impl TaskState {
 impl State {
     pub const fn new() -> Self {
         Self {
-            thread_group: SyncOnceCell::new(),
+            thread_group: OnceLock::new(),
             timer_cmd_send: SpinMutex::new(None),
             origin: AtomicRef::new(None),
         }

src/r3_port_std/src/ums.rs

@@ -1,8 +1,8 @@
 //! Utterly inefficient cross-platform preemptive user-mode scheduling
 use slab::Slab;
 use std::{
-    lazy::SyncOnceCell,
     panic::{catch_unwind, AssertUnwindSafe},
+    sync::OnceLock,
     sync::{mpsc, Arc},
     thread::Result,
 };
@@ -75,7 +75,7 @@ struct WorkerThread {
 }
 
 thread_local! {
-    static TLB: SyncOnceCell<ThreadLocalBlock> = SyncOnceCell::new();
+    static TLB: OnceLock<ThreadLocalBlock> = OnceLock::new();
 }
 
 struct ThreadLocalBlock {

src/r3_port_std/src/ums/tests.rs

@@ -1,7 +1,7 @@
 use super::*;
 use std::{
-    lazy::SyncOnceCell,
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+    sync::OnceLock,
     thread::sleep,
     time::{Duration, Instant},
 };
@@ -21,7 +21,7 @@ fn preempt() {
         counters: [AtomicUsize; 3],
         done: AtomicBool,
         cur_thread: AtomicUsize,
-        threads: SyncOnceCell<[ThreadId; 3]>,
+        threads: OnceLock<[ThreadId; 3]>,
     }
     let st: &_ = Box::leak(Box::new(St {
         counters: [
@@ -31,7 +31,7 @@ fn preempt() {
         ],
         done: AtomicBool::new(false),
         cur_thread: AtomicUsize::new(0),
-        threads: SyncOnceCell::new(),
+        threads: OnceLock::new(),
     }));
 
     impl Scheduler for &'static St {
@@ -144,13 +144,13 @@ fn yield_ring(count: usize) {
         counters: Vec<AtomicUsize>,
         done: AtomicBool,
         cur_thread: AtomicUsize,
-        threads: SyncOnceCell<Vec<ThreadId>>,
+        threads: OnceLock<Vec<ThreadId>>,
     }
     let st: &_ = Box::leak(Box::new(St {
         counters: (0..count).map(|_| AtomicUsize::new(0)).collect(),
         done: AtomicBool::new(false),
         cur_thread: AtomicUsize::new(0),
-        threads: SyncOnceCell::new(),
+        threads: OnceLock::new(),
     }));
 
     const COUNTER_THREAD_ENDED: usize = usize::MAX;
@@ -244,11 +244,11 @@ fn preempt_rapid() {
 
     struct St {
         done: AtomicBool,
-        threads: SyncOnceCell<ThreadId>,
+        threads: OnceLock<ThreadId>,
     }
     let st: &_ = Box::leak(Box::new(St {
         done: AtomicBool::new(false),
-        threads: SyncOnceCell::new(),
+        threads: OnceLock::new(),
     }));
 
     impl Scheduler for &'static St {
@@ -292,10 +292,10 @@ fn forward_panic() {
     init_logger();
 
     struct St {
-        threads: SyncOnceCell<ThreadId>,
+        threads: OnceLock<ThreadId>,
     }
     let st: &_ = Box::leak(Box::new(St {
-        threads: SyncOnceCell::new(),
+        threads: OnceLock::new(),
     }));
 
     impl Scheduler for &'static St {