首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >何时以及如何在simd例程中执行浮点转换?

问何时以及如何在simd例程中执行浮点转换?
EN

Stack Overflow用户
提问于 2020-09-16 04:29:34
回答 3查看 143关注 0票数 0

我正在计算一个双向(水平和垂直)前缀和(扫描)在两个图像上,产生像素和,平方和,和两个图像的交叉积。所有的计算都是在32位整数中完成的,然后我才能得到最后一遍,它需要将32位整数转换为双倍,以计算窗口函数中两幅图像的均值、方差和协方差。

首先--这是最好的方法吗?我可以双倍地构建整个前缀和数组,并且不会有转换步骤。

第二,如果这是正确的方法,我会从使用打包的双simd操作中得到很多好处吗?我只能安全地假设我一次能得到两个单位。

第三,我应该把数据单元打包在一起,还是把它放在当前的平面格式上?平面格式是将像素按“组件”划分的格式。如果您得到32位RGBA输入,即8位R、8位G、8位B和8位A,则填充格式为RGBARGBA,而平面格式为RRRRRRRRRRRRR....GGGGGGGGGGGG....BBBBB.....AAAAA...诸若此类。

以下是我迄今所做的与本主题相关的三项功能。前两个是标量版本,因此更容易阅读和理解正在发生的事情。第三种是当前SIMD功能1的实现。第四种功能(缺少且尚未完成)是这个问题的主题,很可能是第二种功能的SIMD实现。

代码语言:javascript
复制
std::unique_ptr<uint32_t[],boost::alignment::aligned_delete> computeSumMatrixForwardScalar2PassAll(uint8_t const* pImgData1, uint8_t const* pImgData2,
                                                                                                unsigned width, unsigned height)
{
  using namespace simdpp;
  std::unique_ptr<uint32_t[], boost::alignment::aligned_delete> sumArray((uint32_t*)boost::alignment::aligned_alloc(64, 5*width*height*sizeof(uint32_t)));
  auto pSumArray = sumArray.get();
  BOOST_ALIGN_ASSUME_ALIGNED(pImgData1, 64);
  BOOST_ALIGN_ASSUME_ALIGNED(pImgData2, 64);
  BOOST_ALIGN_ASSUME_ALIGNED(pSumArray, 64);
//#pramga omp parallel for private(h) shared(pImgData, pSumArray, w )

#pragma omp for simd
  for (unsigned h = 0; h < height; ++h)
  {
    uint32_t lastValX = 0;
    uint32_t lastValY = 0;
    uint32_t lastValXX = 0;
    uint32_t lastValYY = 0;
    uint32_t lastValXY = 0;
    for (unsigned w = 0; w < width; ++w)
    {
      uint32_t imgValX      = pImgData1[h * width + w];
      uint32_t newValX      = lastValX + imgValX;
      uint32_t newValXX = lastValXX + imgValX*imgValX;
      uint32_t imgValY = pImgData2[h*width + w];
      uint32_t newValY = lastValY + imgValY;
      uint32_t newValYY = lastValYY + imgValY*imgValY;
      uint32_t newValXY = lastValXY + imgValX*imgValY;
      pSumArray[h*width + w]= newValX;
      pSumArray[width*height+h*width + w] = newValY;
      pSumArray[2*width*height+ h*width + w] = newValXX;

      pSumArray[3*width*height+h*width + w] = newValYY;
      pSumArray[4*width*height+h*width + w] = newValXY;
      lastValX              = newValX;
      lastValXX = newValXX;
      lastValY = newValY;
      lastValYY = newValYY;
      lastValXY = newValXY;
    }
  }
  for (unsigned i = 0; i < 5; ++i) {
    for (unsigned h = 0; h+1 < height; ++h)
    {
      for (unsigned w = 0; w < width; ++w) {
        uint32_t above = pSumArray[i*width*height + h * width + w];
        uint32_t current = pSumArray[i*width*height+ (h+1) *width +w];
        pSumArray[i*width*height + (h+1) * width +w]= above+current;
      }
    }
  }

  return sumArray;
}

