iridium-db 0.3.0

A high-performance vector-graph hybrid storage and indexing engine
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60

pub type CoreId = u16;
pub type ShardId = u16;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ThreadCoreRequest {
    pub core_id: CoreId,
    pub shard_count: u16,
}

impl Default for ThreadCoreRequest {
    fn default() -> Self {
        Self {
            core_id: 0,
            shard_count: 1,
        }
    }
}

impl ThreadCoreRequest {
    pub fn owned_shard(&self) -> ShardId {
        if self.shard_count == 0 {
            return 0;
        }
        self.core_id % self.shard_count
    }
}

pub fn shard_for_node(node_id: u64, shard_count: u16) -> ShardId {
    if shard_count == 0 {
        return 0;
    }
    (node_id % shard_count as u64) as u16
}

pub fn request_owns_node(request: &ThreadCoreRequest, node_id: u64) -> bool {
    shard_for_node(node_id, request.shard_count) == request.owned_shard()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn shard_routing_is_deterministic() {
        assert_eq!(shard_for_node(1, 4), 1);
        assert_eq!(shard_for_node(2, 4), 2);
        assert_eq!(shard_for_node(5, 4), 1);
    }

    #[test]
    fn core_request_maps_to_owned_shard() {
        let request = ThreadCoreRequest {
            core_id: 5,
            shard_count: 4,
        };
        assert_eq!(request.owned_shard(), 1);
        assert!(request_owns_node(&request, 9));
        assert!(!request_owns_node(&request, 10));
    }
}