Si può evitare un sovraccarico vtable usando un static_cast?

Question

Ecco il mio problema. Ho una classe base e una classe derivata che sovrascrive alcuni metodi dalla classe base. Per semplicità si consideri il seguente esempio:

struct base 
{ 
    virtual void fn() 
    {/*base definition here*/} 
}; 

struct derived : base 
{ 
    void fn() 
    {/*derived definition here*/} 
}; 

Nel mio programma vero e proprio, queste classi sono passate come argomenti di altre classi e sono chiamati in altri metodi, ma per ragioni di semplicità creiamo una semplice funzione che prende come argomento o la classe base o derivata. Posso semplicemente scrivere

void call_fn(base& obj) 
{obj.fn();} 

e la chiamata alla funzione appropriata sarà risolto a run-time a causa delle funzioni virtuali.

Sono preoccupato, tuttavia, che se il call_fn, deve essere chiamato milioni di volte (che nel mio caso sarà come la mia applicazione reale è un esperimento di simulazione), otterrò un overhead significativo che vorrei evitare .

Quindi, mi chiedevo se l'utilizzo di un static_cast potrebbe effettivamente affrontare il problema. Forse qualcosa di simile:

template <typename T> 
void call_fn(base& obj) 
{(static_cast<T*>(&obj))->fn();} 

In questo caso, la chiamata di funzione sarebbe fatto come call_fn<base>(obj) per chiamare il metodo base o call_fn<derived>(obj) per chiamare il metodo derivato.

Questa soluzione eviterà l'overhead vtable o sarà comunque interessata? Grazie in anticipo per eventuali risposte!

A proposito, sono a conoscenza del CRTP ma non lo conosco molto bene. Questo è il motivo per cui vorrei conoscere prima la risposta a questa semplice domanda :)

Answer 1

Questa soluzione eviterà l'overhead vtable o sarà comunque interessata?

Continuerà a utilizzare la spedizione dinamica (indipendentemente dal fatto che ciò causi un notevole overhead è una questione completamente diversa). È possibile disattivare la spedizione dinamica qualificando la chiamata di funzione come in:

static_cast<T&>(obj).T::fn(); 

Anche se non vorrei anche provare a farlo. Lascia la spedizione dinamica, quindi verifica le prestazioni dell'applicazione, esegui qualche profilazione, fai ulteriori profilature. Rivedi di nuovo il profilo per assicurarti di capire cosa ti sta dicendo il profiler. Solo allora, considera di apportare una modifica e un profilo di nuovo per verificare se le tue supposizioni sono corrette o meno.

Answer 2

Il VTable risiede nella classe. Se si dispone di membri virtuali, sarà possibile accedere tramite VTable. Il cast non influirà sulla presenza o meno del VTable, né sul modo in cui i membri sono accessibili.

Answer 3

Questa non è davvero una risposta alla tua domanda, ma ero curioso di sapere "quale è veramente l'overhead di chiamare una funzione virtuale contro una normale funzione di classe". Per renderlo "equo", ho creato un classes.cpp che implementa una funzione molto semplice, ma è un file separato che viene compilato al di fuori del "main".

classes.h:

#ifndef CLASSES_H 
#define CLASSES_H 

class base 
{ 
    virtual int vfunc(int x) = 0; 
}; 

class vclass : public base 
{ 
public: 
    int vfunc(int x); 
}; 


class nvclass 
{ 
public: 
    int nvfunc(int x); 
}; 


nvclass *nvfactory(); 
vclass* vfactory(); 


#endif 

classi.cpp:

#include "classes.h" 

int vclass:: vfunc(int x) 
{ 
    return x+1; 
} 


int nvclass::nvfunc(int x) 
{ 
    return x+1; 
} 

nvclass *nvfactory() 
{ 
    return new nvclass; 
} 

vclass* vfactory() 
{ 
    return new vclass; 
} 

Questo è chiamato da:

