commit 32529fe8a30b9849957cc5e7a8fd79339d9792a6 · ptr.pet/nsid-tracker

+9 -9
server/src/db/mod.rs
···

       76
       76
        
       pub struct LexiconHandle {

     

       77
       77
        
           tree: Partition,

     

       78
       78
        
           buf: Arc<scc::Queue<EventRecord>>,

     

       79
       79
       -
           buf_len: AtomicUsize,

     

       80
       80
       -
           last_insert: AtomicInstant,

     

       79
       79
       +
           buf_len: AtomicUsize,       // relaxed

     

       80
       80
       +
           last_insert: AtomicInstant, // relaxed

     

       81
       81
       +
           block_size: AtomicUsize,    // relaxed

     

       81
       82
        
           eps: Rate,

     

       82
       82
       -
           block_size: AtomicUsize,

     

       83
       83
        
       }

     

       84
       84
        
       

     

       85
       85
        
       impl LexiconHandle {

     
···

       96
       96
        
           }

     

       97
       97
        
       

     

       98
       98
        
           fn item_count(&self) -> usize {

     

       99
       99
       -
               self.buf_len.load(AtomicOrdering::Acquire)

     

       99
       99
       +
               self.buf_len.load(AtomicOrdering::Relaxed)

     

       100
       100
        
           }

     

       101
       101
        
       

     

       102
       102
        
           fn last_insert(&self) -> Instant {

     

       103
       103
       -
               self.last_insert.load(AtomicOrdering::Acquire)

     

       103
       103
       +
               self.last_insert.load(AtomicOrdering::Relaxed)

     

       104
       104
        
           }

     

       105
       105
        
       

     

       106
       106
        
           fn suggested_block_size(&self) -> usize {

     
···

       109
       109
        
       

     

       110
       110
        
           fn insert(&self, event: EventRecord) {

     

       111
       111
        
               self.buf.push(event);

     

       112
       112
       -
               self.buf_len.fetch_add(1, AtomicOrdering::Release);

     

       112
       112
       +
               self.buf_len.fetch_add(1, AtomicOrdering::Relaxed);

     

       113
       113
        
               self.last_insert

     

       114
       114
       -
                   .store(Instant::now(), AtomicOrdering::Release);

     

       114
       114
       +
                   .store(Instant::now(), AtomicOrdering::Relaxed);

     

       115
       115
        
               self.eps.observe(&(), 1);

     

       116
       116
        
               let rate = self.eps.rate(&()) as usize;

     

       117
       117
        
               if rate != 0 {

     
···

       144
       144
        
                   written += 1;

     

       145
       145
        
               }

     

       146
       146
        
               if let (Some(start_timestamp), Some(end_timestamp)) = (start_timestamp, end_timestamp) {

     

       147
       147
       -
                   self.buf_len.store(0, AtomicOrdering::Release);

     

       147
       147
       +
                   self.buf_len.store(0, AtomicOrdering::Relaxed);

     

       148
       148
        
                   let value = writer.finish()?;

     

       149
       149
        
                   let mut key = Vec::with_capacity(size_of::<u64>() * 2);

     

       150
       150
        
                   key.write_varint(start_timestamp)?;

     
···

       161
       161
        
       // hits is tree per nsid: varint start time + varint end time -> block of hits

     

       162
       162
        
       pub struct Db {

     

       163
       163
        
           inner: Keyspace,

     

       164
       164
       +
           counts: Partition,

     

       164
       165
        
           hits: scc::HashIndex<SmolStr, Arc<LexiconHandle>>,

     

       165
       166
        
           syncpool: threadpool::ThreadPool,

     

       166
       166
       -
           counts: Partition,

     

       167
       167
        
           event_broadcaster: broadcast::Sender<(SmolStr, NsidCounts)>,

     

       168
       168
        
           eps: Rate,

     

       169
       169
        
           shutting_down: AtomicBool,