在不知道“做一些事情”是什么的情况下很难进行测试，但这里有几个潜在的改进，我跳出来：
1.将数组索引替换为gather指令

// This is mostly pseudocode - don't just copy and paste!
// loop 4 times (2 pixels per iteration)
__m128i diff_expanded = _mm_cvtepu8_epi32(*absoluteDiff);
__m128i indices = _mm_cvtepu8_epi32(*previousFrame);

__m128i mask = _mm_set1_epi64(0x0000FFFFFFFFFFFF);

// This assumes noiseLevels should be an int[] to avoid misaligned loads. 
// You should test both - change last param for size
__m256i thresholds = mm256_mask_i32gather_epi32(noiseLevels, indices, mask, 4); 
__m256i thresh_diff = _mm256_sub_epi32(thresholds, diff_expanded);

// movemask creates a bitmask of the high bits of the packed integers.
int different_px = _mm256_movemask_epi8(thresh_diff_masked) & 0x08000800;

// Do some things if different_px is nonzero

1.就像上面一样，但是不需要循环就可以完成所有的操作--这里的挑战是如何完成我的指令。我认为最好的方法是4次调用gather_epi32-> shuffle-> blendv。不要尝试实现它，而是使用下面的实现。

// Again, this is pseudocode
// would need to loop zero times
__m256i indices = *previousFrame;

// in code without my imaginary instruction, this may be a __m128i
__m256i mask = _mm256_set1_epi64(0x00FFFFFF00FFFFFF);

// This instruction doesn't exist - but it can be mimicked with the epi32 
// version and some shuffles, mm_unpack instructions, or blendv instructions, 
// but there might also be better ways that I don't know about.
//
// I might come back and edit this answer if I can be more precise here
__m256i thresholds = mm256_mask_i32gather_epi8(noiseLevels, indices, mask, 1); 

// We would like to use _mm256_cmpgt_epu8, but that doesn't exist,
// instead we can use the solution offered here:
// https://stackoverflow.com/a/24234695
__m256i thresh_diff = _mm_cmpgt_epi8(
        _mm_xor_epi8(*absoluteDiff, _mm_set1_epi8(-128)),
        _mm_xor_epi8(thresholds, _mm_set1_epi8(-128)));

uint different_px = _mm256_movemask_epi8(thresh_diff_masked) & 0x77777777;

// Do some things if different_px is nonzero

这些并不是决定性的，但它们应该可以为您提供一个更好地利用Avx2的起点。
编辑：结合@PeterCords的建议：

// This is still pseudocode
// would need to loop zero times per vector

  __m256i absoluteDiff = _mm256_or_si256(_mm256_subs_epu8(previousChunk, currentChunk), _mm256_subs_epu8(currentChunk, previousChunk));

// using 4 so we're assuming noiseLevels is an array of dwords with 
// the 3 high bytes zeroed
__m256i indices = *previousFrame;

__m256i mask = _mm256_set1_epi32(0x000000FF);

// red channel
__m256i indices_0 = _mm256_and_si256(indices, mask);
__m256i diff_0 = _mm256_and_si256(absoluteDiff, mask);
__m256i threshold_0 = _mm256_i32gather_epi32(noiseLevels, indices_0, 4);
__m256i cmp_0 = _mm256_cmpgt_epi32(diff_0 , threshold_0);

// blue channel
__m256i indices_1 = _mm256_and_si256(_mm256_srli_epi32(indices, 8), mask);
__m256i diff_1 = _mm256_and_si256(_mm256_srli_epi32(absoluteDiff, 8), mask);
__m256i threshold_1 = _mm256_i32gather_epi32(noiseLevels, indices_1, 4);
__m256i cmp_1 = _mm256_cmpgt_epi32(diff_1 , threshold_1);

// green channel
__m256i indices_2 = _mm256_and_si256(_mm256_srli_epi32(indices, 16), mask);
__m256i diff_2 = _mm256_and_si256(_mm256_srli_epi32(absoluteDiff, 16), mask);
__m256i threshold_2 = _mm256_i32gather_epi32(noiseLevels, indices_2, 4);
__m256i cmp_2 = _mm256_cmpgt_epi32(diff_2 , threshold_2);

// from here you'd want to test cmp_0, cmp_1, and cmp_2
// you can OR them all together if you don't care about which pixel
// and then apply movemask or do movemask on each (which would likely
// be slower)

如果修改indices和absoluteDiff会更快，也值得测试：

// This is still pseudocode
// I'm assuming you care about which specific pixel is selected.
// This uses more slower instructions, but it should need fewer
// cache references

  __m256i absoluteDiff = _mm256_or_si256(_mm256_subs_epu8(previousChunk, currentChunk), _mm256_subs_epu8(currentChunk, previousChunk));

// using 4 so we're assuming noiseLevels is an array of dwords with 
// the 3 high bytes zeroed
//
// You could also use _mm256_sll_epi32  which has higher latency but
// better throughput but you would have to pass it a m128i shift count
__m256i indices = *previousFrame;

__m256i mask = _mm256_set1_epi32(0x000000FF);

