Używałem openCV do dopasowywania bloków i zauważyłem, że jego suma kodu kwadratów różnic jest bardzo szybka w porównaniu z prostą pętlą typu:

<code>int SSD = 0;
for(int i =0; i < arraySize; i++)
    SSD += (array1[i] - array2[i] )*(array1[i] - array2[i]);
</code>

Jeśli spojrzę na kod źródłowy, aby zobaczyć, gdzie dzieje się ciężkie podnoszenie, ludzie OpenCV mają swoje pętle for do 4 obliczeń różnicy kwadratów na raz w każdej iteracji pętli. Funkcja dopasowywania bloku wygląda następująco.

<code>int64
icvCmpBlocksL2_8u_C1( const uchar * vec1, const uchar * vec2, int len )
{
int i, s = 0;
int64 sum = 0;

for( i = 0; i <= len - 4; i += 4 ) 
{   
    int v = vec1[i] - vec2[i];
    int e = v * v;

    v = vec1[i + 1] - vec2[i + 1]; 
    e += v * v;
    v = vec1[i + 2] - vec2[i + 2];
    e += v * v;
    v = vec1[i + 3] - vec2[i + 3];
    e += v * v;
    sum += e;
}

for( ; i < len; i++ )
{
    int v = vec1[i] - vec2[i];

    s += v * v;
}

return sum + s;
}
</code>

To obliczenie dotyczy niepodpisanych 8-bitowych liczb całkowitych. Wykonują podobne obliczenia dla 32-bitowych pływaków w tej funkcji:

<code>double
icvCmpBlocksL2_32f_C1( const float *vec1, const float *vec2, int len )
{
double sum = 0;
int i;

for( i = 0; i <= len - 4; i += 4 )
{
    double v0 = vec1[i] - vec2[i];
    double v1 = vec1[i + 1] - vec2[i + 1];
    double v2 = vec1[i + 2] - vec2[i + 2];
    double v3 = vec1[i + 3] - vec2[i + 3];

    sum += v0 * v0 + v1 * v1 + v2 * v2 + v3 * v3;
}
for( ; i < len; i++ )
{
    double v = vec1[i] - vec2[i];

    sum += v * v;
}
return sum;
}
</code>

Zastanawiałem się, czy ktoś miał jakiś pomysł, czy przerwanie pętli do 4 takich fragmentów może przyspieszyć kod? Powinienem dodać, że w tym kodzie nie ma wielowątkowości.