我正在使用 AVX 同时计算八个点积。在我当前的代码中,我做了这样的事情(在展开之前):
常春藤桥/桑迪桥
__m256 areg0 = _mm256_set1_ps(a[m]);
for(int i=0; i<n; i++) {
__m256 breg0 = _mm256_load_ps(&b[8*i]);
tmp0 = _mm256_add_ps(_mm256_mul_ps(arge0,breg0), tmp0);
}
Haswell
__m256 areg0 = _mm256_set1_ps(a[m]);
for(int i=0; i<n; i++) {
__m256 breg0 = _mm256_load_ps(&b[8*i]);
tmp0 = _mm256_fmadd_ps(arge0, breg0, tmp0);
}
我需要为每种情况展开循环多少次才能确保最大吞吐量?
对于使用 FMA3 的 Haswell 我认为答案就在这里sandy-bridge 和 haswell SSE2/AVX/AVX2 每个周期的 FLOPS。我需要将循环展开 10 次。
对于 Ivy Bridge,我认为是 8。这是我的逻辑。 AVX 加法的延迟为 3,乘法的延迟为 5。Ivy Bridge 可以使用不同的端口同时执行一项 AVX 乘法和一项 AVX 加法。使用符号 m 表示乘法,a 表示加法,x 表示无运算以及表示部分和的数字(例如 m5 表示与第 5 个部分和相乘),我可以写:
port0: m1 m2 m3 m4 m5 m6 m7 m8 m1 m2 m3 m4 m5 ...
port1: x x x x x a1 a2 a3 a4 a5 a6 a7 a8 ...
因此,通过在 9 个时钟周期后使用 8 个部分和(四个来自加载,五个来自乘法),我可以在每个时钟周期提交一个 AVX 加载、一个 AVX 加法和一个 AVX 乘法。
我想这意味着 Ivy Bridge 和 Haswell 中的 32 位模式不可能实现该任务的最大吞吐量,因为 32 位模式只有 8 个 AVX 寄存器?
Edit:关于赏金。我的主要问题仍然存在。我想获得上面的 Ivy Bridge 或 Haswell 函数的最大吞吐量,n
可以是大于或等于 64 的任何值。我认为这只能使用展开来完成(Ivy Bridge 为 8 次,Haswell 为 10 次)。如果您认为可以用其他方法来完成,那么让我们看看。从某种意义上说,这是一个变体如何实现每个周期理论最大 4 次 FLOP?。但我不仅仅需要乘法和加法,而是在 Ivy Bridge 的每个时钟周期寻找一个 256 位负载(或两个 128 位负载)、一个 AVX 乘法和一个 AVX 加法,或者两个 256 位负载和两个 FMA3 指令每个时钟周期。
我还想知道需要多少个寄存器。对于 Ivy Bridge,我认为是 10 个。一个用于广播,一个用于负载(由于寄存器重命名,只有一个),八个用于八个部分和。所以我认为这不能在 32 位模式下完成(事实上,当我在 32 位模式下运行时,性能会显着下降)。
我应该指出编译器可能会给出误导性的结果对于高度优化的矩阵乘法代码,MSVC 和 GCC 之间的性能差异
我当前用于 Ivy Bridge 的函数如下。这基本上是将 64x64 矩阵的一行相乘a
全部为 64x64 矩阵b
(我在每一行上运行这个函数 64 次a
得到矩阵中的完整矩阵乘法c
).
#include <immintrin.h>
extern "C" void row_m64x64(const float *a, const float *b, float *c) {
const int vec_size = 8;
const int n = 64;
__m256 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
tmp0 = _mm256_loadu_ps(&c[0*vec_size]);
tmp1 = _mm256_loadu_ps(&c[1*vec_size]);
tmp2 = _mm256_loadu_ps(&c[2*vec_size]);
tmp3 = _mm256_loadu_ps(&c[3*vec_size]);
tmp4 = _mm256_loadu_ps(&c[4*vec_size]);
tmp5 = _mm256_loadu_ps(&c[5*vec_size]);
tmp6 = _mm256_loadu_ps(&c[6*vec_size]);
tmp7 = _mm256_loadu_ps(&c[7*vec_size]);
for(int i=0; i<n; i++) {
__m256 areg0 = _mm256_set1_ps(a[i]);
__m256 breg0 = _mm256_loadu_ps(&b[vec_size*(8*i + 0)]);
tmp0 = _mm256_add_ps(_mm256_mul_ps(areg0,breg0), tmp0);
__m256 breg1 = _mm256_loadu_ps(&b[vec_size*(8*i + 1)]);
tmp1 = _mm256_add_ps(_mm256_mul_ps(areg0,breg1), tmp1);
__m256 breg2 = _mm256_loadu_ps(&b[vec_size*(8*i + 2)]);
tmp2 = _mm256_add_ps(_mm256_mul_ps(areg0,breg2), tmp2);
__m256 breg3 = _mm256_loadu_ps(&b[vec_size*(8*i + 3)]);
tmp3 = _mm256_add_ps(_mm256_mul_ps(areg0,breg3), tmp3);
__m256 breg4 = _mm256_loadu_ps(&b[vec_size*(8*i + 4)]);
tmp4 = _mm256_add_ps(_mm256_mul_ps(areg0,breg4), tmp4);
__m256 breg5 = _mm256_loadu_ps(&b[vec_size*(8*i + 5)]);
tmp5 = _mm256_add_ps(_mm256_mul_ps(areg0,breg5), tmp5);
__m256 breg6 = _mm256_loadu_ps(&b[vec_size*(8*i + 6)]);
tmp6 = _mm256_add_ps(_mm256_mul_ps(areg0,breg6), tmp6);
__m256 breg7 = _mm256_loadu_ps(&b[vec_size*(8*i + 7)]);
tmp7 = _mm256_add_ps(_mm256_mul_ps(areg0,breg7), tmp7);
}
_mm256_storeu_ps(&c[0*vec_size], tmp0);
_mm256_storeu_ps(&c[1*vec_size], tmp1);
_mm256_storeu_ps(&c[2*vec_size], tmp2);
_mm256_storeu_ps(&c[3*vec_size], tmp3);
_mm256_storeu_ps(&c[4*vec_size], tmp4);
_mm256_storeu_ps(&c[5*vec_size], tmp5);
_mm256_storeu_ps(&c[6*vec_size], tmp6);
_mm256_storeu_ps(&c[7*vec_size], tmp7);
}