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

我已经采取了一些自由的代码，所以你可能要显著改变它，但这里是一个（未经测试）音译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's，p[0]'s等，这不是你在这里需要的，但我没有时间去处理所有的加载和混洗。

Answer 2

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

由于对数据有额外的对齐限制，执行SSE路由比较棘手，但最简单的转换是扩展cubicInterpolate_paralelo以同时处理多个计算。有了足够的运气，告诉编译器使用SSE会为你做诡计，但要确保你可以使用内部函数和类型。

Answer 3

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

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

在一个不相关的笔记中，您的代码也会混合使用浮点数和整数数学。 0.5 * x几乎没有x/2那么高效。