Compilier Frage

[Gast]

Hi ich habe einmal folgenden Referenzcode:

Bench::Bench()
{
const int range=46000000;
zahlen=new float[range];
double zahl=65.0001;
for(int i=0;i<range;i++)
{
zahlen[i]=zahl+30.1+i;

}
}

double Bench::get_time_calculation_with_simd()
{
double time1=GetTickCount();
float sum0,sum1,sum2,sum3,sum;

for(int i=0;i<range;i+=4)
{
sum0 += zahlen[i];
sum1 += zahlen[i+1];
sum2 += zahlen[i+2];
sum3 += zahlen[i+3];
}
sum = (sum0+sum1) + (sum2+sum3);
double time2=GetTickCount();

return (time2-time1);
}
double Bench::get_time_calculation_fpu()
{
float sum=0.0;
double time1=GetTickCount();
for(int i=0;i<range;i++)
{
sum+=zahlen[i];
}
double time2=GetTickCount();
return (time2-time1);
}


Der Borland Compilier gibt folgende Zeiten an:
FPU Zeit:438 ms
SIMD Zeit:297 ms
während der Ms Visual Studio 2003 für beide jewahls 0 ms brauche.
Woher kommt dieser enorme Unterschied?

[zeckensack]

Die Berechnung von sum ist toter Code, weil das Ergebnis nicht gespeichert wird. Evtl optimiert der Compiler das einfach völlig raus :|

Versuch mal was passiert wenn du das Ergebnis irgendwo (zB in einer Klassenvariable von Bench) abspeicherst.

[Gast]

Hi Zeckensack,
du hattest Recht :) Nachdem ich das Ergebniss in einer Klassenvariable zwischengespeichert hatte,ist das Ergebniss nun folgendes:
SIMD: 234 ms
FPU: 219 ms

Die einzige Frage,die ich mir nun stelle ist,warum beim Visual Studio Compiler
die SIMD Variante langsamer ist als die FPU Variante und warum beim Borland Compiler es genau anders rum ist.

[Trap]

Es kommt darauf an wie der Compiler optimiert. Je einfacher der Code ist, desto wahrscheinlicher hat der Compiler für diesen Spezialfall eine angepasste optimierte Codegeneration.

Die kann dann im Ergebniss besser sein als der von Hand in der Hochsprache angepasste Code.