2012-08-10 1 views
8

Sto provando a misurare una differenza di prestazioni tra l'utilizzo di Boost.Variant e l'utilizzo di interfacce virtuali. Ad esempio, supponiamo di voler incrementare in modo uniforme tipi diversi di numeri, utilizzando Boost.Variant. Vorrei usare boost :: variant su int e float e un visitatore statico che incrementa ciascuno di essi. Usando le interfacce di classe userei un puro numero di classe virtuale e le classi number_int e number_float che ne derivano e implementano un metodo di "incremento".

Dal mio test, l'utilizzo delle interfacce è molto più veloce rispetto all'utilizzo di Boost.Variant. Ho eseguito il codice in basso e ha ricevuto questi risultati:
virtuale: 00: 00: 00.001028
Variante: 00: 00: 00,012081
Boost.Variant Vs Prestazioni dell'interfaccia virtuale

Perché pensate che questa differenza è? Pensavo che Boost.Variant sarebbe stato molto più veloce.

** Nota: Solitamente Boost.Variant utilizza allocazioni di heap per garantire che la variante sia sempre non vuota. Ma ho letto sulla documentazione di Boost.Variant che se boost :: has_nothrow_copy è vero allora non usa le allocazioni dell'heap che dovrebbero rendere le cose molto più veloci. Per int e float boost :: has_nothrow_copy è true.

Ecco il mio codice per misurare i due approcci l'uno contro l'altro.

#include <iostream> 

#include <boost/variant/variant.hpp> 
#include <boost/variant/static_visitor.hpp> 
#include <boost/variant/apply_visitor.hpp> 

#include <boost/date_time/posix_time/ptime.hpp> 
#include <boost/date_time/posix_time/posix_time_types.hpp> 
#include <boost/date_time/posix_time/posix_time_io.hpp> 

#include <boost/format.hpp> 

const int iterations_count = 100000; 

// a visitor that increments a variant by N 
template <int N> 
struct add : boost::static_visitor<> { 
    template <typename T>  
    void operator() (T& t) const { 
     t += N; 
    } 
}; 

// a number interface 
struct number {   
    virtual void increment() = 0; 
}; 

// number interface implementation for all types 
template <typename T> 
struct number_ : number { 
    number_(T t = 0) : t(t) {} 
    virtual void increment() { 
     t += 1; 
    } 
    T t; 
}; 

void use_virtual() { 
    number_<int> num_int; 
    number* num = &num_int; 

    for (int i = 0; i < iterations_count; i++) { 
     num->increment(); 
    } 
} 

void use_variant() { 
    typedef boost::variant<int, float, double> number; 
    number num = 0; 

    for (int i = 0; i < iterations_count; i++) { 
     boost::apply_visitor(add<1>(), num); 
    } 
} 

int main() { 
    using namespace boost::posix_time; 

    ptime start, end; 
    time_duration d1, d2; 

    // virtual 
    start = microsec_clock::universal_time(); 
    use_virtual(); 
    end = microsec_clock::universal_time(); 

    // store result 
    d1 = end - start; 

    // variant 
    start = microsec_clock::universal_time(); 
    use_variant(); 
    end = microsec_clock::universal_time(); 

    // store result 
    d2 = end - start; 

    // output 
    std::cout << 
     boost::format(
      "Virtual: %1%\n" 
      "Variant: %2%\n" 
     ) % d1 % d2; 
} 

risposta

14

Per chi fosse interessato, dopo che ero un po 'frustrato, ho superato l'opzione -O2 al compilatore e boost :: variante era il modo più veloce di una chiamata virtuale.
Grazie

+0

Grazie per aver postato il follow-up, che era interessato! –

+0

Quali sono stati i tuoi risultati e quale compilatore? Utilizzando Boost 1.52 e Mingw 4.7, la variante diventa circa 8 volte più lenta in modalità di rilascio. Stranamente '-O2' è leggermente più veloce di' -O3';/ – AbstractDissonance

+0

Sto usando g ++ 4.7 e non sono sicuro di cosa sia la versione Boost ma probabilmente è 1.5x. Ho passato -O2 al compilatore ed i miei risultati sono stati: Virtuale: 00: 00: 00.018806 Variante: 00: 00: 00.000001 La maggior parte delle volte ricevevo 00:00:00 sulla variante, quindi ho impostato iterations_count su 10000000 Sto eseguendo questo test su una CPU Intel Core i7 da 2.8Ghz. –

4

Questo è ovvio che -O2 riduce il tempo variante, poiché l'intero ciclo è ottimizzato. Modificare l'implementazione per restituire il risultato accumulato al chiamante, in modo che l'ottimizzatore non eliminerebbe il ciclo, e si otterrà la vera differenza:

uscita:
virtuale: 00: 00: 00,000120 = 10000000
Variante: 00: 00: 00,013483 = 10000000

#include <iostream> 

#include <boost/variant/variant.hpp> 
#include <boost/variant/static_visitor.hpp> 
#include <boost/variant/apply_visitor.hpp> 

#include <boost/date_time/posix_time/ptime.hpp> 
#include <boost/date_time/posix_time/posix_time_types.hpp> 
#include <boost/date_time/posix_time/posix_time_io.hpp> 

#include <boost/format.hpp> 

const int iterations_count = 100000000; 

// a visitor that increments a variant by N 
template <int N> 
struct add : boost::static_visitor<> { 
    template <typename T> 
    void operator() (T& t) const { 
     t += N; 
    } 
}; 

// a visitor that increments a variant by N 
template <typename T, typename V> 
T get(const V& v) { 
    struct getter : boost::static_visitor<T> { 
     T operator() (T t) const { return t; } 
    }; 
    return boost::apply_visitor(getter(), v); 
} 

// a number interface 
struct number { 
    virtual void increment() = 0; 
}; 

// number interface implementation for all types 
template <typename T> 
struct number_ : number { 
    number_(T t = 0) : t(t) {} 
    virtual void increment() { t += 1; } 
    T t; 
}; 

int use_virtual() { 
    number_<int> num_int; 
    number* num = &num_int; 

    for (int i = 0; i < iterations_count; i++) { 
     num->increment(); 
    } 

    return num_int.t; 
} 

int use_variant() { 
    typedef boost::variant<int, float, double> number; 
    number num = 0; 

    for (int i = 0; i < iterations_count; i++) { 
     boost::apply_visitor(add<1>(), num); 
    } 

    return get<int>(num); 
} 
int main() { 
    using namespace boost::posix_time; 

    ptime start, end; 
    time_duration d1, d2; 

    // virtual 
    start = microsec_clock::universal_time(); 
    int i1 = use_virtual(); 
    end = microsec_clock::universal_time(); 

    // store result 
    d1 = end - start; 

    // variant 
    start = microsec_clock::universal_time(); 
    int i2 = use_variant(); 
    end = microsec_clock::universal_time(); 

    // store result 
    d2 = end - start; 

    // output 
    std::cout << 
     boost::format(
      "Virtual: %1% = %2%\n" 
      "Variant: %3% = %4%\n" 
     ) % d1 % i1 % d2 % i2; 
} 
+3

Non mostra ancora che il virtual è più veloce di 2 ordini di grandezza? –

+0

Sei sicuro che il compilatore non stia virtualizzando? – Brahim