Les chiffres que chaque programmeur doit connaître

Lien vers le cache L1 0,5 ns
Prédiction 5 ns incorrecte
Lien vers le cache L2 7 ns 14x vers le cache L1
Mutex Capture / Release 25 ns
Lien vers la mémoire principale 100 ns 20x vers le cache L2, 200x vers le cache L1
Compressez 1000 octets avec Zippy 3000 ns 3 μs
Envoi de 1000 octets sur un réseau à 1 Gbit / s 10000 ns 10 μs
Lecture aléatoire 4000 avec SSD 150 000 ns 150 μs ~ 1 Go / s SSD
Lecture séquentielle de 1 Mo à partir de 250 000 ns 250 μs
Paquet aller-retour à l'intérieur du centre de données 500 000 ns 500 μs
1 Mo de lecture séquentielle dans le SSD 1.000.000 ns 1.000 μs 1 ms ~ 1 Go / s SSD, 4x mémoire
Recherche de disque 10000000 ns 10000 μs 10 ms 20x vers le centre de données
Lecture séquentielle de 1 Mo à partir du disque 20 000 000 ns 20 000 μs 20 ms 80x vers la mémoire, 20x vers SSD
Envoi de colis CA-> Pays-Bas-> CA 150,000,000 ns 150,000 μs 150 ms

Retard en 2020

Frappé dans le cache L1, ~ 4 cycles (2.1 - 1.2 ns)
Frappé dans le cache L2, ~ 10 cycles (5,3 - 3,0 ns)
Frappez dans le cache L3, pour un seul cœur ~ 40 cycles (21,4 - 12,0 ns)
Frappez dans le cache L3, ensemble pour un autre noyau ~ 65 cycles (34,8 - 19,5 ns)
Frappez le cache L3, avec un changement pour un autre noyau ~ 75 cycles (40,2 - 22,5 ns)
RAM locale ~ 60 ns

• L1 est devenu plus lent; 0,5 → 1,5
  
• L2 plus rapide; 7 → 4,2
  
• Le rapport de L1 et L2 est très réduit; 2,5x 14(sensationnel!)
  
• Le cache L3 est désormais devenu la norme; 12 40
  
• La RAM est devenue plus rapide; 100 → 60

Bande passante mémoire: 39,74 gigaoctets par seconde
Cache L1: 192 kilo-octets (32 Ko par cœur)
Cache L2: 1,5 mégaoctets (256 Ko par cœur)
Cache L3: 12 mégaoctets (partagé; 2 Mo par cœur)

• Limite supérieure des performances de la RAM
  
• limite inférieure
  
• Limites du cache L1 / L2 / L3

Analyse comparative naïve

// Generate random elements
std::vector<int> nums;
for (size_t i = 0; i < 1024*1024*1024; ++i) // one billion ints
    nums.push_back(rng() % 1024); // small nums to prevent overflow

// Run test with 1 to 12 threads
for (int thread_count = 1; thread_count <= MAX_THREADS; ++thread_count) {
    auto slice_len = nums.size() / thread_count;
    
    // for-each thread
    for (size_t thread = 0; thread < thread_count; ++thread) {
        
        // partition data
        auto begin = nums.begin() + thread * slice_len;
        auto end = (thread == thread_count - 1)
            ? nums.end() : begin + slice_len;

        // spawn threads
        futures.push_back(std::async([begin, end] { 
            
            // sum ints sequentially
            int64_t sum = 0;
            for (auto ptr = begin; ptr < end; ++ptr)
                sum += *ptr;
            return sum;
        }));
    }

    // combine results
    int64_t sum = 0;
    for (auto& future : futures)
        sum += future.get();
}

std::vector<int> nums = /* ... */;
std::vector<uint32_t> indices = /* shuffled */;

// random access
int64_t sum = 0;
for (auto ptr = indices.begin(); ptr < indices.end(); ++ptr) {
    auto idx = *ptr;
    sum += nums[idx];
}
return sum;

Gros bloc

Petit bloc: lecture séquentielle

Petit bloc: lecture aléatoire

Résultats d'accès aléatoire

Les listes liées sont considérées comme nuisibles

     1 fil | matrix4x4 | unique_ptr | diff |
-------------------- | --------------- | ------------ | -------- |
Grand bloc - Seq | 14,8 Go / s | 0,8 Go / s | 19x |
16 Ko - Séq | 31,6 Go / s | 2,2 Go / s | 14x |
256 Ko - Séq | 22,2 Go / s | 1,9 Go / s | 12x |
Grand bloc - Rand | 2,2 Go / s | 0,1 Go / s | 22x |
16 Ko - Rand | 23,2 Go / s | 1,7 Go / s | 14x |
256 Ko - Rand | 15,2 Go / s | 0,8 Go / s | 19x |


     6 fils | matrix4x4 | unique_ptr | diff |
-------------------- | --------------- | ------------ | -------- |
Grand bloc - Seq | 34,4 Go / s | 2,5 Go / s | 14x |
16 Ko - Séq | 154,8 Go / s | 8,0 Go / s | 19x |
256 Ko - Séq | 111,6 Go / s | 5,7 Go / s | 20x |
Grand bloc - Rand | 7,1 Go / s | 0,4 Go / s | 18x |
16 Ko - Rand | 95,0 Go / s | 7,8 Go / s | 12x |
256 Ko - Rand | 58,3 Go / s | 1,6 Go / s | 36x |

Estimation budgétaire pour les cadres

        | 1 | 10 | 30 | 60 | 90 | 144 | 240 | 360 |
-------- | ------- | -------- | -------- | -------- | ------ - | -------- | -------- | -------- |
40 Go / s | 40 Go | 4 Go | 1,3 Go | 667 Mo | 444 Mo | 278 Mo | 167 Mo | 111 Mo |
10 Go / s | 10 Go | 1 Go | 333 Mo | 166 Mo | 111 Mo | 69 Mo | 42 Mo | 28 Mo |
 1 Go / s | 1 Go | 100 Mo | 33 Mo | 17 Mo | 11 Mo | 7 Mo | 4 Mo | 3 Mo |

Les chiffres que chaque programmeur devrait connaître (2020)

Latence L1: 1 ns
Délai L2: 2,5 ns
Retard L3: 10 ns
Latence RAM: 50 ns

(par fil)
Bande L1: 210 Go / s
Bande L2: 80 Go / s
Bande L3: 60 Go / s

(le système au complet)
Bande RAM: 45 Go / s

Déni de responsabilité

Conclusion

• Performances RAM
  
  • Maximum: 45 /
  • En moyenne, environ: 5 /
  • Le minimum: 1 /
• Performances du cache L1 / L2 / L3 (par cœur)
  
  • Maximum (c simd): 210 // 80 //60 /
  • En moyenne, environ: 25 // 15 //9 /
  • Minimum: 13 // 8 //3,5 /

La source

De plus amples recherches

• Enregistrement des performances
  
• Faux partage
  
• Performance std::atomic(ou son absence)
  
• Compteurs de performance
  
• Performances TLB
  
• Protocoles de cache

Spécifications du système

• Système d'exploitation: Windows 10 v1903 build 18362
• Processeur: Intel i7-8700k à 3,70 GHz
• RAM: 2x16 GSkill Ripjaw DDR4-3200 (16-18-18-38 @ 1600 MHz)
• Carte mère: Asus TUF Z370-Plus Gaming