x86和x86_64中的float和double之间的性能差异

Question

A while ago I heard that some compilers use SSE2 extensions for floating point operations for x86_64 architecture, so I used this simple code to determine the performance difference between them.

I disabled Intel SpeedStep technology via BIOS and system load was approximately equal for my tests. I am using GCC 4.8 on OpenSuSE 64 bit.

I am writing a program with a lot of FPU operations and I would like to know if this test is valid or not?

And any information about the performance difference between float and double under each architecture is appreciated.

Code :

#include <iostream>
#include <sys/time.h>                
#include <vector>
#include <cstdlib>

using namespace std;

int main()
{
    timeval t1, t2;
    double elapsedTime;

    double TotalTime = 0;


    for(int j=0 ; j < 100 ; j++)
    {
        // start timer
        gettimeofday(&t1, NULL);

        vector<float> RealVec;
        float temp;

        for (int i = 0; i < 1000000; i++)
        {
            temp = static_cast <float> (rand()) / (static_cast <float> (RAND_MAX));
            RealVec.push_back(temp);
        }

        for (int i = 0; i < 1000000; i++)
            {
                RealVec[i] = (RealVec[i]*2-435.345345)/15.75;
            }

        // stop timer
        gettimeofday(&t2, NULL);
        elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0;      // sec to ms
        elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0;   // us to ms

        TotalTime = TotalTime + elapsedTime;
    }


    cout << TotalTime/100 << " ms.\n";

    return 0;
}

and result :

32 Bit Double

157.781 ms. 151.994 ms. 152.244 ms.

32 Bit Float

149.896 ms. 148.489 ms. 161.086 ms.

64 Bit Double

110.125 ms. 111.612 ms. 113.818 ms.

64 Bit Float

110.393 ms. 106.778 ms. 107.833 ms.

Answer 1

Not really valid. You're basically testing the performance of the random number generator.

Also, you're not trying to enforce SSE2 SIMD operation, so you can't really claim this compares anything SSE-related.

Answer 2

Valid in what sense?

Measure actual usage, with your actual code.

Some artificial test suite probably won't help you assess the performance characteristics.

You can use a typedef , then change the actual underlying type with a flick of a switch.

Answer 3

You're really not measuring much; perhaps just the degree of compiler optimization. In order for the measurements to be valid, you really have to do something with the results, or the compiler can optimize out all, or the major part of your tests. What I woule do is 1) initialize the vector, 2) get the start time (probably using clock , since that only takes CPU time into account), 3) execute the second loop a 100 (or more... enough to last a couple of seconds, at least) times, 4) get the end time, and finally, 5) output the sum of the elements in the vector.

With regards to the differences you may find: independently of the floating point processors, the 64 bit machine has more general registers for the compiler to play with. This could have an enormous impact. Unless you look at the generated assembler, you just can't know.