Worum geht es bei Multi-Core?

Als Leistungsverbesserungen bei Single-Core-CPUs an Grenzen stießen (Power-Wall, Frequenz-Wall, Pipeline-Komplexitäts-Wall), kamen Ingenieure auf eine "einfache und grobe", aber effektive Lösung: mehrere CPU-Kerne auf einem Chip unterzubringen. In dieser Lektion werden die Prinzipien und Vorteile von Multi-Core sowie die Grenzen des Amdahlschen Gesetzes bei der parallelen Beschleunigung vorgestellt.


Alltagsanalogie: eine Fast-Food-Küche

Stellen Sie sich ein Fast-Food-Restaurant während des Mittagsansturms vor.

Single-Core-Modus: Nur ein Koch. Er versucht verzweifelt, schneller zu werden (Frequenz erhöhen) und den Kochprozess zu optimieren (Pipeline), aber egal, wie sehr er optimiert, es kann immer nur ein Gericht gleichzeitig gekocht werden. Die Kunden warten in einer langen Schlange und werden ungeduldig.

Multi-Core-Modus: Der Chef stellt vier Köche ein, jeder mit eigenem Herd. Die vier Köche können vier verschiedene Gerichte gleichzeitig kochen. Kein Koch muss schneller werden, aber der Gesamtdurchsatz steigt um ein Mehrfaches.

Das ist die Designphilosophie von Multi-Core:Wenn es schwierig ist, einen einzelnen Kern weiter zu beschleunigen, ist es besser, mehr Kerne hinzuzufügen und sie parallel arbeiten zu lassen.

Multi-Core bedeutet nicht "alles 4-fach zu kopieren". Die 4 Kerne teilen sich normalerweise denselben Speicher, dieselbe Disk-Schnittstelle und dasselbe Betriebssystem; sie duplizieren nur auf der Ebene der "Recheneinheit". Genau wie 4 Köche, die sich denselben Kühlschrank und dasselbe Zutatenlager teilen.


Single-Core vs. Multi-Core: Architekturvergleich

Das Dilemma von Single-Core-CPUs

In den frühen 2000er-Jahren verbesserte die CPU-Industrie die Leistung, indem sie die Frequenz ständig erhöhte – von 1 GHz auf 2 GHz auf 3 GHz. Doch dieser Weg erreichte schnell sein Ende.

Drei große Engpässe der Single-Core-Frequenz:

  • Leistungswand: Je höher die Frequenz, desto exponentiell wächst der Stromverbrauch, und die Wärmeableitung wird zu einer physikalischen Grenze.
  • Speicherwand: Die CPU ist zu schnell, der Speicher kann nicht mithalten, und die meiste Zeit wartet sie untätig auf Daten.
  • ILP-Wand: Die Instruction-Level-Parallelität (ILP) wurde bis an ihre Grenzen ausgereizt; immer weniger Instruktionen in einem einzelnen Instruktionsstrom können parallelisiert werden.

Um 2005 gaben Intel und AMD nacheinander das reine "Frequenzrennen" auf und wandten sich dem Multi-Core-Weg zu.

Aufbau einer Multi-Core-CPU

Eine typische interne Struktur einer Multi-Core-CPU sieht wie folgt aus:

  +-----------------------------------------------------------+
  |                         CPU 芯片                          |
  |  +-------------+  +-------------+  +-------------+  +-----+
  |  |   核心 1    |  |   核心 2    |  |   核心 3    |  |核 4 |
  |  | L1 Cache   |  | L1 Cache   |  | L1 Cache   |  | ... |
  |  | L2 Cache   |  | L2 Cache   |  | L2 Cache   |  |     |
  |  +------+------+  +------+------+  +------+------+  +--+--+
  |         |                |                |              |
  |         +----------------+----------------+--------------+
  |                          |
  |                    +-----+------+
  |                    | 共享 L3 Cache |
  |                    +-----+------+
  |                          |
  |                    +-----+------+
  |                    | 内存控制器   | ← 连接主内存 (RAM)
  |                    +------------+
  +-----------------------------------------------------------+

Wichtige Designmerkmale:

  • Jeder Kern hat seine eigenen L1- und L2-Caches (privat).
  • Mehrere Kerne teilen sich einen L3-Cache
  • Alle Kerne greifen über den Speichercontroller auf denselben Hauptspeicher zu.
  • Das Betriebssystem ist dafür verantwortlich, Aufgaben verschiedenen Kernen zuzuweisen.

Amdahls Gesetz: die Obergrenze der Multi-Core-Beschleunigung.

