Crate compiler_interrupts

compiler-interrupts provides Rust API for the Compiler Interrupts library. Check out the Compiler Interrupts main repository for more info.

Requirements

• Rust 1.45.0 or later is required. Due to the usage of #[thread_local] unstable feature, this package currently requires nightly Rust.

Getting started

Add this to your Cargo.toml.

[dependencies]
compiler-interrupts = "1.0"

Register the Compiler Interrupts handler in your program.

#![feature(thread_local)]

#[thread_local]
#[allow(non_upper_case_globals)]
static mut prev_ic: i64 = 0;

fn interrupt_handler(ic: i64) {
    let interval;
    unsafe {
        // save the last interval
        interval = ic - prev_ic;

        // update the instruction count
        prev_ic = ic;
    }
    if interval < 0 {
        panic!("IR interval was negative")
    }
    println!(
        "CI @ {}: last interval = {} IR",
        std::thread::current().name().expect("invalid thread name"),
        interval
    );
}

fn main() {
    // register the CI handler for 1000 IR and cycles interval
    unsafe {
        compiler_interrupts::register(1000, 1000, interrupt_handler);
    }

    // do something compute-intensive
    for _ in 0..100 {}

    println!("i can add an unsafe block, right?")
}

If you have cargo-compiler-interrupts installed, you can now run cargo build-ci to start the compilation and integration. Check out the documentation for more info about the API.

Contribution

All issue reports, feature requests, pull requests and GitHub stars are welcomed and much appreciated.

Author

Quan Tran (@quanshousio)

Acknowledgements

• My advisor Jakob Eriksson for the enormous support for this project.
• Nilanjana Basu for implementing the Compiler Interrupts.

License

compiler-interrupts is available under the MIT license. See the LICENSE file for more info.

Functions

deregister^⚠

De-registers the handler for Compiler Interrupts.

deregister_disable_hook^⚠

De-registers the hook when disabling Compiler Interrupts.

deregister_enable_hook^⚠

De-registers the hook when enabling Compiler Interrupts.

disable^⚠

Disables Compiler Interrupts.

enable^⚠

Enables Compiler Interrupts.

instr_disable^⚠

Disables the probe instrumentation.

instr_enable^⚠

Enables the probe instrumentation.

register^⚠

Registers a handler for Compiler Interrupts.

register_disable_hook^⚠

Registers a hook when disabling Compiler Interrupts.

register_enable_hook^⚠

Registers a hook when enabling Compiler Interrupts.