目录
Chris Fallin

Cranelift: box a few fields in MachBuffer/MachBufferFinalized to avoid memmoves. (#14300)

  • Cranelift: box a few fields in MachBuffer/MachBufferFinalized to avoid memmoves.

Issue initially raised by alexcrichton at last week’s Cranelift meeting: we have SmallVecs that are (ironically) quite large in MachBuffer, and the “finalized” split causes significant memmoves when the MachBufferFinalized is put together with pieces of the MachBuffer during finalization.

The initial design intent (six years ago!) was to avoid allocations for the common case of a small function compilation: a MachBuffer would contain enough buffer space for the machine code + metadata for anything up to, say, a kilobyte of machine code. But that benefit was lost when we moved to the “finalization” design.

The split itself is necessary: it captures an algorithmic finalization step, and that data that we have before and after differs. (Specifically, we translate label indices into buffer offsets inside of several record types; those are different types, we shouldn’t type-pun them, and we have to pass through all the data anyway so those vecs are not a simple bulk data move.)

However many of the metadata arrays are simple passthroughs: for example, the machine-code buffer itself.

This is a simple/mechanical refactor that puts fields that don’t change type during finalization in a MachBufferInner, puts that in a Box, and then holds it from either the MachBuffer or MachBufferFinalized. Thus the finalization can move one pointer over instead of kilobytes of buffers.

On a quick Sightglass run with default.suite, I see one benchmark’s compilation time move:

compilation :: cycles :: spidermonkey-markdown

    Δ = 16405327.75 ± 16285800.71 (confidence = 99%)

    modified.so is 1.00x to 1.02x faster than base.so!

    ┌────────────┬────────────┬───────────────┬────────────┬─────────────┐
    │ Min        │ Max        │ Mean          │ Median     │ Engine      │
    ├────────────┼────────────┼───────────────┼────────────┼─────────────┤
    │ 1258771422 │ 1408382397 │ 1333799348.93 │ 1343472392 │ base.so     │
    ├────────────┼────────────┼───────────────┼────────────┼─────────────┤
    │ 1254241200 │ 1405715279 │ 1317394021.18 │ 1313587478 │ modified.so │
    └────────────┴────────────┴───────────────┴────────────┴─────────────┘

so a mean ~1% speedup.

There is definitely further work to do to try to reuse allocations across compilations by holding something in the Context, as we do with e.g. regalloc2::Ctx. The complication there is that MachBuffer is monomorphized on I because it holds I::LabelUses and those can differ between architectures; and cranelift_codegen::Context can be used to recompile for different ISAs with each compile invocation, so the actual type can necessarily differ between invocations. I suppose we could collapse all individual LabelUse enums into one shared one that has ISA-prefixed names for each arm, then remove the monomorphization in MachBuffer; but I’ll leave that for future work.

  • Refactor: remove most typestate and T/FinalizedT distinctions in MachBuffer.

Instead, create in-place “enums” (bitpacked sum-types) and patch in place as we finalize. Allows most fields of MachBuffer to remain in-situ from initial emission through finalization and stencil-to-absolute conversion.

  • Fix comment.

  • doc-comment formatting fix

  • Fix no-default-features build

22小时前17164次提交

wasmtime

A standalone runtime for WebAssembly

A Bytecode Alliance project

build status zulip chat supported rustc stable Documentation Status

Guide | Contributing | Website | Chat

Installation

The Wasmtime CLI can be installed on Linux and macOS (locally) with a small install script:

curl https://wasmtime.dev/install.sh -sSf | bash

This script installs into $WASMTIME_HOME (defaults to $HOME/.wasmtime), and executable is placed in $WASMTIME_HOME/bin.

After running the install script above, follow the on-screen instructions.

Windows or otherwise interested users can download installers and binaries directly from the GitHub Releases page.

For additional installation options, refer to the online book CLI installation page.

Documentation on Wasmtime’s currently supported versions can be found in the online book documentation.

Example

If you’ve got the Rust compiler installed then you can take some Rust source code:

fn main() {
    println!("Hello, world!");
}

and compile it into a WebAssembly component with:

rustup target add wasm32-wasip2
rustc hello.rs --target wasm32-wasip2

Once compiled, you can run your component:

wasmtime hello.wasm

You should see the following output:

Hello, world!

(Note: make sure you installed Rust using the rustup method in the official instructions above, and do not have a copy of the Rust toolchain installed on your system in some other way as well (e.g. the system package manager). Otherwise, the rustup target add... command may not install the target for the correct copy of Rust.)

Features

  • Fast. Wasmtime is built on the optimizing Cranelift code generator to quickly generate high-quality machine code either at runtime or ahead-of-time. Wasmtime is optimized for efficient instantiation, low-overhead calls between the embedder and wasm, and scalability of concurrent instances.

  • Secure. Wasmtime’s development is strongly focused on correctness and security. Building on top of Rust’s runtime safety guarantees, each Wasmtime feature goes through careful review and consideration via an RFC process. Once features are designed and implemented, they undergo 24/7 fuzzing donated by Google’s OSS Fuzz. As features stabilize they become part of a release, and when things go wrong we have a well-defined security policy in place to quickly mitigate and patch any issues. We follow best practices for defense-in-depth and integrate protections and mitigations for issues like Spectre. Finally, we’re working to push the state-of-the-art by collaborating with academic researchers to formally verify critical parts of Wasmtime and Cranelift.

  • Configurable. Wasmtime uses sensible defaults, but can also be configured to provide more fine-grained control over things like CPU and memory consumption. Whether you want to run Wasmtime in a tiny environment or on massive servers with many concurrent instances, we’ve got you covered.

  • WASI. Wasmtime supports a rich set of APIs for interacting with the host environment through the WASI standard.

  • Standards Compliant. Wasmtime passes the official WebAssembly test suite, implements the official C API of wasm, and implements future proposals to WebAssembly as well. Wasmtime developers are intimately engaged with the WebAssembly standards process all along the way too.

Language Support

You can use Wasmtime from a variety of different languages through embeddings of the implementation.

Languages supported by the Bytecode Alliance:

Languages supported by the community:

Documentation

📚 Read the Wasmtime guide here! 📚

The wasmtime guide is the best starting point to learn about what Wasmtime can do for you or help answer your questions about Wasmtime. If you’re curious in contributing to Wasmtime, it can also help you do that!


It’s Wasmtime.

关于
202.8 MB
邀请码
    Gitlink(确实开源)
  • 加入我们
  • 官网邮箱:gitlink@ccf.org.cn
  • QQ群
  • QQ群
  • 公众号
  • 公众号

版权所有:中国计算机学会技术支持:开源发展技术委员会
京ICP备13000930号-9 京公网安备 11010802047560号