Switch from triomphe::Arc to MiniArc, our own Arc implementation

`MiniArc` is like a `std::sync::Arc` but with a few differences:

- No `Weak` references.
- Uses `AtomicU32` instead of `AtomicUsize` for reference counting.
- Much smaller code size by having only the necessary methods for us.

Cargo.toml

@@ -44,17 +44,13 @@ unstable-debug-counters = ["future", "once_cell"]
 crossbeam-channel = "0.5.5"
 crossbeam-epoch = "0.9.9"
 crossbeam-utils = "0.8"
+moka-arc = { git = "https://gitlab.com/moka-labs/moka-gh440-remove-triomphe/moka-arc.git" }
 parking_lot = "0.12"
 smallvec = "1.8"
 tagptr = "0.2"
 thiserror = "1.0"
 uuid = { version = "1.1", features = ["v4"] }
 
-# Opt-out serde and stable_deref_trait features
-# https://github.com/Manishearth/triomphe/pull/5
-# 0.1.12 requires Rust 1.76
-triomphe = { version = ">=0.1.3, <0.1.12", default-features = false }
-
 # Optional dependencies (enabled by default)
 quanta = { version = "0.12.2", optional = true }
 

src/common/concurrent.rs

@@ -3,7 +3,7 @@ use crate::common::{deque::DeqNode, time::Instant};
 use parking_lot::Mutex;
 use std::{fmt, ptr::NonNull, sync::Arc};
 use tagptr::TagNonNull;
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 pub(crate) mod constants;
 pub(crate) mod deques;
