SSE加速指令集

其他 2018-06-18 21:17:41 阅读次数: 2

SSE技术简介

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

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

SSE程序设计详细介绍

包含的头文件：

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

#include <xmmintrin.h>

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

　数据分组（Data Alignment）

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

__declspec(align(16)) float m_fArray[ARRAY_SIZE];

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

m_fArray = (float*) _aligned_malloc(ARRAY_SIZE * sizeof(float), 16);

由_aligned_malloc函数分配空间的动态数组可以由_aligned_free函数释放其占用的空间：

_aligned_free(m_fArray);

　__m128 数据类型

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

　CPU对SSE指令集的支持

　　如果你的CPU能够具有了SSE指令集，你就可以使用Visual Studio .NET 2003提供的对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下载示例程序压缩包。该压缩包中含有两个项目，这两个项目是基于微软基本类库（MFC）建立的Visual C++.NET项目，你也可以按照下面的讲解建立这两个项目。

　SSETest 示例项目

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

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++代码：

void CSSETestDlg::ComputeArrayCPlusPlus(
                                        float* pArray1, // [输入] 源数组1
                                        float* pArray2, // [输入] 源数组2
                                        float* pResult, // [输出] 用来存放结果的数组
                                        int nSize) // [输入] 数组的大小
{

    int i;

    float* pSource1 = pArray1;
    float* pSource2 = pArray2;
    float* pDest = pResult;

    for ( i = 0; i < nSize; i++ )
    {
        *pDest = (float)sqrt((*pSource1) * (*pSource1) + (*pSource2) * (*pSource2)) + 0.5f;

        pSource1++;
        pSource2++;
        pDest++;
    }
}

　　下面我们用具有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指令函数的代码：

void CSSETestDlg::ComputeArrayCPlusPlusSSE(
                                            float* pArray1, // [输入] 源数组1
                                            float* pArray2, // [输入] 源数组2
                                            float* pResult, // [输出] 用来存放结果的数组
                                            int nSize) // [输入] 数组的大小
{
    int nLoop = nSize/ 4;

    __m128 m1, m2, m3, m4;

    __m128* pSrc1 = (__m128*) pArray1;
    __m128* pSrc2 = (__m128*) pArray2;
    __m128* pDest = (__m128*) pResult;


    __m128 m0_5 = _mm_set_ps1(0.5f); // m0_5[0, 1, 2, 3] = 0.5

    for ( int i = 0; i < nLoop; i++ )
    {
        m1 = _mm_mul_ps(*pSrc1, *pSrc1); // m1 = *pSrc1 * *pSrc1
        m2 = _mm_mul_ps(*pSrc2, *pSrc2); // m2 = *pSrc2 * *pSrc2
        m3 = _mm_add_ps(m1, m2); // m3 = m1 + m2
        m4 = _mm_sqrt_ps(m3); // m4 = sqrt(m3)
        *pDest = _mm_add_ps(m4, m0_5); // *pDest = m4 + 0.5

        pSrc1++;
        pSrc2++;
        pDest++;
    }
}

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

void CSSETestDlg::ComputeArrayAssemblySSE(
                                            float* pArray1, // [输入] 源数组1
                                            float* pArray2, // [输入] 源数组2
                                            float* pResult, // [输出] 用来存放结果的数组
                                            int nSize) // [输入] 数组的大小
{
    int nLoop = nSize/4;
    float f = 0.5f;

    _asm
    {
        movss xmm2, f // xmm2[0] = 0.5
        shufps xmm2, xmm2, 0 // xmm2[1, 2, 3] = xmm2[0]

        mov esi, pArray1 // 输入的源数组1的地址送往esi
        mov edx, pArray2 // 输入的源数组2的地址送往edx

        mov edi, pResult // 输出结果数组的地址保存在edi
        mov ecx, nLoop //循环次数送往ecx

start_loop:
movaps xmm0, [esi] // xmm0 = [esi]
mulps xmm0, xmm0 // xmm0 = xmm0 * xmm0

        movaps xmm1, [edx] // xmm1 = [edx]
        mulps xmm1, xmm1 // xmm1 = xmm1 * xmm1

        addps xmm0, xmm1 // xmm0 = xmm0 + xmm1
        sqrtps xmm0, xmm0 // xmm0 = sqrt(xmm0)

        addps xmm0, xmm2 // xmm0 = xmm1 + xmm2

        movaps [edi], xmm0 // [edi] = xmm0

        add esi, 16 // esi += 16
        add edx, 16 // edx += 16
        add edi, 16 // edi += 16

        dec ecx // ecx--
        jnz start_loop //如果不为0则转向start_loop
    }
}

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

