Drei Arten von I/O -- Polling, Interrupt, DMA

In der vorherigen Lektion haben wir gelernt, wie CPU und Speicher über den Bus kommunizieren. Aber ein Computer besteht nicht nur aus CPU plus Speicher – er muss auch Daten mit verschiedenen externen Geräten (I/O-Geräten) wie Tastaturen, Mäusen, Festplatten und Netzwerkkarten austauschen.

Es gibt drei grundlegende Möglichkeiten, wie die CPU Daten mit externen Geräten austauscht:Polling、Interrupt (Interrupt)、DMA (Direct Memory Access)Die Effizienz der drei Methoden unterscheidet sich enorm – welche man wählt, bestimmt oft die Leistung des gesamten Systems.

In dieser Vorlesung verwenden wir drei Alltagsszenarien, um Ihnen Intuition zu vermitteln, und vergleichen dann mit Python-Code anschaulich die Effizienzunterschiede zwischen den drei Methoden.


Drei Analogien aus dem Alltag

Szenario 1: Polling – alle 5 Sekunden prüfen, ob das Wasser kocht

Sie kochen Wasser in der Küche, aber der Wasserkocher hat keinen Pfeifton. Alle 5 Sekunden rennen Sie vom Wohnzimmer in die Küche, um nachzusehen: „Kocht das Wasser? Kocht das Wasser? Kocht das Wasser?“

Während dieser Zeit sind Sievöllig außerstande, beruhigt fernzusehendenn Sie müssen alle paar Sekunden einen Gang machen und verbringen fast Ihre gesamte Zeit mit „Statusprüfen“.

Das istPollingPolling: Die CPU prüft in einer Endlosschleife, ob das Gerät bereit ist, und verschwendet Zeit mit sinnlosen Abfragen.

Szenario 2: Interrupt – den Herd ausschalten, wenn der Wasserkocher pfeift

Diesmal hat der Wasserkocher einen Pfeifton. Nachdem Sie das Wasser auf den Herd gestellt haben, gehen Sie zurück ins Wohnzimmer und schauen in Ruhe fern. Das Wasser kocht, und der Pfeifton ertönt schrill. Sie unterbrechen das Fernsehen, gehen in die Küche, schalten den Herd aus und schauen dann weiter fern.

Sieverbringen die allermeiste Zeit mit sinnvollen Dingen(Fernsehen), und werden nur in kritischen Momenten kurz unterbrochen.

Das istInterruptInterrupt: Die CPU führt ihr Programm normal aus; wenn das Gerät bereit ist, sendet es aktiv ein Signal, um die CPU zu benachrichtigen. Die CPU unterbricht ihre aktuelle Arbeit, verarbeitet die Gerätedaten und setzt dann ihre vorherige Arbeit fort.

Szenario 3: DMA – Rufen Sie einfach ein Umzugsunternehmen an, Sie müssen keinen Finger rühren.

Du ziehst um, mit einer LKW-Ladung Möbel, die vom alten Haus zum neuen Haus transportiert werden müssen. Wenn du sie selbst Stück für Stück trägst (der Interrupt-Weg), musst du dutzende Male hin und her rennen.

Du engagierst eine Umzugsfirma (DMA-Controller) und sagst ihr: „Die Adresse des alten Hauses ist X, die Adresse des neuen Hauses ist Y, und es gibt insgesamt Z Möbelstücke.“ Dann machst du mit deinen eigenen Dingen weiter. Nachdem die Umzugsfirma alles erledigt hat, ruft sie dich an und sagt: „Umzug erledigt.“

Das istDMADMA: Ein dedizierter DMA-Controller steuert den Datentransfer zwischen Speicher und Peripheriegeräten direkt, und die CPU muss überhaupt nicht mitwirken. Nach Abschluss des Transfers sendet der DMA-Controller eine Interrupt-Benachrichtigung an die CPU.


Die wesentlichen Unterschiede zwischen den drei Methoden

