XNAMath langsamer als inline Funktion Aufruf der selben XNAMath Funktion?



  • Hallo liebes Forum.

    Vorweg ich hab schon nach dem Begriffen XNAMath und inline das Forum durchsucht, allerdings nichts passendes gefunden. Sollte die Frage schon einmal beantwortet worden sein, entschuldigt das bitte und löscht diesen Beitrag.

    Desweiteren sind meine C++ Kenntnisse nur selbst beigebracht und deswegen könnte die Frage vielleicht etwas dumm sein. Ich hoffe ihr verzeiht das. : )

    Ich bin gerade dabei für eigene kleine Projekte eine kleine Mathe Bibliothek zu erstellen. Die Mathe Bibliothek umfasst dabei einfach nur Wrapper Klassen um XNA zu nutzen. Ich finde die Originalaufrufe dafür etwas umständlich.

    Nun nach einem kleinen Test zwischen durch ist mir aufgefallen, dass meine Wrapper Klassenaufrufe schneller ablaufen, als die der eigentlichen XNAMath Bibliothek. Das ganze verwirrt mich etwas und ich bin mir ziemlich sicher, dass ich irgendwo einen Fehler habe.

    Kompilereinstellungen versucht mit: Zi, Ox und Zi, O2 in Visual Studio 2013 (Studenten Version)

    Bisher habe ich diese auch nur als empfohlene Einstellungen für XNA gefunden. Evtl. ist hier schon der Fehler versteckt.

    Im Versuch werden im meinem Programm diese Befehle schneller ausgeführt als die original Befehle:

    In NXVec4:

    inline DirectX::XMVECTOR operator* () const {
       return mVec;
    }
    
    inline DirectX::XMVECTOR & operator* () {
       return mVec;
    }
    
    inline NXVec4 operator + (const NXVec4 & a, const NXVec4 & b) {
       return NXVec4(DirectX::XMVectorAdd(*a, *b));
    }
    inline NXVec4 operator * (const NXVec4 & a, const NXVec4 & b) {
       return NXVec4(DirectX::XMVectorMultiply(*a, *b));
    }
    

    Test Ablauf:

    // XNA Math
    XMFLOAT4 _ta1(1.f, 1.f, 1.f, 1.f), _tb1(1.00000001f, 1.00000001f, 1.00000001f, 1.00000001f);
    XMVECTOR _a1 = XMLoadFloat4(&_ta1);
    XMVECTOR _b1 = XMLoadFloat4(&_tb1);
    
    // NX Math
    NXVec4 _a2(1.f, 1.f, 1.f, 1.f), _b2(1.00000001f, 1.00000001f, 1.00000001f, 1.00000001f);
    
    // timer
    std::chrono::time_point<std::chrono::system_clock> start, end;
    long long elapsed1, elapsed2;
    
    cout << "Starting XNA:" << endl;
    
    start = std::chrono::system_clock::now();
    for (int i = 0; i < TEST_TIMES; ++i) {
       _a1 = XMVectorAdd(_a1, _b1);
    }
    end = std::chrono::system_clock::now();
    elapsed1 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    
    cout << "Starting NX:" << endl;
    
    start = std::chrono::system_clock::now();
    for (int i = 0; i < TEST_TIMES; ++i) {
       _a2 = _a2 + _b2;
    }
    end = std::chrono::system_clock::now();
    elapsed2 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    

    Nun ist meine Frage ob mein nutzen von inline gleich die Methoden von XNAMath mit optimiert? Es würde mich allerdings sehr verwirren und ich könnte es kaum glauben.

    Das Programm ganz (Visual Studio 2013, Windows 8, Windows SDK XNAMath Version)
    noxxkn.de/NXMath.rar



  • welche zeiten misst du?
    mach mal nen loop um den benchmark und lass es 10mal durchlaufen.


Log in to reply