Performance von reinterpretation zweier Bytes als short?



  • Hi!

    Leider bin ich in ASM sehr schwach, deshalb kann ich mir selbst kein Bild machen.

    Ich möchte sehr oft zwei Bytes mit zwei Bytes vergleichen:

    unsigned char* data = ...
    
    // Compare-Funktion
    bool SomeClass::Compare(const unsigned char* bytes)
    {
        return (this->bytes[0] == bytes[0] && this->bytes[1] == bytes[1]);
    }
    
    // Aufruf, sehr oft
    if(obj->Compare(data))
    // ...
    

    Nun, einfacher wäre es aber, der Compare-Funktion short zu übergeben, allerdings müsste ich dann immer Casten. Wie kostspielig ist das?
    Sollte doch eigentlich egal sein, es wird ja nur anders interpretiert, nicht?
    Und ein Vergleich fällt dann auch weg:

    // Ist das teurer?
    
    unsigned char* data = ...
    
    // Compare-Funktion
    bool SomeClass::Compare(unsigned short shortVal)
    {
        return (this->shortVal == shortVal);
    }
    
    // Aufruf, sehr oft
    if(obj->Compare(*reinterpret_cast<unsigned short*>(data)))
    // ...
    

    Ist vielleicht etwas Mikrooptimierung, aber es ist nur wenig Code und der sollte so performant wie nur möglich sein.

    Anmerkung: Ich programmiere nur für Windows, daher ist diese Casterei problemlos. Es wird immer little endian sein.

    Danke!
    MfG





  • Es ist, wie du vermutet hast: reinterpret_cast kostet rein gar nichts.



  • ein direkter short-vergleich ist da performanter. die casterei ist zumindestens
    bei reinterpret_cast 100% gratis. auf assemblerebene hat sie keine auswirkunden.

    allerdings kann es natürlich sein, dass der compiler dein konstrukt erkennt
    und entsprechend optimiert.

    anstatt zu sagen: "teste es", sag ich einfach mal es ist schneller, zumindestens
    unoptimiert.

    tipp:
    caste in der funktion (einmal), das erspart das casten beim aufrufen (oft).



  • Ok, danke.
    Beim Aufruf von Compare() habe ich die Daten nur als unsigned char* zur Verfügung, ich muss also bei jedem Aufruf einmal casten.



  • messen



  • Der Tipp ist folgendermaßen gemeint:

    bool SomeClass::Compare(const unsigned char* bytes)
    {
        return *reinterpret_cast<unsigned short*>(bytes) ==
               *reinterpret_cast<unsigned short*>(this->bytes);
    }
    

    dann brauchst du beim Aufruf nicht zu casten:

    if(obj->Compare(data))
      ...
    


  • Achso ja, danke.
    In meinem Fall rufe ich die Funktion aber nur an einer Stelle auf, also egal 😉
    MfG


Log in to reply