Question

我正在尝试创建一个使用英特尔AVX技术并执行矢量乘法和加法的简单程序。在这里，我与此同时使用Open MP。但是由于函数调用_mm256_store_ps（）而导致分段错误。

我已经尝试过OpenMP原子功能，例如原子的，关键的等，因此，如果此功能本质上是原子的，并且多个内核试图同时执行，但无法正常工作。

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<immintrin.h>
#include<omp.h>
#define N 64

__m256 multiply_and_add_intel(__m256 a, __m256 b, __m256 c) {
  return _mm256_add_ps(_mm256_mul_ps(a, b),c);
}

void multiply_and_add_intel_total_omp(const float* a, const float* b, const float* c, float* d)
{
  __m256 a_intel, b_intel, c_intel, d_intel;
  #pragma omp parallel for private(a_intel,b_intel,c_intel,d_intel)
  for(long i=0; i<N; i=i+8) {
    a_intel = _mm256_loadu_ps(&a[i]);
    b_intel = _mm256_loadu_ps(&b[i]);
    c_intel = _mm256_loadu_ps(&c[i]);
    d_intel = multiply_and_add_intel(a_intel, b_intel, c_intel);
    _mm256_store_ps(&d[i],d_intel);
  }
}
int main()
{
    srand(time(NULL));
    float * a = (float *) malloc(sizeof(float) * N);
    float * b = (float *) malloc(sizeof(float) * N);
    float * c = (float *) malloc(sizeof(float) * N);
    float * d_intel_avx_omp = (float *)malloc(sizeof(float) * N);
    int i;
    for(i=0;i<N;i++)
    {
        a[i] = (float)(rand()%10);
        b[i] = (float)(rand()%10);
        c[i] = (float)(rand()%10);
    }
    double time_t = omp_get_wtime();
    multiply_and_add_intel_total_omp(a,b,c,d_intel_avx_omp);
    time_t = omp_get_wtime() - time_t;
    printf("\nTime taken to calculate with AVX2 and OMP : %0.5lf\n",time_t);
  }

  free(a);
  free(b);
  free(c);
  free(d_intel_avx_omp);
    return 0;
}

我希望我得到d = a * b + c，但它显示出分段错误。我试图在没有OpenMP的情况下执行相同的任务，并且它工作正常。请让我知道是否存在任何兼容性问题，或者我缺少任何部分。

gcc版本7.3.0
英特尔®酷睿™i3-3110M处理器
操作系统Ubuntu 18.04
打开MP 4.5，我执行了命令$ echo |cpp -fopenmp -dM |grep -i open，它显示了#define _OPENMP 201511
编译命令gcc first_int.c -mavx -fopenmp

** UPDATE **

根据讨论和建议，新代码为

 float * a = (float *) aligned_alloc(N, sizeof(float) * N);
 float * b = (float *) aligned_alloc(N, sizeof(float) * N);
 float * c = (float *) aligned_alloc(N, sizeof(float) * N);
 float * d_intel_avx_omp = (float *)aligned_alloc(N, sizeof(float) * N);

无法正常工作。

请注意，我正在尝试比较常规计算，avx计算和avx + openmp计算。这是我得到的结果，

不使用AVX进行计算所需的时间：0.00037

使用AVX计算所需的时间：0.00024

使用AVX和OMP计算所需的时间：0.00019

N = 50000

Answer 1

_mm256_store_ps的文档说：

将a中的256位（由8个压缩的单精度（32位）浮点元素组成）存储到内存中。 mem_addr必须在32字节的边界上对齐，否则可能会生成常规保护异常。

您可以使用_mm256_storeu_si256代替未对齐的商店。

一个更好的选择是将所有阵列对齐在32字节边界上（对于256位avx寄存器），并使用对齐的加载和存储来获得最佳性能，因为未对齐的加载/存储越过缓存行边界会导致性能下降。

使用std::aligned_alloc（或C11 aligned_alloc，memalign，posix_memalign，无论可用的方式）代替malloc(size)，例如：

float* allocate_aligned(size_t n) {
    constexpr size_t alignment = alignof(__m256);
    return static_cast<float*>(aligned_alloc(alignment, sizeof(float) * n));
}
// ...
float* a = allocate_aligned(N);
float* b = allocate_aligned(N);
float* c = allocate_aligned(N);
float* d_intel_avx_omp = allocate_aligned(N);

在C ++-17中，new可以对齐分配：

float* allocate_aligned(size_t n) {
    constexpr auto alignment = std::align_val_t{alignof(__m256)};
    return new(alignment) float[n];
}

或者，使用Vc: portable, zero-overhead C++ types for explicitly data-parallel programming为您对齐堆分配的SIMD向量：

#include <cstdio>
#include <memory>
#include <chrono>
#include <Vc/Vc>

Vc::float_v random_float_v() {
    alignas(Vc::VectorAlignment) float t[Vc::float_v::Size];
    for(unsigned i = 0; i < Vc::float_v::Size; ++i)
        t[i] = std::rand() % 10;
    return Vc::float_v(t, Vc::Aligned);
}

unsigned reverse_crc32(void const* vbegin, void const* vend) {
    unsigned const* begin = reinterpret_cast<unsigned const*>(vbegin);
    unsigned const* end = reinterpret_cast<unsigned const*>(vend);
    unsigned r = 0;
    while(begin != end)
        r = __builtin_ia32_crc32si(r, *--end);
    return r;
}

int main() {
    constexpr size_t N = 65536;
    constexpr size_t M = N / Vc::float_v::Size;

    std::unique_ptr<Vc::float_v[]> a(new Vc::float_v[M]);
    std::unique_ptr<Vc::float_v[]> b(new Vc::float_v[M]);
    std::unique_ptr<Vc::float_v[]> c(new Vc::float_v[M]);
    std::unique_ptr<Vc::float_v[]> d_intel_avx_omp(new Vc::float_v[M]);

    for(unsigned i = 0; i < M; ++i) {
        a[i] = random_float_v();
        b[i] = random_float_v();
        c[i] = random_float_v();
    }

    auto t0 = std::chrono::high_resolution_clock::now();
    for(unsigned i = 0; i < M; ++i)
        d_intel_avx_omp[i] = a[i] * b[i] + c[i];
    auto t1 = std::chrono::high_resolution_clock::now();

    double seconds = std::chrono::duration_cast<std::chrono::duration<double>>(t1 - t0).count();
    unsigned crc = reverse_crc32(d_intel_avx_omp.get(), d_intel_avx_omp.get() + M); // Make sure d_intel_avx_omp isn't optimized out.
    std::printf("crc: %u, time: %.09f seconds\n", crc, seconds);
}

并行版本：

#include <tbb/parallel_for.h>
// ...
    auto t0 = std::chrono::high_resolution_clock::now();
    tbb::parallel_for(size_t{0}, M, [&](unsigned i) {
        d_intel_avx_omp[i] = a[i] * b[i] + c[i];
    });
    auto t1 = std::chrono::high_resolution_clock::now();

Answer 2

您必须对这些内部函数使用对齐的内存。将您的malloc(...)更改为aligned_alloc(sizeof(float) * 8, ...)（C11）。

这与原子完全无关。您正在处理完全独立的数据（即使是在不同的缓存行上），因此不需要任何保护。

_mm256_store_ps（）函数是否是原子函数？与openmp一起使用

2 个答案: