c++ - C/C++:通过将参数复制到局部变量来模拟限制关键字

使用 vector 内在函数(AVX)时遇到以下问题，但该问题可能也适用于顺序编程。它涉及restrict关键字的使用。关键字在C99中可用，但在C++中不可用(大多数编译器提供的特殊关键字除外)。我的问题是:是否可以通过将数据从非restrict指针参数复制到局部变量来避免使用restrict？它在我的示例中有效，但是可以保证这种行为吗？
这是我的代码，其中包含4种不同版本的SIMD vector 加法。第一个版本vecAdd1()将参数作为restrict指针传递。所有其他版本均使用常规(non- restrict)指针作为参数。第二个版本vecAdd2()没有进一步的代码修改。第三版vecAdd3()将每个结构的data指针复制到局部变量中。第四版vecAdd4()对n的大小也相同。

#include <stdio.h>
#include <x86intrin.h>

#define N 8 // 8 floats per AVX vector
#define SIZE 1000 // 1000 floats per data vector

typedef struct { int n; float *data; } Vec;

void vecCreate(int size, Vec *v) {
  v->n = size;
  posix_memalign((void**)&(v->data), 32, size * sizeof(float));
}


void vecAdd1(Vec * restrict a, Vec * restrict b, Vec * restrict c) {
  __m256 va, vb, vc;
  for (int i = 0; i <= (a->n - N); i += N) {
    va = _mm256_load_ps(a->data + i);
    vb = _mm256_load_ps(b->data + i);
    vc = _mm256_add_ps(va, vb);
    _mm256_store_ps(c->data + i, vc);
  }
}

void vecAdd2(Vec *a, Vec *b, Vec *c) {
  __m256 va, vb, vc;
  for (int i = 0; i <= (a->n - N); i += N) {
    va = _mm256_load_ps(a->data + i);
    vb = _mm256_load_ps(b->data + i);
    vc = _mm256_add_ps(va, vb);
    _mm256_store_ps(c->data + i, vc);
  }
}

void vecAdd3(Vec *a, Vec *b, Vec *c) {
  __m256 va, vb, vc;
  float *pa = a->data, *pb = b->data, *pc = c->data;
  for (int i = 0; i <= (a->n - N); i += N) {
    va = _mm256_load_ps(pa + i);
    vb = _mm256_load_ps(pb + i);
    vc = _mm256_add_ps(va, vb);
    _mm256_store_ps(pc + i, vc);
  }
}

void vecAdd4(Vec *a, Vec *b, Vec *c) {
  __m256 va, vb, vc;
  float *pa = a->data, *pb = b->data, *pc = c->data;
  int ae = a->n - N;
  for (int i = 0; i <= ae; i += N) {
    va = _mm256_load_ps(pa + i);
    vb = _mm256_load_ps(pb + i);
    vc = _mm256_add_ps(va, vb);
    _mm256_store_ps(pc + i, vc);
  }
}



int
main()
{
  Vec a, b, c;
  vecCreate(1000, &a);
  vecCreate(1000, &b);
  vecCreate(1000, &c);
  vecAdd1(&a, &b, &c);
  vecAdd2(&a, &b, &c);
  vecAdd3(&a, &b, &c);
  vecAdd4(&a, &b, &c);
  printf("%g\n", c.data[123]);
  return 0;
}

(仅说明一下:-N和<=用于将处理限制为可以加载和存储整个SIMD vector 的部分。我省略了顺序后同步码。)
这是编译器调用:

gcc -O3 -mno-avx256-split-unaligned-load -mno-avx256-split-unaligned-store -march=native -masm=intel -save-temps -std=c99 -Wall -o vecadd vecadd.c

我正在使用7.5.0版。在下面的内容中，我仅显示vecadd.s中汇编代码的相关部分。
在vecAdd1()中，循环具有非常有效的实现:加载一个SIMD vector ，添加第二个，存储结果，前进指针，检查循环结束:

.L5:
    vmovaps ymm0, YMMWORD PTR [rdi+rax]
    vaddps  ymm0, ymm0, YMMWORD PTR [rsi+rax]
    vmovaps YMMWORD PTR [rcx+rax], ymm0
    add rax, 32
    cmp rdx, rax
    jne .L5

