Question

使用intrinsics是SIMDizing的常用方法。例如，我可以通过_mm256_add_epi32对八个整数执行单个add指令。添加后需要两个_mm256_load_si256和一个_mm256_store_si256，如下所示：

__m256i vec1 = _mm256_load_si256((__m256i *)&A[0]); // almost 5 cycles
__m256i vec2 = _mm256_load_si256((__m256i *)&B[0]); // almost 5 cycles
__m256i vec3 = _mm256_add_epi32( vec1 , vec2); // almost 1 cycle
_mm256_store_si256((__m256i *)&C[0], vec3); // almost 5

它执行CPU的单核上的指令。 My Core i7有8核（4真）;我想将操作发送到所有内核，如下所示：

int i_0, i_1, i_2, i_3, i_4, i_5, i_6, i_7 ; // These specify the values in memory
//core 0
__m256i vec1_0 = _mm256_load_si256((__m256i *)&A[i_0]);  
__m256i vec2_0 = _mm256_load_si256((__m256i *)&B[i_0]); 
__m256i vec3_0 = _mm256_add_epi32( vec1 , vec2); 
_mm256_store_si256((__m256i *)&C[i_0], vec3_0);

//core 1
__m256i vec1_1 = _mm256_load_si256((__m256i *)&A[i_1]);
__m256i vec2_1 = _mm256_load_si256((__m256i *)&B[i_1]);
__m256i vec3_1 = _mm256_add_epi32( vec1 , vec2);
_mm256_store_si256((__m256i *)&C[i_1], vec3_1);

//core 2
__m256i vec1_2 = _mm256_load_si256((__m256i *)&A[i_2]);
__m256i vec2_2 = _mm256_load_si256((__m256i *)&B[i_2]);
__m256i vec3_2 = _mm256_add_epi32( vec1 , vec2);
_mm256_store_si256((__m256i *)&C[i_2], vec3_2);

//core 3
__m256i vec1_3 = _mm256_load_si256((__m256i *)&A[i_3]);
__m256i vec2_3 = _mm256_load_si256((__m256i *)&B[i_3]);
__m256i vec3_3 = _mm256_add_epi32( vec1 , vec2);
_mm256_store_si256((__m256i *)&C[i_3], vec3_3);

//core 4
__m256i vec1_4 = _mm256_load_si256((__m256i *)&A[i_4]);
__m256i vec2_4 = _mm256_load_si256((__m256i *)&B[i_4]);
__m256i vec3_4 = _mm256_add_epi32( vec1 , vec2);
_mm256_store_si256((__m256i *)&C[i_4], vec3_4);