FunktionenPollingUnterbrechenDMA
CPU-BeteiligungDie ganze Zeit beschäftigt, ständiges PrüfenWährend der Übertragung kurzzeitig beteiligtKaum beteiligt, erhält nur die Abschlussbenachrichtigung
Wer verschiebt die DatenDie CPU bewegt jedes Byte selbstDie CPU bewegt jedes Byte selbstDer DMA-Controller übernimmt das Verschieben; die CPU ist nicht beteiligt
CPU-LeerlaufzeitNahezu keineDie meiste Zeit im LeerlaufFast die ganze Zeit im Leerlauf
ImplementierungskomplexitätAm einfachstenErfordert Interrupt-Controller-HardwareErfordert DMA-Controller-Hardware
AntwortlatenzHängt vom Polling-Intervall abMikrosekundenbereichHängt von der Gesamtdauer der DMA-Übertragung ab
Anwendbare DatengrößeExtrem kleine MengeKleine bis mittlere Mengen (KB-Bereich)Große Mengen (MB/GB-Bereich)
Typische SzenarienEinfache eingebettete Systeme, extrem kurze WartezeitenTastatureingabe, Mausbewegung, Eintreffen von NetzwerkpaketenFestplatten-Lese-/Schreibzugriffe, Framebuffer der Grafikkarte, große Netzwerkpakete

Jedes Mal, wenn Sie eine Taste drücken, wird ein Interrupt ausgelöst; wenn Sie eine große Datei kopieren, wird DMA verwendet. Moderne Betriebssysteme wählen automatisch das beste Verfahren unter den drei Methoden basierend auf der Datenmenge und dem Szenario aus.


Zeitachsen-Visualisierung: Vergleich von CPU-Zuständen (beschäftigt vs. leerlaufend)

Angenommen, wir müssen 4 Datenblöcke von der Festplatte in den Speicher lesen. Wir verwenden eine ASCII-Zeitachse, um den CPU-Zustand bei den drei Methoden visuell zu vergleichen:

任务: 从硬盘读取 4 个数据块到内存

【轮询 - CPU 几乎全程忙碌】
时间: 0----1----2----3----4----5----6----7----8----9----10--->
CPU:  [查][查][搬][查][查][搬][查][查][搬][查][查][搬]
       忙  忙  忙  忙  忙  忙  忙  忙  忙  忙  忙  忙
                                   ↑ 几乎没有任何空闲

【中断 - CPU 大部分时间空闲】
时间: 0----1----2----3----4----5----6----7----8----9----10--->
CPU:  [工作][等待...][搬][工作]  [等待...][搬][工作]
       忙    闲       忙  忙      闲       忙  忙
                    ↑ 中断触发    ↑ 中断触发

【DMA - CPU 几乎全程空闲】
时间: 0----1----2----3----4----5----6----7----8----9----10--->
CPU:  [设置DMA][工作][工作][工作]      [被通知完成]
       忙       忙    忙    忙              忙
DMA:         [搬][搬][搬][搬]                  ↑ DMA 完成后中断
             忙  忙  忙  忙
                                  ↑ CPU 完全不管传输过程

Auf einen Blick klar: Beim Polling ist die CPU blockiert; bei Interrupt wird die CPU nur kurz unterbrochen; bei DMA wird die CPU fast vollständig freigegeben.


Code-Demonstration: die drei E/A-Methoden in Python simulieren und die Zeitachse ausgeben

Der folgende Code simuliert die Übertragung desselben Datenstapels jeweils mit Polling, Interrupt und DMA, berechnet den Anteil der CPU-Beschäftigt-/Leerlaufzeit und verwendet eine ASCII-Art-Zeitachse, um die Unterschiede anschaulich darzustellen.

Beispiel

"""
Vergleich von drei I/O-Methoden: Polling vs. Interrupt vs. DMA (Beispiel-Demo)

Dieses Programm simuliert das Szenario, in dem die CPU 10 Datenblöcke von einem 'externen Gerät' in den Speicher überträgt,
Implementieren Sie jeweils mit Polling, Interrupt und DMA und geben Sie eine Zeitleiste aus, um CPU-Zustände visuell zu vergleichen.

Kernmetrik: CPU-Beschäftigungszeit-Verhältnis. Je höher das Verhältnis, desto stärker wird die CPU durch I/O belastet.
"""


