Geschwindigkeitsvergleich Purebasic und C++

[phyll]

Servus, ich hab grade mal ausprobieren wollen, wie groß der Geschwindkeitsunterschied zwischen PB und C++ nun ist. Dafür hab ich ein weitgehend optimiertes Primzahlfindeprogramm in C++ genommen, das ich vor einigen Jahren mal geschrieben habe, und versucht, das ganze mit möglichst gleichem Code in PB zu übersetzen.

PB-Version:

Code: Alles auswählen

marker.b
p=1
wurzel.f

anfang = GetTickCount_()

For i=3 To 1000000
  
  wurzel = Sqr(i)
  marker=0
  
  For k=3 To wurzel Step 2
    If Int(i/k) = i/k
      marker = 1
      Goto break ;anstelle eines break-Befehls
    EndIf 
  Next
  
  break:
    
  If marker=0
    p=p+1
  EndIf
 
Next 
 
ende = GetTickCount_()
dauer=ende-anfang
OpenConsole()
Print("Dauer: " +Str(dauer) +" Millisekunden. Es wurden " +Str(p) +"Primzahlen gefunden.")
Delay(10000)

C++-Version:

Code: Alles auswählen

#include<cstdlib>
#include<iostream>
using namespace std;

int main (void)
{ 
    bool marker;
    int p = 1;
    double wurzel;
    
    DWORD Anfang = GetTickCount();

    for (int i=3; i<1000000; i+=1) 
    { 
        marker = false;
        wurzel = i;
        wurzel = sqrt(wurzel);
        
        for (int k=3; k <= wurzel ; k+=2)
        {
                if (i % k == 0)
                {
                                marker=true; 
                                break;
                }
        }
        
        if (marker == false)
        {
                p++;    
        }
    }
    DWORD Ende = GetTickCount();
    DWORD Dauer = Ende-Anfang;
    cout << "\n Zeit:" << Dauer << "Millisekunden\n" << "Zahl: " << p ;
    system ("PAUSE");
}

Der Geschwindkeitsunterschied beträgt auf meinen Rechner, P4 3 Ghz ungefähr 30% zugunsten von C++. Könnte vielleicht daran liegen, dass der Modulo-Operator schneller ist als ein Vergleich. Meine Werte waren:

PB: 1938, 1937 und 1937 Millisekunden
C++: 1313, 1313 und 1328 Millisekunden.

phyll

[edel]

Waere noch interessant zu wissen , mit welchem Compiler du das
C++ Programm uebersetzt hast.

Aber eigentlich ist ein solcher Vergleich Unsinn, da die C++ Compiler
sehr gut optimieren koennen, was PB nicht macht.

[phyll]

Den C++-Code hab ich mit DEV-C++ kompiliert.

Aber eigentlich ist ein solcher Vergleich Unsinn, da die C++ Compiler
sehr gut optimieren koennen, was PB nicht macht.

Was soll man denn sonst vergleichen, wenn nicht die Optimierungsleistung des Compilers? Diese ist natürlich abhängig von der Sprache, aber wenn alle Compiler perfekt optimieren könnten, wären alle Programmiersprachen theoretisch gleich schnell.

[DarkDragon]

Waere noch interessant zu wissen , mit welchem Compiler du das
C++ Programm uebersetzt hast.

Aber eigentlich ist ein solcher Vergleich Unsinn, da die C++ Compiler
sehr gut optimieren koennen, was PB nicht macht.

Wäre mal interessant zu wissen wieso die C++ Compiler so scheiße optimieren, dass garnichts unter 5kb kommt und mein Spiel trotz Optimierungen nur 20-40 FPS schafft.

[EDIT]
Die STL stinkt halt auch gewaltig und an Optimierungen mangelts da auch.

[THEEX]

Wäre mal interessant zu wissen wieso die C++ Compiler so scheiße optimieren, dass garnichts unter 5kb kommt und mein Spiel trotz Optimierungen nur 20-40 FPS schafft.

Weils an Deinem Code liegt?

[Vallan]

Den C++-Code hab ich mit DEV-C++ kompiliert.

Du meinst den eingebauten MinGW compiler, oder?

[phyll]

Ehrlich gesagt weiß ich nicht wie der Compiler heißt Ich habe jedenfalls den integrierten Compiler von Dev-Cpp Version 4.8.9.0 benutzt.

[Thalius]

MSVC ++ hat eine der schnellsten SQRT(F) Routinen. Könnte daran liegen. Plus je nach Compiler werden CPU Feature Optimierungen gemacht welche in PB zwar möglich jedoch in nativer Form noch nicht vorhanden sind.

EDIT: 5 Posts in der Zeit in der ich das hier schrieb !

Hier findest du ein paar Alternativen zu SQRT:
http://www.purebasic.fr/english/viewtopic.php?t=14459

PB's sqrt() scheint auf AMD schneller zu sein als auf Intel ><

Hier noch einer den ich irgendwo mal ausgegrabven habe ( ungetestet ) mit SSE ( float )

Code: Alles auswählen

;// ~19 clocks on Pentium M vs. ~24 For single Precision sqrtf
  Procedure.f squareroot_sse_22bits( x.f )
  Static half.f = 0.5
  z.f
  
  !movss    xmm1, [p.v_x]     ;// x1: x
  !rsqrtss  xmm2, xmm1        ;// x2: ~1/sqrt(x) = 1/z
  !rcpss    xmm0, xmm2        ;// x0: z == ~sqrt(x) To 0.05%
  
  !movss    xmm4, xmm0        ;// x4: z
  !movss    xmm3, [p.v_half] 
  !mulss    xmm4, xmm4        ;// x4: z*z
  !mulss    xmm2, xmm3        ;// x2: 1 / 2z
  !subss    xmm4, xmm1        ;// x4: z*z-x
  !mulss    xmm4, xmm2        ;// x4: (z*z-x)/2z
  !subss    xmm0, xmm4        ;// x0: z' to 0.000015%
  
  !movss    [p.v_z] , xmm0          
  
  ProcedureReturn z.f
EndProcedure

Thalius

[DarkDragon]

Den C++-Code hab ich mit DEV-C++ kompiliert.

Du meinst den eingebauten MinGW compiler, oder?

Das sollte langsam jeder wissen, dass der gemeint ist wenn jemand als Anfänger Dev-C++ sagt.

[Zaphod]

Die STL stinkt nicht, die ist nur generisch. Da PB keine Generezität anbietet, kann man da auch nicht vergleichen.

Die C++ Compiler tendieren dazu mehr hinzu zu linken als nötig ist. Das man das umgehen kann, zeigen die 4,8,16,32,... kb Demos aus der Demoszene, die sind nämlich in der Regel auch mit C/C++ Compilern kompiliert.