第二: SSIM转换--注意不同的语言--因为我还没有完成它的C++实现。注意,它在那里调用weberSumMatrix,这与上面的函数相同。

代码语言:javascript
复制
export function weberSsim(
  pixels1: ImageMatrix,
  pixels2: ImageMatrix,
  options: Options
): MSSIMMatrix {
  // console.time("weber ssim");
  const { bitDepth, k1, k2, windowSize} = options
  const L = (1 << bitDepth) - 1
  const c1 = k1 * L * (k1 * L)
  const c2 = k2 * L * (k2 * L)
  const windowSquared = windowSize * windowSize
  const pixels1Data = pixels1.data;
  const pixels2Data = pixels2.data;
  const width = pixels1.width;
  const height = pixels1.height;
  // Produces exactly the same output as the C++ prefix sum above.
  const sumMatrix = weberSumMatrix(pixels1Data, pixels2Data, width, height);
  const windowHeight = height-windowSize;
  const windowWidth = width-windowSize;
  const imageSize = width*height;
  const ssims = new Array(windowHeight*windowWidth);


  // lets handle w = 0 h = 0 first and initialize mssim

  let cumulativeSsim;
  const reciprocalWindowSquared =  1 / windowSquared;
  {
    const windowOffset = windowSize - 1;
    let bottomOffset = windowOffset*width;
    {
      const meanx = (sumMatrix[bottomOffset+ windowOffset]) * reciprocalWindowSquared;
      const meany = (
        sumMatrix[imageSize + bottomOffset+ windowOffset]) * reciprocalWindowSquared;
      const varx = (
        sumMatrix[2*imageSize + bottomOffset+ windowOffset]) * reciprocalWindowSquared - meanx*meanx ;
      const vary = (
        sumMatrix[3*imageSize + bottomOffset+ windowOffset])  * reciprocalWindowSquared - meany*meany;
      const cov = (
        sumMatrix[4*imageSize + bottomOffset+ windowOffset])  * reciprocalWindowSquared - meanx*meany;
      const na = 2 * meanx * meany + c1
      const nb = 2 * cov + c2
      const da = meanx * meanx + meany * meany + c1
      const db = varx + vary + c2
      const ssim = (na * nb) / (da * db)
      ssims[0] = ssim
      // mssim = ssim
      cumulativeSsim = ssim;
    }



    // next handle all of the h = 0, w > 0 cases first
    for (let w = 1; w <  windowWidth; ++w) {
      // in h =0 cases, there is no top left or top right
      let leftOffset = w - 1;
      const rightx = sumMatrix[bottomOffset+leftOffset];
      const leftx = sumMatrix[bottomOffset+(windowOffset+w)];
      const meanx = (leftx-rightx)* reciprocalWindowSquared;
      const righty= sumMatrix[imageSize + bottomOffset+ leftOffset];
      const lefty = sumMatrix[imageSize + bottomOffset+ (windowOffset+w)];
      const meany = (lefty-righty) * reciprocalWindowSquared;
      const rightxx = sumMatrix[2*imageSize + bottomOffset+leftOffset];
      const leftxx = sumMatrix[2*imageSize + bottomOffset+ (windowOffset+w)];
      const varx = (leftxx-rightxx) * reciprocalWindowSquared - meanx*meanx ;
      const rightyy = sumMatrix[3*imageSize + bottomOffset+leftOffset];
      const leftyy = sumMatrix[3*imageSize + bottomOffset+ (windowOffset+w)]
      const vary = (leftyy - rightyy)  * reciprocalWindowSquared - meany*meany;
      const rightxy = sumMatrix[4*imageSize + bottomOffset+leftOffset];
      const leftxy = sumMatrix[4*imageSize + bottomOffset+ (windowOffset+w)];
      const cov = (leftxy-rightxy)  * reciprocalWindowSquared - meanx*meany;
      const na = 2 * meanx * meany + c1
      const nb = 2 * cov + c2
      const da = meanx * meanx + meany * meany + c1
      const db = varx + vary + c2
      const ssim = (na * nb) / (da *db)
      ssims[w] = ssim
      // mssim = mssim + (ssim - mssim) / (i + 1)
      cumulativeSsim += ssim;
    }
  }

  const windowOffset = windowSize - 1;
  // There will be lots of branch misses if we don't split the w==0 and h==0 cases
  for (let h = 1; h < windowHeight; ++h) {
    // now the w=0 on each line
    let bottomOffset = (h+windowSize-1)*width;
    let topOffset = (h-1)*width;
    {
      // since there is no left side we can skip two operations
      const topx = sumMatrix[topOffset+ windowOffset];
      const bottomx = sumMatrix[bottomOffset+ windowOffset];
      const meanx = (bottomx - topx) * reciprocalWindowSquared;
      const topy = sumMatrix[imageSize + topOffset+ windowOffset];
      const bottomy = sumMatrix[imageSize + bottomOffset+ windowOffset];
      const meany = (bottomy - topy) * reciprocalWindowSquared;
      const topxx = sumMatrix[2*imageSize + topOffset+ windowOffset];
      const bottomxx = sumMatrix[2*imageSize + bottomOffset+ windowOffset];
      const varx = (bottomxx-topxx)  * reciprocalWindowSquared - meanx*meanx ;
      const topyy = sumMatrix[3*imageSize + topOffset+ windowOffset];
      const bottomyy = sumMatrix[3*imageSize + bottomOffset+ windowOffset];
      const vary = (bottomyy-topyy)  * reciprocalWindowSquared - meany*meany;
      const topxy = sumMatrix[4*imageSize + topOffset+ windowOffset];
      const bottomxy = sumMatrix[4*imageSize + bottomOffset+ windowOffset];
      const cov = (bottomxy-topxy)  * reciprocalWindowSquared - meanx*meany;
      const na = 2 * meanx * meany + c1
      const nb = 2 * cov + c2
      const da = meanx * meanx + meany * meany + c1
      const db = varx + vary + c2
      const ssim = (na * nb) / (da *db)
      ssims[h*windowWidth] = ssim
      // mssim = mssim + (ssim - mssim) / (i + 1)
      cumulativeSsim += ssim;
    }


    for (let w = 1; w < windowWidth; ++w) {
      // add top left sub top right sub bottom left add bottom right
      const rightOffset = w + windowSize - 1;
      const leftOffset = w - 1;
      const meanx = (sumMatrix[topOffset + leftOffset]
        - sumMatrix[topOffset+ rightOffset]
        - sumMatrix[bottomOffset+leftOffset]
        + sumMatrix[bottomOffset+ rightOffset]) * reciprocalWindowSquared;
      const meany = (sumMatrix[imageSize+ topOffset + leftOffset]
        - sumMatrix[imageSize + topOffset+ rightOffset]
        - sumMatrix[imageSize + bottomOffset+leftOffset]
        + sumMatrix[imageSize + bottomOffset+ rightOffset]) * reciprocalWindowSquared;
      const varx = (sumMatrix[2*imageSize+ topOffset + leftOffset]
        - sumMatrix[2*imageSize + topOffset+ rightOffset]
        - sumMatrix[2*imageSize + bottomOffset+leftOffset]
        + sumMatrix[2*imageSize + bottomOffset+ rightOffset]) * reciprocalWindowSquared - meanx*meanx ;
      const vary = (sumMatrix[3*imageSize+ topOffset + leftOffset]
        - sumMatrix[3*imageSize + topOffset+ rightOffset]
        - sumMatrix[3*imageSize + bottomOffset+leftOffset]
        + sumMatrix[3*imageSize + bottomOffset+ rightOffset])  * reciprocalWindowSquared - meany*meany;
      const cov = (sumMatrix[4*imageSize+ topOffset + leftOffset]
        - sumMatrix[4*imageSize + topOffset+ rightOffset]
        - sumMatrix[4*imageSize + bottomOffset+leftOffset]
        + sumMatrix[4*imageSize + bottomOffset+ rightOffset])  * reciprocalWindowSquared - meanx*meany;
      const na = 2 * meanx * meany + c1
      const nb = 2 * cov + c2
      const da = meanx * meanx + meany * meany + c1
      const db = varx + vary + c2
      const ssim = (na * nb) / (da * db)
      ssims[h*windowWidth+w] = ssim
      cumulativeSsim += ssim;
      // mssim = mssim + (ssim - mssim) / (i + 1)
    }
  }
  const mssim = cumulativeSsim / (windowHeight*windowWidth);


  return { data: ssims, width, height, mssim }
}

