threedee-simd

What the C++ (and C) stadards could use is a native type for SIMD vectors. In other words, standardize the GCC vector extensions [0] or some variant thereof. Just adding a new header-only library for vector arithmetic isn't something that needs to be in the language standard (library), there are lots of options for that already (such as glm[1]). I've been using vector extensions for my 3d graphics and physics stuff for years now and it works great. There are some pain points, but it already covers most of what I need. As a bonus, it can be used in plain C and you get all the usual math operators (+, -, /, etc) for free. There are minor incompatibilities between GCC and Clang, but nothing a few #ifdefs won't solve. Here's a quick introduction in a few lines of code: typedef float vec4f __attribute__((vector_size(16))); vec4f a = {

> And wrappers exists in the C++ ecosystem, C programmers are stuck to intrinsics. If you can accept working with GNU extensions that are available in recent-ish GCC and Clang (but not MSVC, not sure about Intel ICC), there are pretty nice vector extensions [0]. With them you can get standard binary operators working for arithmetic (+,-,*,/ etc) and shuffling with __builtin_shuffle. These are CPU independent, the same code compiles neatly to ARM NEON as well as x86 SSE+AVX+FMA. All you need is a typedef with an __attribute__. The vector extension functions don't cover the whole instruction sets but the vector types are compatible with _mm128 and NEON native formats so you can resort to intrinsics when necessary. However, for a lot of SIMD tasks I encounter, just basic arithmetic + shuffles is more than 80% of what I need. If you want to s

> My 4x4 matrix-matrix multiplication algorithm beats Intel's own example You know you can't make such statements without putting your money where your mouth is. We want to see the code. Here's three different 4x4 matrix multiplication routines I've written (the mmmul functions). Depends on your cpu which is fastest. https://github.com/rikusalminen/threedee-simd/blob/master/in...

For some simpler vector stuff that's only C (and basically mostly SSE), I tend to use a personal fork of this for my toy games: https://github.com/rikusalminen/threedee-simd The simplicity is what gets to me: vcross(v1, v2) * v3 (with gcc/clangs vector extensions) Great codegen too.

This made me think of clang/gcc's vector extensions [1], which, together with __builtin_shuffle can be used to get some real "ok" cross-platform (SSE/NEON/...) SIMD code going on. An example of this in usage is [2]. That said you're right, usually the best performance can only be obtained by using really specific instructions. But in my experience, a decent performance increase can be obtained by using the generic vector extensions. Moreover, if you can use the vector extensions for a large part of the code, that means you have to write a lot less platform-specific stuff. I.e.: you increase portability anyway, since now you only have to rewrite 5 out of 20 functions instead of 20/20. Even better, they allow one to write v3 = v1 + v2 instead of v3 = _mm_add_ps(v1,v2). The first one being clearer, more portable (will generate appropriate ad

Btw, exDM69 has a project on github written in this style (I'm almost sure he was in fact referring to this in his earlier posts): https://github.com/rikusalminen/threedee-simd

No, pass by value is a lot faster if the values being passed can be passed in registers, which is the case with SIMD vector values and inline functions. Passing by pointer adds restrictions to what the compiler can optimize and in the worst case you actually end up pushing values to the stack just to read them back to registers in the called function. I recently spent a good deal of time looking at assembly code emitted by compilers when doing SIMD code with C and intrinsics. On GCC and Clang pass by value and force_inline functions gave the best results (at least until link time optimization becomes more mainstream). This was even the case with 4x4 matrix structs, not just SIMD vectors. The speed is not in getting individual functions to work fast, but to let the compiler inline and combine several function calls together and keeping liv

Sum of elements in a 4-vector with SIMD in OpenGL/OpenCL style vector shuffle syntax: vec4 s1 = v + v.yxwz; // s1 = (v.x+v.y, v.y+v.x, v.z+v.w, v.w+v.z) vec4 sum = s1 + s1.zwxy; // sum = sum of v More practical examples, related to 3d graphics: https://github.com/rikusalminen/threedee-simd

Shuffles are what makes SIMD go. It's trivial to make simple repeated math ops done in parallel instead of 4 (SIMD vector width) times sequentially, but shuffling vectors cleverly is where you can get big performance wins. Basic example, doing addition of 4 values in 2 ALU operations: vec4 sum(vec4 v) // return v.x+v.y+v.z+v.w repeated 4 times { vec4 temp = v + v.yxzw; return temp + temp.zwxy; // did I get this right? } Practical examples: https://github.com/rikusalminen/threedee-simd (work in progress) Requires this: http://gruntthepeon.free.fr/ssemath/