I/O の三つの方式 -- ポーリング、割り込み、DMA

前回、CPUとメモリがバスを介してどのように通信するかを学びました。しかしコンピュータはCPUとメモリだけではありません。キーボード、マウス、ハードディスク、ネットワークカードなどのさまざまな外部デバイス(I/Oデバイス)とデータをやり取りする必要があります。

CPUが外部デバイスとデータを交換するには、三つの基本的な方式があります:ポーリング(Polling)、割り込み(Interrupt)、DMA(直接メモリアクセス)三者の効率は雲泥の差です。どの方式を選ぶかが、システム全体の性能を左右することがよくあります。

本講では、三つの生活シーンで直感を養い、さらにPythonコードで三つの方式の効率の違いを視覚的に比較します。


三つの生活シーンによる類推

シーン1:ポーリング——5秒ごとに湯が沸いたか見に行く

台所で湯を沸かしていますが、やかんに笛がありません。5秒ごとにリビングから台所へ走って確認します。「湯は沸いた? 湯は沸いた? 湯は沸いた?」

その間、あなたはまったく安心してテレビを見られません数秒ごとに走らなければならないからです。ほとんどすべての時間を「状態の確認」に費やしています。

これがポーリングです:CPUがデバイスの準備ができているかを絶えずループして確認し、無意味な問い合わせに時間を浪費します。

シーン2:割り込み——やかんの笛が鳴ったら火を止めに行く

今回はやかんに笛が付いています。コンロに水を掛けたら、リビングに戻って安心してテレビを見ます。湯が沸くと、笛が鋭く鳴ります。テレビを見るのを一時停止し、台所で火を止め、またテレビを見続けます。

你ほとんどの時間を有意義なことに使います(テレビを見る)、ただ重要な場面で少しだけ中断されます。

これが割り込みです:CPUは通常どおりプログラムを実行し、デバイスが準備完了になると、能動的に信号を送ってCPUに通知します。CPUは手元の作業を一時停止し、デバイスのデータを処理してから、以前の作業を再開します。

シーン3:DMA——引っ越し業者を直接頼んで、自分は何もしない

あなたは引っ越しで、トラック一台分の家具を旧居から新居へ運ぶ必要があります。自分で一つずつ運ぶと(割り込み方式)、何十回も往復しなければなりません。

あなたは引っ越し業者(DMAコントローラ)を雇い、こう伝えます。「旧居の住所はX、新居の住所はY、家具は全部でZ個です。」その後、あなたは自分の用事を続けます。引っ越し業者がすべてを完了したら、電話で「引っ越し完了しました」と連絡します。

これがDMA:専用のDMAコントローラがメモリと周辺機器の間のデータ転送を直接管理し、CPUはまったく関与しません。転送が完了すると、DMAコントローラはCPUに割り込み通知を送ります。


三つの方式の本質的な違い

特性ポーリング (Polling)割り込み (Interrupt)DMA
CPUの関与度常にビジーで、絶えずチェック転送中は短時間だけ関与ほとんど関与せず、完了通知を受け取るだけ
データを運ぶのは誰かCPUが1バイトずつ自分で運ぶCPUが1バイトずつ自分で運ぶDMAコントローラが運び、CPUは関与しない
CPUのアイドル時間ほとんどないほとんどの時間がアイドルほぼすべての時間がアイドル
実装の複雑さ最も簡単割り込みコントローラのハードウェアが必要DMAコントローラのハードウェアが必要
応答遅延ポーリング間隔に依存マイクロ秒レベルDMA転送の合計時間に依存
適用できるデータ量極少量中小量(KBレベル)大量(MB/GBレベル)
代表的なシーン単純な組み込み、ごく短い待機キーボード入力、マウス移動、ネットワークパケット到着ディスク読み書き、グラフィックカードのフレームバッファ、ネットワークカードの大きなパケット

キーボードを叩くたびに割り込みが発生し、大きなファイルをコピーするときはDMAが使われます。現代のオペレーティングシステムは、データ量とシーンに応じて、3つの方式の中から最適なものを自動的に選択します。


時間軸の可視化:CPUのビジーとアイドルの比較

ハードディスクから4つのデータブロックをメモリに読み込む必要があるとします。ASCII時間軸を使って、三つの方式におけるCPUの状態を視覚的に比較します。

