Pyramide de stockage -- pourquoi autant de couches
Vous êtes-vous déjà demandé pourquoi les ordinateurs ont à la fois une « mémoire » et un « disque dur » ? Pourquoi ne pas mettre toutes les données à l'endroit le plus rapide ?
La réponse réside dans la conception des systèmes de stockage informatique--Pyramide de stockageCette leçon vous permet de bien comprendre la sagesse de compromis la plus fondamentale de l'architecte.
Analogie du quotidien : la cuisine face à l'entrepôt du supermarché
Utilisez la disposition des ingrédients pendant la cuisson pour d'abord créer une impression intuitive.
Imaginez que vous cuisinez.
Le sel et la sauce soja, vous les mettez près de la cuisinière, à portée de main--ce sont leregistreet lecache L1 de l'ordinateur。
Les ingrédients dans le réfrigérateur, vous devez faire quelques pas pour les prendre--cela équivaut à lamémoire (RAM)。
Le riz, la farine et l'huile stockés au sous-sol, vous devez faire un voyage spécial--il s'agit dudisque à état solide (SSD)。
Et le stock dans l'entrepôt du supermarché, vous ne le garderiez pas du tout à la maison--c'est ledisque dur (HDD)et le stockage cloud.
Cela révèle une règle simple :Les choses utilisées plus souvent sont placées plus près, mais l'espace plus proche est limité et plus cher ; les choses utilisées moins souvent sont placées plus loin, avec une capacité plus grande et aussi moins chères.
Les systèmes de stockage informatique sont conçus selon cette règle simple.
Pyramide de stockage : le compromis entre vitesse et capacité
À l'intérieur d'un ordinateur, les dispositifs de stockage forment une structure pyramidale selon la relation progressive « vitesse-capacité-coût ».
exemple Pyramide de stockage allocateGraph — spécification de design de diagramme SVG : fond couleur papier + lignes de division fines, accent rouge rouille uniquement, annotation de la couche supérieure registerDiagramme de la pyramide de stockage : plus on monte, plus c'est rapide et petit ; plus on descend, plus c'est lent et grand. Survolez un trapèze pour voir les détails de chaque couche.
Règles fondamentales
Ce diagramme en pyramide révèle une règle d'airain dans la conception matérielle :
- Plus rapide, plus cher, plus petitLes registres se trouvent dans le CPU, fabriqués avec les transistors les plus rapides, mais ne font que quelques kilo-octets. Car la surface de puce est extrêmement coûteuse.
- Plus lent, moins cher, plus grandLes disques durs utilisent des têtes magnétiques et des plateaux tournants, avec un coût extrêmement faible, et peuvent contenir des dizaines de téraoctets de données.
- Objectif de la structure pyramidaleUtiliser une combinaison de « petit et rapide + grand et lent » permet d'obtenir une expérience proche du stockage le plus rapide à un coût raisonnable.
Si un ordinateur utilisait des registres pour tout le stockage, non seulement le prix serait astronomique, mais la surface de puce serait aussi trop grande pour être fabriquée.
Inversement, s'il n'utilisait que des disques durs, l'ordinateur serait trop lent à utiliser--vous devriez attendre des centaines de millisecondes pour ouvrir n'importe quel programme.
Comparaison détaillée de chaque couche
Placez les attributs clés des sept couches de stockage dans un seul tableau pour faciliter la comparaison horizontale.
| Niveau | Capacité typique | Latence d'accès | Vitesse relative | Emplacement physique | Coût de fabrication |
|---|---|---|---|---|---|
| registre | ~1 KB | ~0.3 ns | 1x (référence) | À l'intérieur du cœur du CPU | extrêmement élevé |
| Cache L1 | ~64 KB | ~1 ns | 3x plus lent que les registres | À l'intérieur du cœur du CPU | extrêmement élevé |
| Cache L2 | ~256 KB | ~4 ns | 13x plus lent | À l'intérieur du cœur du CPU | Très élevé |
| Cache L3 | ~8 MB | ~12 ns | 40x plus lent | Sur la puce CPU, partagée par plusieurs cœurs | Élevée |
| Mémoire (RAM) | ~16 GB | ~100 ns | 333x plus lent | Sur la carte mère (puce séparée) | Moyenne |
| Disque à semi-conducteurs (SSD) | ~1 TB | ~100 μs | 333,333x plus lent | À l'intérieur du boîtier de l'ordinateur (appareil séparé) | Relativement faible |
| Disque dur (HDD) | ~10 TB | ~10 ms | 33,333,333x plus lent | À l'intérieur du boîtier de l'ordinateur (appareil séparé) | Faible |
Remarquez les sauts d'ordre de grandeur : la mémoire est 100 fois plus lente que le cache L1, le SSD est 1000 fois plus lent que la mémoire, et le HDD est 100 fois plus lent que le SSD. L'écart de vitesse entre chaque couche se mesure en ordres de grandeur.
Pourquoi le SSD est-il tellement plus rapide que le HDD ?
La différence clé réside dans la présence ou non de pièces mécaniques.
Le SSD utilise des puces de mémoire flash, avec une lecture purement électronique, sans pièces mécaniques.
Le HDD utilise des plateaux en rotation et une tête mobile -- pour lire une donnée, la tête doit d'abord se déplacer vers la bonne piste (temps de recherche, environ 5-10 ms), puis attendre que le plateau tourne jusqu'à la bonne position (latence de rotation, environ 2-4 ms).
Ce processus de mouvement mécanique est exactement la cause profonde du fait que le HDD est des centaines de fois plus lent qu'un SSD.
Démo interactive : simulation des temps d'accès d'un stockage multicouche
Utilisez un extrait Python pour simuler les différences de latence lors de la lecture de la même adresse depuis chacune des sept couches de stockage.
Exemple
Simulateur de latence d'accès à la pyramide mémoire (exemple de démo)
Simulez la lecture de blocs de données de même taille depuis différents niveaux afin de comparer intuitivement les différences de vitesse de chaque niveau
"""
class StorageHierarchy:
"""Simuler la hiérarchie mémoire d'un ordinateur"""
def __init__(self):
# Latence simulée (en nanosecondes) et capacité typique de chaque couche de stockage
self.layers = {
'Registre': {'latency_ns': 0.3, 'capacity': '~1 KB', 'color': 'red'},
'Cache L1': {'latency_ns': 1, 'capacity': '~64 KB', 'color': 'orange'},
'Cache L2': {'latency_ns': 4, 'capacity': '~256 KB', 'color': 'gold'},
'Cache L3': {'latency_ns': 12, 'capacity': '~8 MB', 'color': 'yellow'},
'RAM': {'latency_ns': 100, 'capacity': '~16 GB', 'color': 'green'},
'SSD': {'latency_ns': 100000, 'capacity': '~1 TB', 'color': 'blue'},
'HDD': {'latency_ns': 10000000, 'capacity': '~10 TB', 'color': 'purple'},
}
def read(self, layer_name, address):
"""
Simuler la lecture de données à partir de la couche spécifiée
Retourner les valeurs de données simulées
"""
value = f"DATA_FROM_{layer_name.upper()}_{address}"
return value
def compare_access(self, address, num_accesses=3):
"""Comparer la vitesse de lecture de la même adresse depuis chaque niveau."""
print("=" * 65)
print(f"Comparaison de la latence d'accès à la hiérarchie mémoire (adresse : {address})")
print("=" * 65)
print(f{'Niveau':<12} {'Latence (ns)':>12} {'Capacité':<12} {'Relatif au registre':>12})
print("-" * 65)
baseline = self.layers['Register']['latency_ns']
for name, info in self.layers.items():
lat_ns = info['latency_ns']
ratio = lat_ns / baseline
cap = info['capacity']
print(f"{name:<12} {lat_ns:>10,.1f} ns {cap:<12} {ratio:>10,.0f}x")
# Exécuter la démo
print(EXEMPLE Tutoriel sur le système de stockage : Comparaison de la latence d'accès à la pyramide de stockage)
print()
store = StorageHierarchy()
store.compare_access("0x7FFF1234")
print()
print("=" * 65)
print("Analyse des conclusions :")
print("=" * 65)
# Calculer les ratios clés
register_lat = 0.3 # ns
ram_lat = 100 # ns
ssd_lat = 100000 # ns
hdd_lat = 10000000 # ns
print(f1. La mémoire (RAM) est {ram_lat / register_lat:,.0f} fois plus lente que les registres)
print(f2. Le SSD est {ssd_lat / ram_lat:,.0f} fois plus lent que la mémoire (RAM))
print(f3. Le HDD est {hdd_lat / ram_lat:,.0f} fois plus lent que la mémoire (RAM))
print(f4. Le HDD est {hdd_lat / register_lat:,.0f} fois plus lent que les registres)
print()
print("Si l'accès au registre prend 1 seconde, alors :")
print(f- La récupération depuis le cache L1 prend {1/register_lat:.0f} secondes)
print(f" - obtenir depuis la mémoire nécessite {ram_lat/register_lat:,.0f} secondes (environ {ram_lat/register_lat/60:.0f} minutes)")
print(f" - obtenir depuis le HDD nécessite {hdd_lat/register_lat:,.0f} secondes (environ {hdd_lat/register_lat/3600:,.0f} heures)")
Résultat de l'exécution :
EXAMPLE 存储系统教学: 存储金字塔访问延迟对比 ================================================================= 存储层次访问延迟对比（地址: 0x7FFF1234） ================================================================= 层级 延迟(纳秒) 容量 相对寄存器 ----------------------------------------------------------------- Register 0.3 ns ~1 KB 1x L1 Cache 1.0 ns ~64 KB 3x L2 Cache 4.0 ns ~256 KB 13x L3 Cache 12.0 ns ~8 MB 40x RAM 100.0 ns ~16 GB 333x SSD 100,000.0 ns ~1 TB 333,333x HDD 10,000,000.0 ns ~10 TB 33,333,333x ================================================================= 结论分析： ================================================================= 1. 内存(RAM) 比 寄存器 慢 333 倍 2. SSD 比 内存(RAM) 慢 1,000 倍 3. HDD 比 内存(RAM) 慢 100,000 倍 4. HDD 比 寄存器 慢 33,333,333 倍 如果寄存器访问数据需要 1 秒，那么： - 从 L1 缓存获取需要 3 秒 - 从内存获取需要 333 秒（约 6 分钟） - 从 HDD 获取需要 33,333,333 秒（约 9,259 小时）
Démo interactive : graphique comparatif logarithmique de la latence d'accès entre les couches
Le graphique ci-dessous dessine un diagramme à barres sur une échelle logarithmique ; les intervalles adjacents sur l'axe horizontal diffèrent d'un facteur 10. Survolez une barre pour voir les détails de capacité et de latence.
exemple de comparaison de latence de hiérarchie de stockage — diagramme à barres horizontal en coordonnées logarithmiques Plotly (sélection standard : utiliser Plotly pour le système de coordonnées logarithmiques)Comment fonctionne la pyramide : stratégie de mise en cache couche par couche
La pyramide n'est pas statique -- elle possède un mécanisme automatique de déplacement des données.
Règles de flux de données
- Lorsque le CPU a besoin de donnéesCherchez d'abord dans le cache L1 le plus rapide ; si ce n'est pas trouvé, passez au L2 ; si ce n'est toujours pas trouvé, passez au L3, et ainsi de suite jusqu'à la mémoire principale.
- Après avoir lu des données depuis la couche lenteIl ne se contente pas de donner les données au CPU, mais en stocke aussi une copie dans une couche plus rapide. Ainsi, la prochaine utilisation est rapide.
- Que faire lorsque la couche rapide est pleine ?Selon une certaine politique (comme LRU -- évincer les données les moins récemment utilisées), renvoyer les données peu utilisées vers des couches plus lentes pour faire de la place aux nouvelles données.
Ce processus est complètement transparent pour les programmeurs -- vous n'avez pas besoin de gérer manuellement quelle couche de cache lorsque vous écrivez des programmes ; le matériel et le système d'exploitation font tout cela automatiquement.
Exemples concrets
Supposons que vous éditiez un fichier vidéo :
- Les fichiers vidéo se trouvent surHDD ou SSDau-dessus (couche inférieure).
- Lorsque vous ouvrez un fichier, le système d'exploitation en charge une partie dansla mémoire (RAM).
- Lorsque vous commencez la lecture, le CPU copie les données des images en cours de traitement versle cache L3/L2/L1.
- Les valeurs de pixels actuellement calculées par l'ALU sont stockées dansle registre.
Lorsque vous avez l'impression que c'est « très fluide » dans un logiciel de montage, c'est parce que le CPU trouve les données dont il a besoin dans le cache la plupart du temps.
Contexte historique : pourquoi la pyramide a cette forme
Le nombre de couches de la pyramide est le produit historique de l'écart de vitesse sans cesse croissant entre le CPU et la mémoire.
Dans les années 1980, l'écart de vitesse entre le CPU et la mémoire n'était pas important. Mais à mesure que la fabrication des semi-conducteurs progressait, la vitesse du CPU augmentait d'environ 60% par an, tandis que la vitesse de la mémoire n'augmentait que d'environ 10% par an.
Cet écart qui ne cesse de se creuser est appelé« mur de la mémoire » (Memory Wall)。
La pyramide de stockage est la réponse des ingénieurs au « mur de la mémoire » -- en utilisant plusieurs niveaux de cache pour amortir l'écart de vitesse entre le CPU et la mémoire principale.
| ère | Fréquence du CPU | Latence mémoire | Écart de vitesse | Hiérarchie de cache |
|---|---|---|---|---|
| 1980s | ~10 MHz | ~200 ns | environ 2x | Aucun ou niveau 1 |
| 1990s | ~200 MHz | ~70 ns | Environ 14 fois | L1 + L2 |
| 2000s | ~3 GHz | ~50 ns | Environ 150 fois | L1 + L2 + L3 |
| 2020s | ~5 GHz | ~80 ns | Environ 400 fois | L1 + L2 + L3 |
autres extensionsNotez que la latence de la mémoire n'a quasiment pas changé sur le fond en 40 ans ! Ce n'est pas que la mémoire ne s'est pas améliorée, mais que le processeur s'est amélioré trop vite. La limite physique de la mémoire (vitesse de charge/décharge du condensateur) rend très difficile de réduire significativement sa latence.