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
|
// xfail-win32
use std;
import tuple::{first, second};
import std::list::{list, cons, nil};
import std::time::precise_time_s;
fn main() {
let (repeat, depth) = if os::getenv("RUST_BENCH").is_some() {
(50, 1000)
} else {
(10, 10)
};
run(repeat, depth);
}
fn run(repeat: int, depth: int) {
for iter::repeat(repeat as uint) {
#debug("starting %.4f", precise_time_s());
do task::try {
recurse_or_fail(depth, none)
};
#debug("stopping %.4f", precise_time_s());
}
}
type nillist = list<()>;
// Filled with things that have to be unwound
enum st {
st_({
box: @nillist,
unique: ~nillist,
fn_box: fn@() -> @nillist,
fn_unique: fn~() -> ~nillist,
tuple: (@nillist, ~nillist),
vec: ~[@nillist],
res: r
})
}
class r {
let _l: @nillist;
new(l: @nillist) { self._l = l; }
drop {}
}
fn recurse_or_fail(depth: int, st: option<st>) {
if depth == 0 {
#debug("unwinding %.4f", precise_time_s());
fail;
} else {
let depth = depth - 1;
let st = alt st {
none {
st_({
box: @nil,
unique: ~nil,
fn_box: fn@() -> @nillist { @nil::<()> },
fn_unique: fn~() -> ~nillist { ~nil::<()> },
tuple: (@nil, ~nil),
vec: ~[@nil],
res: r(@nil)
})
}
some(st) {
let fn_box = st.fn_box;
let fn_unique = st.fn_unique;
st_({
box: @cons((), st.box),
unique: ~cons((), @*st.unique),
fn_box: fn@() -> @nillist { @cons((), fn_box()) },
fn_unique: fn~() -> ~nillist { ~cons((), @*fn_unique()) },
tuple: (@cons((), first(st.tuple)),
~cons((), @*second(st.tuple))),
vec: st.vec + ~[@cons((), st.vec.last())],
res: r(@cons((), st.res._l))
})
}
};
recurse_or_fail(depth, some(st));
}
}
|
