[ALG]Snelheid executable afhankelijk van compiler?

[Baron]

Ik heb destijds (op mijn Amiga in basic) een routine gemaakt dat een binaire string in een array stopte zodat ik een snelle conversie decimaal->binair kreeg.
vb x[3] -> 00000011
Ik heb deze routine altijd verder blijven gebruiken om de snelheid tussen verschillende systemen/talen te vergelijken.
Ondertussen heb ik het in C++ gegoten. Ik merk een groot verschil tussen van uitvoering VC++ en CBuilder.
De code is zeker niet optimaal, maar leunt het dichtst bij de basic van toen.

code:

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
  CString x[255];
  int aantal(200000);
  CTime t1, t2;
  int a,b,c,d,e,f,g,h,i, tel;
  double t;

  t1 = CTime::GetCurrentTime();
  cout << "Let's go !!"<< endl;
  for(i=1; i<=aantal;  i++)
  {
     tel = 0;
     for (a=0; a<=1; a++)
     for (b=0; b<=1; b++)
       for (c=0; c<=1; c++)
       for (d=0; d<=1; d++)
         for (e=0; e<=1; e++)
         for (f=0; f<=1; f++)
           for (g=0; g<=1; g++)
           for (h=0; h<=1; h++)
           {
             x[tel]=(100000000+a*10000000+b*1000000+c*100000+d*10000+e*1000+f*100+g*10+h);
               x[tel].Right(8);
               tel++;
             }
  }
  t2 = CTime::GetCurrentTime();
  for (i=0; i>=255; i++)
    cout << x[tel];
  t = (t2.GetHour()-t1.GetHour())*3600+(t2.GetMinute()-t1.GetMinute())*60 + (t2.GetSecond()-t1.GetSecond());
  cout << (t2.GetHour()-t1.GetHour())*3600+(t2.GetMinute()-t1.GetMinute())*60 + (t2.GetSecond()-t1.GetSecond()) << endl;
  cout << t/aantal << "sec" << endl;
  cin >> t;
  return 0;
}

Ik heb een PIII 800 en krijg volgend resultaten.
VisualC 6.0 : 0,000075 sec
CBuilder 5 : 0,00013 sec
Java (1.4) : 0,000203 sec
Java (1.3) : 0,000212 sec
(Op mijn Amiga 500 duurde het destijds 1,25 sec in gecompileerd basic)

Hoe komt het dat er zo'n grote verschillen zijn in VC en CBuilder. (misschien heb ik niet alle optimalisatie opties aangezet)

[dusty]

Op donderdag 14 maart 2002 09:57 schreef Baron het volgende:
[..]
Hoe komt het dat er zo'n grote verschillen zijn in VC en CBuilder. (misschien heb ik niet alle optimalisatie opties aangezet)

Achter beide compilers zitten dus een verschillende engine. Die zullen dus jouw code op verschillende manieren interpreteren. Waardoor je dus een verschillende gecompileerde code krijgt.

[Baron]

Kan er iemand dit eens met een andere compiler proberen?

[roelio]

terzijde: volgens mij kan die routine veel efficienter

ontopic: weet je wel zeker dat jouw routine meer tijd neemt dan de cout en getTime statements? Kun je bij zo'n kleine routine wel serieus meten, zou je de routine dan niet een aantal 100 of 1000 keer moeten laten draaien en die tijd opnemen?

[Baron]

Ik weet dat de routine veel efficienter kan, maar ze is ongeveer 12 jaar oud. Ze moeten mijn eerste stapjes Amiga basic geweest zijn.

weet je wel zeker dat jouw routine meer tijd neemt dan de cout en getTime statements? Kun je bij zo'n kleine routine wel serieus meten, zou je de routine dan niet een aantal 100 of 1000 keer moeten laten draaien en die tijd opnemen?

Enkel het stukje tussen

code:

for(i=1;i<=aantal;i++) { .... }

wordt een aantal keer uitgevoerd en gemeten. In dit geval 200000 dus.

[Varienaja]

Op donderdag 14 maart 2002 09:57 schreef Baron het volgende:
Ik heb een PIII 800 en krijg volgend resultaten.
VisualC 6.0 : 0,000075 sec
CBuilder 5 : 0,00013 sec
Java (1.4) : 0,000203 sec
Java (1.3) : 0,000212 sec
(Op mijn Amiga 500 duurde het destijds 1,25 sec in gecompileerd basic)

Ik zou die tests maar even wat langer laten duren. Deze tijden zijn zo ontzettend kort dat je meteen al een afwijking krijgt als er even een taskswitch tussendoor komt.

[Baron]

De volledige test duurt ongeveer 15 sec en wordt in de (bovenstaande) code 200000 keer uitgevoerd.

[Alarmnummer]

De reden dat java een stuk langzamer is, is dat er altijd array bounds checks worden uitgevoerd. Veiliger, maar wel wat langzamer.

[Baron]

Ik vond dat java het er nog niet zo slecht vanaf bracht t.o.v. CBuilder.
Dit vond ik ook grappig:
Java Excelsior Jet 2.5 beta1 : 0,00025 sec
Java 1.4 : 0,000203 sec
De Jet compiler is trager dan de huidige VM

Java 1.3 (op onze AS/400) : 0,00286 sec
Van waarde kan ik weinig zeggen. Ik heb het gewoon eens geprobeerd.

[Alarmnummer]

Jij test nu alleen een loop en dat is geen goeie representatie van een normale applicatie. Ik denk niet dat je hier veel zinnige uitspraken over kan doen tov applicatie benchmarks. En op welk optimalisatie nivo heb je mbv Jet gecompileerd? De laatste keer dat ik het gezien heb had hij (volgens mij) 10 optimalisatie nivo`s en standaard doet hij de 3e.

[Baron]

Het is inderdaad geen goede representatie van een echt programma. Dit heeft enkel een loopje en een string bewerking.
Welke Jet optimalisatie ik heb gebruikt weet ik niet meer. Ik heb Jet ondertussen van mijn pc gegooid omdat het een beta was en omdat ik toch niet plan ben het te kopen.

Mijn oorspronkelijk punt was het grote verschil tussen VC++ en CBuilder. Want het is letterlijk dezelfde code voor beide compilers (zelfs de MFC CString behouden).
Ik had gehoopt dat er anderen dit met andere compilers (Linux) eens wilden proberen.