One low-level (non-multiplication) optimization could be - but it depends on what your compiler already "knows":

For large data types (depends on the machine and language what "large" is, I use it with C++ on my AMD from __float128  on), I do not pass objects and do not return objects, but work exclusively with references.

int8_t mul_TAB(dvec2& result, dvec2& dsa, dvec2& dsb);
/* return value : success or error Ü/

When passing references, I have control over allocation and deallocation of temporary objects, so one can optimize manually (espcially when using operator overloading).

You might also try putting all temporary objects of your routine in one globally allocated struct and then pass a reference for that. This
saves freeing the stack when exiting the routine - but makes parallelization a bit more tricky.

https://sources.debian.org/src/qd/2.3.22+dfsg.1-3/include/qd/inline.h/#L84 shows you can optimize two_prod (a building block of double-double mul) by using fused-multiply-subtract which avoids the need for splitting magic (btw your split magic number is incorrect for double precision). GLSL has fused-multiply-add (FMA), and you can implement fused-multiply subtract by fms(a, b, c) = fma(a, b, -c).

What's going on here? I can't really track down what's causing the fuzziness.

As registers are the fastest memory, if your language supports side-effect assignments of variables, you might try this:

Instead of

Code: [Select]

c11 = dsa.x * dsb.x;
c21 = a2 * b2 + (a2 * b1 + (a1 * b2 + (a1 * b1 - c11)));

use

Code: [Select]

c21 = a2 * b2 + (a2 * b1 + (a1 * b2 + (a1 * b1 - (c11 = dsa.x * dsb.x))));

That way, the value of c11 is computed in situ at first usage and might then still be in a register rather than having to be fetched from memory (most probably the L1-cache).

If you find a measurable performance gain, I'd be interested in timings. From my (limited) experience working with low-level optimizations of double precision control flows, I have not seen a speed-up (probably I'm interfering with the compiler's optimization capabilities).

Unfortunately GLSL doesn't support side-effect assignments.

You'll have to think of something else.