第三:当前SIMD前缀和。

代码语言:javascript
复制
std::unique_ptr<uint32_t[],boost::alignment::aligned_delete> computeSumMatrixForwardSimd2PassAll(uint8_t const* pImgData1, uint8_t const* pImgData2,
                                                                                              unsigned width, unsigned height)
{
  using namespace simdpp;
  std::unique_ptr<uint32_t[], boost::alignment::aligned_delete> sumArray((uint32_t*)boost::alignment::aligned_alloc(64, 5*width*height*sizeof(uint32_t)));
  auto pSumArray = sumArray.get();
  BOOST_ALIGN_ASSUME_ALIGNED(pImgData1, 64);
  BOOST_ALIGN_ASSUME_ALIGNED(pImgData2, 64);
  BOOST_ALIGN_ASSUME_ALIGNED(pSumArray, 64);
//#pramga omp parallel for private(h) shared(pImgData, pSumArray, w )


  uint32x4 zero = make_zero();
  for (unsigned h = 0; h < height; ++h)
  {
    uint32x4 lastValSplatX = zero;
    uint32x4 lastValSplatY = zero;
    uint32x4 lastValSplatXX = zero;
    uint32x4 lastValSplatYY = zero;
    uint32x4 lastValSplatXY = zero;
    for (unsigned w = 0; w < width; w += 16)
    {
      // starting left value
      // previous line values..
      prefetch_read(pImgData1+(w+1)*64);
      prefetch_read(pImgData2+(w+1)*64);
      uint32v4 imgDataX = to_uint32(uint8x16(load(pImgData1 + h * width + w)));
      uint32v4 imgDataY = to_uint32(uint8x16(load(pImgData2 + h * width + w)));
      static_assert(uint32v4::vec_length == 4);
      static_assert(sizeof(uint32v4::base_vector_type::native_type) == 16);
      for (unsigned i = 0 ; i < uint32v4::vec_length; ++i) {
        // a_0 a_1 a_2 a_3
        uint32v4::base_vector_type   x = imgDataX.vec(i);
        uint32v4::base_vector_type  y = imgDataY.vec(i);
        uint32v4::base_vector_type xx = mul_lo(x,x);
        uint32v4::base_vector_type yy = mul_lo(y, y);
        uint32v4::base_vector_type xy = mul_lo(x, y);
        // a_0 a_0+a_1 a_1+a_2 a_2+a_3
        x = add(x, move4_r<1>(x));
        x = add(x, move4_r<2>(x));
        x = add(x, lastValSplatX);
        lastValSplatX = permute4<3,3,3,3>(x);
        store(pSumArray+h*width+w+i*4, x);
        y = add(y, move4_r<1>(y));
        y = add(y, move4_r<2>(y));
        y = add(y, lastValSplatY);
        lastValSplatY = permute4<3,3,3,3>(y);
        store(width*height+pSumArray+h*width+w+i*4, y);
        xx = add(xx, move4_r<1>(xx));
        xx = add(xx, move4_r<2>(xx));
        xx = add(xx, lastValSplatXX);
        lastValSplatXX = permute4<3,3,3,3>(xx);
        store(2*width*height+pSumArray+h*width+w+i*4, xx);
        yy = add(yy, move4_r<1>(yy));
        yy = add(yy, move4_r<2>(yy));
        yy = add(yy, lastValSplatYY);
        lastValSplatYY = permute4<3,3,3,3>(yy);
        store(3*width*height+pSumArray+h*width+w+i*4, yy);
        xy = add(xy, move4_r<1>(xy));
        xy = add(xy, move4_r<2>(xy));
        xy = add(xy, lastValSplatXY);
        lastValSplatXY = permute4<3,3,3,3>(xy);
        store(4*width*height+pSumArray+h*width+w+i*4, xy);
      }
    }
  }
  // 16 bit 8s for grins...
  // a_0 a_1 a_2 a_3 a_4 a_5 a_6 a_7
  // a_0 a_0+a_1 a_1+a_2 a_2+a_3 a_3+a_4 a_4+a_5 a_5+a_6 a_6+a_7 (>>1)
  // d    d        -a_0  -a_0+a_1 -a_0+a_1+a_2 -a_0+a_1+a_2+a_3 -a_0+a_1+a_2+a_3+a_4 - -a_0+a_1+a_2+a_3+a_4+a_5
  // d    d        shuffle shuffle shuffle+add    shuffle+add     shuffle+add+shuffle+add  shuffle+add+shuffle+add


  // a_0 a_1 a_2 a_3     a_4         a_5           a_6                    a_7
  //         a_0 a_1     a_2         a_3           a_4                    a_5
  //         a_1 a_2+a_0 a_3+a_1-a_0 a_4+a_2-a1-a0 a_5+a_3-a_2-a_0        a_6+a_4...
  for (unsigned i = 0; i < 5; ++i) {
    for (unsigned h = 0; h+1 < height; ++h)
    {
      for (unsigned w = 0; w < width; w += 16) {
        uint32v4 above = load(i*width*height +pSumArray + h * width + w);
        uint32v4 current = load(i*width*height+pSumArray +(h+1) * width +w);
        store(i*width*height+pSumArray +(h+1) * width +w, add(above,current));
      }
    }
  }

  return sumArray;
}
EN

