## スタックマシンとレジスタマシン比較表

| **項目** | **スタックマシン** | **レジスタマシン** |
| :------------------- | :------------------------------------------------------------------ | :----------------------------------------------------- |
| **アーキテクチャ** | スタック（LIFO構造）を使用して演算を行う | レジスタ（CPU内部の高速メモリ）を使用して演算を行う |
| **データ操作方法** | スタックトップを操作（データをプッシュ・ポップ） | レジスタに直接データをロードし、指定したレジスタを操作 |
| **命令形式** | シンプルで短い命令が多い | より多くのオペランドを必要とする命令が多い |
| **メモリの使用** | スタックを使用（メインメモリの一部） | レジスタを使用（CPU内部） |
| **例** | `PUSH 3`, `PUSH 4`, `ADD` | `LOAD R1, 3`, `LOAD R2, 4`, `ADD R3, R1, R2` |
| **効率性** | 命令数が少ないが、スタック操作が必要なため遅くなる場合がある | 高速だが、命令数が多いためコード量が増える場合がある |
| **操作の柔軟性** | オペランドはスタックトップのみ | 任意のレジスタを指定して柔軟に操作可能 |
| **ハードウェア構造** | シンプル（スタックポインタの管理のみ） | 複雑（複数のレジスタとその制御が必要） |
| **使用される場面** | 仮想マシン（例: Java Virtual Machine） | 実際の物理CPU（例: x86, ARM） |
| **コードの可読性** | 簡潔だが、動作を追跡するのが難しいこともある | 複雑だが、操作の流れが明確 |
| **パフォーマンス** | メモリへのアクセスが多く、CPUレジスタを活用しないため遅い場合がある | CPUレジスタを活用し、高速な演算が可能 |

---

<AmazonAffiliateCard
 title="令和7年度］基本情報技術者 超効率の教科書＋よく出る問題集 "
 url="https://amzn.to/4exLuJb"
 imageURL="https://m.media-amazon.com/images/I/71QcybC++GL._SY466_.jpg"
/>

---

## スタックマシン

`1+2=3`の演算を例にイメージします。

1. スタックの初期状態は空とします。
1. スタックへ1を積みます
1. スタックへ2を積みます
1. スタックから1と2を取り出して加算し、結果である3をスタックにプッシュします。

```mermaid
block-beta
 block
 columns 1
 a[" "] b[" "]
 end
 blockArrow1<["1を追加"]>(right)
 block
 columns 1
 0[" "] 1["1"]
 end
 blockArrow2<["2を追加"]>(right)
 block
 columns 1
 2 3["1"]
 end
 blockArrow3<["3を追加"]>(right)
 block
 columns 1
 4[" "] 5["3"]
 end
```

- 特徴
 - スタックマシンでは演算の対象がスタックトップに限定されており、演算命令にオペランドを指定しません。
 - 全ての計算は「スタックを操作する命令の順序」によって進められます。

## レジスタマシン

`1+2=3`の演算を例にイメージします。

1. 初期状態以下とします。

 - レジスタは空
 - レジスタはR1、R2、R3の3つ
 - `1+2` の各項はメモリに乗っているとする

1. メモリからR1に`1`をロードする
1. メモリからR2に`2`をロードする
1. R1とR2の値を加算し結果である`3`をR3に格納する

```mermaid
block-beta
columns 1
 block:group0
 columns 2
 1["1（メモリ）"] 2["2（メモリ）"]
 end

 space

 block:group1
 A["R1（レジスタ）"]
 B["R2（レジスタ）"]
 C["R3（レジスタ）"]
 end

 blockArrow1<[" "]>(down)


 block:group2
 columns 2
 3["1"] 4["2"]
 end

 block:group3
 D["R1"]
 3 -- "ロード" -->D
 E["R2"]
 F["R3"]
 end

 blockArrow2<[" "]>(down)

 block:group4
 columns 2
 5["1"] 6["2"]
 end

 block:group5
 columns 3
 G["R1 = 1"]
 H["R2"]
 6 -- "ロード" -->H
 I["R3"]
 end

 blockArrow3<[" "]>(down)

 block:group6
 columns 2
 J["R1 = 1"]
 K["R2 = 2"]
 L["R3 = 3"]
 J --> L
 K --> L
 end
```

- 特徴
 - 演算の柔軟性: 任意のレジスタを指定して演算を行える。
 - 命令の具体性: 演算対象を明確に指定する必要があり、命令が少し長くなる。
 - 効率性: レジスタ間の操作は高速で、スタック操作のオーバーヘッドがない。

<h2>スタックマシンとレジスタマシン比較表</h2>
| 項目 | スタックマシン | レジスタマシン |
| :------------------- | :------------------------------------------------------------------ | :----------------------------------------------------- |
| アーキテクチャ | スタック（LIFO構造）を使用して演算を行う | レジスタ（CPU内部の高速メモリ）を使用して演算を行う |
| データ操作方法 | スタックトップを操作（データをプッシュ・ポップ） | レジスタに直接データをロードし、指定したレジスタを操作 |
| 命令形式 | シンプルで短い命令が多い | より多くのオペランドを必要とする命令が多い |
| メモリの使用 | スタックを使用（メインメモリの一部） | レジスタを使用（CPU内部） |
| 例 | <code>PUSH 3</code>, <code>PUSH 4</code>, <code>ADD</code> | <code>LOAD R1, 3</code>, <code>LOAD R2, 4</code>, <code>ADD R3, R1, R2</code> |
| 効率性 | 命令数が少ないが、スタック操作が必要なため遅くなる場合がある | 高速だが、命令数が多いためコード量が増える場合がある |
| 操作の柔軟性 | オペランドはスタックトップのみ | 任意のレジスタを指定して柔軟に操作可能 |
| ハードウェア構造 | シンプル（スタックポインタの管理のみ） | 複雑（複数のレジスタとその制御が必要） |
| 使用される場面 | 仮想マシン（例: Java Virtual Machine） | 実際の物理CPU（例: x86, ARM） |
| コードの可読性 | 簡潔だが、動作を追跡するのが難しいこともある | 複雑だが、操作の流れが明確 |
| パフォーマンス | メモリへのアクセスが多く、CPUレジスタを活用しないため遅い場合がある | CPUレジスタを活用し、高速な演算が可能 |
<hr>