纯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++代码：

// 输入: m_fInitialArray
// 输出: m_fResultArray, m_fMin, m_fMax
void CSSESampleDlg::OnBnClickedButtonCplusplus()
{
    m_fMin = FLT_MAX;
    m_fMax = FLT_MIN;

    int i;

    for ( i = 0; i < ARRAY_SIZE; i++ )
    {
        m_fResultArray[i] = sqrt(m_fInitialArray[i] * 2.8f);

        if ( m_fResultArray[i] < m_fMin )
            m_fMin = m_fResultArray[i];

        if ( m_fResultArray[i] > m_fMax )
            m_fMax = m_fResultArray[i];
    }
}

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

// 输入: m_fInitialArray
// 输出: m_fResultArray, m_fMin, m_fMax
void CSSESampleDlg::OnBnClickedButtonSseC()
{
    __m128 coeff = _mm_set_ps1(2.8f); // coeff[0, 1, 2, 3] = 2.8
    __m128 tmp;

    __m128 min128 = _mm_set_ps1(FLT_MAX); // min128[0, 1, 2, 3] = FLT_MAX
    __m128 max128 = _mm_set_ps1(FLT_MIN); // max128[0, 1, 2, 3] = FLT_MIN

    __m128* pSource = (__m128*) m_fInitialArray;
    __m128* pDest = (__m128*) m_fResultArray;

    for ( int i = 0; i < ARRAY_SIZE/4; i++ )
    {
        tmp = _mm_mul_ps(*pSource, coeff); // tmp = *pSource * coeff
        *pDest = _mm_sqrt_ps(tmp); // *pDest = sqrt(tmp)

        min128 = _mm_min_ps(*pDest, min128);
        max128 = _mm_max_ps(*pDest, max128);

        pSource++;
        pDest++;
    }

    // 计算max128的最大值和min128的最小值
    union u
    {
        __m128 m;
        float f[4];
    } x;

    x.m = min128;
    m_fMin = min(x.f[0], min(x.f[1], min(x.f[2], x.f[3])));

    x.m = max128;
    m_fMax = max(x.f[0], max(x.f[1], max(x.f[2], x.f[3])));
}

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

// 输入: m_fInitialArray
// 输出: m_fResultArray, m_fMin, m_fMax
void CSSESampleDlg::OnBnClickedButtonSseAssembly()
{

    float* pIn = m_fInitialArray;
    float* pOut = m_fResultArray;

    float f = 2.8f;
    float flt_min = FLT_MIN;
    float flt_max = FLT_MAX;

    __m128 min128;
    __m128 max128;

    // 使用以下的附加寄存器:xmm2、xmm3、xmm4:
    // xmm2 – 相乘系数
    // xmm3 – 最小值
    // xmm4 – 最大值

    _asm
    {
        movss xmm2, f // xmm2[0] = 2.8
        shufps xmm2, xmm2, 0 // xmm2[1, 2, 3] = xmm2[0]

        movss xmm3, flt_max // xmm3 = FLT_MAX
        shufps xmm3, xmm3, 0 // xmm3[1, 2, 3] = xmm3[0]

        movss xmm4, flt_min // xmm4 = FLT_MIN
        shufps xmm4, xmm4, 0 // xmm3[1, 2, 3] = xmm3[0]

        mov esi, pIn // 输入数组的地址送往esi
        mov edi, pOut // 输出数组的地址送往edi
        mov ecx, ARRAY_SIZE/4 // 循环计数器初始化

start_loop:
movaps xmm1, [esi] // xmm1 = [esi]
mulps xmm1, xmm2 // xmm1 = xmm1 * xmm2
sqrtps xmm1, xmm1 // xmm1 = sqrt(xmm1)
movaps [edi], xmm1 // [edi] = xmm1

        minps xmm3, xmm1
        maxps xmm4, xmm1

        add esi, 16
        add edi, 16

        dec ecx
        jnz start_loop

        movaps min128, xmm3
        movaps max128, xmm4
    }

    union u
    {
        __m128 m;
        float f[4];
    } x;

    x.m = min128;
    m_fMin = min(x.f[0], min(x.f[1], min(x.f[2], x.f[3])));

    x.m = max128;
    m_fMax = max(x.f[0], max(x.f[1], max(x.f[2], x.f[3])));
}

   #define WIN  
