¿Por qué la llamada a función virtual es más rápida que dynamic_cast?

Question

Escribí un ejemplo simple, que estima el tiempo promedio de llamada de la función virtual, utilizando la interfaz de clase base y dynamic_cast y llamada de la función no virtual. aquí es que:

#include <iostream> 
#include <numeric> 
#include <list> 
#include <time.h> 

#define CALL_COUNTER (3000) 

__forceinline int someFunction() 
{ 
    return 5; 
} 

struct Base 
{ 
    virtual int virtualCall() = 0; 
    virtual ~Base(){}; 
}; 

struct Derived : public Base 
{ 
    Derived(){}; 
    virtual ~Derived(){}; 
    virtual int virtualCall(){ return someFunction(); }; 
    int notVirtualCall(){ return someFunction(); }; 
}; 


struct Derived2 : public Base 
{ 
    Derived2(){}; 
    virtual ~Derived2(){}; 
    virtual int virtualCall(){ return someFunction(); }; 
    int notVirtualCall(){ return someFunction(); }; 
}; 

typedef std::list<double> Timings; 

Base* createObject(int i) 
{ 
    if(i % 2 > 0) 
    return new Derived(); 
    else 
    return new Derived2(); 
} 

void callDynamiccast(Timings& stat) 
{ 
    for(unsigned i = 0; i < CALL_COUNTER; ++i) 
    { 
    Base* ptr = createObject(i); 

    clock_t startTime = clock(); 

    for(int j = 0; j < CALL_COUNTER; ++j) 
    { 
     Derived* x = (dynamic_cast<Derived*>(ptr)); 
     if(x) x->notVirtualCall(); 
    } 

    clock_t endTime = clock(); 
    double callTime = (double)(endTime - startTime)/CLOCKS_PER_SEC; 
    stat.push_back(callTime); 

    delete ptr; 
    } 
} 

void callVirtual(Timings& stat) 
{ 
    for(unsigned i = 0; i < CALL_COUNTER; ++i) 
    { 
    Base* ptr = createObject(i); 

    clock_t startTime = clock(); 

    for(int j = 0; j < CALL_COUNTER; ++j) 
     ptr->virtualCall(); 


    clock_t endTime = clock(); 
    double callTime = (double)(endTime - startTime)/CLOCKS_PER_SEC; 
    stat.push_back(callTime); 

    delete ptr; 
    } 
} 

int main() 
{ 
    double averageTime = 0; 
    Timings timings; 


    timings.clear(); 
    callDynamiccast(timings); 
    averageTime = (double) std::accumulate<Timings::iterator, double>(timings.begin(), timings.end(), 0); 
    averageTime /= timings.size(); 
    std::cout << "time for callDynamiccast: " << averageTime << std::endl; 

    timings.clear(); 
    callVirtual(timings); 
    averageTime = (double) std::accumulate<Timings::iterator, double>(timings.begin(), timings.end(), 0); 
    averageTime /= timings.size(); 
    std::cout << "time for callVirtual: " << averageTime << std::endl; 

    return 0; 
} 

Parece que callDynamiccast lleva casi dos veces más.

time for callDynamiccast: 0.000240333

time for callVirtual: 0.0001401

Cualquier idea por qué lo hace?

EDITADO: la creación de objetos se realiza ahora en la función separada, por lo que el complemento no la conoce como tipo real. Casi el mismo resultado.

EDITED2: crea dos tipos diferentes de objetos derivados.

Answer 1

La llamada a la función virtual es similar a un puntero a la función, o si el compilador conoce el tipo, el envío estático. Este es un tiempo constante.

dynamic_cast es bastante diferente: utiliza un medio definido por la implementación para determinar un tipo. No es un tiempo constante, puede atravesar la jerarquía de clases (también considerar la herencia múltiple) y realizar varias búsquedas. Una implementación puede usar comparaciones de cadenas. Por lo tanto, la complejidad es mayor en dos dimensiones. Los sistemas en tiempo real a menudo evitan/desalientan dynamic_cast por estos motivos.

Más detalles están disponibles in this document.

Answer 2

Usted solo está midiendo el costo de dynamic_cast<>. Se implementa con RTTI, que es opcional en cualquier compilador de C++. Project + Properties, C/C++, Language, Enable Run-Time Type Info setting. Cámbielo a No.

Ahora recibirá un recordatorio poco sutil de que dynamic_cast<> ya no puede realizar el trabajo adecuado. Arregla arbitrariamente en static_cast<> para obtener resultados drásticamente diferentes. El punto clave aquí es que si sabe que un upcast es siempre seguro, entonces static_cast<> le compra el rendimiento que está buscando. Si no sabe por el hecho de que la actualización es segura, entonces dynamic_cast<> lo mantiene alejado de problemas. Es el tipo de problema que es terriblemente difícil de diagnosticar. El modo de falla común es la corrupción del montón, solo obtendrá un GPF inmediato si tiene mucha suerte.

Answer 3

Cabe señalar que propósito completo de funciones virtuales es no tener que arrojar el gráfico de herencia. Existen funciones virtuales para que pueda usar una instancia de clase derivada como si fuera una clase base. Para que se puedan llamar implementaciones más especializadas de funciones desde un código que originalmente se llamaba versiones de clase base.

Si las funciones virtuales fueran más lentas que un lanzamiento seguro a la llamada de función de clase derivada +, entonces los compiladores de C++ simplemente implementarían llamadas a funciones virtuales de esa manera.

Así que no hay ninguna razón para esperar que dynamic_cast + llame para ser más rápido.

Answer 4

La diferencia es que puede llamar a la función virtual en cualquier instancia derivada de Base.El miembro notVirtualCall() no existe dentro de Base, y no se puede llamar sin primero determinar el tipo dinámico exacto del objeto.

La consecuencia de esta diferencia es que el vtable de la clase base incluye una ranura para virtualCall(), que contiene un puntero a la función correcta para llamar. Entonces, la llamada virtual simplemente persigue el puntero vtable incluido como el primer miembro (invisible) de todos los objetos de tipo Base, carga el puntero desde la ranura correspondiente a virtualCall() y llama a la función detrás de ese puntero.

Cuando hace un dynamic_cast<>, por el contrario, la clase Base no sabe en tiempo de compilación qué otras clases eventualmente derivarán de ella. En consecuencia, no puede incluir información dentro de su vtable que facilite la resolución del dynamic_cast<>. Esa es la falta de información que hace que dynamic_cast<> sea más costoso de implementar que una llamada de función virtual. El dynamic_cast<> tiene que buscar realmente a través del árbol de herencia del objeto real para comprobar si el tipo de destino del molde se encuentra entre sus bases. Ese es un trabajo que la llamada virtual evita.