encapsulate Runtime within Zalsa

The aim is to eventually eliminate Runtime.

Author: nikomatsakis

src/function/sync.rs

@@ -4,8 +4,8 @@ use std::{
 };
 
 use crate::{
-    hash::FxDashMap, key::DatabaseKeyIndex, local_state::LocalState, runtime::WaitResult, Database,
-    Id, Runtime,
+    hash::FxDashMap, key::DatabaseKeyIndex, local_state::LocalState, runtime::WaitResult,
+    storage::Zalsa, Database, Id,
 };
 
 #[derive(Default)]
@@ -28,7 +28,7 @@ impl SyncMap {
         local_state: &LocalState,
         database_key_index: DatabaseKeyIndex,
     ) -> Option<ClaimGuard<'me>> {
-        let runtime = db.zalsa().runtimex();
+        let zalsa = db.zalsa();
         let thread_id = std::thread::current().id();
         match self.sync_map.entry(database_key_index.key_index) {
             dashmap::mapref::entry::Entry::Vacant(entry) => {
@@ -38,7 +38,7 @@ impl SyncMap {
                 });
                 Some(ClaimGuard {
                     database_key: database_key_index,
-                    runtime,
+                    zalsa,
                     sync_map: &self.sync_map,
                 })
             }
@@ -51,7 +51,7 @@ impl SyncMap {
                 // not to gate future atomic reads.
                 entry.get().anyone_waiting.store(true, Ordering::Relaxed);
                 let other_id = entry.get().id;
-                runtime.block_on_or_unwind(db, local_state, database_key_index, other_id, entry);
+                zalsa.block_on_or_unwind(db, local_state, database_key_index, other_id, entry);
                 None
             }
         }
@@ -63,7 +63,7 @@ impl SyncMap {
 #[must_use]
 pub(super) struct ClaimGuard<'me> {
     database_key: DatabaseKeyIndex,
-    runtime: &'me Runtime,
+    zalsa: &'me Zalsa,
     sync_map: &'me FxDashMap<Id, SyncState>,
 }
 
@@ -75,7 +75,7 @@ impl<'me> ClaimGuard<'me> {
         // NB: `Ordering::Relaxed` is sufficient here,
         // see `store` above for explanation.
         if anyone_waiting.load(Ordering::Relaxed) {
-            self.runtime
+            self.zalsa
                 .unblock_queries_blocked_on(self.database_key, wait_result)
         }
     }

src/storage.rs

@@ -1,4 +1,5 @@
 use std::any::{Any, TypeId};
+use std::thread::ThreadId;
 
 use orx_concurrent_vec::ConcurrentVec;
 use parking_lot::Mutex;
@@ -7,10 +8,11 @@ use rustc_hash::FxHashMap;
 use crate::cycle::CycleRecoveryStrategy;
 use crate::database::UserData;
 use crate::ingredient::{Ingredient, Jar};
+use crate::local_state::LocalState;
 use crate::nonce::{Nonce, NonceGenerator};
-use crate::runtime::Runtime;
+use crate::runtime::{Runtime, WaitResult};
 use crate::views::Views;
-use crate::{Database, DatabaseImpl, Durability, Revision};
+use crate::{Database, DatabaseImpl, DatabaseKeyIndex, Durability, Revision};
 
 pub fn views<Db: ?Sized + Database>(db: &Db) -> &Views {
     db.zalsa().views()
@@ -164,10 +166,6 @@ impl Zalsa {
         self.runtime.report_tracked_write(durability)
     }
 
-    pub(crate) fn runtimex(&self) -> &Runtime {
-        &self.runtime
-    }
-
     /// **NOT SEMVER STABLE**
     pub fn last_changed_revision(&self, durability: Durability) -> Revision {
         self.runtime.last_changed_revision(durability)
@@ -195,6 +193,29 @@ impl Zalsa {
 
         new_revision
     }
+
+    /// See [`Runtime::block_on_or_unwind`][]
+    pub(crate) fn block_on_or_unwind<QueryMutexGuard>(
+        &self,
+        db: &dyn Database,
+        local_state: &LocalState,
+        database_key: DatabaseKeyIndex,
+        other_id: ThreadId,
+        query_mutex_guard: QueryMutexGuard,
+    ) {
+        self.runtime
+            .block_on_or_unwind(db, local_state, database_key, other_id, query_mutex_guard)
+    }
+
+    /// See [`Runtime::unblock_queries_blocked_on`][]
+    pub(crate) fn unblock_queries_blocked_on(
+        &self,
+        database_key: DatabaseKeyIndex,
+        wait_result: WaitResult,
+    ) {
+        self.runtime
+            .unblock_queries_blocked_on(database_key, wait_result)
+    }
 }
 
 /// Caches a pointer to an ingredient in a database.