回答 3

Stack Overflow用户

回答已采纳

发布于 2020-09-17 08:54:26

首先--这是最好的方法吗?我可以双倍地构建整个前缀和数组,并且不会有转换步骤。

通常,整数计算比每个向量具有相同元素数的浮点计算要快得多。例如,paddd在Skylake上分别具有延迟1和交互吞吐量0.33周期和addps -4和0.5。使用整数计算,如果您有乘法,有时由于必须在不同的元素大小之间进行转换或将产品的上、下半部分组合在一起,您会有开销。但是通常情况下,这仍然比FP更快,而且如果您能够合并pmaddwd或pmaddubsw指令(它们是FMA的INT版本),或者您可以丢弃产品的下半部分或uppper,那么也可以减少它。

说到FMA,FP因为AVX2有FMA指令的优点,允许每个乘法有一个加法。在您的情况下,这是否有益取决于您的算法和输入数据,但是如果您有整数输入,我仍然会尽可能多地使用INT计算。

INT计算相对于FP的另一个优点是,您可以对较小的元素进行计算,这意味着您可以处理每条指令的更多数据。当然,这只有在输入和算法允许的情况下才有可能,但特别是在图像处理中,情况通常是这样的。

这部分的最后一个注意事项是,您应该考虑在算法的每个阶段需要处理的数据量。INT到FP转换不是免费的,所以您需要转换的数据越少越好。如果中间数据的数量小于输入,那么推迟转换将是有益的。

