メモリアドレスとアドレッシング

プログラムで変数を宣言したとき、コンピュータはどうやってその変数を「見つける」のか?なぜ32ビットシステムでは4GBメモリモジュールしか挿せないのか?

この講義ではメモリアドレスの謎を解き明かし、アドレス空間—コンピュータが使用できるメモリの大きさを決める根本的な制約—を理解する手助けをします。


生活に身近な例え:アパートの郵便受け

アパートの建物を想像してください。各部屋には独立した郵便受けがあり、それぞれに唯一無二の部屋番号が付いています。

配達員は手紙を届けるとき、部屋番号(アドレス)を知っていれば、正確に対応する郵便受けに手紙を入れられます。CPUがメモリにアクセスする方法は、配達員が手紙を投函する方法とほぼ同じです:

  • 各メモリセル(1バイト)= 郵便受け1つ
  • メモリアドレス= 郵便受けの部屋番号(0から始まる番号)
  • アドレスバスの幅= 部屋番号の最大桁数(最大でいくつの番号を割り当てられるかを決める)

部屋番号が2桁(00〜99)しかなければ、この建物には最大で100個の郵便受けしかありません。同様に、アドレスバスが32ビット幅しかなければ、CPUは最大2^32個の異なるメモリセルを区別できるだけです。


メモリアドレスの本質

アドレスとは番号のこと

ハードウェアの観点から見ると、メモリは0と1を格納できる物理セルが一列に並んだものです。各セルは1バイト(8ビット)を格納し、各セルには一意の番号があります。この番号がメモリアドレスです。

CPUは3つのバスからなるシステムを介してメモリを読み書きします:

  1. CPUは対象アドレスをアドレスバスに載せます—「103番の郵便受けを探します」
  2. CPUはコントロールバスに「読み取り」または「書き込み」信号を送ります—「中身をください」または「これを入れてください」
  3. メモリはデータをデータバスに載せ(読み取り)、またはデータバスからデータを取り去ります(書き込み)

なぜ各アドレスが1バイトに対応するのか?

これは設計上の選択です。初期のコンピュータには「ワードアドレッシング」(各アドレスが2バイトまたは4バイトに対応)を採用したものもありましたが、現代のコンピュータはほぼすべてバイトアドレッシング—各アドレスが1バイトに対応します。

この利点:文字(ASCIIでは各文字が1バイト)を処理する際に非常に自然で、追加のアライメントや分割のロジックが不要です。

内存地址:  0      1      2      3      4      5      6      7
         +------+------+------+------+------+------+------+------+
内容:    | 0x48 | 0x65 | 0x6C | 0x6C | 0x6F | 0x00 | 0xFF | ... |
         +------+------+------+------+------+------+------+------+
           'H'    'e'    'l'    'l'    'o'    '\0'

一个 32 位整数 0x12345678 在内存中的存储(小端序):
地址:    0      1      2      3
         +------+------+------+------+
内容:    | 0x78 | 0x56 | 0x34 | 0x12 |
         +------+------+------+------+
          低字节在低地址——这就是「小端序」(Little Endian)

なぜ32ビットシステムでは最大4GBメモリしか使えないのか

直接の原因:アドレスバスの幅

32ビットのアドレスは、32個の0または1で構成される2進数です。

32ビットで表現できる異なる値の数は:

2^32 = 2 × 2 × 2 × ...(32回)=4,294,967,296

すなわち約4GB(GigaBytes)。

各アドレスが1バイトに対応する場合、32ビットアドレス空間で合計4,294,967,296バイト = 4GBをアドレス指定できます。

導出計算

1 KB  = 2^10 字节 = 1,024 字节
1 MB  = 2^20 字节 = 1,048,576 字节
1 GB  = 2^30 字节 = 1,073,741,824 字节

2^32  = 2^2 × 2^30
      = 4 × 1 GB
      = 4 GB

したがって、32ビット = 4GBこれは偶然ではなく、アドレスのビット数とアドレス可能空間の間の厳密な数学的関係です。

例え:電話番号の桁数

ある都市の電話番号が8桁(00000000〜99999999)だと仮定すると、この都市には最大でいくつの異なる電話番号があり得るでしょうか?

10^8 = 1億個です。人口が1億を超えると、8桁では足りなくなります—9桁にアップグレードする必要があります。

同じ論理で:32ビットアドレスを限界まで使っても4GBです。メモリ需要が4GBを超えると、32ビットシステムでは対応できません—これが業界全体が64ビットへ移行した理由です。


64ビットの意味

64ビットアドレス空間の理論上の上限は:

2^64 = 18,446,744,073,709,551,616 バイト ≈16 EB(ExaBytes)

