SIMD簡介

吉良吉影最近很忙，暫停更新...

本篇文章包含的內(nèi)容有SIMD指令集簡介以及簡短的practice環(huán)節(jié)。

1.SIMD的歷史與分類

SIMD(Single Instruction Multiple Data)即單指令流多數(shù)據(jù)流，是一種采用一個(gè)控制器來控制多個(gè)處理器，同時(shí)對一組數(shù)據(jù)（又稱“數(shù)據(jù)向量”）中的每一個(gè)分別執(zhí)行相同的操作從而實(shí)現(xiàn)空間上的并行性的技術(shù)。簡單來說就是一個(gè)指令能夠同時(shí)處理多個(gè)數(shù)據(jù)。

如上圖所示，使用標(biāo)量運(yùn)算一次只能對一對數(shù)據(jù)執(zhí)行乘法操作，而采用SIMD乘法指令，則一次可以對四對數(shù)據(jù)同時(shí)執(zhí)行乘法操作。

SIMD于20世紀(jì)70年代首次引用于ILLIAC IV大規(guī)模并行計(jì)算機(jī)上。而大規(guī)模應(yīng)用到消費(fèi)級計(jì)算機(jī)則是在20實(shí)際90年代末。

1996年Intel推出了X86的MMX(MultiMedia ? eXtension)指令集擴(kuò)展，MMX定義了8個(gè)寄存器，稱為MM0到MM7，以及對這些寄存器進(jìn)行操作的指令。每個(gè)寄存器為64位寬，可用于以“壓縮”格式保存64位整數(shù)或多個(gè)較小整數(shù)，然后可以將單個(gè)指令一次應(yīng)用于兩個(gè)32位整數(shù)，四個(gè)16位整數(shù)或8個(gè)8位整數(shù)。

intel在1999年又推出了全面覆蓋MMX的SSE(Streaming SIMD Extensions， 流式SIMD擴(kuò)展)指令集，并將其應(yīng)用到Pentium ? III系列處理器上，SSE添加了八個(gè)新的128位寄存器(XMM0至XMM7)，而后來的X86-64擴(kuò)展又在原來的基礎(chǔ)上添加了8個(gè)寄存器(XMM8至XMM15)。SSE支持單個(gè)寄存器存儲(chǔ)4個(gè)32位單精度浮點(diǎn)數(shù)，之后的SSE2則支持單個(gè)寄存器存儲(chǔ)2個(gè)64位雙精度浮點(diǎn)數(shù)，2個(gè)64位整數(shù)或4個(gè)32位整數(shù)或8個(gè)16位短整形。SSE2之后還有SSE3，SSE4以及AVX，AVX2等擴(kuò)展指令集。

AVX引入了16個(gè)256位寄存器(YMM0至YMM15)，AVX的256位寄存器和SSE的128位寄存器存在著相互重疊的關(guān)系(XMM寄存器為YMM寄存器的低位)，所以最好不要混用AVX與SSE指令集，否在會(huì)導(dǎo)致transition penalty(過渡處罰)，兩種寄存器的關(guān)系如下圖：

AVX與SSE支持的數(shù)據(jù)類型如下：

不同處理器對于SIMD指令集的支持如下圖：

如果想知道CPU的SIMD支持等級可以使用cpuid指令 ，或者直接使用cpuz軟件查看。

2.如何使用SIMD

下圖給出了使用SIMD的不同方法：

首先是最簡單的方法是使用Intel開發(fā)的跨平臺(tái)函數(shù)庫（IPP，Intel Integrated Performance Primitives ），里面的函數(shù)實(shí)現(xiàn)都使用了SIMD指令進(jìn)行優(yōu)化。

其次是借助于Auto-vectorization(自動(dòng)矢量化)，借助編譯器將標(biāo)量操作轉(zhuǎn)化為矢量操作。

第三種方法是使用編譯器指示符(compiler directive)，如Cilk里的#pragma simd和OpenMP里的#pragma omp simd。如下所示，使用#pragma simd強(qiáng)制循環(huán)矢量化：

void add_floats（float * a，float * b，float * c，float * d，float * e，int n） { ? ? int i; #pragma simd ? ? for（i = 0; i <n; i ++） ? ? { ? ? ? ? a [i] = a [i] + b [i] + c [i] + d [i] + e [i]; ? ? } }

第四種方法則是使用內(nèi)置函數(shù)(intrinsics)的方式，如下所示，使用SSE _mm_add_ps 內(nèi)置函數(shù)，一次執(zhí)行8個(gè)單精度浮點(diǎn)數(shù)的加法：

int ?main() { __m128 v0 = _mm_set_ps(1.0f, 2.0f, 3.0f, 4.0f); __m128 v1 = _mm_set_ps(1.0f, 2.0f, 3.0f, 4.0f); __m128 result = _mm_add_ps(v0, v1); }

最后一種方法則是使用匯編直接操作寄存器，當(dāng)然直接使用匯編有點(diǎn)太麻煩了，所以本篇文章主要介紹的方法是使用intrinsics的方式使用SIMD指令。

3.SSE/AVX Intrinsics介紹

a.頭文件

SSE/AVX指令主要定義于以下一些頭文件中：

• <xmmintrin.h> : SSE, 支持同時(shí)對4個(gè)32位單精度浮點(diǎn)數(shù)的操作。

• <emmintrin.h> : SSE 2, 支持同時(shí)對2個(gè)64位雙精度浮點(diǎn)數(shù)的操作。

• <pmmintrin.h> : SSE 3, 支持對SIMD寄存器的水平操作(horizontal operation)，如hadd, hsub等...。

• <tmmintrin.h> : SSSE 3, 增加了額外的instructions。

• <smmintrin.h> : SSE 4.1, 支持點(diǎn)乘以及更多的整形操作。

• <nmmintrin.h> : SSE 4.2, 增加了額外的instructions。

• <immintrin.h> : AVX, 支持同時(shí)操作8個(gè)單精度浮點(diǎn)數(shù)或4個(gè)雙精度浮點(diǎn)數(shù)。

每一個(gè)頭文件都包含了之前的所有頭文件，所以如果你想要使用SSE4.2以及之前SSE3, SSE2, SSE中的所有函數(shù)就只需要包含<nmmintrin.h>頭文件。

b.命名規(guī)則

SSE/AVX提供的數(shù)據(jù)類型和函數(shù)的命名規(guī)則如下：

1. 數(shù)據(jù)類型通常以_mxxx(T)的方式進(jìn)行命名，其中xxx代表數(shù)據(jù)的位數(shù)，如SSE提供的__m128為128位，AVX提供的__m256為256位。T為類型，若為單精度浮點(diǎn)型則省略，若為整形則為i，如__m128i，若為雙精度浮點(diǎn)型則為d，如__m256d。

2. 操作浮點(diǎn)數(shù)的內(nèi)置函數(shù)命名方式為：_mm(xxx)_name_PT。 ? xxx為SIMD寄存器的位數(shù)，若為128m則省略，如_mm_addsub_ps，若為_256m則為256，如_mm256_add_ps。 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?name為函數(shù)執(zhí)行的操作的名字，如加法為_mm_add_ps，減法為_mm_sub_ps。 ? ? ? ? ? ? ? ? ?P代表的是對矢量(packed data ?vector)還是對標(biāo)量(scalar)進(jìn)行操作，如_mm_add_ss是只對最低位的32位浮點(diǎn)數(shù)執(zhí)行加法，而_mm_add_ps則是對4個(gè)32位浮點(diǎn)數(shù)執(zhí)行加法操作。 ? ? ? ? ?T代表浮點(diǎn)數(shù)的類型，若為s則為單精度浮點(diǎn)型，若為d則為雙精度浮點(diǎn)，如_mm_add_pd和_mm_add_ps。

3. 操作整形的內(nèi)置函數(shù)命名方式為：_mm(xxx)_name_epUY。xxx為SIMD寄存器的位數(shù)，若為128位則省略。 ? name為函數(shù)的名字。U為整數(shù)的類型，若為無符號(hào)類型則為u，否在為i，如_mm_adds_epu16和_mm_adds_epi16。Y為操作的數(shù)據(jù)類型的位數(shù)，如_mm_cvtpd_pi32。

c.instructions的分類

instructions按執(zhí)行操作類別的不同主要分為以下幾類：

1).存取操作(load/store/set)

