This is a GPU compiler that made different design choices to LLVM and GCC. Autovectorisation of numerical code has a long and not totally successful history. I

This is a GPU compiler that made different design choices to LLVM and GCC. Autovectorisation of numerical code has a long and not totally successful history. It turns out to be really difficult to determine which instructions are independent enough to pack their arguments into vector registers. Where Cuda differs from autovectorisation is by giving that data independence problem to the programmer. The semantics of the kernel are that the instructions are independent from one another, thus the compiler doesn't need to prove it, and if you've written code where that has unwanted behaviour it's your problem. Where ispc differs from llvm is by immediately mapping that implicitly vectorised code onto vector operations in the compiler front end and then optimising the vector form. llvm keeps the instructions in the scalar style until very near codegen. I think ispc made the better choice here. It makes control flow easier to optimise and basic blocks harder to optimise than llvm's approach and that looks like the right tradeoff. However there's an element of the grass is always greener here and it's an expensive experiment to change llvm over to predicated vector IR to find out whether it is better in practice. Interesting blog series, recommended.