一つの命令の完全な旅

第1回の2進数の基礎から、前回のI/Oシステムまで——私たちはコンピュータ構成原理のすべての中核内容を学び終えました。今回はこれらの知識を1本の線に結び付け、1つの命令が生まれてから完了するまでの完全な旅を追跡します。

私たちは完全なフォン・ノイマンコンピュータシミュレータ(FullComputer)それは以下を含みます:4層の記憶構造(ハードディスク、メモリ、キャッシュ、レジスタ)、DMAデータ転送、フェッチ-デコード-実行-ライトバックの4段階パイプライン、バス相互作用、キャッシュヒット率統計。最後に完全な実行レポートを出力します。


振り返り:6つのモジュールの知識地図

エンドツーエンドのシミュレーションを始める前に、本コースの6つのモジュールそれぞれの中核概念を簡単に振り返りましょう:

モジュールテーマ中核概念今回の講義での具体化
第1モジュール2進数と情報表現0/1コーディング、基数変換、補数、浮動小数点数命令とデータはメモリ内でどちらも2進数の形で格納される
第2モジュール論理ゲートとデジタル回路AND/OR/NOTゲート、加算器、ALU実行段階のALU演算はゲート回路で実現される
第3モジュールフォン・ノイマンアーキテクチャ五大コンポーネント、プログラム内蔵方式、命令サイクル今回の講義でシミュレートするのは、完全なフォン・ノイマン機です
第4モジュールCPUの原理レジスタ、PC、IR、パイプライン、4段階フェッチ-デコード-実行-ライトバックの4段階すべてをシミュレートする
第5モジュール記憶システムメモリ階層、キャッシュ、局所性の原理ハードディスク→メモリ→キャッシュ→レジスタ、4レベル記憶の全経路
第6モジュールバスとI/Oアドレス/データ/制御バス、ポーリング/割り込み/DMADMAによるプログラムのロード、バスによるデータ転送、キャッシュラインの埋め込み

一つの命令の完全なライフサイクル

私たちは1つの簡単な疑似命令ADD A, B(レジスタAとBの値を加算し、結果をAに格納する)を例として、その完全な旅を追跡します:

旅の第1歩:プログラムはハードディスクに保存されている

プログラムは最初、ファイルの形でハードディスクに保存されています。ハードディスクは永続化ストレージ、電源を切ってもデータは失われませんが、読み書き速度は最も遅いです(ミリ秒単位)。

旅の第2歩:DMAがプログラムをメモリにロードする

プログラムをダブルクリックして実行すると、オペレーティングシステムはDMAプログラムをハードディスクからメモリへ移します。DMAコントローラがデータ転送作業を引き継ぎ、CPUはその間に他の作業を行うことができます。

旅の第3歩:CPUがバスを介して命令をフェッチする

CPUはプログラムカウンタ(PC)の値をアドレスバスに置き、制御バスに「読み取り」信号を出します。メモリは信号を受け取ると、対応するアドレスの命令をデータバスに置き、CPUはそれを命令レジスタ(IR)に読み込みます。

旅の第4歩:デコード——コントローラが命令を解析する

命令レジスタ内の ADD A, B は3つの部分に分解されます:オペコードADD、デスティネーションオペランドA、ソースオペランドB。コントローラはオペコードに基づいて次の操作を決定します。

旅の第5歩:実行——ALUが演算を行う

コントローラは制御信号を出し、ALUにレジスタAとBから値を取らせ、加算演算を実行させます。結果はALUの出力端に一時保存されます。

旅の第6歩:ライトバック——結果がデータバス経由でレジスタに格納される

ALUの計算結果はデータバス経由でレジスタAに書き戻されます。ここで、1つの命令が実行完了です。PCは自動的に1加算され、次の命令を指します。


コードデモ:FullComputer 完全シミュレーション

以下の FullComputer クラスは、上記の全フローを完全にシミュレートします。それは300行以上のコードを含み、本コースの全6モジュールの知識ポイントを網羅しています。各ステップで詳細なログを出力します。

実例

"""
FullComputer - 完全なフォン・ノイマンコンピュータシミュレータ(サンプル 教育用デモ)

本プログラムは、完全な(簡易版)フォン・ノイマンコンピュータを実装しており、以下を含みます:
- 4層ストレージ: ハードディスク (Disk) → メモリ (Memory) → キャッシュ (Cache) → レジスタ (Register)
- DMAコントローラ: プログラムをハードディスクからメモリへ自動的に転送する
- 3種類のバス: アドレスバス、データバス、制御バス
- 4段階実行: フェッチ (Fetch) → デコード (Decode) → 実行 (Execute) → ライトバック (WriteBack)
- 統計システム: キャッシュヒット率、命令数、バス使用回数、実行時間

対応命令セット:
LOAD reg value - 即値をレジスタにロードする
STORE reg addr - レジスタの値をメモリアドレスに格納する
  ADD dst src      - dst = dst + src
  SUB dst src      - dst = dst - src
  MUL dst src      - dst = dst * src
CMP a b - 2つのレジスタを比較し、フラグを設定する
JMP addr - 無条件ジャンプ
JZ addr - ゼロフラグが真ならジャンプする

実行方法: python fullcomputer.py
"""


