C++ visualc&x2B+；SSE函数在没有调试器的情况下启动时变慢

关于SSE的使用，我有一个非常奇怪的问题

我编写了以下函数，其中使用SSE计算两个浮点数组的最大差值，每个数组包含64个浮点

dists数组是通过

\u aligned\u malloc

分配的2d数组

#include <iostream>
#include <xmmintrin.h>
#include <time.h>
#include <stdio.h>
#include <algorithm>
#include <fstream>

#include "hr_time.h"

using namespace std;

float** dists;
float** dists2;
__m128* a;
__m128* b;
__m128* c;
__m128* d;
__m128 diff;
__m128 diff2;
__m128 mymax;
float* myfmax;

float test(int s, int t)
{
    a = (__m128*) dists[s];
    b = (__m128*) dists[t];
    c = (__m128*) dists2[s];
    d = (__m128*) dists2[t];

    diff;
    mymax = _mm_set_ps(0.0, 0.0, 0.0, 0.0);
    for (int i = 0; i <= 16; i++)
    {
        diff = _mm_sub_ps(*a, *b);
        mymax = _mm_max_ps(diff, mymax);

        diff2 = _mm_sub_ps(*d, *c);
        mymax = _mm_max_ps(diff2, mymax);

        a++;
        b++;
        c++;
        d++;
    }

    _mm_store_ps(myfmax, mymax);
    float res = max(max(max(myfmax[0], myfmax[1]), myfmax[2]), myfmax[3]);
    return res;
}

int Deserialize(std::istream* stream)
{
    int numOfElements, arraySize;

    stream->read((char*)&numOfElements, sizeof(int)); // numOfElements = 64
    stream->read((char*)&arraySize, sizeof(int)); // arraySize = 8000000 

    dists = (float**)_aligned_malloc(arraySize * sizeof(float*), 16);
    dists2 = (float**)_aligned_malloc(arraySize * sizeof(float*), 16);
    for (int j = 0; j < arraySize; j++)
    {
        dists[j] = (float*)_aligned_malloc(numOfElements * sizeof(float), 16);
        dists2[j] = (float*)_aligned_malloc(numOfElements * sizeof(float), 16);
    }

    for (int i = 0; i < arraySize; i++)
    {
        stream->read((char*)dists[i], (numOfElements*sizeof(float)));
    }

    for (int i = 0; i < arraySize; i++)
    {
        stream->read((char*)dists2[i], (numOfElements*sizeof(float)));
    }

    return 0;
}

int main(int argc, char** argv)
{
    int entries = 8000000;

    myfmax = (float*)_aligned_malloc(4 * sizeof(float), 16);
    ifstream fs("binary_file", std::ios::binary);
    Deserialize(&fs);

    CStopWatch* watch = new CStopWatch();
    watch->StartTimer();
    int i;
    for (i = 0; i < entries; i++)
    {
        int s = rand() % entries;
        int t = rand() % entries;
        test(s, t);
    }
    watch->StopTimer();
    cout << i << " iterations took " << watch->GetElapsedTimeMs() << "ms" << endl;

    cin.get();
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括“hr_time.h”
使用名称空间std；
浮动**距离；
浮动**dists2；
__m128*a；
__m128*b；
__m128*c；
__m128*d；
__m128差；
__m128-diff2；
__m128 mymax；
浮动*myfmax；
浮动测试（int s，int t）
{
a=（uu m128*）距离[s]；
b=（uu m128*）距离[t]；
c=（uu m128*）距离2[s]；
d=（uu m128*）距离2[t]；
差异；
mymax=_mm_set_ps（0.0,0.0,0.0,0.0）；
对于（int i=0；我读取（（char*）&numOfElements，sizeof（int））；//numOfElements=64
stream->read（（char*）&arraySize，sizeof（int））；//arraySize=8000000
dists=（float**）\u aligned\u malloc（arraySize*sizeof（float*），16）；
dists2=（float**）\u aligned\u malloc（arraySize*sizeof（float*），16）；
对于（int j=0；jread（（char*）dists[i]，（numOfElements*sizeof（float））；
}
for（int i=0；iread（（char*）dists2[i]，（numOfElements*sizeof（float））；
}
返回0；
}
int main（int argc，字符**argv）
{
整数项=8000000；
myfmax=（浮动*）\u对齐\u malloc（4*sizeof（浮动），16）；
ifstream fs（“二进制文件”，std:：ios:：binary）；
反序列化（&fs）；
CStopWatch*watch=新的CStopWatch（）；
watch->StartTimer（）；
int i；
对于（i=0；i停止计时器（）；
cout您的代码有一个bug。
\u mm\u store\u ps
存储一个由四个浮点组成的数组，但您只声明一个。编译器甚至不应该允许您这样做

改变

float fmax;
_mm_store_ps(fmax, max);
pi = std::max(std::max(std::max(fmax[0], fmax[1]), fmax[2]), fmax[3]);

到

嗯，奇怪！我们能看看你的分配代码吗？你是为发布或调试而编译吗？分配有多大？什么是“快”和“非常慢”-你是如何测量这些代码的？在代码的中间是什么？<代码>差异；<代码>。抱歉，很多问题，但是几乎不可能只确定发布的代码有什么错误……让我猜猜：你在一个前沙质桥处理器上运行？@ MyStudio，你能解释一下你的意思吗？“让我猜猜：你是在一个Sandy Bridge之前的处理器上运行的？"@Zboson在OP发布代码之前，没有初始化的迹象。在调试中，它将被初始化为类似于
0xcccc
。在发布中，它将是堆垃圾-有很高的非规范化概率。Sandy Bridge之前的所有处理器都会因以下原因而遭受巨大的减速。你是对的，我忘记了w的一些部分当我从我们的源代码中提取代码时
float __declspec(align(16)) fmax[4];
_mm_store_ps(fmax, max);
return std::max(std::max(std::max(fmax[0], fmax[1]), fmax[2]), fmax[3]);