Show description
CSE 230 | Computer Organization & Assembly Language
CSE 230 | Computer Organization & Assembly Language
CSE 230
Computer Organization & Assembly Language
// COMPLETE REFERENCE GUIDE
01 Program Execution
02 Performance
03 Data Representation
04 Assembly Programming
05 Hardware Optimization
06 Datapath Design
07 Memory Hierarchy
08 Multiprocessors
01
How Programs Execute on a Computer
Basic Components of CPU Design
┌─────────────────────────────────────────────────────────────────┐
│ CPU │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Control │ │ ALU │ │ Registers │ │
│ │ Unit │◄──►│ (Arithmetic │◄──►│ (Fast │ │
│ │ (Fetches & │ │ Logic Unit) │ │ Storage) │ │
│ │ Decodes) │ │ │ │ │ │
│ └──────┬───────┘ └──────────────┘ └──────────────┘ │
│ │ ▲ ▲ │
│ ▼ │ │ │
│ ┌──────────────┐ │ │ │
│ │Program Counter│ └───────────────────┘ │
│ │ (PC) │ │ │
│ └──────────────┘ ▼ │
│ ┌──────────────┐ │
│ │ Data Bus │ │
└───────────────────────────┴──────────────┴───────────────────────┘
│
▼
┌──────────────┐
│ Memory │
└──────────────┘
Control Unit (CU) — Directs operations, fetches instructions, decodes opcodes, generates control signals
Arithmetic Logic Unit (ALU) — Performs arithmetic (+, -, ×, ÷) and logical (AND, OR, XOR, NOT) operations
Registers — Ultra-fast storage inside CPU (general purpose, special purpose like PC, SP, IR)
Program Counter (PC) — Holds address of next instruction to execute
Instruction Register (IR) — Holds currently executing instruction
Memory Address Register (MAR) — Holds address for memory access
Memory Data Register (MDR) — Holds data being transferred to/from memory
Stack Pointer (SP) — Points to top of the stack in memory
Program Compilation Process
┌─────────────────┐
│ Source Code │ (.c, .cpp, .java)
│ (High-Level) │
└────────┬────────┘
│
▼ [Preprocessor]
┌─────────────────┐
│ Expanded Code │ (includes, macros resolved)
└────────┬────────┘
│
▼ [Compiler]
┌─────────────────┐
│ Assembly Code │ (.s, .asm)
└────────┬────────┘
│
▼ [Assembler]
┌─────────────────┐
│ Object Code │ (.o, .obj) - machine code + symbols
└────────┬────────┘
│
▼ [Linker]
┌─────────────────┐
│ Executable │ (.exe, .out) - complete binary
└────────┬────────┘
│
▼ [Loader]
┌─────────────────┐
│ Process in │ Running in RAM
│ Memory │
└──────────…
CSE 230 | Computer Organization & Assembly Language
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>CSE 230 | Computer Organization & Assembly Language</title>
<link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600;700&family=Orbitron:wght@400;500;600;700;800;900&family=Space+Grotesk:wght@300;400;500;600;700&display=swap" rel="stylesheet">
<style>
:root {
--bg-primary: #0a0a0f;
--bg-secondary: #12121a;
--bg-tertiary: #1a1a25;
--bg-card: #15151f;
--text-primary: #e8e8f0;
--text-secondary: #9090a8;
--text-muted: #606078;
--accent-cyan: #00f5ff;
--accent-magenta: #ff00aa;
--accent-green: #00ff88;
--accent-orange: #ff8800;
--accent-purple: #8855ff;
--accent-yellow: #ffee00;
--accent-red: #ff4455;
--border-color: #2a2a3a;
--glow-cyan: 0 0 20px rgba(0, 245, 255, 0.3);
--glow-magenta: 0 0 20px rgba(255, 0, 170, 0.3);
--glow-green: 0 0 20px rgba(0, 255, 136, 0.3);
}
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
html {
scroll-behavior: smooth;
}
body {
font-family: 'Space Grotesk', sans-serif;
background: var(--bg-primary);
color: var(--text-primary);
line-height: 1.7;
min-height: 100vh;
}
/* Animated Background Grid */
body::before {
content: '';
position: fixed;
top: 0;
left: 0;
width: 100%;
height: 100%;
background:
linear-gradient(90deg, rgba(0, 245, 255, 0.03) 1px, transparent 1px),
linear-gradient(rgba(0, 245, 255, 0.03) 1px, transparent 1px);
background-size: 50px 50px;
pointer-events: none;
z-index: -1;
}
/* Header */
.hero {
position: relative;
padding: 60px 40px;
text-align: center;
border-bottom: 1px solid var(--border-color);
background: linear-gradient(180deg, var(--bg-secondary) 0%, var(--bg-primary) 100%);
overflow: hidden;
}
.hero::before {
content: '';
position: absolute;
top: 0;
left: 50%;
transform: translateX(-50%);
width: 600px;
height: 600px;
background: radial-gradient(circle, rgba(0, 245, 255, 0.1) 0%, transparent 70%);
pointer-events: none;
}
.hero-title {
font-family: 'Orbitron', sans-serif;
font-size: clamp(2.5rem, 6vw, 4.5rem);
font-weight: 900;
letter-spacing: 4px;
text-transform: uppercase;
background: linear-gradient(135deg, var(--accent-cyan) 0%, var(--accent-magenta) 50%, var(--accent-cyan) 100%);
background-size: 200% auto;
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
animation: gradient-shift 3s ease infinite;
margin-bottom: 15px;
}
@keyframes gradient-shift {
0%, 100% { background-position: 0% center; }
50% { background-position: 100% center; }
}
.hero-subtitle {
font-family: 'JetBrains Mono', monospace;
font-size: 1.1rem;
color: var(--text-secondary);
letter-spacing: 2px;
}
.hero-badge {
display: inline-block;
margin-top: 20px;
padding: 8px 20px;
background: var(--bg-tertiary);
border: 1px solid var(--accent-cyan);
border-radius: 4px;
font-family: 'JetBrains Mono', monospace;
font-size: 0.85rem;
color: var(--accent-cyan);
}
/* Navigation */
.nav-container {
position: sticky;
top: 0;
z-index: 1000;
background: rgba(10, 10, 15, 0.95);
backdrop-filter: blur(10px);
border-bottom: 1px solid var(--border-color);
padding: 15px 40px;
}
.nav-list {
display: flex;
flex-wrap: wrap;
gap: 10px;
justify-content: center;
list-style: none;
max-width: 1400px;
margin: 0 auto;
}
.nav-item a {
display: flex;
align-items: center;
gap: 8px;
padding: 8px 16px;
background: var(--bg-tertiary);
border: 1px solid var(--border-color);
border-radius: 4px;
color: var(--text-secondary);
text-decoration: none;
font-size: 0.85rem;
font-weight: 500;
transition: all 0.2s ease;
}
.nav-item a:hover {
background: var(--bg-card);
border-color: var(--accent-cyan);
color: var(--accent-cyan);
box-shadow: var(--glow-cyan);
}
.nav-num {
font-family: 'Orbitron', sans-serif;
font-weight: 700;
font-size: 0.75rem;
}
/* Main Content */
.main-content {
max-width: 1600px;
margin: 0 auto;
padding: 40px;
}
/* Section Styling */
.section {
margin-bottom: 60px;
animation: fade-in 0.5s ease;
}
@keyframes fade-in {
from { opacity: 0; transform: translateY(20px); }
to { opacity: 1; transform: translateY(0); }
}
.section-header {
display: flex;
align-items: center;
gap: 20px;
margin-bottom: 30px;
padding-bottom: 15px;
border-bottom: 2px solid var(--border-color);
}
.section-number {
font-family: 'Orbitron', sans-serif;
font-size: 3rem;
font-weight: 900;
color: var(--accent-cyan);
text-shadow: var(--glow-cyan);
line-height: 1;
}
.section-title {
font-family: 'Orbitron', sans-serif;
font-size: 1.5rem;
font-weight: 600;
text-transform: uppercase;
letter-spacing: 2px;
color: var(--text-primary);
}
/* Cards Grid */
.cards-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(450px, 1fr));
gap: 25px;
}
.card {
background: var(--bg-card);
border: 1px solid var(--border-color);
border-radius: 8px;
padding: 25px;
transition: all 0.3s ease;
position: relative;
overflow: hidden;
}
.card::before {
content: '';
position: absolute;
top: 0;
left: 0;
width: 4px;
height: 100%;
background: linear-gradient(180deg, var(--accent-cyan), var(--accent-magenta));
}
.card:hover {
border-color: var(--accent-cyan);
transform: translateY(-3px);
box-shadow: 0 10px 40px rgba(0, 0, 0, 0.3);
}
.card-title {
font-family: 'Orbitron', sans-serif;
font-size: 1rem;
font-weight: 600;
color: var(--accent-cyan);
margin-bottom: 15px;
text-transform: uppercase;
letter-spacing: 1px;
}
.card-content {
color: var(--text-secondary);
font-size: 0.95rem;
}
.card-content p {
margin-bottom: 12px;
}
.card-content p:last-child {
margin-bottom: 0;
}
/* Code Blocks */
.code-block {
background: var(--bg-primary);
border: 1px solid var(--border-color);
border-radius: 6px;
padding: 15px;
margin: 15px 0;
overflow-x: auto;
position: relative;
}
.code-block::before {
content: attr(data-lang);
position: absolute;
top: 8px;
right: 12px;
font-size: 0.7rem;
color: var(--text-muted);
text-transform: uppercase;
letter-spacing: 1px;
}
.code-block code {
font-family: 'JetBrains Mono', monospace;
font-size: 0.85rem;
color: var(--text-primary);
line-height: 1.6;
}
.code-block .comment { color: var(--text-muted); }
.code-block .keyword { color: var(--accent-magenta); }
.code-block .register { color: var(--accent-cyan); }
.code-block .number { color: var(--accent-orange); }
.code-block .string { color: var(--accent-green); }
.code-block .label { color: var(--accent-yellow); }
.code-block .directive { color: var(--accent-purple); }
/* Tables */
.table-container {
overflow-x: auto;
margin: 15px 0;
border-radius: 6px;
border: 1px solid var(--border-color);
}
table {
width: 100%;
border-collapse: collapse;
font-size: 0.9rem;
}
th {
background: var(--bg-tertiary);
padding: 12px 15px;
text-align: left;
font-family: 'Orbitron', sans-serif;
font-size: 0.8rem;
font-weight: 600;
text-transform: uppercase;
letter-spacing: 1px;
color: var(--accent-cyan);
border-bottom: 2px solid var(--accent-cyan);
}
td {
padding: 12px 15px;
border-bottom: 1px solid var(--border-color);
color: var(--text-secondary);
}
tr:hover td {
background: rgba(0, 245, 255, 0.05);
}
td code {
font-family: 'JetBrains Mono', monospace;
font-size: 0.85rem;
color: var(--accent-green);
background: var(--bg-primary);
padding: 2px 6px;
border-radius: 3px;
}
/* Diagrams */
.diagram {
background: var(--bg-primary);
border: 1px solid var(--border-color);
border-radius: 6px;
padding: 20px;
margin: 15px 0;
font-family: 'JetBrains Mono', monospace;
font-size: 0.8rem;
line-height: 1.4;
color: var(--accent-cyan);
overflow-x: auto;
white-space: pre;
}
/* Formula Boxes */
.formula-box {
background: linear-gradient(135deg, rgba(136, 85, 255, 0.1) 0%, rgba(0, 245, 255, 0.1) 100%);
border: 1px solid var(--accent-purple);
border-radius: 6px;
padding: 15px 20px;
margin: 15px 0;
font-family: 'JetBrains Mono', monospace;
font-size: 0.95rem;
color: var(--text-primary);
}
.formula-box .formula-title {
font-size: 0.75rem;
color: var(--accent-purple);
text-transform: uppercase;
letter-spacing: 1px;
margin-bottom: 8px;
}
/* Key Points */
.key-point {
display: flex;
align-items: flex-start;
gap: 12px;
padding: 12px;
background: rgba(0, 255, 136, 0.05);
border-left: 3px solid var(--accent-green);
border-radius: 0 6px 6px 0;
margin: 10px 0;
}
.key-point-icon {
color: var(--accent-green);
font-size: 1.2rem;
}
/* Warning Box */
.warning-box {
background: rgba(255, 68, 85, 0.1);
border: 1px solid var(--accent-red);
border-radius: 6px;
padding: 15px;
margin: 15px 0;
}
.warning-box-title {
display: flex;
align-items: center;
gap: 8px;
color: var(--accent-red);
font-weight: 600;
margin-bottom: 8px;
}
/* Subsection */
.subsection {
margin: 25px 0;
}
.subsection-title {
font-family: 'Orbitron', sans-serif;
font-size: 1.1rem;
font-weight: 600;
color: var(--accent-magenta);
margin-bottom: 15px;
padding-left: 15px;
border-left: 3px solid var(--accent-magenta);
}
/* Lists */
.styled-list {
list-style: none;
padding: 0;
}
.styled-list li {
position: relative;
padding-left: 25px;
margin-bottom: 10px;
color: var(--text-secondary);
}
.styled-list li::before {
content: '▸';
position: absolute;
left: 0;
color: var(--accent-cyan);
}
/* Full Width Card */
.card-full {
grid-column: 1 / -1;
}
/* Two Column Layout */
.two-col {
display: grid;
grid-template-columns: repeat(2, 1fr);
gap: 20px;
}
@media (max-width: 768px) {
.two-col {
grid-template-columns: 1fr;
}
.cards-grid {
grid-template-columns: 1fr;
}
}
/* Comparison */
.comparison {
display: grid;
grid-template-columns: repeat(2, 1fr);
gap: 15px;
margin: 15px 0;
}
.comparison-item {
padding: 15px;
border-radius: 6px;
}
.comparison-item.pros {
background: rgba(0, 255, 136, 0.1);
border: 1px solid var(--accent-green);
}
.comparison-item.cons {
background: rgba(255, 68, 85, 0.1);
border: 1px solid var(--accent-red);
}
.comparison-title {
font-weight: 600;
margin-bottom: 10px;
}
.comparison-item.pros .comparison-title { color: var(--accent-green); }
.comparison-item.cons .comparison-title { color: var(--accent-red); }
/* Inline Code */
code {
font-family: 'JetBrains Mono', monospace;
background: var(--bg-tertiary);
padding: 2px 6px;
border-radius: 3px;
font-size: 0.9em;
color: var(--accent-cyan);
}
/* Highlight */
.highlight {
color: var(--accent-yellow);
font-weight: 500;
}
/* Conversion Example */
.conversion-example {
background: var(--bg-primary);
border: 1px solid var(--border-color);
border-radius: 6px;
padding: 15px;
margin: 10px 0;
}
.conversion-step {
display: flex;
align-items: center;
gap: 10px;
margin: 8px 0;
font-family: 'JetBrains Mono', monospace;
font-size: 0.9rem;
}
.conversion-arrow {
color: var(--accent-magenta);
}
/* Pipeline Diagram */
.pipeline {
display: flex;
gap: 5px;
margin: 15px 0;
overflow-x: auto;
padding: 10px 0;
}
.pipeline-stage {
flex: 1;
min-width: 100px;
padding: 15px 10px;
text-align: center;
background: var(--bg-tertiary);
border: 1px solid var(--border-color);
border-radius: 6px;
position: relative;
}
.pipeline-stage::after {
content: '→';
position: absolute;
right: -15px;
top: 50%;
transform: translateY(-50%);
color: var(--accent-cyan);
font-size: 1.2rem;
}
.pipeline-stage:last-child::after {
display: none;
}
.pipeline-name {
font-family: 'Orbitron', sans-serif;
font-size: 0.9rem;
font-weight: 600;
color: var(--accent-cyan);
margin-bottom: 5px;
}
.pipeline-desc {
font-size: 0.75rem;
color: var(--text-muted);
}
/* Memory Hierarchy */
.memory-pyramid {
display: flex;
flex-direction: column;
align-items: center;
margin: 20px 0;
gap: 5px;
}
.memory-level {
display: flex;
justify-content: center;
align-items: center;
text-align: center;
padding: 15px;
border-radius: 4px;
font-family: 'JetBrains Mono', monospace;
font-size: 0.85rem;
position: relative;
}
.memory-level:nth-child(1) {
width: 30%;
background: linear-gradient(135deg, var(--accent-cyan), var(--accent-magenta));
color: var(--bg-primary);
font-weight: 600;
}
.memory-level:nth-child(2) {
width: 45%;
background: var(--accent-green);
color: var(--bg-primary);
}
.memory-level:nth-child(3) {
width: 60%;
background: var(--accent-orange);
color: var(--bg-primary);
}
.memory-level:nth-child(4) {
width: 75%;
background: var(--accent-purple);
color: var(--text-primary);
}
.memory-level:nth-child(5) {
width: 90%;
background: var(--bg-tertiary);
border: 1px solid var(--border-color);
color: var(--text-secondary);
}
/* Bit Display */
.bit-display {
display: flex;
gap: 2px;
margin: 10px 0;
font-family: 'JetBrains Mono', monospace;
}
.bit {
width: 35px;
height: 35px;
display: flex;
align-items: center;
justify-content: center;
background: var(--bg-tertiary);
border: 1px solid var(--border-color);
border-radius: 4px;
font-size: 0.9rem;
}
.bit.sign {
background: var(--accent-magenta);
color: var(--bg-primary);
font-weight: 600;
}
.bit.highlight {
border-color: var(--accent-cyan);
color: var(--accent-cyan);
}
/* Footer */
.footer {
text-align: center;
padding: 40px;
border-top: 1px solid var(--border-color);
color: var(--text-muted);
font-size: 0.85rem;
}
.footer-title {
font-family: 'Orbitron', sans-serif;
color: var(--accent-cyan);
margin-bottom: 10px;
}
/* Scrollbar */
::-webkit-scrollbar {
width: 8px;
height: 8px;
}
::-webkit-scrollbar-track {
background: var(--bg-secondary);
}
::-webkit-scrollbar-thumb {
background: var(--border-color);
border-radius: 4px;
}
::-webkit-scrollbar-thumb:hover {
background: var(--accent-cyan);
}
/* Print Styles */
@media print {
body::before { display: none; }
.nav-container { display: none; }
.card { break-inside: avoid; }
}
</style>
</head>
<body>
<!-- Hero Section -->
<header class="hero">
<h1 class="hero-title">CSE 230</h1>
<p class="hero-subtitle">Computer Organization & Assembly Language</p>
<span class="hero-badge">// COMPLETE REFERENCE GUIDE</span>
</header>
<!-- Navigation -->
<nav class="nav-container">
<ul class="nav-list">
<li class="nav-item"><a href="#section1"><span class="nav-num">01</span> Program Execution</a></li>
<li class="nav-item"><a href="#section2"><span class="nav-num">02</span> Performance</a></li>
<li class="nav-item"><a href="#section3"><span class="nav-num">03</span> Data Representation</a></li>
<li class="nav-item"><a href="#section4"><span class="nav-num">04</span> Assembly Programming</a></li>
<li class="nav-item"><a href="#section5"><span class="nav-num">05</span> Hardware Optimization</a></li>
<li class="nav-item"><a href="#section6"><span class="nav-num">06</span> Datapath Design</a></li>
<li class="nav-item"><a href="#section7"><span class="nav-num">07</span> Memory Hierarchy</a></li>
<li class="nav-item"><a href="#section8"><span class="nav-num">08</span> Multiprocessors</a></li>
</ul>
</nav>
<!-- Main Content -->
<main class="main-content">
<!-- SECTION 1: Program Execution -->
<section id="section1" class="section">
<div class="section-header">
<span class="section-number">01</span>
<h2 class="section-title">How Programs Execute on a Computer</h2>
</div>
<div class="cards-grid">
<!-- CPU Components -->
<div class="card">
<h3 class="card-title">Basic Components of CPU Design</h3>
<div class="card-content">
<div class="diagram">
┌─────────────────────────────────────────────────────────────────┐
│ CPU │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Control │ │ ALU │ │ Registers │ │
│ │ Unit │◄──►│ (Arithmetic │◄──►│ (Fast │ │
│ │ (Fetches & │ │ Logic Unit) │ │ Storage) │ │
│ │ Decodes) │ │ │ │ │ │
│ └──────┬───────┘ └──────────────┘ └──────────────┘ │
│ │ ▲ ▲ │
│ ▼ │ │ │
│ ┌──────────────┐ │ │ │
│ │Program Counter│ └───────────────────┘ │
│ │ (PC) │ │ │
│ └──────────────┘ ▼ │
│ ┌──────────────┐ │
│ │ Data Bus │ │
└───────────────────────────┴──────────────┴───────────────────────┘
│
▼
┌──────────────┐
│ Memory │
└──────────────┘</div>
<ul class="styled-list">
<li><strong>Control Unit (CU)</strong> — Directs operations, fetches instructions, decodes opcodes, generates control signals</li>
<li><strong>Arithmetic Logic Unit (ALU)</strong> — Performs arithmetic (+, -, ×, ÷) and logical (AND, OR, XOR, NOT) operations</li>
<li><strong>Registers</strong> — Ultra-fast storage inside CPU (general purpose, special purpose like PC, SP, IR)</li>
<li><strong>Program Counter (PC)</strong> — Holds address of next instruction to execute</li>
<li><strong>Instruction Register (IR)</strong> — Holds currently executing instruction</li>
<li><strong>Memory Address Register (MAR)</strong> — Holds address for memory access</li>
<li><strong>Memory Data Register (MDR)</strong> — Holds data being transferred to/from memory</li>
<li><strong>Stack Pointer (SP)</strong> — Points to top of the stack in memory</li>
</ul>
</div>
</div>
<!-- Compilation Process -->
<div class="card">
<h3 class="card-title">Program Compilation Process</h3>
<div class="card-content">
<div class="diagram">
┌─────────────────┐
│ Source Code │ (.c, .cpp, .java)
│ (High-Level) │
└────────┬────────┘
│
▼ [Preprocessor]
┌─────────────────┐
│ Expanded Code │ (includes, macros resolved)
└────────┬────────┘
│
▼ [Compiler]
┌─────────────────┐
│ Assembly Code │ (.s, .asm)
└────────┬────────┘
│
▼ [Assembler]
┌─────────────────┐
│ Object Code │ (.o, .obj) - machine code + symbols
└────────┬────────┘
│
▼ [Linker]
┌─────────────────┐
│ Executable │ (.exe, .out) - complete binary
└────────┬────────┘
│
▼ [Loader]
┌─────────────────┐
│ Process in │ Running in RAM
│ Memory │
└─────────────────┘</div>
<div class="key-point">
<span class="key-point-icon">★</span>
<span>The <strong>compiler</strong> translates high-level to assembly. The <strong>assembler</strong> converts assembly to machine code. The <strong>linker</strong> combines object files and resolves external references.</span>
</div>
</div>
</div>
<!-- Instruction Cycle -->
<div class="card card-full">
<h3 class="card-title">Stages of the Instruction Cycle (Fetch-Decode-Execute)</h3>
<div class="card-content">
<div class="pipeline">
<div class="pipeline-stage">
<div class="pipeline-name">FETCH</div>
<div class="pipeline-desc">Get instruction from memory at PC address</div>
</div>
<div class="pipeline-stage">
<div class="pipeline-name">DECODE</div>
<div class="pipeline-desc">Interpret opcode & identify operands</div>
</div>
<div class="pipeline-stage">
<div class="pipeline-name">EXECUTE</div>
<div class="pipeline-desc">Perform the operation (ALU, branch, etc.)</div>
</div>
<div class="pipeline-stage">
<div class="pipeline-name">MEMORY</div>
<div class="pipeline-desc">Access memory if needed (load/store)</div>
</div>
<div class="pipeline-stage">
<div class="pipeline-name">WRITEBACK</div>
<div class="pipeline-desc">Write result to register</div>
</div>
</div>
<div class="subsection">
<h4 class="subsection-title">Detailed Breakdown</h4>
<div class="table-container">
<table>
<thead>
<tr>
<th>Stage</th>
<th>Actions</th>
<th>Hardware Used</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>FETCH</code></td>
<td>MAR ← PC; IR ← Memory[MAR]; PC ← PC + 4</td>
<td>PC, MAR, MDR, IR, Memory</td>
</tr>
<tr>
<td><code>DECODE</code></td>
<td>Extract opcode, read source registers, sign-extend immediate</td>
<td>Control Unit, Register File</td>
</tr>
<tr>
<td><code>EXECUTE</code></td>
<td>ALU computes result or calculates branch target address</td>
<td>ALU, Branch Unit</td>
</tr>
<tr>
<td><code>MEMORY</code></td>
<td>Load: read from memory; Store: write to memory</td>
<td>Data Memory, Cache</td>
</tr>
<tr>
<td><code>WRITEBACK</code></td>
<td>Write ALU result or loaded data to destination register</td>
<td>Register File</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
</div>
</div>
</section>
<!-- SECTION 2: Performance -->
<section id="section2" class="section">
<div class="section-header">
<span class="section-number">02</span>
<h2 class="section-title">Hardware Factors & Performance</h2>
</div>
<div class="cards-grid">
<!-- Measuring Performance -->
<div class="card">
<h3 class="card-title">Measuring & Comparing Performance</h3>
<div class="card-content">
<div class="formula-box">
<div class="formula-title">CPU Performance Equation</div>
CPU Time = Instructions × CPI × Clock Period<br>
CPU Time = (Instruction Count × CPI) / Clock Rate
</div>
<ul class="styled-list">
<li><strong>Instruction Count</strong> — Total instructions executed (depends on ISA, compiler)</li>
<li><strong>CPI (Cycles Per Instruction)</strong> — Average clock cycles per instruction</li>
<li><strong>Clock Rate (Hz)</strong> — Cycles per second (e.g., 3 GHz = 3×10⁹ cycles/sec)</li>
<li><strong>Clock Period</strong> — Time for one cycle = 1/Clock Rate</li>
</ul>
<div class="formula-box">
<div class="formula-title">MIPS (Million Instructions Per Second)</div>
MIPS = Instruction Count / (Execution Time × 10⁶)<br>
MIPS = Clock Rate / (CPI × 10⁶)
</div>
<div class="warning-box">
<div class="warning-box-title">⚠ MIPS Pitfalls</div>
MIPS can be misleading — different ISAs have different instruction complexities. A CISC machine might do more work per instruction than a RISC machine.
</div>
</div>
</div>
<!-- Propagation Delay -->
<div class="card">
<h3 class="card-title">Propagation Delay</h3>
<div class="card-content">
<p><strong>Definition:</strong> Time for a signal to travel through a circuit component from input to stable output.</p>
<div class="diagram">
Input ──┐ ┌── Output
│ Component │
└──────────────┘
│←── t_pd ────→│
t_pd = propagation delay</div>
<ul class="styled-list">
<li><strong>Gate Delay</strong> — Time through a single logic gate (typically 1-10 ns)</li>
<li><strong>Wire Delay</strong> — Signal travel time through interconnects</li>
<li><strong>Critical Path</strong> — Longest delay path determines max clock speed</li>
</ul>
<div class="formula-box">
<div class="formula-title">Maximum Clock Frequency</div>
f_max = 1 / t_critical_path<br>
<br>
Clock Period ≥ t_propagation + t_setup
</div>
<div class="key-point">
<span class="key-point-icon">★</span>
<span>Reducing propagation delay allows higher clock frequencies but may require more power or better silicon technology.</span>
</div>
</div>
</div>
<!-- Clock Speed -->
<div class="card">
<h3 class="card-title">Influence of Clock Speed on Performance</h3>
<div class="card-content">
<p>Clock speed (frequency) determines how many cycles execute per second.</p>
<div class="comparison">
<div class="comparison-item pros">
<div class="comparison-title">✓ Higher Clock Speed Benefits</div>
<ul class="styled-list">
<li>More operations per second</li>
<li>Faster instruction throughput</li>
<li>Better single-thread performance</li>
</ul>
</div>
<div class="comparison-item cons">
<div class="comparison-title">✗ Higher Clock Speed Costs</div>
<ul class="styled-list">
<li>Increased power consumption (P ∝ f)</li>
<li>More heat generation</li>
<li>Higher voltage requirements</li>
<li>Diminishing returns</li>
</ul>
</div>
</div>
<div class="formula-box">
<div class="formula-title">Power-Frequency Relationship</div>
P_dynamic = α × C × V² × f<br>
<br>
Where: α = activity factor, C = capacitance,<br>
V = voltage, f = frequency
</div>
</div>
</div>
<!-- Computer Architecture -->
<div class="card">
<h3 class="card-title">Computer Architecture & Performance</h3>
<div class="card-content">
<div class="subsection">
<h4 class="subsection-title">Architecture Types</h4>
<div class="table-container">
<table>
<thead>
<tr>
<th>Aspect</th>
<th>RISC</th>
<th>CISC</th>
</tr>
</thead>
<tbody>
<tr>
<td>Instructions</td>
<td>Simple, fixed-length</td>
<td>Complex, variable-length</td>
</tr>
<tr>
<td>CPI</td>
<td>~1 (ideally)</td>
<td>Variable (1-20+)</td>
</tr>
<tr>
<td>Memory Access</td>
<td>Load/Store only</td>
<td>Memory operands allowed</td>
</tr>
<tr>
<td>Registers</td>
<td>Many (32+)</td>
<td>Fewer</td>
</tr>
<tr>
<td>Pipelining</td>
<td>Easy to pipeline</td>
<td>Harder to pipeline</td>
</tr>
<tr>
<td>Examples</td>
<td>ARM, MIPS, RISC-V</td>
<td>x86, x86-64</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
</div>
<!-- Architecture & ISA Relationship -->
<div class="card card-full">
<h3 class="card-title">Relationship Between Architecture & Instruction Set</h3>
<div class="card-content">
<div class="two-col">
<div>
<p><strong>Instruction Set Architecture (ISA)</strong> is the interface between hardware and software — the "contract" specifying:</p>
<ul class="styled-list">
<li>Available instructions and their encoding</li>
<li>Registers and their purposes</li>
<li>Addressing modes</li>
<li>Data types and sizes</li>
<li>Memory model</li>
</ul>
</div>
<div>
<p><strong>Microarchitecture</strong> is how the ISA is implemented in hardware:</p>
<ul class="styled-list">
<li>Pipeline depth and organization</li>
<li>Cache sizes and hierarchy</li>
<li>Branch prediction strategy</li>
<li>Out-of-order execution</li>
<li>Superscalar width</li>
</ul>
</div>
</div>
<div class="key-point">
<span class="key-point-icon">★</span>
<span>Same ISA (e.g., x86-64) can have different microarchitectures (Intel Skylake vs AMD Zen) with vastly different performance characteristics.</span>
</div>
</div>
</div>
<!-- Execution Time Prediction -->
<div class="card card-full">
<h3 class="card-title">Predicting Execution Time</h3>
<div class="card-content">
<p>Given CPU architecture details, predict execution time by considering:</p>
<div class="two-col">
<div>
<div class="subsection-title">Datapath Design</div>
<ul class="styled-list">
<li><strong>Single-cycle:</strong> CPI = 1, but slow clock</li>
<li><strong>Multi-cycle:</strong> Variable CPI, faster clock</li>
<li><strong>Pipelined:</strong> CPI ≈ 1, fast clock, hazards add stalls</li>
</ul>
</div>
<div>
<div class="subsection-title">Branch Prediction Impact</div>
<ul class="styled-list">
<li>Misprediction penalty = pipeline depth</li>
<li>90% accuracy with 10-stage pipeline:</li>
<li>Extra CPI = 0.10 × 10 = 1.0 cycles/branch</li>
</ul>
</div>
</div>
<div class="formula-box">
<div class="formula-title">Effective CPI Calculation</div>
CPI_effective = CPI_base + (branch_freq × mispredict_rate × penalty)<br>
+ (mem_access_freq × miss_rate × miss_penalty)<br>
<br>
Example: CPI = 1.0 + (0.2 × 0.1 × 10) + (0.3 × 0.05 × 100)<br>
= 1.0 + 0.2 + 1.5 = 2.7 cycles/instruction
</div>
</div>
</div>
</div>
</section>
<!-- SECTION 3: Data Representation -->
<section id="section3" class="section">
<div class="section-header">
<span class="section-number">03</span>
<h2 class="section-title">Data Representation & Addressing Modes</h2>
</div>
<div class="cards-grid">
<!-- Number Systems -->
<div class="card">
<h3 class="card-title">Binary & Hexadecimal Number Systems</h3>
<div class="card-content">
<div class="table-container">
<table>
<thead>
<tr>
<th>Decimal</th>
<th>Binary</th>
<th>Hex</th>
<th>Decimal</th>
<th>Binary</th>
<th>Hex</th>
</tr>
</thead>
<tbody>
<tr><td>0</td><td>0000</td><td>0</td><td>8</td><td>1000</td><td>8</td></tr>
<tr><td>1</td><td>0001</td><td>1</td><td>9</td><td>1001</td><td>9</td></tr>
<tr><td>2</td><td>0010</td><td>2</td><td>10</td><td>1010</td><td>A</td></tr>
<tr><td>3</td><td>0011</td><td>3</td><td>11</td><td>1011</td><td>B</td></tr>
<tr><td>4</td><td>0100</td><td>4</td><td>12</td><td>1100</td><td>C</td></tr>
<tr><td>5</td><td>0101</td><td>5</td><td>13</td><td>1101</td><td>D</td></tr>
<tr><td>6</td><td>0110</td><td>6</td><td>14</td><td>1110</td><td>E</td></tr>
<tr><td>7</td><td>0111</td><td>7</td><td>15</td><td>1111</td><td>F</td></tr>
</tbody>
</table>
</div>
<div class="key-point">
<span class="key-point-icon">★</span>
<span>Each hex digit = exactly 4 binary bits. This is why hex is used — compact representation of binary.</span>
</div>
<div class="formula-box">
<div class="formula-title">Powers of 2 (Memorize These!)</div>
2⁰=1 2¹=2 2²=4 2³=8 2⁴=16 2⁵=32<br>
2⁶=64 2⁷=128 2⁸=256 2⁹=512 2¹⁰=1024<br>
2¹⁶=65,536 2³²=4,294,967,296
</div>
</div>
</div>
<!-- Binary Arithmetic -->
<div class="card">
<h3 class="card-title">Binary Addition & Subtraction</h3>
<div class="card-content">
<div class="subsection-title">Binary Addition Rules</div>
<div class="code-block" data-lang="rules">
<code> 0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 0 (carry 1)
1 + 1 + 1 = 1 (carry 1)</code></div>
<div class="conversion-example">
<strong>Example: 1011 + 0110</strong>
<div class="conversion-step">
<code>
1 1 1 ← carries
1 0 1 1
+ 0 1 1 0
---------
1 0 0 0 1 = 17₁₀ (11 + 6 = 17 ✓)
</code>
</div>
</div>
<div class="subsection-title">Binary Subtraction (Using 2's Complement)</div>
<p>A - B = A + (-B) = A + (2's complement of B)</p>
<div class="conversion-example">
<strong>Example: 1010 - 0011 (10 - 3 = 7)</strong>
<div class="conversion-step">
<code>
2's complement of 0011:
Invert: 1100
Add 1: 1101
Now add: 1010 + 1101
1 1
1 0 1 0
+ 1 1 0 1
---------
1 0 1 1 1 (ignore overflow bit)
= 0111 = 7₁₀ ✓
</code>
</div>
</div>
</div>
</div>
<!-- Decimal to Binary -->
<div class="card">
<h3 class="card-title">Decimal ↔ Binary Conversion</h3>
<div class="card-content">
<div class="subsection-title">Decimal to Binary (Divide by 2)</div>
<div class="conversion-example">
<strong>Convert 45₁₀ to binary:</strong>
<div class="conversion-step">
<code>
45 ÷ 2 = 22 remainder 1 ↑
22 ÷ 2 = 11 remainder 0 │
11 ÷ 2 = 5 remainder 1 │ Read
5 ÷ 2 = 2 remainder 1 │ bottom
2 ÷ 2 = 1 remainder 0 │ to top
1 ÷ 2 = 0 remainder 1 │
Answer: 101101₂
</code>
</div>
</div>
<div class="subsection-title">Binary to Decimal (Positional Weights)</div>
<div class="conversion-example">
<strong>Convert 101101₂ to decimal:</strong>
<div class="conversion-step">
<code>
Position: 5 4 3 2 1 0
Binary: 1 0 1 1 0 1
Weight: 32 16 8 4 2 1
= 1×32 + 0×16 + 1×8 + 1×4 + 0×2 + 1×1
= 32 + 8 + 4 + 1 = 45₁₀ ✓
</code>
</div>
</div>
</div>
</div>
<!-- Decimal to Hex -->
<div class="card">
<h3 class="card-title">Decimal ↔ Hexadecimal Conversion</h3>
<div class="card-content">
<div class="subsection-title">Decimal to Hex (Divide by 16)</div>
<div class="conversion-example">
<strong>Convert 255₁₀ to hex:</strong>
<div class="conversion-step">
<code>
255 ÷ 16 = 15 remainder 15 (F) ↑
15 ÷ 16 = 0 remainder 15 (F) │
Answer: FF₁₆ (or 0xFF)
</code>
</div>
</div>
<div class="subsection-title">Hex to Decimal</div>
<div class="conversion-example">
<strong>Convert 2A3₁₆ to decimal:</strong>
<div class="conversion-step">
<code>
2A3₁₆ = 2×16² + A×16¹ + 3×16⁰
= 2×256 + 10×16 + 3×1
= 512 + 160 + 3
= 675₁₀
</code>
</div>
</div>
<div class="subsection-title">Binary ↔ Hex (Group by 4)</div>
<div class="conversion-example">
<strong>Binary to Hex: 11010110₂</strong>
<div class="conversion-step">
<code>
1101 0110
D 6 → D6₁₆
</code>
</div>
</div>
</div>
</div>
<!-- Signed Binary -->
<div class="card card-full">
<h3 class="card-title">Signed Binary Representation</h3>
<div class="card-content">
<div class="two-col">
<div>
<div class="subsection-title">Two's Complement (Standard Method)</div>
<p>For n-bit number, range is: -2^(n-1) to 2^(n-1)-1</p>
<p>8-bit range: -128 to +127</p>
<div class="conversion-example">
<strong>Converting -45 to 8-bit two's complement:</strong>
<div class="conversion-step">
<code>
Step 1: +45 in binary = 00101101
Step 2: Invert all bits = 11010010
Step 3: Add 1 = 11010011
-45₁₀ = 11010011₂
</code>
</div>
</div>
<div class="bit-display">
<div class="bit sign">1</div>
<div class="bit">1</div>
<div class="bit">0</div>
<div class="bit">1</div>
<div class="bit">0</div>
<div class="bit">0</div>
<div class="bit">1</div>
<div class="bit">1</div>
</div>
<p style="font-size: 0.85rem; color: var(--text-muted);">MSB (sign bit): 1 = negative, 0 = positive</p>
</div>
<div>
<div class="subsection-title">Two's Complement Values (8-bit)</div>
<div class="table-container">
<table>
<thead>
<tr>
<th>Binary</th>
<th>Unsigned</th>
<th>Signed</th>
</tr>
</thead>
<tbody>
<tr><td><code>00000000</code></td><td>0</td><td>0</td></tr>
<tr><td><code>00000001</code></td><td>1</td><td>+1</td></tr>
<tr><td><code>01111111</code></td><td>127</td><td>+127</td></tr>
<tr><td><code>10000000</code></td><td>128</td><td>-128</td></tr>
<tr><td><code>10000001</code></td><td>129</td><td>-127</td></tr>
<tr><td><code>11111111</code></td><td>255</td><td>-1</td></tr>
</tbody>
</table>
</div>
<div class="conversion-example">
<strong>Reading negative: 11010011₂</strong>
<div class="conversion-step">
<code>
MSB is 1 → negative number
Invert: 00101100
Add 1: 00101101 = 45
Answer: -45
</code>
</div>
</div>
</div>
</div>
</div>
</div>
<!-- Endianness -->
<div class="card">
<h3 class="card-title">Big-Endian vs Little-Endian</h3>
<div class="card-content">
<p>How multi-byte values are stored in memory.</p>
<p>Example: Store 0x12345678 at address 0x100</p>
<div class="diagram">
Big-Endian (MSB First)
Address: 0x100 0x101 0x102 0x103
Data: 12 34 56 78
[MSB] [LSB]
Little-Endian (LSB First)
Address: 0x100 0x101 0x102 0x103
Data: 78 56 34 12
[LSB] [MSB]</div>
<div class="table-container">
<table>
<thead>
<tr>
<th>Type</th>
<th>Description</th>
<th>Used By</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Big-Endian</strong></td>
<td>Most significant byte at lowest address</td>
<td>Network protocols, MIPS, SPARC</td>
</tr>
<tr>
<td><strong>Little-Endian</strong></td>
<td>Least significant byte at lowest address</td>
<td>x86, x86-64, ARM (configurable)</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<!-- Overflow/Underflow -->
<div class="card">
<h3 class="card-title">Data Overflow & Underflow</h3>
<div class="card-content">
<div class="warning-box">
<div class="warning-box-title">⚠ Overflow</div>
Occurs when result is too large for the number of bits.
</div>
<div class="subsection-title">Unsigned Overflow</div>
<div class="conversion-example">
<code>
8-bit max = 255 (11111111)
255 + 1 = 256... but 256 = 100000000 (9 bits!)
Result wraps to 0 (overflow)
</code>
</div>
<div class="subsection-title">Signed Overflow Detection</div>
<ul class="styled-list">
<li>Positive + Positive = Negative → Overflow!</li>
<li>Negative + Negative = Positive → Overflow!</li>
<li>Positive + Negative → Cannot overflow</li>
</ul>
<div class="conversion-example">
<strong>Example: 8-bit signed, 100 + 50</strong>
<code>
01100100 (100)
+ 00110010 (50)
= 10010110 = -106 in signed! (overflow)
</code>
</div>
<div class="key-point">
<span class="key-point-icon">★</span>
<span><strong>Underflow</strong> is the opposite — result too small (negative overflow). Same detection rules apply.</span>
</div>
</div>
</div>
<!-- Assembly to Machine -->
<div class="card card-full">
<h3 class="card-title">Assembly Language to Machine Language Translation</h3>
<div class="card-content">
<p>The assembler converts human-readable assembly into binary machine code using the ISA specification.</p>
<div class="subsection-title">MIPS Instruction Formats (32-bit)</div>
<div class="diagram">
R-Type (Register):
┌────────┬───────┬───────┬───────┬───────┬────────┐
│ opcode │ rs │ rt │ rd │ shamt │ funct │
│ 6 bits │ 5 bits│ 5 bits│ 5 bits│ 5 bits│ 6 bits │
└────────┴───────┴───────┴───────┴───────┴────────┘
I-Type (Immediate):
┌────────┬───────┬───────┬─────────────────────────┐
│ opcode │ rs │ rt │ immediate │
│ 6 bits │ 5 bits│ 5 bits│ 16 bits │
└────────┴───────┴───────┴─────────────────────────┘
J-Type (Jump):
┌────────┬────────────────────────────────────────┐
│ opcode │ address │
│ 6 bits │ 26 bits │
└────────┴────────────────────────────────────────┘</div>
<div class="subsection-title">Translation Example</div>
<div class="code-block" data-lang="assembly">
<code><span class="comment"># Assembly instruction:</span>
<span class="keyword">add</span> <span class="register">$t0</span>, <span class="register">$s1</span>, <span class="register">$s2</span>
<span class="comment"># Register numbers:</span>
<span class="comment"># $t0 = $8, $s1 = $17, $s2 = $18</span>
<span class="comment"># R-Type encoding:</span>
<span class="comment"># opcode=0, rs=$s1=17, rt=$s2=18, rd=$t0=8, shamt=0, funct=32</span>
<span class="comment"># Binary:</span>
<span class="comment"># 000000 10001 10010 01000 00000 100000</span>
<span class="comment"># Hex: 0x02324020</span></code></div>
<div class="table-container">
<table>
<thead>
<tr>
<th>Field</th>
<th>Value</th>
<th>Binary</th>
</tr>
</thead>
<tbody>
<tr><td>opcode</td><td>0</td><td>000000</td></tr>
<tr><td>rs ($s1)</td><td>17</td><td>10001</td></tr>
<tr><td>rt ($s2)</td><td>18</td><td>10010</td></tr>
<tr><td>rd ($t0)</td><td>8</td><td>01000</td></tr>
<tr><td>shamt</td><td>0</td><td>00000</td></tr>
<tr><td>funct (add)</td><td>32</td><td>100000</td></tr>
</tbody>
</table>
</div>
</div>
</div>
<!-- Addressing Modes -->
<div class="card card-full">
<h3 class="card-title">Addressing Modes</h3>
<div class="card-content">
<div class="table-container">
<table>
<thead>
<tr>
<th>Mode</th>
<th>Description</th>
<th>Example</th>
<th>Effective Address</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Immediate</strong></td>
<td>Operand is part of instruction</td>
<td><code>addi $t0, $t1, 5</code></td>
<td>N/A (value = 5)</td>
</tr>
<tr>
<td><strong>Register</strong></td>
<td>Operand is in a register</td>
<td><code>add $t0, $t1, $t2</code></td>
<td>N/A (value in $t2)</td>
</tr>
<tr>
<td><strong>Base/Displacement</strong></td>
<td>Base register + offset</td>
<td><code>lw $t0, 8($s0)</code></td>
<td>EA = $s0 + 8</td>
</tr>
<tr>
<td><strong>PC-Relative</strong></td>
<td>PC + offset (for branches)</td>
<td><code>beq $t0, $t1, label</code></td>
<td>EA = PC + 4 + offset×4</td>
</tr>
<tr>
<td><strong>Pseudo-Direct</strong></td>
<td>Upper PC bits + address field</td>
<td><code>j target</code></td>
<td>EA = PC[31:28] | addr | 00</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
</div>
</section>
<!-- SECTION 4: Assembly Programming -->
<section id="section4" class="section">
<div class="section-header">
<span class="section-number">04</span>
<h2 class="section-title">Assembly Language Programming</h2>
</div>
<div class="cards-grid">
<!-- MIPS Register Reference -->
<div class="card">
<h3 class="card-title">MIPS Register Convention</h3>
<div class="card-content">
<div class="table-container">
<table>
<thead>
<tr>
<th>Name</th>
<th>Number</th>
<th>Usage</th>
<th>Preserved?</th>
</tr>
</thead>
<tbody>
<tr><td><code>$zero</code></td><td>$0</td><td>Constant 0</td><td>N/A</td></tr>
<tr><td><code>$at</code></td><td>$1</td><td>Assembler temporary</td><td>No</td></tr>
<tr><td><code>$v0-$v1</code></td><td>$2-$3</td><td>Return values</td><td>No</td></tr>
<tr><td><code>$a0-$a3</code></td><td>$4-$7</td><td>Arguments</td><td>No</td></tr>
<tr><td><code>$t0-$t7</code></td><td>$8-$15</td><td>Temporaries</td><td>No</td></tr>
<tr><td><code>$s0-$s7</code></td><td>$16-$23</td><td>Saved registers</td><td>Yes</td></tr>
<tr><td><code>$t8-$t9</code></td><td>$24-$25</td><td>More temporaries</td><td>No</td></tr>
<tr><td><code>$gp</code></td><td>$28</td><td>Global pointer</td><td>Yes</td></tr>
<tr><td><code>$sp</code></td><td>$29</td><td>Stack pointer</td><td>Yes</td></tr>
<tr><td><code>$fp</code></td><td>$30</td><td>Frame pointer</td><td>Yes</td></tr>
<tr><td><code>$ra</code></td><td>$31</td><td>Return address</td><td>Yes</td></tr>
</tbody>
</table>
</div>
</div>
</div>
<!-- Common Instructions -->
<div class="card">
<h3 class="card-title">Essential MIPS Instructions</h3>
<div class="card-content">
<div class="subsection-title">Arithmetic</div>
<div class="code-block" data-lang="mips">
<code><span class="keyword">add</span> <span class="register">$d</span>, <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># $d = $s + $t</span>
<span class="keyword">addi</span> <span class="register">$t</span>, <span class="register">$s</span>, <span class="number">imm</span> <span class="comment"># $t = $s + imm</span>
<span class="keyword">sub</span> <span class="register">$d</span>, <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># $d = $s - $t</span>
<span class="keyword">mul</span> <span class="register">$d</span>, <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># $d = $s × $t (low 32 bits)</span>
<span class="keyword">div</span> <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># lo = $s / $t, hi = $s % $t</span>
<span class="keyword">mflo</span> <span class="register">$d</span> <span class="comment"># $d = lo (quotient)</span>
<span class="keyword">mfhi</span> <span class="register">$d</span> <span class="comment"># $d = hi (remainder)</span></code></div>
<div class="subsection-title">Logical</div>
<div class="code-block" data-lang="mips">
<code><span class="keyword">and</span> <span class="register">$d</span>, <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># $d = $s AND $t</span>
<span class="keyword">andi</span> <span class="register">$t</span>, <span class="register">$s</span>, <span class="number">imm</span> <span class="comment"># $t = $s AND imm</span>
<span class="keyword">or</span> <span class="register">$d</span>, <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># $d = $s OR $t</span>
<span class="keyword">ori</span> <span class="register">$t</span>, <span class="register">$s</span>, <span class="number">imm</span> <span class="comment"># $t = $s OR imm</span>
<span class="keyword">xor</span> <span class="register">$d</span>, <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># $d = $s XOR $t</span>
<span class="keyword">nor</span> <span class="register">$d</span>, <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># $d = NOT($s OR $t)</span>
<span class="keyword">sll</span> <span class="register">$d</span>, <span class="register">$t</span>, <span class="number">shamt</span> <span class="comment"># $d = $t << shamt</span>
<span class="keyword">srl</span> <span class="register">$d</span>, <span class="register">$t</span>, <span class="number">shamt</span> <span class="comment"># $d = $t >> shamt (logical)</span>
<span class="keyword">sra</span> <span class="register">$d</span>, <span class="register">$t</span>, <span class="number">shamt</span> <span class="comment"># $d = $t >> shamt (arithmetic)</span></code></div>
</div>
</div>
<!-- Memory Instructions -->
<div class="card">
<h3 class="card-title">Memory Access Instructions</h3>
<div class="card-content">
<div class="code-block" data-lang="mips">
<code><span class="comment"># Load instructions</span>
<span class="keyword">lw</span> <span class="register">$t</span>, <span class="number">offset</span>(<span class="register">$s</span>) <span class="comment"># Load word: $t = Mem[$s + offset]</span>
<span class="keyword">lh</span> <span class="register">$t</span>, <span class="number">offset</span>(<span class="register">$s</span>) <span class="comment"># Load halfword (sign-extended)</span>
<span class="keyword">lhu</span> <span class="register">$t</span>, <span class="number">offset</span>(<span class="register">$s</span>) <span class="comment"># Load halfword (zero-extended)</span>
<span class="keyword">lb</span> <span class="register">$t</span>, <span class="number">offset</span>(<span class="register">$s</span>) <span class="comment"># Load byte (sign-extended)</span>
<span class="keyword">lbu</span> <span class="register">$t</span>, <span class="number">offset</span>(<span class="register">$s</span>) <span class="comment"># Load byte (zero-extended)</span>
<span class="comment"># Store instructions</span>
<span class="keyword">sw</span> <span class="register">$t</span>, <span class="number">offset</span>(<span class="register">$s</span>) <span class="comment"># Store word: Mem[$s + offset] = $t</span>
<span class="keyword">sh</span> <span class="register">$t</span>, <span class="number">offset</span>(<span class="register">$s</span>) <span class="comment"># Store halfword</span>
<span class="keyword">sb</span> <span class="register">$t</span>, <span class="number">offset</span>(<span class="register">$s</span>) <span class="comment"># Store byte</span>
<span class="comment"># Load address (pseudo-instruction)</span>
<span class="keyword">la</span> <span class="register">$t</span>, <span class="label">label</span> <span class="comment"># $t = address of label</span></code></div>
<div class="key-point">
<span class="key-point-icon">★</span>
<span>MIPS uses <strong>byte addressing</strong>. Words are 4 bytes, so word addresses must be divisible by 4 (aligned).</span>
</div>
</div>
</div>
<!-- Mathematical Expressions -->
<div class="card card-full">
<h3 class="card-title">Mathematical Expressions in Assembly</h3>
<div class="card-content">
<div class="two-col">
<div>
<div class="subsection-title">Example: f = (g + h) - (i + j)</div>
<p>Assume: g→$s1, h→$s2, i→$s3, j→$s4, f→$s0</p>
<div class="code-block" data-lang="mips">
<code><span class="comment"># f = (g + h) - (i + j)</span>
<span class="keyword">add</span> <span class="register">$t0</span>, <span class="register">$s1</span>, <span class="register">$s2</span> <span class="comment"># $t0 = g + h</span>
<span class="keyword">add</span> <span class="register">$t1</span>, <span class="register">$s3</span>, <span class="register">$s4</span> <span class="comment"># $t1 = i + j</span>
<span class="keyword">sub</span> <span class="register">$s0</span>, <span class="register">$t0</span>, <span class="register">$t1</span> <span class="comment"># f = $t0 - $t1</span></code></div>
</div>
<div>
<div class="subsection-title">Example: f = 2*g + h/4</div>
<div class="code-block" data-lang="mips">
<code><span class="comment"># f = 2*g + h/4</span>
<span class="keyword">sll</span> <span class="register">$t0</span>, <span class="register">$s1</span>, <span class="number">1</span> <span class="comment"># $t0 = g * 2 (shift left)</span>
<span class="keyword">sra</span> <span class="register">$t1</span>, <span class="register">$s2</span>, <span class="number">2</span> <span class="comment"># $t1 = h / 4 (shift right)</span>
<span class="keyword">add</span> <span class="register">$s0</span>, <span class="register">$t0</span>, <span class="register">$t1</span> <span class="comment"># f = $t0 + $t1</span></code></div>
</div>
</div>
<div class="key-point">
<span class="key-point-icon">★</span>
<span>Multiply/divide by powers of 2 using shifts: <code>sll</code> by n = multiply by 2^n, <code>srl/sra</code> by n = divide by 2^n</span>
</div>
</div>
</div>
<!-- Decisions (Branching) -->
<div class="card">
<h3 class="card-title">Decisions (Conditional Branching)</h3>
<div class="card-content">
<div class="code-block" data-lang="mips">
<code><span class="comment"># Branch instructions</span>
<span class="keyword">beq</span> <span class="register">$s</span>, <span class="register">$t</span>, <span class="label">label</span> <span class="comment"># if ($s == $t) goto label</span>
<span class="keyword">bne</span> <span class="register">$s</span>, <span class="register">$t</span>, <span class="label">label</span> <span class="comment"># if ($s != $t) goto label</span>
<span class="comment"># Set on less than</span>
<span class="keyword">slt</span> <span class="register">$d</span>, <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># $d = ($s < $t) ? 1 : 0</span>
<span class="keyword">slti</span> <span class="register">$t</span>, <span class="register">$s</span>, <span class="number">imm</span> <span class="comment"># $t = ($s < imm) ? 1 : 0</span>
<span class="keyword">sltu</span> <span class="register">$d</span>, <span class="register">$s</span>, <span class="register">$t</span> <span class="comment"># unsigned comparison</span>
<span class="comment"># Unconditional jump</span>
<span class="keyword">j</span> <span class="label">label</span> <span class="comment"># goto label</span></code></div>
<div class="subsection-title">If-Else Example</div>
<div class="two-col">
<div>
<p><strong>C Code:</strong></p>
<div class="code-block" data-lang="c">
<code>if (i == j)
f = g + h;
else
f = g - h;</code></div>
</div>
<div>
<p><strong>MIPS Assembly:</strong></p>
<div class="code-block" data-lang="mips">
<code> <span class="keyword">bne</span> <span class="register">$s3</span>, <span class="register">$s4</span>, <span class="label">Else</span>
<span class="keyword">add</span> <span class="register">$s0</span>, <span class="register">$s1</span>, <span class="register">$s2</span>
<span class="keyword">j</span> <span class="label">Exit</span>
<span class="label">Else:</span> <span class="keyword">sub</span> <span class="register">$s0</span>, <span class="register">$s1</span>, <span class="register">$s2</span>
<span class="label">Exit:</span></code></div>
</div>
</div>
</div>
</div>
<!-- Loops -->
<div class="card">
<h3 class="card-title">Loops in Assembly</h3>
<div class="card-content">
<div class="subsection-title">While Loop</div>
<div class="two-col">
<div>
<p><strong>C Code:</strong></p>
<div class="code-block" data-lang="c">
<code>while (save[i] == k)
i += 1;</code></div>
</div>
<div>
<p><strong>MIPS:</strong> (i→$s3, k→$s5, save base→$s6)</p>
<div class="code-block" data-lang="mips">
<code><span class="label">Loop:</span> <span class="keyword">sll</span> <span class="register">$t1</span>, <span class="register">$s3</span>, <span class="number">2</span> <span class="comment"># $t1 = i * 4</span>
<span class="keyword">add</span> <span class="register">$t1</span>, <span class="register">$t1</span>, <span class="register">$s6</span> <span class="comment"># $t1 = &save[i]</span>
<span class="keyword">lw</span> <span class="register">$t0</span>, <span class="number">0</span>(<span class="register">$t1</span>) <span class="comment"># $t0 = save[i]</span>
<span class="keyword">bne</span> <span class="register">$t0</span>, <span class="register">$s5</span>, <span class="label">Exit</span> <span class="comment"># if != k, exit</span>
<span class="keyword">addi</span> <span class="register">$s3</span>, <span class="register">$s3</span>, <span class="number">1</span> <span class="comment"># i++</span>
<span class="keyword">j</span> <span class="label">Loop</span>
<span class="label">Exit:</span></code></div>
</div>
</div>
<div class="subsection-title">For Loop</div>
<div class="two-col">
<div>
<p><strong>C Code:</strong></p>
<div class="code-block" data-lang="c">
<code>// Sum array elements
int sum = 0;
for (int i = 0; i < n; i++)
sum += arr[i];</code></div>
</div>
<div>
<p><strong>MIPS:</strong></p>
<div class="code-block" data-lang="mips">
<code> <span class="keyword">li</span> <span class="register">$t0</span>, <span class="number">0</span> <span class="comment"># sum = 0</span>
<span class="keyword">li</span> <span class="register">$t1</span>, <span class="number">0</span> <span class="comment"># i = 0</span>
<span class="label">Loop:</span> <span class="keyword">bge</span> <span class="register">$t1</span>, <span class="register">$s1</span>, <span class="label">Exit</span> <span class="comment"># if i >= n, exit</span>
<span class="keyword">sll</span> <span class="register">$t2</span>, <span class="register">$t1</span>, <span class="number">2</span> <span class="comment"># $t2 = i * 4</span>
<span class="keyword">add</span> <span class="register">$t2</span>, <span class="register">$t2</span>, <span class="register">$s0</span> <span class="comment"># $t2 = &arr[i]</span>
<span class="keyword">lw</span> <span class="register">$t3</span>, <span class="number">0</span>(<span class="register">$t2</span>) <span class="comment"># $t3 = arr[i]</span>
<span class="keyword">add</span> <span class="register">$t0</span>, <span class="register">$t0</span>, <span class="register">$t3</span> <span class="comment"># sum += arr[i]</span>
<span class="keyword">addi</span> <span class="register">$t1</span>, <span class="register">$t1</span>, <span class="number">1</span> <span class="comment"># i++</span>
<span class="keyword">j</span> <span class="label">Loop</span>
<span class="label">Exit:</span></code></div>
</div>
</div>
</div>
</div>
<!-- Procedures -->
<div class="card card-full">
<h3 class="card-title">Procedures (Functions)</h3>
<div class="card-content">
<div class="two-col">
<div>
<div class="subsection-title">Procedure Call Steps</div>
<ol class="styled-list">
<li>Place arguments in $a0-$a3</li>
<li>Transfer control: <code>jal ProcedureLabel</code></li>
<li>Acquire storage (if needed)</li>
<li>Perform procedure's task</li>
<li>Place result in $v0-$v1</li>
<li>Return: <code>jr $ra</code></li>
</ol>
<div class="code-block" data-lang="mips">
<code><span class="comment"># Caller code</span>
<span class="keyword">li</span> <span class="register">$a0</span>, <span class="number">5</span> <span class="comment"># arg1 = 5</span>
<span class="keyword">li</span> <span class="register">$a1</span>, <span class="number">3</span> <span class="comment"># arg2 = 3</span>
<span class="keyword">jal</span> <span class="label">multiply</span> <span class="comment"># call function</span>
<span class="keyword">move</span> <span class="register">$s0</span>, <span class="register">$v0</span> <span class="comment"># save result</span></code></div>
</div>
<div>
<div class="subsection-title">Procedure Implementation</div>
<div class="code-block" data-lang="mips">
<code><span class="comment"># int multiply(int a, int b)</span>
<span class="label">multiply:</span>
<span class="comment"># Leaf procedure - no stack needed</span>
<span class="keyword">mul</span> <span class="register">$v0</span>, <span class="register">$a0</span>, <span class="register">$a1</span> <span class="comment"># $v0 = a * b</span>
<span class="keyword">jr</span> <span class="register">$ra</span> <span class="comment"># return</span></code></div>
</div>
</div>
<div class="subsection-title">Stack Management for Non-Leaf Procedures</div>
<div class="code-block" data-lang="mips">
<code><span class="comment"># int factorial(int n)</span>
<span class="label">factorial:</span>
<span class="comment"># Prologue - save registers</span>
<span class="keyword">addi</span> <span class="register">$sp</span>, <span class="register">$sp</span>, <span class="number">-8</span> <span class="comment"># allocate stack space</span>
<span class="keyword">sw</span> <span class="register">$ra</span>, <span class="number">4</span>(<span class="register">$sp</span>) <span class="comment"># save return address</span>
<span class="keyword">sw</span> <span class="register">$a0</span>, <span class="number">0</span>(<span class="register">$sp</span>) <span class="comment"># save n</span>
<span class="comment"># Base case: if (n <= 1) return 1</span>
<span class="keyword">slti</span> <span class="register">$t0</span>, <span class="register">$a0</span>, <span class="number">2</span> <span class="comment"># $t0 = (n < 2)</span>
<span class="keyword">beq</span> <span class="register">$t0</span>, <span class="register">$zero</span>, <span class="label">recurse</span>
<span class="keyword">li</span> <span class="register">$v0</span>, <span class="number">1</span> <span class="comment"># return 1</span>
<span class="keyword">j</span> <span class="label">fact_exit</span>
<span class="label">recurse:</span>
<span class="comment"># Recursive case: return n * factorial(n-1)</span>
<span class="keyword">addi</span> <span class="register">$a0</span>, <span class="register">$a0</span>, <span class="number">-1</span> <span class="comment"># n - 1</span>
<span class="keyword">jal</span> <span class="label">factorial</span> <span class="comment"># factorial(n-1)</span>
<span class="keyword">lw</span> <span class="register">$a0</span>, <span class="number">0</span>(<span class="register">$sp</span>) <span class="comment"># restore n</span>
<span class="keyword">mul</span> <span class="register">$v0</span>, <span class="register">$a0</span>, <span class="register">$v0</span> <span class="comment"># n * factorial(n-1)</span>
<span class="label">fact_exit:</span>
<span class="comment"># Epilogue - restore registers</span>
<span class="keyword">lw</span> <span class="register">$ra</span>, <span class="number">4</span>(<span class="register">$sp</span>) <span class="comment"># restore return address</span>
<span class="keyword">addi</span> <span class="register">$sp</span>, <span class="register">$sp</span>, <span class="number">8</span> <span class="comment"># deallocate stack</span>
<span class="keyword">jr</span> <span class="register">$ra</span> <span class="comment"># return</span></code></div>
<div class="diagram">
Stack Layout During Recursive Call:
High Address
┌──────────────┐
│ ... │
├──────────────┤
│ saved $ra │ ← $sp + 4
├──────────────┤
│ saved $a0 │ ← $sp
├──────────────┤
│ ... │
└──────────────┘
Low Address
Stack grows downward (toward lower addresses)</div>
</div>
</div>
<!-- System Calls -->
<div class="card">
<h3 class="card-title">System Calls (SPIM/MARS)</h3>
<div class="card-content">
<div class="table-container">
<table>
<thead>
<tr>
<th>Service</th>
<th>$v0</th>
<th>Arguments</th>
<th>Result</th>
</tr>
</thead>
<tbody>
<tr><td>Print int</td><td>1</td><td>$a0 = integer</td><td>-</td></tr>
<tr><td>Print string</td><td>4</td><td>$a0 = address</td><td>-</td></tr>
<tr><td>Read int</td><td>5</td><td>-</td><td>$v0 = integer</td></tr>
<tr><td>Read string</td><td>8</td><td>$a0=buffer, $a1=len</td><td>-</td></tr>
<tr><td>Exit</td><td>10</td><td>-</td><td>-</td></tr>
<tr><td>Print char</td><td>11</td><td>$a0 = char</td><td>-</td></tr>
<tr><td>Read char</td><td>12</td><td>-</td><td>$v0 = char</td></tr>
</tbody>
</table>
</div>
<div class="code-block" data-lang="mips">
<code><span class="comment"># Print "Hello" and read an integer</span>
<span class="directive">.data</span>
<span class="label">msg:</span> <span class="directive">.asciiz</span> <span class="string">"Enter a number: "</span>
<span class="directive">.text</span>
<span class="keyword">li</span> <span class="register">$v0</span>, <span class="number">4</span> <span class="comment"># print_string</span>
<span class="keyword">la</span> <span class="register">$a0</span>, <span class="label">msg</span>
<span class="keyword">syscall</span>
<span class="keyword">li</span> <span class="register">$v0</span>, <span class="number">5</span> <span class="comment"># read_int</span>
<span class="keyword">syscall</span>
<span class="keyword">move</span> <span class="register">$s0</span>, <span class="register">$v0</span> <span class="comment"># save input in $s0</span></code></div>
</div>
</div>
</div>
</section>
<!-- SECTION 5: Hardware Optimization -->
<section id="section5" class="section">
<div class="section-header">
<span class="section-number">05</span>
<h2 class="section-title">Hardware Performance Techniques</h2>
</div>
<div class="cards-grid">
<!-- Clock Rate -->
<div class="card">
<h3 class="card-title">Increasing Clock Rate</h3>
<div class="card-content">
<div class="comparison">
<div class="comparison-item pros">
<div class="comparison-title">✓ Advantages</div>
<ul class="styled-list">
<li>More cycles per second</li>
<li>Faster single-thread execution</li>
<li>Direct performance boost</li>
<li>No software changes needed</li>
</ul>
</div>
<div class="comparison-item cons">
<div class="comparison-title">✗ Disadvantages</div>
<ul class="styled-list">
<li>Power increases linearly with freq</li>
<li>Heat dissipation problems</li>
<li>Signal integrity issues</li>
<li>Diminishing returns (power wall)</li>
</ul>
</div>
</div>
</div>
</div>
<!-- Silicon Feature Size -->
<div class="card">
<h3 class="card-title">Decreasing Silicon Feature Size</h3>
<div class="card-content">
<div class="comparison">
<div class="comparison-item pros">
<div class="comparison-title">✓ Advantages</div>
<ul class="styled-list">
<li>More transistors per chip</li>
<li>Lower capacitance → less power</li>
<li>Faster switching speed</li>
<li>Lower voltage operation</li>
</ul>
</div>
<div class="comparison-item cons">
<div class="comparison-title">✗ Disadvantages</div>
<ul class="styled-list">
<li>Increased leakage current</li>
<li>Manufacturing complexity</li>
<li>Quantum effects at small scales</li>
<li>Higher defect rates</li>
<li>Extreme cost of fab facilities</li>
</ul>
</div>
</div>
<div class="key-point">
<span class="key-point-icon">★</span>
<span><strong>Moore's Law:</strong> Transistor count doubles ~every 2 years. Currently at 3-5nm process nodes.</span>
</div>
</div>
</div>
<!-- Pipelining -->
<div class="card card-full">
<h3 class="card-title">Pipelined Datapath</h3>
<div class="card-content">
<div class="comparison">
<div class="comparison-item pros">
<div class="comparison-title">✓ Advantages</div>
<ul class="styled-list">
<li>Higher throughput (instructions/second)</li>
<li>Better hardware utilization</li>
<li>Allows higher clock frequency</li>
<li>Ideally CPI approaches 1</li>
</ul>
</div>
<div class="comparison-item cons">
<div class="comparison-title">✗ Disadvantages</div>
<ul class="styled-list">
<li>Pipeline hazards cause stalls</li>
<li>Increased latency per instruction</li>
<li>More complex control logic</li>
<li>Branch misprediction penalty</li>
</ul>
</div>
</div>
<div class="subsection-title">Pipeline Hazards</div>
<div class="table-container">
<table>
<thead>
<tr>
<th>Hazard Type</th>
<th>Cause</th>
<th>Solution</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Structural</strong></td>
<td>Hardware resource conflict</td>
<td>Duplicate resources, stall</td>
</tr>
<tr>
<td><strong>Data</strong></td>
<td>Instruction depends on prior result</td>
<td>Forwarding, stall, reorder</td>
</tr>
<tr>
<td><strong>Control</strong></td>
<td>Branch outcome unknown</td>
<td>Branch prediction, delay slot</td>
</tr>
</tbody>
</table>
</div>
<div class="diagram">
Pipeline Execution (5-stage):
Cycle: 1 2 3 4 5 6 7 8 9
Instr 1: [IF][ID][EX][MEM][WB]
Instr 2: [IF][ID][EX][MEM][WB]
Instr 3: [IF][ID][EX][MEM][WB]
Instr 4: [IF][ID][EX][MEM][WB]
Instr 5: [IF][ID][EX][MEM][WB]
Without pipeline: 5 instructions × 5 cycles = 25 cycles
With pipeline: 5 instructions in 9 cycles (after filling)</div>
</div>
</div>
<!-- Branch Prediction -->
<div class="card card-full">
<h3 class="card-title">Branch Prediction Methods</h3>
<div class="card-content">
<div class="table-container">
<table>
<thead>
<tr>
<th>Method</th>
<th>Description</th>
<th>Typical Accuracy</th>
<th>Cost</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Static: Always Not Taken</strong></td>
<td>Predict branch not taken</td>
<td>~30-40%</td>
<td>None</td>
</tr>
<tr>
<td><strong>Static: Always Taken</strong></td>
<td>Predict branch taken</td>
<td>~60-70%</td>
<td>None</td>
</tr>
<tr>
<td><strong>Static: Backward Taken</strong></td>
<td>Backward=taken (loops), Forward=not taken</td>
<td>~65-75%</td>
<td>Low</td>
</tr>
<tr>
<td><strong>1-bit Dynamic</strong></td>
<td>Remember last outcome</td>
<td>~80-85%</td>
<td>Medium</td>
</tr>
<tr>
<td><strong>2-bit Saturating Counter</strong></td>
<td>4 states: strongly/weakly taken/not</td>
<td>~85-92%</td>
<td>Medium</td>
</tr>
<tr>
<td><strong>Correlating/Two-Level</strong></td>
<td>Uses global/local branch history</td>
<td>~93-97%</td>
<td>High</td>
</tr>
<tr>
<td><strong>Tournament</strong></td>
<td>Multiple predictors, choose best</td>
<td>~95-98%</td>
<td>Very High</td>
</tr>
</tbody>
</table>
</div>
<div class="subsection-title">2-bit Saturating Counter State Machine</div>
<div class="diagram">
Taken Taken
┌────────────┐ ┌────────────┐
│ ▼ │ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Strongly│ │ Weakly │ │ Weakly │ │ Strongly│
│ Not │◄─────│ Not │◄─────│ Taken │◄─────│ Taken │
│ Taken │ Not │ Taken │ Not │ │ Not │ │
│ 00 │Taken │ 01 │Taken │ 10 │Taken │ 11 │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
│ │
│ Predict: NOT TAKEN Predict: TAKEN │
└───────────────────────────────────────────────────┘</div>
<div class="formula-box">
<div class="formula-title">Misprediction Penalty</div>
Extra cycles = misprediction_rate × pipeline_stages_to_flush<br>
<br>
Example: 5% mispredict, 10-stage pipeline<br>
Penalty = 0.05 × 10 = 0.5 cycles per branch
</div>
</div>
</div>
</div>
</section>
<!-- SECTION 6: Datapath Design -->
<section id="section6" class="section">
<div class="section-header">
<span class="section-number">06</span>
<h2 class="section-title">Datapath Design</h2>
</div>
<div class="cards-grid">
<div class="card card-full">
<h3 class="card-title">Single-Cycle vs Pipelined Design</h3>
<div class="card-content">
<div class="table-container">
<table>
<thead>
<tr>
<th>Aspect</th>
<th>Single-Cycle</th>
<th>Multi-Cycle</th>
<th>Pipelined</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>CPI</strong></td>
<td>1</td>
<td>Variable (3-5)</td>
<td>~1 (ideal)</td>
</tr>
<tr>
<td><strong>Clock Period</strong></td>
<td>Longest instruction</td>
<td>Longest stage</td>
<td>Longest stage</td>
</tr>
<tr>
<td><strong>Throughput</strong></td>
<td>Low</td>
<td>Medium</td>
<td>High</td>
</tr>
<tr>
<td><strong>Hardware</strong></td>
<td>Duplicated (ALU, memory)</td>
<td>Shared</td>
<td>Pipeline registers</td>
</tr>
<tr>
<td><strong>Control</strong></td>
<td>Simple</td>
<td>FSM-based</td>
<td>Complex (hazards)</td>
</tr>
</tbody>
</table>
</div>
<div class="subsection-title">Single-Cycle Datapath</div>
<div class="diagram">
┌─────────┐
PC ──────►│Instruction│──────────────────────────────────────┐
│ Memory │ │
└─────────┬─┘ │
│ │
▼ │
┌─────────────────┐ │
│ Control Unit │────────────────────┐ │
└─────────────────┘ │ │
│ │ │
┌──────────────┼──────────────┐ │ │
│ │ │ │ │
▼ ▼ ▼ │ │
┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ Register│ │ Sign │ │ Register│ │ │
│ Read │ │ Extend │ │ Write │ │ │
└────┬────┘ └────┬────┘ └────▲────┘ │ │
│ │ │ │ │
└──────┬──────┘ │ │ │
│ │ │ │
▼ │ │ │
┌─────────┐ │ │ │
│ ALU │──────────────┤ │ │
└────┬────┘ │ │ │
│ │ │ │
▼ │ │ │
┌─────────┐ │ │ │
│ Data │─────────────┘ │ │
│ Memory │ │ │
└─────────┘ │ │
│ │
Clock: All operations complete in ONE cycle │</div>
<div class="subsection-title">Pipelined Datapath</div>
<div class="diagram">
IF/ID ID/EX EX/MEM MEM/WB
│ │ │ │
▼ ▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ Instruction│ │ Decode │ │ Execute │ │ Memory │ │ WriteBack│
│ Fetch │──│ + Reg │──│ (ALU) │──│ Access │──│ (to Reg) │
│ │ │ Read │ │ │ │ │ │ │
└──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘
│ │ │ │ │
└─────────────┴─────────────┴─────────────┴─────────────┘
Pipeline Registers (store intermediate results)</div>
<div class="formula-box">
<div class="formula-title">Performance Comparison</div>
Single-cycle time: T_single = longest_instruction_time<br>
Pipelined time: T_pipelined = longest_stage_time + register_overhead<br>
<br>
Speedup ≈ number_of_stages (ideal, no hazards)<br>
Actual speedup = stages / (1 + stall_cycles_per_instruction)
</div>
</div>
</div>
</div>
</section>
<!-- SECTION 7: Memory Hierarchy -->
<section id="section7" class="section">
<div class="section-header">
<span class="section-number">07</span>
<h2 class="section-title">Memory Hierarchy</h2>
</div>
<div class="cards-grid">
<!-- Memory Types -->
<div class="card">
<h3 class="card-title">Types of Memory</h3>
<div class="card-content">
<div class="memory-pyramid">
<div class="memory-level">Registers (~1ns)</div>
<div class="memory-level">L1 Cache (~2-4ns)</div>
<div class="memory-level">L2 Cache (~10ns)</div>
<div class="memory-level">L3 Cache (~40ns)</div>
<div class="memory-level">Main Memory DRAM (~100ns)</div>
</div>
<div class="table-container">
<table>
<thead>
<tr>
<th>Level</th>
<th>Size</th>
<th>Speed</th>
<th>Cost/GB</th>
</tr>
</thead>
<tbody>
<tr><td>Registers</td><td>~1 KB</td><td>< 1 ns</td><td>$$$$$</td></tr>
<tr><td>L1 Cache</td><td>32-64 KB</td><td>~2 ns</td><td>$$$$</td></tr>
<tr><td>L2 Cache</td><td>256 KB-1 MB</td><td>~10 ns</td><td>$$$</td></tr>
<tr><td>L3 Cache</td><td>8-64 MB</td><td>~40 ns</td><td>$$</td></tr>
<tr><td>DRAM</td><td>8-128 GB</td><td>~100 ns</td><td>$</td></tr>
<tr><td>SSD</td><td>256 GB-8 TB</td><td>~100 μs</td><td>¢</td></tr>
<tr><td>HDD</td><td>1-20 TB</td><td>~10 ms</td><td>¢¢</td></tr>
</tbody>
</table>
</div>
</div>
</div>
<!-- Memory Usage -->
<div class="card">
<h3 class="card-title">How Memory Types Are Used</h3>
<div class="card-content">
<ul class="styled-list">
<li><strong>Registers:</strong> Currently executing instruction's operands</li>
<li><strong>L1 Cache:</strong> Split I-cache and D-cache, most recently used code/data</li>
<li><strong>L2 Cache:</strong> Unified, backs up L1 misses</li>
<li><strong>L3 Cache:</strong> Shared among cores, last level before DRAM</li>
<li><strong>DRAM:</strong> Running programs, OS, active data</li>
<li><strong>Disk/SSD:</strong> Virtual memory, persistent storage</li>
</ul>
<div class="key-point">
<span class="key-point-icon">★</span>
<span><strong>Principle of Locality:</strong> Temporal (recently used → likely reused) and Spatial (nearby addresses → likely accessed soon)</span>
</div>
</div>
</div>
<!-- Cache Miss Calculations -->
<div class="card card-full">
<h3 class="card-title">Calculating Cache Miss Delays</h3>
<div class="card-content">
<div class="formula-box">
<div class="formula-title">Average Memory Access Time (AMAT)</div>
AMAT = Hit_time + (Miss_rate × Miss_penalty)<br>
<br>
For multi-level cache:<br>
AMAT = L1_hit_time + L1_miss_rate × (L2_hit_time + L2_miss_rate × L2_miss_penalty)
</div>
<div class="subsection-title">Example Calculation</div>
<div class="conversion-example">
<strong>Given:</strong>
<ul class="styled-list">
<li>L1 hit time = 1 cycle</li>
<li>L1 miss rate = 5%</li>
<li>L2 hit time = 10 cycles</li>
<li>L2 miss rate = 20% (of L1 misses)</li>
<li>Memory access = 100 cycles</li>
</ul>
<br>
<strong>Calculate AMAT:</strong>
<code>
AMAT = 1 + 0.05 × (10 + 0.20 × 100)
= 1 + 0.05 × (10 + 20)
= 1 + 0.05 × 30
= 1 + 1.5
= 2.5 cycles
</code>
</div>
<div class="formula-box">
<div class="formula-title">CPI with Memory Stalls</div>
CPI_total = CPI_base + Memory_stall_cycles<br>
<br>
Memory_stall_cycles = (Reads/Instruction × Read_miss_rate × Miss_penalty)<br>
+ (Writes/Instruction × Write_miss_rate × Miss_penalty)
</div>
</div>
</div>
<!-- Cache Organization -->
<div class="card card-full">
<h3 class="card-title">Cache Organization</h3>
<div class="card-content">
<div class="table-container">
<table>
<thead>
<tr>
<th>Type</th>
<th>Description</th>
<th>Pros</th>
<th>Cons</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Direct Mapped</strong></td>
<td>Each block maps to exactly one cache line</td>
<td>Simple, fast lookup</td>
<td>Conflict misses</td>
</tr>
<tr>
<td><strong>Fully Associative</strong></td>
<td>Block can go anywhere in cache</td>
<td>No conflict misses</td>
<td>Expensive lookup</td>
</tr>
<tr>
<td><strong>Set Associative</strong></td>
<td>Block maps to a set, can go in any line within set</td>
<td>Balance of both</td>
<td>Moderate complexity</td>
</tr>
</tbody>
</table>
</div>
<div class="diagram">
Address breakdown for cache access:
│◄────────────── Address ──────────────►│
┌────────────────┬───────────────┬──────┐
│ Tag │ Index │Offset│
│ │ │ │
└────────────────┴───────────────┴──────┘
│ │ │
│ │ └─► Byte within block
│ └─────────────► Which set/line
└─────────────────────────────► Verify correct block
For direct-mapped cache with 2^n blocks, block size 2^m bytes:
- Offset bits = m (selects byte in block)
- Index bits = n (selects cache line)
- Tag bits = address_bits - n - m</div>
</div>
</div>
</div>
</section>
<!-- SECTION 8: Multiprocessors -->
<section id="section8" class="section">
<div class="section-header">
<span class="section-number">08</span>
<h2 class="section-title">Transition to Multiprocessor Architectures</h2>
</div>
<div class="cards-grid">
<div class="card card-full">
<h3 class="card-title">Why Multiprocessors?</h3>
<div class="card-content">
<div class="two-col">
<div>
<div class="subsection-title">The Power Wall</div>
<p>Around 2004, single-core frequency scaling hit physical limits:</p>
<ul class="styled-list">
<li>Power consumption grew faster than performance gains</li>
<li>Heat dissipation became unmanageable</li>
<li>Voltage couldn't decrease further without reliability issues</li>
<li>Dennard scaling ended</li>
</ul>
</div>
<div>
<div class="subsection-title">The ILP Wall</div>
<p>Diminishing returns from single-thread optimizations:</p>
<ul class="styled-list">
<li>Branch prediction accuracy plateaued</li>
<li>Memory latency gap widened</li>
<li>Out-of-order windows limited by power</li>
<li>Instruction-level parallelism exhausted</li>
</ul>
</div>
</div>
<div class="key-point">
<span class="key-point-icon">★</span>
<span><strong>Solution:</strong> Instead of making one core faster, use multiple cores working in parallel. Performance scales with parallelizable workload.</span>
</div>
<div class="subsection-title">Multiprocessor Types</div>
<div class="table-container">
<table>
<thead>
<tr>
<th>Type</th>
<th>Description</th>
<th>Examples</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>SMP (Symmetric)</strong></td>
<td>Shared memory, equal access time</td>
<td>Multi-core desktops</td>
</tr>
<tr>
<td><strong>NUMA</strong></td>
<td>Shared memory, non-uniform access time</td>
<td>Multi-socket servers</td>
</tr>
<tr>
<td><strong>Cluster</strong></td>
<td>Distributed memory, message passing</td>
<td>Supercomputers, cloud</td>
</tr>
</tbody>
</table>
</div>
<div class="formula-box">
<div class="formula-title">Amdahl's Law</div>
Speedup = 1 / ((1 - P) + P/N)<br>
<br>
Where: P = parallelizable fraction, N = number of processors<br>
<br>
Example: 90% parallelizable, 4 cores<br>
Speedup = 1 / (0.1 + 0.9/4) = 1 / 0.325 = 3.08×
</div>
<div class="warning-box">
<div class="warning-box-title">⚠ Challenges of Multiprocessing</div>
<ul class="styled-list">
<li><strong>Cache Coherence:</strong> Multiple caches must stay synchronized</li>
<li><strong>Synchronization:</strong> Locks, barriers, atomic operations needed</li>
<li><strong>Load Balancing:</strong> Work must be evenly distributed</li>
<li><strong>Communication Overhead:</strong> Data sharing has latency cost</li>
<li><strong>Software Complexity:</strong> Parallel programming is hard!</li>
</ul>
</div>
</div>
</div>
</div>
</section>
</main>
<!-- Footer -->
<footer class="footer">
<div class="footer-title">CSE 230 MASTER REFERENCE</div>
<p>Computer Organization & Assembly Language | Arizona State University</p>
<p style="margin-top: 10px; color: var(--accent-cyan);">Good luck this semester! 🚀</p>
</footer>
<script>
// Smooth scroll for navigation
document.querySelectorAll('a[href^="#"]').forEach(anchor => {
anchor.addEventListener('click', function(e) {
e.preventDefault();
const target = document.querySelector(this.getAttribute('href'));
if (target) {
const offset = 80;
const targetPosition = target.getBoundingClientRect().top + window.pageYOffset - offset;
window.scrollTo({
top: targetPosition,
behavior: 'smooth'
});
}
});
});
// Active nav highlighting
const sections = document.querySelectorAll('.section');
const navItems = document.querySelectorAll('.nav-item a');
window.addEventListener('scroll', () => {
let current = '';
sections.forEach(section => {
const sectionTop = section.offsetTop;
if (pageYOffset >= sectionTop - 150) {
current = section.getAttribute('id');
}
});
navItems.forEach(item => {
item.style.borderColor = 'var(--border-color)';
item.style.color = 'var(--text-secondary)';
if (item.getAttribute('href') === '#' + current) {
item.style.borderColor = 'var(--accent-cyan)';
item.style.color = 'var(--accent-cyan)';
}
});
});
</script>
</body>
</html>