import time


# ============================
# 1. 記憶システム - 4層構造
# ============================

class Disk:
    """
ハードディスク - 最下層の永続化ストレージ。
速度は最も遅く(ミリ秒単位)、容量は最大で、電源が切れてもデータを失いません。
    """

    def __init__(self):
        self.sectors = {}          # セクターストレージ、ハードディスクセクターをシミュレート
        self.read_latency = 5      # 読み取りレイテンシ(シミュレーション時間単位)
        self.write_latency = 8     # 書き込みレイテンシ

    def load_program(self, program_name):
        """ハードディスクに保存されているプログラムをロードします。None を返す場合、プログラムは存在しません。"""
        if program_name in self.sectors:
            print(f" [ハードディスク] プログラム '{program_name}' を見つけました、サイズ: {len(self.sectors[program_name])} 命令")
            return self.sectors[program_name]
        print(f" [ハードディスク] プログラム '{program_name}' が見つかりません!")
        return None

    def store_program(self, name, program):
        """プログラムをハードディスクに保存します"""
        self.sectors[name] = program
        print(f" [ハードディスク] プログラム '{name}' ({len(program)} 命令) をセクター 0x{hash(name) & 0xFFFF:04X} に保存しました")


class Memory:
    """
メインメモリ - 第2層のストレージ。
速度は中程度(ナノ秒単位)、容量は比較的大きく、電源が切れるとデータは失われます。
CPUはメモリ内のデータにのみ直接アクセスできます(ハードディスクには直接アクセスできません)。
    """

    def __init__(self, size=65536):
        self.size = size           # メモリサイズ(バイト)
        self.cells = {}            # メモリセル、キーはアドレス、値はデータ/命令
        self.read_count = 0        # 読み取り操作カウント
        self.write_count = 0       # 書き込み操作カウント

    def read(self, addr):
        """指定されたアドレスからデータを読み取ります"""
        self.read_count += 1
        if addr not in self.cells:
            print(f" 警告: アドレス {addr} が初期化されていません、0 を返します")
            return 0
        return self.cells[addr]

    def write(self, addr, data):
        """指定されたアドレスにデータを書き込みます"""
        self.write_count += 1
        self.cells[addr] = data

    def load_block(self, start_addr, data_block):
        """
データの塊全体をメモリの連続したアドレス領域にロードします。
DMA一括転送のシナリオに使用されます。
        """

        for i, item in enumerate(data_block):
            self.cells[start_addr + i] = item
        return len(data_block)


class Cache:
    """
キャッシュ (L1 Cache シミュレーション) - 第3層のストレージ。
速度は極めて速く(CPUと同じ周波数)、容量は最小です。

単純なダイレクトマップキャッシュモデルを使用します:
- 各キャッシュラインの格納: (メモリアドレス, データ内容)
- キャッシュヒット: データがすでにキャッシュ内にある場合、直接返す
- キャッシュミス: メモリからロードし、キャッシュラインを1つ置き換える
    """

    def __init__(self, num_lines=8):
        self.num_lines = num_lines
        self.lines = {}            # キャッシュライン: {cache_line_index: (mem_addr, data)}
        self.hit_count = 0
        self.miss_count = 0

    def read(self, mem_addr, memory):
        """
キャッシュから読み取る。ヒットした場合は直接返し、ミスした場合はメモリからロードする。
戻り値: (data, was_hit)
        """

        # 単純マッピング: キャッシュ行インデックス = メモリアドレス % キャッシュ行数
        line_index = mem_addr % self.num_lines

        if line_index in self.lines:
            cached_addr, cached_data = self.lines[line_index]
            if cached_addr == mem_addr:
                # キャッシュヒット
                self.hit_count += 1
                print(f" [キャッシュ] ヒット!行 {line_index}, アドレス {mem_addr}, データ: {cached_data}")
                return cached_data, True

        # キャッシュミス
        self.miss_count += 1
        data = memory.read(mem_addr)
        self.lines[line_index] = (mem_addr, data)
        print(f" [キャッシュ] ミス、メモリアドレス {mem_addr} からデータ {data} をロード → キャッシュ行 {line_index}")
        return data, False

    @property
    def hit_rate(self):
        total = self.hit_count + self.miss_count
        return self.hit_count / total * 100 if total > 0 else 0.0


