grundsätzliche Frage zu Multithreading

[Neutral General]

Und in C++ ? (darum gings ja in erster Linie )
Und dann noch den C# Code!

[Gargamel]

@jfheins: Gerne doch.

Delphi-Quellcode:

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

            float len = Mathf.Sqrt(vecX*vecX+vecY*vecY+vecZ*vecZ);

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

[Sir Rufo]

@Gargamel

Implementiere doch mal in allen 3 Sprachen die Funktion

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;

exact gleich und führe dann deine Messung erneut durch. Diese Werte wären interessant im Vergleich zu sehen

[Gargamel]

Mit dem nachfolgenden C++-Code sind es 0,8 Sekunden.

Delphi-Quellcode:

TVector normalisieren(TVector AVector)
{
  float len = sqrt(AVector.x*AVector.x+AVector.y*AVector.y+AVector.z*AVector.z);
  AVector.x = AVector.x / len;
  AVector.y = AVector.y / len;
  AVector.z = AVector.z / len;
  return AVector;
}

__declspec(dllexport) void cppTesten()
{
  TVector vec;
  for (int i=0; i< 100000000 - 1; i++)
  {
    vec.x = 5.7458F;
    vec.y = 3.758F;
    vec.z = 7.12544F;
    vec = normalisieren(vec);
  }
}

[Gargamel]

@alle: Damit jetzt alle drei Sprachen abgedeckt wurden, hier noch der C#-Code. Die benötigte Zeit hierfür beträgt 2,9 Sekunden.

Delphi-Quellcode:

public struct TVector
    {
        public float x;
        public float y;
        public float z;
    }

////////////////////////////

public TVector normalisieren(TVector AVector)
    {
        float len = Mathf.Sqrt(AVector.x * AVector.x + AVector.y * AVector.y + AVector.z * AVector.z);
        AVector.x = AVector.x / len;
        AVector.y = AVector.y / len;
        AVector.z = AVector.z / len;
        return AVector;
    }

void calcCSharp_V2()
    {
        TVector vec;
        for (int i = 0; i < 100000000 - 1; i++)
        {
            vec.x = 5.7458F;
            vec.y = 3.758F;
            vec.z = 7.12544F;
            vec = normalisieren(vec);
        }
    }

[Neutral General]

Also ernsthaft.. Jetzt würde ich noch gerne den Maschinencode der normalisieren Funktion in Delphi und C++ sehen

Wo spart C++ denn da über die Hälfte der Zeit?

[Robotiker]

Zitat von Blup:

Ein Unterschied von 2-5% zwischen den einzelnen Compilern ist durchaus denkbar,

Der Unterschied zwischen den (32 Bit-) Compilern vom C++ Builder und Visual C++ ist durchaus größer als 2-5%, eher manchmal 20-50% bei gleichem Code.

Zitat von Neutral General:

Wo spart C++ denn da über die Hälfte der Zeit?

Von welchem Compiler reden wir eigentlich ?
Schlägt da ein Vektorisierer zu, wie bei Microsoft oder Intel ?
http://msdn.microsoft.com/de-de/library/hh872235.aspx

[Gargamel]

1. Für C++ habe ich Visual C++ 2010 Express verwendet. Ahnung habe ich aber nicht, welche Optimierungen da vorgenommen werden.

2. Thema Multithreading: Nehmen wir an, es ist ein QuadCore, ich erstelle 4 Threads und es gibt 4 KI-Objekte. Jedes Objekt läuft auf einem separaten Kern. Jetzt wird, auch angenommen, ständig in jedem Objekt ein Vektor normalisiert. Die vier Threads laufen über Delphi, jedoch wird die "normalisieren"-Funktion aus einer C++-DLL aufgerufen. Würde das funktionieren oder gibt es da Probleme?

[Sir Rufo]

Letztens las ich erst, dass man für intensive Berechnungen 2*CPUKerne an Threads benutzen kann.

Die aufgerufenen Funktionen laufen immer in diesem Kontext (wenn man das nicht aktiv ändert und in einen weiteren Thread übergibt)

[Der schöne Günther]

Jeder Thread hat doch seinen eigenen Stack, das Beispiel mit der Vektor-Normalisierung dürfte doch problemlos klappen?