第二种--如果这是正确的方法,我会从使用打包的双simd操作中得到很多好处吗?我只能安全地假设我一次能得到两个单位。

嗯,每个指令两次比一次要好,所以在我的书中它是值得的。您还可以对向量执行更精细的操作,如FMA、掩蔽、混合、min/max,而不是在标量上(尽管编译器甚至可以在标量代码上为您生成一些指令)。如果运行时检测到AVX,就可以机会主义地将吞吐量提高一倍。

此外,您应该考虑在您的情况下,32位浮动精度是否足够。您可能不需要双重精度的结果,并且通过使用一些FP技术,您可以减少32位FP数学累积的错误,并且仍然具有比64位计算更好的性能。

第三种--是将数据单元打包在一起,还是将其保留在当前的平面格式中?

一般来说,您应该更喜欢平面输入数据。一般来说,SIMD,特别是SSE/AVX,更适合于垂直操作(即在不同向量的对应元素之间执行操作时),而不是水平操作(当操作在同一向量的元素之间执行时)。通过打包输入,您可能需要对输入数据进行解压缩和洗牌,这将增加开销。现代CPU能够跟踪从内存到内存的多个读写流,因此硬件预取器应该能够处理不同数据平面上的线性存储器访问。

票数 2
EN

Stack Overflow用户