Die Intuition, dass "mehr Kerne schneller bedeutet", ist nicht immer richtig. Im Jahr 1967 stellte der Informatiker Gene Amdahl ein berühmtes Gesetz auf.

Amdahls Gesetz: Die Gesamtbeschleunigung einer Aufgabe ist durch den Anteil begrenzt, der seriell ausgeführt werden muss.

Die Formel lautet wie folgt:

加速比 = 1 / (S + P/N)

其中:
  S = 任务中必须串行执行的比例(0~1)
  P = 任务中可以并行执行的比例(0~1),且 S + P = 1
  N = 并行处理单元的数量(核心数)

Diese Formel offenbart eine grausame Tatsache:

Selbst mit unendlich vielen Kernen kann der Speedup höchstens 2x betragen, wenn nur 50 % der Aufgabe parallelisiert werden können.

Herleitung: Wenn N gegen unendlich geht, geht P/N gegen 0, und der Speedup nähert sich 1/S.

Parallelisierbarer Anteil1 Kern2 Kerne4 Kerne8 Kerne16 KerneUnendlich viele Kerne (die Obergrenze)
50%1.00x1.33x1.60x1.78x1.88x2.00x
75%1.00x1.60x2.29x2.91x3.37x4.00x
90%1.00x1.82x3.08x4.71x6.40x10.00x
95%1.00x1.90x3.48x5.93x9.14x20.00x
99%1.00x1.98x3.88x7.48x13.91x100.00x

Beobachte das Muster in dieser Tabelle:

  • Je höher der Parallelisierungsanteil, desto deutlicher fällt der Multi-Core-Speedup aus.Eine zu 99 % parallelisierbare Aufgabe kann auf 16 Kernen nahezu 14-mal beschleunigt werden.
  • Mehr Kerne bedeuten geringere Grenzerträge.Die Speedup-Verbesserung von 2 auf 4 Kerne ist weitaus größer als von 16 auf 32 Kerne.
  • Der serielle Anteil ist die harte GrenzeWenn nur 50 % parallelisierbar sind, kann es selbst mit zehntausend Kernen höchstens 2-mal schneller sein.

Amdahls Gesetz erklärt, warum "mehr Kerne nicht unbedingt schneller bedeutet." Wenn Ihr Programm hauptsächlich aus serieller Logik besteht – zum Beispiel muss ein Berechnungsschritt auf das Ergebnis des vorherigen Schritts warten –, dann können sie, egal wie viele Kerne vorhanden sind, nur zusehen und nicht helfen.


Interaktive Demo: Rechner für Amdahls Gesetz

Der folgende Python-Code berechnet und gibt eine Vergleichstabelle der Speedups nach Amdahls Gesetz aus und stellt außerdem dar, wie sich der Speedup mit der Anzahl der Kerne ändert, sodass Sie die Auswirkungen des "seriellen Flaschenhalses" intuitiv nachvollziehen können.

Beispiel

"""
Rechner für Amdahls Gesetz (Beispiel-Demo)
Speedup bei unterschiedlichen Parallelisierungsanteilen und Kernzahlen berechnen
Vergleichstabelle und Trendanalyse ausgeben
"""


def amdahl_speedup(parallel_fraction, num_cores):
    """
Kernformel von Amdahls Gesetz
parallel_fraction: Anteil, der parallel ausgeführt werden kann (0.0 ~ 1.0)
num_cores: Anzahl der Kerne
Speedup zurückgeben
    """

    if num_cores == 1:
        return 1.0
    serial_fraction = 1.0 - parallel_fraction
    speedup = 1.0 / (serial_fraction + parallel_fraction / num_cores)
    return speedup


def amdahl_limit(parallel_fraction):
    """
Berechne die theoretische obere Speedup-Grenze nach Amdahls Gesetz (wenn die Anzahl der Kerne gegen unendlich geht)
Wenn N→∞, P/N→0, Speedup → 1/S
    """

    serial_fraction = 1.0 - parallel_fraction
    if serial_fraction == 0:
        return float('inf')  # Vollständig parallelisierbar, theoretisch unendlich beschleunigbar
    return 1.0 / serial_fraction