<hr>
<h2>スタックマシン</h2>
<code>1+2=3</code>の演算を例にイメージします。
<ol>
<li>スタックの初期状態は空とします。</li>
<li>スタックへ1を積みます</li>
<li>スタックへ2を積みます</li>
<li>スタックから1と2を取り出して加算し、結果である3をスタックにプッシュします。</li>
</ol>
<pre><code class="language-mermaid">block-beta
 block
 columns 1
 a[" "] b[" "]
 end
 blockArrow1&#x3C;["1を追加"]>(right)
 block
 columns 1
 0[" "] 1["1"]
 end
 blockArrow2&#x3C;["2を追加"]>(right)
 block
 columns 1
 2 3["1"]
 end
 blockArrow3&#x3C;["3を追加"]>(right)
 block
 columns 1
 4[" "] 5["3"]
 end
</code></pre>
<ul>
<li>特徴
<ul>
<li>スタックマシンでは演算の対象がスタックトップに限定されており、演算命令にオペランドを指定しません。</li>
<li>全ての計算は「スタックを操作する命令の順序」によって進められます。</li>
</ul>
</li>
</ul>
<h2>レジスタマシン</h2>
<code>1+2=3</code>の演算を例にイメージします。
<ol>
<li>
初期状態以下とします。
<ul>
<li>レジスタは空</li>
<li>レジスタはR1、R2、R3の3つ</li>
<li><code>1+2</code> の各項はメモリに乗っているとする</li>
</ul>
</li>
<li>
メモリからR1に<code>1</code>をロードする
</li>
<li>
メモリからR2に<code>2</code>をロードする
</li>
<li>
R1とR2の値を加算し結果である<code>3</code>をR3に格納する
</li>
</ol>
<pre><code class="language-mermaid">block-beta
columns 1
 block:group0
 columns 2
 1["1（メモリ）"] 2["2（メモリ）"]
 end

 space

 block:group1
 A["R1（レジスタ）"]
 B["R2（レジスタ）"]
 C["R3（レジスタ）"]
 end

 blockArrow1&#x3C;[" "]>(down)


 block:group2
 columns 2
 3["1"] 4["2"]
 end

 block:group3
 D["R1"]
 3 -- "ロード" -->D
 E["R2"]
 F["R3"]
 end

 blockArrow2&#x3C;[" "]>(down)

 block:group4
 columns 2
 5["1"] 6["2"]
 end

 block:group5
 columns 3
 G["R1 = 1"]
 H["R2"]
 6 -- "ロード" -->H
 I["R3"]
 end

 blockArrow3&#x3C;[" "]>(down)

 block:group6
 columns 2
 J["R1 = 1"]
 K["R2 = 2"]
 L["R3 = 3"]
 J --> L
 K --> L
 end
</code></pre>
<ul>
<li>特徴
<ul>
<li>演算の柔軟性: 任意のレジスタを指定して演算を行える。</li>
<li>命令の具体性: 演算対象を明確に指定する必要があり、命令が少し長くなる。</li>
<li>効率性: レジスタ間の操作は高速で、スタック操作のオーバーヘッドがない。</li>
</ul>
</li>
</ul>

足し算を例にスタックマシンとレジスタマシンの違いについてまとめました

項目	スタックマシン	レジスタマシン
アーキテクチャ	スタック（LIFO構造）を使用して演算を行う	レジスタ（CPU内部の高速メモリ）を使用して演算を行う
データ操作方法	スタックトップを操作（データをプッシュ・ポップ）	レジスタに直接データをロードし、指定したレジスタを操作
命令形式	シンプルで短い命令が多い	より多くのオペランドを必要とする命令が多い
メモリの使用	スタックを使用（メインメモリの一部）	レジスタを使用（CPU内部）
例	`PUSH 3`, `PUSH 4`, `ADD`	`LOAD R1, 3`, `LOAD R2, 4`, `ADD R3, R1, R2`
効率性	命令数が少ないが、スタック操作が必要なため遅くなる場合がある	高速だが、命令数が多いためコード量が増える場合がある
操作の柔軟性	オペランドはスタックトップのみ	任意のレジスタを指定して柔軟に操作可能
ハードウェア構造	シンプル（スタックポインタの管理のみ）	複雑（複数のレジスタとその制御が必要）
使用される場面	仮想マシン（例: Java Virtual Machine）	実際の物理CPU（例: x86, ARM）
コードの可読性	簡潔だが、動作を追跡するのが難しいこともある	複雑だが、操作の流れが明確
パフォーマンス	メモリへのアクセスが多く、CPUレジスタを活用しないため遅い場合がある	CPUレジスタを活用し、高速な演算が可能