SSE 并行化

Question

您好我正在尝试提高这段代码的性能，假设我有一台能够处理 4 个线程的机器。我首先考虑使 omp 并行化，但后来我发现这个函数在 for 循环中，因此多次创建线程效率不高。所以我想知道如何用SSE实现它会更有效：

unsigned char cubicInterpolate_paralelo(unsigned char p[4], unsigned char x) {
    unsigned char resultado;
    unsigned char intermedio;
    intermedio = + x*(3.0*(p[1] - p[2]) + p[3] - p[0]);

    resultado = p[1] + 0.5 * x *(p[2] - p[0] + x*(2.0*p[0] - 5.0*p[1] + 4.0*p[2] - p[3] + x*(3.0*(p[1] - p[2]) + p[3] - p[0])));
    return resultado;
}

unsigned char bicubicInterpolate_paralelo (unsigned char p[4][4], unsigned char x, unsigned char y) {
    unsigned char arr[4],valorPixelCanal;
    arr[0] = cubicInterpolate_paralelo(p[0], y);
    arr[1] = cubicInterpolate_paralelo(p[1], y);
    arr[2] = cubicInterpolate_paralelo(p[2], y);
    arr[3] = cubicInterpolate_paralelo(p[3], y);

    valorPixelCanal = cubicInterpolate_paralelo(arr, x);
    return valorPixelCanal;
}

这在一些嵌套的内部使用：

for(i=0; i<z_img.width(); i++) {
        for(j=0; j<z_img.height(); j++) {
            //For R,G,B
            for(c=0; c<3; c++) { 

                for(l=0; l<4; l++){
                    for(k=0; k<4; k++){

                        arr[l][k] = img(i/zFactor +l, j/zFactor +k, 0, c); 
                    }
                }

                color[c] = bicubicInterpolate_paralelo(arr, (unsigned char)(i%zFactor)/zFactor, (unsigned char)(j%zFactor)/zFactor);
            }
            z_img.draw_point(i,j,color);
        }
    }

Answer 1

使用 OpenMP，您可以尝试将 #pragma 添加到最外层的 for 循环。这应该可以解决您的问题。

走 SSE 路线比较棘手，因为对数据有额外的对齐限制，但最简单的转换是扩展 cubicInterpolate_paralelo 以同时处理多个计算。运气好的话，告诉编译器使用 SSE 就可以解决问题，但为了确保您可以使用内部函数和类型。

Answer 2

SSE 与线程完全无关。单个线程一次执行一条指令；对于 SSE，一条指令可以一次应用于 4 或 8 组参数。因此，对于多线程，您还可以运行多个 SSE 指令来处理更多数据。

您可以使用带有 for 循环的线程。只是不要在里面使用它们。相反，采用 for(i=0; i<z_img.width(); i++) { 外循环并将其拆分为 4 个带 width/4。线程 0 获得 0..width/4，线程 1 获得 width/4..width/2 等

在一个不相关的说明中，您的代码还存在混合浮点和整数数学问题。 0.5 * x 的效率几乎不如 x/2。

Answer 3

我对代码进行了一些改动，因此您可能需要对其进行重大更改，但这是对 SSE 的（未经测试的）音译：

__m128i x = _mm_unpacklo_epi8(_mm_loadl_epi64(x_array), _mm_setzero_si128());
__m128i p0 = _mm_unpacklo_epi8(_mm_loadl_epi64(p0_array), _mm_setzero_si128());
__m128i p1 = _mm_unpacklo_epi8(_mm_loadl_epi64(p1_array), _mm_setzero_si128());
__m128i p2 = _mm_unpacklo_epi8(_mm_loadl_epi64(p2_array), _mm_setzero_si128());
__m128i p3 = _mm_unpacklo_epi8(_mm_loadl_epi64(p3_array), _mm_setzero_si128());
__m128i t = _mm_sub_epi16(p1, p2);
t = _mm_add_epi16(_mm_add_epi16(t, t), t); // 3 * (p[1] - p[2])
__m128i intermedio = _mm_mullo_epi16(x,  _mm_sub_epi16(_mm_add_epi16(t, p3), p0));
t = _mm_add_epi16(p1, _mm_slli_epi16(p1, 2)); // 5 * p[1]
// t2 = 2 * p[0] + 4 * p[2]
__m128i t2 = _mm_add_epi16(_mm_add_epi16(p0, p0), _mm_slli_epi16(p2, 2));
t = _mm_mullo_epi16(x, _mm_sub_epi16(_mm_add_epi16(t2, intermedio), _mm_add_epi16(t, p3)));
t = _mm_mullo_epi16(x, _mm_add_epi16(_mm_sub_epi16(p2, p0), t));
__m128i resultado = _mm_add_epi16(p1, _mm_srli_epi16(t, 1)); 
return resultado;

我使用的16位中间值应该足够宽，此代码中高位信息影响低位的唯一方法是右移1（您的代码中的0.5 *），所以实际上我们只需要 9 位，其余的不会影响结果。字节不够宽（除非你有一些我不知道的额外保证），但无论如何它们都会很烦人，因为没有很好的方法来乘以它们。

为了简单起见，我假装输入采用 x、p[0] 等连续数组的形式，这不是您在这里需要的，但我没有时间计算出所有的加载和改组。

SSE 并行化

SSE parallelization

c

parallel-processing

sse

openmp