ascent/
c_rel_no_index.rs

1use dashmap::RwLock;
2use instant::Instant;
3use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
4
5use crate::internal::{
6   CRelIndexRead, CRelIndexReadAll, CRelIndexWrite, Freezable, RelIndexMerge, RelIndexRead, RelIndexReadAll,
7   RelIndexWrite,
8};
9
10pub struct CRelNoIndex<V> {
11   // TODO remove pub
12   pub vec: Vec<RwLock<Vec<V>>>,
13   // vec: [RwLock<Vec<V>>; 32],
14   frozen: bool,
15}
16
17impl<V> Default for CRelNoIndex<V> {
18   #[inline]
19   fn default() -> Self {
20      let threads = rayon::current_num_threads().max(1);
21      let mut vec = Vec::with_capacity(threads);
22      for _ in 0..threads {
23         vec.push(RwLock::new(vec![]));
24      }
25      Self { vec, frozen: false }
26
27      // Self { vec: array_init::array_init(|_| RwLock::new(vec![])), frozen: false }
28   }
29}
30
31impl<V> CRelNoIndex<V> {
32   pub fn hash_usize(&self, _key: &()) -> usize { 0 }
33}
34
35impl<V> Freezable for CRelNoIndex<V> {
36   fn freeze(&mut self) { self.frozen = true; }
37   fn unfreeze(&mut self) { self.frozen = false; }
38}
39
40impl<'a, V: 'a> RelIndexRead<'a> for CRelNoIndex<V> {
41   type Key = ();
42   type Value = &'a V;
43
44   type IteratorType = std::iter::FlatMap<
45      std::slice::Iter<'a, RwLock<Vec<V>>>,
46      std::slice::Iter<'a, V>,
47      fn(&RwLock<Vec<V>>) -> std::slice::Iter<V>,
48   >;
49
50   fn index_get(&'a self, _key: &Self::Key) -> Option<Self::IteratorType> {
51      assert!(self.frozen);
52      let res: Self::IteratorType = self.vec.iter().flat_map(|v| {
53         let data = unsafe { &*v.data_ptr() };
54         data.iter()
55      });
56      Some(res)
57   }
58
59   #[inline(always)]
60   fn len_estimate(&self) -> usize { 1 }
61
62   fn is_empty(&'a self) -> bool { false }
63}
64
65impl<'a, V: 'a + Sync + Send> CRelIndexRead<'a> for CRelNoIndex<V> {
66   type Key = ();
67   type Value = &'a V;
68
69   type IteratorType =
70      rayon::iter::FlatMap<rayon::slice::Iter<'a, RwLock<Vec<V>>>, fn(&RwLock<Vec<V>>) -> rayon::slice::Iter<V>>;
71
72   fn c_index_get(&'a self, _key: &Self::Key) -> Option<Self::IteratorType> {
73      assert!(self.frozen);
74      let res: Self::IteratorType = self.vec.par_iter().flat_map(|v| {
75         let data = unsafe { &*v.data_ptr() };
76         data.par_iter()
77      });
78      Some(res)
79   }
80}
81
82impl<V> RelIndexWrite for CRelNoIndex<V> {
83   type Key = ();
84   type Value = V;
85
86   fn index_insert(&mut self, _key: Self::Key, value: Self::Value) {
87      // not necessary because we have a mut reference
88      // assert!(!ind.frozen);
89      let shard_idx = rayon::current_thread_index().unwrap_or(0) % self.vec.len();
90      self.vec[shard_idx].get_mut().push(value);
91   }
92}
93
94impl<V> RelIndexMerge for CRelNoIndex<V> {
95   fn move_index_contents(from: &mut Self, to: &mut Self) {
96      let before = Instant::now();
97      assert_eq!(from.len_estimate(), to.len_estimate());
98      // not necessary because we have a mut reference
99      // assert!(!from.frozen);
100      // assert!(!to.frozen);
101
102      from.vec.iter_mut().zip(to.vec.iter_mut()).for_each(|(from, to)| {
103         let from = from.get_mut();
104         let to = to.get_mut();
105
106         if from.len() > to.len() {
107            std::mem::swap(from, to);
108         }
109         to.append(from);
110      });
111      unsafe {
112         crate::internal::MOVE_NO_INDEX_CONTENTS_TOTAL_TIME += before.elapsed();
113      }
114   }
115}
116
117impl<V> CRelIndexWrite for CRelNoIndex<V> {
118   type Key = ();
119   type Value = V;
120
121   fn index_insert(&self, _key: Self::Key, value: Self::Value) {
122      assert!(!self.frozen);
123      let shard_idx = rayon::current_thread_index().unwrap_or(0) % self.vec.len();
124      self.vec[shard_idx].write().push(value);
125   }
126}
127
128impl<'a, V: 'a> RelIndexReadAll<'a> for CRelNoIndex<V> {
129   type Key = &'a ();
130   type Value = &'a V;
131
132   type ValueIteratorType = <Self as RelIndexRead<'a>>::IteratorType;
133
134   type AllIteratorType = std::iter::Once<(&'a (), Self::ValueIteratorType)>;
135
136   fn iter_all(&'a self) -> Self::AllIteratorType { std::iter::once((&(), self.index_get(&()).unwrap())) }
137}
138
139impl<'a, V: 'a + Sync + Send> CRelIndexReadAll<'a> for CRelNoIndex<V> {
140   type Key = &'a ();
141   type Value = &'a V;
142
143   type ValueIteratorType = <Self as CRelIndexRead<'a>>::IteratorType;
144
145   type AllIteratorType = rayon::iter::Once<(&'a (), Self::ValueIteratorType)>;
146
147   fn c_iter_all(&'a self) -> Self::AllIteratorType { rayon::iter::once((&(), self.c_index_get(&()).unwrap())) }
148}
ascent/c_rel_no_index.rs

ascent/
c_rel_no_index.rs