load系列可以用來從內(nèi)存中載入數(shù)據(jù)到SSE/AVX提供的類型中，如：

void test() ?{ __declspec(align(16)) float p[] = { 1.0f, 2.0f, 3.0f, 4.0f }; __m128 v = _mm_load_ps(p); }

_mm_load_ps可以從16字節(jié)對齊的連續(xù)內(nèi)存中加載4個(gè)32位單精度浮點(diǎn)數(shù)到__m128數(shù)據(jù)類型中（若不對齊則加載會(huì)出錯(cuò)）。

_mm_loadu_ps同_mm_load_ps的作用相同，但不要求提供的內(nèi)存地址對齊。

_mm_load_ps1是從內(nèi)存中載入一個(gè)32位浮點(diǎn)數(shù)，并重復(fù)存儲(chǔ)到__m128中的4個(gè)浮點(diǎn)數(shù)中，即：m[0] = p[0], m[1] = p[0], m[2] = p[0], m[3] = p[0]。

_mm_load_ss則是從內(nèi)存中載入一個(gè)32位浮點(diǎn)數(shù)，并將其賦值給__m128中的最低位的浮點(diǎn)數(shù)，并將高位的3個(gè)浮點(diǎn)數(shù)設(shè)置為0，即：m[0] = p[0], m[1] = 0, m[2] = 0, m[3] = 0。

_mm_loadr_ps位載入4個(gè)32位浮點(diǎn)數(shù)并將其反向賦值給__m128中的4個(gè)浮點(diǎn)數(shù)，即：m[0] = p[3], m[1] = p[2], m[2] = p[1], m[3] = p[0]。

除此之外還有_mm_loadh_pd，_mm_loadl_pi等...

store系列可以將SSE/AVX提供的類型中的數(shù)據(jù)存儲(chǔ)到內(nèi)存中，如：

void test() ?{ __declspec(align(16)) float p[] = { 1.0f, 2.0f, 3.0f, 4.0f }; __m128 v = _mm_load_ps(p); __declspec(align(16)) float a[] = { 1.0f, 2.0f, 3.0f, 4.0f }; _mm_store_ps(a, v); }

_mm_store_ps可以__m128中的數(shù)據(jù)存儲(chǔ)到16字節(jié)對齊的內(nèi)存。

_mm_storeu_ps不要求存儲(chǔ)的內(nèi)存對齊。

_mm_store_ps1則是把__m128中最低位的浮點(diǎn)數(shù)存儲(chǔ)為4個(gè)相同的連續(xù)的浮點(diǎn)數(shù)，即：p[0] = m[0], p[1] = m[0], p[2] = m[0], p[3] = m[0]。

_mm_store_ss是存儲(chǔ)__m128中最低位的位浮點(diǎn)數(shù)到內(nèi)存中。

_mm_storer_ps是按相反順序存儲(chǔ)__m128中的4個(gè)浮點(diǎn)數(shù)。

set系列可以直接設(shè)置SSE/AVX提供的類型中的數(shù)據(jù)，如：

__m128 v = _mm_set_ps(0.5f, 0.2f, 0.3f, 0.4f);

_mm_set_ps可以將4個(gè)32位浮點(diǎn)數(shù)按相反順序賦值給__m128中的4個(gè)浮點(diǎn)數(shù)，即：_mm_set_ps(a, b, c, d) : m[0] = d, m[1] = c, m[2] = b, m[3] = a。

_mm_set_ps1則是將一個(gè)浮點(diǎn)數(shù)賦值給__m128中的四個(gè)浮點(diǎn)數(shù)。

_mm_set_ss是將給定的浮點(diǎn)數(shù)設(shè)置到__m128中的最低位浮點(diǎn)數(shù)中，并將高三位的浮點(diǎn)數(shù)設(shè)置為0.

_mm_setzero_ps是將__m128中的四個(gè)浮點(diǎn)數(shù)全部設(shè)置為0.

2). 算術(shù)運(yùn)算

SSE/AVX提供的算術(shù)運(yùn)算操作包括：

• _mm_add_ps，_mm_add_ss等加法系列

• _mm_sub_ps，_mm_sub_pd等減法系列

• _mm_mul_ps，_mm_mul_epi32等乘法系列

• _mm_div_ps，_mm_div_ss等除法系列

• _mm_sqrt_pd，_mm_rsqrt_ps等開平方系列

• _mm_rcp_ps，_mm_rcp_ss等求倒數(shù)系列

• _mm_dp_pd，_mm_dp_ps計(jì)算點(diǎn)乘

此外還有向下取整，向上取整等運(yùn)算，這里只列出了浮點(diǎn)數(shù)支持的算術(shù)運(yùn)算類型，還有一些整形的算術(shù)運(yùn)算類型未列出。

3).比較運(yùn)算

SSE/AVX提供的比較運(yùn)算操作包括：

• _mm_max_ps逐分量對比兩個(gè)數(shù)據(jù)，并將較大的分量存儲(chǔ)到返回類型的對應(yīng)位置中。

• _mm_min_ps逐分量對比兩個(gè)數(shù)據(jù)，并將較小的分量存儲(chǔ)到返回類型的對應(yīng)位置中。

• _mm_cmpeq_ps逐分量對比兩個(gè)數(shù)據(jù)是否相等。

• _mm_cmpge_ps逐分量對比一個(gè)數(shù)據(jù)是否大于等于另一個(gè)是否相等。

• _mm_cmpgt_ps逐分量對比一個(gè)數(shù)據(jù)是否大于另一個(gè)是否相等。

• _mm_cmple_ps逐分量對比一個(gè)數(shù)據(jù)是否小于等于另一個(gè)是否相等。

• _mm_cmplt_ps逐分量對比一個(gè)數(shù)據(jù)是否小于另一個(gè)是否相等。

• _mm_cmpneq_ps逐分量對比一個(gè)數(shù)據(jù)是否不等于另一個(gè)是否相等。

• _mm_cmpnge_ps逐分量對比一個(gè)數(shù)據(jù)是否不大于等于另一個(gè)是否相等。

• _mm_cmpngt_ps逐分量對比一個(gè)數(shù)據(jù)是否不大于另一個(gè)是否相等。

• _mm_cmpnle_ps逐分量對比一個(gè)數(shù)據(jù)是否不小于等于另一個(gè)是否相等。

• _mm_cmpnlt_ps逐分量對比一個(gè)數(shù)據(jù)是否不小于另一個(gè)是否相等。

此外還有一些執(zhí)行單分量對比的比較運(yùn)算

4).邏輯運(yùn)算

SSE/AVX提供的邏輯運(yùn)算操作包括：

• _mm_and_pd對兩個(gè)數(shù)據(jù)逐分量and

• _mm_andnot_ps先對第一個(gè)數(shù)進(jìn)行not，然后再對兩個(gè)數(shù)據(jù)進(jìn)行逐分量and

• _mm_or_pd對兩個(gè)數(shù)據(jù)逐分量or

• _mm_xor_ps對兩個(gè)數(shù)據(jù)逐分量xor

5).Swizzle運(yùn)算

包含_mm_shuffle_ps，_mm_blend_ps, _mm_movelh_ps等。

這里主要介紹以下_mm_shuffle_ps:

void test() ?{ __m128 a = _mm_set_ps(1, 2, 3, 4); __m128 b = _mm_set_ps(5, 6, 7, 8); __m128 v = _mm_shuffle_ps(a, b, _MM_SHUFFLE(1, 0, 3, 2)); // 2, 1, 8, 7 }

_mm_shuffle_ps讀取兩個(gè)__m128類型的數(shù)據(jù)a和b，并按照_MM_SHUFFLE提供的索引將返回的__m128類型數(shù)據(jù)的低兩位設(shè)置為a中按索引值取得到的對應(yīng)值，將高兩位設(shè)置為按索引值從b中取得到的對應(yīng)值。索引值在0到3之間，分別以相反的順序?qū)?yīng)__m128中的四個(gè)浮點(diǎn)數(shù)。

SSE/AVX還提供了類型轉(zhuǎn)換等操作，這里就不做介紹了。

PS:補(bǔ)充一個(gè)操作指令：_mm_cvtss_f32，可以獲取__m128中的最低位浮點(diǎn)數(shù)并返回。

4. Practice環(huán)節(jié)

現(xiàn)在可以使用之前所介紹的instructions來實(shí)現(xiàn)一個(gè)簡單的數(shù)學(xué)運(yùn)算庫。

