Allocazione memoria ottimizzata via dai compilatori

Question

Nel suo discorso "Efficiency with algorithms, Performance with data structures", Chandler Carruth parla della necessità di un modello di allocatore migliore in C++. L'attuale modello di allocatore invade il sistema di tipi e rende quasi impossibile lavorare in molti progetti a causa di ciò. D'altra parte, lo Bloomberg allocator model non invade il sistema di tipi ma si basa su chiamate di funzioni virtuali che rendono impossibile al compilatore 'vedere' l'allocazione e ottimizzarla. Nel suo discorso parla dei compilatori deduplicando l'allocazione di memoria (1:06:47).

Mi ci è voluto un po 'di tempo per trovare alcuni esempi di ottimizzazione dell'allocazione della memoria, ma ho trovato questo esempio di codice, compilato in clang, che ottimizza l'allocazione di memoria e restituisce solo 1000000 senza allocare nulla.

template<typename T> 
T* create() { return new T(); } 

int main() { 
    auto result = 0; 
    for (auto i = 0; i < 1000000; ++i) { 
     result += (create<int>() != nullptr); 
    } 

    return result; 
} 

Il seguente documento http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3664.html dice anche che l'assegnazione potrebbe essere fusa in compilatori e sembra suggerire che alcuni compilatori già fanno questo genere di cose.

Dato che sono molto interessato alle strategie per l'allocazione di memoria efficiente, voglio davvero capire perché Chandler Carruth è contro le chiamate virtuali nel modello di Bloomberg. L'esempio sopra mostra chiaramente che clang ottimizza le cose quando può vedere l'allocazione.

1. mi piacerebbe avere un "codice di vita reale", dove questa ottimizzazione è utile e fatto da qualsiasi compilatore corrente
2. Avete qualche esempio di codice in cui allocazione diversa sono fusi da Anu compilatore attuale?
3. Capisci cosa significa Chandler Carruth quando dice che i compilatori possono "deduplicare" la tua allocazione nel suo discorso alle 1:06:47?

Answer 1

Ho trovato questo sorprendente esempio che risponde al primo punto della domanda iniziale. Entrambi i punti 2 e 3 non hanno ancora alcuna risposta.

#include <iostream> 
#include <vector> 
#include <chrono> 

std::vector<double> f_val(std::size_t i, std::size_t n) { 
    auto v = std::vector<double>(n); 
    for (std::size_t k = 0; k < v.size(); ++k) { 
     v[k] = static_cast<double>(k + i); 
    } 
    return v; 
} 

void f_ref(std::size_t i, std::vector<double>& v) { 
    for (std::size_t k = 0; k < v.size(); ++k) { 
     v[k] = static_cast<double>(k + i); 
    } 
} 

int main (int argc, char const *argv[]) { 
    const auto n = std::size_t{10}; 
    const auto nb_loops = std::size_t{300000000}; 

    // Begin: Zone 1 
    { 
     auto v = std::vector<double>(n, 0.0); 
     auto start_time = std::chrono::high_resolution_clock::now(); 
     for (std::size_t i = 0; i < nb_loops; ++i) { 
      auto w = f_val(i, n); 
      for (std::size_t k = 0; k < v.size(); ++k) { 
       v[k] += w[k]; 
      } 
     } 
     auto end_time = std::chrono::high_resolution_clock::now(); 
     auto time = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count(); 
     std::cout << time << std::endl; 
     std::cout << v[0] << " " << v[n - 1] << std::endl; 
    } 
    // End: Zone 1 

    { 
     auto v = std::vector<double>(n, 0.0); 
     auto w = std::vector<double>(n); 
     auto start_time = std::chrono::high_resolution_clock::now(); 
     for (std::size_t i = 0; i < nb_loops; ++i) { 
      f_ref(i, w); 
      for (std::size_t k = 0; k < v.size(); ++k) { 
       v[k] += w[k]; 
      } 
     } 
     auto end_time = std::chrono::high_resolution_clock::now(); 
     auto time = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count(); 
     std::cout << time << std::endl; 
     std::cout << v[0] << " " << v[n - 1] << std::endl; 
    } 

    return 0; 
} 

dove non si verifica una singola allocazione di memoria nel ciclo for con f_val. Questo succede solo con Clang (Gcc e icpc falliscono entrambi) e quando si costruisce un esempio leggermente più complicato, l'ottimizzazione non viene eseguita.