refactor(port_std): replace the bespoke iterpool with slab

It's hard to find something like `slab` because such a data structure
doesn't have a well-known common name.

Author: yvt

Cargo.lock

@@ -15,6 +15,7 @@ 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" }
 
 [dev-dependencies.r3_test_suite]

src/r3_port_std/Cargo.toml

@@ -1,15 +1,15 @@
 //! Utterly inefficient cross-platform preemptive user-mode scheduling
 use once_cell::sync::OnceCell;
+use slab::Slab;
 use std::{
     panic::{catch_unwind, AssertUnwindSafe},
     sync::{mpsc, Arc, Mutex, MutexGuard},
     thread::Result,
 };
 
-use crate::{
-    threading,
-    utils::iterpool::{Pool, PoolPtr},
-};
+use crate::threading;
+
+type SlabPtr = usize;
 
 #[cfg(test)]
 mod tests;
@@ -43,7 +43,7 @@ pub struct ThreadGroupLockGuard<'a, Sched: ?Sized> {
 
 /// Identifies a thread in [`ThreadGroup`].
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-pub struct ThreadId(PoolPtr);
+pub struct ThreadId(SlabPtr);
 
 /// Encapsulates the state of a client-supplied user-mode scheduler.
 pub trait Scheduler: Send + 'static {
@@ -61,7 +61,7 @@ pub trait Scheduler: Send + 'static {
 
 #[derive(Debug)]
 struct State<Sched: ?Sized> {
-    threads: Pool<WorkerThread>,
+    threads: Slab<WorkerThread>,
     num_threads: usize,
     cur_thread_id: Option<ThreadId>,
     shutting_down: bool,
@@ -92,7 +92,7 @@ impl<Sched: Scheduler> ThreadGroup<Sched> {
         let (send, recv) = mpsc::channel();
 
         let state = Arc::new(Mutex::new(State {
-            threads: Pool::new(),
+            threads: Slab::new(),
             num_threads: 0,
             cur_thread_id: None,
             shutting_down: false,
@@ -144,10 +144,10 @@ impl<'a, Sched: Scheduler> ThreadGroupLockGuard<'a, Sched> {
         let state = Arc::clone(self.state_ref);
 
         // Allocate a `ThreadId`
-        let ptr = self
+        let ptr: SlabPtr = self
             .guard
             .threads
-            .allocate(WorkerThread { join_handle: None });
+            .insert(WorkerThread { join_handle: None });
         let thread_id = ThreadId(ptr);
         self.guard.num_threads += 1;
 
@@ -312,7 +312,7 @@ fn finalize_thread(
     // Delete the current thread
     let mut state_guard = thread_group.lock().unwrap();
     state_guard.sched.thread_exited(thread_id);
-    state_guard.threads.deallocate(thread_id.0).unwrap();
+    state_guard.threads.remove(thread_id.0);
     state_guard.num_threads -= 1;
 
     if let Err(e) = result {

src/r3_port_std/src/ums.rs

@@ -1,7 +1,5 @@
 use std::sync::atomic;
 
-pub mod iterpool;
-
 pub trait HasAtomicEquivalent {
     type AtomicEquivalent;
 }