From ed8d539d144122915b3172c9811218f805384623 Mon Sep 17 00:00:00 2001
From: Tatsuya Kawano <tatsuya@hibaridb.org>
Date: Tue, 1 Feb 2022 19:34:06 +0800
Subject: [PATCH] Replace some `std::sync::Arc` with `triomphe::Arc` to reduce
 memory utilization

- Replace `Arc` for `Arc<ValueEntry>`, `Arc<EntryInfo>` and `Arc<value_initializer::Waiter>`.
- Add `triomphe` to the dependencies.

Relates to #72.
---
 .vscode/settings.json           |  1 +
 Cargo.toml                      |  1 +
 src/future/value_initializer.rs |  9 ++++----
 src/sync.rs                     | 31 +++++++++++++-------------
 src/sync/base_cache.rs          | 39 +++++++++++++++++----------------
 src/sync/deques.rs              | 22 +++++++++----------
 src/sync/invalidator.rs         | 12 +++++-----
 src/sync/value_initializer.rs   |  9 ++++----
 8 files changed, 65 insertions(+), 59 deletions(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index ec6e3f23..4d0da6b0 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -41,6 +41,7 @@
         "Tatsuya",
         "thiserror",
         "toolchain",
+        "triomphe",
         "trybuild",
         "Uninit",
         "unsync",
diff --git a/Cargo.toml b/Cargo.toml
index c21904a6..c63a2dd9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,6 +45,7 @@ quanta = "0.9.3"
 scheduled-thread-pool = "0.2"
 smallvec = "1.6"
 thiserror = "1.0"
+triomphe = "0.1"
 uuid = { version = "0.8", features = ["v4"] }
 
 # Optional dependencies
diff --git a/src/future/value_initializer.rs b/src/future/value_initializer.rs
index 2fbff790..53bff8fd 100644
--- a/src/future/value_initializer.rs
+++ b/src/future/value_initializer.rs
@@ -5,6 +5,7 @@ use std::{
     hash::{BuildHasher, Hash},
     sync::Arc,
 };
+use triomphe::Arc as TrioArc;
 
 type ErrorObject = Arc<dyn Any + Send + Sync + 'static>;
 
@@ -23,7 +24,7 @@ enum WaiterValue<V> {
     EnclosingFutureAborted,
 }
 
-type Waiter<V> = Arc<RwLock<WaiterValue<V>>>;
+type Waiter<V> = TrioArc<RwLock<WaiterValue<V>>>;
 
 struct WaiterGuard<'a, K, V, S>
 // NOTE: We usually do not attach trait bounds to here at the struct definition, but
@@ -172,7 +173,7 @@ where
         let mut retries = 0;
 
         loop {
-            let waiter = Arc::new(RwLock::new(WaiterValue::Computing));
+            let waiter = TrioArc::new(RwLock::new(WaiterValue::Computing));
             let mut lock = waiter.write().await;
 
             match self.try_insert_waiter(key, type_id, &waiter) {
@@ -246,10 +247,10 @@ where
         waiter: &Waiter<V>,
     ) -> Option<Waiter<V>> {
         let key = Arc::clone(key);
-        let waiter = Arc::clone(waiter);
+        let waiter = TrioArc::clone(waiter);
 
         self.waiters
-            .insert_with_or_modify((key, type_id), || waiter, |_, w| Arc::clone(w))
+            .insert_with_or_modify((key, type_id), || waiter, |_, w| TrioArc::clone(w))
     }
 }
 
diff --git a/src/sync.rs b/src/sync.rs
index 35fe8dcd..cb13dfd9 100644
--- a/src/sync.rs
+++ b/src/sync.rs
@@ -4,6 +4,7 @@ use crate::common::{deque::DeqNode, time::Instant};
 
 use parking_lot::Mutex;
 use std::{ptr::NonNull, sync::Arc};
+use triomphe::Arc as TrioArc;
 
 pub(crate) mod base_cache;
 mod builder;
@@ -68,14 +69,14 @@ impl<K> Clone for KeyHash<K> {
 
 pub(crate) struct KeyDate<K> {
     key: Arc<K>,
-    entry_info: Arc<EntryInfo>,
+    entry_info: TrioArc<EntryInfo>,
 }
 
 impl<K> KeyDate<K> {
-    pub(crate) fn new(key: Arc<K>, entry_info: &Arc<EntryInfo>) -> Self {
+    pub(crate) fn new(key: Arc<K>, entry_info: &TrioArc<EntryInfo>) -> Self {
         Self {
             key,
-            entry_info: Arc::clone(entry_info),
+            entry_info: TrioArc::clone(entry_info),
         }
     }
 
@@ -91,15 +92,15 @@ impl<K> KeyDate<K> {
 pub(crate) struct KeyHashDate<K> {
     key: Arc<K>,
     hash: u64,
-    entry_info: Arc<EntryInfo>,
+    entry_info: TrioArc<EntryInfo>,
 }
 
 impl<K> KeyHashDate<K> {
-    pub(crate) fn new(kh: KeyHash<K>, entry_info: &Arc<EntryInfo>) -> Self {
+    pub(crate) fn new(kh: KeyHash<K>, entry_info: &TrioArc<EntryInfo>) -> Self {
         Self {
             key: kh.key,
             hash: kh.hash,
-            entry_info: Arc::clone(entry_info),
+            entry_info: TrioArc::clone(entry_info),
         }
     }
 
@@ -114,11 +115,11 @@ impl<K> KeyHashDate<K> {
 
 pub(crate) struct KvEntry<K, V> {
     pub(crate) key: Arc<K>,
-    pub(crate) entry: Arc<ValueEntry<K, V>>,
+    pub(crate) entry: TrioArc<ValueEntry<K, V>>,
 }
 
 impl<K, V> KvEntry<K, V> {
-    pub(crate) fn new(key: Arc<K>, entry: Arc<ValueEntry<K, V>>) -> Self {
+    pub(crate) fn new(key: Arc<K>, entry: TrioArc<ValueEntry<K, V>>) -> Self {
         Self { key, entry }
     }
 }
@@ -183,12 +184,12 @@ unsafe impl<K> Send for DeqNodes<K> {}
 
 pub(crate) struct ValueEntry<K, V> {
     pub(crate) value: V,
-    info: Arc<EntryInfo>,
+    info: TrioArc<EntryInfo>,
     nodes: Mutex<DeqNodes<K>>,
 }
 
 impl<K, V> ValueEntry<K, V> {
-    fn new(value: V, entry_info: Arc<EntryInfo>) -> Self {
+    fn new(value: V, entry_info: TrioArc<EntryInfo>) -> Self {
         Self {
             value,
             info: entry_info,
@@ -199,7 +200,7 @@ impl<K, V> ValueEntry<K, V> {
         }
     }
 
-    fn new_from(value: V, entry_info: Arc<EntryInfo>, other: &Self) -> Self {
+    fn new_from(value: V, entry_info: TrioArc<EntryInfo>, other: &Self) -> Self {
         let nodes = {
             let other_nodes = other.nodes.lock();
             DeqNodes {
@@ -218,7 +219,7 @@ impl<K, V> ValueEntry<K, V> {
         }
     }
 
-    pub(crate) fn entry_info(&self) -> &Arc<EntryInfo> {
+    pub(crate) fn entry_info(&self) -> &TrioArc<EntryInfo> {
         &self.info
     }
 
@@ -266,7 +267,7 @@ impl<K, V> ValueEntry<K, V> {
     }
 }
 
-impl<K, V> AccessTime for Arc<ValueEntry<K, V>> {
+impl<K, V> AccessTime for TrioArc<ValueEntry<K, V>> {
     #[inline]
     fn last_accessed(&self) -> Option<Instant> {
         self.info.last_accessed()
@@ -290,14 +291,14 @@ impl<K, V> AccessTime for Arc<ValueEntry<K, V>> {
 
 pub(crate) enum ReadOp<K, V> {
     // u64 is the hash of the key.
-    Hit(u64, Arc<ValueEntry<K, V>>, Instant),
+    Hit(u64, TrioArc<ValueEntry<K, V>>, Instant),
     Miss(u64),
 }
 
 pub(crate) enum WriteOp<K, V> {
     Upsert {
         key_hash: KeyHash<K>,
-        value_entry: Arc<ValueEntry<K, V>>,
+        value_entry: TrioArc<ValueEntry<K, V>>,
         old_weight: u32,
         new_weight: u32,
     },
diff --git a/src/sync/base_cache.rs b/src/sync/base_cache.rs
index 22720337..5b31a7d4 100644
--- a/src/sync/base_cache.rs
+++ b/src/sync/base_cache.rs
@@ -32,6 +32,7 @@ use std::{
     },
     time::Duration,
 };
+use triomphe::Arc as TrioArc;
 
 pub(crate) const MAX_SYNC_REPEATS: usize = 4;
 
@@ -271,7 +272,7 @@ where
                     cnt,
                     WriteOp::Upsert {
                         key_hash: KeyHash::new(Arc::clone(&key), hash),
-                        value_entry: Arc::clone(&entry),
+                        value_entry: TrioArc::clone(&entry),
                         old_weight: 0,
                         new_weight: weight,
                     },
@@ -290,10 +291,10 @@ where
                 let cnt = op_cnt2.fetch_add(1, Ordering::Relaxed);
                 op2 = Some((
                     cnt,
-                    Arc::clone(old_entry),
+                    TrioArc::clone(old_entry),
                     WriteOp::Upsert {
                         key_hash: KeyHash::new(Arc::clone(&key), hash),
-                        value_entry: Arc::clone(&entry),
+                        value_entry: TrioArc::clone(&entry),
                         old_weight,
                         new_weight: weight,
                     },
@@ -321,9 +322,9 @@ where
     }
 
     #[inline]
-    fn new_value_entry(&self, value: V, policy_weight: u32) -> Arc<ValueEntry<K, V>> {
-        let info = Arc::new(EntryInfo::new(policy_weight));
-        Arc::new(ValueEntry::new(value, info))
+    fn new_value_entry(&self, value: V, policy_weight: u32) -> TrioArc<ValueEntry<K, V>> {
+        let info = TrioArc::new(EntryInfo::new(policy_weight));
+        TrioArc::new(ValueEntry::new(value, info))
     }
 
     #[inline]
@@ -332,10 +333,10 @@ where
         value: V,
         policy_weight: u32,
         other: &ValueEntry<K, V>,
-    ) -> Arc<ValueEntry<K, V>> {
-        let info = Arc::clone(other.entry_info());
+    ) -> TrioArc<ValueEntry<K, V>> {
+        let info = TrioArc::clone(other.entry_info());
         info.set_policy_weight(policy_weight);
-        Arc::new(ValueEntry::new_from(value, info, other))
+        TrioArc::new(ValueEntry::new_from(value, info, other))
     }
 
     #[inline]
@@ -457,9 +458,9 @@ enum AdmissionResult<K> {
     },
 }
 
-type CacheStore<K, V, S> = crate::cht::SegmentedHashMap<Arc<K>, Arc<ValueEntry<K, V>>, S>;
+type CacheStore<K, V, S> = crate::cht::SegmentedHashMap<Arc<K>, TrioArc<ValueEntry<K, V>>, S>;
 
-type CacheEntry<K, V> = (Arc<K>, Arc<ValueEntry<K, V>>);
+type CacheEntry<K, V> = (Arc<K>, TrioArc<ValueEntry<K, V>>);
 
 pub(crate) struct Inner<K, V, S> {
     max_capacity: Option<u64>,
@@ -636,7 +637,7 @@ where
     }
 
     #[inline]
-    fn is_invalidated_entry(&self, key: &Arc<K>, entry: &Arc<ValueEntry<K, V>>) -> bool {
+    fn is_invalidated_entry(&self, key: &Arc<K>, entry: &TrioArc<ValueEntry<K, V>>) -> bool {
         if self.invalidator_enabled {
             if let Some(inv) = &*self.invalidator.read() {
                 return inv.apply_predicates(key, entry);
@@ -671,13 +672,13 @@ where
     K: Hash + Eq,
     S: BuildHasher,
 {
-    fn get_value_entry(&self, key: &Arc<K>) -> Option<Arc<ValueEntry<K, V>>> {
+    fn get_value_entry(&self, key: &Arc<K>) -> Option<TrioArc<ValueEntry<K, V>>> {
         self.cache.get(key)
     }
 
-    fn remove_key_value_if<F>(&self, key: &Arc<K>, condition: F) -> Option<Arc<ValueEntry<K, V>>>
+    fn remove_key_value_if<F>(&self, key: &Arc<K>, condition: F) -> Option<TrioArc<ValueEntry<K, V>>>
     where
-        F: FnMut(&Arc<K>, &Arc<ValueEntry<K, V>>) -> bool,
+        F: FnMut(&Arc<K>, &TrioArc<ValueEntry<K, V>>) -> bool,
     {
         self.cache.remove_if(key, condition)
     }
@@ -875,7 +876,7 @@ where
     fn handle_upsert(
         &self,
         kh: KeyHash<K>,
-        entry: Arc<ValueEntry<K, V>>,
+        entry: TrioArc<ValueEntry<K, V>>,
         old_weight: u32,
         new_weight: u32,
         timestamp: Instant,
@@ -1035,7 +1036,7 @@ where
     fn handle_admit(
         &self,
         kh: KeyHash<K>,
-        entry: &Arc<ValueEntry<K, V>>,
+        entry: &TrioArc<ValueEntry<K, V>>,
         policy_weight: u32,
         deqs: &mut Deques<K>,
         counters: &mut EvictionCounters,
@@ -1055,7 +1056,7 @@ where
 
     fn handle_remove(
         deqs: &mut Deques<K>,
-        entry: Arc<ValueEntry<K, V>>,
+        entry: TrioArc<ValueEntry<K, V>>,
         counters: &mut EvictionCounters,
     ) {
         if entry.is_admitted() {
@@ -1071,7 +1072,7 @@ where
         ao_deq_name: &str,
         ao_deq: &mut Deque<KeyHashDate<K>>,
         wo_deq: &mut Deque<KeyDate<K>>,
-        entry: Arc<ValueEntry<K, V>>,
+        entry: TrioArc<ValueEntry<K, V>>,
         counters: &mut EvictionCounters,
     ) {
         if entry.is_admitted() {
diff --git a/src/sync/deques.rs b/src/sync/deques.rs
index 68f400d7..3c8a6749 100644
--- a/src/sync/deques.rs
+++ b/src/sync/deques.rs
@@ -1,8 +1,8 @@
 use super::{KeyDate, KeyHashDate, ValueEntry};
 use crate::common::deque::{CacheRegion, DeqNode, Deque};
 
-use std::{ptr::NonNull, sync::Arc};
-
+use std::ptr::NonNull;
+use triomphe::Arc as TrioArc;
 pub(crate) struct Deques<K> {
     pub(crate) window: Deque<KeyHashDate<K>>, //    Not used yet.
     pub(crate) probation: Deque<KeyHashDate<K>>,
@@ -34,7 +34,7 @@ impl<K> Deques<K> {
         &mut self,
         region: CacheRegion,
         khd: KeyHashDate<K>,
-        entry: &Arc<ValueEntry<K, V>>,
+        entry: &TrioArc<ValueEntry<K, V>>,
     ) {
         use CacheRegion::*;
         let node = Box::new(DeqNode::new(region, khd));
@@ -47,13 +47,13 @@ impl<K> Deques<K> {
         entry.set_access_order_q_node(Some(node));
     }
 
-    pub(crate) fn push_back_wo<V>(&mut self, kd: KeyDate<K>, entry: &Arc<ValueEntry<K, V>>) {
+    pub(crate) fn push_back_wo<V>(&mut self, kd: KeyDate<K>, entry: &TrioArc<ValueEntry<K, V>>) {
         let node = Box::new(DeqNode::new(CacheRegion::WriteOrder, 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: &Arc<ValueEntry<K, V>>) {
+    pub(crate) fn move_to_back_ao<V>(&mut self, entry: &TrioArc<ValueEntry<K, V>>) {
         use CacheRegion::*;
         if let Some(node) = entry.access_order_q_node() {
             let p = unsafe { node.as_ref() };
@@ -73,7 +73,7 @@ impl<K> Deques<K> {
     pub(crate) fn move_to_back_ao_in_deque<V>(
         deq_name: &str,
         deq: &mut Deque<KeyHashDate<K>>,
-        entry: &Arc<ValueEntry<K, V>>,
+        entry: &TrioArc<ValueEntry<K, V>>,
     ) {
         if let Some(node) = entry.access_order_q_node() {
             let p = unsafe { node.as_ref() };
@@ -90,7 +90,7 @@ impl<K> Deques<K> {
         }
     }
 
-    pub(crate) fn move_to_back_wo<V>(&mut self, entry: &Arc<ValueEntry<K, V>>) {
+    pub(crate) fn move_to_back_wo<V>(&mut self, entry: &TrioArc<ValueEntry<K, V>>) {
         use CacheRegion::*;
         if let Some(node) = entry.write_order_q_node() {
             let p = unsafe { node.as_ref() };
@@ -103,7 +103,7 @@ impl<K> Deques<K> {
 
     pub(crate) fn move_to_back_wo_in_deque<V>(
         deq: &mut Deque<KeyDate<K>>,
-        entry: &Arc<ValueEntry<K, V>>,
+        entry: &TrioArc<ValueEntry<K, V>>,
     ) {
         if let Some(node) = entry.write_order_q_node() {
             let p = unsafe { node.as_ref() };
@@ -120,7 +120,7 @@ impl<K> Deques<K> {
         }
     }
 
-    pub(crate) fn unlink_ao<V>(&mut self, entry: &Arc<ValueEntry<K, V>>) {
+    pub(crate) fn unlink_ao<V>(&mut self, entry: &TrioArc<ValueEntry<K, V>>) {
         if let Some(node) = entry.take_access_order_q_node() {
             self.unlink_node_ao(node);
         }
@@ -129,14 +129,14 @@ impl<K> Deques<K> {
     pub(crate) fn unlink_ao_from_deque<V>(
         deq_name: &str,
         deq: &mut Deque<KeyHashDate<K>>,
-        entry: &Arc<ValueEntry<K, V>>,
+        entry: &TrioArc<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<KeyDate<K>>, entry: &Arc<ValueEntry<K, V>>) {
+    pub(crate) fn unlink_wo<V>(deq: &mut Deque<KeyDate<K>>, entry: &TrioArc<ValueEntry<K, V>>) {
         if let Some(node) = entry.take_write_order_q_node() {
             Self::unlink_node_wo(deq, node);
         }
diff --git a/src/sync/invalidator.rs b/src/sync/invalidator.rs
index 861a1c3e..22f74f8e 100644
--- a/src/sync/invalidator.rs
+++ b/src/sync/invalidator.rs
@@ -8,7 +8,6 @@ use crate::{
     },
     PredicateError,
 };
-
 use super::{base_cache::Inner, AccessTime, KvEntry, PredicateId, PredicateIdStr, ValueEntry};
 
 use parking_lot::{Mutex, RwLock};
@@ -22,16 +21,17 @@ use std::{
     },
     time::Duration,
 };
+use triomphe::Arc as TrioArc;
 use uuid::Uuid;
 
 pub(crate) type PredicateFun<K, V> = Arc<dyn Fn(&K, &V) -> bool + Send + Sync + 'static>;
 
 pub(crate) trait GetOrRemoveEntry<K, V> {
-    fn get_value_entry(&self, key: &Arc<K>) -> Option<Arc<ValueEntry<K, V>>>;
+    fn get_value_entry(&self, key: &Arc<K>) -> Option<TrioArc<ValueEntry<K, V>>>;
 
-    fn remove_key_value_if<F>(&self, key: &Arc<K>, condition: F) -> Option<Arc<ValueEntry<K, V>>>
+    fn remove_key_value_if<F>(&self, key: &Arc<K>, condition: F) -> Option<TrioArc<ValueEntry<K, V>>>
     where
-        F: FnMut(&Arc<K>, &Arc<ValueEntry<K, V>>) -> bool;
+        F: FnMut(&Arc<K>, &TrioArc<ValueEntry<K, V>>) -> bool;
 }
 
 pub(crate) struct KeyDateLite<K> {
@@ -161,7 +161,7 @@ impl<K, V, S> Invalidator<K, V, S> {
 
     // This method will be called by the get method of Cache.
     #[inline]
-    pub(crate) fn apply_predicates(&self, key: &Arc<K>, entry: &Arc<ValueEntry<K, V>>) -> bool {
+    pub(crate) fn apply_predicates(&self, key: &Arc<K>, entry: &TrioArc<ValueEntry<K, V>>) -> bool {
         if self.is_empty() {
             false
         } else if let Some(ts) = entry.last_modified() {
@@ -434,7 +434,7 @@ where
         false
     }
 
-    fn invalidate<C>(cache: &Arc<C>, key: &Arc<K>, ts: Instant) -> Option<Arc<ValueEntry<K, V>>>
+    fn invalidate<C>(cache: &Arc<C>, key: &Arc<K>, ts: Instant) -> Option<TrioArc<ValueEntry<K, V>>>
     where
         Arc<C>: GetOrRemoveEntry<K, V>,
     {
diff --git a/src/sync/value_initializer.rs b/src/sync/value_initializer.rs
index 2e7ea9fe..bc725b27 100644
--- a/src/sync/value_initializer.rs
+++ b/src/sync/value_initializer.rs
@@ -4,10 +4,11 @@ use std::{
     hash::{BuildHasher, Hash},
     sync::Arc,
 };
+use triomphe::Arc as TrioArc;
 
 type ErrorObject = Arc<dyn Any + Send + Sync + 'static>;
 type WaiterValue<V> = Option<Result<V, ErrorObject>>;
-type Waiter<V> = Arc<RwLock<WaiterValue<V>>>;
+type Waiter<V> = TrioArc<RwLock<WaiterValue<V>>>;
 
 pub(crate) enum InitResult<V, E> {
     Initialized(V),
@@ -97,7 +98,7 @@ where
         let mut retries = 0;
 
         loop {
-            let waiter = Arc::new(RwLock::new(None));
+            let waiter = TrioArc::new(RwLock::new(None));
             let mut lock = waiter.write();
 
             match self.try_insert_waiter(key, type_id, &waiter) {
@@ -157,9 +158,9 @@ where
         waiter: &Waiter<V>,
     ) -> Option<Waiter<V>> {
         let key = Arc::clone(key);
-        let waiter = Arc::clone(waiter);
+        let waiter = TrioArc::clone(waiter);
 
         self.waiters
-            .insert_with_or_modify((key, type_id), || waiter, |_, w| Arc::clone(w))
+            .insert_with_or_modify((key, type_id), || waiter, |_, w| TrioArc::clone(w))
     }
 }