Skip to content
LAM
Read Home Blog
Make Projects HTML Tools Games
Touch grass Notes Resume Links
Home Blog HTML Projects
Tools Games Notes Resume Links
Back CSE 230 | Computer Organization & Assembly Language Computing
Download Open
Show description 2,401 chars · Computing

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

126,815 bytes · HTML source
<!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>