一、avx2指令集介绍
avx2是simd(单指令多数据流)指令集，支持在一个指令周期内同时对256位内存进行操作。包含乘法，加法，位运算等功能。下附intel官网使用文档。
intel® intrinsics guide
我们本次要用到的指令有 __m256i _mm256_add_epi32(__m256i a, __m256i b), __m256i _mm256_add_epi64等
它们可以一次取256位的内存，并按32/64位一个整形进行加法运算。下附官网描述。
synopsis
__m256i _mm256_add_epi64 (__m256i a, __m256i b)
#include <immintrin.h>
instruction: vpaddq ymm, ymm, ymm
cpuid flags: avx2
description
add packed 64-bit integers in a and b, and store the results in dst.
operation
for j := 0 to 3 i := j*64 dst[i+63:i] := a[i+63:i] + b[i+63:i] endfor dst[max:256] := 0
performance
| architecture | latency | throughput (cpi) |
|---|---|---|
| icelake | 1 | 0.33 |
| skylake | 1 | 0.33 |
| broadwell | 1 | 0.5 |
| haswell | 1 | 0.5 |
二、代码实现
0. 数据生成
为了比较结果，我们生成从1到n的等差数列。这里利用模版兼容不同数据类型。由于avx2指令集一次要操作多个数据，为了防止访存越界，我们将大小扩展到256的整数倍位比特，也就是32字节的整数倍。
uint64_t lowbit(uint64_t x)
{
return x & (-x);
}
uint64_t extto2power(uint64_t n, int i)//arraysize datasize
{
while(lowbit(n) < i)
n += lowbit(n);
return n;
}
template <typename t>
t* getarray(uint64_t size)
{
uint64_t exsize = extto2power(size, 32/sizeof(t));
t* arr = new t[exsize];
for (uint64_t i = 0; i < size; i++)
arr[i] = i+1;
for (uint64_t i = size; i < exsize; i++)
arr[i] = 0;
return arr;
}
1. 普通数组求和
为了比较性能差异，我们先实现一份普通的数组求和。这里也使用模版。
template <typename t>
t simplesum(t* arr, uint64_t size)
{
t sum = 0;
for (uint64_t i = 0; i < size; i++)
sum += arr[i];
return sum;
}
2. avx2指令集求和：32位整形
这里我们预开一个avx2的整形变量，每次从数组中取8个32位整形，加到这个变量上，最后在对这8个32位整形求和。
int32_t avx2sum(int32_t* arr, uint64_t size)
{
int32_t sum[8] = {0};
__m256i sum256 = _mm256_setzero_si256();
__m256i load256 = _mm256_setzero_si256();
for (uint64_t i = 0; i < size; i += 8)
{
load256 = _mm256_loadu_si256((__m256i*)&arr[i]);
sum256 = _mm256_add_epi32(sum256, load256);
}
sum256 = _mm256_hadd_epi32(sum256, sum256);
sum256 = _mm256_hadd_epi32(sum256, sum256);
_mm256_storeu_si256((__m256i*)sum, sum256);
sum[0] += sum[4];
return sum[0];
}
这里的hadd是横向加法，具体实现类似下图，可以帮我们实现数组内求和：
3. avx2指令集求和：64位整形
int64_t avx2sum(int64_t* arr, uint64_t size)
{
int64_t sum[4] = {0};
__m256i sum256 = _mm256_setzero_si256();
__m256i load256 = _mm256_setzero_si256();
for (uint64_t i = 0; i < size; i += 4)
{
load256 = _mm256_loadu_si256((__m256i*)&arr[i]);
sum256 = _mm256_add_epi64(sum256, load256);
}
_mm256_storeu_si256((__m256i*)sum, sum256);
sum[0] += sum[1] + sum[2] + sum[3];
return sum[0];
}
三、性能测试
测试环境
| device | description |
|---|---|
| cpu | intel core i9-9880h 8-core 2.3ghz |
| memory | ddr4-2400mhz dual-channel 32gb |
| complier | apple clang-1300.0.29.30 |
计时方式
利用chrono库获取系统时钟计算运行时间，精确到毫秒级
uint64_t gettime()
{
uint64_t timems = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
return timems;
}
测试内容
对1到1e9求和，答案应该为500000000500000000, 分别测试32位整形和64位整形。
uint64_t n = 1e9;
// compare the performance of normal add and avx2 add
uint64_t start, end;
// test int32_t
cout << "compare int32_t sum: " << endl;
int32_t* arr = getarray<int32_t>(n);
start = gettime();
int32_t sum = simplesum(arr, n);
end = gettime();
cout << "int32_t simplesum time: " << end - start << endl;
cout << "int32_t simplesum sum: " << sum << endl;
start = gettime();
sum = avx2sum(arr, n);
end = gettime();
cout << "int32_t avx2sum time: " << end - start << endl;
cout << "int32_t avx2sum sum: " << sum << endl;
delete[] arr;
cout << endl << endl;
// test int64_t
cout << "compare int64_t sum: " << endl;
int64_t* arr2 = getarray<int64_t>(n);
start = gettime();
int64_t sum2 = simplesum(arr2, n);
end = gettime();
cout << "int64_t simplesum time: " << end - start << endl;
cout << "int64_t simplesum sum: " << sum2 << endl;
start = gettime();
sum2 = avx2sum(arr2, n);
end = gettime();
cout << "int64_t avx2sum time: " << end - start << endl;
cout << "int64_t avx2sum sum: " << sum2 << endl;
delete[] arr2;
cout << endl << endl;
进行性能测试
第一次测试
测试命令
g++ -mavx2 avx_big_integer.cpp ./a.out
测试结果
| 方法 | 耗时(ms) |
|---|---|
| avx2加法 32位 | 537 |
| 普通加法 32位 | 1661 |
| avx2加法 64位 | 1094 |
| 普通加法 64位 | 1957 |
可以看出，avx2在32位加法上大致能快3倍，在64位加法上只能快2倍，因为64位下每次只能操作4个变量，而32位能操作8个。
第二次测试
测试命令
现在我们再开启o2编译优化试一试：
g++ -o2 -mavx2 avx_big_integer.cpp ./a.out
测试结果
| 方法 | 耗时(ms) |
|---|---|
| avx2加法 32位 | 269 |
| 普通加法 32位 | 342 |
| avx2加法 64位 | 516 |
| 普通加法 64位 | 750 |
发现开启o2后相对的性能提升减小很多。
四、总结
使用avx2进行指令层面的并行加法，确实提高了运算效率。
但是，这里可能有朋友会有疑问，我们明明是每次同时处理了4/8个整形，为什么加速比达不到4/8倍呢？
个人推断原因：
- vx2加法指令的长度大于普通加法，单次指令实现比普通加法略慢一些。
- 在进行avx2加法时，我们每次需要拷贝256位内存进对应256位的变量内，再把结果拷贝出来，存在拷贝的开支。
- 普通加法在for循环内可能会激发流水线执行。
- 开启o2后普通加法可以激发并行，提高实际运行效率。
以上就是avx2指令集优化整形数组求和算法的详细内容，更多关于avx2指令集整形数组求和的资料请关注其它相关文章！
