"suivi de variable" est en train de manger mon temps de compilation!

Question

J'ai un fichier généré automatiquement qui ressemble à quelque chose comme ça ...

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... 
    } 
} 

Quand je construis comme ça, le temps de construction est énorme. Si j'introduis toutes les fonctions automatiquement dans leurs cas respectifs en utilisant mon script, le temps de construction est réduit de moitié. GCC 4.5.0 indique ~ 50% du temps de construction est occupé par "suivi de variable" quand j'utilise -ftime-report. Qu'est-ce que cela signifie et comment puis-je accélérer la compilation tout en conservant la localisation de cache supérieure de retirer les fonctions du commutateur?

EDIT: Il est intéressant, le temps de construction a explosé seulement sur debug, selon les informations de profilage suivants du projet dans son ensemble (qui est non seulement le fichier en question, mais toujours une bonne mesure, le fichier en question prend le plus de temps à construire):

• Mise au point: 8 minutes 50 secondes
• sortie: 4 minutes, 25 secondes

Si vous êtes curieux, voici quelques exemples do_func de , co ntext supprimé. Comme vous pouvez le voir, j'ai simplifié un peu la définition du problème pour ne montrer que les parties pertinentes. Au cas où vous vous poseriez la question, tous les appels self-> func sont des appels à boost :: signal.

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

Vous pouvez désactiver le suivi des variables. Le suivi des variables est utilisé pour rendre les informations de débogage un peu plus utiles, mais si ce code est généré automatiquement et que vous ne le déboguerez pas vraiment, ce n'est pas vraiment utile. Vous pouvez simplement l'éteindre pour ce fichier seulement.

gcc -fno-var-tracking ... 

Doit faire l'affaire. Comme je l'ai dit, je pense que vous pouvez le faire pour ce fichier.

Answer 2

Dans GNU Make, vous pouvez désactiver le suivi variable pour une cible unique si votre commande utilise un drapeaux de compilation variables dans les arguments comme

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