obstack 0.1.4

A fast, stack-based allocator, usable for any object
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

#[macro_use]
extern crate bencher;

extern crate obstack;

use std::mem;
use std::rc::Rc;

use bencher::Bencher;

use obstack::{Obstack, Ref};

const CONS_ITERS: usize = 10000;
const CONS_SUM: usize = 49995000;

fn cons_list_with_box(bench: &mut Bencher) {
    enum BoxCons<T> {
        Nil,
        Cell(T, Box<BoxCons<T>>),
    }

    bench.iter(|| {
        let mut tip = BoxCons::Nil;
        for i in 0 .. CONS_ITERS {
            let old_tip = mem::replace(&mut tip, BoxCons::Nil);
            tip = BoxCons::Cell(i, Box::new(old_tip));
        }

        let mut cur_tip = &tip;
        let mut sum = 0;
        while let BoxCons::Cell(ref v, ref cdr) = *cur_tip {
            sum += *v;
            cur_tip = &*cdr;
        }
        assert_eq!(sum, CONS_SUM);
    })
}

fn cons_list_with_rc(bench: &mut Bencher) {
    enum RcCons<T> {
        Nil,
        Cell(T, Rc<RcCons<T>>),
    }

    bench.iter(|| {
        let mut tip = RcCons::Nil;
        for i in 0 .. CONS_ITERS {
            let old_tip = mem::replace(&mut tip, RcCons::Nil);
            tip = RcCons::Cell(i, Rc::new(old_tip));
        }

        let mut cur_tip = &tip;
        let mut sum = 0;
        while let RcCons::Cell(ref v, ref cdr) = *cur_tip {
            sum += *v;
            cur_tip = &*cdr;
        }
        assert_eq!(sum, CONS_SUM);
    })
}

fn cons_list_with_obstack(bench: &mut Bencher) {
    enum RefCons<'a, T: 'a> {
        Nil,
        Cell(T, Ref<'a, RefCons<'a, T>>),
    }

    bench.iter(|| {
        let stack = Obstack::new();

        let mut tip = RefCons::Nil;
        for i in 0 .. CONS_ITERS {
            let old_tip = mem::replace(&mut tip, RefCons::Nil);
            tip = RefCons::Cell(i, stack.push(old_tip));
        }

        let mut cur_tip = &tip;
        let mut sum = 0;
        while let RefCons::Cell(ref v, ref cdr) = *cur_tip {
            sum += *v;
            cur_tip = &*cdr;
        }
        assert_eq!(sum, CONS_SUM);
    })
}

fn str_cons_list_stack(bench: &mut Bencher) {
    enum RefCons<'a, T: 'a> {
        Nil,
        Cell(T, Ref<'a, RefCons<'a, T>>),
    }

    bench.iter(|| {
        let stack = Obstack::new();

        let mut tip = RefCons::Nil;
        for i in 0 .. CONS_ITERS {
            let s = i.to_string();
            let old_tip = mem::replace(&mut tip, RefCons::Nil);
            tip = RefCons::Cell(s, stack.push(old_tip));
        }
    })
}

fn str_cons_list_box(bench: &mut Bencher) {
    enum BoxCons<T> {
        Nil,
        Cell(T, Box<BoxCons<T>>),
    }

    bench.iter(|| {
        let mut tip = BoxCons::Nil;
        for i in 0 .. CONS_ITERS {
            let s = i.to_string();
            let old_tip = mem::replace(&mut tip, BoxCons::Nil);
            tip = BoxCons::Cell(s, Box::new(old_tip));
        }
    })
}

benchmark_group!(benches,
                 cons_list_with_box,
                 cons_list_with_rc,
                 cons_list_with_obstack,
                 str_cons_list_stack,
                 str_cons_list_box);
benchmark_main!(benches);