Haben diese Defines irgendeinen Sinn?



  • Bitte ein Bit schrieb:

    void WriteToLog(const std::string& Msg)
    {
    #ifdef _DEBUG
        g_pages_mutex.lock();
        //...
        g_pages_mutex.unlock();
    #endif
    }
    

    So besser? :p

    Nein. Aufrufen tut man es immernoch mit

    WriteLog(whoAmI()+" sends SQL-Command=\"+sql+"\");
    

    und die Funktionsaufrufe und Stingverarbeitung kosten was.

    Also baut man keine ein/aus-schaltbaren Log-Zeilen ein, sondern loggt lieber gar nicht.



  • Ernstgemeint: Ernsthaft?

    Ich dachte bisher der Compiler würde erkennen, dass die aufzurufende Funktion keinen Inhalt hat und sie daher wegoptimieren 😕 😕



  • wooooo schrieb:

    Ernstgemeint: Ernsthaft?

    Ich dachte bisher der Compiler würde erkennen, dass die aufzurufende Funktion keinen Inhalt hat und sie daher wegoptimieren 😕 😕

    In dem Fall natürlich unter der Voraussetzung das whoAmI() "const" ist



  • @Bitte ein Bit
    Miss mal die Performance wenn die Log-Ausgaben zwar mit reincompiliert sind, aber nicht ausgegeben werden (="dynamisch" ausgeschaltet).
    Das ist ein Fall auf den BOOST_LOG speziell hinoptimiert ist.
    Da bleibt nämlich ausser einem "if" nichts mehr übrig -- auch nicht das Auswerten der Expressions die in die Log-Message reingeshiftet werden.

    Wie schnell es dann beim Schreiben ist, ist mir mehr oder weniger egal. (So lange es nicht komplett krass langsam ist.)



  • wooooo schrieb:

    Ernstgemeint: Ernsthaft?

    Ich dachte bisher der Compiler würde erkennen, dass die aufzurufende Funktion keinen Inhalt hat und sie daher wegoptimieren 😕 😕

    Der kann doch nicht wissen, welche Nebeneffekte whoAmI() hat.

    for(int i=0;i<1000000000;++i){//packt er
    }
    
    string fuu;
    for(int i=0;i<1000000000;++i){//weiß nicht, würde mich wundern
       string bar(foo+"test");
    }
    
    for(int i=0;i<1000000000;++i){//klassische optimiererblindmachzeitschleife
       cout<<"";
    }
    


  • hustbaer schrieb:

    Da bleibt nämlich ausser einem "if" nichts mehr übrig -- auch nicht das Auswerten der Expressions die in die Log-Message reingeshiftet werden.

    Wie soll das denn gehen?



  • BOOST_LOG(logger)
            << Expression1
            << Expression2
            ...;
    
    // Wird zu (sinngemäss, stark vereinfacht)
    
        // --BEGIN-- BOOST_LOG(logger)
        if (!IsLoggerEnabled(logger))
            ;
        else
            LogMessage(logger, __FILE__, __LINE__)
        // --END--
            << Expression1
            << Expression2
            ...;
    

    In diesem Beispiel müsste die LogMessage sich selbst im Destruktor selbst loggen. Ich meine sie haben das in Wirklichkeit über nen for -Loop umgesetzt, aber der Teil ist ja diesbezüglich nicht interessant.
    Wichtig ist dass Expression1 , Expression2 etc. nicht ausgewertet werden wenn der Logger nicht aktiv ist.

    (Und man kann Logger auch statisch deaktivieren -- wobei BOOST_LOG dann über Template-Magic dafür sorgt dass IsLoggerEnabled(logger) compile-time-constant wird.)



  • hustbaer schrieb:

    BOOST_LOG(logger)
            << Expression1
            << Expression2
            ...;
    
    // Wird zu (sinngemäss, stark vereinfacht)
    
        // --BEGIN-- BOOST_LOG(logger)
        if (!IsLoggerEnabled(logger))
            ;
        else
            LogMessage(logger, __FILE__, __LINE__)
        // --END--
            << Expression1
            << Expression2
            ...;
    

    In diesem Beispiel müsste die LogMessage sich selbst im Destruktor selbst loggen. Ich meine sie haben das in Wirklichkeit über nen for -Loop umgesetzt, aber der Teil ist ja diesbezüglich nicht interessant.
    Wichtig ist dass Expression1 , Expression2 etc. nicht ausgewertet werden wenn der Logger nicht aktiv ist.

    (Und man kann Logger auch statisch deaktivieren -- wobei BOOST_LOG dann über Template-Magic dafür sorgt dass IsLoggerEnabled(logger) compile-time-constant wird.)

    Was schreibst Du ins Makro FOO, damit bei

    FOO()<<system("cls");
    

    der Systemaufruf nicht passiert?


  • Mod

    volkard schrieb:

    Was schreibst Du ins Makro FOO, damit bei

    FOO()<<system("cls");
    

    der Systemaufruf nicht passiert?

    Könnte so aussehen:
    http://www.c-plusplus.net/forum/p2362104#2362104



  • SeppJ schrieb:

    volkard schrieb:

    Was schreibst Du ins Makro FOO, damit bei

    FOO()<<system("cls");
    

    der Systemaufruf nicht passiert?

    Könnte so aussehen:
    http://www.c-plusplus.net/forum/p2362104#2362104

    Das hat mich jetzt nicht befriedigt.


  • Mod

    volkard schrieb:

    SeppJ schrieb:

    volkard schrieb:

    Was schreibst Du ins Makro FOO, damit bei

    FOO()<<system("cls");
    

    der Systemaufruf nicht passiert?

    Könnte so aussehen:
    http://www.c-plusplus.net/forum/p2362104#2362104

    Das hat mich jetzt nicht befriedigt.

    Wieso? Das erzeugt Code wie den hier:

    FOO()<<system("cls");
    

    ->

    if (true); else Logger << system("cls");
    

    Da wird doch niemals system aufgerufen, da sollte nicht einmal ein (niemals aufgerufener) Aufruf im Code sein, sondern alles komplett wegoptimiert werden.



  • Oh, wie blind von mir!
    thx.



  • SeppJ schrieb:

    ->

    if (true); else Logger << system("cls");
    

    Da wird doch niemals system aufgerufen, da sollte nicht einmal ein (niemals aufgerufener) Aufruf im Code sein, sondern alles komplett wegoptimiert werden.

    Ja.
    Wobei ich den grossen Vorteil eher darin sehe, dass auch mit compile-time aktivem Logger nur Log-Ausgaben, die auch wirklich gemacht werden, merklich bremsen.

    (Der dynamische Test ob ein Logger aktiv ist verwendet bei Boost.Log IIRC nen relaxed atomic load, ist also wirklich sehr billig. Bitte um Korrektur falls es jmd. genauer weiss und ich mich vertan/falsch erinnert habe.)



  • volkard schrieb:

    Kellerautomat schrieb:

    Codegenerierung.

    Hab ich in den letzten Jahren immer mit Templates gemacht.

    #include <iostream>
    using namespace std;
    
    template<int n>
    struct TuWas{
        static void tuWas(){
            TuWas<n-1>::tuWas();
            cout<<n<<'*'<<n<<'='<<n*n<<'\n';
        }
    };
    template<>
    struct TuWas<0>{
        static void tuWas(){
        }
    };
    
    int main(){
        TuWas<10>::tuWas();
    }
    

    Ich rede von Codegenerierung im Sinne von Source Code, nicht ausfuehrbarem Code.
    Bestimmte Dinge lassen sich mit Templates einfach nicht sinnvoll generieren.


Anmelden zum Antworten