refactor(port_std): use #![feature(once_cell)]

`std::lazy::SyncOnceCell` was unstably added by [rust-lang/rust#72414]
[1] and is being tracked by [rust-lang/rust#74465][2]. This replaces
`once_cell::sync::OnceCell`.

[1]: rust-lang/rust#72414
[2]: rust-lang/rust#74465

Author: yvt

Cargo.lock

@@ -17,7 +17,6 @@ r3_core = { version = "0.1.0", path = "../r3_core" }
 
 atomic_ref = { version = "0.2.0" }
 env_logger = { version = "0.8.4" }
-once_cell = { version = "1.4.0" }
 spin = { version = "0.9.2", default-features = false, features = ["spin_mutex"] }
 slab = { version = "0.4.5" }
 log = { version = "0.4.8" }

src/r3_port_std/Cargo.toml

@@ -2,14 +2,14 @@
 #![feature(atomic_mut_ptr)]
 #![feature(thread_local)]
 #![feature(deadline_api)]
+#![feature(once_cell)]
 #![cfg_attr(
     feature = "doc",
     doc(html_logo_url = "https://r3-os.github.io/r3/logo-small.svg")
 )]
 #![doc = include_str!("./lib.md")]
 #![deny(unsafe_op_in_unsafe_fn)]
 use atomic_ref::AtomicRef;
-use once_cell::sync::OnceCell;
 use r3_core::{
     kernel::{
         ClearInterruptLineError, EnableInterruptLineError, InterruptNum, InterruptPriority,
@@ -22,6 +22,7 @@ use r3_kernel::{KernelTraits, Port, PortToKernel, System, TaskCb, UTicks};
 use spin::Mutex as SpinMutex;
 use std::{
     cell::Cell,
+    lazy::SyncOnceCell,
     sync::mpsc,
     time::{Duration, Instant},
 };
@@ -96,7 +97,7 @@ pub unsafe trait PortInstance:
 /// the corresponding trait methods of `Port*`.
 #[doc(hidden)]
 pub struct State {
-    thread_group: OnceCell<ums::ThreadGroup<sched::SchedState>>,
+    thread_group: SyncOnceCell<ums::ThreadGroup<sched::SchedState>>,
     timer_cmd_send: SpinMutex<Option<mpsc::Sender<TimerCmd>>>,
     origin: AtomicRef<'static, Instant>,
 }
@@ -205,7 +206,7 @@ impl TaskState {
 impl State {
     pub const fn new() -> Self {
         Self {
-            thread_group: OnceCell::new(),
+            thread_group: SyncOnceCell::new(),
             timer_cmd_send: SpinMutex::new(None),
             origin: AtomicRef::new(None),
         }

src/r3_port_std/src/lib.rs

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

src/r3_port_std/src/ums.rs

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