Merge remote-tracking branch 'upstream/main'

Author: Lslightly

.github/workflows/rustdoc.yaml

@@ -23,7 +23,7 @@ jobs:
       run: if ! command -v rustup &>/dev/null; then (curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y); fi
 
     - name: Install Rust toolchain
-      run: source "$HOME/.cargo/env"; rustup update --no-self-update stable
+      run: source "$HOME/.cargo/env"; rustup update --no-self-update nightly
 
     - name: Build Documentation
       run: source "$HOME/.cargo/env"; cd homework; cargo doc --all --document-private-items

Cargo.toml

@@ -2,10 +2,10 @@
 name = "cs431"
 version = "0.1.0"
 authors = ["Jeehoon Kang <jeehoon.kang@kaist.ac.kr>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 crossbeam-epoch = "0.9.18"
-crossbeam-utils = "0.8.19"
+crossbeam-utils = "0.8.21"

homework/Cargo.toml

@@ -22,5 +22,5 @@ ctrlc = { version = "3.4.4", optional = true }
 cs431 = { git = "https://github.com/kaist-cp/cs431" }
 # cs431 = { path = "../cs431" }
 loom = { version = "0.7.2", optional = true }
-rand = "0.8.5"
+rand = "0.9.0"
 regex = "1.10.4"

homework/src/elim_stack/base.rs

@@ -4,14 +4,14 @@ use core::ops::Deref;
 use std::time;
 
 use crossbeam_epoch::{Atomic, Guard, Owned, pin};
-use rand::{Rng, thread_rng};
+use rand::{self, Rng};
 
 pub(crate) const ELIM_SIZE: usize = 16;
 pub(crate) const ELIM_DELAY: time::Duration = time::Duration::from_millis(10);
 
 #[inline]
 pub(crate) fn get_random_elim_index() -> usize {
-    thread_rng().r#gen::<usize>() % ELIM_SIZE
+    (rand::rng().random::<u64>() as usize) % ELIM_SIZE
 }
 
 /// Concurrent stack types.

homework/src/hash_table/growable_array.rs

@@ -135,25 +135,25 @@ const SEGMENT_LOGSIZE: usize = 10;
 
 /// A fixed size array of atomic pointers to other `Segment<T>` or `T`.
 ///
-/// Each segment is either a child segment with pointers to `Segment<T>` or an element segment with
-/// pointers to `T`. This is determined by the height of this segment in the main array, which one
-/// needs to track separately. For example, use the main array root's tag.
+/// Each segment is either an inner segment with pointers to other, children `Segment<T>` or an
+/// element segment with pointers to `T`. This is determined by the height of this segment in the
+/// main array, which one needs to track separately. For example, use the main array root's tag.
 ///
-/// Since destructing segments requires its height information, it is not recommended to
-/// implement [`Drop`]. Rather, implement and use the custom [`Segment::deallocate`] method that
-/// accounts for the height of the segment.
+/// Since destructing segments requires its height information, it is not recommended to implement
+/// [`Drop`]. Rather, implement and use the custom [`Segment::deallocate`] method that accounts for
+/// the height of the segment.
 union Segment<T> {
     children: ManuallyDrop<[Atomic<Segment<T>>; 1 << SEGMENT_LOGSIZE]>,
     elements: ManuallyDrop<[Atomic<T>; 1 << SEGMENT_LOGSIZE]>,
 }
 
 impl<T> Segment<T> {
     /// Create a new segment filled with null pointers. It is up to the callee to whether to use
-    /// this as a children or an element segment.
+    /// this as an intermediate or an element segment.
     fn new() -> Owned<Self> {
         Owned::new(
-            // SAFETY: An array of null pointers can be interperted as either an element segment or
-            // a children segment.
+            // SAFETY: An array of null pointers can be interperted as either an intermediate
+            // segment or an element segment.
             unsafe { mem::zeroed() },
         )
     }
@@ -162,7 +162,8 @@ impl<T> Segment<T> {
     ///
     /// # Safety
     ///
-    /// `self` must actually have height `height`.
+    /// - `self` must actually have height `height`.
+    /// - There should be no other references to possible children segments.
     unsafe fn deallocate(self, height: usize) {
         todo!()
     }
@@ -197,7 +198,7 @@ impl<T> GrowableArray<T> {
 
     /// Returns the reference to the `Atomic` pointer at `index`. Allocates new segments if
     /// necessary.
-    pub fn get<'g>(&self, mut index: usize, guard: &'g Guard) -> &'g Atomic<T> {
+    pub fn get<'g>(&self, index: usize, guard: &'g Guard) -> &'g Atomic<T> {
         todo!()
     }
 }

