switch to PCT shuttle scheduler

Author: ibraheemdev

.github/workflows/test.yml

@@ -52,15 +52,13 @@ jobs:
       - name: Format
         run: cargo fmt -- --check
       - name: Clippy
-        run: cargo clippy --workspace --all-features --all-targets -- -D warnings
+        run: cargo clippy --workspace --all-targets -- -D warnings
       - name: Test
-        run: cargo nextest run --workspace --all-features --all-targets --no-fail-fast
+        run: cargo nextest run --workspace --all-targets --no-fail-fast
       - name: Test docs
-        run: cargo test --workspace --all-features --doc
+        run: cargo test --workspace --doc
       - name: Check (without default features)
         run: cargo check --workspace --no-default-features
-      - name: Check (loom)
-        run: RUSTFLAGS="--cfg loom" cargo check --workspace --features loom
 
   miri:
     name: Miri
@@ -88,12 +86,34 @@ jobs:
       - name: Setup Miri
         run: cargo miri setup
       - name: Test with Miri
-        run: cargo miri nextest run --all-features --no-fail-fast --tests
+        run: cargo miri nextest run --no-fail-fast --tests
         env:
           MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-retag-fields
       - name: Run examples with Miri
         run: cargo miri run --example calc
 
+  shuttle:
+    name: Shuttle
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        id: rust-toolchain
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ steps.rust-toolchain.outputs.cachekey }}-${{ hashFiles('**/Cargo.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-${{ steps.rust-toolchain.outputs.cachekey }}-
+            ${{ runner.os }}-cargo-
+      - name: Test with Shuttle
+        run: cargo test --features shuttle --test parallel
+
   benchmarks:
     # https://github.com/CodSpeedHQ/action/issues/126
     if: github.event_name != 'merge_group'

Cargo.toml

@@ -15,6 +15,8 @@ salsa-macros = { version = "0.21.1", path = "components/salsa-macros", optional
 boxcar = { version = "0.2.12" }
 crossbeam-queue = "0.3.11"
 dashmap = { version = "6", features = ["raw-api"] }
+# the version of hashbrown used by dashmap
+hashbrown_14 = { version = "0.14", package = "hashbrown" }
 hashbrown = "0.15"
 hashlink = "0.10"
 indexmap = "2"
@@ -30,13 +32,14 @@ rayon = { version = "1.10.0", optional = true }
 # Stuff we want Update impls for by default
 compact_str = { version = "0.9", optional = true }
 thin-vec = "0.2.13"
-loom = { version = "0.7.2", optional = true }
+
+shuttle = { version = "0.8.0", optional = true }
 
 [features]
 default = ["salsa_unstable", "rayon", "macros"]
+shuttle = ["dep:shuttle"]
 # FIXME: remove `salsa_unstable` before 1.0.
 salsa_unstable = []
-loom = ["dep:loom", "boxcar/loom"]
 macros = ["dep:salsa-macros"]
 
 # This interlocks the `salsa-macros` and `salsa` versions together
@@ -67,9 +70,6 @@ half = "=2.4.1"
 [target.'cfg(all(not(target_os = "windows"), not(target_os = "openbsd"), any(target_arch = "x86_64", target_arch = "aarch64", target_arch = "powerpc64")))'.dev-dependencies]
 tikv-jemallocator = "0.6.0"
 
-[lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
-
 [[bench]]
 name = "compare"
 harness = false

components/salsa-macro-rules/src/setup_accumulator_impl.rs

@@ -21,13 +21,9 @@ macro_rules! setup_accumulator_impl {
             use salsa::plumbing as $zalsa;
             use salsa::plumbing::accumulator as $zalsa_struct;
 
-            // Suppress the lint against `cfg(loom)`.
-            #[allow(unexpected_cfgs)]
             fn $ingredient(zalsa: &$zalsa::Zalsa) -> &$zalsa_struct::IngredientImpl<$Struct> {
-                $zalsa::__maybe_lazy_static! {
-                    static $CACHE: $zalsa::IngredientCache<$zalsa_struct::IngredientImpl<$Struct>> =
-                        $zalsa::IngredientCache::new();
-                }
+                static $CACHE: $zalsa::IngredientCache<$zalsa_struct::IngredientImpl<$Struct>> =
+                    $zalsa::IngredientCache::new();
 
                 $CACHE.get_or_create(zalsa, || {
                     zalsa.add_or_lookup_jar_by_type::<$zalsa_struct::JarImpl<$Struct>>()

components/salsa-macro-rules/src/setup_input_struct.rs

@@ -95,13 +95,9 @@ macro_rules! setup_input_struct {
                     Self::ingredient_(db.zalsa())
                 }
 
-                // Suppress the lint against `cfg(loom)`.
-                #[allow(unexpected_cfgs)]
                 fn ingredient_(zalsa: &$zalsa::Zalsa) -> &$zalsa_struct::IngredientImpl<Self> {
-                    zalsa_::__maybe_lazy_static! {
-                        static CACHE: $zalsa::IngredientCache<$zalsa_struct::IngredientImpl<$Configuration>> =
-                            $zalsa::IngredientCache::new();
-                    }
+                    static CACHE: $zalsa::IngredientCache<$zalsa_struct::IngredientImpl<$Configuration>> =
+                        $zalsa::IngredientCache::new();
 
                     CACHE.get_or_create(zalsa, || {
                         zalsa.add_or_lookup_jar_by_type::<$zalsa_struct::JarImpl<$Configuration>>()

components/salsa-macro-rules/src/setup_interned_struct.rs

@@ -131,16 +131,12 @@ macro_rules! setup_interned_struct {
             }
 
             impl $Configuration {
-                // Suppress the lint against `cfg(loom)`.
-                #[allow(unexpected_cfgs)]
                 pub fn ingredient<Db>(db: &Db) -> &$zalsa_struct::IngredientImpl<Self>
                 where
                     Db: ?Sized + $zalsa::Database,
                 {
-                    $zalsa::__maybe_lazy_static! {
-                        static CACHE: $zalsa::IngredientCache<$zalsa_struct::IngredientImpl<$Configuration>> =
-                            $zalsa::IngredientCache::new();
-                    }
+                    static CACHE: $zalsa::IngredientCache<$zalsa_struct::IngredientImpl<$Configuration>> =
+                        $zalsa::IngredientCache::new();
 
                     let zalsa = db.zalsa();
                     CACHE.get_or_create(zalsa, || {

components/salsa-macro-rules/src/setup_tracked_fn.rs

@@ -74,8 +74,6 @@ macro_rules! setup_tracked_fn {
     ) => {
         // Suppress this clippy lint because we sometimes require `'db` where the ordinary Rust rules would not.
         #[allow(clippy::needless_lifetimes)]
-        // Suppress the lint against `cfg(loom)`.
-        #[allow(unexpected_cfgs)]
         $(#[$attr])*
         $vis fn $fn_name<$db_lt>(
             $db: &$db_lt dyn $Db,
@@ -85,10 +83,8 @@ macro_rules! setup_tracked_fn {
 
             struct $Configuration;
 
-            $zalsa::__maybe_lazy_static! {
-                static $FN_CACHE: $zalsa::IngredientCache<$zalsa::function::IngredientImpl<$Configuration>> =
-                    $zalsa::IngredientCache::new();
-            }
+            static $FN_CACHE: $zalsa::IngredientCache<$zalsa::function::IngredientImpl<$Configuration>> =
+                $zalsa::IngredientCache::new();
 
             $zalsa::macro_if! {
                 if $needs_interner {
@@ -98,10 +94,8 @@ macro_rules! setup_tracked_fn {
                         std::marker::PhantomData<&$db_lt $zalsa::interned::Value<$Configuration>>,
                     );
 
-                    $zalsa::__maybe_lazy_static! {
-                        static $INTERN_CACHE: $zalsa::IngredientCache<$zalsa::interned::IngredientImpl<$Configuration>> =
-                            $zalsa::IngredientCache::new();
-                    }
+                    static $INTERN_CACHE: $zalsa::IngredientCache<$zalsa::interned::IngredientImpl<$Configuration>> =
+                        $zalsa::IngredientCache::new();
 
                     impl $zalsa::SalsaStructInDb for $InternedData<'_> {
                         type MemoIngredientMap = $zalsa::MemoIngredientSingletonIndex;

components/salsa-macro-rules/src/setup_tracked_struct.rs

@@ -173,13 +173,9 @@ macro_rules! setup_tracked_struct {
                     Self::ingredient_(db.zalsa())
                 }
 
-                // Suppress the lint against `cfg(loom)`.
-                #[allow(unexpected_cfgs)]
                 fn ingredient_(zalsa: &$zalsa::Zalsa) -> &$zalsa_struct::IngredientImpl<Self> {
-                    $zalsa::__maybe_lazy_static! {
-                        static CACHE: $zalsa::IngredientCache<$zalsa_struct::IngredientImpl<$Configuration>> =
-                            $zalsa::IngredientCache::new();
-                    }
+                    static CACHE: $zalsa::IngredientCache<$zalsa_struct::IngredientImpl<$Configuration>> =
+                        $zalsa::IngredientCache::new();
 
                     CACHE.get_or_create(zalsa, || {
                         zalsa.add_or_lookup_jar_by_type::<$zalsa_struct::JarImpl<$Configuration>>()

justfile

@@ -1,10 +1,10 @@
 test:
-    cargo test --workspace --all-features --all-targets --no-fail-fast
+    cargo test --workspace --all-targets --no-fail-fast
 
 miri:
-    cargo +nightly miri test --no-fail-fast --all-features
+    cargo +nightly miri test --no-fail-fast
 
-loom:
-    RUSTFLAGS="--cfg loom" cargo check --workspace --features loom
+shuttle:
+    cargo test --features shuttle --test parallel
 
 all: test miri

src/accumulator.rs

@@ -10,8 +10,8 @@ use accumulated::{Accumulated, AnyAccumulated};
 use crate::cycle::CycleHeads;
 use crate::function::VerifyResult;
 use crate::ingredient::{Ingredient, Jar};
-use crate::loom::sync::Arc;
 use crate::plumbing::{IngredientIndices, ZalsaLocal};
+use crate::sync::Arc;
 use crate::table::memo::MemoTableTypes;
 use crate::zalsa::{IngredientIndex, Zalsa};
 use crate::{Database, Id, Revision};

src/accumulator/accumulated_map.rs

@@ -4,7 +4,7 @@ use rustc_hash::FxHashMap;
 
 use crate::accumulator::accumulated::Accumulated;
 use crate::accumulator::{Accumulator, AnyAccumulated};
-use crate::loom::sync::atomic::{AtomicBool, Ordering};
+use crate::sync::atomic::{AtomicBool, Ordering};
 use crate::IngredientIndex;
 
 #[derive(Default)]

src/active_query.rs

@@ -8,8 +8,8 @@ use crate::cycle::CycleHeads;
 use crate::durability::Durability;
 use crate::hash::FxIndexSet;
 use crate::key::DatabaseKeyIndex;
-use crate::loom::sync::atomic::AtomicBool;
 use crate::runtime::Stamp;
+use crate::sync::atomic::AtomicBool;
 use crate::tracked_struct::{Disambiguator, DisambiguatorMap, IdentityHash, IdentityMap};
 use crate::zalsa_local::{QueryEdge, QueryEdges, QueryOrigin, QueryRevisions};
 use crate::{Accumulator, IngredientIndex, Revision};

src/attach.rs

@@ -1,17 +1,17 @@
+use std::cell::Cell;
 use std::ptr::NonNull;
 
-use crate::loom::cell::Cell;
 use crate::Database;
 
-#[cfg(loom)]
-crate::loom::thread_local! {
+#[cfg(feature = "shuttle")]
+crate::sync::thread_local! {
     /// The thread-local state salsa requires for a given thread
     static ATTACHED: Attached = Attached::new();
 }
 
-// loom's `thread_local` macro does not support const-initialization.
-#[cfg(not(loom))]
-crate::loom::thread_local! {
+// shuttle's `thread_local` macro does not support const-initialization.
+#[cfg(not(feature = "shuttle"))]
+crate::sync::thread_local! {
     /// The thread-local state salsa requires for a given thread
     static ATTACHED: Attached = const { Attached::new() }
 }
@@ -28,14 +28,6 @@ struct Attached {
 }
 
 impl Attached {
-    #[cfg(loom)]
-    fn new() -> Self {
-        Self {
-            database: Cell::new(None),
-        }
-    }
-
-    #[cfg(not(loom))]
     const fn new() -> Self {
         Self {
             database: Cell::new(None),
@@ -58,9 +50,7 @@ impl Attached {
                     Some(current_db) => {
                         let new_db = NonNull::from(db);
                         if !std::ptr::addr_eq(current_db.as_ptr(), new_db.as_ptr()) {
-                            panic!(
-                                                "Cannot change database mid-query. current: {current_db:?}, new: {new_db:?}",
-                                            );
+                            panic!("Cannot change database mid-query. current: {current_db:?}, new: {new_db:?}");
                         }
                         Self { state: None }
                     }

src/cycle.rs

@@ -55,6 +55,7 @@ use std::panic;
 use thin_vec::{thin_vec, ThinVec};
 
 use crate::key::DatabaseKeyIndex;
+use crate::sync::OnceLock;
 
 /// The maximum number of times we'll fixpoint-iterate before panicking.
 ///
@@ -258,13 +259,9 @@ impl From<CycleHead> for CycleHeads {
     }
 }
 
-#[cfg(not(loom))]
-pub(crate) static EMPTY_CYCLE_HEADS: std::sync::LazyLock<CycleHeads> =
-    std::sync::LazyLock::new(|| CycleHeads(ThinVec::new()));
-
-#[cfg(loom)]
-loom::lazy_static! {
-    pub(crate) static ref EMPTY_CYCLE_HEADS: CycleHeads = CycleHeads(ThinVec::new());
+pub(crate) fn empty_cycle_heads() -> &'static CycleHeads {
+    static EMPTY_CYCLE_HEADS: OnceLock<CycleHeads> = OnceLock::new();
+    EMPTY_CYCLE_HEADS.get_or_init(|| CycleHeads(ThinVec::new()))
 }
 
 #[derive(Debug, PartialEq, Eq)]

src/event.rs

@@ -1,5 +1,5 @@
 use crate::key::DatabaseKeyIndex;
-use crate::loom::thread::{self, ThreadId};
+use crate::sync::thread::{self, ThreadId};
 use crate::Revision;
 
 /// The `Event` struct identifies various notable things that can

src/function.rs

@@ -10,9 +10,9 @@ use crate::function::delete::DeletedEntries;
 use crate::function::sync::{ClaimResult, SyncTable};
 use crate::ingredient::Ingredient;
 use crate::key::DatabaseKeyIndex;
-use crate::loom::sync::Arc;
 use crate::plumbing::MemoIngredientMap;
 use crate::salsa_struct::SalsaStructInDb;
+use crate::sync::Arc;
 use crate::table::memo::MemoTableTypes;
 use crate::table::Table;
 use crate::views::DatabaseDownCaster;

src/function/execute.rs

@@ -1,7 +1,7 @@
 use crate::cycle::{CycleRecoveryStrategy, MAX_ITERATIONS};
 use crate::function::memo::Memo;
 use crate::function::{Configuration, IngredientImpl};
-use crate::loom::sync::atomic::{AtomicBool, Ordering};
+use crate::sync::atomic::{AtomicBool, Ordering};
 use crate::zalsa::{MemoIngredientIndex, Zalsa, ZalsaDatabase};
 use crate::zalsa_local::{ActiveQueryGuard, QueryRevisions};
 use crate::{Event, EventKind, Id, Revision};

src/function/fetch.rs

@@ -2,7 +2,6 @@ use crate::cycle::{CycleHeads, CycleRecoveryStrategy, UnexpectedCycle};
 use crate::function::memo::Memo;
 use crate::function::sync::ClaimResult;
 use crate::function::{Configuration, IngredientImpl, VerifyResult};
-use crate::loom::sync::AtomicMut;
 use crate::zalsa::{MemoIngredientIndex, Zalsa, ZalsaDatabase};
 use crate::zalsa_local::QueryRevisions;
 use crate::Id;
@@ -163,7 +162,7 @@ where
                         let mut revisions = active_query.pop();
                         revisions.cycle_heads = CycleHeads::initial(database_key_index);
                         // We need this for `cycle_heads()` to work. We will unset this in the outer `execute()`.
-                        revisions.verified_final.write_mut(false);
+                        *revisions.verified_final.get_mut() = false;
                         Some(self.insert_memo(
                             zalsa,
                             id,

src/function/lru.rs

@@ -1,7 +1,7 @@
 use std::num::NonZeroUsize;
 
 use crate::hash::FxLinkedHashSet;
-use crate::loom::sync::Mutex;
+use crate::sync::Mutex;
 use crate::Id;
 
 pub(super) struct Lru {

src/function/maybe_changed_after.rs

@@ -4,8 +4,8 @@ use crate::function::memo::Memo;
 use crate::function::sync::ClaimResult;
 use crate::function::{Configuration, IngredientImpl};
 use crate::key::DatabaseKeyIndex;
-use crate::loom::sync::atomic::Ordering;
 use crate::plumbing::ZalsaLocal;
+use crate::sync::atomic::Ordering;
 use crate::zalsa::{MemoIngredientIndex, Zalsa, ZalsaDatabase};
 use crate::zalsa_local::{QueryEdge, QueryOrigin};
 use crate::{AsDynDatabase as _, Id, Revision};