// red channel
__m256i indices_0 = _mm256_and_si256(indices, mask);
__m256i diff_0 = _mm256_and_si256(absoluteDiff, mask);
__m256i threshold_0 = _mm256_i32gather_epi32(noiseLevels, indices_0, 4);
__m256i cmp_0 = _mm256_cmpgt_epi32(diff_0, threshold_0);

uint res = _mm256_movemask_ps(cmp_0);

// blue channel
indices = _mm256_srli_epi32(indices, 8);
absoluteDiff = _mm256_srli_epi32(absoluteDiff, 8);
__m256i indices_1 = _mm256_and_si256(indices, mask);
__m256i diff_1 = _mm256_and_si256(absoluteDiff, mask);
__m256i threshold_1 = _mm256_i32gather_epi32(noiseLevels, indices_1, 4);
__m256i cmp_1 = _mm256_cmpgt_epi32(diff_1, threshold_1);
res |= _mm256_movemask_ps(cmp_1);

// green channel
indices = _mm256_srli_epi32(indices, 8);
absoluteDiff = _mm256_srli_epi32(absoluteDiff, 8);
__m256i indices_2 = _mm256_and_si256(indices, mask);
__m256i diff_2 = _mm256_and_si256(absoluteDiff, mask);
__m256i threshold_2 = _mm256_i32gather_epi32(noiseLevels, indices_2, 4);
__m256i cmp_2 = _mm256_cmpgt_epi32(diff_2, threshold_2);
res |= _mm256_movemask_ps(cmp_2);

// from here, each nonzero bit in the low byte of res represents
// a pixel where one channel exceeded the threshold

经过几个小时的优化和整合@PeterCordes和@gfaster的一些想法/建议，我来到了下面的算法。此算法的一个显著变化是不再忽略Alpha通道。尽管alpha通道对于比较来说并不重要（因为它总是期望为255），但我发现无论如何都可以通过比较来编写最有效的算法。

for (int i = 0; i < pixelCount; i += 8) {
  __m256i previousChunk = _mm256_loadu_si256(previousFrame);
  __m256i currentChunk = _mm256_loadu_si256(currentFrame);
  __m256i absoluteDiff = _mm256_or_si256(_mm256_subs_epu8(previousChunk, currentChunk), _mm256_subs_epu8(currentChunk, previousChunk));
  __m256i noiseLevelsChunk = _mm256_set_epi8(
    noiseLevels[previousFrame[0]],
    noiseLevels[previousFrame[1]],
    ...
    noiseLevels[previousFrame[30]],
    noiseLevels[previousFrame[31]]
  );
  __m256i xorMask = _mm256_set1_epi8(0x80);
  __m256i comparedChunk = _mm256_cmpgt_epi8(_mm256_xor_si256(absoluteDiff, xorMask), _mm256_xor_si256(noiseLevelsChunk, xorMask));
  int comparisonMask = _mm256_movemask_epi8(comparedChunk);

  if (!comparisonMask) {
    previousFrame += 32;
    currentFrame += 32;
    continue;
  }

  int* pixelComparisons = (int*) &comparedChunk;
  for (int j = 0; j < 8; j++) {
    if (pixelComparisons[j]) {
      // Do stuff
    }
  }

  currentFrame += 32;
  previousFrame += 32;
}

与原始问题相比，这包括以下优化：

使用_mm256_cmpgt_epi8比较absoluteDiff和noiseLevels

我尝试了许多方法来通过AVX 2比较绝对差异和噪声水平，包括使用gather操作来收集内存的噪声水平。然而，对于尝试的所有方法，性能受到影响。最后，使用_mm256_set_epi8将所有噪声电平设置到YMM寄存器中，产生了迄今为止最好的性能。一些猜测：我怀疑原因是previousFrame的相关内容仍然存储在处理器的缓存中（因为previousFrame已经在几行之前被访问，以将其加载到YMM寄存器中），因此在查找噪声水平时它很容易获得。
然后，通过_mm256_cmpgt_epi8进行比较，一次比较8个像素，与单独比较每个像素的颜色分量相比，产生了显着的性能提升。

创建32位掩码提前返回

在comparedChunk中创建每个字节最高有效位的掩码，可以非常快速地跳过8个像素的块，其中没有任何重要的变化：

int comparisonMask = _mm256_movemask_epi8(comparedChunk);
if (!comparisonMask) {
  previousFrame += 32;
  currentFrame += 32;
}

这里的一个旁注是，使用这种特定的优化只有在预期经常发生像素簇没有显著改变的情况下才有帮助。比较具有强方差的帧（例如由于强噪声）可能不会从该优化中受益。

编辑2023-06-13 19：39阿姆斯特丹时间

正如@PeterCordes所指出的，我计算comparedChunk的方法只有在噪声水平和diff都<= 127 u时才有效。由于该算法应该支持完整的无符号字节范围（0-255），我用PeterCordes提出的修复方法更新了这个答案。
旧的（* 错误 *）计算值的方法是：__m256i comparedChunk = _mm256_cmpgt_epi8(absoluteDiff, noiseLevelsChunk);