#include <cstdio> 
#include <cstdlib> 
#include "classes.h" 

#if 0 
#define ASSERT(x) do { if(!(x)) { assert_fail(__FILE__, __LINE__, #x); } } while(0) 
static void assert_fail(const char* file, int line, const char *cond) 
{ 
    fprintf(stderr, "ASSERT failed at %s:%d condition: %s \n", file, line, cond); 
    exit(1); 
} 
#else 
#define ASSERT(x) (void)(x) 
#endif 

#define SIZE 10000000 

static __inline__ unsigned long long rdtsc(void) 
{ 
    unsigned hi, lo; 
    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi)); 
    return ((unsigned long long)lo)|(((unsigned long long)hi)<<32); 
} 


void print_avg(const char *str, const int *diff, int size) 
{ 
    int i; 
    long sum = 0; 
    for(i = 0; i < size; i++) 
    { 
    int t = diff[i]; 
    sum += t; 
    } 

    printf("%s average =%f clocks\n", str, (double)sum/size); 
} 


int diff[SIZE]; 

int main() 
{ 
    unsigned long long a, b; 
    int i; 
    int sum = 0; 
    int x; 

    vclass *v = vfactory(); 
    nvclass *nv = nvfactory(); 


    for(i = 0; i < SIZE; i++) 
    { 
    a = rdtsc(); 

    x = 16; 
    sum+=x; 
    b = rdtsc(); 

    diff[i] = (int)(b - a); 
    } 

    print_avg("Emtpy", diff, SIZE); 


    for(i = 0; i < SIZE; i++) 
    { 
    a = rdtsc(); 

    x = 0; 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    x = v->vfunc(x); 
    ASSERT(x == 4); 
    sum+=x; 
    b = rdtsc(); 

    diff[i] = (int)(b - a); 
    } 

    print_avg("Virtual", diff, SIZE); 

    for(i = 0; i < SIZE; i++) 
    { 
    a = rdtsc(); 
    x = 0; 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    x = nv->nvfunc(x); 
    ASSERT(x == 4);  
    sum+=x; 
    b = rdtsc(); 
    diff[i] = (int)(b - a); 
    } 
    print_avg("no virtual", diff, SIZE); 

    printf("sum=%d\n", sum); 

    delete v; 
    delete nv; 

    return 0; 
} 

La vera differenza nel codice è questo: chiamata virtuale:

40066b: ff 10     callq *(%rax) 

chiamata non virtuale:

4006d3: e8 78 01 00 00   callq 400850 <_ZN7nvclass6nvfuncEi> 

E i risultati:

Emtpy average =78.686081 clocks 
Virtual average =144.732567 clocks 
no virtual average =122.781466 clocks 
sum=480000000 

Ricordiamo che questo è il sovraccarico per 16 chiamate per loop, quindi la differenza tra chiamare una funzione e non chiamare una funzione è di circa 5 cicli di clock per iterazione [compresi sommando i risultati e l'altra elaborazione richiesto], e la chiamata virtuale aggiunge 22 clock per iterazione, quindi circa 1,5 orologi per chiamata.

Dubito che si noterà, assumendo che si faccia qualcosa di un po 'più significativo del ritorno x + 1 nella propria funzione.

Answer 4

Se si dispone di un array polimorfico, in cui gli elementi sono polimorfici ma tutti gli elementi hanno lo stesso tipo, è anche possibile esternalizzare il vtable. Ciò consente di cercare la funzione una volta e quindi chiamarla direttamente su ciascun elemento. In tal caso, C++ non ti aiuta però, dovrai farlo manualmente.

Questo è utile anche se si stanno microptimizzando le cose. Credo che la funzione di Boost usi una tecnica simile. Ha bisogno solo di due funzioni (call e release reference) nel vtable, ma quella generata dal compilatore conterrà anche RTTI e alcune altre cose, che possono essere evitate codificando a mano un vtable che ha solo quei due puntatori di funzione.