object-space 0.1.1

An object store library for highly concurrent program written in Rust.
Documentation 
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

extern crate object_space;
extern crate serde;
#[macro_use]
extern crate serde_derive;

use std::env;
use std::sync::Arc;
use std::thread;

use object_space::{ObjectSpace, RangeLookupObjectSpace, TreeObjectSpace, ValueLookupObjectSpace};

fn main() {
    let mut args = env::args();
    let upper_lim = args.nth(1)
        .and_then(|input| input.parse::<i64>().ok())
        .expect("please provide an integer input");

    let thread_count = args.next()
        .and_then(|input| input.parse::<i64>().ok())
        .unwrap_or(4);

    run(upper_lim, thread_count);
}

fn run(upper_lim: i64, thread_count: i64) {
    // setup. add 2 & 3 just because we can
    let mut n = 4;
    let space = Arc::new(TreeObjectSpace::new());
    space.write::<i64>(2);
    space.write::<i64>(3);

    // create 4 worker threads
    for _ in 0..thread_count {
        let space_clone = space.clone();
        thread::spawn(move || {
            check_numbers(space_clone);
        });
    }

    // continue until we hit limit
    while n < upper_lim {
        let max = if n * n < upper_lim { n * n } else { upper_lim };
        let mut current_pos = n as f64;
        let mut end = n;
        let gap = ((max - n) as f64) / (thread_count as f64);

        for _ in 0..thread_count {
            // divide work evenly between threads
            let start = end;
            current_pos = current_pos + gap;
            end = current_pos.round() as i64;

            let clone = space.clone();
            clone.write(Task {
                finished: false,
                start: start,
                end: end,
            });
        }

        // "joining" threads
        for _ in 0..thread_count {
            let clone = space.clone();
            clone.take_by_value::<Task>("finished", &true);
        }
        n = max;
    }

    // for i in space.read_all::<i64>() {
    //     println!("{}", i);
    // }
}

fn check_numbers(space: Arc<TreeObjectSpace>) {
    loop {
        let task = space.take_by_value::<Task>("finished", &false);
        let max = task.end;
        let min = task.start;
        let upper_limit = (max as f64).sqrt() as i64 + 1;
        let primes: Vec<i64> = space
            .read_all_by_range::<i64, _>("", ..upper_limit)
            .collect();
        for i in min..max {
            if primes.iter().all(|prime| i % prime != 0) {
                space.write(i);
            }
        }
        space.write(Task {
            finished: true,
            start: min,
            end: max,
        });
    }
}

#[derive(Serialize, Deserialize)]
struct Task {
    finished: bool,
    start: i64,
    end: i64,
}