#include <Windows.h>
#include <intrin.h>  
#include <stdlib.h>  
#include <math.h>  
#include <iostream>
using namespace std;
#define N 4*1000000    // 注意：必须是4的倍数，否则使用SSE指令计算，要进行一些处理，从而保证正确。  
_MM_ALIGN16 float op1[N];
//---dymic array memory align
//float* op1 = (float*)_aligned_malloc(N * sizeof(float), 16);
//_aligned_free(op1);
_MM_ALIGN16 float op2[N];
_MM_ALIGN16 float result1[N];
_MM_ALIGN16 float result2[N];
/*
//---指定字节对齐
__declspec(align(16)) float op1[4] = {1.0, 2.0, 3.0, 4.0};
__declspec(align(16)) float op2[4] = {1.0, 2.0, 3.0, 4.0};
_MM_ALIGN16 float result[4];        // A macro, same as "__declspec(align(16))"
*/
void init()
{
    for (int i = 0; i < N; i++)
    {
        op1[i] = (float)rand() / (float)RAND_MAX;
        op2[i] = (float)rand() / (float)RAND_MAX;
    }
}

void checkResult(int debug)
{
    bool isSame = true;
    for (int i = 0; i < N; i++)
    {
        if (debug)
        {
            cout << "result1:" << result1[i] << "result2:" << result2[i] << endl;
        }
        else
        {
            if (fabs(result1[i] - result2[i]) > 0.000001)
            {
                isSame = false;
                break;
            }
        }
    }
    if (!debug) {
        if (isSame)
            printf("Result is Same\n");
        else
            printf("Result is not same\n");
    }
}

void add1()
{
    for (int i = 0; i < N; i++)
    {
        //op1[i] = (float)rand() / (float)RAND_MAX;
        //op2[i] = (float)rand() / (float)RAND_MAX;
        result1[i] = op1[i] + op2[i];
    }

}

