Падение производительности на gcc - C++ - Ответ 2543321

#include "stdio.h"
#include  "time.h"
#include  "stdlib.h"
#include "complex.h"
 
#include  "math.h"
#include "string.h"
 
//g++ -O3 -msse -msse3 -msse2 main.cpp
#include "pmmintrin.h"
#include "emmintrin.h"
#include "xmmintrin.h"
//__m128d x128 = {
 
int main()
{
 
    dComplex C(1,2), C1(2,4), C2(-1,-1), D(10,0);
    int tm = clock();
    for (int i = 0; i < 1000000000; ++i)
    {
        C1.Re = i & 15;     // меняем входной аргумент, чтоб компилер не пропускал цикл
        C = C1 * C2 + (C2 - C1) * C1;
    }
    tm = clock() - tm;
    printf("time: %f\n",tm * 0.001);
 
 
    printf("%f %f\n",C.Re,C.Im);
 
    return 0;
}

#ifndef COMPLEX
#define COMPLEX
//g++ -O3 -march=k8 -mfpmath=sse -msse3 -msse2 main.cpp complex.cpp
//g++ -O3 -msse -msse3 -msse2 main.cpp
#include "stdlib.h"
#include "math.h"
#include "stdlib.h"
#include "math.h"
 
#include "pmmintrin.h"
#include "emmintrin.h"
#include "xmmintrin.h"
 
 
static __m128d __m128d_1_1 = {-1.0,-1.0},
        __m128d1_1 = {1.0,-1.0};
//__declspec(align(16)) 
struct dComplex
{
        union compl_value
        {
            __m128d value;
            struct re_im_ { double re, im; } re_im;
        } value_un;
#define Re value_un.re_im.re
#define Im value_un.re_im.im
#define Value value_un.value
#define to_xmm(v) *((__m128d*)(&(v)))
#define to_compl(v) *((dComplex*)(&(v)))
        dComplex()
        { }
        ~dComplex()
        { }
        dComplex(double re, double im);
        dComplex(const __m128d & val_xmm);
        dComplex(const dComplex & orig);
        dComplex& operator = (const dComplex & val);
 
        double Module();
        
        double Argument();
        
        dComplex operator + (const dComplex & val);
        dComplex operator - ();
        dComplex operator - (const dComplex & val);
        
 
        dComplex operator * (const dComplex & val);
        
        dComplex operator / (const dComplex & val);
        
        dComplex  operator ^ (int ext);
        
        dComplex  operator ^ (const dComplex & val);
        
        dComplex& operator = (double val);
        dComplex& operator = (const double values[]);
        //dComplex& operator = (const expComplex & exp_compl);
 
};
 
 
        dComplex::dComplex(double re, double im)
        { 
            Re = re;
            Im = im;
        }
        dComplex::dComplex(const __m128d & val_xmm)
        { 
            Value = val_xmm;
        }
        dComplex::dComplex(const dComplex & orig)
        { 
            Value = orig.Value;
        }
        dComplex& dComplex::operator = (const dComplex & val)
        {
            return to_compl(Value = val.Value);
        }
 
        double dComplex::Module()
        {
            compl_value x_un;
            x_un.value = _mm_sub_pd(Value, Value);
            return sqrt(x_un.re_im.re + x_un.re_im.im);
        }
        
        double dComplex::Argument()
        {
            return atan2(Im, Re);
        }
        
        dComplex dComplex::operator + (const dComplex & val)
        {
            return dComplex(_mm_add_pd(Value,val.Value));
        }
        dComplex dComplex::operator - ()
        {
            return dComplex(_mm_mul_pd(Value,__m128d_1_1));
        }
        dComplex dComplex::operator - (const dComplex & val)
        {
            return dComplex(_mm_sub_pd(Value,to_xmm(val)));
        }
        
 
        dComplex dComplex::operator * (const dComplex & val)
        {   
        //  return dComplex(Re * val.Re - Im * val.Im, Re * val.Im + Im * val.Re);
            return dComplex(_mm_addsub_pd(
                _mm_mul_pd(Value, _mm_movedup_pd(val.Value)),
                _mm_mul_pd(
                    _mm_shuffle_pd(Value ,Value, 1),
                    _mm_shuffle_pd(val.Value, val.Value, 3)
                    )
                ));
        }
        
        dComplex dComplex::operator / (const dComplex & val)
        {   
            __m128d x = _mm_mul_pd(val.Value,val.Value),
                r = _mm_shuffle_pd(Value ,Value, 1),
                val_inv = _mm_mul_pd(val.Value, __m128d1_1);
 
            return dComplex(_mm_div_pd(
                _mm_addsub_pd(
                    _mm_mul_pd(Value,_mm_movedup_pd(val_inv)),//_mm_shuffle_pd(val.Value, val.Value, 0)),
                    _mm_mul_pd(
                        r,
                        _mm_shuffle_pd(val_inv, val_inv, 3)
                    )),
                _mm_hadd_pd(x,x)
                ));
        }
        
        dComplex  dComplex::operator ^ (int ext)
        {
            int ex = abs(ext);
            dComplex ret = (ex & 1) ? *this : dComplex(1,0), 
                p = *this;
            while (ex >>= 1)
            {
                p = p * p;
                if (ex & 1) ret = ret * p;
            }
            return ext >= 0 ? ret : dComplex(1,0) / ret;
        }
        
        dComplex  dComplex::operator ^ (const dComplex & val)
        {
            if (val.Im == 0 && val.Re == (int)val.Re)
                return operator ^ ((int)val.Re);
            dComplex EXT(dComplex(
                        0.5 * log(Im * Im + Re * Re),
                        atan2(Im, Re)
                        ) * val);
            return _mm_mul_pd(
                        _mm_movedup_pd(_mm_set_sd(exp(EXT.Re))),
                        _mm_set_pd(sin(EXT.Im),cos(EXT.Im))
                        );
        }
        
        dComplex& dComplex::operator = (double val)
        {
            Re = val;
            Im = 0;
            return *this;
        }
        dComplex& dComplex::operator = (const double values[])
        {
            Re = values[0];
            Im = values[1];
            return *this;
        }
#endif