f30ce1fe97
For host VM code, we use plain reference counting, where cloning increments
the reference count, and dropping decrements it. We can avoid many of the
on-stack increment/decrement operations that typically plague the
performance of reference counting via Rust's ownership and borrowing system.
Moving a `VMExternRef` avoids mutating its reference count, and borrowing it
either avoids the reference count increment or delays it until if/when the
`VMExternRef` is cloned.
When passing a `VMExternRef` into compiled Wasm code, we don't want to do
reference count mutations for every compiled `local.{get,set}`, nor for
every function call. Therefore, we use a variation of **deferred reference
counting**, where we only mutate reference counts when storing
`VMExternRef`s somewhere that outlives the activation: into a global or
table. Simultaneously, we over-approximate the set of `VMExternRef`s that
are inside Wasm function activations. Periodically, we walk the stack at GC
safe points, and use stack map information to precisely identify the set of
`VMExternRef`s inside Wasm activations. Then we take the difference between
this precise set and our over-approximation, and decrement the reference
count for each of the `VMExternRef`s that are in our over-approximation but
not in the precise set. Finally, the over-approximation is replaced with the
precise set.
The `VMExternRefActivationsTable` implements the over-approximized set of
`VMExternRef`s referenced by Wasm activations. Calling a Wasm function and
passing it a `VMExternRef` moves the `VMExternRef` into the table, and the
compiled Wasm function logically "borrows" the `VMExternRef` from the
table. Similarly, `global.get` and `table.get` operations clone the gotten
`VMExternRef` into the `VMExternRefActivationsTable` and then "borrow" the
reference out of the table.
When a `VMExternRef` is returned to host code from a Wasm function, the host
increments the reference count (because the reference is logically
"borrowed" from the `VMExternRefActivationsTable` and the reference count
from the table will be dropped at the next GC).
For more general information on deferred reference counting, see *An
Examination of Deferred Reference Counting and Cycle Detection* by Quinane:
https://openresearch-repository.anu.edu.au/bitstream/1885/42030/2/hon-thesis.pdf
cc #929
Fixes #1804
89 lines
3.4 KiB
Rust
89 lines
3.4 KiB
Rust
//! Support for compiling with Lightbeam.
|
|
|
|
use crate::cache::ModuleCacheDataTupleType;
|
|
use crate::compilation::{Compilation, CompileError};
|
|
use crate::func_environ::FuncEnvironment;
|
|
use crate::CacheConfig;
|
|
use crate::ModuleTranslation;
|
|
// TODO: Put this in `compilation`
|
|
use crate::address_map::{ModuleAddressMap, ValueLabelsRanges};
|
|
use crate::cranelift::{RelocSink, TrapSink};
|
|
use cranelift_codegen::isa;
|
|
use cranelift_entity::{PrimaryMap, SecondaryMap};
|
|
use lightbeam::{CodeGenSession, NullOffsetSink, Sinks};
|
|
|
|
/// A compiler that compiles a WebAssembly module with Lightbeam, directly translating the Wasm file.
|
|
pub struct Lightbeam;
|
|
|
|
impl crate::compilation::Compiler for Lightbeam {
|
|
/// Compile the module using Lightbeam, producing a compilation result with
|
|
/// associated relocations.
|
|
fn compile_module(
|
|
translation: &ModuleTranslation,
|
|
isa: &dyn isa::TargetIsa,
|
|
_cache_config: &CacheConfig,
|
|
) -> Result<ModuleCacheDataTupleType, CompileError> {
|
|
if translation.tunables.debug_info {
|
|
return Err(CompileError::DebugInfoNotSupported);
|
|
}
|
|
|
|
let env = FuncEnvironment::new(
|
|
isa.frontend_config(),
|
|
&translation.module.local,
|
|
&translation.tunables,
|
|
);
|
|
let mut relocations = PrimaryMap::with_capacity(translation.function_body_inputs.len());
|
|
let mut traps = PrimaryMap::with_capacity(translation.function_body_inputs.len());
|
|
let stack_maps = PrimaryMap::with_capacity(translation.function_body_inputs.len());
|
|
|
|
let mut codegen_session: CodeGenSession<_> = CodeGenSession::new(
|
|
translation.function_body_inputs.len() as u32,
|
|
&env,
|
|
lightbeam::microwasm::I32,
|
|
);
|
|
|
|
for (i, function_body) in &translation.function_body_inputs {
|
|
let func_index = translation.module.local.func_index(i);
|
|
|
|
let mut reloc_sink = RelocSink::new(func_index);
|
|
let mut trap_sink = TrapSink::new();
|
|
lightbeam::translate_function(
|
|
&mut codegen_session,
|
|
Sinks {
|
|
relocs: &mut reloc_sink,
|
|
traps: &mut trap_sink,
|
|
offsets: &mut NullOffsetSink,
|
|
},
|
|
i.as_u32(),
|
|
wasmparser::FunctionBody::new(0, function_body.data),
|
|
)
|
|
.map_err(|e| CompileError::Codegen(format!("Failed to translate function: {}", e)))?;
|
|
|
|
relocations.push(reloc_sink.func_relocs);
|
|
traps.push(trap_sink.traps);
|
|
}
|
|
|
|
let code_section = codegen_session
|
|
.into_translated_code_section()
|
|
.map_err(|e| CompileError::Codegen(format!("Failed to generate output code: {}", e)))?;
|
|
|
|
// TODO pass jump table offsets to Compilation::from_buffer() when they
|
|
// are implemented in lightbeam -- using empty set of offsets for now.
|
|
// TODO: pass an empty range for the unwind information until lightbeam emits it
|
|
let code_section_ranges_and_jt = code_section
|
|
.funcs()
|
|
.into_iter()
|
|
.map(|r| (r, SecondaryMap::new()));
|
|
|
|
Ok((
|
|
Compilation::from_buffer(code_section.buffer().to_vec(), code_section_ranges_and_jt),
|
|
relocations,
|
|
ModuleAddressMap::new(),
|
|
ValueLabelsRanges::new(),
|
|
PrimaryMap::new(),
|
|
traps,
|
|
stack_maps,
|
|
))
|
|
}
|
|
}
|