def print_comparison_table(parallel_fractions, core_counts):
    """Gibt die vollständige Speedup-Vergleichstabelle aus."""
    # Tabellenkopf
    header = f"{'Kerne':>6} |"
    for pf in parallel_fractions:
        header += f" {pf*100:>5.0f}% parallelisierbar |"
    print("=" * (12 + 12 * len(parallel_fractions)))
    print(Amdahls Gesetz - Multicore-Speedup-Vergleichstabelle)
    print("=" * (12 + 12 * len(parallel_fractions)))
    print(header)
    print("-" * (12 + 12 * len(parallel_fractions)))

    for cores in core_counts:
        row = f" {cores:>5} |"
        for pf in parallel_fractions:
            speedup = amdahl_speedup(pf, cores)
            row += f" {speedup:>6.2f}x |"
        print(row)

    # Theoretische Obergrenze
    print("-" * (12 + 12 * len(parallel_fractions)))
    limit_row = f" {'Obergrenze':>5} |"
    for pf in parallel_fractions:
        limit = amdahl_limit(pf)
        if limit == float('inf'):
            limit_row += f" keine Obergrenze |"
        else:
            limit_row += f" {limit:>6.2f}x |"
    print(limit_row)
    print("=" * (12 + 12 * len(parallel_fractions)))