この数字はどれくらい大きいのでしょうか?

  • 1 EB = 10億 GB
  • 16 EBは、2025年の世界のインターネットにおける1日分のデータトラフィックの数百倍に相当します
  • もし各バイトが砂1粒だとしたら、16 EBの砂で約2000個の標準プールを埋められます。

現在、これほど大きなメモリをサポートするコンシューマ向けマザーボードはありません。現代の64ビットCPUは通常、48ビットの物理アドレスラインのみを実装しており(256 TBをアドレス指定可能)、Windows 10 Homeは128 GBに制限されています—しかし、現在および予見可能な将来にとっては、これで「十分」です。

64ビットの本当の意味は、どれだけ大きなメモリを挿せるかではなく、次の点にあります:ソフトウェアとOSは、アドレス空間の不足に対して様々な回避策を考える必要がなくなります(例:32ビット時代のPAE—物理アドレス拡張)。


異なるビット幅のアドレス可能空間の比較

アドレスビット数アドレス可能なセル数アドレス可能空間イメージしやすい例え代表的なデバイス/システム
8ビット256256 Bショートメッセージ1件の長さ初期のマイクロコントローラ
10ビット1,0241 KBプレーンテキスト1ページ分初期のEEPROM
16ビット65,53664 KB短編小説1編Intel 8086, 6502
20ビット1,048,5761 MB中くらいの厚さの本1冊Intel 8088 (IBM PC)
24ビット16,777,21616 MBロスレス音楽1曲初期のワークステーション
32ビット4,294,967,2964 GBHD映画1本Pentium, ARMv7
36ビット68,719,476,73664 GB小型NASの全データx86 PAEモード
40ビット1,099,511,627,7761 TBコンシューマ向けSSD1台分の全容量初期のARMv8
48ビット281,474,976,710,656256 TB中規模データセンターのデータ量現代のx86-64
64ビット~1.84 × 10^1916 EB天文学的な数値で、現在の物理メモリの限界をはるかに超えているx86-64 / ARMv8 アーキテクチャの上限

注意:32ビットから64ビットへの変化は「2倍」ではなく、4GBから16EBへの跳躍です—増加量は40億倍以上!指数関数的成長の力は、ここで余すところなく発揮されています。


インタラクティブデモ:アドレス空間計算機

以下のプログラムは、異なるアドレスビット数に対応するアドレス可能空間を体系的に示し、視覚化によって指数関数的成長を直感的に実感させます。

実例

"""
メモリアドレス空間計算機 (サンプル デモ)
機能:
1. 任意のアドレスビット数に対応するアドレス可能空間を計算
2. 8ビットから64ビットまでの完全な比較表を表示
3. 指数関数的成長を可視化
"""

import math

def address_space_to_str(bytes_val):
    """
バイト数を人間が読みやすい形式に変換します
対応:B, KB, MB, GB, TB, PB, EB
    """

    if bytes_val == 0:
        return "0 B"

    units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB']
    unit_idx = 0
    value = float(bytes_val)

    # 単位を段階的に上げ、数値を適切な範囲に保つ
    while value >= 1024 and unit_idx < len(units) - 1:
        value /= 1024
        unit_idx += 1

    if unit_idx == 0:
        return f"{int(value):,} {units[unit_idx]}"
    elif value >= 100:
        return f"{value:,.0f} {units[unit_idx]}"
    elif value >= 10:
        return f"{value:,.1f} {units[unit_idx]}"
    else:
        return f"{value:,.2f} {units[unit_idx]}"


def print_address_space_table(start_bits=8, end_bits=64):
    """
アドレス空間の比較表を表示します
:param start_bits: 開始ビット数
:param end_bits: 終了ビット数
    """

    print("=" * 85)
    print("メモリアドレス空間計算機 - サンプル コンピュータ構成原理")
    print("=" * 85)
    print()
    print(f"{'アドレスビット数':<10} {'アドレス可能セル数':>20} {'アドレス可能空間':>18} {'32ビット比':>15}")
    print("-" * 85)

    # 32ビットを基準にする
    baseline_32 = 2 ** 32

    # 重要なビット数を選択して表示
    key_bits = [8, 10, 12, 14, 16, 18, 20, 24, 28, 30, 32, 36, 40, 44, 48, 52, 56, 60, 64]

    for bits in key_bits:
        if bits < start_bits or bits > end_bits:
            continue

        count = 2 ** bits
        space_str = address_space_to_str(count)

        # 32ビットに対する比率を計算
        if bits <= 32:
            ratio = count / baseline_32
            ratio_str = f"1/{int(baseline_32/count)}" if ratio < 1 else "1x"
        else:
            ratio = count / baseline_32
            if ratio >= 1_000_000_000:
                ratio_str = f"{ratio/1_000_000_000:,.1f} 億倍"
            elif ratio >= 1_000_000:
                ratio_str = f"{ratio/1_000_000:,.0f} 百万倍"
            elif ratio >= 1_000:
                ratio_str = f"{ratio/1_000:,.0f} 千倍"
            else:
                ratio_str = f"{ratio:,.0f}x"

        print(f):X}")

    print("-" * 85)
    print()


