EASTL performance

Question

Oggi ho scaricato e creato un progetto di esempio dell'implementazione STL di Electronic Arts e il vettore di EA mi sembra molto più lento dello standard. Ho appena creato 2 vettori e caricarli con 1 milione di oggetti:

void performance_test(void) 
{ 
    clock_t start; 
    clock_t end; 


    // EA 

    eastl::string strEA = "hello"; 
    eastl::vector<eastl::string> vec_EA; 

    start = clock(); 
    for (size_t i = 0; i < 1000000; i++) 
    { 
     vec_EA.push_back(strEA); 
    } 

    end = clock(); 
    printf("EA  %f\n", (double(end - start)/1000)); 

    // Standard 

    std::string strStandard = "hello"; 
    std::vector<std::string> vec_Standard; 

    start = clock(); 
    for (size_t i = 0; i < 1000000; i++) 
    { 
     vec_Standard.push_back(strStandard); 
    } 

    end = clock(); 
    printf("Standard %f\n", (double(end - start)/1000)); 
} 

ei risultati sono:

1. EA 0,759 mila
2. standard 0,064000

Quindi, c'è qualcosa cosa sto sbagliando o mi sono perso qualcosa? L'esempio è stato compilato con il set di strumenti della piattaforma v100.

Answer 1

Quando eseguo il tuo punto di riferimento con una build di rilascio in VS 2010, ho ottenere risultati simili a quanto si potrebbe sperare:

EA  0.063000 
Standard 0.073000 

Tuttavia, quando si esegue la stessa build di rilascio nel debugger VS, il i risultati cambiano drasticamente:

EA  1.293000 
Standard 0.080000 

E ci vuole anche più tempo (decine di secondi) per qualsiasi pulizia dell'oggetto. Ricordati: questa è la stessa build in modalità di rilascio, non una build di debug.

Non ho esaminato perché EASTL è influenzato in modo così grave dall'ambiente del debugger. Presumo che abbia qualcosa a che fare con l'heap di debug.

---

aggiornamento (4 marzo 2015):

Un altro dettaglio che influisce sui risultati è la lunghezza della stringa in questione. VS utilizza un 'ottimizzazione di stringa corta' in std::string che ridurrà il numero di allocazioni che si verificano per oggetti stringa che hanno un valore come "hello". Se si modifica il valore inizializzato per le stringhe utilizzati nell'esempio "hello"-"hello - but not too short", otterrete risultati più come la seguente:

// release build, run outside of the debugger 
EA  0.078000 
Standard 0.113000 

// release build, run under the debugger 
EA  0.762000 
Standard 1.414000 

e ora diventa evidente che l'ordine di grandezza differenza quando il punto di riferimento è è possibile eseguire il debugger a causa dell'heap di debug che trascorre molto tempo a tracciare le allocazioni della memoria di stringa.