class RegisterFile:
    """
レジスタ群 - 最上位のストレージ。
最速(1クロックサイクル)、容量は最小。
汎用レジスタ + 特殊レジスタ (PC, IR, MAR, MDR, FLAGS)
    """

    def __init__(self):
        # 汎用レジスタ
        self.gpr = {'A': 0, 'B': 0, 'C': 0, 'D': 0}

        # 特殊レジスタ
        self.PC = 0                # プログラムカウンタ: 次の命令のアドレスを保持
        self.IR = None             # 命令レジスタ: 現在実行中の命令を保持
        self.MAR = 0               # メモリアドレスレジスタ: アクセスするメモリアドレスを保持
        self.MDR = 0               # メモリデータレジスタ: メモリから読み出した/書き込むデータを保持

        # フラグレジスタ
        self.FLAGS = {'Z': False}  # ゼロフラグ: 直前の演算結果が 0 かどうか

    def __repr__(self):
        gpr_str = ', '.join(f'{k}={v}' for k, v in self.gpr.items())
        return f"GPR[{gpr_str}] PC={self.PC} IR={self.IR} FLAGS={self.FLAGS}"


# ============================
# 2. バスシステム - 3本のバス
# ============================

class SystemBus:
    """
システムバス - アドレスバス、データバス、制御バスを含む。
CPU、メモリ、DMA が使用する統一インターフェースを提供する。
    """

    def __init__(self):
        self.address_bus = 0       # アドレスバス: 現在転送中のアドレス
        self.data_bus = 0          # データバス: 現在転送中のデータ
        self.control_bus = 'IDLE'  # 制御バス: IDLE, READ, WRITE, INTERRUPT, DMA_REQ, DMA_ACK
        self.transfer_count = 0    # バス転送回数

    def cpu_read(self, address, memory, cache):
        """
CPU はバスを介してメモリからデータを読み取る(キャッシュ経由)。
完全なバス相互作用プロセス:
1. CPU はアドレスをアドレスバスに載せる
2. CPU は制御バスに READ 信号を発行する
3. メモリは(キャッシュ層を介して)データをデータバスに返す
4. CPU はデータバスからデータを読み取る
5. バスをクリアする
        """

        self.address_bus = address
        self.control_bus = 'READ'
        self.transfer_count += 1
        print(f" [バス] アドレスバス ← {address}, 制御バス ← READ")

        # メモリはキャッシュ層を介して応答
        data, was_hit = cache.read(address, memory)
        self.data_bus = data
        print(f" [バス] データバス ← {data} {'(キャッシュヒット)' if was_hit else '(メモリから)'}")

        # CPU がデータを読み取る
        result = self.data_bus

        # バスをクリア
        self.address_bus = 0
        self.data_bus = 0
        self.control_bus = 'IDLE'
        print(f" [バス] バスをクリアし、アイドル状態に移行")

        return result

    def cpu_write(self, address, data, memory):
        """
CPU はバスを介してメモリにデータを書き込む。
        """

        self.address_bus = address
        self.data_bus = data
        self.control_bus = 'WRITE'
        self.transfer_count += 1
        print(f" [バス] アドレスバス ← {address}, データバス ← {data}, 制御バス ← WRITE")

        memory.write(address, data)
        print(f" [バス] データ {data} はメモリアドレス {address} に書き込まれた")

        # バスをクリア
        self.address_bus = 0
        self.data_bus = 0
        self.control_bus = 'IDLE'
        print(f" [バス] バスをクリアし、アイドル状態に移行")


# ============================
# 3. DMA コントローラ
# ============================