def analyze_why_4gb():
    ):X}"
    print("=" * 85)
    print("深掘り:なぜ 2^32 = 4 GB なのか?")
    print("=" * 85)
    print()
    print("導出ステップ:")
    print()
    print("  2^10 = 1,024                             → 1 KB")
    print("  2^20 = 1,024 × 1,024 = 1,048,576         → 1 MB")
    print("  2^30 = 1,024 × 1,024 × 1,024             → 1 GB")
    print(" = 1,073,741,824 バイト")
    print()
    print("  2^32 = 2^2 × 2^30")
    print("       = 4 × 1,073,741,824")
    print(" = 4,294,967,296 バイト")
    print(" = 4 GB(正確には 4 GiB)")
    print()
    print(" 注:厳密には")
    print(" 4 GB (Gigabyte) = 4 × 10^9 = 4,000,000,000 バイト(十進法)")
    print(" 4 GiB (Gibibyte) = 4 × 2^30 = 4,294,967,296 バイト(二進法)")
    print(" コンピュータ分野で日常的に言う「4GB メモリ」は、実際には 4 GiB を指します。")
    print()


def visualize_growth():
    シンプルな ASCII 棒グラフで指数関数の成果長を表示
    print("=" * 85)
    print("指数関数的成長の可視化(ASCII 棒グラフ、対数スケール)")
    print("=" * 85)
    print()

    bits_list = [8, 16, 20, 24, 28, 32, 36, 40, 48, 64]
    # 対数を使用して表示範囲を圧縮する
    for bits in bits_list:
        count = 2 ** bits
        log10 = math.log10(count)
        bar = "=" * int(log10 * 3)  # 1 log10 単位ごとに = 3 つの等号
        space_str = address_space_to_str(count)
        print(f" {bits:>3} ビット |{bar:<60} {space_str}")

    print()
    print(" 観察:8 ビットから 64 ビットまで、棒の長さは着実に伸びています(対数スケールのため)")
    print(一方、実際の数値は指数関数のに爆発しています——32 ビットから 64 ビットで 40 億倍以上に増加!)
    print()


def practical_questions():
    """実用的な応用問題"""
    print("=" * 85)
    print("実際の応用:あなたのシステムがどれだけのメモリをサポートできるか計算する")
    print("=" * 85)
    print()

    questions = [
        ("8 ビットアドレスバスの旧式マイクロコントローラ", 8),
        ("16 ビットアドレスバスの 6502 CPU", 16),
        ("32 ビットオペレーティングシステムのノートパソコン", 32),
        ("PAE を有効にした 32 ビットサーバー (36 ビット物理アドレス)", 36),
        ("現代の 64 ビット家庭用パソコン (48 ビット物理アドレス)", 48),
        (64 ビットアーキテクチャの理論の上限, 64),
    ]

    for desc, bits in questions:
        space = 2 ** bits
        print(f"  {desc}:")
        print(f" 2^{bits} = {space:,} バイト = {address_space_to_str(space)}")

    print()


# ========== メインプログラム ==========
if __name__ == "__main__":
    print_address_space_table(8, 64)
    analyze_why_4gb()
    visualize_growth()
    practical_questions()

    # 追加:インタラクティブな問い合わせ
    print("=" * 85)
    print("カスタムクエリ")
    print("=" * 85)
    print()

    custom_bits = [1, 4, 8, 16, 32, 64, 128]
    for bits in custom_bits:
        space = 2 ** bits
        print(f" {bits:>3} ビットアドレス → {space:,} 個のアドレス")
        if bits >= 128:
            print(f" → {address_space_to_str(space)} (注意:この数は観測可能な宇宙の原子の総数をはるかに超えています!)")
サンプル アドレス空間計算機 — スライダー + KaTeX 数式レンダリング + CSS Grid グリッド可視化

インタラクティブデモ:アドレス空間計算機

スライダーをドラッグしてアドレスビット数(1〜64)を調整し、KaTeX でリアルタイムに 2 をレンダリングn数式、CSS Grid でメモリセルのグリッドを描画(8 ビット以下は 256 セルを完全に描画)

クイックプリセットボタン
アドレスビット数スライダー
8
KaTeX 数式レンダリング領域
アドレス指定可能なユニットの総数
CSS Grid グリッド可視化領域
メモリセルのグリッド可視化(各セルは 1 バイトを表します)

PAE:32ビットシステムの「延命」策

64 ビットが普及する前、4GB の制限に直面し、Intel は回避策を設計しました——PAE(物理アドレス拡張)。

PAE は物理アドレス線を 32 ビットから 36 ビットに拡張し、32 ビット CPU が最大 2^36 = 64 GB の物理メモリをアドレス指定できるようにします。

