f901946455
By avoiding atomic refcounting for any threadlocal variable, this greatly improves performance. Leads to the performance of threadlocal refcounting being only ~4% behind non-atomic refcounting. The old atomic refcounting could be as far as ~50% behind (though normally 10-20%). This does not enable anything atomic related. If we enable all forms of data loading (List.get, Box.unbox, loading recursive tag) to propagate the atomic flag, this should be a reasonable implementation for roc by default. With propagation, a platform would just set a list to atomic. On load, individual elements would also get set to atomic. We also should probably revert back to threadlocal if an atomic refcount drops to 1. |
||
|---|---|---|
| .. | ||
| bc | ||
| src | ||
| .gitignore | ||
| build.rs | ||
| build.zig | ||
| Cargo.toml | ||
| fuzz_in_tmux.sh | ||
| README.md | ||
| run-tests.sh | ||
| run-wasm-tests.sh | ||
Bitcode for Builtins
Adding a bitcode builtin
To add a builtin:
- Add the function to the relevant module. For
Numbuiltin use it insrc/num.zig, forStrbuiltins usesrc/str.zig, and so on. For anything you add, you must add tests for it! Not only does to make the builtins more maintainable, it's the the easiest way to test these functions on Zig. To run the test, run:zig build test - Make sure the function is public with the
pubkeyword and uses the C calling convention. This is really easy, just addpubandcallconv(.C)to the function declaration like so:pub fn atan(num: f64) callconv(.C) f64 { ... } - In
src/main.zig, export the function. This is also organized by module. For example, for aNumfunction find theNumsection and add:comptime { exportNumFn(num.atan, "atan"); }. The first argument is the function, the second is the name of it in LLVM. - In
compiler/builtins/src/bitcode.rs, add a constant for the new function. This is how we use it in Rust. Once again, this is organized by module, so just find the relevant area and add your new function. - You can now use your function in Rust using
call_bitcode_fninllvm/src/build.rs!
How it works
Roc's builtins are implemented in the compiler using LLVM only. When their implementations are simple enough (e.g. addition), they can be implemented directly in Inkwell.
When their implementations are complex enough, it's nicer to implement them in a higher-level language like Zig, then compile the result to LLVM bitcode, and import that bitcode into the compiler.
Compiling the bitcode happens automatically in a Rust build script at compiler/builtins/build.rs.
Then builtins/src/bitcode/rs statically imports the compiled bitcode for use in the compiler.
You can find the compiled bitcode in target/debug/build/roc_builtins-[some random characters]/out/builtins.bc.
There will be two directories like roc_builtins-[some random characters], look for the one that has an
out directory as a child.
The bitcode is a bunch of bytes that aren't particularly human-readable. If you want to take a look at the human-readable LLVM IR, look at
compiler/builtins/bitcode/builtins.ll
Calling bitcode functions
Use the call_bitcode_fn function defined in llvm/src/build.rs to call bitcode functions.