如果我在restrict的参数列表中遗漏了vecAdd2()关键字，则循环会变得效率很低:在循环中，每次在加载，处理和存储SIMD vector 之前，都要重新加载三个data指针和大小n，并且检查循环条件:

.L10:
    mov r10, QWORD PTR 8[rdi]
    mov r9, QWORD PTR 8[rsi]
    add r8d, 8
    mov rcx, QWORD PTR 8[rdx]
    vmovaps ymm0, YMMWORD PTR [r10+rax]
    vaddps  ymm0, ymm0, YMMWORD PTR [r9+rax]
    vmovaps YMMWORD PTR [rcx+rax], ymm0
    mov ecx, DWORD PTR [rdi]
    add rax, 32
    sub ecx, 7
    cmp ecx, r8d
    jg  .L10

在vecAdd3()版本中，不会重新加载data指针(它们在循环之前加载一次)，但是会重新加载大小n:

.L15:
    vmovaps ymm0, YMMWORD PTR -32[r8+rax*4]
    mov ecx, eax
    vaddps  ymm0, ymm0, YMMWORD PTR -32[rsi+rax*4]
    vmovaps YMMWORD PTR -32[r9+rax*4], ymm0
    mov edx, DWORD PTR [rdi]
    add rax, 8
    sub edx, 7
    cmp edx, ecx
    jg  .L15

仅当我将所有data指针和n复制到vecAdd4()中的局部变量时，该代码才看起来像vecAdd1()中的一个:

.L20:
    vmovaps ymm0, YMMWORD PTR [rcx+rax]
    vaddps  ymm0, ymm0, YMMWORD PTR [rsi+rax]
    vmovaps YMMWORD PTR [r8+rax], ymm0
    add rax, 32
    cmp rdx, rax
    jne .L20

因此，重复我的问题:假设我想避免在C++中替换特定于编译器的restrict。因此，我使用了非restrict参数，但是将它们复制到了本地变量(也就是非restrict)中。是否可以保证编译器不会假设它们可以别名(即使函数参数可以)为别名？
(旁边的问题:复制结构组件与此问题是否相关？)

最佳答案

通常，局部变量无法实现与restrict之类的别名指令相同的优化功能。
例如。想象vecAdd4中的循环被编译器展开:

  for (int i = 0; i <= ae / 2; i += 2*N) {
    va_1 = _mm256_load_ps(pa + i);
    vb_1 = _mm256_load_ps(pb + i);
    vc_1 = _mm256_add_ps(va_1, vb_1);
    _mm256_store_ps(pc + i, vc_1);
    va_2 = _mm256_load_ps(pa + i + 1);
    vb_2 = _mm256_load_ps(pb + i + 1);
    vc_2 = _mm256_add_ps(va_2, vb_2);
    _mm256_store_ps(pc + i + 1, vc_2);
  }

在这种情况下，由于va_2和va_3之间可能存在混叠，因此它无法在第一个_mm256_store_ps内部函数之前移动pa + i和pc + i负载(以隐藏延迟)。
假设所有a，b，c，pa，pb和pc不别名，我建议将它们标记为:

void vecAdd5(Vec * restrict a, Vec * restrict b, Vec * restrict c) {
  __m256 va, vb, vc;
  float * restrict pa = a->data, * restrict pb = b->data, * restrict pc = c->data;
  for (int i = 0; i <= a->n - N; i += N) {
    va = _mm256_load_ps(pa + i);
    vb = _mm256_load_ps(pb + i);
    vc = _mm256_add_ps(va, vb);
    _mm256_store_ps(pc + i, vc);
  }
}

这样可以实现与vecAdd4相同的汇编，而所需的人工工作却少得多:

        vmovaps ymm1, YMMWORD PTR [rcx+rax*4]
        vaddps  ymm0, ymm1, YMMWORD PTR [rsi+rax*4]
        vmovaps YMMWORD PTR [rdi+rax*4], ymm0
        add     rax, 8
        cmp     edx, eax
        jg      .L3

关于c++ - C/C++:通过将参数复制到局部变量来模拟限制关键字，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/63133816/