しかし、ここには重要な制限があります:各プロセスの仮想アドレス空間は依然として 32 ビット(4GB)です。単一のプログラムは依然として最大 4GB のメモリしか使用できません。PAE の利点は、サーバーがより多くのプログラムを同時に実行でき、各プログラムがそれぞれ独自の 4GB を使用できることです。

PAE はあくまでも過渡的な対策であり、本当の解決策は全面的に 64 ビットへ移行することです。


仮想アドレス vs 物理アドレス

先ほど説明した「アドレス」は主に物理アドレス——メモリモジュール上の実際の、ハードウェアレベルの番号です。

しかし、現代のオペレーティングシステムでは、あなたが書いたプログラムが見るアドレスは物理アドレスではなく、仮想アドレス。

なぜ仮想アドレスが必要なのか?

  1. 隔離保護:プログラム A はプログラム B のメモリを読み書きできません(そうでなければ、クラッシュしたプログラムがシステム全体を破壊する可能性があります)。
  2. プログラミングの簡素化:各プログラムは自分がアドレス空間全体(たとえば 0 から 4GB)を独占していると思い込み、他のプログラムがどのアドレスを使っているかを気にする必要がありません。
  3. 柔軟なメモリ管理:オペレーティングシステムは使用頻度の低いメモリを一時的にハードディスクに書き出し(スワップ/ページング)、必要なときに読み戻すことができます。

CPU 内部にはハードウェアユニットがあり、MMU(メモリ管理ユニット)と呼ばれ、仮想アドレスをリアルタイムで物理アドレスに変換する役割を担っています。

程序看到的虚拟地址 → [MMU 翻译] → 物理地址 → [地址总线] → 内存条

程序写:  *(0x08048000) = 42
         ↓
MMU 查表: 虚拟页 0x08048 → 物理页 0x1A3F0
         ↓
物理地址: 0x1A3F0000 的内存单元被写入 42

仮想アドレスは現代のオペレーティングシステムの安定性の基盤です。仮想アドレスと MMU がなければ、範囲外の読み書きを行うプログラムがシステム全体をブルースクリーンにする可能性があります——このような悪夢は DOS 時代には毎日起こっていました。


プログラミングにおけるメモリアドレスの現れ方

C/C++ では、メモリアドレス(ポインタ)を直接操作できます。ここで直感的な例を示します:

実例

"""
Python でのメモリアドレス確認 (サンプル デモ)
Python は低レベルのポインタを隠蔽していますが、id() 関数を使えばアドレスの概念を垣間見ることができます
"""

import sys

# 基本型のメモリアドレス
a = 42
b = 42
c = 999
d = 999

print("サンプル メモリアドレス探求: Python id() デモ")
print("=" * 60)
print()

# Python は小整数(-5〜256)をキャッシュしており、同じ値の変数は同じアドレスを指します
print("小整数キャッシュ現象:")
print(f" a = 42, id(a) = {id(a)} (十六進法: 0x{id(a):X})")
print(f" b = 42, id(b) = {id(b)} (十六進法: 0x{id(b):X})")
print(f" a と b は同じオブジェクトを指しています: {a is b}")
print()

print("大きな整数はキャッシュされません:")
print(f" c = 999, id(c) = {id(c)} (十六進法: 0x{id(c):X})")
print(f" d = 999, id(d) = {id(d)} (十六進法: 0x{id(d):X})")
print(f" c と d は同じオブジェクトを指しています: {c is d} (通常は False、Python の実装によって異なります)")
print()

# 文字列のアドレス
text = "Hello サンプル"
print(f"文字列 'Hello サンプル' の id: 0x{id(text):X}")

# リストのアドレスと要素のアドレス
lst = [10, 20, 30]
print(f"\n"リスト lst = {lst}")
print(f" リスト自体の id: 0x{id(lst):X}")
print(f" lst)
print(f" lst)
print(f" lst)

print()
print("説明:")
print(" Python は物理メモリアドレスを公開しませんが、id() はオブジェクトの一意の識別子を返します。")
print(" CPython の実装では、id() が返すのはオブジェクトの仮想メモリ上のアドレスです。")
print(" リストの要素は分散して格納されていることがわかります(C の配列のように連続していません)。")
print()

# 32 ビット vs 64 ビットの現れ
print("=" * 60)
print("Python インタプリタのビット数情報:")
print(f"  sys.maxsize = {sys.maxsize}")
print(f"  2^31 - 1     = {2**31 - 1}")
print(f"  2^63 - 1     = {2**63 - 1}")
print()
if sys.maxsize > 2**32:
    print(f" あなたの Python は 64 ビットです(maxsize > 2^32)")
else:
    print(f" あなたの Python は 32 ビットです(maxsize <= 2^32)")
その他の拡張