Prestazioni C++, compilatore ottimizzante, funzione vuota in .cpp

Question

Ho una classe molto semplice, denominata Basic, utilizzata in quasi tutti gli altri file in un progetto più grande. In alcuni casi, è necessario eseguire l'output di debug, ma in modalità di rilascio, questo non deve essere abilitato ed essere un NOOP.

Attualmente è presente una definizione nell'intestazione, che attiva o disattiva un pulsante, a seconda dell'impostazione. Quindi questo è sicuramente un NOOP, quando spento. Mi chiedo, se ho il seguente codice, se un compilatore (MSVS/gcc) è in grado di ottimizzare la chiamata di funzione, in modo che sia di nuovo un NOOP. (Facendo ciò, lo switch potrebbe essere in .cpp e lo switching sarà molto più veloce, compilare/link time saver).

--Header-- 
void printDebug(const Basic* p); 

class Basic { 
    Basic() { 
     simpleSetupCode; 

     // this should be a NOOP in release, 
     // but constructor could be inlined 
     printDebug(this); 
    } 
}; 
--Source-- 
// PRINT_DEBUG defined somewhere else or here 
#if PRINT_DEBUG 
void printDebug(const Basic* p) { 
    // Lengthy debug print 
} 
#else 
void printDebug(const Basic* p) {} 
#endif 

Answer 1

Come per tutte le domande di questo tipo, la risposta è - se è veramente importante per voi, provate l'approccio e esaminare il linguaggio assembly emessa.

Answer 2

Il compilatore può eventualmente ottimizzare questo codice, se conosce l'implementazione della funzione printDebug al momento della compilazione. Se printDebug si trova in un altro modulo di oggetto, questo probabilmente può essere ottimizzato solo dal linker, utilizzando l'intera ottimizzazione del programma. Ma l'unico modo per testare questo è leggere il codice assembly generato dal compilatore. Se si dispone già di PRINT_DEBUG macro, è possibile estenderla dal modo come TRACE è definito:

 
#define PRINT_DEBUG // optional 
#ifdef PRINT_DEBUG 
#define PRINT_DEBUG_CALL(p) printDebug(p) 
#else 
#define PRINT_DEBUG_CALL(p) 
#endif 


void printDebug(const Basic* p); 

class Basic { 
    Basic() { 
     simpleSetupCode; 

     // this should be a NOOP in release, 
     // but constructor could be inlined 
     PRINT_DEBUG_CALL(this); 
    } 
}; 
--Source-- 
// PRINT_DEBUG defined somewhere else or here 
#if PRINT_DEBUG 
void printDebug(const Basic* p) { 
    // Lengthy debug print 
} 
#endif 

Answer 3

ERRm, perché non utilizzare il pre-processore di macro in modo diverso?

Proprio della parte superiore della mia testa, qualcosa di simile a:

#define DEBUG_TRACE(p) 
    #ifdef PRINT_DEBUG 
    printDebug(p); 
    #else 
    ; 
    #endif 

Answer 4

Attualmente la maggior parte delle ottimizzazioni sono fatte al momento della compilazione. Alcuni compilatori come LLVM sono in grado di ottimizzare al momento del collegamento. Questa è un'idea davvero interessante. Ti suggerisco di dare un'occhiata.

In attesa di questo tipo di ottimizzazione, quello che puoi fare è il seguente. Definisci una macro che ti permetta di includere la seguente dichiarazione a seconda che DEBUG sia definito o meno.

#ifdef DEBUG 
#define IF_DEBUG (false) {} else 
#else 
#define IF_DEBUG 
#endif 

È possibile l'utilizzo come questo

Basic() { 
     simpleSetupCode; 

     // this should be a NOOP in release, 
     // but constructor could be inlined 
     IF_DEBUG printDebug(this); 
    } 

che è già molto più leggibile di

Basic() { 
     simpleSetupCode; 

     // this should be a NOOP in release, 
     // but constructor could be inlined 
#if DEBUG 
     printDebug(this); 
#endif 
    } 

noti che è possibile utilizzarlo come se fosse una parola chiave

IF_DEBUG { 
    printDebug(this); 
    printDebug(thas); 
} 

Answer 5

#if PRINT_DEBUG 
#define printDebug _real_print_debug 
#else 
#define printDebug(...) 
#endif 

In questo modo il preprocessore eliminerà tutto il codice di debug prima che arrivi anche al compilatore.