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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
//: Reclaiming memory when it's no longer used.
void test_new_reclaim() {
run(
"def main [\n"
" 10:&:num <- new number:type\n"
" 20:num <- deaddress 10:&:num\n"
" abandon 10:&:num\n"
" 30:&:num <- new number:type\n" // must be same size as abandoned memory to reuse
" 40:num <- deaddress 30:&:num\n"
" 50:bool <- equal 20:num, 40:num\n"
"]\n"
);
CHECK_TRACE_CONTENTS(
// both allocations should have returned the same address
"mem: storing 1 in location 50\n"
);
}
//: When abandoning addresses we'll save them to a 'free list', segregated by size.
//: Before, suppose variable V contains address A which points to payload P:
//: location V contains an alloc-id N
//: location V+1 contains A
//: location A contains alloc-id N
//: location A+1 onwards contains P
//: Additionally, suppose the head of the free list is initially F.
//: After abandoning:
//: location V contains invalid alloc-id -1
//: location V+1 contains 0
//: location A contains invalid alloc-id N
//: location A+1 contains the previous head of free-list F
:(before "End routine Fields")
map<int, int> free_list;
:(before "End Primitive Recipe Declarations")
ABANDON,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "abandon", ABANDON);
:(before "End Primitive Recipe Checks")
case ABANDON: {
if (!inst.products.empty()) {
raise << maybe(get(Recipe, r).name) << "'abandon' shouldn't write to any products in '" << to_original_string(inst) << "'\n" << end();
break;
}
for (int i = 0; i < SIZE(inst.ingredients); ++i) {
if (!is_mu_address(inst.ingredients.at(i)))
raise << maybe(get(Recipe, r).name) << "ingredients of 'abandon' should be addresses, but ingredient " << i << " is '" << to_string(inst.ingredients.at(i)) << '\n' << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case ABANDON: {
for (int i = 0; i < SIZE(current_instruction().ingredients); ++i) {
reagent/*copy*/ ingredient = current_instruction().ingredients.at(i);
canonize(ingredient);
abandon(get_or_insert(Memory, ingredient.value+/*skip alloc id*/1), payload_size(ingredient));
//? cerr << "clear after abandon: " << ingredient.value << '\n';
put(Memory, /*alloc id*/ingredient.value, /*invalid*/-1);
put(Memory, /*address*/ingredient.value+1, 0);
}
break;
}
:(code)
void abandon(int address, int payload_size) {
put(Memory, address, /*invalid alloc-id*/-1);
//? cerr << "abandon: " << address << '\n';
// clear rest of payload
for (int curr = address+1; curr < address+payload_size; ++curr)
put(Memory, curr, 0);
// append existing free list to address
trace(Callstack_depth+1, "abandon") << "saving " << address << " in free-list of size " << payload_size << end();
put(Memory, address+/*skip invalid alloc-id*/1, get_or_insert(Current_routine->free_list, payload_size));
put(Current_routine->free_list, payload_size, address);
}
int payload_size(reagent/*copy*/ x) {
x.properties.push_back(pair<string, string_tree*>("lookup", NULL));
lookup_memory_core(x, /*check_for_null*/false);
return size_of(x)+/*alloc id*/1;
}
:(after "Allocate Special-cases")
if (get_or_insert(Current_routine->free_list, size)) {
trace(Callstack_depth+1, "abandon") << "picking up space from free-list of size " << size << end();
int result = get_or_insert(Current_routine->free_list, size);
trace(Callstack_depth+1, "mem") << "new alloc from free list: " << result << end();
put(Current_routine->free_list, size, get_or_insert(Memory, result+/*skip alloc id*/1));
// clear 'deleted' tag
put(Memory, result, 0);
// clear next pointer
put(Memory, result+/*skip alloc id*/1, 0);
for (int curr = result; curr < result+size; ++curr) {
if (get_or_insert(Memory, curr) != 0) {
raise << maybe(current_recipe_name()) << "memory in free list was not zeroed out: " << curr << '/' << result << "; somebody wrote to us after free!!!\n" << end();
break; // always fatal
}
}
return result;
}
:(code)
void test_new_differing_size_no_reclaim() {
run(
"def main [\n"
" 1:&:num <- new number:type\n"
" 2:num <- deaddress 1:&:num\n"
" abandon 1:&:num\n"
" 3:&:@:num <- new number:type, 2\n" // different size
" 4:num <- deaddress 3:&:@:num\n"
" 5:bool <- equal 2:num, 4:num\n"
"]\n"
);
CHECK_TRACE_CONTENTS(
// no reuse
"mem: storing 0 in location 5\n"
);
}
void test_new_reclaim_array() {
run(
"def main [\n"
" 10:&:@:num <- new number:type, 2\n"
" 20:num <- deaddress 10:&:@:num\n"
" abandon 10:&:@:num\n"
" 30:&:@:num <- new number:type, 2\n" // same size
" 40:num <- deaddress 30:&:@:num\n"
" 50:bool <- equal 20:num, 40:num\n"
"]\n"
);
CHECK_TRACE_CONTENTS(
// both calls to new returned identical addresses
"mem: storing 1 in location 50\n"
);
}
void test_lookup_of_abandoned_address_raises_error() {
Hide_errors = true;
run(
"def main [\n"
" 1:&:num <- new num:type\n"
" 3:&:num <- copy 1:&:num\n"
" abandon 1:&:num\n"
" 5:num/raw <- copy *3:&:num\n"
"]\n"
);
CHECK_TRACE_CONTENTS(
"error: main: address is already abandoned in '5:num/raw <- copy *3:&:num'\n"
);
}
|