_mm_sad_epu8 is faster than _mm_sad_pu8

Question

In a test test, is a 128-bit internal function faster than a 64-bit internal?

_mm_sad_epu8(__m128i, __m128i) //Clocks: 0.0300
_mm_sad_pu8(__m64, __m64)      //Clocks: 0.0491

From what I understand, the Intel Reference Guide states that it (PSADBW)has a latency of 5 and a throughput of 1 on mmx registers, but does not show performance for mm registers.

If they are not equally fast, and is this common for built-in functions that take 128-bit arguments?

Answer 1

My measurement program (see below) shows that on the Core-i5 3450 (Ivy Bridge), performance _mm_sad_epu8is equal to performance _mm_sad_pu8. The latter is even a little faster.

:

warmup:              1.918 sec total
measure_mm_sad_epu8: 1.904 sec total, 0.372 nsec per operation
measure_mm_sad_pu8:  1.872 sec total, 0.366 nsec per operation

3,5 ( ), _mm_sad_epu8 1 . , 0.286 . , 77% .

Visual Studio ++ 2010 Express Win32. "Release". cpp:

#include "stdafx.h"
#include <cassert>
#include <ctime>
#include <iostream>
#include <iomanip>

extern "C" {
  #include <emmintrin.h>
}

float measure_mm_sad_epu8(int n, int repeat) {
    assert(n % 16 == 0);
    // Didn't get an aligned "new" to work :-(
    __m128i *input  = (__m128i *) _aligned_malloc(n * sizeof *input,  16);
    __m128i *output = (__m128i *) _aligned_malloc(n * sizeof *output, 16);
    if(!input || !output) exit(1);
    __m128i zero = _mm_setzero_si128();

    for(int i=0; i < n; i++) {
        input[i].m128i_i64[0] = 0x0123456789abcdef;
        input[i].m128i_i64[1] = 0xfedcba9876543210;
    }

    clock_t startTime = clock();
    for(int r = 0; r < repeat; r++) {
        for(int i = 0; i < n; i+=16) { // loop unrolled
            output[i  ] = _mm_sad_epu8(input[i  ], zero);
            output[i+1] = _mm_sad_epu8(input[i+1], zero);
            output[i+2] = _mm_sad_epu8(input[i+2], zero);
            output[i+3] = _mm_sad_epu8(input[i+3], zero);
            output[i+4] = _mm_sad_epu8(input[i+4], zero);
            output[i+5] = _mm_sad_epu8(input[i+5], zero);
            output[i+6] = _mm_sad_epu8(input[i+6], zero);
            output[i+7] = _mm_sad_epu8(input[i+7], zero);
            output[i+8] = _mm_sad_epu8(input[i+8], zero);
            output[i+9] = _mm_sad_epu8(input[i+9], zero);
            output[i+10] = _mm_sad_epu8(input[i+10], zero);
            output[i+11] = _mm_sad_epu8(input[i+11], zero);
            output[i+12] = _mm_sad_epu8(input[i+12], zero);
            output[i+13] = _mm_sad_epu8(input[i+13], zero);
            output[i+14] = _mm_sad_epu8(input[i+14], zero);
            output[i+15] = _mm_sad_epu8(input[i+15], zero);
        }
    }
    _mm_empty();
    clock_t endTime = clock();

    _aligned_free(input);
    _aligned_free(output);
    return (endTime-startTime)/(float)CLOCKS_PER_SEC;
}

float measure_mm_sad_pu8(int n, int repeat) {
    assert(n % 16 == 0);
    // Didn't get an aligned "new" to work :-(
    __m64 *input  = (__m64 *) _aligned_malloc(n * sizeof *input,  16);
    __m64 *output = (__m64 *) _aligned_malloc(n * sizeof *output, 16);
    if(!input || !output) exit(1);
    __m64 zero = _mm_setzero_si64();

    for(int i=0; i < n; i+=2) {
        input[i  ].m64_i64 = 0x0123456789abcdef;
        input[i+1].m64_i64 = 0xfedcba9876543210;
    }

    clock_t startTime = clock();
    for(int r = 0; r < repeat; r++) {
        for(int i = 0; i < n; i+=16) { // loop unrolled
            output[i  ] = _mm_sad_pu8(input[i  ], zero);
            output[i+1] = _mm_sad_pu8(input[i+1], zero);
            output[i+2] = _mm_sad_pu8(input[i+2], zero);
            output[i+3] = _mm_sad_pu8(input[i+3], zero);
            output[i+4] = _mm_sad_pu8(input[i+4], zero);
            output[i+5] = _mm_sad_pu8(input[i+5], zero);
            output[i+6] = _mm_sad_pu8(input[i+6], zero);
            output[i+6] = _mm_sad_pu8(input[i+7], zero);
            output[i+7] = _mm_sad_pu8(input[i+8], zero);
            output[i+8] = _mm_sad_pu8(input[i+9], zero);
            output[i+10] = _mm_sad_pu8(input[i+10], zero);
            output[i+11] = _mm_sad_pu8(input[i+11], zero);
            output[i+12] = _mm_sad_pu8(input[i+12], zero);
            output[i+13] = _mm_sad_pu8(input[i+13], zero);
            output[i+14] = _mm_sad_pu8(input[i+14], zero);
            output[i+15] = _mm_sad_pu8(input[i+15], zero);
        }
    }
    _mm_empty();
    clock_t endTime = clock();

    _aligned_free(input);
    _aligned_free(output);
    return (endTime-startTime)/(float)CLOCKS_PER_SEC;
}

int _tmain(int argc, _TCHAR* argv[])
{
    int n = 256, repeat = 20000000;
    float time;

    std::cout << std::setprecision(3) << std::fixed;

    time = measure_mm_sad_epu8(n,repeat);
    std::cout << "warmup:              " << time << " sec total" << std::endl;
    time = measure_mm_sad_epu8(n,repeat);
    std::cout << "measure_mm_sad_epu8: " << time << " sec total, " << time/n/repeat*1e9 << " nsec per operation" << std::endl;

    n*=2;      // same memory footprint
    repeat/=2; // but with same amount of calculations
    time = measure_mm_sad_pu8(n,repeat);
    std::cout << "measure_mm_sad_pu8:  " << time << " sec total, " << time/n/repeat*1e9 << " nsec per operation" << std::endl;
    return 0;
}

"stdafx.h":

#pragma once
#include "targetver.h"
#include <stdio.h>
#include <tchar.h>

EDIT: output[i] = _mm_sad_epu8(input[i], zero); , a psadbw , ( ):

013410D0  movdqa      xmm1,xmmword ptr [ecx-30h]  
013410D5  psadbw      xmm1,xmm0  
013410D9  movdqa      xmmword ptr [eax-10h],xmm1  

013410DE  ...

IvyBridge () . xmm1 xmm0, . EDIT2. - 13 20 . , , Ivy Bridge 16 ( 4 ). , , .

MMX :

013412D4  movq        mm1,mmword ptr [ecx-18h]  
013412D8  psadbw      mm1,mm0  
013412DB  movq        mmword ptr [eax-8],mm1  

013412DF  ...

2 * 4 KiB , MMX (. ).