HolyJit: A New Hope

In the mean time, the performance for Firefox' Tree Style Tabs plugin have gone downhill. I'd be interested to know more about new browsers that put tabs on the side by default.

Do they use tree style tabs though?

Because trying to enumerate everything that could possibly be relevant to your work probably misses some valuable and relevant things.

1) Not work related typically really means “not whitelisted” so often sites that would be beneficial to the employee completing their jobs will also be inaccessible.

2) Since everyone has smartphones they will just access the same sites with their personal device which is more time-consuming.

I'm truly sorry that GitHub is blocked where you work. Here's the pitch, taken from the repo's README [1]:

1) holyjit aims to be easy:

> As a user, this implies that to inline a function in JIT compiled code, one just need to annotate it with the jit! macro.

    jit!{
        fn eval(script: &Script, args: &[Value]) -> Result
        = eval_impl
        in script.as_ref()
    }

    fn eval_impl(script: &Script, args: &[Value]) -> Result {
        // ...
        // ... A few hundred lines or ordinary Rust code later ...
        // ...
    }

    fn main() {
        let script = ...;
        let args = ...;
        // Call it as any ordinary function.
        let res = eval(&script, &args);
        println!("Result: {}", res);
    }

> Thus, you basically have to write an interpreter, and annotate it properly to teach the JIT compiler what can be optimized by the compiler.

> No assembly knowledge is required to start instrumenting your code to make it available to the JIT compiler set of known functions.

2) holyjit aims to be safe:

> Security issues from JIT compilers are coming from: > * Duplication of the runtime into a set of MacroAssembler functions. > * Correctness of the compiler optimization.

> As HolyJiy extends the Rust compiler to extract the effective knowledge of the compiler, there is no more risk of having correctness issues caused by the duplication of code.

> Moreover, the code which is given to the JIT compiler is as safe as the code users wrote in the Rust language.

> As HolyJit aims at being a JIT library which can easily be embedded into other projects, correctness of the compiler optimizations should be caught by the community of users and fuzzers. Thus leaving less bugs for you to find out.

3) holyjit aims to be fast

> Fast is a tricky question when dealing with a JIT compiler, as the cost of the compilation is part of the equation.

> HolyJit aims at reducing the start-up time, based on annotation made out of macros, to guide the early tiers of the compilers for unrolling loops and generating inline caches.

> For final compilation tiers, it uses special types/traits to wrap the data in order to instrument and monitor the values which are being used, such that guard can later be converted into constraints.

> Moreover, the code which is given to the JIT compiler is as safe as the code users wrote in the Rust language.

> As HolyJit aims at being a JIT library which can easily be embedded into other projects, correctness of the compiler optimizations should be caught by the community of users and fuzzers. Thus leaving less bugs for you to find out.

[1]: https://github.com/nbp/holyjit/blob/master/README.md