grundsätzliche Frage zu Multithreading

[Gargamel]

Zitat:

Multithreading und DLL-Aufrufe geht natürlich, sofern die Funktionen in der DLL auch threadsicher implementiert sind oder nur von einem Thread verwendet werden.

Wobei mich ja genau das interessiert. Die Funktion in C/C++ sieht so aus:

Delphi-Quellcode:

__declspec(dllexport) int calcCPP(void)
{
   int sum = 0;
   for (int i = 0; i < (100000000 - 1); i++)
        {
            float vecX = 5.7458F;
            float vecY = 3.758F;
            float vecZ = 7.12544F;

            float len = sqrt(vecX*vecX+vecY*vecY+vecZ*vecZ);

            float normX = vecX / len;
            float normY = vecY / len;
            float normZ = vecZ / len;

         sum+=1;
        }
   return sum;
}

[Neutral General]

Und in Delphi?

[Gargamel]

Delphi-Quellcode:

procedure calcDelphi();
var vecX, vecY, vecZ, len, normX, normY, normZ:single;
    i:integer;
Begin
  for i:=0 to 100000000 - 1 do
  Begin
    vecX:= 5.7458;
    vecY:= 3.758;
    vecZ:= 7.12544;

    len:=Sqrt(vecX*vecX+vecY*vecY+vecZ*vecZ);

    normX:= vecX / len;
    normY:= vecY / len;
    normZ:= vecZ / len;
  End;
End;

procedure calcDelphi_withCPP();
Begin
  calcCPP(); // importierte Funktion
End;

[Sir Rufo]

Wobei ich bei solchen Implementierungen immer vorsichtig wäre, denn hier könnte der Compiler auch einfach die Berechnungen wegoptimieren, denn die Ergebnisse sind rein lokal

Und gleich implementiert sind die auch nicht

[Neutral General]

Mach doch am besten mal eine Funktion mit der du allgemein einen Vektor normalisierst.
Und die rufst du dann 1000000x auf oder so.
Macht das einen Unterschied?

Kann mir kaum vorstellen dass C++ da so viel schneller sein kann.

[Gargamel]

@General:
Habe ich schon gemacht. In CPP wurde nur die reine Funktion implementiert und in Delphi x-mal aufgerufen. Das Ergebnis war, dass die benötigte Zeit in Delphi von 0,5 Sekunden auf 0,2 Sekunden sank.

[Gargamel]

@Sir Rufo: Ich hatte einen ähnlichen Gedanken. Möglicherweise erkennt der CPP-Compiler, dass in der Funktion eh immer die gleichen Werte berechnet werden und ruft die Funktion halt nur 1x auf, statt die ganze Schleife komplett durchzulaufen.

[Neutral General]

Ich meinte eher dass du sowohl in C++ als auch in Delphi den Code so umänderst dass du jeweils eine
normalisiereVektor-Funktion hast. Quasi unter realen Bedingungen^^

Delphi-Quellcode:

type
  TVector = record
    x,y,z: Single;
  end;

function normalisieren(AVector: TVector): TVector; // inline;
var len: Integer;
begin
  len := sqrt(AVector.x*AVector.x+AVector.y*AVector.y+AVector.z*AVector.z);
  Result.x := AVector.x / len;
  Result.y := AVector.y / len;
  Result.z := AVector.z / len;
end;

procedure Testen;
var i: Integer; 
    vec: TVector;
begin
  for i:=0 to 100000000 - 1 do
  begin
    vec.x := 5.7458;
    vec.y := 3.758;
    vec.z := 7.12544;
    vec := normalisieren(vec);
  end;
end;

Das gleiche dann nochmal in C++ und dann nochmal die Geschwindigkeit messen.

[jfheins]

Also bei 10 Mio habe ich ja schon gestutzt. Aber 100 Mio. Berechnungen in 0,003 Sekunden ... no way!

Bei einem 3GHz Rechner sind das 11 Berechnungen (Schleifendurchläufe) pro Takt. Da das ganze nicht irgendwie parallelisiert ist, kann das nicht sein!
Du hast da irgendwo einen Fehler im Vergleich drin, die genannte Optimierung wird sicherlich durchgeführt.

Der Vollständigkeit halber wäre ich auch noch an deinem C# Quellcode interessiert

[Gargamel]

@General: Gerade probiert. Jetzt braucht Delphi 1,9 Sekunden.