class DMAController:
    """
DMA コントローラ - ハードディスクとメモリの間でデータを直接転送する役割を担う。
CPU は DMA に指示するだけでよい: 送信元アドレス、宛先アドレス、転送長。
DMA は転送完了後、割り込みで CPU に通知する。
    """

    def __init__(self, bus):
        self.bus = bus
        self.transfer_count = 0    # DMA 転送回数
        self.total_bytes = 0       # 総転送バイト数

    def transfer_program(self, disk, program_name, memory, load_addr=0):
        """
DMA を介してプログラムをハードディスクからメモリにロードする。
これは本コース第20回「DMA方式」の実際の応用である。
        """

        print(f"\n  {'='*50}")
        print(f" DMA 転送開始: ハードディスク → メモリ")
        print(f"  {'='*50}")
        print(f" [DMA] 送信元: ハードディスクセクタ (プログラム '{program_name}')")
        print(f" [DMA] 宛先: メモリアドレス 0x{load_addr:04X} から")
        print(f" [DMA] バス制御権を要求中...")

        # DMA がバスを占有
        self.bus.control_bus = 'DMA_REQ'
        print(f" [DMA] バス制御権を獲得 (制御バス ← DMA_REQ)")

        program = disk.load_program(program_name)
        if program is None:
            print(f[DMA] エラー: プログラムが存在しないため、転送を中止)
            self.bus.control_bus = 'IDLE'
            return 0

        # 命令ごとに転送
        for i, instruction in enumerate(program):
            addr = load_addr + i
            memory.write(addr, instruction)
            self.bus.address_bus = addr
            self.bus.data_bus = instruction
            self.total_bytes += 1
            self.transfer_count += 1
            print(f" [DMA] 転送 #{i}: 命令 '{instruction}' → メモリアドレス {addr} (0x{addr:04X})")

        # DMA がバスを解放し、完了割り込みを送信
        self.bus.control_bus = 'DMA_ACK'
        print(f[DMA] 転送完了!合計 {len(program)} 命令、{self.total_bytes} 回のバス転送)
        print(f" [DMA] バス制御権を解放 (制御バス ← IDLE)")

        # 割り込みで CPU に通知
        print(f" [DMA] 割り込み信号を送信して CPU に通知: プログラムのロード完了")
        self.bus.control_bus = 'INTERRUPT'

        # CPU が割り込みを受けた後の処理
        time.sleep(0.001)
        print(f" [CPU 割り込み応答] DMA 完了割り込みを受信、プログラムの準備が完了")
        self.bus.control_bus = 'IDLE'

        return len(program)

    def cache_prefetch(self, memory, cache, start_addr, count):
        """
DMA プリフェッチ: メモリ内で間もなく使用するデータを先にキャッシュへロードする。
現代 CPU のハードウェアプリフェッチ機構をシミュレートする。
        """

        print(f"\n[DMA プリフェッチ] メモリアドレス {start_addr}~{start_addr+count-1} をキャッシュにプリロード中...")
        for i in range(count):
            addr = start_addr + i
            data = memory.read(addr)
            line_index = addr % cache.num_lines
            cache.lines[line_index] = (addr, data)
        print(f" [DMA プリフェッチ] 完了、{count} 命令がキャッシュに書き込まれた")


# ============================
# 4. ALU - 算術論理演算装置
# ============================

class ALU:
    """
算術論理演算装置 - すべての算術演算と論理演算を実行する。
コース第2モジュールの加算器、論理ゲートなどの内容に対応する。
    """

    @staticmethod
    def add(a, b):
        print(f" [ALU] 加算を実行: {a} + {b} = {a + b}")
        return a + b

    @staticmethod
    def sub(a, b):
        print(f" [ALU] 減算を実行: {a} - {b} = {a - b}")
        return a - b

    @staticmethod
    def mul(a, b):
        print(f" [ALU] 乗算を実行: {a} * {b} = {a * b}")
        return a * b

    @staticmethod
    def cmp(a, b):
        result = (a == b)
        print(f" [ALU] 比較を実行: {a} == {b} ? {'はい' if result else 'いいえ'} (Z={1 if result else 0})")
        return result


# ============================
# 5. FullComputer - 完全なコンピュータ
# ============================

