Skip to content

Commit c00b5d9

Browse files
btzybtzy
committed
Add custom-made test framework for emitted code, fix some bugs in Cheney
1 parent 49813ef commit c00b5d9

35 files changed

+738
-61
lines changed

‎Cargo.toml

+6
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,12 @@ members = [
55
"lib-wasmgen",
66
"lib-ir",
77
"lib-backend-wasm",
8+
"wasm-test-harness",
9+
"wasm-test-driver",
10+
"wasm-test-local",
11+
]
12+
default-members = [
13+
"source-compiler",
814
]
915

1016
[profile.release]

‎lib-backend-wasm/Cargo.toml

+7
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,14 @@ edition = "2018"
1111
[lib]
1212
crate-type = ["lib"]
1313

14+
[features]
15+
wasmtest = ["wasm-test-harness"]
16+
1417
[dependencies]
1518
wasmgen = { path = "../lib-wasmgen" }
1619
ir = { path = "../lib-ir" }
1720
projstd = { path = "../lib-projstd" }
21+
22+
[dependencies.wasm-test-harness]
23+
path = "../wasm-test-harness"
24+
optional = true

‎lib-backend-wasm/src/func.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ use super::gc::HeapManager;
22
/**
33
* Contains stuff related to encoding of function bodies.
44
*/
5-
use super::scratch::Scratch;
5+
use wasmgen::Scratch;
66

77
use super::var_conv::*;
88

‎lib-backend-wasm/src/gc/cheney/copy_children_elements.rs

+5-3
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use super::super::Scratch;
1+
use wasmgen::Scratch;
22

33
// returns the base table element index from which indirect access should be calculated (i.e. the "table offset")
44
// e.g. if we want to access copy_children_$i, we should call_indirect with index = (table_offset+i)
@@ -274,8 +274,10 @@ pub fn make_copy_children_elements(
274274
func_idx
275275
}
276276

277-
let copy_children_table_offset: u32 =
278-
wasm_module.reserve_table_elements(tableidx, ir::NUM_PRIMITIVE_TAG_TYPES as u32);
277+
let copy_children_table_offset: u32 = wasm_module.reserve_table_elements(
278+
tableidx,
279+
(ir::NUM_PRIMITIVE_TAG_TYPES + struct_types.len()) as u32,
280+
);
279281

280282
// Note: some reserved table elements are left uncommitted. They will automatically trap if called at runtime. (If that happens, then the compiler has a bug.)
281283

‎lib-backend-wasm/src/gc/cheney/copy_funcs.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use super::super::Scratch;
1+
use wasmgen::Scratch;
22

33
pub fn make_copy_funcs(
44
wasm_module: &mut wasmgen::WasmModule,

‎lib-backend-wasm/src/gc/cheney/copy_indirect_elements.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use super::super::Scratch;
1+
use wasmgen::Scratch;
22

33
// returns the base table element index from which indirect access should be calculated (i.e. the "table offset")
44
// e.g. if we want to access copy_indirect_$i, we should call_indirect with index = (table_offset+i)
@@ -242,8 +242,8 @@ pub fn make_copy_indirect_elements(
242242
func_idx
243243
}
244244

245-
let copy_indirect_table_offset: u32 =
246-
wasm_module.reserve_table_elements(tableidx, ir::NUM_PRIMITIVE_TAG_TYPES as u32);
245+
let copy_indirect_table_offset: u32 = wasm_module
246+
.reserve_table_elements(tableidx, (ir::NUM_PRIMITIVE_TAG_TYPES + num_structs) as u32);
247247

248248
let no_op_funcidx: wasmgen::FuncIdx = make_no_op_function(wasm_module);
249249
let func_funcidx: wasmgen::FuncIdx =
@@ -267,7 +267,7 @@ pub fn make_copy_indirect_elements(
267267
)
268268
}))
269269
.collect();
270-
assert!(copy_indirect_elements.len() == ir::NUM_PRIMITIVE_TAG_TYPES);
270+
assert!(copy_indirect_elements.len() == ir::NUM_PRIMITIVE_TAG_TYPES + num_structs);
271271
wasm_module.commit_table_elements(tableidx, copy_indirect_table_offset, copy_indirect_elements);
272272
copy_indirect_table_offset
273273
}

‎lib-backend-wasm/src/gc/cheney/do_cheney.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use super::super::Scratch;
1+
use wasmgen::Scratch;
22

33
use super::WASM_PAGE_BITS;
44