homework/src/list_set/optimistic_fine_grained.rs

@@ -20,7 +20,7 @@ pub struct OptimisticFineGrainedListSet<T> {
 }
 
 unsafe impl<T: Send> Send for OptimisticFineGrainedListSet<T> {}
-unsafe impl<T: Send> Sync for OptimisticFineGrainedListSet<T> {}
+unsafe impl<T: Sync> Sync for OptimisticFineGrainedListSet<T> {}
 
 #[derive(Debug)]
 struct Cursor<'g, T> {

homework/src/test/adt/map.rs

@@ -36,7 +36,7 @@ pub fn stress_sequential<
         Ops::DeleteNone,
     ];
 
-    let mut rng = thread_rng();
+    let mut rng = rand::rng();
     let map = M::default();
     let mut hashmap = HashMap::new();
 
@@ -118,7 +118,7 @@ pub fn lookup_concurrent<
     }
     const OPS: [Ops; 2] = [Ops::LookupSome, Ops::LookupNone];
 
-    let mut rng = thread_rng();
+    let mut rng = rand::rng();
     let map = M::default();
     let mut hashmap = HashMap::new();
 
@@ -133,7 +133,7 @@ pub fn lookup_concurrent<
         let mut handles = Vec::new();
         for _ in 0..threads {
             let handle = s.spawn(|| {
-                let mut rng = thread_rng();
+                let mut rng = rand::rng();
                 for _ in 0..steps {
                     let op = OPS.choose(&mut rng).unwrap();
 
@@ -164,7 +164,7 @@ pub fn insert_concurrent<
         let mut handles = Vec::new();
         for _ in 0..threads {
             let handle = s.spawn(|| {
-                let mut rng = thread_rng();
+                let mut rng = rand::rng();
                 for _ in 0..steps {
                     let key = K::rand_gen(&mut rng);
                     let value = V::rand_gen(&mut rng);
@@ -218,7 +218,7 @@ pub fn stress_concurrent<
         let mut handles = Vec::new();
         for _ in 0..threads {
             let handle = s.spawn(|| {
-                let mut rng = thread_rng();
+                let mut rng = rand::rng();
                 for _ in 0..steps {
                     let op = OPS.choose(&mut rng).unwrap();
                     let key = K::rand_gen(&mut rng);
@@ -303,7 +303,7 @@ pub fn log_concurrent<
 
         for _ in 0..threads {
             let handle = s.spawn(|| {
-                let mut rng = thread_rng();
+                let mut rng = rand::rng();
                 let mut logs = Vec::new();
 
                 for _ in 0..steps {

homework/src/test/rand.rs

@@ -1,7 +1,7 @@
 //! Utilities for random value generator
 
 use rand::Rng;
-use rand::distributions::Alphanumeric;
+use rand::distr::Alphanumeric;
 use rand::rngs::ThreadRng;
 
 /// Types that has random generator
@@ -14,7 +14,7 @@ const KEY_MAX_LENGTH: usize = 4;
 
 impl RandGen for String {
     fn rand_gen(rng: &mut ThreadRng) -> Self {
-        let length = rng.r#gen::<usize>() % KEY_MAX_LENGTH;
+        let length = (rng.random::<u64>() as usize) % KEY_MAX_LENGTH;
         rng.sample_iter(&Alphanumeric)
             .take(length)
             .map(|x| x as char)
@@ -26,21 +26,21 @@ impl RandGen for usize {
     /// pick only 16 bits, MSB=0
     fn rand_gen(rng: &mut ThreadRng) -> Self {
         const MASK: usize = 0x4004004004007777usize;
-        rng.r#gen::<usize>() & MASK
+        (rng.random::<u64>() as usize) & MASK
     }
 }
 
 impl RandGen for u32 {
     /// pick only 16 bits
     fn rand_gen(rng: &mut ThreadRng) -> Self {
         const MASK: u32 = 0x66666666u32;
-        rng.r#gen::<u32>() & MASK
+        rng.random::<u32>() & MASK
     }
 }
 
 impl RandGen for u8 {
     fn rand_gen(rng: &mut ThreadRng) -> Self {
-        rng.r#gen::<u8>()
+        rng.random::<u8>()
     }
 }
 

homework/tests/list_set/fine_grained.rs

@@ -57,22 +57,24 @@ fn iter_consistent() {
 
     let done = AtomicBool::new(false);
     thread::scope(|s| {
+        // Ensure handles lives to the end.
+        let mut handles = Vec::with_capacity(THREADS + 1);
         // insert or remove odd numbers
         for _ in 0..THREADS {
-            let _ = s.spawn(|| {
-                let mut rng = thread_rng();
+            handles.push(s.spawn(|| {
+                let mut rng = rand::rng();
                 for _ in 0..STEPS {
-                    let key = 2 * rng.gen_range(0..50) + 1;
-                    if rng.r#gen() {
+                    let key = 2 * rng.random_range(0..50) + 1;
+                    if rng.random() {
                         set.insert(key);
                     } else {
                         set.remove(&key);
                     }
                 }
                 done.store(true, Release);
-            });
+            }));
         }
-        let _ = s.spawn(|| {
+        handles.push(s.spawn(|| {
             while !done.load(Acquire) {
                 let snapshot = set.iter().copied().collect::<Vec<_>>();
                 // sorted
@@ -81,6 +83,6 @@ fn iter_consistent() {
                 let snapshot = snapshot.into_iter().collect::<HashSet<_>>();
                 assert!(evens.is_subset(&snapshot));
             }
-        });
+        }));
     });
 }

homework/tests/list_set/optimistic_fine_grained.rs

@@ -120,23 +120,26 @@ fn iter_consistent() {
 
     let done = AtomicBool::new(false);
     thread::scope(|s| {
+        // Ensure handles lives to the end.
+        let mut handles = Vec::with_capacity(THREADS + 1);
         // Inserts or removes odd numbers.
         for _ in 0..THREADS {
-            let _ = s.spawn(|| {
-                let mut rng = thread_rng();
+            handles.push(s.spawn(|| {
+                let mut rng = rand::rng();
                 for _ in 0..STEPS {
-                    let key = 2 * rng.gen_range(0..50) + 1;
-                    if rng.r#gen() {
+                    let key = 2 * rng.random_range(0..50) + 1;
+                    if rng.random() {
                         let _ = set.insert(key);
                     } else {
                         let _ = set.remove(&key);
                     }
                 }
+                // TODO: Ideally, should be per-thread variable?
                 done.store(true, Release);
-            });
+            }));
         }
         // Checks iterator consistency.
-        let _ = s.spawn(|| {
+        handles.push(s.spawn(|| {
             while !done.load(Acquire) {
                 let mut snapshot = Vec::new();
                 for r in set.iter(&pin()) {
@@ -157,6 +160,6 @@ fn iter_consistent() {
                 let snapshot = snapshot.into_iter().collect::<HashSet<_>>();
                 assert!(evens.is_subset(&snapshot));
             }
-        });
+        }));
     });
 }