SIMD（single-instruction, multiple-data）是一種使用單道指令處理多道資料流的CPU執行模式，即在一個CPU指令執行週期內用一道指令完成處理多個數據的操作。

for each  f in array        //對陣列中的每一個元素
    f = sqrt(f)             //計算它的平方根

為了瞭解實現的細節，我們把上面的程式碼這樣寫：

for each  f in array
{
    把f從記憶體載入到浮點暫存器
    計算平方根
    再把計算結果從暫存器中取出放入記憶體
}

具有Intel SSE指令集支援的處理器有8個128位的暫存器，每一個暫存器可以存放4個（32位）單精度的浮點數。SSE同時提供了一個指令集，其中的指令可以允許把浮點數載入到這些128位的暫存器之中，這些數就可以在這些暫存器中進行算術邏輯運算，然後把結果放回記憶體。採用SSE技術後，演算法可以寫成下面的樣子：

for each  4 members in array  //對陣列中的每4個元素
{
    把陣列中的這4個數載入到一個128位的SSE暫存器中
    在一個CPU指令執行週期中完成計算這4個數的平方根的操作
    把所得的4個結果取出寫入記憶體
}

下面是一個演示的例子

使用純C＋＋

1. void CSSETestDlg::ComputeArrayCPlusPlus(  
2.           float* pArray1,                   // [in] first source array
3.           float* pArray2,                   
   // [in] second source array
4.           float* pResult,                   // [out] result array
5.           int nSize)                        // [in] size of all arrays
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內嵌原語

1. void CSSETestDlg::ComputeArrayCPlusPlusSSE(  
2.           float* pArray1,                   // [in] first source array
3.           float* pArray2,                   // [in] second source array
4.           float* pResult,                   // [out] result array
5.           int nSize)                        // [in] size of all arrays
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.         pSrc1++;  
21.         pSrc2++;  
22.         pDest++;  
23.     }  
24. }  

使用SSE彙編

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. }  

在訊號處理中的實際應用（sse2）：

獲得訊號能量

1. /* 
2. * Compute Energy of a complex signal vector, removing the DC component!  
3. * input  : points to vector 
4. * length : length of vector in complex samples 
5. */
6. #define shift 4
7. #define shift_DC 0
8. int signal_energy(int *input, unsigned int length)  
9. {  
10.     int i;  
11.     int temp, temp2;  
12.     register __m64 mm0, mm1, mm2, mm3;  
13.     __m64 *in;  
14.     in = (__m64 *)input;  
15.     mm0 = _m_pxor(mm0,mm0);  
16.     mm3 = _m_pxor(mm3,mm3);  
17.     for (i = 0; i < length >> 1; i++) {  
18.         mm1 = in[i];  
19.         mm2 = mm1;  
20.         mm1 = _m_pmaddwd(mm1, mm1);  
21.         mm1 = _m_psradi(mm1, shift);  
22.         mm0 = _m_paddd(mm0, mm1);  
23.         mm2 = _m_psrawi(mm2, shift_DC);  
24.         mm3 = _m_paddw(mm3, mm2);  
25.     }  
26.     mm1 = mm0;  
27.     mm0 = _m_psrlqi(mm0, 32);  
28.     mm0 = _m_paddd(mm0, mm1);  
29.     temp = _m_to_int(mm0);  
30.     temp /= length;  
31.     temp <<= shift;   
32.     /*now remove the DC component*/
33.     mm2 = _m_psrlqi(mm3, 32);  
34.     mm2 = _m_paddw(mm2, mm3);  
35.     mm2 = _m_pmaddwd(mm2, mm2);  
36.     temp2 = _m_to_int(mm2);  
37.     temp2 /= (length * length);  
38.     temp2 <<= (2 * shift_DC);  
39.     temp -= temp2;  
40.     _mm_empty();  
41.     _m_empty();  
42.     return((temp > 0) ? temp : 1);  
43. }