首先需要定義一些宏：

#ifndef SIMD_LEVEL #if defined(__AVX__) || defined(__AVX2__) #define SIMD_LEVEL 2 //Support SSE4, AVX, AVX2 #include <immintrin.h> ? #elif defined(_M_IX86_FP) && (_M_IX86_FP == 2) #define SIMD_LEVEL 1 //Support SSE2 #include <emmintrin.h> ?#else #define SIMD_LEVEL 0 #endif #endif // !SIMD_LEVEL #ifndef AMVector #if SIMD_LEVEL == 0 typedef Vector4<float> AMVector; typedef const Vector4<float>& CRAMVector; #else typedef __m128 AMVector; typedef const AMVector CRAMVector; #endif #endif // !AMVector #define SHUFFLE4(V, X,Y,Z,W) (_mm_shuffle_ps(V, V, _MM_SHUFFLE(W,Z,Y,X))) #define SHUFFLE3(V, X,Y,Z) (_mm_shuffle_ps(V, V, _MM_SHUFFLE(3,Z,Y,X))) #define SHUFFLE2(V, X,Y) (_mm_shuffle_ps(V, V, _MM_SHUFFLE(3,2,Y,X))) #define AM_INLINEF ?__forceinline #define AM_CALLCONV __vectorcall

visual studio上可以通過__AVX__，__AVX2__等宏檢測是否支持AVX指令集，_M_IX86_FP為2則表示支持SSE2，為1則表示支持SSE，否則不支持SSE。

這里將__m128類型定義為AMVector，并且定義了SHUFFLE4等宏方便對__m128類型進(jìn)行Swizzle運(yùn)算。

因?yàn)槲覀兌x的函數(shù)都比較短，所以有必要把所有函數(shù)都定義為_forceinline來減少函數(shù)調(diào)用開銷。x64上的默認(rèn)函數(shù)調(diào)用約定為__fastcall，前兩個(gè)參數(shù)通過寄存器傳遞，其他參數(shù)通過堆棧傳遞，而__vectorcall能使用比__fastcall更多的寄存器傳遞參數(shù)，并且支持__m128矢量類型，在可能的情況下可以通過寄存器返回函數(shù)返回值。（關(guān)于__vectorcall的更多信息可以查看Introducing ‘Vector Calling Convention’）

首先需要定義加，減，乘，除等算術(shù)運(yùn)算與賦值操作：

AM_INLINEF AMVector AM_CALLCONV operator + (CRAMVector lhs, CRAMVector rhs) { return _mm_add_ps(lhs, rhs); } AM_INLINEF AMVector& AM_CALLCONV operator += (AMVector &lhs, CRAMVector rhs) { lhs = _mm_add_ps(lhs, rhs); return lhs; } AM_INLINEF AMVector AM_CALLCONV operator - (CRAMVector lhs, CRAMVector rhs) { return _mm_sub_ps(lhs, rhs); } AM_INLINEF AMVector& AM_CALLCONV operator -= (AMVector &lhs, CRAMVector rhs) { lhs = mm_sub_ps(lhs, rhs); return lhs; } AM_INLINEF AMVector AM_CALLCONV operator * (CRAMVector lhs, CRAMVector rhs) { return _mm_mul_ps(lhs, rhs); } AM_INLINEF AMVector AM_CALLCONV operator * (CRAMVector lhs, float rhs) { return _mm_mul_ps(lhs, _mm_set1_ps(rhs)); } AM_INLINEF AMVector AM_CALLCONV operator * (float lhs, CRAMVector rhs) { return _mm_mul_ps(_mm_set1_ps(lhs), rhs); } AM_INLINEF AMVector& AM_CALLCONV operator *= (AMVector& lhs, float rhs) { lhs = _mm_mul_ps(lhs, _mm_set1_ps(rhs)); return lhs; } AM_INLINEF AMVector& AM_CALLCONV operator *= (AMVector& lhs, CRAMVector rhs) { lhs = _mm_mul_ps(lhs, rhs); return lhs } AM_INLINEF AMVector AM_CALLCONV operator / (CRAMVector lhs, CRAMVector rhs) { return _mm_div_ps(lhs, rhs); } AM_INLINEF AMVector AM_CALLCONV operator / (CRAMVector lhs, float rhs) { return _mm_div_ps(lhs, _mm_set1_ps(rhs } AM_INLINEF AMVector AM_CALLCONV operator / (float lhs, CRAMVector rhs) { return _mm_div_ps(_mm_set1_ps(lhs), rhs); } AM_INLINEF AMVector& AM_CALLCONV operator /= (AMVector& lhs, float rhs) { lhs = _mm_div_ps(lhs, _mm_set1_ps(rhs)); return lhs; } AM_INLINEF AMVector& AM_CALLCONV operator /= (AMVector& lhs, CRAMVector rhs) { lhs = _mm_div_ps(lhs, rhs); return lh }

然后可以定義一些Set，get 操作方便我們存儲(chǔ)和讀取__m128中的值：

AM_INLINEF AMVector AM_CALLCONV am_vector_set(float x, float y, float z, float w) { return _mm_set_ps(w, z, y, x); } AM_INLINEF float AM_CALLCONV am_vector_get_y(CRAMVector v) { return _mm_cvtss_f32(_mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1))); }

之后就是必不可少的點(diǎn)乘和叉乘操作了：

