Efficient 4×4 matrix multiplication (C vs assembly)

by

4×4 matrix multiplication is 64 multiplications and 48 additions. Using SSE this can be reduced to 16 multiplications and 12 additions (and 16 broadcasts). The following code will do this for you. It only requires SSE (#include <xmmintrin.h>). The arrays A, B, and C need to be 16 byte aligned. Using horizontal instructions such as hadd (SSE3) and dpps (SSE4.1) will be less efficient (especially dpps). I don’t know if loop unrolling will help.

void M4x4_SSE(float *A, float *B, float *C) {
    __m128 row1 = _mm_load_ps(&B[0]);
    __m128 row2 = _mm_load_ps(&B[4]);
    __m128 row3 = _mm_load_ps(&B[8]);
    __m128 row4 = _mm_load_ps(&B[12]);
    for(int i=0; i<4; i++) {
        __m128 brod1 = _mm_set1_ps(A[4*i + 0]);
        __m128 brod2 = _mm_set1_ps(A[4*i + 1]);
        __m128 brod3 = _mm_set1_ps(A[4*i + 2]);
        __m128 brod4 = _mm_set1_ps(A[4*i + 3]);
        __m128 row = _mm_add_ps(
                    _mm_add_ps(
                        _mm_mul_ps(brod1, row1),
                        _mm_mul_ps(brod2, row2)),
                    _mm_add_ps(
                        _mm_mul_ps(brod3, row3),
                        _mm_mul_ps(brod4, row4)));
        _mm_store_ps(&C[4*i], row);
    }
}

More Related Contents:

  1. Efficient 4×4 matrix vector multiplication with SSE: horizontal add and dot product – what’s the point?
  2. Why does mulss take only 3 cycles on Haswell, different from Agner’s instruction tables? (Unrolling FP loops with multiple accumulators)
  3. print a __m128i variable
  4. Is it safe to read past the end of a buffer within the same page on x86 and x64?
  5. What is the instruction that gives branchless FP min and max on x86?
  6. What is the fastest way to convert float to int on x86
  7. Fastest Implementation of the Natural Exponential Function Using SSE
  8. Do I get a performance penalty when mixing SSE integer/float SIMD instructions
  9. Getting max value in a __m128i vector with SSE?
  10. How to determine if memory is aligned?
  11. Very fast memcpy for image processing?
  12. Most insanely fast way to convert 9 char digits into an int or unsigned int
  13. Produce loops without cmp instruction in GCC
  14. Bit popcount for large buffer, with Core 2 CPU (SSSE3)
  15. Fastest way to do horizontal SSE vector sum (or other reduction)
  16. Rounding up to next power of 2
  17. Why is there no “sub rsp” instruction in this function prologue and why are function parameters stored at negative rbp offsets?
  18. Why are global variables in x86-64 accessed relative to the instruction pointer?
  19. Unexpected exec permission from mmap when assembly files included in the project
  20. Why is the value of EDX overwritten when making call to printf?
  21. Why doesn’t GCC optimize structs?
  22. Alloca implementation
  23. Why is memcmp so much faster than a for loop check?
  24. C++ error: ‘_mm_sin_ps’ was not declared in this scope
  25. Visual Studio 2017: _mm_load_ps often compiled to movups
  26. Compiler changes printf to puts
  27. What’s the proper implementation for hardware emulation?
  28. Convert ASM to C (not reverse engineer)
  29. How to tell GCC to generate 16-bit code for real mode
  30. How to get the size of a C function from inside a C program or with inline assembly?

Leave a Comment