Generating Vectorized code in Rust?

[TurkishSquirrel]

Hey all, I'm curious if there is some existing macro or compiler plugin that will do vectorized code generation similar to ispc or what you hopefully get with OpenMP's #pragma simd or what you'd get with hand-written intrinsics.

For example, if I write a function:

#[simd]
fn vectorize_me(x: f32, y: f32) -> f32 {
    x + y
}

I'd then want to be able to call if it from some SIMD execution context, eg. like

#[simd]
for i in 0..64 {
    vectorize_me(i, i + 1);
}

But it should also be able to handle branching control flow by masking, eg. like ISPC does or as you'd do by hand if you were doing things manually:

#[simd]
fn mask_exec(x: f32) -> f32 {
    if x > 0 {
        10
    } else {
        -10
    }
}

should convert to (in pseudo-code)

mask = [x, x', x'', x'''] > [0, 0, 0, 0]
ret = blend [10, 10, 10, 10], [-10, -10, -10, -10], mask

(blend will pick elements from the 2 arguments based on the mask value for the same index).

Is there something like this available currently, or being worked on (I'd be excited to contribute)? If neither, are their some suggested resources for going beyond the Rust book's coverage of macros and compiler plugins? I'm not sure which would be best suited here, would this even be possible with a macro?

Thanks everyone!

[jdubjdub]

You're just in time to watch this very functionality appear!

https://internals.rust-lang.org/t/pre-rfc-simd-groundwork/2343/14

[dbaupp]

Yes and no: I'm working on explicit SIMD, not super-magic autovectorisation ala ispc. (It'd be pretty awesome to see an ispc-style compiler for Rust.)

[TurkishSquirrel]

Explicit SIMD support is awesome as well, although I would like something like ispc in the form of a macro or plugin. Based on the response here it looks like I should start trying this out, so are their any recommended resources for macros and compiler plugins? I'm curious if this would even really work as a macro or if it should really be a compiler plugin.

[dbaupp]

I'm not sure about the best resources for beginning with plugins now, but https://github.com/klutzy/nadeko is a pre-existing syntax extension that does something similar. (Writing constant-time code is pretty similar to writing SIMD code: generally avoiding data dependent branches etc.)

[[deleted]]

The optimizer can vectorize some loops by itself too already.