AM_INLINEF AMVector AM_CALLCONV am_vector3_dot(CRAMVector lhs, CRAMVector rhs) { #if SIMD_LEVEL == 0 float dot = lhs.x() * rhs.x() + lhs.y() * rhs.y() + lhs.z() * rhs.z(); return Vector4<float>{dot}; #elif SIMD_LEVEL == 1 AMVector dot = _mm_mul_ps(lhs, rhs); AMVector temp = SHUFFLE4(dot, 1, 1, 2, 2); dot = _mm_add_ps(dot, temp); temp = SHUFFLE4(dot, 3, 3, 3, 3); dot = _mm_add_ps(dot, temp); return SHUFFLE4(dot, 0, 0, 0, 0); #else return _mm_dp_ps(lhs, rhs, 0x7f); #endif // SIMD_LEVEL == 0 }

如果支持SSE4則可以直接采用_mm_dp_ps實(shí)現(xiàn)點(diǎn)乘操作，否則若支持SSE則可以將lhs和rhs相乘，然后通過shuffle操作打亂乘法操作的結(jié)果，并將對應(yīng)的的三個(gè)分量加起來。

AM_INLINEF AMVector AM_CALLCONV am_vector3_cross(CRAMVector lhs, CRAMVector rhs) { #if SIMD_LEVEL == 0 return vector4_cross3(lhs, rhs); #else //http://threadlocalmutex.com/?p=8 ?Investigating SSE Cross Product Performance //return _mm_sub_ps(_mm_mul_ps(SHUFFLE3(lhs, 1, 2, 0), SHUFFLE3(rhs, 2, 0, 1)), _mm_mul_ps(SHUFFLE3(lhs, 2, 0, 1), SHUFFLE3(rhs, 1, 2, 0))); AMVector result = _mm_sub_ps(_mm_mul_ps(lhs, SHUFFLE3(rhs, 1, 2, 0)), _mm_mul_ps(SHUFFLE3(lhs, 1, 2, 0), rhs)); return SHUFFLE3(result, 1, 2, 0); #endif // SIMD_LEVEL == 0 }

三維向量的叉乘操作定義為：
cross(a, b) = a.yzx * b.zxy - a.zxy * b.yzx;

可以表示為：

• cross(a, b).x = a.y * b.z - a.z * b.y;

• cross(a, b).y = a.z * b.x - a.x * b.z;

• cross(a, b).z = a.x * b.y - a.y * b.x;

可以將上面的式子重新排序如下：

• cross(a, b).z = a.x * b.y - a.y * b.x;

• cross(a, b).x = a.y * b.z - a.z * b.y;

• cross(a, b).y = a.z * b.x - a.x * b.z;

然后我們就可以得到：

cross(a, b).zxy = a * b.yzx - a.yzx * b;

即：

cross(a, b) = (a * b.yzx - a.yzx * b).yzx;

這樣以來叉乘的實(shí)現(xiàn)就只需要3個(gè)shuffle操作即可完成，比起代碼中我原來實(shí)現(xiàn)的方法少了一個(gè)shuffle指令，效率更高(上面介紹的叉乘操作方法來自于Investigating SSE Cross Product Performance)。

隨后可以定義向量的取模和歸一化操作：

AM_INLINEF AMVector AM_CALLCONV am_vector3_length_sq(CRAMVector v) { return am_vector3_dot(v, v); } AM_INLINEF AMVector AM_CALLCONV am_vector3_length(CRAMVector v) { #if SIMD_LEVEL == 0 float dot = v.x() * v.x() + v.y() * v.y() + v.z() * v.z(); return Vector4<float>{ std::sqrt(dot) }; #elif SIMD_LEVEL == 1 AMVector dot = _mm_mul_ps(v, v); AMVector temp = SHUFFLE4(dot, 1, 1, 2, 2); dot = _mm_add_ps(dot, temp); temp = SHUFFLE4(dot, 3, 3, 3, 3); dot = _mm_sqrt_ss(_mm_add_ps(dot, temp)); return SHUFFLE4(dot, 0, 0, 0, 0); #else return _mm_sqrt_ps(_mm_dp_ps(v, v, 0x7f)); #endif // SIMD_LEVEL == 0 }

計(jì)算向量的?？梢韵韧ㄟ^對向量和它本身做點(diǎn)擊計(jì)算出模的平方，然后再對其開平方求得。

AM_INLINEF AMVector AM_CALLCONV am_vector3_normalize_est(CRAMVector v) { #if SIMD_LEVEL == 0 float dot = v.x() * v.x() + v.y() * v.y() + v.z() * v.z(); return vector4_divide(v, std::sqrt(dot)); #elif SIMD_LEVEL == 1 AMVector dot = _mm_mul_ps(v, v); AMVector temp = SHUFFLE4(dot, 1, 1, 2, 2); dot = _mm_add_ps(dot, temp); temp = SHUFFLE4(dot, 3, 3, 3, 3); dot = _mm_rsqrt_ss(_mm_add_ps(dot, temp)); return _mm_mul_ps(v, SHUFFLE4(dot, 0, 0, 0, 0)); #else return _mm_mul_ps(v, _mm_rsqrt_ps(_mm_dp_ps(v, v, 0x7f))); #endif // SIMD_LEVEL == 0 }

對向量進(jìn)行歸一化即 v/v.length，需要求向量模的倒數(shù)，可以通過_mm_rsqrt_ps取倒數(shù)，但是會(huì)有一些誤差，也可以通過_mm_div_ps(1, length)取得精確的倒數(shù)值。

此外還定義了sqrt, lerp, clamp, saturate等函數(shù)。

AM_INLINEF AMVector AM_CALLCONV am_vector_sqrt_est(CRAMVector v) { return _mm_rsqrt_ps(v); } AM_INLINEF AMVector AM_CALLCONV am_vector_lerp(float t, CRAMVector lhs, CRAMVector rhs) { return _mm_add_ps(lhs, am_vector_scale(_mm_sub_ps(rhs, lhs), t)); } AM_INLINEF AMVector AM_CALLCONV am_vector_clamp(CRAMVector v, CRAMVector min, CRAMVector max) { return _mm_max_ps(_mm_min_ps(v, max), min); } AM_INLINEF AMVector AM_CALLCONV am_vector_saturate(CRAMVector v) { return _mm_max_ps(_mm_min_ps(v, am_const_one), am_const_zero); }

還有一些算術(shù)運(yùn)算如log，exp，pow等函數(shù)可以借助標(biāo)準(zhǔn)庫std::log, std::exp, std::pow實(shí)現(xiàn)

(pow實(shí)現(xiàn)整數(shù)指數(shù)計(jì)算比較簡單，但是要支持浮點(diǎn)數(shù)就有些麻煩了...，exp雖然可以通過泰勒展開式計(jì)算，但是要計(jì)算到比較精確的值需要計(jì)算100項(xiàng)以上，速度比較慢，而且誤差也比加大...)

三角函數(shù)可以通過泰勒展開式計(jì)算，只需要計(jì)算5項(xiàng)左右就可以得到比較好的精度了：

AM_INLINEF AMVector AM_CALLCONV am_vector_acos(CRAMVector v) { AMVector v2 = _mm_mul_ps(v, v); AMVector v3 = _mm_mul_ps(v2, v); AMVector v5 = _mm_mul_ps(v3, v2); AMVector v7 = _mm_mul_ps(v5, v2); AMVector v9 = _mm_mul_ps(v7, v2); AMVector result = _mm_sub_ps(_mm_sub_ps(_mm_sub_ps(_mm_sub_ps(_mm_sub_ps(am_const_half_pi, v), _mm_mul_ps(v3, _mm_set1_ps(0.16666666666667f))), _mm_mul_ps(v5, _mm_set1_ps(0.075f))), _mm_mul_ps(v7, _mm_set1_ps(0.04464285714f))), _mm_mul_ps(v9, _mm_set1_ps(0.030381944444444f))); return result; }

常見的三角函數(shù)泰勒展開式都可以在wiki上找到：

除了這些算術(shù)運(yùn)算外還定義了floor, ceil等函數(shù)直接借助于SSE的_mm_floor_ps和_mm_ceil_ps函數(shù)進(jìn)行計(jì)算。

然后就是比較運(yùn)算：

typedef int AM_MASK; AM_INLINEF AM_MASK AM_CALLCONV am_vector_less(CRAMVector lhs, CRAMVector rhs) { AMVector temp = _mm_cmplt_ps(lhs, rhs); return _mm_movemask_ps(temp); } AM_INLINEF bool am_mask_all3(AM_MASK m) { return (m & 7) == 7; } AM_INLINEF bool am_mask_any3(AM_MASK m) { return (m & 7) != 0; }

_mm_cmplt_ps函數(shù)返回的是__m128類型的數(shù)據(jù)，其中存儲(chǔ)了逐分量比較的結(jié)果，如果條件成立則為-nan，否則為0：

void test() ?{ __m128 a = am_vector_set(5, 6, 7, 4); __m128 b = am_vector_set(5, 6, 7, 8); __m128 v = _mm_cmpeq_ps(a, b); // -nan, -nan, -nan, 0 AM_MASK mask = _mm_movemask_ps(v); // 7 bool all = am_mask_all3(mask); //true }

可以使用_mm_movemask_ps將比較結(jié)果轉(zhuǎn)化為int類型的值，此int值從低到高的4位分別對應(yīng)兩個(gè)__m128從低到高逐分量比較的結(jié)果，所以這個(gè)int類型的值的范圍在0-15之間?？梢酝ㄟ^檢查這個(gè)int類型的值判斷條件是否都成立，或其中一個(gè)是否成立。

AM_INLINEF AMVector AM_CALLCONV am_vector_select(CRAMVector a, CRAMVector b, CRAMVector condition) { //..... #elif SIMD_LEVEL == 1 return _mm_or_ps(_mm_andnot_ps(condition, a), _mm_and_ps(b, condition)); #else return _mm_blendv_ps(a, b, condition); #endif // SIMD_LEVEL == 0 }

可以定義一個(gè)select函數(shù)，根據(jù)比較結(jié)果，選擇a或b中的對應(yīng)分量作為返回值的對應(yīng)分量(如果為true則選擇b，否則選擇a)，如果支持sse則select函數(shù)通過位操作實(shí)現(xiàn)，若支持sse4則可以通過_mm_blendv_ps指令實(shí)現(xiàn)。select函數(shù)的效果如下：

void test() ?{ __m128 a = am_vector_set(1, 9, 3, 10); __m128 b = am_vector_set(5, 6, 7, 8); __m128 v = _mm_cmplt_ps(a, b); // ?-nan, 0, -nan, 0 __m128 result = am_vector_select(a, b, v); // 5, 9, 7, 10 }

以上差不多介紹了所有向量支持的操作。接下來可以實(shí)現(xiàn)下簡單的矩陣操作。

矩陣的定義如下（這里矩陣采用的是行主序(Row Major)）：

struct alignas(16) SIMDMatrix { AMVector m_rows[4]; SIMDMatrix()= default; SIMDMatrix(const SIMDMatrix &m) { m_rows[0] = m.m_rows[0]; m_rows[1] = m.m_rows[1]; m_rows[2] = m.m_rows[2]; m_rows[3] = m.m_rows[3]; } SIMDMatrix(float a00, float a01, float a02, float a03, float a10, float a11, float a12, float a13, float a20, float a21, float a22, float a23, float a30, float a31, float a32, float a33) { m_rows[0] = am_vector_set(a00, a01, a02, a03); m_rows[1] = am_vector_set(a10, a11, a12, a13); m_rows[2] = am_vector_set(a20, a21, a22, a23); m_rows[3] = am_vector_set(a30, a31, a32, a33); } //...... } #if SIMD_LEVEL == 0 typedef Matrix4x4<float> AMMatrix; typedef const Matrix4x4<float>& CRAMMatrix; #else typedef SIMDMatrix AMMatrix; typedef const SIMDMatrix CRAMMatrix; #endif

矩陣也定義了一些set函數(shù)，和AMVector定義的set函數(shù)差不多，這里就不再給出了。

接下來定義矩陣與矩陣的相乘操作，考慮兩個(gè)矩陣a和b相乘得到c：

根據(jù)矩陣相乘的定義(a的行乘以b的列)，可以得到c的第一行為：

對上面的式子重新排列后可以得到：

即c的第0行為a的第零行第零列的元素乘以b的第0行元素加上a的第零行第一列的元素乘以b的第2行元素加上a的第零行第二列的元素乘以b的第3行元素最后再加上a的第零行第三列的元素乘以b的第3行元素。c的其他行與第一行類似，代碼實(shí)現(xiàn)如下：

AM_INLINEF AMMatrix AM_CALLCONV am_matrix_multiply(CRAMMatrix lhs, CRAMMatrix rhs) { AMMatrix result; //Row0 AMVector vec = lhs.m_rows[0]; AMVector vec_x = SHUFFLE4(vec, 0, 0, 0, 0); AMVector vec_y = SHUFFLE4(vec, 1, 1, 1, 1); AMVector vec_z = SHUFFLE4(vec, 2, 2, 2, 2); AMVector vec_w = SHUFFLE4(vec, 3, 3, 3, 3); vec_x = _mm_mul_ps(vec_x, rhs.m_rows[0]); vec_y = _mm_mul_ps(vec_y, rhs.m_rows[1]); vec_z = _mm_mul_ps(vec_z, rhs.m_rows[2]); vec_w = _mm_mul_ps(vec_w, rhs.m_rows[3]); vec_x = _mm_add_ps(vec_x, vec_y); vec_z = _mm_add_ps(vec_z, vec_w); result.m_rows[0] = _mm_add_ps(vec_x, vec_z); //Row1 vec = lhs.m_rows[1]; vec_x = SHUFFLE4(vec, 0, 0, 0, 0); vec_y = SHUFFLE4(vec, 1, 1, 1, 1); vec_z = SHUFFLE4(vec, 2, 2, 2, 2); vec_w = SHUFFLE4(vec, 3, 3, 3, 3); vec_x = _mm_mul_ps(vec_x, rhs.m_rows[0]); vec_y = _mm_mul_ps(vec_y, rhs.m_rows[1]); vec_z = _mm_mul_ps(vec_z, rhs.m_rows[2]); vec_w = _mm_mul_ps(vec_w, rhs.m_rows[3]); vec_x = _mm_add_ps(vec_x, vec_y); vec_z = _mm_add_ps(vec_z, vec_w); result.m_rows[1] = _mm_add_ps(vec_x, vec_z); //Row2 vec = lhs.m_rows[2]; vec_x = SHUFFLE4(vec, 0, 0, 0, 0); vec_y = SHUFFLE4(vec, 1, 1, 1, 1); vec_z = SHUFFLE4(vec, 2, 2, 2, 2); vec_w = SHUFFLE4(vec, 3, 3, 3, 3); vec_x = _mm_mul_ps(vec_x, rhs.m_rows[0]); vec_y = _mm_mul_ps(vec_y, rhs.m_rows[1]); vec_z = _mm_mul_ps(vec_z, rhs.m_rows[2]); vec_w = _mm_mul_ps(vec_w, rhs.m_rows[3]); vec_x = _mm_add_ps(vec_x, vec_y); vec_z = _mm_add_ps(vec_z, vec_w); result.m_rows[2] = _mm_add_ps(vec_x, vec_z); //Row3 vec = lhs.m_rows[3]; vec_x = SHUFFLE4(vec, 0, 0, 0, 0); vec_y = SHUFFLE4(vec, 1, 1, 1, 1); vec_z = SHUFFLE4(vec, 2, 2, 2, 2); vec_w = SHUFFLE4(vec, 3, 3, 3, 3); vec_x = _mm_mul_ps(vec_x, rhs.m_rows[0]); vec_y = _mm_mul_ps(vec_y, rhs.m_rows[1]); vec_z = _mm_mul_ps(vec_z, rhs.m_rows[2]); vec_w = _mm_mul_ps(vec_w, rhs.m_rows[3]); vec_x = _mm_add_ps(vec_x, vec_y); vec_z = _mm_add_ps(vec_z, vec_w); result.m_rows[3] = _mm_add_ps(vec_x, vec_z); return result; }

向量與矩陣相乘采用的是左乘，計(jì)算方式與上面計(jì)算c的第一行的方式完全相同。

接下來是定義矩陣轉(zhuǎn)置操作，轉(zhuǎn)置操作用到了_mm_unpacklo_ps，_mm_unpackhi_ps，_mm_movelh_ps，_mm_movehl_ps等操作。這里簡單介紹下_mm_unpacklo_ps和_mm_movelh_ps。

void test() ?{ __m128 a = am_vector_set(1, 2, 3, 4); __m128 b = am_vector_set(5, 6, 7, 8); __m128 v = _mm_unpacklo_ps(a, b); // ?1, 5, 2, 6 //v[0] = a[0] //v[1] = b[0] //v[2] = a[1] //v[3] = b[1] v = _mm_movelh_ps(a, b); // 1, 2, 5, 6 //v[0] = a[0] //v[1] = a[1] //v[2] = b[0] //v[3] = b[1] }

對矩陣A做轉(zhuǎn)置操作可以先對第0行和第1行做_mm_unpacklo_ps操作得到temp1 ?: {a00, a10, a01, a11}， 再對第2行和第3行做_mm_unpacklo_ps操作得到temp2 : {a20, a30, ?a21, a31}，再對temp1和temp2做_mm_movelh_ps操作就可以得到轉(zhuǎn)置后矩陣的第一行元素{a00, a10, a20, ?a30}了。其他行的操作與第一行類似。

轉(zhuǎn)置操作的完整實(shí)現(xiàn)如下：

AM_INLINEF AMMatrix AM_CALLCONV am_matrix_transpose(CRAMMatrix m) { AMVector t0 = _mm_unpacklo_ps(m.m_rows[0], m.m_rows[1]); AMVector t1 = _mm_unpacklo_ps(m.m_rows[2], m.m_rows[3]); AMVector t2 = _mm_unpackhi_ps(m.m_rows[0], m.m_rows[1]); AMVector t3 = _mm_unpackhi_ps(m.m_rows[2], m.m_rows[3]); return AMMatrix{ _mm_movelh_ps(t0, t1), _mm_movehl_ps(t1, t0), _mm_movelh_ps(t2, t3), _mm_movehl_ps(t3, t2) }; }

至于矩陣的求逆操作，采用的是分塊求逆：

分塊求逆的原理和實(shí)現(xiàn)可以參考：Fast 4x4 Matrix Inverse with SSE SIMD, Explained

到這里整個(gè)數(shù)學(xué)運(yùn)算庫差不多介紹完畢了。

當(dāng)然使用SSE/AVX的方法也不止使用數(shù)學(xué)運(yùn)算庫這一種方式，下面給出了一個(gè)10000個(gè)數(shù)字求和的例子，使用SSE指令的求和運(yùn)算，其速度為標(biāo)量求和運(yùn)算的3倍多：

void test() { constexpr size_t num = 10000; float *vars = static_cast<float*>(_aligned_malloc(sizeof(float) * num, 16)); for (size_t i = 0; i < num; i++) { vars[i] = 1; } float sum = 0.0f; auto t0 = std::chrono::steady_clock::now(); //Scalar for (size_t i = 0; i < 10000; i++) { sum += vars[i]; } auto t1 = std::chrono::steady_clock::now(); std::cout << "Scalar sum！" << std::endl; std::chrono::duration<double> time_span = std::chrono::duration_cast<std::chrono::duration<double>>(t1 - t0); std::cout << "Time Span: " << time_span.count() << std::endl; std::cout << sum << std::endl; AMVector vector_sum = am_vector_set(0, 0, 0, 0); t0 = std::chrono::steady_clock::now(); //SSE for (size_t i = 0; i < 10000; i += 4) { vector_sum += am_vector_load_aligned(vars + i); } sum = am_vector4_hadd(vector_sum); t1 = std::chrono::steady_clock::now(); std::cout << "SSE sum！" << std::endl; time_span = std::chrono::duration_cast<std::chrono::duration<double>>(t1 - t0); std::cout << "Time Span: " << time_span.count() << std::endl; std::cout << sum << std::endl; _aligned_free(vars); }

上面的例子還可以擴(kuò)展出更多內(nèi)容，不過本篇文章的內(nèi)容已經(jīng)夠多了，所以留著以后有機(jī)會(huì)再講吧...

如果你覺得本篇文章的內(nèi)容對你有幫助，請點(diǎn)贊?。?！

引用：

1. https://software.intel.com/zh-cn/articles/ticker-tape-part-2

2. Writing C++ Wrappers for SIMD Intrinsics (1)

3. How To Write A Maths Library In 2016

4. Fast 4x4 Matrix Inverse with SSE SIMD, Explained

5. 在C/C++代碼中使用SSE等指令集的指令(3)SSE指令集基礎(chǔ) - 。。。。 - CSDN博客

6. Easy SIMD through Wrappers

7. C++中使用SIMD的幾種方法 - 道道道人間道 - CSDN博客

如果你想查看所有的SSE/AVX指令集可以查看Intrinsics Guide

https://db.in.tum.de/~finis/x86%20intrinsics%20cheat%20sheet%20v1.0.pdf 這個(gè)pdf也羅列出了大部分的SSE/AVX指令集，以及對應(yīng)的功能

編輯于 2019-01-26 11:10C++并行計(jì)算C / C++

評論千萬條，友善第一條
17 條評論默認(rèn)最新

Nakano Nino

之前在嘗試寫一個(gè)軟光柵時(shí)，發(fā)現(xiàn)用了SSE指令集和沒用的差不多的效率 一直沒查出來是為什么

2019-01-22

pig-10

你是靠編譯器自己優(yōu)化？編譯器自己優(yōu)化的范圍很窄的，需要非常規(guī)則的循環(huán)或者數(shù)據(jù)結(jié)構(gòu)，軟光柵不在此例。

我自己寫的時(shí)候，流水線部分用的Intrinsic（因?yàn)橐疹檌nline和LTCG），采樣器用的是純匯編寫的寫的SSE代碼（因?yàn)橛兄_的prefetch需求），效率一下子就差了好幾倍。

當(dāng)然，我的軟光柵的著色器是f32格式，如果你用i16格式的話或許差別沒這么大。

2019-01-26

NET科隆編譯器優(yōu)化也會(huì)使用simd指令的，把代碼反編譯之后比較下。2019-01-23

X.Wang

非常不錯(cuò)的入門文章，贊一個(gè)。

2020-01-26

蕭葉

能講講pow應(yīng)該怎么計(jì)算嗎？

2020-09-18

李堅(jiān)松typos，4x4矩陣乘解釋那個(gè)公式，式子重新排列那里，a01*{b10,b11,b02,b03}是不是寫錯(cuò)了，應(yīng)該是a01*{b10,b11,b12,b13}01-29

老光太感謝了，找到了想要的接口2019-08-07

一只努力蹦達(dá)的蝦simd是說一次可以將多個(gè)數(shù)據(jù)載入到多個(gè)寄存器中，然后同時(shí)運(yùn)算？還是說一次載入多個(gè)數(shù)據(jù)到一個(gè)寄存器中，同時(shí)運(yùn)算？2021-07-21

一只努力蹦達(dá)的蝦是否可以控制多個(gè)處理器，對多個(gè)寄存器同時(shí)計(jì)算?？粗噶畹囊馑际侵荒軐蝹€(gè)寄存器進(jìn)行計(jì)算2021-07-21

Peter呂

practice 代碼從哪里可以獲取？

2020-09-23

Decay

感謝作者。不過_mm_shuffle_ps部分似乎有些問題，我實(shí)際測試下來的裝載順序是反的，比如_mm_shuffle_ps(a, b, _MM_SHUFFLE(0,3,2,2)) = [b2, b2, a3, a0]

2022-09-07

shadowlr

妙，太妙了2022-05-03

真叫人頭大interesting2022-03-16

__cpuid, __cpuidex

• Article

• 08/03/2021

• 
  

In this article

1. Syntax

2. Requirements

3. Remarks

4. Example

5. See also

Microsoft Specific

Generates the cpuid instruction that is available on x86 ?and x64. This instruction queries the processor for information about ?supported features and the CPU type.

Syntax

C void __cpuid( ? ?int cpuInfo[4], ? ?int function_id ); void __cpuidex( ? ?int cpuInfo[4], ? ?int function_id, ? ?int subfunction_id );

Parameters

cpuInfo
[out] An array of four integers that contains the information returned ?in EAX, EBX, ECX, and EDX about supported features of the CPU.

function_id
[in] A code that specifies the information to retrieve, passed in EAX.

subfunction_id
[in] An additional code that specifies information to retrieve, passed in ECX.

Requirements

IntrinsicArchitecture__cpuidx86, x64__cpuidexx86, x64

Header file <intrin.h>

Remarks

This intrinsic stores the supported features and CPU information returned by the cpuid instruction in cpuInfo, ?an array of four 32-bit integers that's filled with the values of the ?EAX, EBX, ECX, and EDX registers (in that order). The information ?returned has a different meaning depending on the value passed as the function_id parameter. The information returned with various values of function_id is processor-dependent.

The __cpuid intrinsic clears the ECX register before calling the cpuid instruction. The __cpuidex intrinsic sets the value of the ECX register to subfunction_id before it generates the cpuid instruction. It enables you to gather additional information about the processor.

For more information about the specific parameters to use and the ?values returned by these intrinsics on Intel processors, see the ?documentation for the cpuid instruction in Intel 64 and IA-32 Architectures Software Developers Manual Volume 2: Instruction Set Reference and Intel Architecture Instruction Set Extensions Programming Reference. Intel documentation uses the terms "leaf" and "subleaf" for the function_id and subfunction_id parameters passed in EAX and ECX.

For more information about the specific parameters to use and the ?values returned by these intrinsics on AMD processors, see the ?documentation for the cpuid instruction in AMD64 ?Architecture Programmer's Manual Volume 3: General-Purpose and System ?Instructions, and in the Revision Guides for specific processor ?families. For links to these documents and other information, see the ?AMD Developer Guides, Manuals & ISA Documents page. AMD documentation uses the terms "function number" and "subfunction number" for the function_id and subfunction_id parameters passed in EAX and ECX.

When the function_id argument is 0, cpuInfo[0] returns the highest available non-extended function_id value supported by the processor. The processor manufacturer is encoded in cpuInfo[1], cpuInfo[2], and cpuInfo[3].

Support for specific instruction set extensions and CPU features is encoded in the cpuInfo results returned for higher function_id values. For more information, see the manuals linked above, and the following example code.

Some processors support Extended Function CPUID information. When it's supported, function_id values from 0x80000000 might be used to return information. To determine the maximum meaningful value allowed, set function_id to 0x80000000. The maximum value of function_id supported for extended functions will be written to cpuInfo[0].

Example

This example shows some of the information available through the __cpuid and __cpuidex ?intrinsics. The app lists the instruction set extensions supported by ?the current processor. The output shows a possible result for a ?particular processor.

C++ // InstructionSet.cpp // Compile by using: cl /EHsc /W4 InstructionSet.cpp // processor: x86, x64 // Uses the __cpuid intrinsic to get information about // CPU extended instruction set support. #include <iostream> #include <vector> #include <bitset> #include <array> #include <string> #include <intrin.h> class InstructionSet { ? ? // forward declarations ? ? class InstructionSet_Internal; public: ? ? // getters ? ? static std::string Vendor(void) { return CPU_Rep.vendor_; } ? ? static std::string Brand(void) { return CPU_Rep.brand_; } ? ? static bool SSE3(void) { return CPU_Rep.f_1_ECX_[0]; } ? ? static bool PCLMULQDQ(void) { return CPU_Rep.f_1_ECX_[1]; } ? ? static bool MONITOR(void) { return CPU_Rep.f_1_ECX_[3]; } ? ? static bool SSSE3(void) { return CPU_Rep.f_1_ECX_[9]; } ? ? static bool FMA(void) { return CPU_Rep.f_1_ECX_[12]; } ? ? static bool CMPXCHG16B(void) { return CPU_Rep.f_1_ECX_[13]; } ? ? static bool SSE41(void) { return CPU_Rep.f_1_ECX_[19]; } ? ? static bool SSE42(void) { return CPU_Rep.f_1_ECX_[20]; } ? ? static bool MOVBE(void) { return CPU_Rep.f_1_ECX_[22]; } ? ? static bool POPCNT(void) { return CPU_Rep.f_1_ECX_[23]; } ? ? static bool AES(void) { return CPU_Rep.f_1_ECX_[25]; } ? ? static bool XSAVE(void) { return CPU_Rep.f_1_ECX_[26]; } ? ? static bool OSXSAVE(void) { return CPU_Rep.f_1_ECX_[27]; } ? ? static bool AVX(void) { return CPU_Rep.f_1_ECX_[28]; } ? ? static bool F16C(void) { return CPU_Rep.f_1_ECX_[29]; } ? ? static bool RDRAND(void) { return CPU_Rep.f_1_ECX_[30]; } ? ? static bool MSR(void) { return CPU_Rep.f_1_EDX_[5]; } ? ? static bool CX8(void) { return CPU_Rep.f_1_EDX_[8]; } ? ? static bool SEP(void) { return CPU_Rep.f_1_EDX_[11]; } ? ? static bool CMOV(void) { return CPU_Rep.f_1_EDX_[15]; } ? ? static bool CLFSH(void) { return CPU_Rep.f_1_EDX_[19]; } ? ? static bool MMX(void) { return CPU_Rep.f_1_EDX_[23]; } ? ? static bool FXSR(void) { return CPU_Rep.f_1_EDX_[24]; } ? ? static bool SSE(void) { return CPU_Rep.f_1_EDX_[25]; } ? ? static bool SSE2(void) { return CPU_Rep.f_1_EDX_[26]; } ? ? static bool FSGSBASE(void) { return CPU_Rep.f_7_EBX_[0]; } ? ? static bool BMI1(void) { return CPU_Rep.f_7_EBX_[3]; } ? ? static bool HLE(void) { return CPU_Rep.isIntel_ && CPU_Rep.f_7_EBX_[4]; } ? ? static bool AVX2(void) { return CPU_Rep.f_7_EBX_[5]; } ? ? static bool BMI2(void) { return CPU_Rep.f_7_EBX_[8]; } ? ? static bool ERMS(void) { return CPU_Rep.f_7_EBX_[9]; } ? ? static bool INVPCID(void) { return CPU_Rep.f_7_EBX_[10]; } ? ? static bool RTM(void) { return CPU_Rep.isIntel_ && CPU_Rep.f_7_EBX_[11]; } ? ? static bool AVX512F(void) { return CPU_Rep.f_7_EBX_[16]; } ? ? static bool RDSEED(void) { return CPU_Rep.f_7_EBX_[18]; } ? ? static bool ADX(void) { return CPU_Rep.f_7_EBX_[19]; } ? ? static bool AVX512PF(void) { return CPU_Rep.f_7_EBX_[26]; } ? ? static bool AVX512ER(void) { return CPU_Rep.f_7_EBX_[27]; } ? ? static bool AVX512CD(void) { return CPU_Rep.f_7_EBX_[28]; } ? ? static bool SHA(void) { return CPU_Rep.f_7_EBX_[29]; } ? ? static bool PREFETCHWT1(void) { return CPU_Rep.f_7_ECX_[0]; } ? ? static bool LAHF(void) { return CPU_Rep.f_81_ECX_[0]; } ? ? static bool LZCNT(void) { return CPU_Rep.isIntel_ && CPU_Rep.f_81_ECX_[5]; } ? ? static bool ABM(void) { return CPU_Rep.isAMD_ && CPU_Rep.f_81_ECX_[5]; } ? ? static bool SSE4a(void) { return CPU_Rep.isAMD_ && CPU_Rep.f_81_ECX_[6]; } ? ? static bool XOP(void) { return CPU_Rep.isAMD_ && CPU_Rep.f_81_ECX_[11]; } ? ? static bool TBM(void) { return CPU_Rep.isAMD_ && CPU_Rep.f_81_ECX_[21]; } ? ? static bool SYSCALL(void) { return CPU_Rep.isIntel_ && CPU_Rep.f_81_EDX_[11]; } ? ? static bool MMXEXT(void) { return CPU_Rep.isAMD_ && CPU_Rep.f_81_EDX_[22]; } ? ? static bool RDTSCP(void) { return CPU_Rep.isIntel_ && CPU_Rep.f_81_EDX_[27]; } ? ? static bool _3DNOWEXT(void) { return CPU_Rep.isAMD_ && CPU_Rep.f_81_EDX_[30]; } ? ? static bool _3DNOW(void) { return CPU_Rep.isAMD_ && CPU_Rep.f_81_EDX_[31]; } private: ? ? static const InstructionSet_Internal CPU_Rep; ? ? class InstructionSet_Internal ? ? { ? ? public: ? ? ? ? InstructionSet_Internal() ? ? ? ? ? ? : nIds_{ 0 }, ? ? ? ? ? ? nExIds_{ 0 }, ? ? ? ? ? ? isIntel_{ false }, ? ? ? ? ? ? isAMD_{ false }, ? ? ? ? ? ? f_1_ECX_{ 0 }, ? ? ? ? ? ? f_1_EDX_{ 0 }, ? ? ? ? ? ? f_7_EBX_{ 0 }, ? ? ? ? ? ? f_7_ECX_{ 0 }, ? ? ? ? ? ? f_81_ECX_{ 0 }, ? ? ? ? ? ? f_81_EDX_{ 0 }, ? ? ? ? ? ? data_{}, ? ? ? ? ? ? extdata_{} ? ? ? ? { ? ? ? ? ? ? //int cpuInfo[4] = {-1}; ? ? ? ? ? ? std::array<int, 4> cpui; ? ? ? ? ? ? // Calling __cpuid with 0x0 as the function_id argument ? ? ? ? ? ? // gets the number of the highest valid function ID. ? ? ? ? ? ? __cpuid(cpui.data(), 0); ? ? ? ? ? ? nIds_ = cpui[0]; ? ? ? ? ? ? for (int i = 0; i <= nIds_; ++i) ? ? ? ? ? ? { ? ? ? ? ? ? ? ? __cpuidex(cpui.data(), i, 0); ? ? ? ? ? ? ? ? data_.push_back(cpui); ? ? ? ? ? ? } ? ? ? ? ? ? // Capture vendor string ? ? ? ? ? ? char vendor[0x20]; ? ? ? ? ? ? memset(vendor, 0, sizeof(vendor)); ? ? ? ? ? ? *reinterpret_cast<int*>(vendor) = data_[0][1]; ? ? ? ? ? ? *reinterpret_cast<int*>(vendor + 4) = data_[0][3]; ? ? ? ? ? ? *reinterpret_cast<int*>(vendor + 8) = data_[0][2]; ? ? ? ? ? ? vendor_ = vendor; ? ? ? ? ? ? if (vendor_ == "GenuineIntel") ? ? ? ? ? ? { ? ? ? ? ? ? ? ? isIntel_ = true; ? ? ? ? ? ? } ? ? ? ? ? ? else if (vendor_ == "AuthenticAMD") ? ? ? ? ? ? { ? ? ? ? ? ? ? ? isAMD_ = true; ? ? ? ? ? ? } ? ? ? ? ? ? // load bitset with flags for function 0x00000001 ? ? ? ? ? ? if (nIds_ >= 1) ? ? ? ? ? ? { ? ? ? ? ? ? ? ? f_1_ECX_ = data_[1][2]; ? ? ? ? ? ? ? ? f_1_EDX_ = data_[1][3]; ? ? ? ? ? ? } ? ? ? ? ? ? // load bitset with flags for function 0x00000007 ? ? ? ? ? ? if (nIds_ >= 7) ? ? ? ? ? ? { ? ? ? ? ? ? ? ? f_7_EBX_ = data_[7][1]; ? ? ? ? ? ? ? ? f_7_ECX_ = data_[7][2]; ? ? ? ? ? ? } ? ? ? ? ? ? // Calling __cpuid with 0x80000000 as the function_id argument ? ? ? ? ? ? // gets the number of the highest valid extended ID. ? ? ? ? ? ? __cpuid(cpui.data(), 0x80000000); ? ? ? ? ? ? nExIds_ = cpui[0]; ? ? ? ? ? ? char brand[0x40]; ? ? ? ? ? ? memset(brand, 0, sizeof(brand)); ? ? ? ? ? ? for (int i = 0x80000000; i <= nExIds_; ++i) ? ? ? ? ? ? { ? ? ? ? ? ? ? ? __cpuidex(cpui.data(), i, 0); ? ? ? ? ? ? ? ? extdata_.push_back(cpui); ? ? ? ? ? ? } ? ? ? ? ? ? // load bitset with flags for function 0x80000001 ? ? ? ? ? ? if (nExIds_ >= 0x80000001) ? ? ? ? ? ? { ? ? ? ? ? ? ? ? f_81_ECX_ = extdata_[1][2]; ? ? ? ? ? ? ? ? f_81_EDX_ = extdata_[1][3]; ? ? ? ? ? ? } ? ? ? ? ? ? // Interpret CPU brand string if reported ? ? ? ? ? ? if (nExIds_ >= 0x80000004) ? ? ? ? ? ? { ? ? ? ? ? ? ? ? memcpy(brand, extdata_[2].data(), sizeof(cpui)); ? ? ? ? ? ? ? ? memcpy(brand + 16, extdata_[3].data(), sizeof(cpui)); ? ? ? ? ? ? ? ? memcpy(brand + 32, extdata_[4].data(), sizeof(cpui)); ? ? ? ? ? ? ? ? brand_ = brand; ? ? ? ? ? ? } ? ? ? ? }; ? ? ? ? int nIds_; ? ? ? ? int nExIds_; ? ? ? ? std::string vendor_; ? ? ? ? std::string brand_; ? ? ? ? bool isIntel_; ? ? ? ? bool isAMD_; ? ? ? ? std::bitset<32> f_1_ECX_; ? ? ? ? std::bitset<32> f_1_EDX_; ? ? ? ? std::bitset<32> f_7_EBX_; ? ? ? ? std::bitset<32> f_7_ECX_; ? ? ? ? std::bitset<32> f_81_ECX_; ? ? ? ? std::bitset<32> f_81_EDX_; ? ? ? ? std::vector<std::array<int, 4>> data_; ? ? ? ? std::vector<std::array<int, 4>> extdata_; ? ? }; }; // Initialize static member data const InstructionSet::InstructionSet_Internal InstructionSet::CPU_Rep; // Print out supported instruction set extensions int main() { ? ? auto& outstream = std::cout; ? ? auto support_message = [&outstream](std::string isa_feature, bool is_supported) { ? ? ? ? outstream << isa_feature << (is_supported ? " supported" : " not supported") << std::endl; ? ? }; ? ? std::cout << InstructionSet::Vendor() << std::endl; ? ? std::cout << InstructionSet::Brand() << std::endl; ? ? support_message("3DNOW", ? ? ? InstructionSet::_3DNOW()); ? ? support_message("3DNOWEXT", ? ?InstructionSet::_3DNOWEXT()); ? ? support_message("ABM", ? ? ? ? InstructionSet::ABM()); ? ? support_message("ADX", ? ? ? ? InstructionSet::ADX()); ? ? support_message("AES", ? ? ? ? InstructionSet::AES()); ? ? support_message("AVX", ? ? ? ? InstructionSet::AVX()); ? ? support_message("AVX2", ? ? ? ?InstructionSet::AVX2()); ? ? support_message("AVX512CD", ? ?InstructionSet::AVX512CD()); ? ? support_message("AVX512ER", ? ?InstructionSet::AVX512ER()); ? ? support_message("AVX512F", ? ? InstructionSet::AVX512F()); ? ? support_message("AVX512PF", ? ?InstructionSet::AVX512PF()); ? ? support_message("BMI1", ? ? ? ?InstructionSet::BMI1()); ? ? support_message("BMI2", ? ? ? ?InstructionSet::BMI2()); ? ? support_message("CLFSH", ? ? ? InstructionSet::CLFSH()); ? ? support_message("CMPXCHG16B", ?InstructionSet::CMPXCHG16B()); ? ? support_message("CX8", ? ? ? ? InstructionSet::CX8()); ? ? support_message("ERMS", ? ? ? ?InstructionSet::ERMS()); ? ? support_message("F16C", ? ? ? ?InstructionSet::F16C()); ? ? support_message("FMA", ? ? ? ? InstructionSet::FMA()); ? ? support_message("FSGSBASE", ? ?InstructionSet::FSGSBASE()); ? ? support_message("FXSR", ? ? ? ?InstructionSet::FXSR()); ? ? support_message("HLE", ? ? ? ? InstructionSet::HLE()); ? ? support_message("INVPCID", ? ? InstructionSet::INVPCID()); ? ? support_message("LAHF", ? ? ? ?InstructionSet::LAHF()); ? ? support_message("LZCNT", ? ? ? InstructionSet::LZCNT()); ? ? support_message("MMX", ? ? ? ? InstructionSet::MMX()); ? ? support_message("MMXEXT", ? ? ?InstructionSet::MMXEXT()); ? ? support_message("MONITOR", ? ? InstructionSet::MONITOR()); ? ? support_message("MOVBE", ? ? ? InstructionSet::MOVBE()); ? ? support_message("MSR", ? ? ? ? InstructionSet::MSR()); ? ? support_message("OSXSAVE", ? ? InstructionSet::OSXSAVE()); ? ? support_message("PCLMULQDQ", ? InstructionSet::PCLMULQDQ()); ? ? support_message("POPCNT", ? ? ?InstructionSet::POPCNT()); ? ? support_message("PREFETCHWT1", InstructionSet::PREFETCHWT1()); ? ? support_message("RDRAND", ? ? ?InstructionSet::RDRAND()); ? ? support_message("RDSEED", ? ? ?InstructionSet::RDSEED()); ? ? support_message("RDTSCP", ? ? ?InstructionSet::RDTSCP()); ? ? support_message("RTM", ? ? ? ? InstructionSet::RTM()); ? ? support_message("SEP", ? ? ? ? InstructionSet::SEP()); ? ? support_message("SHA", ? ? ? ? InstructionSet::SHA()); ? ? support_message("SSE", ? ? ? ? InstructionSet::SSE()); ? ? support_message("SSE2", ? ? ? ?InstructionSet::SSE2()); ? ? support_message("SSE3", ? ? ? ?InstructionSet::SSE3()); ? ? support_message("SSE4.1", ? ? ?InstructionSet::SSE41()); ? ? support_message("SSE4.2", ? ? ?InstructionSet::SSE42()); ? ? support_message("SSE4a", ? ? ? InstructionSet::SSE4a()); ? ? support_message("SSSE3", ? ? ? InstructionSet::SSSE3()); ? ? support_message("SYSCALL", ? ? InstructionSet::SYSCALL()); ? ? support_message("TBM", ? ? ? ? InstructionSet::TBM()); ? ? support_message("XOP", ? ? ? ? InstructionSet::XOP()); ? ? support_message("XSAVE", ? ? ? InstructionSet::XSAVE()); } Output GenuineIntel ? ? ? ? Intel(R) Core(TM) i5-2500 CPU @ 3.30GHz 3DNOW not supported 3DNOWEXT not supported ABM not supported ADX not supported AES supported AVX supported AVX2 not supported AVX512CD not supported AVX512ER not supported AVX512F not supported AVX512PF not supported BMI1 not supported BMI2 not supported CLFSH supported CMPXCHG16B supported CX8 supported ERMS not supported F16C not supported FMA not supported FSGSBASE not supported FXSR supported HLE not supported INVPCID not supported LAHF supported LZCNT not supported MMX supported MMXEXT not supported MONITOR not supported MOVBE not supported MSR supported OSXSAVE supported PCLMULQDQ supported POPCNT supported PREFETCHWT1 not supported RDRAND not supported RDSEED not supported RDTSCP supported RTM not supported SEP supported SHA not supported SSE supported SSE2 supported SSE3 supported SSE4.1 supported SSE4.2 supported SSE4a not supported SSSE3 supported SYSCALL supported TBM not supported XOP not supported XSAVE supported

END Microsoft Specific