发布于 2020-09-16 16:48:25

对于第3部分--至少Intel 64和IA-32架构优化参考手册将平面格式指定为更理想的一般格式。这样我就可以跳过那次了。看起来我可以做浮点值,而不是16x16 (255*256**2)窗口的双倍值,因为这在溢出之前是可表示的。从这个角度来看,我得到的好处是每向量4次浮动,而不是2倍。这很有帮助。看来,我可以得到一个滚动的总和,我的平均计算,从四个浮动,并计算它的最后。因此,如果我根据最大窗口大小约束该函数,则可以确定何时使用float,何时使用double。实现并没有太大的不同。

我想,在我试着看之前,我不会知道它的真正表现。

票数 0
EN

Stack Overflow用户

发布于 2020-09-17 16:59:18

关于第1部分,取决于整数的计数及其范围,您可以使用64位整数而不是双整数。一般稍微快一点,尤其是延迟,也更精确。以下是SSE2中的一些片段。

代码语言:javascript
复制
// Return acc64 += a32. The a32 is viewed as uint32_t lanes, the accumulator is uint64_t
inline __m128i integerAdd( __m128i a32, __m128i acc64 )
{
    const __m128i low = _mm_and_si128( a32, _mm_set1_epi64x( UINT_MAX ) );
    acc64 = _mm_add_epi64( acc64, low );
    const __m128i high = _mm_srli_epi64( a32, 32 );
    acc64 = _mm_add_epi64( acc64, high );
    return acc64;
}

// Compute a32 * b32, add to the accumulator. The two inputs are viewed as uint32_t lanes, the accumulator is uint64_t
inline __m128i integerFma( __m128i a32, __m128i b32, __m128i acc64 )
{
    const __m128i low = _mm_mul_epu32( a32, b32 );
    a32 = _mm_srli_si128( a32, 4 );
    b32 = _mm_srli_si128( b32, 4 );
    const __m128i high = _mm_mul_epu32( a32, b32 );
    acc64 = _mm_add_epi64( acc64, low );
    acc64 = _mm_add_epi64( acc64, high );
    return acc64;
}

// Add both 64-bit lanes of the accumulator, convert to double
inline double accumulatedValue( __m128i acc64 )
{
    acc64 = _mm_add_epi64( acc64, _mm_unpackhi_epi64( acc64, acc64 ) );
    const uint64_t v = (uint64_t)_mm_cvtsi128_si64( acc64 );
    return (double)v;
}

更新:平均值为sum(x) / count。你不需要分数来计算整数的和,你只需要64位整数来避免溢出,如果你有很多的值。您只需要一个最终指令的非整数号。

对于方差,您需要sum((x-mean)^2)。这可以重写为sum(x^2) + mean * ( mean - 2 * sum(x) )。现在很明显,您只需要对输入数据进行一次传递,计算平方和值。如果输入太多,而且它们太大,则计算平方和会使64位整数溢出。但是对于许多实际应用来说,这是很好的,例如,如果您的输入在0 .65535范围,64位整数在40亿个样本之后才会溢出,你可能没有那么多.

票数 0
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://stackoverflow.com/questions/63913157

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档