import time
import random


class IODevice:
    """Simuliert externe I/O-Geräte (wie Festplatten, Tastaturen usw.)"""

    def __init__(self, name="Festplatte", response_time=4):
        """
name: Gerätename
response_time: die Anzahl der 'Zeiteinheiten', die für die Geräteantwort erforderlich sind
        """

        self.name = name
        self.response_time = response_time  # Gerätevorbereitungszeit pro Datenblock
        self.data_buffer = []               # Geräteinterner Datenpuffer
        self.ready = False                  # Ist das Gerät bereit?

    def prepare_data(self, block_id):
        """
Gerät bereitet Daten vor – die interne Verarbeitung des Geräts wird simuliert.
In echter Hardware umfasst dieser Schritt Vorgänge wie Festplattenzugriffe, Paketempfang der Netzwerkkarte usw.
        """

        self.ready = False
        data = f"DATA_BLOCK_{block_id:02d}"
        self.data_buffer.append(data)
        # Simuliere, dass Geräte nach unterschiedlichen Zeiteinheiten bereit sind
        return data

    def is_ready(self):
        """CPU prüft diesen Status beim Polling"""
        return self.ready

    def mark_ready(self):
        """Gerät hat die Vorbereitung abgeschlossen, sendet Interrupt-Signal"""
        self.ready = True

    def get_data(self):
        """Holt einen Datenblock aus dem Gerätepuffer"""
        if self.data_buffer:
            return self.data_buffer.pop(0)
        return None


class Timeline:
    """
Timeline-Logger — zeichnet den CPU- und DMA-Zustand für jede Zeiteinheit auf
Wird für die endgültige Darstellung der ASCII-Zeitleiste verwendet
    """


    def __init__(self):
        self.cpu_states = []     # CPU-Zustand pro Zeiteinheit: 'BUSY' oder 'IDLE'
        self.dma_states = []     # DMA-Status pro Zeiteinheit
        self.events = []         # Ereignisprotokoll: (Zeit, Beschreibung)

    def record_cpu(self, state):
        self.cpu_states.append(state)

    def record_dma(self, state):
        self.dma_states.append(state)

    def log_event(self, time_unit, desc):
        self.events.append((time_unit, desc))

    def draw(self, title="Zeitleiste"):
        """Eine ASCII-Zeitleiste zeichnen"""
        total = len(self.cpu_states)
        if total == 0:
            print(" (keine Zeitdaten)")
            return

        print(f"\n  ╔══ {title} ══╗")
        print(f" ║ Gesamtzeiteinheiten: {total}")

        # CPU-Statuszeile
        cpu_line = "CPU: "
        for s in self.cpu_states:
            cpu_line += "[" + ("Ausgelastet" if s == "BUSY" else "Leerlauf") + "]"
        print(f" ║ {cpu_line}")

        # DMA-Statuszeile (wenn DMA-Aktivität vorhanden ist)
        if any(s == "BUSY" for s in self.dma_states):
            dma_line = "DMA: "
            for s in self.dma_states:
                dma_line += "[" + ("Ausgelastet" if s == "BUSY" else "Leerlauf") + "]"
            print(f" ║ {dma_line}")

        # Ereignisprotokoll
        if self.events:
            print(f" ╠══ Ereignisprotokoll ══╣")
            for t, desc in self.events:
                print(f" ║ T={t}: {desc}")

        # Statistische Zusammenfassung
        busy_count = sum(1 for s in self.cpu_states if s == "BUSY")
        idle_count = total - busy_count
        busy_pct = busy_count / total * 100 if total > 0 else 0
        idle_pct = idle_count / total * 100 if total > 0 else 0
        print(f" ╠══ Statistiken ══╣")
        print(f║ CPU belegt: {busy_count}/{total} ({busy_pct:.0f}%))
        print(f║ CPU im Leerlauf: {idle_count}/{total} ({idle_pct:.0f}%))
        print(f"  ╚{'═' * 20}╝")

        return busy_pct