class FullComputer:
    """
完全なフォン・ノイマン型コンピュータのシミュレータ。

コンポーネント:
- disk: ハードディスク(永続ストレージ)
- memory: メインメモリ
- cache: L1 キャッシュ
- registers: レジスタ群 (PC, IR, MAR, MDR, FLAGS を含む)
- alu: 算術論理演算装置
- bus: システムバス(アドレス + データ + 制御)
- dma: DMA コントローラ

実行フロー:
1. ロード: DMA がプログラムをハードディスクからメモリへ転送
2. ループ: 命令フェッチ → デコード → 実行 → ライトバック
3. 完全な実行レポートを生成
    """


    def __init__(self):
        print("=" * 60)
        print(" FullComputer - フォン・ノイマン型コンピュータ初期化中...")
        print("=" * 60)

        # 4層ストレージシステム
        self.disk = Disk()
        self.memory = Memory()
        self.cache = Cache(num_lines=8)
        self.registers = RegisterFile()

        # 演算ユニット
        self.alu = ALU()

        # バスシステム
        self.bus = SystemBus()

        # DMA コントローラ
        self.dma = DMAController(self.bus)

        # 統計情報
        self.instructions_executed = 0
        self.clock_cycles = 0

        print(コンポーネント準備完了: ハードディスク, メモリ(64KB), キャッシュ(8行L1), 4つの汎用レジスタ)
        print(" コンポーネント準備完了: ALU, システムバス, DMAコントローラ")
        print()

    def store_program(self, name, program):
        """プログラムをハードディスクに保存"""
        print(f"[Step 0] プログラム '{name}' をハードディスクに保存")
        self.disk.store_program(name, program)
        print()

    def load_program(self, program_name, load_addr=0):
        """
プログラムのロード: DMA がハードディスクからメモリへ転送。
        """

        print(f"[Step 1] DMA がプログラムをメモリにロード")
        size = self.dma.transfer_program(
            self.disk, program_name, self.memory, load_addr
        )
        print()

        # 命令をキャッシュにプリフェッチ
        print(f"[Step 2] キャッシュウォームアップ: 先頭の {min(4, size)} 命令をプリフェッチ")
        self.dma.cache_prefetch(self.memory, self.cache, load_addr, min(4, size))
        print()

        # PC をプログラム開始アドレスに設定
        self.registers.PC = load_addr
        print(f"[Step 3] PC ← {load_addr} に設定 (プログラム開始アドレス)")
        print()

    def fetch(self):
        """
フェーズ 1: 命令フェッチ (Fetch)
- PC の値を MAR に設定
- アドレスバスを介してアドレスを送信
- 制御バスを介して READ 信号を発行
- データバスから命令を取得(キャッシュ層経由)
- 命令を IR に格納
- PC をインクリメント
        """

        print(f"--- フェーズ 1: 命令フェッチ (Fetch) ---")
        self.clock_cycles += 1

        # MAR ← PC
        self.registers.MAR = self.registers.PC
        print(f"  MAR ← PC = {self.registers.PC}")

        # バスを介してメモリを読み取る(キャッシュ経由)
        instruction = self.bus.cpu_read(
            self.registers.MAR, self.memory, self.cache
        )

        # MDR ← データバス, IR ← MDR
        self.registers.MDR = instruction
        self.registers.IR = instruction
        print(f"  MDR ← {instruction}, IR ← MDR")

        # PC をインクリメント
        old_pc = self.registers.PC
        self.registers.PC += 1
        print(f"  PC ← {old_pc} + 1 = {self.registers.PC}")

        return instruction

    def decode(self):
        """
フェーズ 2: デコード (Decode)
コントローラはIR内の命令を解析する
オペコードとオペランドを分離する
実行段階の操作を決定する
        """

        print(f"--- ステージ 2: デコード (Decode) ---")
        self.clock_cycles += 1

        instruction = self.registers.IR
        parts = instruction.split()
        opcode = parts[0]
        operands = parts[1:] if len(parts) > 1 else []

        print(f" 命令: '{instruction}'")
        print(f" オペコード: {opcode}, オペランド: {operands}")

        return opcode, operands

    def execute(self, opcode, operands):
        """
ステージ 3: 実行 (Execute)
- オペコードに基づいて対応する操作を実行する
- ALU は算術/論理演算に関与する
- レジスタを変更したり、フラグを設定したりする場合がある
        """

        print(f"--- ステージ 3: 実行 (Execute) ---")
        self.clock_cycles += 1

        if opcode == 'LOAD':
            # LOAD reg value: 即値をレジスタにロードする
            reg, value = operands[0], int(operands[1])
            self.registers.gpr[reg] = value
            print(f" 操作: 即値 {value} → レジスタ {reg} にロード")
            print(f" ALU は関与しない(直接ロード)")

        elif opcode == 'STORE':
            # STORE reg addr: レジスタの値をメモリに格納する
            reg, addr = operands[0], int(operands[1])
            value = self.registers.gpr[reg]
            print(f" 操作: レジスタ {reg} の値 {value} をメモリアドレス {addr} に格納する準備")
            # データの準備ができたので、ライトバックステージで実際のストア操作を実行する
            return ('STORE', reg, addr, value)

        elif opcode == 'ADD':
            # ADD dst src: dst = dst + src
            dst, src = operands[0], operands[1]
            old_val = self.registers.gpr[dst]
            result = self.alu.add(old_val, self.registers.gpr[src])
            self.registers.gpr[dst] = result
            # ゼロフラグを設定する
            self.registers.FLAGS['Z'] = (result == 0)
            print(f" 操作: {dst} ← {old_val} + {self.registers.gpr.get(src, src)} = {result}")
            print(f" ゼロフラグ Z ← {self.registers.FLAGS['Z']}")

        elif opcode == 'SUB':
            # SUB dst src: dst = dst - src
            dst, src = operands[0], operands[1]
            old_val = self.registers.gpr[dst]
            result = self.alu.sub(old_val, self.registers.gpr[src])
            self.registers.gpr[dst] = result
            self.registers.FLAGS['Z'] = (result == 0)
            print(f" 操作: {dst} ← {old_val} - {self.registers.gpr.get(src, src)} = {result}")

        elif opcode == 'MUL':
            # MUL dst src: dst = dst * src
            dst, src = operands[0], operands[1]
            old_val = self.registers.gpr[dst]
            result = self.alu.mul(old_val, self.registers.gpr[src])
            self.registers.gpr[dst] = result
            self.registers.FLAGS['Z'] = (result == 0)
            print(f" 操作: {dst} ← {old_val} * {self.registers.gpr.get(src, src)} = {result}")

        elif opcode == 'CMP':
            # CMP a b: 2つのレジスタ値を比較し、ゼロフラグを設定する
            a, b = operands[0], operands[1]
            is_equal = self.alu.cmp(
                self.registers.gpr[a],
                self.registers.gpr[b]
            )
            self.registers.FLAGS['Z'] = is_equal

        elif opcode == 'JMP':
            # JMP addr: 無条件ジャンプ
            target = int(operands[0])
            print(f" 操作: アドレス {target} へ無条件ジャンプ")
            old_pc = self.registers.PC
            self.registers.PC = target
            print(f" PC ← {old_pc} → {target} (ジャンプ)")

        elif opcode == 'JZ':
            # JZ addr: ゼロフラグが真ならジャンプする
            target = int(operands[0])
            if self.registers.FLAGS['Z']:
                print(f" 操作: ゼロフラグが真 (Z=1)、アドレス {target} へジャンプ")
                self.registers.PC = target
            else:
                print(f" 操作: ゼロフラグが偽 (Z=0)、ジャンプせず順次実行")

        elif opcode == 'HALT':
            # HALT: 停止
            print(f操作: 停止命令、プログラム終了)
            return 'HALT'

        else:
            print(f" 未知のオペコード: {opcode}")

        return None

    def writeback(self):
        """
ステージ 4: ライトバック (WriteBack)
- メモリへの書き戻しが必要な操作(STORE など)があれば、このステージで完了する
- データバスを介してデータを転送する
        """

        print(f"--- ステージ 4: ライトバック (WriteBack) ---")
        self.clock_cycles += 1

        # 一般的な命令の結果は実行ステージで既にレジスタに書き込まれている
        # STORE命令はこのステージでメモリに書き込む必要がある
        print(f" レジスタ状態: {self.registers.gpr}")
        print(f" フラグレジスタ: {self.registers.FLAGS}")

    def writeback_store(self, addr, value):
        """STORE命令のライトバック操作——バスを介してメモリに書き込む"""
        self.bus.cpu_write(addr, value, self.memory)
        print(f" STORE 完了: {value} → メモリアドレス {addr}")

    def run(self):
        """
ロードされたプログラムを実行する。
命令フェッチ→デコード→実行→ライトバックをプログラム終了まで繰り返し実行する。
        """

        print("=" * 60)
        print(" プログラムの実行を開始")
        print("=" * 60)

        while self.registers.PC < max(self.memory.cells.keys(), default=0) + 1:
            # PC が有効範囲内かどうかを確認する
            if self.registers.PC not in self.memory.cells:
                # PC がプログラム範囲外、ジャンプして末尾に達した可能性があるため終了
                print(f"\nプログラムカウンタ PC={self.registers.PC} がプログラム範囲外のため、実行を終了します)
                break

            self.instructions_executed += 1

            print(f"\n{'#' * 55}")
            print(f"### 命令 #{self.instructions_executed} | PC = {self.registers.PC}")
            print(f"{'#' * 55}")

            # 命令フェッチ
            instruction = self.fetch()

            # デコード
            opcode, operands = self.decode()

            # 実行
            special = self.execute(opcode, operands)

            # HALT命令を処理する
            if special == 'HALT':
                self.clock_cycles += 1
                break

            # ライトバック
            if special and special[0] == 'STORE':
                _, reg, addr, value = special
                self.writeback_store(int(addr), value)
            else:
                self.writeback()

            # 安全チェック: 無限ループを防ぐ
            if self.instructions_executed > 1000:
                print("\n警告: 1000 命令以上実行されたため、強制停止します(無限ループの可能性))
                break

        print(f"\n{'=' * 60}")
        print(f" プログラムの実行が完了")
        print(f"{'=' * 60}")

    def report(self):
        """
完全な実行レポートを生成する。
すべての統計情報をまとめる: キャッシュヒット率、命令数、クロックサイクル、
バス転送回数、メモリ読み書き回数など。
        """

        print(f"\n{'=' * 65}")
        print(f" FullComputer 実行レポート —— サンプル")
        print(f"{'=' * 65}")
        print()

        # 基本情報
        print(f"  {'─' * 55}")
        print(f" 基本情報")
        print(f"  {'─' * 55}")
        print(f" 実行命令総数: {self.instructions_executed:>6d} 命令")
        print(f" 総クロックサイクル: {self.clock_cycles:>6d} 個")
        if self.instructions_executed > 0:
            cpi = self.clock_cycles / self.instructions_executed
            print(f" 平均 CPI(周期/命令): {cpi:>6.2f}")
        print()

        # キャッシュ性能
        print(f"  {'─' * 55}")
        print(f" キャッシュ性能 (L1 Cache)")
        print(f"  {'─' * 55}")
        total_access = self.cache.hit_count + self.cache.miss_count
        print(f" キャッシュヒット: {self.cache.hit_count:>6d} 回")
        print(f" キャッシュミス: {self.cache.miss_count:>6d} 回")
        print(f" 総アクセス回数: {total_access:>6d} 回")
        print(f" ヒット率: {self.cache.hit_rate:>6.1f}%")
        print(f" キャッシュライン総数: {self.cache.num_lines:>6d} ライン")
        print()

        # メモリアクセス
        print(f"  {'─' * 55}")
        print(f" メモリアクセス統計")
        print(f"  {'─' * 55}")
        print(f" メモリ読み取り操作: {self.memory.read_count:>6d} 回")
        print(f" メモリ書き込み操作: {self.memory.write_count:>6d} 回")
        print(f" メモリ総アクセス: {self.memory.read_count + self.memory.write_count:>6d} 回")
        print(f" メモリ使用済みアドレス数: {len(self.memory.cells):>6d} 個")
        print()

        # バス統計
        print(f"  {'─' * 55}")
        print(f" バス統計")
        print(f"  {'─' * 55}")
        print(f" CPU が開始したバス転送: {self.bus.transfer_count:>6d} 回")
        print(f" DMA が開始したバス転送: {self.dma.transfer_count:>6d} 回")
        total_bus = self.bus.transfer_count + self.dma.transfer_count
        print(f" バス転送総回数: {total_bus:>6d} 回")
        print()

        # レジスタ最終状態
        print(f"  {'─' * 55}")
        print(f" レジスタ最終状態")
        print(f"  {'─' * 55}")
        print(f" 汎用レジスタ: {self.registers.gpr}")
        print(f" プログラムカウンタ PC: {self.registers.PC}")
        print(f" 命令レジスタ IR: {self.registers.IR}")
        print(f" フラグレジスタ FLAGS: {self.registers.FLAGS}")
        print()

        # メモリデータダンプ(有効なアドレスのデータのみ表示)
        print(f"  {'─' * 55}")
        print(f" メモリデータダンプ (プログラム領域のみ表示)")
        print(f"  {'─' * 55}")
        if self.memory.cells:
            for addr in sorted(self.memory.cells.keys()):
                val = self.memory.cells[addr]
                print(f" アドレス {addr:>4d} (0x{addr:04X}): {val}")
        else:
            print(f" (メモリが空)")
        print()

        print(f"{'=' * 65}")
        print(fレポート終了。サンプル FullComputer シミュレータをご利用いただきありがとうございます!)
        print(f"{'=' * 65}")


# ============================
# 6. メインプログラム - エンドツーエンドデモ
# ============================

if __name__ == "__main__":
    print()
    print("╔" + "═" * 58 + "╗")
    print("║" + " 1つの命令の完全な旅路 —— サンプル FullComputer デモ ".center(52) + "║")
    print("╚" + "═" * 58 + "╝")
    print()

    # コンピュータを作成する
    computer = FullComputer()

    # デモプログラムを定義する: (10 + 7) * 2 - 3 = ? を計算
    # LOAD で初期値をロードし、ADD/MUL/SUB で計算を完了する
    demo_program = [
        "LOAD A 10",    # A = 10
        "LOAD B 7",     # B = 7
        "ADD A B",      # A = A + B = 17
        "LOAD C 2",     # C = 2
        "MUL A C",      # A = A * C = 34
        "LOAD D 3",     # D = 3
        "SUB A D",      # A = A - D = 31
        "STORE A 100",  # 結果をメモリアドレス 100 に格納する
        "LOAD B 31",    # B = 31 (期待される結果)
        "CMP A B",      # A と B を比較する -> 等しくなるはず
        "JZ 12",        # 等しい場合(Z=1)、HALT にジャンプする
        "LOAD D 0",     # (実行されない) D = 0
        "HALT",         # 停止
    ]

    # ステップ 1: プログラムをハードディスクに保存する
    computer.store_program("サンプル_DEMO", demo_program)

    # ステップ 2: DMA メモリへのロード
    computer.load_program("サンプル_DEMO", load_addr=0)

    # ステップ 3: プログラムの実行
    computer.run()

    # ステップ 4: 完全な実行レポートの出力
    computer.report()

    print(f"\n")
    print(f" 知識の復習: 今回のデモはコンピュータ構成原理の全6モジュールをカバーしています:")
    print(f" モジュール 1 (2進数): 命令とデータはメモリ内で2進数としてエンコードされて格納される")
    print(f" モジュール 2 (論理ゲート): 実行段階の ADD/SUB/MUL は ALU のゲート回路によって実行される")
    print(f" モジュール 3 (フォン・ノイマン): プログラムとデータはメモリを共有し、5大コンポーネントが連携して動作する")
    print(f" モジュール 4 (CPU 原理): PCフェッチ→IRデコード→ALU実行→ライトバック、完全な4段階")
    print(f" モジュール 5 (ストレージシステム): ハードディスク→メモリ→キャッシュ→レジスタ、4レベルのストレージ階層")
    print(f" モジュール 6 (バスとI/O): 3バスの相互作用、DMAプログラムのロード、割り込み通知")
    print()

実行レポートの読み解き

上記のコードを実行すると、FullComputer は詳細な実行レポートを出力します。その中の主要な指標を解読しましょう:

キャッシュヒット率

レポートに表示されるキャッシュヒット率は、プログラムの時間的局所性と空間的局所性。私たちのデモプログラムは非常に小さく、DMA が最初の4命令をプリフェッチするため、ヒット率は高くなります。実際の大規模プログラムでは、キャッシュヒット率は通常90%以上です——これこそがキャッシュが存在する意味です。

CPI(命令あたりのクロックサイクル数)

私たちの簡素化されたシミュレーションでは、各命令は固定で4クロックサイクル(フェッチ-デコード-実行-ライトバック)かかり、CPI は約4です。現代のCPUはパイプラインテクノロジーにより、CPI を1に近づけることができます——つまり各クロックサイクルで1命令を完了します。

バス転送回数

バス転送回数 = CPU が開始した転送 + DMA が開始した転送。DMA はプログラムのロード段階で大量の転送を完了し、CPU は各命令のフェッチ段階で少なくとも1回の読み取り転送を開始します。


私たちが学んだこと——6週間コースの振り返り

6週間前、私たちは最も基本的な「なぜコンピュータは0と1しか認識しないのか」から始めました。今では、ゼロから完全なコンピュータシミュレータを構築することができます。この学習経路をもう一度辿ってみましょう:

週次モジュール主要な成果
第 1 週2進数と情報表現なぜコンピュータが2進数を使うのか、進数変換の方法、そして様々な情報(数字、文字、画像)がどのように0と1にエンコードされるのかを理解した
第 2 週論理ゲートとデジタル回路AND・OR・NOTの3つの基本ゲート回路を習得し、それらを使って加算器とALUを構築する方法を理解した
第 3 週フォン・ノイマンアーキテクチャ5大コンポーネントの役割分担(演算器、制御器、メモリ、入力、出力)と「プログラム内蔵方式」の思想を理解した
第 4 週CPU 原理命令サイクルの4段階(フェッチ-デコード-実行-ライトバック)と、パイプライン技術がどのように効率を向上させるかを習得した
第 5 週ストレージシステムレジスタからハードディスクまでの4層のストレージピラミッドと、キャッシュが局所性の原理を利用してアクセスを高速化する方法を理解した
第 6 週バスと I/O3種類のバス(アドレス/データ/制御)の連携動作と、3種類のI/O方式(ポーリング/割り込み/DMA)の効率の違いを習得した

理論から実践へ:次はどこへ進めるか

このコースは、コンピュータ構成原理の強固な基礎を築きました。さらに深く学びたい場合は、以下の方向性をお勧めします:

  • オペレーティングシステム:オペレーティングシステムがCPU、メモリ、ファイルシステム、I/Oデバイスをどのように管理するかを学びます。このコースで学んだ「割り込み」「DMA」「メモリ階層」はすべてオペレーティングシステムの中心的な概念です。
  • アセンブリ言語:CPU命令と直接やり取りします。このコースを修了すると、アセンブリ言語はもはや「難解な書物」ではありません——各アセンブリ命令がハードウェアレベルでどのように実行されるかを理解できます。
  • nand2tetris:NANDゲート1つから始めて、完全なプログラマブルコンピュータを段階的に構築する有名なオンラインコースです。このコースの内容と非常に相補的です。
  • コンピュータアーキテクチャ:パイプライン、スーパースカラ、アウト・オブ・オーダー実行、分岐予測などの高度なCPU設計技術を深く学びます。
  • 組み込みシステム:このコースの知識をマイコン(Arduino、STM32など)に応用し、レジスタやペリフェラルを直接操作するプログラムを作成します。

まとめと最終チェック

一言でまとめると:コンピュータは魔法ではありません——それは慎重に設計された抽象化の層であり、トランジスタのスイッチから始まり、論理ゲート、ALU、CPU、メモリシステム、バスへと段階的に構築され、最終的に任意のプログラムを実行できる汎用マシンになります。これらの層を理解すれば、コンピュータを本当に理解したことになります。

コース総合自己確認問題

  1. FullComputer シミュレータにおいて、LOAD 命令の実行中に、アドレスバス、データバス、制御バスはそれぞれどのステップで使用されますか?
  2. FullComputer のキャッシュが8行ではなく4行しかない場合、プログラムの実行効率にどのような影響がありますか?これはコンピュータアーキテクチャでは何と呼ばれる現象ですか?
  3. 現代のオペレーティングシステムはどのようなシナリオでポーリング、割り込み、DMAを使用しますか?日常的にコンピュータを使用する際に観察できる例をそれぞれ1つ挙げてください。

参考解答:1. フェッチ段階:アドレスバスが PC の値(命令アドレス)を転送し、制御バスが READ 信号を送信し、データバスが命令内容を返します。2. キャッシュの競合が増え、ヒット率が低下します(キャッシュスラッシングまたは競合ミスと呼ばれます)。3. ポーリング:一部の単純な組み込みデバイスのファームウェア更新時の進捗確認;割り込み:キーボードでキーを押すたびに割り込みが発生します;DMA:大容量ファイルのコピー、GPUのレンダリングフレームバッファ転送。

その他の拡張