用AVX2指令集优化整形数组求和

用AVX2指令集优化整形数组求和

  • 一、AVX2指令集介绍
  • 二、代码实现
    • 0. 数据生成
    • 1. 普通数组求和
    • 2. AVX2指令集求和:32位整形
    • 3. AVX2指令集求和:64位整形
  • 三、性能测试
    • 测试环境
    • 计时方式
    • 测试内容
    • 进行性能测试
      • 第一次测试
      • 第二次测试
  • 四、总结
    • 个人推断原因:

一、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
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是横向加法,具体实现类似下图,可以帮我们实现数组内求和:
用AVX2指令集优化整形数组求和_第1张图片

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指令集优化整形数组求和_第2张图片

可以看出,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

用AVX2指令集优化整形数组求和_第3张图片
发现开启O2后相对的性能提升减小很多。

四、总结

使用AVX2进行指令层面的并行加法,确实提高了运算效率。
但是,这里可能有朋友会有疑问,我们明明是每次同时处理了4/8个整形,为什么加速比达不到4/8倍呢?

个人推断原因:

  1. AVX2加法指令的长度大于普通加法,单次指令实现比普通加法略慢一些。
  2. 在进行AVX2加法时,我们每次需要拷贝256位内存进对应256位的变量内,再把结果拷贝出来,存在拷贝的开支。
  3. 普通加法在for循环内可能会激发流水线执行。
  4. 开启O2后普通加法可以激发并行,提高实际运行效率。

你可能感兴趣的:(算法,c++,算法,性能优化)