skippydb 0.2.2

A high-performance verifiable key-value store with SHA256 Merkle trees and optional CUDA GPU acceleration, designed for blockchain state storage.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

use std::sync::mpsc::{sync_channel, Receiver, RecvError, SendError, SyncSender};

pub struct Producer<T: Clone> {
    fwd_sender: SyncSender<T>,
    bck_receiver: Receiver<T>,
}

pub struct Consumer<T: Clone> {
    bck_sender: SyncSender<T>,
    fwd_receiver: Receiver<T>,
}

pub fn new<T: Clone>(size: usize, t: &T) -> (Producer<T>, Consumer<T>) {
    let (fwd_sender, fwd_receiver) = sync_channel(size);
    let (bck_sender, bck_receiver) = sync_channel(size);
    for _ in 0..size {
        bck_sender.send(t.clone()).unwrap();
    }
    let prod = Producer {
        fwd_sender,
        bck_receiver,
    };
    let cons = Consumer {
        bck_sender,
        fwd_receiver,
    };
    (prod, cons)
}

impl<T: Clone> Producer<T> {
    pub fn produce(&mut self, t: T) -> Result<(), SendError<T>> {
        self.fwd_sender.send(t)
    }
    pub fn receive_returned(&mut self) -> Result<T, RecvError> {
        self.bck_receiver.recv()
    }
}

impl<T: Clone> Consumer<T> {
    pub fn consume(&mut self) -> T {
        self.fwd_receiver.recv().unwrap()
    }
    pub fn send_returned(&mut self, t: T) {
        self.bck_sender.send(t).unwrap();
    }
}