void add2()
{
    __m128  a;
    __m128  b;
    __m128  c;


    //for (int i = 0; i < N; i = i + 4)
    for (int i = 0; i < N/4; i++)
    {
        /*
        op1[i] = (float)rand() / (float)RAND_MAX;
        op2[i] = (float)rand() / (float)RAND_MAX;
        __m128  a;
        __m128  b;
        __m128  c;

        // Load  
        a = _mm_loadu_ps(op1);
        b = _mm_loadu_ps(op2);

        // Calculate  
        c = _mm_add_ps(a, b);
        */
        //---由SSE指令处理的每一个浮点数数组必须把其中需要处理的数每16个字节（128位二进制）分为一组
        // Load  
        /*a = _mm_load_ps(op1 +i);//0.00869
        b = _mm_load_ps(op2 +i);*/
        a = _mm_load_ps(op1);//0.00326
        b = _mm_load_ps(op2);
        //一次会将同时将数组中的4个元素进行运算
        c = _mm_add_ps(a, b);   // c = a + b  //---//将4对32位浮点数同时进行相加操作。这4对32位浮点数来自两个128位的存储单元，再把计算结果（相加之和）赋给一个128位的存储单元。

        //_mm_store_ps(result2 +i, c);
        _mm_store_ps(result2, c);

    }
}
void add3()
{
    //---申请内存空间
    float op1[4] = { 1.0, 2.0, 3.0,4.0};
    float op2[4] = { 1.0, 2.0, 3.0, 4.0};
    float result[4];
    //---申请寄存器内存空间
    __m128  a;
    __m128  b;
    __m128  c;

    // Load---从内存到寄存器中  
    a = _mm_loadu_ps(op1);
    b = _mm_loadu_ps(op2);

    // Calculate  
    c = _mm_add_ps(a, b);   // c = a + b  

    // Store  
    _mm_storeu_ps(result, c);

    /*      // Using the __m128 union to get the result.
    printf("0: %lf\n", c.m128_f32[0]);
    printf("1: %lf\n", c.m128_f32[1]);
    printf("2: %lf\n", c.m128_f32[2]);
    printf("3: %lf\n", c.m128_f32[3]);
    */
    printf("0: %lf\n", result[0]);
    printf("1: %lf\n", result[1]);
    printf("2: %lf\n", result[2]);
    printf("3: %lf\n", result[3]);

}
void add4(
    float* pArray1, // [输入] 源数组1
    float* pArray2, // [输入] 源数组2
    float* pResult, // [输出] 用来存放结果的数组
    int nSize) // [输入] 数组的大小
{

    int i;

    float* pSource1 = pArray1;
    float* pSource2 = pArray2;
    float* pDest = pResult;

    for (i = 0; i < nSize; i++)
    {
        *pDest = (float)sqrt((*pSource1) * (*pSource1) + (*pSource2) * (*pSource2)) + 0.5f;

        pSource1++;
        pSource2++;
        pDest++;
    }
}
void add5(
    float* pArray1, // [输入] 源数组1
    float* pArray2, // [输入] 源数组2
    float* pResult, // [输出] 用来存放结果的数组
    int nSize) // [输入] 数组的大小
{
    int nLoop = nSize / 4;

    __m128 m1, m2, m3, m4;

    __m128* pSrc1 = (__m128*) pArray1;
    __m128* pSrc2 = (__m128*) pArray2;
    __m128* pDest = (__m128*) pResult;


    __m128 m0_5 = _mm_set_ps1(0.5f); // m0_5[0, 1, 2, 3] = 0.5

    for (int i = 0; i < nLoop; i++)
    {
        m1 = _mm_mul_ps(*pSrc1, *pSrc1); // m1 = *pSrc1 * *pSrc1
        m2 = _mm_mul_ps(*pSrc2, *pSrc2); // m2 = *pSrc2 * *pSrc2
        m3 = _mm_add_ps(m1, m2); // m3 = m1 + m2
        m4 = _mm_sqrt_ps(m3); // m4 = sqrt(m3)
        *pDest = _mm_add_ps(m4, m0_5); // *pDest = m4 + 0.5

        pSrc1++;
        pSrc2++;
        pDest++;
    }
}
void OnBnClickedButtonCplusplus()
{
    float m_fMin = FLT_MAX;
    float m_fMax = FLT_MIN;
    const int ARRAY_SIZE = 4 * 100000;
    int i;
    float* m_fResultArray;
    float* m_fInitialArray;
    for (i = 0; i < ARRAY_SIZE; i++)
    {
        m_fResultArray[i] = sqrt(m_fInitialArray[i] * 2.8f);

        if (m_fResultArray[i] < m_fMin)
            m_fMin = m_fResultArray[i];

        if (m_fResultArray[i] > m_fMax)
            m_fMax = m_fResultArray[i];
    }
}
void OnBnClickedButtonSseC()
{
    const int ARRAY_SIZE = 4 * 100000;
    float* m_fResultArray;
    float* m_fInitialArray;
    __m128 coeff = _mm_set_ps1(2.8f); // coeff[0, 1, 2, 3] = 2.8
    __m128 tmp;

    __m128 min128 = _mm_set_ps1(FLT_MAX); // min128[0, 1, 2, 3] = FLT_MAX
    __m128 max128 = _mm_set_ps1(FLT_MIN); // max128[0, 1, 2, 3] = FLT_MIN
    //---使用强制类型转换进行加载
    __m128* pSource = (__m128*) m_fInitialArray;//强制类型转换代替加载
    __m128* pDest = (__m128*) m_fResultArray;
    //__m128* pSource;
    //pSource = _mm_load_ps(m_fInitialArray);//强制类型转换
    //__m128* pDest = (__m128*) m_fResultArray;
    for (int i = 0; i < ARRAY_SIZE / 4; i++)
    {
        tmp = _mm_mul_ps(*pSource, coeff); // tmp = *pSource * coeff
        *pDest = _mm_sqrt_ps(tmp); // *pDest = sqrt(tmp)

        min128 = _mm_min_ps(*pDest, min128);
        max128 = _mm_max_ps(*pDest, max128);

        pSource++;
        pDest++;
    }

    // 计算max128的最大值和min128的最小值
    /*---union可以节省内存
    1. 共用体和结构体都是由多个不同的数据类型成员组成, 但在任何同一时刻, 
    共用体只存放了一个被选中的成员, 而结构体的所有成员都存在。
    2. 对于共用体的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了,
    而对于结构体的不同成员赋值是互不影响的。
    */
    union u
    {
        __m128 m;
        float f[4];
    } x;

    x.m = min128;
    //---获取数组中的最小值
    int m_fMin = min(x.f[0], min(x.f[1], min(x.f[2], x.f[3])));

    x.m = max128;
    int m_fMax = max(x.f[0], max(x.f[1], max(x.f[2], x.f[3])));
}
int main()
{
    init();

    _LARGE_INTEGER time_start;    /*开始时间*/
    _LARGE_INTEGER time_over;        /*结束时间*/
    double dqFreq;                /*计时器频率*/
    LARGE_INTEGER f;            /*计时器频率*/
    QueryPerformanceFrequency(&f);
    dqFreq = (double)f.QuadPart;
    QueryPerformanceCounter(&time_start);
    //---
    printf("Add a vector:\n");
    add1();
    //
    QueryPerformanceCounter(&time_over);
    cout << ((time_over.QuadPart - time_start.QuadPart) / dqFreq) << endl;//单位为秒，精度为1000 000/（cpu主频）微秒

    printf("\n");
    _LARGE_INTEGER time_start1;    /*开始时间*/
    _LARGE_INTEGER time_over1;        /*结束时间*/
    double dqFreq1;                /*计时器频率*/
    LARGE_INTEGER f1;            /*计时器频率*/
    QueryPerformanceFrequency(&f1);
    dqFreq1 = (double)f.QuadPart;
    QueryPerformanceCounter(&time_start1);
    printf("Add a vector with SSE instructions:\n");
    add2();
    QueryPerformanceCounter(&time_over1);
    cout << ((time_over1.QuadPart - time_start1.QuadPart) / dqFreq1) << endl;

    printf("\n");
    checkResult(0);
    add3();
    return 0;
}
/*
//---
#include <iostream>
#include <windows.h>
using namespace    std;
void main()
{
_LARGE_INTEGER time_start;     //开始时间
_LARGE_INTEGER time_over;      //结束时间
double dqFreq;                //计时器频率
LARGE_INTEGER f;              //计时器频率
QueryPerformanceFrequency(&f);
dqFreq = (double)f.QuadPart;
QueryPerformanceCounter(&time_start);
Sleep(1000);//循环耗时
QueryPerformanceCounter(&time_over);
cout << ((time_over.QuadPart - time_start.QuadPart) / dqFreq) << endl;//单位为秒，精度为1000 000/（cpu主频）微秒
}
//---
*/


转自：http://dev.gameres.com/Program/Other/sseintro.htm

猜你喜欢

转载自blog.csdn.net/u014413083/article/details/53559147
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022