Intel指令集及SIMD数据加速

查看CPU相关信息

执行结果举例：

查看电脑CPU支持的指令集：

cat /proc/cpuinfo | grep "processor" | wc -l

支持的指令集：

向量指令集

Flynn分类法根据指令和数据进入CPU的方式，将计算机 架构分为四种不同的类型。

• 1.单指令流单数据流(SISD,Single Instruction stream Single Data stream)
• 2.单指令流多数据流(SIMD,Single Instruction stream Multiple Data stream)
• 3.多指令流单数据流(MISD,Multiple Instruction stream Single Data stream)
• 4.多指令流多数据流(MIMD,Multiple Instruction stream Multiple Data stream)

举例：
SISD指令：需要多条指令完成相关操作

SIMD指令：只需要单条指令就可完成相关操作

API 介绍

官方参考文档见： Intel® Intrinsics Guide
需要什么功能，可对应该文档查看对应的API

因API太多，整个左侧区域是用来筛选，左侧上方的选择区域使用来按指令集来筛选，左测下方的选择区域是用来按功能筛选。

数据类型

可简单理解为，MMX对应64位，SSE对应128位，AVX对应256位
intel 指令集的变量命名规则位__mm<bit_width><data_type>，其中bit_width即数据长度(64|128|256)，data_type即存储的数据是什么类型(i|d),i对应int,d对应double,要是空，则对应float

SSE Data Type(16 XMM Registers)

AVX Data Types(16 YMM Registers)

注：
AVX的256位寄存器和SSE的128位寄存器存在着相互重叠的关系(XMM寄存器位YMM寄存器的低位)，所以最好不要混用AVX与SSE指令集，否则会导致transition penalty(过度处罚)，慢50～80时钟周期

函数类型：
SSE/AVX intrinsic functions的命名格式位_mm<bit_width>_<name>_<data_type>

• <bit_width>：表明向量的位长度，对于128位的向量，这个参数为空；256位的向量，这个参数位256
• <name>：描述内联函数的算术操作
• <data_type>：标识函数主参数的数据类型。

• ps 包含float 类型的向量，把32 bits当作一个数
• pd包含double类型的向量，把64bits当作一个数
• epi8/epi16/epi32/epi64 ：向量中每个数都是整型，包含8位/16位/32位/64位的有符号整数
• epu8/epu16/epu32/epu64: 向量中每个数都是无符号整型(unsigned)，包含8位/16位/32位/64位的无符号整数
• m128/m128i/m128d/m256/m256i/m256d：输入值与返回类型不同时，标识输入向量类型
  例如:__m256i _mm256_setr_m128i(__m128i lo,__m128i hi) 输入两个__m128i向量，把他们拼在一起，变成一个__m256i返回，另外这种结尾只见于load
• si128/si256：未指定的128或者256位向量，不关心向量里到底是什么类型，反正是128bit/256bit
  例如：__m256i _mm_broadcastsi128_si256 (__m128i a)

一个小demo

#include <iostream>
#include <immintrin.h>
int main(int argc, char* agv[])
{
    __m256 a = _mm256_set_ps(8.0, 7.0, 6.0,5.0,
                            4.0, 3.0, 2.0, 1.0);
    __m256 b = _mm256_set_ps(18.0, 17.0, 16.0, 15.0,
                            14.0, 13.0, 12.0, 11.0);
    __m256 c = _mm256_add_ps(a, b);

    float d[8];
    _mm256_storeu_ps(d, c);

    std::cout << "result equals:" << d[0] <<","<<d[1]<<","<<d[2]<<","
                <<d[4]<<","<<d[5]<<","<<d[6]<<","<<d[7]<<std::endl;
    return 0;
}

编译时，需要增加编译参数-msse -mavx -mavx2

g++ simple_demo.cc -mavx2 -mavx -msse

运行结果：
result equals:12,14,16,20,22,24,26

PS：

编译参数 -mavx 是用于启用 AVX（Advanced Vector Extensions）指令集的选项。
AVX 是 Intel 推出的一种 SIMD（Single Instruction, Multiple Data）扩展指令集，它可以提高向量化计算的性能。
在使用 g++ 编译器时，可以使用 -mavx 参数来启用 AVX 指令集的支持
需要注意的是，使用 -mavx 参数编译的程序只能在支持 AVX 指令集的 CPU 上运行，否则可能会导致程序崩溃或产生错误。因此，在使用 -mavx 参数之前，建议先检查目标机器是否支持 AVX 指令集。

支持的函数操作：
存取操作(load/store/set)

PS：
最后两个函数前面有个(2)，代表只在AVX2中支持

store函数：

算术运算

• 加减法

将饱和度考虑在内的函数将结果钳制到可以存储的最小/最大值。没有饱和的函数在饱和发生时忽略内存问题。
而在水平方向上做减法的意思如下图：

_mm256_hadd_pd接口描述

Operation
dst[63:0] := a[127:64] + a[63:0]
dst[127:64] := b[127:64] + b[63:0]
dst[191:128] := a[255:192] + a[191:128]
dst[255:192] := b[255:192] + b[191:128]
dst[MAX:256] := 0

最后一个指令：_mm256_addsub_ps/pd 在偶数位置减去，奇数位置加上，获最后的目标向量

• 乘除法

• 融合乘法和加法

• 排列和洗牌(Permuting and Shuffling)
  排列 Permuting

洗牌Shuffling