任务: 从硬盘读取 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 完全不管传输过程

一目瞭然です。ポーリングではCPUが拘束され、割り込みではCPUは一時的に中断されるだけで、DMAではCPUはほぼ完全に解放されます。


コードデモ:Pythonで三つのI/O方式をシミュレートして時間軸を出力

以下のコードは、ポーリング、割り込み、DMAの三つの方式で同じデータの転送プロセスをシミュレートし、CPUのビジー/アイドル時間の割合を集計し、文字画の時間軸で違いを視覚的に示します。

実例

"""
I/O三方式の比較:ポーリング vs 割り込み vs DMA(サンプルデモ)

このプログラムは、CPUが「外部デバイス」から10個のデータブロックをメモリへ転送するシーンをシミュレートします。
それぞれポーリング、割り込み、DMAの三つの方式で実行し、時間軸を出力してCPUの状態を直感的に比較します。

核心指標:CPUのビジー時間の割合。割合が高いほど、CPUがI/Oに妨げられていることを示します。
"""


import time
import random


class IODevice:
    """外部I/Oデバイス(ハードディスク、キーボードなど)をシミュレート"""

    def __init__(self, name="ハードディスク", response_time=4):
        """
name: デバイス名
response_time: デバイスの応答に必要な「時間単位」の数
        """

        self.name = name
        self.response_time = response_time  # 各データブロックのデバイス準備時間
        self.data_buffer = []               # デバイス内部のデータバッファ
        self.ready = False                  # デバイスが準備完了かどうか

    def prepare_data(self, block_id):
        """
デバイスがデータを準備する——デバイス内部の処理プロセスをシミュレート。
実際のハードウェアでは、このステップはハードディスクのシーク、ネットワークカードのパケット受信などの操作です。
        """

        self.ready = False
        data = f"DATA_BLOCK_{block_id:02d}"
        self.data_buffer.append(data)
        # デバイスが異なる時間単位後に準備完了になるのをシミュレート
        return data

    def is_ready(self):
        """CPUがポーリングするときにこの状態をチェック"""
        return self.ready

    def mark_ready(self):
        """デバイスが準備を完了し、割り込み信号を送信"""
        self.ready = True

    def get_data(self):
        """デバイスバッファからデータブロックを1つ取り出す"""
        if self.data_buffer:
            return self.data_buffer.pop(0)
        return None


class Timeline:
    """
時間軸レコーダー——各時間単位のCPUとDMAの状態を記録
最終的にASCII時間軸を描画するために使用
    """


    def __init__(self):
        self.cpu_states = []     # 各時間単位のCPUの状態: 'BUSY' または 'IDLE'
        self.dma_states = []     # 各時間単位のDMAの状態
        self.events = []         # イベントログ: (時間, 説明)

    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="時間軸"):
        """ASCII時間軸を描画"""
        total = len(self.cpu_states)
        if total == 0:
            print(" (時間データなし)")
            return

        print(f"\n  ╔══ {title} ══╗")
        print(f" ║ 総時間単位: {total}")

        # CPU状態行
        cpu_line = "CPU:  "
        for s in self.cpu_states:
            cpu_line += "[" + ("忙" if s == "BUSY" else "暇") + "]"
        print(f"  ║ {cpu_line}")

        # DMA状態行(DMAアクティビティがある場合)
        if any(s == "BUSY" for s in self.dma_states):
            dma_line = "DMA:  "
            for s in self.dma_states:
                dma_line += "[" + ("忙" if s == "BUSY" else "暇") + "]"
            print(f"  ║ {dma_line}")

        # イベントログ
        if self.events:
            print(f" ╠══ イベントログ ══╣")
            for t, desc in self.events:
                print(f"  ║  T={t}: {desc}")

        # 統計サマリー
        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" ╠══ 統計 ══╣")
        print(f" ║ CPU ビジー: {busy_count}/{total} ({busy_pct:.0f}%)")
        print(f" ║ CPU アイドル: {idle_count}/{total} ({idle_pct:.0f}%)")
        print(f"  ╚{'═' * 20}╝")

        return busy_pct


class Memory:
    """メインメモリをシミュレート"""
    def __init__(self):
        self.data = {}

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

    def __repr__(self):
        return f"Memory({len(self.data)} 件のデータ)"