def analyze_diminishing_returns(parallel_fraction, max_cores=64):
    """Analysiere die abnehmenden Grenzerträge der Mehrkernbeschleunigung"""
    print(f"\nGrenznutzenanalyse (parallelisierbarer Anteil {parallel_fraction*100:.0f}%):)
    print(f{'Kerne':>6} | {'Beschleunigung':>8} | {'Verbesserung':>10} | {'Effizienz':>8})
    print("-" * 42)

    prev_speedup = 1.0
    cores = 1
    while cores <= max_cores:
        speedup = amdahl_speedup(parallel_fraction, cores)
        improvement = speedup - prev_speedup
        # Effizienz = tatsächlicher Speedup / Anzahl der Kerne (100% bei perfektem linearem Speedup)
        efficiency = (speedup / cores) * 100
        print(f" {cores:>6} | {speedup:>8.2f}x | +{improvement:>8.3f}x | {efficiency:>7.1f}%")
        prev_speedup = speedup
        if cores == 1:
            cores = 2
        else:
            cores *= 2


def compare_serial_vs_parallel(serial_work_ms, parallel_work_ms, num_cores):
    """
Verwende die Zeit, die eine bestimmte Aufgabe benötigt, um Amdahls Gesetz zu demonstrieren
serial_work_ms: Zeit, die für den seriellen Teil aufgewendet wird (Millisekunden)
parallel_work_ms: Zeit für den parallelisierbaren Teil (Einzelkern, Millisekunden)
num_cores: Anzahl der verfügbaren Kerne
    """

    total_single_ms = serial_work_ms + parallel_work_ms
    parallel_fraction = parallel_work_ms / total_single_ms

    parallel_time_multi = parallel_work_ms / num_cores
    total_multi_ms = serial_work_ms + parallel_time_multi

    speedup = total_single_ms / total_multi_ms

    print(f"\nSimulation der Dauer einer bestimmten Aufgabe:)
    print(fVerstrichene Zeit für seriellen Teil: {serial_work_ms} ms (kann nicht beschleunigt werden))
    print(fIm parallelisierbaren Teil verbrachte Zeit: {parallel_work_ms} ms (Einzelkern))
    print(fParalleler Anteil: {parallel_fraction*100:.0f}%)
    print(f"")
    print(fGesamtzeit auf einem Kern: {total_single_ms} ms)
    print(f" {num_cores} Kerne Gesamtzeit: {total_multi_ms:.1f} ms(seriell {serial_work_ms} + parallel {parallel_work_ms}/{num_cores} = {parallel_time_multi:.1f})")
    print(f" Tatsächliche Beschleunigung: {speedup:.2f}x")
    print(fAmdahl-Grenze: {amdahl_limit(parallel_fraction):.2f}x)
    return speedup


# ===== Hauptprogramm =====
print("=" * 60)
print(Rechner für das Amdahlsche Gesetz (Beispiel))
print("=" * 60)

# 1. Grundlegende Vergleichstabelle
parallel_levels = [0.50, 0.75, 0.90, 0.95, 0.99]
core_list = [1, 2, 4, 8, 16, 32, 64, 128, 256]
print_comparison_table(parallel_levels, core_list)

# 2. Analyse des marginalen Nutzens (mit 75% Parallelisierbarkeit als Beispiel)
analyze_diminishing_returns(0.75, max_cores=64)

# 3. Simulation einer spezifischen Aufgabe
print("\n" + "=" * 60)
print(" Simulation eines realen Szenarios")
print("=" * 60)

# Szenario 1: Video-Rendering (hochgradig parallel, 95%)
print("\n[Szenario 1] Video-Rendering-Aufgabe")
print(Serieller Teil: Datei lesen, Encoder initialisieren = 10ms)
print(Paralleler Teil: Rendering pro Frame = 200ms (Einzelkern))
compare_serial_vs_parallel(10, 200, 16)

# Szenario 2: Datenbanktransaktion (mäßig parallelisierbar, 50%)
print("\n[Szenario 2] Verarbeitung von Datenbanktransaktionen")
print(" Serieller Teil: Log-Schreiben, Sperrverwaltung = 50ms")
print(Paralleler Teil: Abfrageausführung = 50ms (Einzelkern))
compare_serial_vs_parallel(50, 50, 16)

# Szenario 3: Reine Berechnung (hochgradig parallel, 99%)
print("\n[Szenario 3] Wissenschaftliches Rechnen / Matrixoperationen)
print(Serieller Teil: Ergebnisaggregation = 1ms)
print(Paralleler Teil: Matrixmultiplikation = 1000ms (Einzelkern))
compare_serial_vs_parallel(1, 1000, 16)

# 4. Empfohlene Anzahl von Kernen
print("\n" + "=" * 60)
print(Praktischer Rat: Wie lässt sich feststellen, ob Sie mehr Kerne benötigen?)
print("=" * 60)

# Den 'Kosten-Leistungs'-Wendepunkt bei verschiedenen Parallelisierungsverhältnissen berechnen
print(f" {'Parallelisierungsverhältnis':>10} | {'2-Kern-Verbesserung':>10} | {'4-Kern-Verbesserung':>10} | {'8-Kern-Verbesserung':>10} | {'16-Kern-Verbesserung':>9} | {'Empfohlene Kernanzahl':>10}")
print("-" * 70)

for pf in [0.50, 0.60, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 0.99]:
    ratios = []
    prev = 1.0
    recommendations = []
    for cores in [2, 4, 8, 16]:
        sp = amdahl_speedup(pf, cores)
        gain = (sp / prev - 1) * 100  # Prozentuale Verbesserung gegenüber der vorherigen Stufe
        ratios.append(gain)
        prev = sp
        if gain < 10:
            recommendations.append(cores)

    # Vorschlag: Eine Verbesserung unter 10 % ist ein Upgrade nicht wert
    suggested = ">=16 Kerne" if not recommendations else f{recommendations[0]} Kerne sind ausreichend

    print(f" {pf*100:>9.0f}% | {ratios[0]:>9.1f}% | {ratios[1]:>9.1f}% | {ratios[2]:>9.1f}% | {ratios[3]:>8.1f}% | {suggested:>10}")

print()
print(" Faustregel:")
print(- Tägliche Büroarbeit, Webbrowsing (niedriger Parallelanteil): 4-6 Kerne sind ausreichend)
print(- Programmierung/Kompilierung, leichtes Gaming: 6-8 Kerne)
print(- Videorendering, 3D-Modellierung: 8-16 Kerne)
print(- Wissenschaftliches Rechnen, KI-Training: je mehr Kerne, desto besser (aber auch VRAM und Speicherbandbreite berücksichtigen))

Beim Ausführen des obigen Codes sehen Sie mehrere Schlüsselphänomene:

  • Der Parallelanteil bestimmt alles: Eine Aufgabe, die zu 50 % parallelisierbar ist, erreicht selbst mit 256 Kernen eine Beschleunigung von weniger als dem Zweifachen. Aber eine zu 99 % parallelisierbare Aufgabe kann auf 16 Kernen eine Beschleunigung von fast dem 14-Fachen erreichen.
  • Abnehmende Grenzerträge: Die größte Verbesserung ergibt sich von 1 Kern auf 2 Kerne; danach wird der zusätzliche Geschwindigkeitsgewinn jedes Mal kleiner, wenn sich die Kernanzahl verdoppelt.
  • Effizienzabfall: Wenn sich die Kernanzahl verdoppelt, sinkt die Effizienz (tatsächliche Beschleunigung / Anzahl der Kerne) weiter. Deshalb ist es nicht kosteneffizient, blind immer mehr Kerne hinzuzufügen.

Interaktive Demo: Animation zur Aufgabenverteilung auf mehrere Kerne

Die folgende Demonstration weist 12 Rechenaufgaben1 Kernund4 Kernenzur Verarbeitung zu. Im 1-Kern-Modus werden Aufgaben in eine Warteschlange gestellt und seriell ausgeführt; im 4-Kern-Modus werden vier Aufgaben gleichzeitig parallel verarbeitet. Beobachten Sie den Unterschied in der Füllgeschwindigkeit der Fortschrittsbalken und der Abschlusszeit zwischen den beiden Modi.

Demo der Multi-Core-Aufgabenverteilungsanimation (Beispiel)

Aufgabenwarteschlange
Warteschlange ausstehender Aufgaben (insgesamt12eins)
Vergleichspanel
Single-Core-Panel

1 Kern (serielle Verarbeitung)

Fortschritt von Kern 1
Multi-Core-Panel

4 Kerne (parallele Verarbeitung)

Fortschritt von Kern 1
Fortschritt Kern 2
Fortschritt Kern 3
Fortschritt Kern 4
Timer
1-Kern-Zeit
0.0 s
4-Kern-Zeit
0.0 s
Beschleunigung
—
Ergebnistext
Schaltfläche

Multi-Core in realen Anwendungen

Wie das Betriebssystem Multi-Core plant

Der Scheduler im Betriebssystem ist dafür verantwortlich, verschiedene Prozesse und Threads verschiedenen Kernen zuzuweisen.

Dabei wird Folgendes berücksichtigt:

  • Lastverteilung: Jeden Kern beschäftigt halten und dabei vermeiden, dass "ein Kern in Schwierigkeiten ist und viele Kerne zuschauen."
  • Cache-Affinität: Versuchen Sie, denselben Thread auf demselben Kern laufen zu lassen und dabei den privaten Cache dieses Kerns zu nutzen
  • Energieverwaltung: Bei geringer Last einige Kerne abschalten, um Energie zu sparen.

Multi-Core vs. Hyper-Threading

Neben physischem Multi-Core gibt es auch eine Technologie namensHyper-Threading (SMT)。

Hyper-Threading lässt einen physischen Kern wie zwei "logische Kerne" erscheinen. Wenn ein Thread auf Daten wartet (Cache-Miss), kann der Kern zu einem anderen Thread wechseln, um weiterzuarbeiten.

LösungHardwarekostenLeistungssteigerungAnwendbare Szenarien
Physisches Multi-CoreHoch (erfordert Duplizierung der gesamten Ausführungseinheit)Nahezu doppelt (Idealfall)Dauerhafte Hochlast-Aufgaben
Hyper-Threading (SMT)Gering (erfordert nur zusätzliche Register + Steuerlogik).Etwa 10%~30%Die Wartezeit vollständig ausnutzen

Viele moderne CPUs nutzen beide Technologien gleichzeitig. Beispielsweise könnte ein Intel Core i7 "4 physische Kerne + Hyper-Threading = 8 logische Kerne" sein.


Zusammenfassung und Überprüfung

Zusammenfassung in einem Satz: Viele Kerne führen dieselbe Aufgabe parallel aus, indem mehrere CPU-Kerne auf einem einzigen Chip platziert werden. Aber das Amdahlsche Gesetz besagt, dass die tatsächliche Beschleunigung vom Anteil der Parallelisierbarkeit in der Aufgabe abhängt – der serielle Teil bestimmt bereits die Obergrenze der Beschleunigung; mehr Kerne bedeuten geringere Grenzerträge.

Selbsttestfragen

  1. Bei einer Aufgabe können 80% parallel ausgeführt werden. Welche Beschleunigung ergibt sich nach dem Amdahlschen Gesetz auf einer 4-Kern-CPU?

    Antwort: S=0.2, P=0.8, N=4. Speedup = 1/(0.2 + 0.8/4) = 1/(0.2 + 0.2) = 1/0.4 = 2.5x. Das heißt, 4 Kerne bringen nur eine 2.5-fache Beschleunigung, die Effizienz beträgt nur 62.5%.

  2. Wenn eine Aufgabe fast zu 100% parallelisiert werden kann, was ist die theoretische Obergrenze? Warum ist sie in der Praxis immer noch nicht erreichbar?

    Antwort: Die theoretische Obergrenze ist unendlich (Speedup = Anzahl der Kerne). In der Praxis wird sie jedoch begrenzt durch: (1) Overhead beim Aufteilen und Zusammenführen von Aufgaben; (2) Latenz bei der Synchronisation und Kommunikation zwischen Kernen; (3) Konkurrenz um gemeinsam genutzte Ressourcen (wie Speicherbandbreite).

  3. Warum können moderne Server-CPUs 64 oder sogar 128 Kerne haben, während Personalcomputer normalerweise nur 4 bis 16 Kerne haben?

    Antwort: Von Servern bearbeitete Anfragen (wie Webanfragen und Datenbankabfragen) sind von Natur aus stark parallel – jede Benutzeranfrage ist unabhängig, daher liegt der parallelisierbare Anteil nahe bei 100%. Auf der anderen Seite haben alltägliche Aufgaben auf Personalcomputern (wie Browser-Rendering und Verarbeitung von Office-Dokumenten) begrenzte Parallelität; zu viele Kerne wären nutzlos und würden stattdessen den Stromverbrauch und die Kosten erhöhen.

Weitere Erweiterungen