@@ -75,8 +75,8 @@ pub fn make_do_cheney(
7575
}
7676
expr_builder.call_indirect(
7777
wasm_module.insert_type_into(wasmgen::FuncType::new(
78-
Box::new([wasmgen::ValType::I32]),
79-
Box::new([wasmgen::ValType::I32]),
78+
Box::new([wasmgen::ValType::I64]),
79+
Box::new([wasmgen::ValType::I64]),
8080
)),
8181
tableidx,
8282
);

‎lib-backend-wasm/src/gc/cheney/mod.rs

+23-13
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
1-
use super::Scratch;
1+
use super::HeapManager;
22
use super::WASM_PAGE_BITS;
33
use super::WASM_PAGE_SIZE;
4-
use super::HeapManager;
4+
use wasmgen::Scratch;
55

66
use crate::var_conv::*;
77

@@ -10,6 +10,9 @@ mod copy_funcs;
1010
mod copy_indirect_elements;
1111
mod do_cheney;
1212

13+
#[cfg(feature = "wasmtest")]
14+
pub mod wasmtest;
15+
1316
/**
1417
* Cheney is a GC implementation that uses Cheney's algorithm.
1518
* At every alternate run of the GC, it will ensure that it has as much free space as used space (not including the swap space).
@@ -130,7 +133,7 @@ impl<'a, 'b, 'c> Cheney<'a, 'b, 'c> {
130133
(*ptr) = I32_MIN | (new_ptr >> 1); // say that we already copied it.
131134
return new_ptr;
132135
}
133-
// `bytes_required`: min number of bytes we want
136+
// `bytes_required`: min number of bytes we want (including the tag!)
134137
// returns nonzero if successfully made enough space, otherwise zero.
135138
fn do_cheney(bytes_required: u32) -> i32 {
136139
if (end_mem_ptr != gc_roots_stack_base_ptr) {
@@ -274,7 +277,9 @@ impl<'a, 'b, 'c> Cheney<'a, 'b, 'c> {
274277
}
275278
}
276279

277-
fn filter_roots(local_roots: &[(ir::VarType, wasmgen::LocalIdx)]) -> Box<[(ir::VarType, wasmgen::LocalIdx)]> {
280+
fn filter_roots(
281+
local_roots: &[(ir::VarType, wasmgen::LocalIdx)],
282+
) -> Box<[(ir::VarType, wasmgen::LocalIdx)]> {
278283
local_roots
279284
.iter()
280285
.cloned()
@@ -286,10 +291,10 @@ impl<'a, 'b, 'c> Cheney<'a, 'b, 'c> {
286291
_ => true,
287292
})
288293
.collect()
289-
}
294+
}
290295

291296
// Helper function used to encode heap allocation.
292-
// `f` should be a function that has net wasm stack [] -> [i32(size)]
297+
// `f` should be a function that has net wasm stack [] -> [i32(size)], it pushes the bytes required (including tag) on the stack.
293298
// net wasm stack: [] -> [i32(ptr)]
294299
fn encode_allocation<F: Fn(&mut wasmgen::ExprBuilder) -> ()>(
295300
&self,
@@ -322,6 +327,7 @@ impl<'a, 'b, 'c> Cheney<'a, 'b, 'c> {
322327
label:
323328
ret = free_mem_ptr; // ret is the value that is left on the stack
324329
free_mem_ptr += size;
330+
ret += 4;
325331
*/
326332

327333
// (end_mem_ptr - free_mem_ptr < size)
@@ -369,6 +375,8 @@ impl<'a, 'b, 'c> Cheney<'a, 'b, 'c> {
369375
encode_size(expr_builder);
370376
expr_builder.i32_add();
371377
expr_builder.global_set(self.free_mem_ptr);
378+
expr_builder.i32_const(4);
379+
expr_builder.i32_add();
372380
}
373381
}
374382