class Memory:
    """Hauptspeicher simulieren"""
    def __init__(self):
        self.data = {}

    def write(self, addr, data):
        self.data[addr] = data

    def __repr__(self):
        return fMemory({len(self.data)} Datenelemente)


class Controller:
    """CPU-Controller — Simulation der Ausführung verschiedener E/A-Modi"""

    def __init__(self):
        self.memory = Memory()
        self.total_transferred = 0

    def simulate_polling(self, device, block_count):
        """
Polling-Simulation:
Die CPU prüft bei jeder Zeiteinheit, ob das Gerät bereit ist.
Wenn bereit, einen Datenblock verschieben; andernfalls weiter prüfen.
        """

        print(f"\n{'#'*55}")
        print(f"# Methode 1: Polling")
        print(f# Gerät: {device.name} | Blockanzahl: {block_count})
        print(f"# Strategie: CPU prüft Gerätestatus jede Zeiteinheit")
        print(f"{'#'*55}")

        timeline = Zeitleiste()
        time_unit = 0
        blocks_done = 0
        device_ready_at = 0  # Zeiteinheit, zu der das Gerät für den nächsten Block bereit ist

        # Initialisierung: Das Gerät beginnt, den ersten Datenblock vorzubereiten
        device.prepare_data(0)
        device_ready_at = time_unit + device.response_time

        while blocks_done < block_count:
            # CPU prüft Gerätestatus (Polling)
            timeline.record_cpu("BUSY")
            timeline.record_dma("IDLE")

            if time_unit >= device_ready_at and device.is_ready():
                # Gerät bereit -> CPU überträgt Daten
                data = device.get_data()
                self.memory.write(blocks_done, data)
                timeline.log_event(time_unit, f"CPU hat Datenblock {blocks_done} verschoben: {data}")
                blocks_done += 1
                self.total_transferred += 1

                # Nächsten Datenblock vorbereiten (falls vorhanden)
                if blocks_done < block_count:
                    device.prepare_data(blocks_done)
                    device_ready_at = time_unit + device.response_time
            else:
                # Gerät nicht bereit -> CPU hat einen Versuch umsonst gemacht
                timeline.log_event(time_unit,
                    fCPU prüft Gerät... {'Bereit' if device.is_ready() else 'Nicht bereit'})

            # Geräte-Hintergrundarbeit (falls in der Vorbereitungsphase)
            if time_unit == device_ready_at:
                device.mark_ready()
                timeline.log_event(time_unit, Gerät bereit, Daten bereit)

            time_unit += 1

        print(f"\nTransfer abgeschlossen: {self.total_transferred} Datenblöcke)
        busy_pct = timeline.draw("Polling-Modus-Zeitleiste")
        return busy_pct

    def simulate_interrupt(self, device, block_count):
        """
Interrupt-Simulation:
CPU verbringt die meiste Zeit mit der Ausführung anderer Aufgaben (als IDLE bezeichnet),
Erst nach dem Empfang des Interrupt-Signals hält es die aktuelle Arbeit an, führt die Datenübertragung aus und fährt dann fort.
        """

        print(f"\n{'#'*55}")
        print(f# Methode 2: Interrupt)
        print(f# Gerät: {device.name} | Blockanzahl: {block_count})
        print(f# Strategie: Die CPU führt Aufgaben normal aus und sendet eine Interrupt-Benachrichtigung, wenn das Gerät bereit ist)
        print(f"{'#'*55}")

        timeline = Zeitleiste()
        time_unit = 0
        blocks_done = 0
        transferred_in_interrupt = 0
        device_ready_at = 0

        # Initialisieren
        device.prepare_data(0)
        device_ready_at = time_unit + device.response_time

        while blocks_done < block_count:
            # Standard: CPU führt andere Aufgaben aus (Leerlauf)
            if time_unit == device_ready_at:
                # Gerät bereit, Interrupt-Signal senden
                device.mark_ready()
                timeline.log_event(time_unit, Interrupt ausgelöst! Gerätedaten bereit)

                # CPU reagiert auf den Interrupt und überträgt Daten (während dieser Zeit ist die CPU beschäftigt)
                data = device.get_data()
                for substep in range(2):  # Interrupt-Behandlung erfordert 2 Zeiteinheiten
                    if substep == 0:
                        timeline.record_cpu("BUSY")  # Kontext speichern, Interrupt-Behandlung betreten
                        timeline.record_dma("IDLE")
                        timeline.log_event(time_unit + substep, f"CPU tritt in die Interrupt-Behandlung ein")
                    else:
                        timeline.record_cpu("BUSY")  # Daten verschieben
                        timeline.record_dma("IDLE")
                        self.memory.write(blocks_done, data)
                        transferred_in_interrupt += 1
                        timeline.log_event(time_unit + substep, f"CPU hat Datenblock {blocks_done} verschoben: {data}")
                        blocks_done += 1

                # Interrupt-Behandlung abgeschlossen, CPU setzt ihre vorherige Arbeit fort.
                timeline.record_cpu("BUSY")
                timeline.record_dma("IDLE")
                timeline.log_event(time_unit + 2, CPU setzt vorherige Arbeit fort)
                time_unit += 3  # Die von der Interrupt-Behandlung benötigte Zeit überspringen

                # Nächsten Block vorbereiten
                if blocks_done < block_count:
                    device.prepare_data(blocks_done)
                    device_ready_at = time_unit + device.response_time
                continue

            # Normale Ausführungsphase — CPU erledigt ihre eigenen Aufgaben
            timeline.record_cpu("IDLE")
            timeline.record_dma("IDLE")
            timeline.log_event(time_unit, CPU führt andere Aufgaben aus (Leerlauf-/Benutzerprogramm))

            time_unit += 1

        print(f"\nTransfer abgeschlossen: {self.total_transferred} Datenblöcke)
        busy_pct = timeline.draw("Interrupt-Modus-Zeitachse")
        return busy_pct

    def simulate_dma(self, device, block_count):
        """
DMA-Modus-Simulation:
Die CPU konfiguriert den DMA-Controller nur am Anfang und kümmert sich dann überhaupt nicht mehr um die Datenübertragung.
Der DMA-Controller überträgt alle Datenblöcke autonom.
Nach Abschluss der Übertragung sendet DMA einen Interrupt, um die CPU zu benachrichtigen.
        """

        print(f"\n{'#'*55}")
        print(f# Methode 3: DMA (Direct Memory Access))
        print(f# Gerät: {device.name} | Blockanzahl: {block_count})
        print(f# Strategie: CPU konfiguriert DMA und arbeitet weiter, DMA-Controller überträgt Daten automatisch)
        print(f"{'#'*55}")

        timeline = Zeitleiste()
        time_unit = 0
        dma_busy_until = 0
        setup_done = False
        blocks_to_transfer = list(range(block_count))
        dma_buffer = []

        # Alle Datenblöcke vorbereiten
        for i in range(block_count):
            device.prepare_data(i)

        while blocks_to_transfer or dma_buffer:
            # Phase 1: CPU konfiguriert den DMA-Controller (nur einmal, 2 Zeiteinheiten dauernd)
            if not setup_done:
                for substep in range(2):
                    timeline.record_cpu("BUSY")
                    timeline.record_dma("IDLE")
                    if substep == 0:
                        timeline.log_event(time_unit,
                            CPU konfiguriert DMA: Quelladresse, Zieladresse und Anzahl der zu übertragenden Bytes festlegen)
                    else:
                        timeline.log_event(time_unit,
                            CPU initiiert DMA-Übertragung und setzt dann ihre eigene Arbeit fort)
                    time_unit += 1
                setup_done = True
                dma_busy_until = time_unit + block_count * device.response_time
                # Gerät als bereit markieren
                device.mark_ready()
                # DMA-Puffer vorbefüllen
                while device.data_buffer:
                    dma_buffer.append(device.data_buffer.pop(0))
                continue

            # Zweite Phase: DMA-Controller überträgt Daten autonom, CPU ist im Leerlauf
            if time_unit < dma_busy_until:
                timeline.record_cpu("IDLE")
                timeline.record_dma("BUSY")
                if dma_buffer:
                    data = dma_buffer.pop(0)
                    blocks_to_transfer.pop(0)
                    mem_addr = block_count - len(blocks_to_transfer) - 1
                    self.memory.write(mem_addr, data)
                    self.total_transferred += 1
                    timeline.log_event(time_unit, fDMA überträgt Datenblock {mem_addr}: {data})
                else:
                    timeline.log_event(time_unit, "DMA-Controller arbeitet...")
            else:
                # Phase 3: DMA abgeschlossen, sendet Interrupt, um die CPU zu benachrichtigen
                timeline.record_cpu("BUSY")
                timeline.record_dma("BUSY")
                timeline.⟦⟧log_event⟦⟧time_unit⟦⟧"DMA-Transfer benachrichtigt CPU"log_event(time_unit, "DMA transfer complete, interrupt notifies CPU")
                timeline.record_cpu("BUSY")
                timeline.record_dma("IDLE")
                timeline.⟦⟧log_eventlog_event(time_unit + ⟦⟧"CPU bestätigt" 1, "CPU confirms transfer complete")
                time_unit += 2
                break

            time_unit += 1

        print(f"\nTransfer abgeschlossen: {self.total_transferred} Datenblöcke)
        bus_pct = timeline.draw(time_unit timeline)
        return busy_pct


# ===== Hauptprogramm: Vergleich dreier Ansätze =====
if __name__ == "__main__":
    print("=" * 60)
    print(Effizienzvergleich dreier I/O-Modi — BEISPIEL Computer Organization Principles Demo)
    print("=" * 60)
    print()
    print(Szenario: Übertragung von 5 Datenblöcken von einem externen Gerät in den Speicher)
    print(Antwortzeit des Geräts (Zeiteinheiten, die zum Vorbereiten jedes Datenblocks benötigt werden): 4)
    print()

    BLOCK_COUNT = 5
    RESPONSE_TIME = 4

    results = {}

    # ---- Methode 1: Polling ----
    dev1 = IODevice("Festplatte", RESPONSE_TIME)
    ctrl1 = Controller()
    pct1 = ctrl1.simulate_polling(dev1, BLOCK_COUNT)
    results["Polling"] = pct1

    # ---- Methode 2: Interrupt ----
    dev2 = IODevice("Festplatte", RESPONSE_TIME)
    ctrl2 = Controller()
    pct2 = ctrl2.simulate_interrupt(dev2, BLOCK_COUNT)
    results["Interrupt"] = pct2

    # ---- Methode 3: DMA ----
    dev3 = IODevice("Festplatte", RESPONSE_TIME)
    ctrl3 = Controller()
    pct3 = ctrl3.simulate_dma(dev3, BLOCK_COUNT)
    results["DMA"] = pct3

    # ---- Abschließender Vergleich ----
    print("\n" + "=" * 60)
    print(Vergleich der CPU-Auslastungsanteile der drei Methoden)
    print("=" * 60)
    print(fPolling: CPU ist {results['polling']:.0f}% der Zeit ausgelastet)
    print(fInterrupt: CPU ist {results['interrupt']:.0f}% der Zeit ausgelastet)
    print(fDMA: CPU ist {results['DMA']:.0f}% der Zeit ausgelastet)
    print()

    best = min(results, key=results.get)
    worst = max(results, key=results.get)
    print(f" Beste Methode: {best} (niedrigste CPU-Auslastung)")
    print(f" Schlechteste Methode: {worst} (höchste CPU-Auslastung)")
    print()
    print(fFazit: Bei großen Datenübertragungen reduziert DMA die CPU-Auslastung im Vergleich zum Polling.)
    print(fetwa {results['polling'] - results['DMA']:.0f} Prozentpunkte.)
    print(f" Deshalb verwenden moderne Computer DMA, wenn sie große Dateien übertragen.")
    print("=" * 60)

Praxisnahe Anwendungsszenarien

Tastatureingabe — ein typisches Beispiel für Interrupts

Jedes Mal, wenn Sie eine Taste drücken, sendet der Tastaturcontroller ein Interrupt-Signal an die CPU. Die CPU unterbricht das aktuelle Programm, liest den Tastencode und setzt dann die Ausführung fort. Dieser Vorgang ist so schnell, dass Sie keine Verzögerung bemerken.

Wenn die Tastatur Polling verwenden würde – die CPU prüft 1,000 Mal pro Sekunde „Hat der Benutzer eine Taste gedrückt?“ – würde Ihr Computer einfrieren und Sie könnten nichts mehr tun.

Kopieren großer Dateien — ein typisches Beispiel für DMA

Sie kopieren einen 2GB-Film von Laufwerk C auf Laufwerk D. Der Laufwerkscontroller verwendet DMA, um Daten direkt in den Speicher zu übertragen; die CPU ist während des gesamten Vorgangs kaum beteiligt. Sie können gleichzeitig im Web surfen und Code schreiben, völlig unbeeinträchtigt.

Ohne DMA – die CPU müsste 2GB Daten selbst transportieren – und während dieser Zeit kann die CPU im Grunde keine anderen Aufgaben erledigen.

Warum wurde Polling nicht abgeschafft?

Obwohl Polling die niedrigste Effizienz hat, ist esExtrem einfaches eingebettetes SystemWeiterhin nützlich in:

  • Geringste Hardwarekosten – es wird weder ein Interrupt-Controller noch ein DMA-Controller benötigt.
  • Für Szenarien, in denen „das Gerät fast sofort bereit ist“, hat Polling einen mit Interrupts vergleichbaren Overhead, ist aber viel einfacher zu implementieren.
  • In einigen Echtzeitsystemen hat der Determinismus von Polling (genau zu wissen, wann geprüft werden muss) einen Vorteil gegenüber der Zufälligkeit von Interrupts.

Zusammenfassung und Überprüfung

Ein-Satz-Zusammenfassung:Polling bedeutet, die CPU fragt ununterbrochen „OK schon?“; Interrupt bedeutet, das Gerät ruft aktiv „IOK bereit“; DMA bedeutet, jemanden zu finden, der die Arbeit für dich erledigt – je größer die Datenmenge, desto deutlicher der Vorteil von DMA.

Selbsttestfragen

  1. Sie verwenden Ihren Computer, um ein Dokument zu schreiben, während im Hintergrund eine große Datei kopiert wird. Welche I/O-Methode wird für das Kopieren der Datei verwendet? Welche wird für Ihre Tastatureingabe verwendet?
  2. Wenn die Datenvorbereitungszeit eines Geräts extrem kurz ist (zum Beispiel nur 1 Mikrosekunde), würde Polling dann immer noch CPU verschwenden? Warum?
  3. Wie benachrichtigt der DMA-Controller die CPU, nachdem er den Datentransfer abgeschlossen hat? Welchen Mechanismus verwendet er?

Referenzantwort: 1. Das Kopieren von Dateien verwendet DMA, die Tastatureingabe verwendet Interrupts. 2. Es verschwendet immer noch – denn während des Pollings kann die CPU nichts anderes tun; selbst wenn jeder Poll schnell ist, kann der belegte Zeitschlitz nicht zur Ausführung von Benutzerprogrammen genutzt werden. Aber wenn das Gerät wirklich sehr schnell ist, kann die Einfachheit der Polling-Implementierung von Vorteil sein. 3. Nach Abschluss von DMA benachrichtigt es die CPU über einen Interrupt – dies ist der einzige Moment, in dem DMA eine Beteiligung der CPU erfordert.

Weitere Erweiterungen