"seguimiento variable" está comiendo mi tiempo de compilación!

Question

Tengo un archivo generado automáticamente que se ve algo como esto ...

static void do_SomeFunc1(void* parameter) 
{ 
    // Do stuff. 
} 

// Continues on for another 4000 functions... 

void dispatch(int id, void* parameter) 
{ 
    switch(id) 
    { 
     case ::SomeClass1::id: return do_SomeFunc1(parameter); 
     case ::SomeClass2::id: return do_SomeFunc2(parameter); 
     // This continues for the next 4000 cases... 
    } 
} 

Cuando construyo como este, el tiempo de construcción es enorme. Si incluyo automágicamente todas las funciones en sus respectivos casos utilizando mi secuencia de comandos, el tiempo de construcción se reduce a la mitad. GCC 4.5.0 dice que ~ 50% del tiempo de compilación está siendo utilizado por "tracking variable" cuando uso -ftime-report. ¿Qué significa esto y cómo puedo acelerar la compilación mientras mantengo la ubicación de caché superior para extraer las funciones del conmutador?

EDITAR: Curiosamente, el tiempo de construcción se ha disparado sólo en versiones de depuración, de acuerdo con la siguiente información de perfiles de todo el proyecto (que no es sólo el archivo en cuestión, pero sigue siendo una buena métrica; el archivo en cuestión toma más tiempo para construir):

• depuración: 8 minutos 50 segundos
• de lanzamiento: 4 minutos, 25 segundos

Si tienes curiosidad, aquí son una muestra algunas de do_func , co ntext eliminado. Como puede ver, simplifiqué un poco la definición del problema para mostrar solo las partes relevantes. En caso de que te lo estés preguntando, todas las llamadas autocofrentes son llamadas a impulsar :: señales.

static void do_Match_Login(Registry* self, const uint8_t* parameters, uint16_t length) 
{ 
    const uint8_t* paramPtr = parameters; 

    std::string p0 = extract_string(parameters, &paramPtr, length); 
    std::string p1 = extract_string(parameters, &paramPtr, length); 
    int32_t p2 = extract_int32(parameters, &paramPtr, length); 
    uint32_t p3 = extract_uint32(parameters, &paramPtr, length); 
    tuple<Buffer, size_t, size_t> p4 = extract_blob(parameters, &paramPtr, length); 

    return self->Match_Login(p0, p1, p2, p3, p4); 
} 

static void do_Match_ResponseLogin(Registry* self, const uint8_t* parameters, uint16_t length) 
{ 
    const uint8_t* paramPtr = parameters; 

    int32_t p0 = extract_int32(parameters, &paramPtr, length); 
    std::string p1 = extract_string(parameters, &paramPtr, length); 
    array<uint16_t, 3> p2 = extract_vector(parameters, &paramPtr, length); 
    std::string p3 = extract_string(parameters, &paramPtr, length); 
    uint8_t p4 = extract_uint8(parameters, &paramPtr, length); 
    uint8_t p5 = extract_uint8(parameters, &paramPtr, length); 
    uint64_t p6 = extract_MUID(parameters, &paramPtr, length); 
    bool p7 = extract_bool(parameters, &paramPtr, length); 
    tuple<Buffer, size_t, size_t> p8 = extract_blob(parameters, &paramPtr, length); 

    return self->Match_ResponseLogin(p0, p1, p2, p3, p4, p5, p6, p7, p8); 
} 

Answer 1

Puede desactivar el seguimiento de variables. El seguimiento de variables se usa para hacer que la información de depuración sea un poco más valiosa, pero si este código se genera automáticamente y no vas a depurarlo mucho, entonces no es realmente útil. Puede desactivarlo para ese archivo solo.

gcc -fno-var-tracking ... 

Debería hacer el truco. Como dije, creo que puedes hacerlo para ese archivo.

Answer 2

En GNU make, puede desactivar el control variable para un solo objetivo si su mandato de compilación utiliza unas banderas variables en los argumentos como

fileName.o: CXXFLAGS += -fno-var-tracking