blob: 5ef2df221a6de25fa03f71765ab4ac8fa1f9ec94 (
plain) (
blame)
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
|
// repeated allocations of a size known at compile time: new(T) of a struct of
// numbers, and new(n) with a constant n. each pass of the loop makes an object
// and frees it at the end of the block, so the allocator should hand back the
// block it just took. the sums prove the objects were zeroed every time.
struct point { int x, y; };
struct line { point* a; int len; };
fn loop_leaf(int n) {
let total = 0;
for (int i = 0; i < n; i++) {
point* p = new(point);
total += p.x + p.y; // zero from the allocator, every pass
p.x = i; p.y = 2;
}
return total;
}
fn loop_words(int n) {
let total = 0, i = 0;
while (i < n) {
let w = new(6);
total += w[0] + w[5];
w[0] = 7; w[5] = 9;
i++;
}
return total;
}
fn loop_owner(int n) {
let i = 0, total = 0;
while (i < n) {
line* l = new(line);
l.a = new(point);
l.a.x = i;
total += l.a.x + l.len;
i++;
}
return total;
}
fn main() {
let before = live_objects();
put_n(loop_leaf(50000)); put_c(' ');
put_n(loop_words(50000)); put_c(' ');
put_n(loop_owner(1000)); put_c(' ');
put_n(live_objects() - before); put_c(10);
return 0;
}
|