//core 5
__m256i vec1_5 = _mm256_load_si256((__m256i *)&A[i_5]);
__m256i vec2_5 = _mm256_load_si256((__m256i *)&B[i_5]);
__m256i vec3_5 = _mm256_add_epi32( vec1 , vec2);
_mm256_store_si256((__m256i *)&C[i_5, vec3_5);

//core 6
__m256i vec1_6 = _mm256_load_si256((__m256i *)&A[i_6]);
__m256i vec2_6 = _mm256_load_si256((__m256i *)&B[i_6]);
__m256i vec3_6 = _mm256_add_epi32( vec1 , vec2);
_mm256_store_si256((__m256i *)&C[i_6], vec3_6);

//core 7
__m256i vec1_7 = _mm256_load_si256((__m256i *)&A[i_7]);
__m256i vec2_7 = _mm256_load_si256((__m256i *)&B[i_7]);
__m256i vec3_7 = _mm256_add_epi32( vec1 , vec2);
_mm256_store_si256((__m256i *)&C[i_7], vec3_7);

POSIX线程可用，在这种情况下openMP也很有用。但是，与此操作的几乎5+5+1个问题相比，创建和维护线程需要花费太多时间。因为，所有数据都是相关的，所以我不需要观察共享内存。实现此操作的最快显式方法是什么？

因此我在GPP上工作，GPU可能不是答案。我还想实现一个库，因此编译器基础解决方案可能是一个挑战者。问题对于多线程来说已经够大了。这是我的研究，因此我可以改变问题以适应这个概念。我想实现一个库并将其与其他解决方案（如OpenMP）进行比较，希望我的库比其他当前解决方案更快。 GCC 6.3/clang 3.8, Linux Mint, Skylake

提前致谢。

Answer 1

如果问题很严重，必须多线程。

您可以选择openmp或pthread，它们会为您提供类似的性能级别（使用pthread可能会更好一点，但这将是不可移植的并且维护起来更复杂）。

您的代码将受带宽限制，绝对不受计算限制。

为了实现最大吞吐量，您需要通过多线程交错独立的内存操作。

一个非常简单的解决方案，如

extern "C" void add(int* a, int* b, int* c, int N) {
    #pragma omp parallel for
    for(int i = 0; i < N; ++i) {
        a[i] = b[i] + c[i];
    }
}

可能会在每个编译器的所有系统上为您提供可接受的性能。

事实上，让编译器优化可能会给你带来良好的性能，并且肯定会帮助你编写可读的代码。

但有时候，即使是最好的编译器也不能给出满意的结果（总是在性能关键部分检查你的程序集）。

他们需要帮助，有时您需要自己编写程序集。

这是我要遵循的路径，以优化此循环，直到我得到我想要的结果。

首先，您可以实施经典的优化技巧：

常量和别名

通过__restrict关键字提供常量并防止别名：

extern "C" void add(int* __restrict a, const int* __restrict b, const int* __restrict c, int N) {
    #pragma omp parallel for
    for(int i = 0; i < N; ++i) {
        a[i] = b[i] + c[i];
    }
}

这将有助于编译器，因为它将知道a，b和c不能相互alias。

对象信息：

告诉编译器你的指针是否正确对齐

#define RESTRICT __restrict

    typedef __attribute__((aligned(32))) int* intptr;

    extern "C" void add(intptr RESTRICT a, const intptr RESTRICT b, const intptr RESTRICT c, int N) {
        #pragma omp parallel for
        for(int i = 0; i < N; ++i) {
            a[i] = b[i] + c[i];
        }
    }

这也有助于编译器生成vload指令而不是vloadu（加载未对齐）。

展开内部循环（如果可以）：

如果您知道问题大小（如果是256位的倍数），您甚至可以展开内部循环：

#define RESTRICT __restrict

typedef __attribute__((aligned(32))) int* intptr;

extern "C" void add(intptr RESTRICT a, const intptr RESTRICT b, const intptr RESTRICT c, int N) {
    #pragma omp parallel for
    for(int i = 0; i < N; i += 8) {
        #pragma unroll
        for(int k = 0; k < 8; ++k)
        a[i+k] = b[i+k] + c[i+k];
    }
}

使用该代码，clang 4.0提供了非常简洁的程序集：

...
 vmovdqu ymm0, ymmword ptr [rdx + 4*rcx]
 vpaddd  ymm0, ymm0, ymmword ptr [rsi + 4*rcx]
 vmovdqu ymmword ptr [rdi + 4*rcx], ymm0
...

由于某些原因，您需要调整属性和编译指示以与其他编译器具有相同的结果。

的内在函数

如果你想确保你有正确的装配，那么你必须去内在/装配。

简单的事情：

#define RESTRICT __restrict typedef __attribute__((aligned(32))) int* intptr; extern "C" void add(intptr RESTRICT a, const intptr RESTRICT b, const intptr RESTRICT c, int N) { #pragma omp parallel for for(int i = 0; i < N; i += 8) { __m256i vb = _mm256_load_si256((__m256i*) (b + i)); __m256i vc = _mm256_load_si256((__m256i*) (c + i)); _mm256_store_si256((__m256i*) (a + i), _mm256_add_epi32(vb, vc)); } }

非临时商店：作为最后的优化，你可以在store指令上使用non-temporal hint，因为循环的另一个迭代不会读取你刚写的值：

typedef __attribute__((aligned(32))) int* intptr; extern "C" void add(intptr RESTRICT a, const intptr RESTRICT b, const intptr RESTRICT c, int N) { #pragma omp parallel for for(int i = 0; i < N; i += 8) { __m256i vb = _mm256_load_si256((__m256i*) (b + i)); __m256i vc = _mm256_load_si256((__m256i*) (c + i)); _mm256_stream_si256((__m256i*) (a + i), _mm256_add_epi32(vb, vc)); } }

给你那个集会：

.L3: vmovdqa ymm0, YMMWORD PTR [rdx+rax] vpaddd ymm0, ymm0, YMMWORD PTR [rsi+rax] vmovntdq YMMWORD PTR [rdi+rax], ymm0 add rax, 32 cmp rcx, rax jne .L3 vzeroupper

如果您在每一步都对cmp指令感到担心，可以在循环中展开更多步骤，但branch prediction在现代处理器上做得相当不错

[编辑：添加pthread] 如上所述，pthread管理起来有点痛苦...... 这是一个使用pthread的完整功能示例：

#include <pthread.h> #include <cstdlib> #include <cstdio> #include <immintrin.h> typedef struct AddStruct { int *a, *b, *c; int N; } AddStruct_t; void* add(void* s); int main() { const int N = 1024*1024*32; // out of cache int *a, *b, *c; int err; err = posix_memalign((void**) &a, 32, N*sizeof(int)); err = posix_memalign((void**) &b, 32, N*sizeof(int)); err = posix_memalign((void**) &c, 32, N*sizeof(int)); for(int i = 0; i < N; ++i) { a[i] = 0; b[i] = 1; c[i] = i; } int slice = N / 8; pthread_t threads[8]; AddStruct_t arguments[8]; for(int i = 0; i < 8; ++i) { arguments[i].a = a + slice * i; arguments[i].b = b + slice * i; arguments[i].c = c + slice * i; arguments[i].N = slice; } for(int i = 0; i < 8; ++i) { if(pthread_create(&threads[i], NULL, add, &arguments[i])) { fprintf(stderr, "ERROR CREATING THREAD %d\n", i); abort(); } } for(int i = 0; i < 8; ++i) { pthread_join(threads[i], NULL); } for(int i = 0; i < N; ++i) { if(a[i] != i + 1) { fprintf(stderr, "ERROR AT %d: expected %d, actual %d\n", i, i+1, a[i]); abort(); } } fprintf(stdout, "OK\n"); } void* add(void* v) { AddStruct_t* s = (AddStruct_t*) v; for(int i = 0; i < s->N; i += 8) { __m256i vb = _mm256_load_si256((__m256i*) (s->b + i)); __m256i vc = _mm256_load_si256((__m256i*) (s->c + i)); _mm256_stream_si256((__m256i*) (s->a + i), _mm256_add_epi32(vb, vc)); } }

此代码在我的Xeon E5-1620 v3上实现了34 GB / s，DDR4内存@ 2133 MHz，而开始时的简单解决方案是33 GB / S.

所有那些努力节省3％:)。但有时这3％可能是至关重要的。

请注意，内存初始化应该由执行计算的同一核心执行（对于NUMA系统尤其如此），以避免页面迁移。

Answer 2

实施的最快方法是：

void add_ints(int *vec1, int *vec2, int *vec3 int n){
 int i; 
#pragma simd
for (i=0; i<n; i++){
  vec3[i] = vec1[i] + vec2[i] ;
}

“自己滚动”是否更快值得进行一些调查。但是“滚动你自己”可能更容易出错......这使得它实施起来更慢。

对于这些简单的问题，人们会期望编译器编写者足够复杂，能够理解最简单问题的最快解决方案，而且他们甚至可以很好地找到解决复杂问题的最快解决方案......而且#pragma的使用有助于它们。

其次;我很少发现“SIMD并行”在IO驱动问题上运行速度更快的情况，例如与单核上的直接“SIMD”相比。我通常只能达到1600 MB /秒的吞吐量，1600个内存似乎相当不错除非GPU具有比1600 MB /秒更高的IO带宽，否则在单个主机核心上可能会更好，并且在需要更多数学/ IO时使用GPU。

然而，您可以而且应该尝试亲自看看。（是的......以下示例不在icc网站上）

#pragma omp parallel for simd schedule(static,10) {
  for (i=0; i<N; i++) { vec3[i] = vec1[i] + vec2[i]; }
}

在你有了简单的方法之后，你可以使用单核和多核来测量使用-O3在编译器上执行“滚动你自己”的效果。

考虑矢量的另一个选择是CILK +。当一个来自MATLAB或Fortran背景时，尤其如此，因为矢量和矩阵/数组结构非常相似。

基本上SIMD内在函数在早期是“流行”的，一旦编译器和OpenMP将它们引入内部，那么当仅为编译器无法提供向量机的情况保留时，内在函数的使用似乎更好 - 为你编码。

明确地进行多线程SIMD操作的最快方法是什么？

2 个答案: