如何解决在 AVX 寄存器之间移动长向量在 AVX512VL CPU 之前
我在制作一些 2D/平面图像数据重采样器和当前最高性能的 2D 卷积方法的过程中需要以固定数量的 float32（4 字节）值在 AVX（ymm 或 zmm）寄存器之间执行长 float32 向量的移位.移位距离等于图像放大的乘法比，因此对于整数比，我需要在很长的 AVX 寄存器之间移位到 2,3,4,5,6 float32。 8 和 16 的移位只是寄存器的重命名。
目前最快的转移到 4 个 float32 的代码使用罕见的 AVX 指令
_mm256_permute2f128_ps。它允许在 2 个 ymm 寄存器之间移动和交换数据。
所以当前在 7 个 ymm 寄存器之间转移到 4 个 float32 看起来像
_mm_store_ps(pfProc,_mm256_castps256_ps128(my_ymm0));
my_ymm0 = _mm256_permute2f128_ps(my_ymm0,my_ymm1,33);
my_ymm1 = _mm256_permute2f128_ps(my_ymm1,my_ymm2,33);
my_ymm2 = _mm256_permute2f128_ps(my_ymm2,my_ymm3,33);
my_ymm3 = _mm256_permute2f128_ps(my_ymm3,my_ymm4,33);
my_ymm4 = _mm256_permute2f128_ps(my_ymm4,my_ymm5,33);
my_ymm5 = _mm256_permute2f128_ps(my_ymm5,my_ymm6,33);
my_ymm6 = _mm256_permute2f128_ps(my_ymm6,49);
my_ymm6 = _mm256_insertf128_ps(my_ymm6,*(__m128*)(pfProc + 56),1);
以先存出4个浮点数的结果，移位加载4个浮点数到最后。在大量 fma 指令的情况下，这种多样本卷积方法达到了具有 4 个 FMA512 单元的 4 核英特尔第 9 代 CPU 理论 FMA 性能的 30..35%。
不幸的是，我在 AVX512VL 之前的指令集中找不到 1 条指令来转移到其他数量的浮点数。
目前在 before_AVX512VL 上找到的用于转移到 2 个浮点数的方法使用置换在 ymm 内进行转移并混合以将移出的浮点数转移到另一个 ymm：
const register __m256i my_ymm8_main_circ = _mm256_set_epi32(1,7,6,2); // main circulating const
my_ymm2 = _mm256_permutevar8x32_ps(my_ymm2,my_ymm8_main_circ); // circulate by 2 ps to the left
my_ymm3 = _mm256_permutevar8x32_ps(my_ymm3,my_ymm8_main_circ); // circulate by 2 ps to the left
my_ymm2 = _mm256_blend_ps(my_ymm2,192); // copy higher 2 floats
my_ymm4 = _mm256_permutevar8x32_ps(my_ymm4,my_ymm8_main_circ); // circulate by 2 ps to the left
my_ymm3 = _mm256_blend_ps(my_ymm3,192); // copy higher 2 floats
my_ymm5 = _mm256_permutevar8x32_ps(my_ymm5,my_ymm8_main_circ); // circulate by 2 ps to the left
my_ymm4 = _mm256_blend_ps(my_ymm4,192); // copy higher 2 floats
my_ymm6 = _mm256_permutevar8x32_ps(my_ymm6,my_ymm8_main_circ); // circulate by 2 ps to the left
my_ymm5 = _mm256_blend_ps(my_ymm5,192); // copy higher 2 floats
my_ymm7 = _mm256_permutevar8x32_ps(my_ymm7,my_ymm8_main_circ); // circulate by 2 ps to the left
my_ymm6 = _mm256_blend_ps(my_ymm6,my_ymm7,192); // copy higher 2 floats
它的工作速度明显变慢，并且使用非常大的立即数（大小与 ymm 256 位寄存器一样大）来仅设置几个用于排列的控制位。这不允许使用更多 ymm regs 进行数据存储，并导致编译器立即加载/存储并减慢执行速度。
另一种方法是存储（到 L1d 缓存）来自 5..7 ymm regs 的长向量并使用移位地址加载回。但由于大型降压内存读写操作，它看起来更慢，我无法确定它是否不会通过所有缓存层次结构传输，从而导致内存控制器减慢多核 CPU 中的主内存加载/存储流。>
使用 AVX512VL 指令集，我看到了 2 源排列指令
_mm512_permutex2var_ps（也使用大 zmm 立即数选择 float32 进行排列）。
它可以将 _mm256_permute2f128_ps 替换为取自第 1 个和第 2 个 zmm 寄存器的任意数量的 float32，因此允许在 1 条指令中的寄存器之间移动到任意数量的 float32。
但 AVX512VL CPU 甚至在 2021 年也不会在最终用户中普遍使用。可能在 10 年后才会如此。但不是现在。
对于不具备 AVX512VL 功能的 CPU，可能存在其他方法，以便在以 ps 浮点数为单位测量的任何步骤中更快地在多个 ymm（并且可能是 zmm）寄存器之间移动 float32 长向量？
关于使用这个长向量移位的整个实现算法，我有几个问题。最简短的 2D/平面 upsizer 到 4x 函数列表之一是：
void JincResize::KernelRowAll_avx2_mul4_taps4_cb(unsigned char* src,int iSrcStride,int iInpWidth,int iInpHeight,unsigned char* dst,int iDstStride,const int ciMul,const int ciTaps,const int ciKS)
{
// current input plane sizes
iWidthEl = iInpWidth + 64/*2 * iKernelSize*/;
iHeightEl = iInpHeight + 64/*2 * iKernelSize*/;
const int k_col8 = 32/*iKernelSize*/ - (32/*iKernelSize*/ % 8);
const int col8 = iWidthEl - 4/*iTaps*/ - ((iWidthEl - 4/*iTaps*/) % 8);
float* pfCurrKernel = g_pfKernel;
int64_t col;
memset(pfFilteredCirculatingBuf,iWidthEl * 32 * 4/*iKernelSize * iMul*/ * sizeof(float));
// no MT version
for (int64_t row = 4/*iTaps*/; row < iHeightEl - 4/*iTaps*/; row++) // input lines counter
{
// start all row-only dependent ptrs here
float* pfInpRowSamplesFloatBufStart = pfInpFloatRow;
GetInpElRowAsFloat_avx2(row,iInpHeight,iInpWidth,src,iSrcStride,pfInpRowSamplesFloatBufStart,32/*iKernelSize*/);
for (col = 4/*iTaps*/; col < col8; col += 8) // input cols counter
{
float* pfColStart = pfInpRowSamplesFloatBufStart + col;
float* pfCurrKernel_pos = pfCurrKernel;
for (int64_t k_row = 0; k_row < iKernelSize; k_row++)
{
float* pfProc = vpfRowsPointers[k_row] + col * 4/*iMul*/;
__m256 my_ymm0,my_ymm7; // out samples
__m256 my_ymm8,my_ymm9,my_ymm10,my_ymm11; // inp samples
__m256 my_ymm12,my_ymm13,my_ymm14,my_ymm15; // kernel samples
my_ymm12 = _mm256_load_ps(pfCurrKernel_pos);
my_ymm13 = _mm256_load_ps(pfCurrKernel_pos + 8);
my_ymm14 = _mm256_load_ps(pfCurrKernel_pos + 16);
my_ymm15 = _mm256_load_ps(pfCurrKernel_pos + 24);
my_ymm0 = _mm256_load_ps(pfProc);
my_ymm1 = _mm256_load_ps(pfProc + 8);
my_ymm2 = _mm256_load_ps(pfProc + 16);
my_ymm3 = _mm256_load_ps(pfProc + 24);
my_ymm4 = _mm256_load_ps(pfProc + 32);
my_ymm5 = _mm256_load_ps(pfProc + 40);
my_ymm6 = _mm256_load_ps(pfProc + 48);
my_ymm8 = _mm256_broadcast_ss(pfColStart + 0); // 1
my_ymm9 = _mm256_broadcast_ss(pfColStart + 2); // 3
my_ymm10 = _mm256_broadcast_ss(pfColStart + 4); // 5
my_ymm11 = _mm256_broadcast_ss(pfColStart + 6); // 7
// 1st sample
my_ymm0 = _mm256_fmadd_ps(my_ymm12,my_ymm8,my_ymm0);
my_ymm1 = _mm256_fmadd_ps(my_ymm13,my_ymm1);
my_ymm2 = _mm256_fmadd_ps(my_ymm14,my_ymm2);
my_ymm3 = _mm256_fmadd_ps(my_ymm15,my_ymm3);
// 3rd sample
my_ymm1 = _mm256_fmadd_ps(my_ymm12,my_ymm1);
my_ymm2 = _mm256_fmadd_ps(my_ymm13,my_ymm2);
my_ymm3 = _mm256_fmadd_ps(my_ymm14,my_ymm3);
my_ymm4 = _mm256_fmadd_ps(my_ymm15,my_ymm4);
// 5th sample
my_ymm2 = _mm256_fmadd_ps(my_ymm12,my_ymm2);
my_ymm3 = _mm256_fmadd_ps(my_ymm13,my_ymm3);
my_ymm4 = _mm256_fmadd_ps(my_ymm14,my_ymm4);
my_ymm5 = _mm256_fmadd_ps(my_ymm15,my_ymm5);
// 7th sample
my_ymm3 = _mm256_fmadd_ps(my_ymm12,my_ymm11,my_ymm3);
my_ymm4 = _mm256_fmadd_ps(my_ymm13,my_ymm4);
my_ymm5 = _mm256_fmadd_ps(my_ymm14,my_ymm5);
my_ymm6 = _mm256_fmadd_ps(my_ymm15,my_ymm6);
_mm_store_ps(pfProc,_mm256_castps256_ps128(my_ymm0));
my_ymm0 = _mm256_permute2f128_ps(my_ymm0,33);
my_ymm1 = _mm256_permute2f128_ps(my_ymm1,33);
my_ymm2 = _mm256_permute2f128_ps(my_ymm2,33);
my_ymm3 = _mm256_permute2f128_ps(my_ymm3,33);
my_ymm4 = _mm256_permute2f128_ps(my_ymm4,33);
my_ymm5 = _mm256_permute2f128_ps(my_ymm5,33);
my_ymm6 = _mm256_permute2f128_ps(my_ymm6,49);
my_ymm6 = _mm256_insertf128_ps(my_ymm6,1);
// even samples
my_ymm8 = _mm256_broadcast_ss(pfColStart + 1); // 2
my_ymm9 = _mm256_broadcast_ss(pfColStart + 3); // 4
my_ymm10 = _mm256_broadcast_ss(pfColStart + 5); // 6
my_ymm11 = _mm256_broadcast_ss(pfColStart + 7); // 8
// 2nd sample
my_ymm0 = _mm256_fmadd_ps(my_ymm12,my_ymm3);
// 4th sample
my_ymm1 = _mm256_fmadd_ps(my_ymm12,my_ymm4);
// 6th sample
my_ymm2 = _mm256_fmadd_ps(my_ymm12,my_ymm5);
// 7th sample
my_ymm3 = _mm256_fmadd_ps(my_ymm12,my_ymm6);
_mm256_store_ps(pfProc + 4,my_ymm0);
_mm256_store_ps(pfProc + 12,my_ymm1);
_mm256_store_ps(pfProc + 20,my_ymm2);
_mm256_store_ps(pfProc + 28,my_ymm3);
_mm256_store_ps(pfProc + 36,my_ymm4);
_mm256_store_ps(pfProc + 44,my_ymm5);
_mm256_store_ps(pfProc + 52,my_ymm6);
pfCurrKernel_pos += 32/*iKernelSize*/; // point to next kernel row now
} // k_row
} // col
// need to process last up to 7 cols separately...
for (col = col8 + 4/*iTaps*/; col < iWidthEl - 4/*iTaps*/; col++) // input cols counter
{
float* pfCurrKernel_pos = pfCurrKernel;
float* pfProc;
for (int64_t k_row = 0; k_row < 32/*iKernelSize*/; k_row++)
{
pfProc = vpfRowsPointers[k_row] + col * 4/*iMul*/;
for (int64_t k_col = 0; k_col < k_col8; k_col += 8)
{
*(__m256*)(pfProc + k_col) = _mm256_fmadd_ps(*(__m256*)(pfCurrKernel_pos + k_col),_mm256_broadcast_ss(&pfInpRowSamplesFloatBufStart[col]),*(__m256*)(pfProc + k_col));
}
// need to process last (up to 7) floats separately..
for (int64_t k_col = k_col8; k_col < 32/*iKernelSize*/; ++k_col)
{
pfProc[k_col] += (pfCurrKernel_pos[k_col] * pfInpRowSamplesFloatBufStart[col]);
}
pfCurrKernel_pos += 32/*iKernelSize*/; // point to next kernel row now
} // k_row
} // col
int iOutStartRow = (row - (4 + 32/*iTaps + iKernelSize*/)) * 4/*iMul*/;
//iMul rows ready - output result,skip iKernelSize+iTaps rows from beginning
if (iOutStartRow >= 0 && iOutStartRow < (iInpHeight) * 4/*iMul*/)
{
ConvertiMulRowsToInt_avx2(vpfRowsPointers,iOutStartRow,dst,iDstStride);
}
// circulate pointers to iMul rows upper
std::rotate(vpfRowsPointers.begin(),vpfRowsPointers.begin() + 4/*iMul*/,vpfRowsPointers.end());
// clear last iMul rows
for (int i = 32 - 4/*iKernelSize - iMul*/; i < 32/*iKernelSize*/; i++)
{
memset(vpfRowsPointers[i],iWidthEl * 4/*iMul*/ * sizeof(float));
}
} // row
}
如要求添加重采样器的完全非矢量化的 C 版本：
void JincResize::KernelRowAll_c_mul_cb(unsigned char *src,unsigned char *dst,int iDstStride)
{
iWidthEl = iInpWidth + 2 * iKernelSize;
iHeightEl = iInpHeight + 2 * iKernelSize;
float* pfCurrKernel = g_pfKernel;
memset(pfFilteredCirculatingBuf,iWidthEl * iKernelSize * iMul * num_threads * sizeof(float));
// single threaded for now
for (int64_t row = iTaps; row < iHeightEl - iTaps; row++) // input lines counter
{
float* pfInpRowSamplesFloatBufStart = pfInpFloatRow;
(this->*GetInpElRowAsFloat)(row,pfInpRowSamplesFloatBufStart);
for (int64_t col = iTaps; col < iWidthEl - iTaps; col++) // input cols counter
{
float fInpSample = pfInpRowSamplesFloatBufStart[col];
float* pfCurrKernel_pos = pfCurrKernel;
float* pfProc;
for (int64_t k_row = 0; k_row < iKernelSize; k_row++)
{
pfProc = vpfRowsPointers[k_row] + col * iMul;
for (int64_t k_col = 0; k_col < iKernelSize; k_col++)
{
pfProc[k_col] += pfCurrKernel_pos[k_col] * fInpSample;
} // k_col
pfCurrKernel_pos += iKernelSize; // point to next kernel row now
} // k_row
} // col
int iOutStartRow = (row - (iTaps + iKernelSize))*iMul;
//iMul rows ready - output result,skip iKernelSize+iTaps rows from beginning
if (iOutStartRow >= 0 && iOutStartRow < (iInpHeight)*iMul)
{
ConvertNRowsToInt_c(vpfRowsPointers,iDstStride,iMul);
}
// circulate pointers to iMul rows upper
std::rotate(vpfRowsPointers.begin(),vpfRowsPointers.begin() + iMul,vpfRowsPointers.end());
// clear last iMul rows
for (int i = iKernelSize - iMul; i < iKernelSize; i++)
{
memset(vpfRowsPointers[i],iWidthEl*iMul * sizeof(float));
}
}
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