@@ -396,7 +404,7 @@ impl<'a, 'b, 'c> HeapManager for Cheney<'a, 'b, 'c> {
396404
self.encode_allocation(
397405
|expr_builder| {
398406
// net wasm stack: [] -> [i32(size)]
399-
expr_builder.i32_const(size as i32);
407+
expr_builder.i32_const((size + 4) as i32);
400408
},
401409
local_roots,
402410
scratch,
@@ -452,9 +460,9 @@ impl<'a, 'b, 'c> HeapManager for Cheney<'a, 'b, 'c> {
452460
match ir_vartype {
453461
ir::VarType::String => {
454462
let localidx_mem_size: wasmgen::LocalIdx = scratch.push_i32();
455-
// Algorithm: mem_size = ((num_bytes + 7) & (~3)) // equivalent to (4 + round_up_to_multiple_of_4(num_bytes))
463+
// Algorithm: mem_size = ((num_bytes + 11) & (~3)) // equivalent to (4 + round_up_to_multiple_of_4(num_bytes))
456464
// net wasm stack: [i32(num_bytes)] -> []
457-
expr_builder.i32_const(7);
465+
expr_builder.i32_const(11);
458466
expr_builder.i32_add();
459467
expr_builder.i32_const(-4); // equivalent to (~3) in two's complement
460468
expr_builder.i32_and();
@@ -501,8 +509,9 @@ impl<'a, 'b, 'c> HeapManager for Cheney<'a, 'b, 'c> {
501509
scratch: &mut Scratch,
502510
expr_builder: &mut wasmgen::ExprBuilder,
503511
) -> Self::RootsStackHandle {
504-
let filtered_roots: Box<[(ir::VarType, wasmgen::LocalIdx)]> = Self::filter_roots(local_roots);
505-
512+
let filtered_roots: Box<[(ir::VarType, wasmgen::LocalIdx)]> =
513+
Self::filter_roots(local_roots);
514+
506515
// if there are no roots to add, then we don't need to load the gc_roots_stack_ptr.
507516
// net wasm stack: [] -> []
508517
if !filtered_roots.is_empty() {
@@ -540,8 +549,9 @@ impl<'a, 'b, 'c> HeapManager for Cheney<'a, 'b, 'c> {
540549
scratch: &mut Scratch,
541550
expr_builder: &mut wasmgen::ExprBuilder,
542551
) {
543-
let filtered_roots: Box<[(ir::VarType, wasmgen::LocalIdx)]> = Self::filter_roots(local_roots);
544-
552+
let filtered_roots: Box<[(ir::VarType, wasmgen::LocalIdx)]> =
553+
Self::filter_roots(local_roots);
554+
545555
if !filtered_roots.is_empty() {
546556
let localidx_gc_roots_stack_ptr = scratch.push_i32();
547557

‎lib-backend-wasm/src/gc/cheney/wasmtest.rs

+79
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,79 @@
1+
use super::*;
2+
use wasm_test_harness::*;
3+
4+
pub fn wasmtest<C: TestContext>(c: &mut C) {
5+
c.add_test("basic test", |code_builder, wasm_module, t| {
6+
/*
7+
In this test we will create a Cheney with the initial size (1MiB usuable size),
8+
and add 32768 copies of 28-byte structs (which will exactly hit the maximum size (including 4-byte tag)).
9+
The memory should be located at increasing order at 32-byte offsets.
10+
Then add 32768 copies again (without holding references to the old memory).
11+
And do it a another time... for 8 times total.
12+
The memory should not grow, and it should be located as expected.
13+
*/
14+
// 28 bytes struct
15+
let struct_types: [Box<[ir::VarType]>; 1] = [Box::new([
16+
ir::VarType::Any,
17+
ir::VarType::Any,
18+
ir::VarType::Boolean,
19+
])];
20+
let struct_field_byte_offsets: [Box<[u32]>; 1] = [Box::new([0, 12, 24])];
21+
let struct_sizes: [u32; 1] = [28];
22+
let cheney = Cheney::new(
23+
&struct_types,
24+
&struct_field_byte_offsets,
25+
&struct_sizes,
26+
wasm_module.add_unbounded_memory(MEM_INITIAL_HEAP_SIZE),
27+
0,
28+
MEM_INITIAL_HEAP_SIZE,
29+
wasm_module,
30+
);
31+
32+
let (locals_builder, expr_builder) = code_builder.split();
33+
let mut scratch = Scratch::new(locals_builder);
34+
35+
// add 32768 structs, ensuring that they are at proper positions
36+
{
37+
let localidx_i = scratch.push_i32();
38+
39+
// i = 0;
40+
expr_builder.i32_const(0);
41+
expr_builder.local_set(localidx_i);
42+
43+
// do {..} while(..);
44+
expr_builder.loop_(&[]);
45+
{
46+
// ret = new struct$0();
47+
cheney.encode_fixed_allocation(
48+
ir::VarType::StructT { typeidx: 0 },
49+
&[],
50+
&mut scratch,
51+
expr_builder,
52+
);
53+
54+
// assert(ret == i * 32 + 4); // this is where the Cheney GC stores the memory.
55+
expr_builder.local_get(localidx_i);
56+
expr_builder.i32_const(32);
57+
expr_builder.i32_mul();
58+
expr_builder.i32_const(4);
59+
expr_builder.i32_add();
60+
t.i32_assert_eq(&mut scratch, expr_builder);
61+
62+
// i = i + 1;
63+
expr_builder.local_get(localidx_i);
64+
expr_builder.i32_const(1);
65+
expr_builder.i32_add();
66+
expr_builder.local_set(localidx_i);
67+
68+
// while (i < 32768);
69+
expr_builder.local_get(localidx_i);
70+
expr_builder.i32_const(32768);
71+
expr_builder.i32_lt_u();
72+
expr_builder.br_if(0);
73+
}
74+
expr_builder.end();
75+
76+
scratch.pop_i32();
77+
}
78+
});
79+
}

‎lib-backend-wasm/src/gc/leaky.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
1-
use super::Scratch;
21
use super::WASM_PAGE_BITS;
32
use super::WASM_PAGE_SIZE;
3+
use wasmgen::Scratch;
44

55
/**
66
* Leaky is a GC implementation that does not clean up anything. It simply allocates more memory every time a request is made.

‎lib-backend-wasm/src/gc/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ pub mod leaky;
44
use crate::WASM_PAGE_SIZE;
55
const WASM_PAGE_BITS: u32 = WASM_PAGE_SIZE.trailing_zeros();
66

7-
use crate::scratch::Scratch;
7+
use wasmgen::Scratch;
88

99
/**
1010
* Trait that all heap managers (i.e. garbage collectors) should implement.

‎lib-backend-wasm/src/lib.rs

+7-1
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,6 @@ use wasmgen;
5959

6060
mod func;
6161
mod gc;
62-
mod scratch;
6362
mod var_conv;
6463

6564
use gc::leaky::Leaky;
@@ -68,6 +67,8 @@ use gc::HeapManager;
6867
use projstd::iter::*;
6968
use projstd::tuple::*;
7069

70+
use wasmgen::Scratch;
71+
7172
const IR_FUNCIDX_TABLE_OFFSET: u32 = 0; // If ir::FuncIdx == x, then wasmgen::TableIdx == IR_FUNCIDX_TABLE_OFFSET + x as u32
7273

7374
const WASM_PAGE_SIZE: u32 = 65536;
@@ -165,3 +166,8 @@ fn encode_mem(globals_num_pages: u32, wasm_module: &mut wasmgen::WasmModule) ->
165166
wasm_module
166167
.add_unbounded_memory(MEM_STACK_SIZE + globals_num_pages + Leaky::initial_heap_size())
167168
}
169+
170+
#[cfg(feature = "wasmtest")]
171+
pub fn wasmtest<C: wasm_test_harness::TestContext>(c: &mut C) {
172+
gc::cheney::wasmtest::wasmtest(c);
173+
}

‎lib-backend-wasm/src/var_conv.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use super::scratch::Scratch;
1+
use wasmgen::Scratch;
22

33
// stores a ir variable from the protected stack to local variable(s)
44
// net wasm stack: [<ir_source_vartype>] -> []

‎lib-projstd/src/searchablevec.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
use std::cmp::Eq;
2+
use std::collections::hash_map::Entry;
23
use std::collections::HashMap;
34
use std::hash::Hash;
45
/**
@@ -24,20 +25,19 @@ impl<T: Eq + Hash + Clone> SearchableVec<T> {
2425
* Otherwise returns the index of the existing element
2526
*/
2627
pub fn insert(&mut self, value: T) -> usize {
27-
let curr_len = self.vec.len();
28-
let new_idx = *(self.index.entry(value.clone()).or_insert(curr_len));
29-
if new_idx == curr_len {
30-
self.vec.push(value);
28+
match self.index.entry(value) {
29+
Entry::Occupied(occupied_entry) => *(occupied_entry.get()),
30+
Entry::Vacant(vacant_entry) => {
31+
let curr_len = self.vec.len();
32+
let value_cloned = vacant_entry.key().clone();
33+
vacant_entry.insert(curr_len);
34+
self.vec.push(value_cloned);
35+
curr_len
36+
}
3137
}
32-
return 0;
3338
}
3439
pub fn insert_copy(&mut self, value: &T) -> usize {
35-
let curr_len = self.vec.len();
36-
let new_idx = *(self.index.entry(value.clone()).or_insert(curr_len));
37-
if new_idx == curr_len {
38-
self.vec.push(value.clone());
39-
}
40-
return 0;
40+
self.insert(value.clone())
4141
}
4242
pub fn vec(&self) -> &Vec<T> {
4343
&self.vec

‎lib-wasmgen/src/lib.rs

+2
Original file line numberDiff line numberDiff line change
@@ -7,9 +7,11 @@ use std::option::Option;
77
use std::vec::Vec;
88

99
pub mod codewriter;
10+
pub mod scratch;
1011
pub mod serialize;
1112
pub mod write;
1213
pub use codewriter::*;
14+
pub use scratch::*;
1315
pub use serialize::*;
1416
pub use write::*;
1517

0 commit comments

Comments
 (0)