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
|
use crate::value::Value;
use std::error::Error;
pub const NUM_LOCALS: usize = 256;
#[derive(Debug)]
pub struct Heap {
pub buf: Vec<u64>,
first_active: bool,
free_ptr: usize,
last_live: usize,
pub locals: [Value; NUM_LOCALS],
}
impl Heap {
pub fn new() -> Heap {
Heap {
buf: Vec::new(),
first_active: true,
free_ptr: 0,
last_live: 0,
locals: [Value(0); NUM_LOCALS],
}
}
fn forwarded(&self, p: usize) -> bool {
let Some(q) = Value(self.buf[p]).to_pointer() else {
return false;
};
self.first_active == (q < self.buf.len() / 2)
}
fn alloc_size(&self, p: usize) -> usize {
usize::try_from(self.buf[p - 1] >> 1).expect("using 32 bits in 2024 LULW")
}
fn simple_alloc(&mut self, size: usize) -> usize {
self.buf[self.free_ptr] = u64::try_from(size).expect("how even??") << 1;
let p = self.free_ptr + 1;
self.free_ptr += size + 1;
p
}
fn process_gc_value(&mut self, val: Value) -> Value {
let Some(p) = val.to_pointer() else {
return val;
};
if self.forwarded(p) {
return Value(self.buf[p]);
}
let size = self.alloc_size(p);
// Allocate space in the new buffer.
let q = self.simple_alloc(size);
// Write forwarding pointer.
let first_val = Value(self.buf[p]);
self.buf[p] = Value::from_pointer(q).repr();
// Copy values, recursively modifying pointers.
self.buf[q] = self.process_gc_value(first_val).repr();
for i in 1..size {
self.buf[q + i] = self.process_gc_value(Value(self.buf[p + i])).repr();
}
Value::from_pointer(q)
}
fn size(&self) -> usize {
if self.first_active {
self.free_ptr
} else {
self.free_ptr - self.buf.len() / 2
}
}
fn collect_garbage(&mut self) {
if self.size() < 2 * self.last_live {
return;
}
// Swap the heaps.
if self.first_active {
self.first_active = false;
self.free_ptr = self.buf.len() / 2;
} else {
self.first_active = true;
self.free_ptr = 0;
}
for i in 0..self.locals.len() {
self.locals[i] = self.process_gc_value(self.locals[i]);
}
self.last_live = self.size();
}
fn more_space(&mut self, size_hint: usize) {
let mut new_size = self.buf.len() / 2;
if new_size == 0 {
new_size = 1;
}
while new_size < self.free_ptr + size_hint {
new_size *= 2;
}
self.first_active = true;
self.buf.resize(new_size * 2, 0);
}
pub fn alloc(&mut self, size: i64) -> Result<usize, Box<dyn Error>> {
if size <= 0 {
return Err(Box::from("alloc of zero size"));
}
let usize = usize::try_from(size).expect("32 bits in 2024 LULW");
self.collect_garbage();
if self.size() + usize + 1 > self.buf.len() / 2 {
self.more_space(usize + 1);
}
let p = self.simple_alloc(usize::try_from(size).expect("using 32 bits in 2024 LULW"));
for i in 0..usize {
self.buf[p + i] = 0;
}
Ok(p)
}
pub fn peek(&self, p: usize) -> Result<Value, Box<dyn Error>> {
if p >= self.buf.len() {
return Err(Box::from("peek: out of range"));
}
Ok(Value(self.buf[p]))
}
pub fn poke(&mut self, p: usize, val: Value) -> Result<(), Box<dyn Error>> {
if p >= self.buf.len() {
return Err(Box::from("poke: out of range"));
}
self.buf[p] = val.repr();
Ok(())
}
}
|