class Controller:
    """CPUコントローラ——さまざまなI/O方式のシミュレーションを実行"""

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

    def simulate_polling(self, device, block_count):
        """
ポーリング方式のシミュレーション:
CPUは各時間単位でデバイスが準備完了かどうかを確認します。
準備完了ならデータブロックを1つ運びます。そうでなければチェックを続けます。
        """

        print(f"\n{'#'*55}")
        print(f"# 方式一: ポーリング (Polling)")
        print(f"# デバイス: {device.name} | データブロック数: {block_count}")
        print(f"# 戦略: CPU は各時間単位でデバイスの状態を確認する")
        print(f"{'#'*55}")

        timeline = Timeline()
        time_unit = 0
        blocks_done = 0
        device_ready_at = 0  "# デバイスがどの時間単位で次のブロックを準備できるか"

        "# 初期化: デバイスが最初のデータブロックの準備を開始する"
        device.prepare_data(0)
        device_ready_at = time_unit + device.response_time

        while blocks_done < block_count:
            "# CPU がデバイスの状態を確認(ポーリング)"
            timeline.record_cpu("BUSY")
            timeline.record_dma("IDLE")

            if time_unit >= device_ready_at and device.is_ready():
                "# デバイス準備完了 -> CPU がデータを転送"
                data = device.get_data()
                self.memory.write(blocks_done, data)
                timeline.log_event(time_unit, f"CPU がデータブロック {blocks_done} を転送: {data}")
                blocks_done += 1
                self.total_transferred += 1

                "# 次のデータブロックを準備(まだあれば)"
                if blocks_done < block_count:
                    device.prepare_data(blocks_done)
                    device_ready_at = time_unit + device.response_time
            else:
                "# デバイス未準備 -> CPU は無駄足を踏む"
                timeline.log_event(time_unit,
                    f"CPU がデバイスを確認... {'準備完了' if device.is_ready() else '未準備'}")

            "# デバイスはバックグラウンドで動作(準備段階の場合)"
            if time_unit == device_ready_at:
                device.mark_ready()
                timeline.log_event(time_unit, "デバイス準備完了、データ準備完了")

            time_unit += 1

        print(f"\n転送完了: {self.total_transferred} ブロックのデータ")
        busy_pct = timeline.draw("ポーリング方式のタイムライン")
        return busy_pct

    def simulate_interrupt(self, device, block_count):
        """
割り込み方式のシミュレーション:
CPU はほとんどの時間を他のタスクの実行に費やしている(IDLE と記録される)、
割り込み信号を受け取ったときだけ現在の作業を一時停止し、データ転送を処理してから再開する。
        """

        print(f"\n{'#'*55}")
        print(f"# 方式2: 割り込み (Interrupt)")
        print(f"# デバイス: {device.name} | データブロック数: {block_count}")
        print(f# 戦略: CPU は通常のタスクを実行し、デバイスが準備完了すると割り込みで通知する)
        print(f"{'#'*55}")

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

        "# 初期化"
        device.prepare_data(0)
        device_ready_at = time_unit + device.response_time

        while blocks_done < block_count:
            "# 既定: CPU は他のタスクを実行中(アイドル)"
            if time_unit == device_ready_at:
                "# デバイス準備完了、割り込み信号を送信"
                device.mark_ready()
                timeline.log_event(time_unit, "割り込み発生!デバイスのデータ準備完了")

                "# CPU は割り込みに応答してデータを転送(この間 CPU はビジー)"
                data = device.get_data()
                for substep in range(2):  "# 割り込み処理には 2 時間単位かかる"
                    if substep == 0:
                        timeline.record_cpu("BUSY")  "# コンテキストを保存し、割り込み処理に入る"
                        timeline.record_dma("IDLE")
                        timeline.log_event(time_unit + substep, f"CPU は割り込み処理に入る")
                    else:
                        timeline.record_cpu("BUSY")  "# データを転送"
                        timeline.record_dma("IDLE")
                        self.memory.write(blocks_done, data)
                        transferred_in_interrupt += 1
                        timeline.log_event(time_unit + substep, f"CPU がデータブロック {blocks_done} を転送: {data}")
                        blocks_done += 1

                "# 割り込み処理が完了し、CPU は以前の作業を再開する"
                timeline.record_cpu("BUSY")
                timeline.record_dma("IDLE")
                timeline.log_event(time_unit + 2, "CPU は以前の作業を再開する")
                time_unit += 3  "# 割り込み処理に要した時間をスキップ"

                "# 次のブロックを準備"
                if blocks_done < block_count:
                    device.prepare_data(blocks_done)
                    device_ready_at = time_unit + device.response_time
                continue

            "# 通常実行段階——CPU は自身のタスクを処理"
            timeline.record_cpu("IDLE")
            timeline.record_dma("IDLE")
            timeline.log_event(time_unit, "CPU は他のタスクを実行 (アイドル/ユーザープログラム)")

            time_unit += 1

        print(f"\n転送完了: {self.total_transferred} ブロックのデータ")
        busy_pct = timeline.draw("割り込み方式のタイムライン")
        return busy_pct

    def simulate_dma(self, device, block_count):
        """
DMA 方式のシミュレーション:
CPU は最初に DMA コントローラを設定するだけで、その後はデータ転送に一切関与しない。
DMA コントローラがすべてのデータブロックを自律的に転送する。
転送完了後、DMA は割り込みで CPU に通知する。
        """

        print(f"\n{'#'*55}")
        print(f"# 方式3: DMA (直接メモリアクセス)")
        print(f"# デバイス: {device.name} | データブロック数: {block_count}")
        print(f"# 戦略: CPU は DMA を設定してから作業を続行し、DMA コントローラが自動的にデータを転送する")
        print(f"{'#'*55}")

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

        "# すべてのデータブロックを準備"
        for i in range(block_count):
            device.prepare_data(i)

        while blocks_to_transfer or dma_buffer:
            "# 第1段階: CPU が DMA コントローラを設定(一度だけ、2 時間単位を消費)"
            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 が DMA を設定: 送信元アドレス、宛先アドレス、転送バイト数を指定")
                    else:
                        timeline.log_event(time_unit,
                            "CPU は DMA 転送を開始し、その後自分の作業を続行する")
                    time_unit += 1
                setup_done = True
                dma_busy_until = time_unit + block_count * device.response_time
                "# デバイス準備完了をマーク"
                device.mark_ready()
                "# DMA バッファを事前に埋める"
                while device.data_buffer:
                    dma_buffer.append(device.data_buffer.pop(0))
                continue

            "# 第2段階: DMA コントローラが自律的にデータを転送し、CPU はアイドル状態"
            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, f"DMA がデータブロック {mem_addr} を転送: {data}")
                else:
                    timeline.log_event(time_unit, "DMA コントローラ動作中...")
            else:
                "# 第3段階: DMA 完了、割り込みで CPU に通知"
                timeline.record_cpu("BUSY")
                timeline.record_dma("BUSY")
                timeline.log_event(time_unit, "DMA 転送完了、割り込みで CPU に通知")
                timeline.record_cpu("BUSY")
                timeline.record_dma("IDLE")
                timeline.log_event(time_unit + 1, "CPU が転送完了を確認")
                time_unit += 2
                break

            time_unit += 1

        print(f"\n転送完了: {self.total_transferred} ブロックのデータ")
        busy_pct = timeline.draw("DMA 方式のタイムライン")
        return busy_pct