对于_mm256_shuffle_pd，只使用控制值的高4位。如果输入向量包含int或float，则使用所有控制位。对于_mm256_shuffle_ps，前两对位从第一个矢量中选择元素，第二对位从第二个矢量中选择元素。

举例：

#include <iostream>
#include <immintrin.h>

void print_value(__m128 value)
{
    float *v = (float *)&value;
    std::cout<< v[0] << "," << v[1] << ","<< v[2] << ","<<v[3] << std::endl;
}

// load，用于从内存加载到寄存器中
__m128 function_load(float const*mem_addr)
{
    return _mm_load_ps(mem_addr);
}

// set,用于从内存加载到寄存器中
__m128 function_set(float const *mem_addr)
{
    return _mm_set_ps(mem_addr[3], mem_addr[2], mem_addr[1], mem_addr[0]);
}

// 直接初始化
__m128 direct_init(float const *mem_addr)
{
    __m128 value = {mem_addr[0], mem_addr[1], mem_addr[2], mem_addr[3] };
    return value;
}

int main()
{
    float *mem_addr = (float*)malloc(sizeof(float)*4);
    mem_addr[0] = 1.0f;
    mem_addr[1] = 2.0f;
    mem_addr[2] = 3.0f;
    mem_addr[3] = 4.0f;
    print_value(function_load(mem_addr));
    print_value(function_set(mem_addr));
    print_value(direct_init(mem_addr));

    return 0;
}

运行结果：

一个简单的加法验证SIMD效率上的提升

// 写一个简单的程序来验证SIMD在效率方面的提升
#include <iostream>
#include <nmmintrin.h>
#include <immintrin.h>
#include <string>
#include <time.h>
#include <stdlib.h>

void print_time_result(std::string func_name, clock_t start, clock_t finish, int res)
{
    double time = (double(finish - start) / double(CLOCKS_PER_SEC)) * 1000; // ms
    std::cout << func_name << ": " << time << "ms, result = " << res << std::endl;
}

// 普通的加法
void normal_add(int *nums, size_t n)
{
    clock_t start = clock();
    int sum = 0;
    for (size_t i = 0; i < n; i++)
    {
        sum += nums[i];
    }
    clock_t finish = clock();
    print_time_result("normal_add", start, finish, sum);
}

// 使用128bit的SIMD
void SSE_add(int *nums, size_t n)
{
    clock_t start = clock();

    __m128i simd_sum = _mm_setzero_si128();// 累加和
    int normal_sum = 0;

    size_t loop = n / 4;
    size_t reserve = n % 4;

    __m128i *p = (__m128i *)nums;
    for (size_t i = 0; i < loop; i++)
    {
        simd_sum = _mm_add_epi32(simd_sum, *p);
        p++;
    }

    int *q = (int *)p;
    for (size_t i = 0; i < reserve; i++)
    {
        normal_sum += q[i];
    }
    normal_sum += (((int *)&simd_sum)[0] + ((int *)&simd_sum)[1] + ((int *)&simd_sum)[2] + ((int *)&simd_sum)[3]);

    clock_t finish = clock();
    print_time_result("SSE_add", start, finish, normal_sum);
}

// 使用256bit的SIMD
void AVX2_add(int *nums, size_t n)
{
    clock_t start = clock();

    __m256i simd_sum = _mm256_setzero_si256();
    __m256i simd_load;
    int normal_sum = 0;

    size_t loop = n / 8;
    size_t reserve = n % 8;

    __m256i *p = (__m256i *)nums;
    for (size_t i = 0; i < loop; i++)
    {
        simd_load = _mm256_load_si256((const __m256i *)p);
        simd_sum = _mm256_add_epi32(simd_sum, simd_load);
        p++;
    }

    int *q = (int *)p;
    for (size_t i = 0; i < reserve; i++)
    {
        normal_sum += q[i];
    }
    normal_sum += (((int *)&simd_sum)[0] + ((int *)&simd_sum)[1] +
                   ((int *)&simd_sum)[2] + ((int *)&simd_sum)[3] +
                   ((int *)&simd_sum)[4] + ((int *)&simd_sum)[5] +
                   ((int *)&simd_sum)[6] + ((int *)&simd_sum)[7]);

    clock_t finish = clock();
    print_time_result("AVX2_add", start, finish, normal_sum);
}

int main()
{
    size_t n = 10000000;
    int *nums = NULL;
    // nums = (int *)malloc(sizeof(int) * n);
    posix_memalign((void **)&nums, 32, sizeof(int) * n); // 注意要32字节对齐，否则会段错误

    for (size_t i = 0; i < n; i++)
    {
        nums[i] = 5;
    }
    normal_add(nums, n);
    SSE_add(nums, n);
    AVX2_add(nums, n);
    return 0;
}

上述代码其实就是在做10000000个5相加，normal_add()是按照一般思路，循环1千万次加法，SSE_add()是4个一组（128bit）相加，AVX2_add()是8个一组（256bit）相加。

注意：对于SSE，我们申请的空间要16字节对齐，对于AVX要32字节对齐，否则会出现段错误。

// 方法一：
__attribute__((aligned(16))) float A[10000000];// Linux下
// 方法二：
posix_memalign((void **)&B, 32, sizeof(int) * 10000000); // #include <stdlib.h>

运行结果：

也许和硬件不一样，在自己电脑上还是有提升的。

参考博客
https://blog.triplez.cn/avx-avx2-learning-notes/
https://blog.csdn.net/just_sort/article/details/94393506
https://zhuanlan.zhihu.com/p/457505686