SSE指令介绍及其C、C++应用（2）

冷不防 2022-06-02 11:06 216阅读 0赞

转自 [http://blog.csdn.net/hikaliv/article/details/4264188][http_blog.csdn.net_hikaliv_article_details_4264188]

[http://blog.csdn.net/olncy/archive/2009/04/16/4084374.aspx][http_blog.csdn.net_olncy_archive_2009_04_16_4084374.aspx]

作者：Alex Farber  
出处：[http://www.codeproject.com/cpp/sseintro.asp][http_www.codeproject.com_cpp_sseintro.asp]

# SSE技术简介 #

Intel公司的单指令多数据流式扩展（SSE，Streaming SIMD Extensions）技术能够有效增强CPU浮点运算的能力。Visual Studio 提供了对SSE指令集的编程支持，从而允许用户在C++代码中不用编写汇编代码就可直接使用SSE指令的功能。MSDN中有关SSE技术的主题 \[1\]有可能会使不熟悉使用SSE汇编指令编程的初学者感到困惑，但是在阅读MSDN有关文档的同时，参考一下Intel软件说明书（Intel Software manuals）\[2\]会使你更清楚地理解使用SSE指令编程的要点。

SIMD（single-instruction, multiple-data）是一种使用单道指令处理多道数据流的CPU执行模式，即在一个CPU指令执行周期内用一道指令完成处理多个数据的操作。考虑一下下面这个任务：计算一个很长的浮点型数组中每一个元素的平方根。实现这个任务的算法可以这样写：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **for** each   f in array      //对数组中的每一个元素  
2.       f = sqrt(f)              //计算它的平方根  
3.  end **for**

为了了解实现的细节，我们把上面的代码这样写：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **for** each   f in array  
2.  \{  
3.       把f从内存加载到浮点寄存器  
4.       计算平方根  
5.       再把计算结果从寄存器中取出放入内存  
6.  \}

具有Intel SSE指令集支持的处理器有8个128位的寄存器，每一个寄存器可以存放4个（32位）单精度的浮点数。SSE同时提供了一个指令集，其中的指令可以允许把浮点数加载到这些128位的寄存器之中，这些数就可以在这些寄存器中进行算术逻辑运算，然后把结果放回内存。采用SSE技术后，算法可以写成下面的样子：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **for** each   4 members in array   //对数组中的每4个元素  
2.  \{  
3.       把数组中的这4个数加载到一个128位的SSE寄存器中  
4.       在一个CPU指令执行周期中完成计算这4个数的平方根的操作  
5.       把所得的4个结果取出写入内存  
6.  \}

C++编程人员在使用SSE指令函数编程时不必关心这些128位的寄存器，你可以使用128位的数据类型“\_\_m128”和一系列C++函数来实现这些算术和逻辑操作，而决定程序使用哪个SSE寄存器以及代码优化是C++编译器的任务。当需要对很长的浮点数数组中的元素进行处理的时候，SSE技术确实是一种很高效的方法。

# SSE程序设计详细介绍 #

包含的头文件：

所有的SSE指令函数和\_\_m128数据类型都在xmmintrin.h文件中定义：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <xmmintrin.h>

因为程序中用到的SSE处理器指令是由编译器决定，所以它并没有相关的.lib库文件。

数据分组（Data Alignment）

由SSE指令处理的每一个浮点数数组必须把其中需要处理的数每16个字节（128位二进制）分为一组。一个静态数组（static array）可由\_\_declspec(align(16))关键字声明：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **\_\_declspec**(align(16)) **float** m\_fArray\[ARRAY\_SIZE\];

动态数组（dynamic array）可由\_aligned\_malloc函数为其分配空间：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  m\_fArray = (**float**\*) \_aligned\_malloc(ARRAY\_SIZE \* **sizeof**(**float**), 16);

由\_aligned\_malloc函数分配空间的动态数组可以由\_aligned\_free函数释放其占用的空间：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \_aligned\_free(m\_fArray);

\_\_m128 数据类型

该数据类型的变量可用做SSE指令的操作数，它们不能被用户指令直接存取。\_m128类型的变量被自动分配为16个字节的字长。

## CPU对SSE指令集的支持 ##

如果你的CPU能够具有了SSE指令集，你就可以使用Visual Studio .NET 提供的对SSE指令集支持的C++函数库了，你可以查看MSDN中的一个Visual C++ CPUID的例子\[4\]，它可以帮你检测你的CPU是否支持SSE、MMX指令集或其它的CPU功能。

编程实例  
以下讲解了SSE技术在Visual Studio .NET 2003下的应用实例，你可以在[http://www.codeproject.com/cpp/sseintro/SSE\_src.zip][http_www.codeproject.com_cpp_sseintro_SSE_src.zip]下载示例程序压缩包。该压缩包中含有两个项目，这两个项目是基于微软基本类库（MFC）建立的Visual C++.NET项目，你也可以按照下面的讲解建立这两个项目。

### SSETest 示例项目 ###

SSETest项目是一个基于对话框的应用程序，它用到了三个浮点数组参与运算：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  fResult\[i\] = sqrt( fSource1\[i\]\*fSource1\[i\] + fSource2\[i\]\*fSource2\[i\] ) + 0.5

其中i = 0, 1, 2 ... ARRAY\_SIZE-1

其中ARRAY\_SIZE被定义为30000。数据源数组（Source数组）通过使用sin和cos函数给它赋值，我们用Kris Jearakul开发的瀑布状图表控件（Waterfall chart control）\[3\] 来显示参与计算的源数组和结果数组。计算所需的时间(以毫秒ms为单位)在对话框中显示出来。我们使用三种不同的途径来完成计算：

纯C++代码；  
使用SSE指令函数的C++代码；  
包含SSE汇编指令的代码。

纯C++代码：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void** CSSETestDlg::ComputeArrayCPlusPlus(  
2.             **float**\* pArray1,                    // \[输入\] 源数组1  
3.             **float**\* pArray2,                    // \[输入\] 源数组2  
4.             **float**\* pResult,                    // \[输出\] 用来存放结果的数组  
5.             **int** nSize)                             // \[输入\] 数组的大小  
6.  \{  
7.       **int** i;  
8.       **float**\* pSource1 = pArray1;  
9.       **float**\* pSource2 = pArray2;  
10.      **float**\* pDest = pResult;  
11.      **for** ( i = 0; i < nSize; i++ )  
12.      \{  
13.          \*pDest = (**float**)sqrt((\*pSource1) \* (\*pSource1) + (\*pSource2)  
14.                   \* (\*pSource2)) + 0.5f;  
15.          pSource1++;  
16.          pSource2++;  
17.          pDest++;  
18.      \}  
19. \}

下面我们用具有SSE特性的C++代码重写上面这个函数。为了查询使用SSE指令C++函数的方法，我参考了Intel软件说明书（Intel Software manuals）中有关SSE汇编指令的说明，首先我是在第一卷的第九章找到的相关SSE指令，然后在第二卷找到了这些SSE指令的详细说明，这些说明有一部分涉及了与其特性相关的C++函数。然后我通过这些SSE指令对应的C++函数查找了MSDN中与其相关的说明。搜索的结果见下表：

实现的功能 对应的SSE汇编指令 Visual C++.NET中的SSE函数   
将4个32位浮点数放进一个128位的存储单元。 movss 和 shufps \_mm\_set\_ps1    
将4对32位浮点数同时进行相乘操作。这4对32位浮点数来自两个128位的存储单元，再把计算结果（乘积）赋给一个128位的存储单元。 mulps \_mm\_mul\_ps   
将4对32位浮点数同时进行相加操作。这4对32位浮点数来自两个128位的存储单元，再把计算结果（相加之和）赋给一个128位的存储单元。 addps \_mm\_add\_ps   
对一个128位存储单元中的4个32位浮点数同时进行求平方根操作。 sqrtps \_mm\_sqrt\_ps

使用Visual C++.NET的 SSE指令函数的代码：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void** CSSETestDlg::ComputeArrayCPlusPlusSSE(  
2.             **float**\* pArray1,                    // \[输入\] 源数组1  
3.             **float**\* pArray2,                    // \[输入\] 源数组2  
4.             **float**\* pResult,                    // \[输出\] 用来存放结果的数组  
5.             **int** nSize)                         // \[输入\] 数组的大小  
6.  \{  
7.       **int** nLoop = nSize/ 4;  
8.       \_\_m128 m1, m2, m3, m4;  
9.       \_\_m128\* pSrc1 = (\_\_m128\*) pArray1;  
10.      \_\_m128\* pSrc2 = (\_\_m128\*) pArray2;  
11.      \_\_m128\* pDest = (\_\_m128\*) pResult;  
12.      \_\_m128 m0\_5 = \_mm\_set\_ps1(0.5f);         // m0\_5\[0, 1, 2, 3\] = 0.5  
13.      **for** ( **int** i = 0; i < nLoop; i++ )  
14.      \{  
15.          m1 = \_mm\_mul\_ps(\*pSrc1, \*pSrc1);         // m1 = \*pSrc1 \* \*pSrc1  
16.          m2 = \_mm\_mul\_ps(\*pSrc2, \*pSrc2);         // m2 = \*pSrc2 \* \*pSrc2  
17.          m3 = \_mm\_add\_ps(m1, m2);                 // m3 = m1 + m2  
18.          m4 = \_mm\_sqrt\_ps(m3);                    // m4 = sqrt(m3)  
19.          \*pDest = \_mm\_add\_ps(m4, m0\_5);           // \*pDest = m4 + 0.5  
20.           
21.          pSrc1++;  
22.          pSrc2++;  
23.          pDest++;  
24.      \}  
25. \}

使用SSE汇编指令实现的C++函数代码：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void** CSSETestDlg::ComputeArrayAssemblySSE(  
2.             **float**\* pArray1,                    // \[输入\] 源数组1  
3.             **float**\* pArray2,                    // \[输入\] 源数组2  
4.             **float**\* pResult,                    // \[输出\] 用来存放结果的数组  
5.             **int** nSize)                         // \[输入\] 数组的大小  
6.  \{  
7.       **int** nLoop = nSize/4;  
8.       **float** f = 0.5f;  
9.       \_asm  
10.      \{  
11.          movss    xmm2, f                          // xmm2\[0\] = 0.5  
12.          shufps   xmm2, xmm2, 0                    // xmm2\[1, 2, 3\] = xmm2\[0\]  
13.          mov          esi, pArray1                 // 输入的源数组1的地址送往esi  
14.          mov          edx, pArray2                 // 输入的源数组2的地址送往edx  
15.          mov          edi, pResult                 // 输出结果数组的地址保存在edi  
16.          mov          ecx, nLoop                   //循环次数送往ecx  
17. start\_loop:  
18.          movaps       xmm0, \[esi\]                  // xmm0 = \[esi\]  
19.          mulps        xmm0, xmm0                   // xmm0 = xmm0 \* xmm0  
20.          movaps       xmm1, \[edx\]                  // xmm1 = \[edx\]  
21.          mulps        xmm1, xmm1                   // xmm1 = xmm1 \* xmm1  
22.          addps        xmm0, xmm1                   // xmm0 = xmm0 + xmm1  
23.          sqrtps       xmm0, xmm0                   // xmm0 = sqrt(xmm0)  
24.          addps        xmm0, xmm2                   // xmm0 = xmm1 + xmm2  
25.          movaps       \[edi\], xmm0                  // \[edi\] = xmm0  
26.          add          esi, 16                      // esi += 16  
27.          add          edx, 16                      // edx += 16  
28.          add          edi, 16                      // edi += 16  
29.          dec          ecx                          // ecx--  
30.          jnz          start\_loop                 //如果不为0则转向start\_loop  
31.      \}  
32. \}

最后，在我的计算机上运行计算测试的结果：

纯C++代码计算所用的时间是26 毫秒   
使用SSE的C++ 函数计算所用的时间是 9 毫秒   
包含SSE汇编指令的C++代码计算所用的时间是 9 毫秒

以上的时间结果是在Release优化编译后执行程序得出的。

### SSESample 示例项目 ###

SSESample项目是一个基于对话框的应用程序，其中它用下面的浮点数数组进行计算：

fResult\[i\] = sqrt(fSource\[i\]\*2.8)

其中i = 0, 1, 2 ... ARRAY\_SIZE-1

这个程序同时计算了数组中的最大值和最小值。ARRAY\_SIZE被定义为100000，数组中的计算结果在列表框中显示出来。其中在我的机子上用下面三种方法计算所需的时间是：  
纯C++代码计算                    6 毫秒   
使用SSE的C++ 函数计算      3 毫秒   
使用SSE汇编指令计算          2 毫秒

大家看到，使用SSE汇编指令计算的结果会好一些，因为使用了效率增强了的SSX寄存器组。但是在通常情况下，使用SSE的C++ 函数计算会比汇编代码计算的效率更高一些，因为C++编译器的优化后的代码有很高的运算效率，若要使汇编代码比优化后的代码运算效率更高，这通常是很难做到的。

纯C++代码：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  // 输入: m\_fInitialArray  
2.  // 输出: m\_fResultArray, m\_fMin, m\_fMax  
3.  **void** CSSESampleDlg::OnBnClickedButtonCplusplus()  
4.  \{  
5.       m\_fMin = FLT\_MAX;  
6.       m\_fMax = FLT\_MIN;  
7.       **int** i;  
8.       **for** ( i = 0; i < ARRAY\_SIZE; i++ )  
9.       \{  
10.          m\_fResultArray\[i\] = sqrt(m\_fInitialArray\[i\]   \* 2.8f);  
11.          **if** ( m\_fResultArray\[i\] < m\_fMin )  
12.              m\_fMin = m\_fResultArray\[i\];  
13.          **if** ( m\_fResultArray\[i\] > m\_fMax )  
14.              m\_fMax = m\_fResultArray\[i\];  
15.      \}  
16. \}

使用Visual C++.NET的 SSE指令函数的代码：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  // 输入: m\_fInitialArray  
2.  // 输出: m\_fResultArray, m\_fMin, m\_fMax  
3.  **void** CSSESampleDlg::OnBnClickedButtonSseC()  
4.  \{  
5.       \_\_m128 coeff = \_mm\_set\_ps1(2.8f);       // coeff\[0, 1, 2, 3\] = 2.8  
6.       \_\_m128 tmp;  
7.       \_\_m128 min128 = \_mm\_set\_ps1(FLT\_MAX);   // min128\[0, 1, 2, 3\] = FLT\_MAX  
8.       \_\_m128 max128 = \_mm\_set\_ps1(FLT\_MIN);   // max128\[0, 1, 2, 3\] = FLT\_MIN  
9.       \_\_m128\* pSource = (\_\_m128\*) m\_fInitialArray;  
10.      \_\_m128\* pDest = (\_\_m128\*) m\_fResultArray;  
11.      **for** ( **int** i = 0; i < ARRAY\_SIZE/4; i++ )  
12.      \{  
13.          tmp = \_mm\_mul\_ps(\*pSource, coeff);       // tmp = \*pSource \* coeff  
14.          \*pDest = \_mm\_sqrt\_ps(tmp);               // \*pDest = sqrt(tmp)  
15.          min128 =   \_mm\_min\_ps(\*pDest, min128);  
16.          max128 =   \_mm\_max\_ps(\*pDest, max128);  
17.          pSource++;  
18.          pDest++;  
19.      \}  
20.      // 计算max128的最大值和min128的最小值  
21.      **union** u  
22.      \{  
23.          \_\_m128 m;  
24.          **float** f\[4\];  
25.      \} x;  
26.      x.m = min128;  
27.      m\_fMin = min(x.f\[0\], min(x.f\[1\], min(x.f\[2\], x.f\[3\])));  
28.      x.m = max128;  
29.      m\_fMax = max(x.f\[0\], max(x.f\[1\], max(x.f\[2\], x.f\[3\])));  
30. \}

使用SSE汇编指令的C++函数代码：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  // 输入: m\_fInitialArray  
2.  // 输出: m\_fResultArray, m\_fMin, m\_fMax  
3.  **void** CSSESampleDlg::OnBnClickedButtonSseAssembly()  
4.  \{  
5.       
6.       **float**\* pIn = m\_fInitialArray;  
7.       **float**\* pOut = m\_fResultArray;  
8.       **float** f = 2.8f;  
9.       **float** flt\_min = FLT\_MIN;  
10.      **float** flt\_max = FLT\_MAX;  
11.      \_\_m128 min128;  
12.      \_\_m128 max128;  
13.      // 使用以下的附加寄存器:xmm2、xmm3、xmm4:  
14.      // xmm2 – 相乘系数  
15.      // xmm3 – 最小值  
16.      // xmm4 – 最大值  
17.      \_asm  
18.      \{  
19.          movss    xmm2, f                          // xmm2\[0\] = 2.8  
20.          shufps   xmm2, xmm2, 0                    // xmm2\[1, 2, 3\] = xmm2\[0\]  
21.          movss    xmm3, flt\_max                    // xmm3 = FLT\_MAX  
22.          shufps   xmm3, xmm3, 0                    // xmm3\[1, 2, 3\] = xmm3\[0\]  
23.          movss    xmm4, flt\_min                    // xmm4 = FLT\_MIN  
24.          shufps   xmm4, xmm4, 0                    // xmm3\[1, 2, 3\] = xmm3\[0\]  
25.          mov          esi, pIn                     // 输入数组的地址送往esi  
26.          mov          edi, pOut                    // 输出数组的地址送往edi  
27.          mov          ecx, ARRAY\_SIZE/4            // 循环计数器初始化  
28. start\_loop:  
29.          movaps       xmm1, \[esi\]                  // xmm1 = \[esi\]  
30.          mulps        xmm1, xmm2                   // xmm1 = xmm1 \* xmm2  
31.          sqrtps       xmm1, xmm1                   // xmm1 = sqrt(xmm1)  
32.          movaps       \[edi\], xmm1                  // \[edi\] = xmm1  
33.          minps        xmm3, xmm1  
34.          maxps        xmm4, xmm1  
35.          add          esi, 16  
36.          add          edi, 16  
37.          dec          ecx  
38.          jnz          start\_loop  
39.          movaps       min128, xmm3  
40.          movaps       max128, xmm4  
41.      \}  
42.      **union** u  
43.      \{  
44.          \_\_m128 m;  
45.          **float** f\[4\];  
46.      \} x;  
47.      x.m = min128;  
48.      m\_fMin = min(x.f\[0\], min(x.f\[1\], min(x.f\[2\], x.f\[3\])));  
49.      x.m = max128;  
50.      m\_fMax = max(x.f\[0\], max(x.f\[1\], max(x.f\[2\], x.f\[3\])));  
51. \}

参考文档：

\[1\]MSDN, SSE技术主题：  
[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vcrefstreamingsimdextensions.asp][http_msdn.microsoft.com_library_default.asp_url_library_en-us_vclang_html_vcrefstreamingsimdextensions.asp]

\[2\]Intel软件说明书（Intel Software manuals）：  
[http://developer.intel.com/design/archives/processors/mmx/index.htm][http_developer.intel.com_design_archives_processors_mmx_index.htm]

\[3\] Kris Jearakul的瀑布状图表控件：[http://www.codeguru.com/controls/Waterfall.shtml][http_www.codeguru.com_controls_Waterfall.shtml]

\[4\] Microsoft Visual C++ CPUID示例：  
[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vcsample/html/vcsamcpuiddeterminecpucapabilities.asp][http_msdn.microsoft.com_library_default.asp_url_library_en-us_vcsample_html_vcsamcpuiddeterminecpucapabilities.asp]

\[5\] Matt Pietrek在Microsoft Systems Journal 1998年2月刊上的评论文章：  
[http://www.microsoft.com/msj/0298/hood0298.aspx][http_www.microsoft.com_msj_0298_hood0298.aspx] 。

[http_blog.csdn.net_hikaliv_article_details_4264188]: http://blog.csdn.net/hikaliv/article/details/4264188
[http_blog.csdn.net_olncy_archive_2009_04_16_4084374.aspx]: http://blog.csdn.net/olncy/archive/2009/04/16/4084374.aspx
[http_www.codeproject.com_cpp_sseintro.asp]: http://www.codeproject.com/cpp/sseintro.asp
[view plain]: http://blog.csdn.net/hikaliv/article/details/4264188#
[http_www.codeproject.com_cpp_sseintro_SSE_src.zip]: http://www.codeproject.com/cpp/sseintro/SSE_src.zip
[http_msdn.microsoft.com_library_default.asp_url_library_en-us_vclang_html_vcrefstreamingsimdextensions.asp]: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vcrefstreamingsimdextensions.asp
[http_developer.intel.com_design_archives_processors_mmx_index.htm]: http://developer.intel.com/design/archives/processors/mmx/index.htm
[http_www.codeguru.com_controls_Waterfall.shtml]: http://www.codeguru.com/controls/Waterfall.shtml
[http_msdn.microsoft.com_library_default.asp_url_library_en-us_vcsample_html_vcsamcpuiddeterminecpucapabilities.asp]: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vcsample/html/vcsamcpuiddeterminecpucapabilities.asp
[http_www.microsoft.com_msj_0298_hood0298.aspx]: http://www.microsoft.com/msj/0298/hood0298.aspx