"# ===== メインプログラム: 3つの方式の比較 ====="
if __name__ == "__main__":
    print("=" * 60)
    print(" I/O の3つの方式の効率比較 —— サンプル コンピュータ構成原理デモ")
    print("=" * 60)
    print()
    print("シナリオ: 外部デバイスからメモリへ 5 つのデータブロックを転送")
    print("デバイス応答時間(各データブロックの準備に必要な時間単位): 4")
    print()

    BLOCK_COUNT = 5
    RESPONSE_TIME = 4

    results = {}

    "# ---- 方式1: ポーリング ----"
    dev1 = IODevice("ハードディスク", RESPONSE_TIME)
    ctrl1 = Controller()
    pct1 = ctrl1.simulate_polling(dev1, BLOCK_COUNT)
    results["ポーリング"] = pct1

    "# ---- 方式2: 割り込み ----"
    dev2 = IODevice("ハードディスク", RESPONSE_TIME)
    ctrl2 = Controller()
    pct2 = ctrl2.simulate_interrupt(dev2, BLOCK_COUNT)
    results["割り込み"] = pct2

    "# ---- 方式3: DMA ----"
    dev3 = IODevice("ハードディスク", RESPONSE_TIME)
    ctrl3 = Controller()
    pct3 = ctrl3.simulate_dma(dev3, BLOCK_COUNT)
    results["DMA"] = pct3

    "# ---- 最終比較 ----"
    print("\n" + "=" * 60)
    print(" 3つの方式の CPU ビジー時間割合の比較")
    print("=" * 60)
    print(f" ポーリング (Polling): CPU ビジー {results['轮询']:.0f}% の時間")
    print(f" 割り込み (Interrupt): CPU ビジー {results['中断']:.0f}% の時間")
    print(f" DMA: CPU ビジー {results['DMA']:.0f}% の時間")
    print()

    best = min(results, key=results.get)
    worst = max(results, key=results.get)
    print(f" 最適な方式: {best} (CPU 使用が最小)")
    print(f" 最悪の方式: {worst} (CPU 使用が最大)")
    print()
    print(f" 結論: 大量のデータ転送では、ポーリングと比較して DMA の CPU 使用率が低下し")
    print(f" 約 {results['轮询'] - results['DMA']:.0f} パーセントポイント。")
    print(f" これが、現代のコンピュータが大容量ファイル転送に DMA を使用する理由です。")
    print("=" * 60)