@@ -64,13 +64,13 @@ impl<K> Clone for KeyHash<K> {
 }
 
 pub(crate) struct KeyHashDate<K> {
-    entry_info: TrioArc<EntryInfo<K>>,
+    entry_info: MiniArc<EntryInfo<K>>,
 }
 
 impl<K> KeyHashDate<K> {
-    pub(crate) fn new(entry_info: &TrioArc<EntryInfo<K>>) -> Self {
+    pub(crate) fn new(entry_info: &MiniArc<EntryInfo<K>>) -> Self {
         Self {
-            entry_info: TrioArc::clone(entry_info),
+            entry_info: MiniArc::clone(entry_info),
         }
     }
 
@@ -101,11 +101,11 @@ impl<K> KeyHashDate<K> {
 
 pub(crate) struct KvEntry<K, V> {
     pub(crate) key: Arc<K>,
-    pub(crate) entry: TrioArc<ValueEntry<K, V>>,
+    pub(crate) entry: MiniArc<ValueEntry<K, V>>,
 }
 
 impl<K, V> KvEntry<K, V> {
-    pub(crate) fn new(key: Arc<K>, entry: TrioArc<ValueEntry<K, V>>) -> Self {
+    pub(crate) fn new(key: Arc<K>, entry: MiniArc<ValueEntry<K, V>>) -> Self {
         Self { key, entry }
     }
 }
@@ -114,7 +114,7 @@ impl<K, V> Clone for KvEntry<K, V> {
     fn clone(&self) -> Self {
         Self {
             key: Arc::clone(&self.key),
-            entry: TrioArc::clone(&self.entry),
+            entry: MiniArc::clone(&self.entry),
         }
     }
 }
@@ -177,33 +177,33 @@ impl<K> DeqNodes<K> {
 
 pub(crate) struct ValueEntry<K, V> {
     pub(crate) value: V,
-    info: TrioArc<EntryInfo<K>>,
-    nodes: TrioArc<Mutex<DeqNodes<K>>>,
+    info: MiniArc<EntryInfo<K>>,
+    nodes: MiniArc<Mutex<DeqNodes<K>>>,
 }
 
 impl<K, V> ValueEntry<K, V> {
-    pub(crate) fn new(value: V, entry_info: TrioArc<EntryInfo<K>>) -> Self {
+    pub(crate) fn new(value: V, entry_info: MiniArc<EntryInfo<K>>) -> Self {
         #[cfg(feature = "unstable-debug-counters")]
         self::debug_counters::InternalGlobalDebugCounters::value_entry_created();
 
         Self {
             value,
             info: entry_info,
-            nodes: TrioArc::new(Mutex::new(DeqNodes::default())),
+            nodes: MiniArc::new(Mutex::new(DeqNodes::default())),
         }
     }
 
-    pub(crate) fn new_from(value: V, entry_info: TrioArc<EntryInfo<K>>, other: &Self) -> Self {
+    pub(crate) fn new_from(value: V, entry_info: MiniArc<EntryInfo<K>>, other: &Self) -> Self {
         #[cfg(feature = "unstable-debug-counters")]
         self::debug_counters::InternalGlobalDebugCounters::value_entry_created();
         Self {
             value,
             info: entry_info,
-            nodes: TrioArc::clone(&other.nodes),
+            nodes: MiniArc::clone(&other.nodes),
         }
     }
 
-    pub(crate) fn entry_info(&self) -> &TrioArc<EntryInfo<K>> {
+    pub(crate) fn entry_info(&self) -> &MiniArc<EntryInfo<K>> {
         &self.info
     }
 
@@ -224,7 +224,7 @@ impl<K, V> ValueEntry<K, V> {
         self.info.policy_weight()
     }
 
-    pub(crate) fn deq_nodes(&self) -> &TrioArc<Mutex<DeqNodes<K>>> {
+    pub(crate) fn deq_nodes(&self) -> &MiniArc<Mutex<DeqNodes<K>>> {
         &self.nodes
     }
 
@@ -278,7 +278,7 @@ impl<K, V> Drop for ValueEntry<K, V> {
     }
 }
 
-impl<K, V> AccessTime for TrioArc<ValueEntry<K, V>> {
+impl<K, V> AccessTime for MiniArc<ValueEntry<K, V>> {
     #[inline]
     fn last_accessed(&self) -> Option<Instant> {
         self.info.last_accessed()
@@ -302,7 +302,7 @@ impl<K, V> AccessTime for TrioArc<ValueEntry<K, V>> {
 
 pub(crate) enum ReadOp<K, V> {
     Hit {
-        value_entry: TrioArc<ValueEntry<K, V>>,
+        value_entry: MiniArc<ValueEntry<K, V>>,
         is_expiry_modified: bool,
     },
     // u64 is the hash of the key.
@@ -312,7 +312,7 @@ pub(crate) enum ReadOp<K, V> {
 pub(crate) enum WriteOp<K, V> {
     Upsert {
         key_hash: KeyHash<K>,
-        value_entry: TrioArc<ValueEntry<K, V>>,
+        value_entry: MiniArc<ValueEntry<K, V>>,
         /// Entry generation after the operation.
         entry_gen: u16,
         old_weight: u32,
@@ -324,7 +324,7 @@ pub(crate) enum WriteOp<K, V> {
     },
 }
 
-/// Cloning a `WriteOp` is safe and cheap because it uses `Arc` and `TrioArc` pointers to
+/// Cloning a `WriteOp` is safe and cheap because it uses `Arc` and `MiniArc` pointers to
 /// the actual data.
 impl<K, V> Clone for WriteOp<K, V> {
     fn clone(&self) -> Self {
@@ -337,7 +337,7 @@ impl<K, V> Clone for WriteOp<K, V> {
                 new_weight,
             } => Self::Upsert {
                 key_hash: key_hash.clone(),
-                value_entry: TrioArc::clone(value_entry),
+                value_entry: MiniArc::clone(value_entry),
                 entry_gen: *entry_gen,
                 old_weight: *old_weight,
                 new_weight: *new_weight,
@@ -366,13 +366,13 @@ impl<K, V> WriteOp<K, V> {
     pub(crate) fn new_upsert(
         key: &Arc<K>,
         hash: u64,
-        value_entry: &TrioArc<ValueEntry<K, V>>,
+        value_entry: &MiniArc<ValueEntry<K, V>>,
         entry_generation: u16,
         old_weight: u32,
         new_weight: u32,
     ) -> Self {
         let key_hash = KeyHash::new(Arc::clone(key), hash);
-        let value_entry = TrioArc::clone(value_entry);
+        let value_entry = MiniArc::clone(value_entry);
         Self::Upsert {
             key_hash,
             value_entry,
@@ -384,15 +384,15 @@ impl<K, V> WriteOp<K, V> {
 }
 
 pub(crate) struct OldEntryInfo<K, V> {
-    pub(crate) entry: TrioArc<ValueEntry<K, V>>,
+    pub(crate) entry: MiniArc<ValueEntry<K, V>>,
     pub(crate) last_accessed: Option<Instant>,
     pub(crate) last_modified: Option<Instant>,
 }
 
 impl<K, V> OldEntryInfo<K, V> {
-    pub(crate) fn new(entry: &TrioArc<ValueEntry<K, V>>) -> Self {
+    pub(crate) fn new(entry: &MiniArc<ValueEntry<K, V>>) -> Self {
         Self {
-            entry: TrioArc::clone(entry),
+            entry: MiniArc::clone(entry),
             last_accessed: entry.last_accessed(),
             last_modified: entry.last_modified(),
         }

src/common/concurrent/deques.rs

@@ -6,7 +6,8 @@ use crate::common::{
 
 use std::ptr::NonNull;
 use tagptr::TagNonNull;
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
+
 pub(crate) struct Deques<K> {
     pub(crate) window: Deque<KeyHashDate<K>>, //    Not used yet.
     pub(crate) probation: Deque<KeyHashDate<K>>,
@@ -50,7 +51,7 @@ impl<K> Deques<K> {
         &mut self,
         region: CacheRegion,
         khd: KeyHashDate<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         let node = Box::new(DeqNode::new(khd));
         let node = match region {
@@ -66,14 +67,14 @@ impl<K> Deques<K> {
     pub(crate) fn push_back_wo<V>(
         &mut self,
         kd: KeyHashDate<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         let node = Box::new(DeqNode::new(kd));
         let node = self.write_order.push_back(node);
         entry.set_write_order_q_node(Some(node));
     }
 
-    pub(crate) fn move_to_back_ao<V>(&mut self, entry: &TrioArc<ValueEntry<K, V>>) {
+    pub(crate) fn move_to_back_ao<V>(&mut self, entry: &MiniArc<ValueEntry<K, V>>) {
         if let Some(tagged_node) = entry.access_order_q_node() {
             let (node, tag) = tagged_node.decompose();
             let p = unsafe { node.as_ref() };
@@ -95,7 +96,7 @@ impl<K> Deques<K> {
     pub(crate) fn move_to_back_ao_in_deque<V>(
         deq_name: &str,
         deq: &mut Deque<KeyHashDate<K>>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         if let Some(tagged_node) = entry.access_order_q_node() {
             let (node, tag) = tagged_node.decompose();
@@ -111,7 +112,7 @@ impl<K> Deques<K> {
         }
     }
 
-    pub(crate) fn move_to_back_wo<V>(&mut self, entry: &TrioArc<ValueEntry<K, V>>) {
+    pub(crate) fn move_to_back_wo<V>(&mut self, entry: &MiniArc<ValueEntry<K, V>>) {
         if let Some(node) = entry.write_order_q_node() {
             let p = unsafe { node.as_ref() };
             if self.write_order.contains(p) {
@@ -122,7 +123,7 @@ impl<K> Deques<K> {
 
     pub(crate) fn move_to_back_wo_in_deque<V>(
         deq: &mut Deque<KeyHashDate<K>>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         if let Some(node) = entry.write_order_q_node() {
             let p = unsafe { node.as_ref() };
@@ -132,7 +133,7 @@ impl<K> Deques<K> {
         }
     }
 
-    pub(crate) fn unlink_ao<V>(&mut self, entry: &TrioArc<ValueEntry<K, V>>) {
+    pub(crate) fn unlink_ao<V>(&mut self, entry: &MiniArc<ValueEntry<K, V>>) {
         if let Some(node) = entry.take_access_order_q_node() {
             self.unlink_node_ao(node);
         }
@@ -141,14 +142,14 @@ impl<K> Deques<K> {
     pub(crate) fn unlink_ao_from_deque<V>(
         deq_name: &str,
         deq: &mut Deque<KeyHashDate<K>>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         if let Some(node) = entry.take_access_order_q_node() {
             unsafe { Self::unlink_node_ao_from_deque(deq_name, deq, node) };
         }
     }
 
-    pub(crate) fn unlink_wo<V>(deq: &mut Deque<KeyHashDate<K>>, entry: &TrioArc<ValueEntry<K, V>>) {
+    pub(crate) fn unlink_wo<V>(deq: &mut Deque<KeyHashDate<K>>, entry: &MiniArc<ValueEntry<K, V>>) {
         if let Some(node) = entry.take_write_order_q_node() {
             Self::unlink_node_wo(deq, node);
         }

src/common/timer_wheel.rs

@@ -20,7 +20,7 @@ use super::{
 };
 
 use parking_lot::Mutex;
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 const BUCKET_COUNTS: &[u64] = &[
     64, // roughly seconds
@@ -69,16 +69,16 @@ pub(crate) enum TimerNode<K> {
         /// The position (level and index) of the timer wheel bucket.
         pos: Option<(u8, u8)>,
         /// An Arc pointer to the `EntryInfo` of the cache entry (`ValueEntry`).
-        entry_info: TrioArc<EntryInfo<K>>,
+        entry_info: MiniArc<EntryInfo<K>>,
         /// An Arc pointer to the `DeqNodes` of the cache entry (`ValueEntry`).
-        deq_nodes: TrioArc<Mutex<DeqNodes<K>>>,
+        deq_nodes: MiniArc<Mutex<DeqNodes<K>>>,
     },
 }
 
 impl<K> TimerNode<K> {
     fn new(
-        entry_info: TrioArc<EntryInfo<K>>,
-        deq_nodes: TrioArc<Mutex<DeqNodes<K>>>,
+        entry_info: MiniArc<EntryInfo<K>>,
+        deq_nodes: MiniArc<Mutex<DeqNodes<K>>>,
         level: usize,
         index: usize,
     ) -> Self {
@@ -118,7 +118,7 @@ impl<K> TimerNode<K> {
         matches!(self, Self::Sentinel)
     }
 
-    pub(crate) fn entry_info(&self) -> &TrioArc<EntryInfo<K>> {
+    pub(crate) fn entry_info(&self) -> &MiniArc<EntryInfo<K>> {
         if let Self::Entry { entry_info, .. } = &self {
             entry_info
         } else {
@@ -209,8 +209,8 @@ impl<K> TimerWheel<K> {
     /// Schedules a timer event for the node.
     pub(crate) fn schedule(
         &mut self,
-        entry_info: TrioArc<EntryInfo<K>>,
-        deq_nodes: TrioArc<Mutex<DeqNodes<K>>>,
+        entry_info: MiniArc<EntryInfo<K>>,
+        deq_nodes: MiniArc<Mutex<DeqNodes<K>>>,
     ) -> Option<NonNull<DeqNode<TimerNode<K>>>> {
         debug_assert!(self.is_enabled());
 
@@ -397,7 +397,7 @@ pub(crate) enum TimerEvent<K> {
     // from one wheel to another in a lower level of the hierarchy. (This variant
     // is mainly used for testing)
     #[cfg(test)]
-    Rescheduled(TrioArc<EntryInfo<K>>),
+    Rescheduled(MiniArc<EntryInfo<K>>),
     #[cfg(not(test))]
     Rescheduled(()),
     /// This timer node (containing a cache entry) has been removed from the timer.
@@ -517,7 +517,7 @@ impl<'iter, K> Iterator for TimerEventsIter<'iter, K> {
                     // Get the entry info before rescheduling (mutating) the node to
                     // avoid Stacked Borrows/Tree Borrows violations on `node_p`.
                     let entry_info =
-                        TrioArc::clone(unsafe { node_p.as_ref() }.element.entry_info());
+                        MiniArc::clone(unsafe { node_p.as_ref() }.element.entry_info());
 
                     match self.timer_wheel.schedule_existing_node(node_p) {
                         ReschedulingResult::Rescheduled => {
@@ -564,7 +564,7 @@ mod tests {
         time::{CheckedTimeOps, Clock, Instant, Mock},
     };
 
-    use triomphe::Arc as TrioArc;
+    use moka_arc::MiniArc;
 
     #[test]
     fn test_bucket_indices() {
@@ -654,10 +654,10 @@ mod tests {
             let hash = key as u64;
             let key_hash = KeyHash::new(Arc::new(key), hash);
             let policy_weight = 0;
-            let entry_info = TrioArc::new(EntryInfo::new(key_hash, now, policy_weight));
+            let entry_info = MiniArc::new(EntryInfo::new(key_hash, now, policy_weight));
             entry_info.set_expiration_time(Some(now.checked_add(ttl).unwrap()));
             let deq_nodes = Default::default();
-            let timer_node = timer.schedule(entry_info, TrioArc::clone(&deq_nodes));
+            let timer_node = timer.schedule(entry_info, MiniArc::clone(&deq_nodes));
             deq_nodes.lock().set_timer_node(timer_node);
         }