現実世界の実際の応用シーン

キーボード入力——割り込みの代表的な例

キーを押すたびに、キーボードコントローラが CPU に割り込み信号を送ります。CPU は現在のプログラムを一時停止し、キーコードを読み取って、再開します。この処理は非常に速いため、遅延をまったく感じることはありません。

もしキーボードがポーリング方式だったら——CPU が毎秒 1000 回「ユーザーはキーを押したか?」をチェックする——あなたのコンピュータはフリーズして、何もできなくなるでしょう。

大容量ファイルのコピー——DMAの代表的な例

C ドライブから D ドライブへ 2GB の映画をコピーする場合を考えます。ハードディスクコントローラは DMA を介して直接メモリへデータを転送するため、その間 CPU はほとんど関与しません。その間にウェブを閲覧したりコードを書いたりしても、まったく影響を受けません。

DMA がなければ——CPU が 2GB のデータを自ら転送しなければならず——その間 CPU は他のタスクをほとんど処理できません。

なぜポーリングは廃止されないのか?

ポーリングは効率が最も低いが、それは極めて単純な組み込みシステムの中では依然として有用です:

  • ハードウェアコストが最も低い——割り込みコントローラや DMA コントローラが不要である。
  • 「デバイスがほぼ瞬時に準備完了になる」ようなシナリオでは、ポーリングのオーバーヘッドは割り込みと同等ですが、実装はずっと簡単です。
  • 一部のリアルタイムシステムでは、ポーリングの決定性(いつチェックするかを正確に把握できること)が、割り込みのランダム性よりも有利です。

まとめと確認

一言でまとめると:ポーリングは CPU がひたすら「できた?」と尋ね続けること、割り込みはデバイスが自ら「できたよ!」と知らせること、DMA は代わりに働いてくれる助手を雇うことです——データ量が多ければ多いほど、DMA の利点は顕著になります。

自習問題

  1. あなたはコンピュータで文書を書いていて、同時にバックグラウンドで大容量ファイルをコピーしています。ファイルのコピーはどの I/O 方式を使っていますか? キーボード入力はどちらを使っていますか?
  2. あるデバイスのデータ準備時間が極端に短い場合(たとえば 1 マイクロ秒だけ)、ポーリングでも CPU を無駄に消費するでしょうか? なぜですか?
  3. DMA コントローラはデータ転送を完了した後、どのように CPU に通知しますか? それはどのようなメカニズムですか?

参考解答:1. ファイルコピーは DMA、キーボード入力は割り込みを使用します。2. それでも無駄になります——ポーリング中は CPU が他のことをできないからです。たとえ毎回のポーリングが速くても、占有されたタイムスライスはユーザープログラムの実行に使用できません。ただし、デバイスが本当に極端に高速であれば、ポーリングの実装が単純であるという利点があり得ます。3. DMA は完了後に割り込みで CPU に通知します——これが DMA が CPU の関与を必要とする唯一の瞬間です。

その他の発展トピック