1.1 Architecture vs Organization

มุมมองเก่า: architecture = การออกแบบ ISA (Instruction Set Architecture) คือ registers, memory addressing, addressing modes, instruction operands, operations, control flow, instruction encoding

มุมมองจริง: ออกแบบให้ได้ performance สูงสุดภายใต้ข้อจำกัด cost, power, availability ครอบคลุม ISA + microarchitecture + hardware

1.2 Classes of Computers & Cloud Computing

• Supercomputers — คำนวณวิทยาศาสตร์/วิศวกรรมระดับสูง ความสามารถสูงสุด แต่เป็นส่วนเล็กของตลาด
• Embedded Computers — ซ่อนอยู่ในอุปกรณ์ ถูกจำกัดเข้มทั้ง power / performance / cost
• (ตามสไลด์ส่วน Parallelism ยังมี PC/Server/Personal Mobile Device ในตำราหลัก)

Cloud Computing

โมเดลที่เปิดให้เข้าถึง ทรัพยากรคอมพิวเตอร์ที่แชร์ร่วมกัน ได้ทุกที่ ตามต้องการ (on demand) ผ่านเครือข่าย

• Cloud networking — เครือข่ายและระบบจัดการที่ต้องมีเพื่อให้ cloud ทำงานได้
• Cloud storage — ฐานข้อมูลและแอปฐานข้อมูลที่โฮสต์บน cloud server ระยะไกล

1.3 Eight Great Ideas in Computer Architecture

1. Design for Moore's Law — ออกแบบโดยคาดว่าทรานซิสเตอร์เพิ่มขึ้นเรื่อย ๆ
2. Use abstraction to simplify design — ซ่อนรายละเอียดเป็นชั้น ๆ
3. Make the common case fast — ทำเคสที่เกิดบ่อยให้เร็ว
4. Performance via parallelism — ทำหลายอย่างพร้อมกัน
5. Performance via pipelining — ทำเป็นสายพาน (ซ้อนขั้นตอน)
6. Performance via prediction — เดาล่วงหน้า (เช่น branch prediction) ถ้าเดาถูกคุ้มกว่ารอ
7. Hierarchy of memories — หน่วยความจำเป็นลำดับชั้น เร็ว/เล็ก/แพง → ช้า/ใหญ่/ถูก
8. Dependability via redundancy — ทนทานโดยมีของสำรอง

ข้อ 4–6 อาจารย์จัดเป็นกลุ่ม "เพิ่ม Performance"

ปัจจัยที่กำหนด Performance

1.4 Below Your Program

ชั้นของซอฟต์แวร์ (จากนอกเข้าใน): Application software → System software → Hardware

• Application software — เขียนด้วย high-level language
• System software — Compiler แปล HLL เป็น machine code; Operating System ให้บริการ: จัดการ input/output, จัดการ memory และ storage, จัด schedule งานและแชร์ทรัพยากร
• Hardware — processor, memory, I/O controllers

Levels of Program Code

1. High-level language (เช่น C) — ใกล้โจทย์ ผลิตภาพดี พกพาข้ามเครื่องได้ ↓ Compiler
2. Assembly language — ข้อความแทนคำสั่ง (ตัวอย่างในสไลด์เป็น RISC-V: slli, add, ld, sd, jalr) ↓ Assembler
3. Machine language — เลขฐานสอง (bits) เข้ารหัส instruction และ data

1.5 Components of Computers & Inside the CPU

ส่วนประกอบ: Input devices, CPU, Memory (RAM), Storage devices, Motherboard, Output devices, Power supply unit, GPU

ภายใน CPU

Machine Cycle: Fetch → Decode → Execute → Store

1. Fetch ดึง instruction จาก memory
2. Decode แปล instruction เป็นคำสั่งย่อยให้ control unit
3. Execute ทำคำสั่ง (ที่ ALU)
4. Store เก็บผลลัพธ์ลง memory

Registers สำคัญ

• PC (Program Counter) — เก็บ address ของ instruction ถัดไป
• IR (Instruction Register) — เก็บ instruction ที่กำลังทำ
• Status register — เก็บสถานะ / flags

1.6 Cache, Multi-core vs Multi-thread

Cache memory

• อยู่ระหว่าง processor กับ main memory; เล็กกว่าและเร็วกว่า main memory
• ใช้เก็บข้อมูลจาก main memory ที่ น่าจะถูกใช้ในอนาคตอันใกล้ เพื่อเร่งการเข้าถึง
• หลายระดับ: L1 (ใกล้ core ที่สุด เร็วและเล็กที่สุด) → L2 → L3 (ไกลออกไปเรื่อย ๆ)

Multi-core vs Multi-thread

1.7 RISC vs CISC, Embedded Systems, Parallelism

Embedded Systems

• อิเล็กทรอนิกส์ + ซอฟต์แวร์ฝังในผลิตภัณฑ์ ผลิตปีละพันล้านเครื่อง
• เกาะติดกับสภาพแวดล้อม → มี real-time constraints และต้องจัดการหลายกิจกรรมพร้อมกัน
• ตัวอย่าง ARM Cortex-M: interrupt เร็วและ deterministic, กินไฟต่ำ; Cortex-M3 เป็น microcontroller 16/32-bit มี debug/trace

Parallelism

Flynn's Taxonomy

System-level architecture patterns

Monolithic (ระบบเดียวรวม) · Client-server (แยกเครื่องร้องขอ/ให้บริการ) · Distributed (คำนวณกระจายหลายเครื่องในเครือข่าย) · Microservices (บริการย่อยแยก deploy อิสระ — เป็น software pattern)

1.8 Performance — สูตรที่ต้องจำ

ตัวอย่าง: A ใช้ 10s, B ใช้ 15s → ExecTime_B/ExecTime_A = 15/10 = 1.5 → A เร็วกว่า B 1.5 เท่า

วัด Execution Time

• Elapsed time (wall-clock) — เวลาตอบสนองรวมทุกอย่าง: processing, I/O, OS overhead, idle → ตัวกำหนดประสิทธิภาพระบบ
• CPU time — เวลาที่ CPU ประมวลผลงานนั้นจริง ๆ ไม่นับ I/O และงานอื่น; แบ่งเป็น user CPU time + system CPU time

Clock

• Clock period = ระยะเวลา 1 cycle เช่น 250 ps = 0.25 ns = 250×10⁻¹² s
• Clock frequency (rate) = cycles ต่อวินาที เช่น 4.0 GHz = 4000 MHz = 4.0×10⁹ Hz
• Rate = 1 / Period

ปรับปรุง performance ได้โดย ลดจำนวน clock cycles หรือ เพิ่ม clock rate (ผู้ออกแบบมักต้อง trade-off ระหว่าง clock rate กับจำนวน cycle)

Instruction Count และ CPI

• Instruction Count ขึ้นกับ program, ISA และ compiler
• CPI ขึ้นกับ hardware ของ CPU; ถ้าแต่ละ instruction มี CPI ต่างกัน ใช้ average CPI ซึ่งขึ้นกับ instruction mix

ตัวอย่างที่ 1: CPU Time

ตัวอย่างที่ 2: CPI (ISA เดียวกัน)

2.1 Von Neumann vs Harvard

2.2 BUS

• ชนิด: point-to-point และ multipoint (shared resource ต้องควบคุมด้วย protocol ใน hardware)
• ประกอบด้วย 3 สาย: Data lines (ส่งบิต) · Control lines (กำหนดทิศทาง และใครใช้ bus ได้เมื่อไร) · Address lines (ระบุต้นทาง/ปลายทางของข้อมูล)

Bus arbitration — 4 แบบ (กรณีมี bus master หลายตัว)

2.3 Hardware vs Software approach

• (a) Programming in hardware — ลำดับฟังก์ชันคำนวณ/ตรรกะถูก "เดินสาย" ตายตัว เปลี่ยนงานต้องเดินสายใหม่
• (b) Programming in software — ส่วนหนึ่งของ hardware (instruction interpreter) แปลรหัสคำสั่ง แล้วสร้าง control signals ให้หน่วยคำนวณอเนกประสงค์ → เปลี่ยนงานแค่ใส่ชุดรหัสใหม่ ไม่ต้องรื้อ hardware

องค์ประกอบหลัก: CPU (instruction interpreter + general-purpose arithmetic/logic functions + I/O components) พร้อมวิธีรับข้อมูลเข้าและรายงานผล

2.4 Registers และ Instruction Cycle

Fetch cycle

1. ต้นทุก instruction cycle CPU ดึง instruction จาก memory
2. PC เก็บ address ของ instruction ที่จะดึง
3. หลัง fetch PC เพิ่มอัตโนมัติ เพื่อชี้ instruction ถัดไป
4. instruction ที่ดึงมาถูกโหลดเข้า IR
5. CPU แปลความ (interpret) แล้วทำตาม

ตัวอย่างโปรแกรมแบบ 16-bit (สไลด์)

• รูปแบบ instruction: 4 bit Opcode + 12 bit Address
• Integer format: 1 bit sign (S) + 15 bit magnitude
• Register: PC, IR, AC (Accumulator — ที่พักชั่วคราว)
• Opcode ตัวอย่าง: 0001 = Load AC from memory · 0010 = Store AC to memory · 0101 = Add to AC from memory

2.5 MARIE — computer จำลองสำหรับเรียน

7 registers

Registers เชื่อมกันและเชื่อม main memory ผ่าน common data bus; มีทางตรงแยกระหว่าง AC ↔ MBR และ ALU ↔ AC/MBR เพื่อโอนข้อมูลโดยไม่ผ่าน main bus. อุปกรณ์แต่ละตัวมีเลขประจำตัวที่ตั้งบน control lines

รูปแบบ instruction (16 bit)

bit 15–12 = Opcode (4 bit) · bit 11–0 = Address (12 bit) → ISA ของ MARIE มี 13 คำสั่ง (ตารางด้านล่างคือ 9 คำสั่งพื้นฐานในสไลด์)

RTL — Register Transfer Language

แต่ละ instruction ประกอบด้วย microoperations; RTL ใช้ M[X] = ค่าใน memory ตำแหน่ง X และ ← = โอนข้อมูล

SKIPCOND: if IR[11–10] = 00 and AC < 0 then PC ← PC + 1 · = 01 and AC = 0 then PC ← PC + 1 · = 11 and AC > 0 then PC ← PC + 1

Fetch-Decode-Execute

1. Fetch instruction จาก memory ใส่ IR (MAR ← PC, IR ← M[MAR], PC ← PC + 1)
2. Decode หาว่าต้องทำอะไร (MAR ← IR[11–0], ถอดรหัส IR[15–12])
3. ถ้ามี operand ใน memory ดึงมาใส่ MBR
4. Execute

ตัวอย่างโปรแกรม (address 100–106 hex)

ผล: 0023 + FFE9 = 000C (35 − 23 = 12) เก็บที่ 106. ADD 105 trace: เริ่ม PC=101 → MAR←PC (MAR=101) → IR←M[MAR] (IR=3105) → PC←PC+1 (PC=102) → MAR←IR[11–0] (MAR=105) → MBR←M[MAR] (MBR=FFE9) → AC←AC+MBR (AC=0023+FFE9=000C)

2.6 Interrupts

ทุกคอมพิวเตอร์มีวิธี ขัดจังหวะ fetch-decode-execute cycle

เมื่อไรเกิด interrupt

• user break (เช่น Ctrl+C)
• มีการร้องขอ I/O
• เกิด error ร้ายแรง

แหล่งกำเนิด: Hardware interrupt และ Software interrupt (software เรียก OS ผ่าน system call)

4 ชนิดของ Interrupt

ขั้นตอนเมื่อมี interrupt

• เพิ่ม Interrupt step ต่อท้าย cycle: หลัง execute ตรวจว่ามี interrupt ไหม → ถ้ามี ไปทำ ISR (Interrupt Service Routine) แล้วกลับมาทำต่อ
• ระหว่างทำ interrupt ระบบทั่วไปมัก ปิด interrupt (ตั้ง bit ใน flags register) — interrupt ที่ถูกเมินแบบนี้คือ maskable
• Nonmaskable = ต้องจัดการเสมอเพื่อให้ระบบเสถียร
• Interrupt เหมาะกับ I/O; แต่ MARIE ใช้ programmed I/O แบบปรับ: ผลลัพธ์ใส่ OutREG และ CPU polling InREG จนมีข้อมูลก็คัดลอกเข้า AC

Timing กับ I/O และ Multiple interrupts

• Short I/O wait — การรอ I/O สั้น CPU รอไม่เสียมาก; Long I/O wait — รอนาน ถ้าไม่มี interrupt CPU ว่างเปล่า ถ้ามี interrupt CPU ไปทำงานอื่นระหว่างรอได้ → ใช้ CPU คุ้มกว่า
• Multiple interrupts: จัดการได้ 2 วิธี — (1) ปิด interrupt ระหว่างทำ ISR (เรียงตามลำดับที่มา) (2) ใช้ priority ให้ interrupt สำคัญกว่า ขัดจังหวะ ISR ที่ต่ำกว่าได้ (nested)
• ตัวอย่างสไลด์: printer (t=10), communication (t=15), disk (t=25) ขัดผ่านโปรแกรมผู้ใช้ — ตัวที่ priority สูงกว่าแทรกเข้าไปก่อน

A1 Data Representation & Signed integers

• ข้อมูลเก็บใน register ซึ่งมีจำนวนและขนาด จำกัด
• ข้อมูลแบ่งเป็น Quantitative (ตัวเลข) และ Qualitative (อักขระ/สัญลักษณ์)
• Quantitative → Integers (unsigned เช่น 20; signed เช่น +20, −20) และ Non-integers / Floating point (10.25, 3.3333…, 1/8 = 0.125)
• Unsigned n bit: ช่วง 0 ถึง 2ⁿ − 1

Signed integer ต้องมีวิธีแทนค่าลบ 3 แบบ: (1) Sign & Magnitude (2) Complement method (1's และ 2's) (3) Bias / Excess notation

A2 Sign & Magnitude (S&M)

• บิตซ้ายสุด = sign bit S: 0 = บวก (หรือศูนย์), 1 = ลบ (หรือศูนย์); ที่เหลือ n บิตเป็น magnitude
• ช่วงค่า: −(2ⁿ−1) ถึง +(2ⁿ−1) (n = จำนวนบิต magnitude)
• ตัวอย่าง 8 บิต: 0000 0000 = +0, 1000 0000 = −0 → ศูนย์ไม่ unique (มี 2 ค่า); 8 บิตมีช่วง −127 ถึง +127

A3 Complement Method

ตัวอย่างฐาน 10: n = 3, m = 382 → 9's complement (−382) = 617 · 10's complement = 618

1's complement (ฐาน 2)

• คำนวณ (2ⁿ−1) − m = กลับทุกบิต (invert)
• m = 0101 (4 บิต) → 1010 = −5 ใน 1's complement
• m = 00101011 → 11010100 · m = 00000000 (= 0) → 11111111 (= −0)
• ช่วง 8 บิต: −127 ถึง +127 · มี สองศูนย์ (+0, −0)
• การบวก: ถ้าผลมี carry ออกมา ให้ นำ carry ไปบวกที่ LSB (end-around carry)

2's complement

• ไม่ต้องทำ end-around carry · สร้างโดย หา 1's complement แล้ว +1 ที่ LSB
• ช่วง 8 บิต: −128 ถึง +127 (−128 เพราะมีการ +1 ให้ค่าลบ) · มีศูนย์ตัวเดียว
• Short-cut: เริ่มจาก LSB หาบิต 1 ตัวแรก → คงบิตนั้นและบิตขวาไว้ แล้ว กลับ (invert) ทุกบิตทางซ้าย

เปรียบเทียบ

2's complement ไม่ต้องมีวงจรลบแยก (ใช้ NOT + บวก ถูกกว่าในการออกแบบวงจร) แต่ คูณ/หารช้า

A4 Bias (Excess) Notation

ค่าที่เก็บ = ค่าจริง + bias · ตาราง Biased-127 (8 บิต):

ค่าจริง = unsigned − 127 (ใช้เป็น exponent ใน floating point)

A5 Floating Point & IEEE 754

• mantissa m อยู่ในช่วง 1 ถึง (2 − 2⁻²³) (มี implicit leading 1)
• E ใช้ได้ 1 ถึง 254 → e = −126 ถึง +127
• E = 0 และ E = 255 สงวนไว้ แทน −∞, +∞, NaN
• ค่ามากสุด ≈ 2 × 2¹²⁷ = 2¹²⁸

ทบทวน Binary fraction

ตัวอย่าง: 17.15 เป็น IEEE single

A6 Character Representation

• 1 ไบต์ (8 บิต) แทนได้ 256 อักขระ · มาตรฐาน: ASCII (American Standard Code for Information Interchange), EBCDIC (Extended Binary-Coded Decimal Interchange Code), Unicode
• ASCII: มาตรฐานโลก de facto มี 128 ตัว (7 บิต: 000 0000–111 1111) = ตัวอักษรละติน ใหญ่/เล็ก ตัวเลข เครื่องหมายวรรคตอน และ control; อาจมี parity bit เพิ่ม · (RISC-V ส่วนอักขระ: 95 graphic + 33 control)
• จุดต้องรู้: รหัส ASCII ของตัวเลข ไม่เท่ากับค่าตัวเลข · พิมพ์ใหญ่/เล็กต่างกัน 0x20 (= 32 = 0010 0000) — Shift key clear bit 5 · ตัวอย่าง A = 65 = 0100 0001, a = 97 = 0110 0001
• ภาษาส่วนใหญ่ต้องการมากกว่า 128 ตัว → Latin-1 (256 ตัว = ASCII + graphic เพิ่ม 96), Unicode (32-bit ใน Java, C++ wide char; รองรับอักษรทั่วโลก; UTF-8 / UTF-16 เป็น variable-length)

B1 RISC-V — พื้นฐาน

• Instruction set ต่างกันในแต่ละเครื่อง; เครื่องยุคแรกคำสั่งง่าย (implement ง่าย) เครื่องสมัยใหม่หลายตัวก็ง่ายเช่นกัน
• RISC-V: เกิดที่ UC Berkeley เป็น open ISA ปัจจุบันดูแลโดย RISC-V Foundation; เป็นตัวแทนของ ISA ยุคใหม่ ใช้ใน embedded (consumer electronics, network/storage, cameras, printers)

Arithmetic

add/sub มี 3 operands (2 source, 1 destination): add a, b, c // a gets b + c

add x5, x20, x21     // t0 = g + h
add x6, x22, x23     // t1 = i + j
sub x19, x5, x6      // f = t0 - t1

Register file

• RISC-V มี 32 × 64-bit register (x0–x31) · ข้อมูล 64 บิต = doubleword · 32 บิต = word
• Design Principle 2: Smaller is faster — register น้อยเร็วกว่า (เทียบ main memory ที่มีล้านตำแหน่ง)

Registers vs Memory: register เร็วกว่า; ทำงานกับ memory ต้อง load/store (instruction เพิ่ม) → compiler ควรใช้ register ให้มากที่สุด ย้ายลง memory (spill) เฉพาะตัวแปรที่ใช้ไม่บ่อย

Immediate operands

ค่าคงที่ฝังในคำสั่ง เช่น addi x22, x22, 4 — ไม่มี subi (ใช้ addi กับค่าลบ) · Make the common case fast: ค่าคงที่เล็กพบบ่อย ไม่ต้อง load จาก memory

B2 Memory operands & Endian

• Main memory เก็บ composite data (array, structure, dynamic data); ทำเลขต้อง load → register → store กลับ
• Memory เป็น byte addressed (แต่ละ address = 1 byte); RISC-V เป็น Little Endian — byte น้อยที่สุด (LSB) อยู่ address ต่ำสุด ของ word · (Big Endian = MSB ที่ address ต่ำสุด)
• RISC-V ไม่บังคับ alignment (บาง ISA บังคับ)

ld  x9, 64(x22)      // x9 = A[8]
add x9, x21, x9      // x9 = h + A[8]
sd  x9, 96(x22)      // A[12] = x9

ld = load doubleword · sd = store doubleword · รูปแบบ op reg, offset(base)

B3 Instruction formats (เข้ารหัส 32 บิต)

คำสั่งถูกเก็บเป็น เลขฐานสองเหมือนข้อมูล (stored program) — ทุก instruction ยาว 32 bit

R-format (register-register)

• opcode ชนิดคำสั่ง · rd register ปลายทาง · funct3 / funct7 opcode เพิ่มเติม · rs1, rs2 register ต้นทาง

I-format (immediate arithmetic & load)

• immediate เป็น 2's complement และ sign-extended · rs1 = source หรือ base address · ใช้กับ addi, ld ฯลฯ

S-format (store)

• rs1 = base address · rs2 = ค่าที่จะเก็บ · immediate = offset ถูก แยกเป็นสองท่อน เพื่อให้ตำแหน่ง rs1/rs2 อยู่ที่เดิมเสมอ

สรุปทุก format (Encoding summary)

Stored-program

คำสั่งและข้อมูลเป็นเลขฐานสองเก็บใน memory เหมือนกัน → โปรแกรมกระทำกับโปรแกรมได้ (compiler, linker) · Binary compatibility ทำให้โปรแกรมที่ compile แล้วรันบนเครื่องอื่นได้ (ISA มาตรฐาน)

Sign extension & ตัวเลข

• Unsigned n บิต: 0…2ⁿ−1 · 2's complement: −2ⁿ⁻¹…2ⁿ⁻¹−1
• Negation = complement แล้ว +1 (เช่น +2 = 0…0010, −2 = 1…1110)
• Sign extension: ขยายความกว้างโดยทำซ้ำ sign bit — lb sign-extend, lbu zero-extend

B4 Logical & Shift

• slli by i bit = คูณด้วย 2ⁱ (เติม 0 ทางขวา) · srli by i bit = หารด้วย 2ⁱ (เฉพาะ unsigned)
• Shift format: funct6 (6) | immed (6) | rs1 | funct3 | rd | opcode — immed = จำนวนตำแหน่งที่เลื่อน
• AND ใช้ mask บิต: เลือกบางบิต ที่เหลือเคลียร์เป็น 0 · OR ใช้ set บิต · XOR ใช้ toggle/เปรียบเทียบ

B5 Conditional, If, Loop

• beq rs1, rs2, L1: if (rs1 == rs2) กระโดดไป L1 · bne: if (rs1 != rs2)
• blt (<) · bge (≥) signed · bltu, bgeu unsigned
• ไม่ branch ก็ทำคำสั่งถัดไปตามลำดับ

        bne x22, x23, Else
        add x19, x20, x21
        beq x0, x0, Exit     // unconditional
Else:   sub x19, x20, x21
Exit:   ...

Loop: slli x10, x22, 3     // x10 = i*8
      add  x10, x10, x25   // address of save[i]
      ld   x9, 0(x10)
      bne  x9, x24, Exit
      addi x22, x22, 1
      beq  x0, x0, Loop
Exit: ...

bge  x23, x22, Exit   // branch if b >= a
addi x22, x22, 1
Exit:

Basic block = ลำดับคำสั่งที่ ไม่มี branch ฝังกลาง (ยกเว้นท้าย) และ ไม่มี branch target (ยกเว้นต้น) — compiler ใช้ optimize, processor ขั้นสูงเร่งได้

B6 Procedure Calling & Stack

6 ขั้นตอน

1. วาง parameter ใน x10–x17
2. โอนการควบคุมไปที่ procedure
3. จัดสรร storage (stack) ให้ procedure
4. ทำงานของ procedure
5. วางผลลัพธ์ใน register ให้ caller
6. กลับไปจุดที่เรียก (address ใน x1)

• Call: jal x1, ProcedureLabel — เก็บ address ของคำสั่งถัดไปใน x1 แล้วกระโดด
• Return: jalr x0, 0(x1) — กระโดดไป 0 + ค่าใน x1 · ใช้ x0 เป็น rd (เขียนทับ x0 ไม่ได้ = ทิ้งค่า) · jalr ยังใช้ทำ computed jump (switch/case)

Leaf procedure (ไม่เรียกฟังก์ชันอื่น)

leaf_example:
  addi sp, sp, -24     // ขอที่ stack 3 doubleword
  sd   x5, 16(sp)
  sd   x6, 8(sp)
  sd   x20, 0(sp)
  add  x5, x10, x11    // g+h
  add  x6, x12, x13    // i+j
  sub  x20, x5, x6     // f
  addi x10, x20, 0     // copy f ไป return register
  ld   x20, 0(sp)      // restore
  ld   x6, 8(sp)
  ld   x5, 16(sp)
  addi sp, sp, 24      // pop
  jalr x0, 0(x1)       // return

• Stack โตลง (ที่อยู่ต่ำลง) : addi sp,sp,-N ขอที่ · addi sp,sp,N คืนที่

Register usage

• x5–x7, x28–x31 temporaries: callee ไม่ต้องรักษา
• x8–x9, x18–x27 saved: ถ้าใช้ callee ต้อง save/restore

Non-leaf procedure (เรียกฟังก์ชันอื่น / recursion)

caller ต้องเก็บลง stack: return address (x1) และ argument/temporary ที่ต้องใช้หลังการเรียก แล้ว restore หลังเรียกเสร็จ

fact:
  addi sp, sp, -16
  sd   x1, 8(sp)        // save return address
  sd   x10, 0(sp)       // save n
  addi x5, x10, -1      // x5 = n-1
  bge  x5, x0, L1       // if n-1 >= 0 (n >= 1) go L1
  addi x10, x0, 1       // else return 1
  addi sp, sp, 16       // pop (ไม่ต้อง restore)
  jalr x0, 0(x1)
L1: addi x10, x10, -1   // n = n-1
  jal  x1, fact         // call fact(n-1)
  addi x6, x10, 0       // x6 = fact(n-1)
  ld   x10, 0(sp)       // restore n
  ld   x1, 8(sp)        // restore return address
  addi sp, sp, 16
  mul  x10, x10, x6     // n * fact(n-1)
  jalr x0, 0(x1)

Memory layout

B7 Characters, 32-bit constants, Addressing

Byte/Halfword/Word operations

strcpy: addi sp,sp,-8 ; sd x19,0(sp) ; add x19,x0,x0    // i=0
L1: add x5,x19,x10 ; lbu x6,0(x5)      // x6 = y[i]
    add x7,x19,x10 ; sb  x6,0(x7)      // x[i] = y[i]
    beq x6,x0,L2                        // ถ้าเป็น '\0' จบ
    addi x19,x19,1 ; jal x0,L1
L2: ld x19,0(sp) ; addi sp,sp,8 ; jalr x0,0(x1)

ค่าคงที่ 32 บิต

• ค่าคงที่ส่วนใหญ่เล็ก → 12-bit immediate พอ · ค่า 32 บิตใช้ lui rd, constant
• lui = load upper immediate: คัดลอก 20 บิตไปที่ bit [31:12] ของ rd, extend bit 31 ไป [63:32], เคลียร์ [11:0] = 0

Branch & Jump addressing

• Branch (SB format): opcode + 2 register + immediate · PC-relative: target = PC + immediate × 2 (target ส่วนมากอยู่ใกล้ ทั้งไปหน้า/ย้อนหลัง)
• Jump (jal, UJ format): immediate 20 บิต (rd + opcode + imm[20|10:1|11|19:12]) ได้ช่วงไกลกว่า
• กระโดดไกล (absolute 32 บิต): lui ใส่ address[31:12] ใน temp แล้ว jalr บวก address[11:0] และกระโดด

4 Addressing modes ของ RISC-V

1. Immediate addressing — operand คือค่าคงที่ในคำสั่ง
2. Register addressing — operand อยู่ใน register
3. Base (displacement) addressing — register + offset ได้ address memory (byte/halfword/word/doubleword)
4. PC-relative addressing — PC + offset (ใช้ใน branch)

B8 หัวข้ออ่านเพิ่ม (Part II: self-study)

อาจารย์ระบุว่า "Students can explore by themselves" — ความสำคัญรองลงมา แต่สรุปไว้ครบ

Synchronization

• ปัญหา: สอง processor แชร์ memory — P1 เขียน P2 อ่าน ถ้าไม่ synchronize เกิด data race (ผลลัพธ์ขึ้นกับลำดับการเข้าถึง)
• ต้องมี hardware support เป็น atomic read/write (ไม่มีใครเข้าถึง location นั้นระหว่าง read กับ write) — instruction เดียว (เช่น atomic swap) หรือคู่ instruction
• RISC-V: lr.d rd,(rs1) (load reserved — จอง address) + sc.d rd,(rs1),rs2 (store conditional — สำเร็จถ้า location ไม่เปลี่ยนตั้งแต่ lr.d → rd = 0; ล้มเหลว → rd ≠ 0)
• Atomic swap: again: lr.d x10,(x20) → sc.d x11,(x20),x23 → bne x11,x0,again → addi x23,x10,0
• Lock: ตั้ง x12 = 1 → วน lr.d อ่านล็อกจนเป็น 0 → sc.d พยายามเขียน 1 → ถ้าล้มเหลววนใหม่ · Unlock: sd x0,0(x20)

Translation & Startup (ลำดับ: Compile → Assemble → Link → Load)

ตัวอย่าง C Sort (bubble)

• swap (leaf): v ใน x10, k ใน x11, temp ใน x5 → slli x6,x11,3 (k*8) · add x6,x10,x6 · ld x5,0(x6) · ld x7,8(x6) · sd x7,0(x6) · sd x5,8(x6) · jalr x0,0(x1)
• sort (non-leaf เรียก swap): v ใน x10, n ใน x11, i ใน x19, j ใน x20 → ต้อง save x1, x19–x22 บน stack (addi sp,sp,-40) และ restore ก่อน return
• Outer loop: li x19,0 / for1tst: bge x19,x11,exit1 / … / addi x19,x19,1 / j for1tst
• Inner loop: addi x20,x19,-1 / for2tst: blt x20,x0,exit2 / คำนวณ address v[j], v[j+1] / ble x6,x7,exit2 / ย้าย parameter / jal x1,swap / addi x20,x20,-1

Effect of Compiler Optimization / Language / Algorithm (Lessons learnt)

• Instruction count และ CPI ไม่ใช่ตัวชี้วัด performance ที่ดีเมื่อดูโดด ๆ
• Compiler optimization ขึ้นกับ algorithm
• Java JIT เร็วกว่า JVM interpret มาก และใกล้เคียง C ที่ optimize ในบางกรณี
• "Nothing can fix a dumb algorithm!"

Arrays vs Pointers

• Array indexing = คูณ index ด้วยขนาด element + บวก base address · Pointer = address ตรง ๆ ตัดความซับซ้อนของการ index
• clear1 (array): ใน loop มี slli + add ทุกรอบ · clear2 (pointer): sd x0,0(x5); addi x5,x5,8; bltu x5,x7,loop2 — เร็วกว่าเล็กน้อย
• Compiler ทำได้เทียบเท่า (strength reduction: คูณ→shift; induction variable elimination) — เขียนให้อ่านง่ายและปลอดภัยดีกว่า

MIPS & ส่วนขยาย RISC-V

• MIPS = รุ่นก่อนเชิงพาณิชย์ของ RISC-V: 32-bit instructions, 32 GPR (reg 0 = 0 เสมอ), 32 FP registers, memory ผ่าน load/store เท่านั้น · เปรียบเทียบ branch: RISC-V ใช้ blt, bge, bltu, bgeu; MIPS ใช้ slt, sltu (set less than → 0/1) แล้ว beq/bne
• RV64I เพิ่ม: auipc rd, immed (rd = (imm<<12) + pc, ตามด้วย jalr สำหรับ long jump) · slt, sltu, slti, sltui · addw, subw, addiw (32-bit add/sub) · shift 32-bit sllw, srlw, slliw, srliw, sraiw · RV32I = register 32 บิต
• Extensions: M multiply/divide/remainder · A atomic memory ops · F single-precision FP · D double-precision FP · C compressed (16-bit สำหรับ instruction ที่ใช้บ่อย)

4.1 Principle of Locality & Memory Hierarchy

โปรแกรมเข้าถึง ส่วนเล็ก ๆ ของ address space ในช่วงเวลาหนึ่ง

Memory hierarchy

1. เก็บทุกอย่างบน disk
2. คัดลอกของที่ใช้ล่าสุด (และข้างเคียง) จาก disk → DRAM (main memory) ที่เล็กกว่า
3. คัดลอกจาก DRAM → SRAM (cache ติดกับ CPU) ที่เล็กกว่าและเร็วกว่า

4.2 Memory Technology

Ideal memory = เวลาเข้าถึงเท่า SRAM + ความจุและราคาต่อ GB เท่า disk

DRAM

• เก็บข้อมูลเป็น ประจุใน capacitor เข้าถึงด้วย transistor ตัวเดียว · ต้อง refresh เป็นระยะ (อ่านแล้วเขียนกลับ ทีละ "row")
• จัดเป็นอาร์เรย์สี่เหลี่ยม; เข้าถึงทั้ง row; Burst mode ส่ง word ต่อเนื่องจาก row ด้วย latency ต่ำ
• DDR (Double Data Rate) ส่งข้อมูลทั้งขอบขาขึ้นและขาลงของ clock · QDR แยก input/output DDR
• ปัจจัย performance: Row buffer (อ่าน/refresh หลาย word ขนาน) · Synchronous DRAM (burst ไม่ต้องส่ง address ทุกครั้ง) · DRAM banking (เข้าถึงหลาย DRAM พร้อมกัน)
• ราคา/ความจุ: 1980 = 64 Kbit ($1,500,000/GB) → 2007 = 1 Gbit ($50/GB)

เพิ่ม Memory bandwidth (block 4 word; bus: 1 cycle address, 15 cycle DRAM access, 1 cycle/transfer)

Flash Storage

• nonvolatile semiconductor; เร็วกว่า disk 100×–1000×; เล็ก กินไฟน้อย ทนทาน; แต่ $/GB แพงกว่า disk (อยู่ระหว่าง disk กับ DRAM)
• NOR flash: random read/write, ใช้เป็น instruction memory ใน embedded · NAND flash: หนาแน่นกว่า เข้าถึงทีละ block ถูกต่อ GB ใช้ใน USB, media storage
• เสื่อมหลังเขียนหลายพันครั้ง → ใช้แทน RAM/disk ตรง ๆ ไม่ได้ · Wear leveling = ย้ายข้อมูลไป block ที่ใช้น้อย

Disk

• nonvolatile, หมุนแม่เหล็ก · แต่ละ sector เก็บ: Sector ID, Data (512 byte; เสนอ 4096), ECC, sync fields และ gaps
• เวลาเข้าถึง: Queuing delay + Seek + Rotational latency + Data transfer + Controller overhead

ผู้ผลิตบอก seek เฉลี่ยจากทุกการ seek; แต่ locality + OS scheduling ทำให้จริงสั้นกว่า · controller อัจฉริยะแสดง logical sector (SCSI, ATA, SATA) · disk มี cache และ prefetch

4.3 Cache & Direct Mapped

Cache = ระดับของ hierarchy ที่ ใกล้ CPU ที่สุด · คำถาม: ข้อมูลอยู่ในนั้นไหม? ไปหาที่ไหน?

• Tag = บิตสูงของ address (เก็บแยกเพื่อรู้ว่า block ใดอยู่ที่ตำแหน่งนั้น)
• Valid bit: 1 = มีข้อมูล, 0 = ไม่มี (เริ่มต้น 0)

Address subdivision (block ใหญ่ขึ้น)

4.4 Block size, Misses & Write policy

Block Size

• block ใหญ่ → miss rate ลด (spatial locality) แต่ ใน cache ขนาดคงที่ block ใหญ่ = จำนวนน้อยลง → แย่งกัน miss rate เพิ่ม + pollution + miss penalty สูงขึ้น
• บรรเทาด้วย early restart และ critical-word-first

Cache miss

• hit → CPU ทำงานต่อปกติ
• miss → stall pipeline → ดึง block จาก level ถัดไป · I-cache miss: restart instruction fetch · D-cache miss: ทำ data access ให้เสร็จ

Write policy

Write allocation (เมื่อ write miss)

• สำหรับ write-through: Allocate on miss (ดึง block มา) หรือ Write around (ไม่ดึง — เพราะโปรแกรมมักเขียนทั้ง block ก่อนอ่าน เช่น initialization)
• สำหรับ write-back: โดยปกติ ดึง block มา

ตัวอย่าง Intrinsity FastMATH

MIPS embedded, pipeline 12 stage, split cache (I-cache + D-cache แยก) แต่ละอัน 16 KB = 256 blocks × 16 words · D-cache เลือก write-through/write-back ได้ · miss rate: I-cache 0.4%, D-cache 11.4%, weighted average 3.2%

4.5 Measuring Cache Performance

สรุป: เมื่อ CPU เร็วขึ้น (base CPI ลด หรือ clock เร็วขึ้น) miss penalty ยิ่งมีน้ำหนัก สัดส่วนเวลาใน memory stall มากขึ้น → ประเมินระบบโดยไม่ดู cache ไม่ได้

4.6 Associative Caches

Associativity เพิ่ม → miss rate ลด แต่ผลตอบแทนลดลงเรื่อย ๆ (diminishing returns) และเพิ่มความซับซ้อน ต้นทุน เวลาเข้าถึง

ข้อมูลจำลอง (64 KB D-cache, 16-word blocks, SPEC2000): miss rate 1-way 10.3% · 2-way 8.6% · 4-way 8.3% · 8-way 8.1%

Replacement policy

• Direct mapped: ไม่มีทางเลือก
• Set associative: เลือก entry ที่ไม่ valid ก่อน ถ้าไม่มีเลือกจาก set: LRU (ไม่ได้ใช้นานสุด — ง่ายสำหรับ 2-way, ไหวสำหรับ 4-way, เกินนั้นยากมาก) หรือ Random (ประสิทธิภาพใกล้ LRU เมื่อ associativity สูง)

4.7 Multilevel Caches

• Primary (L1) ติด CPU เล็กแต่เร็ว → เน้น minimal hit time
• L2 รับ miss ของ L1 ใหญ่กว่า ช้ากว่า แต่เร็วกว่า main memory → เน้น low miss rate (hit time ผลน้อยกว่า)
• Main memory รับ miss ของ L2 · ระบบบางตัวมี L3
• ผลลัพธ์: L1 มักเล็กกว่า cache เดี่ยว และ L1 block size เล็กกว่า L2 block size

CPU ขั้นสูง & Software

• Out-of-order CPU ทำคำสั่งอื่นต่อระหว่าง cache miss (store ค้างใน load/store unit, dependent instruction รอใน reservation station) → วิเคราะห์ยาก ต้องใช้ simulation
• miss ขึ้นกับรูปแบบการเข้าถึง memory (algorithm, compiler)
• Software optimization via blocking (DGEMM): แบ่งเมทริกซ์เป็น block (เช่น BLOCKSIZE 32) เพื่อ ใช้ข้อมูลให้มากที่สุดก่อนถูกแทนที่ — loop 3 ชั้นนอก (sj, si, sk) เรียก do_block ที่ทำคูณเฉพาะ block ย่อย

4.8 Dependable Memory Hierarchy

• Fault = component ล้มเหลว (อาจหรือไม่นำไปสู่ system failure)
• สถานะ: Service accomplishment (บริการตามระบุ) ⇄ Service interruption (เบี่ยงเบน) — Failure → Restoration

เพิ่ม availability: เพิ่ม MTTF (fault avoidance, fault tolerance, fault forecasting) หรือลด MTTR (เครื่องมือ/กระบวนการวินิจฉัยซ่อมที่ดีขึ้น)

Hamming SEC code

• Hamming distance = จำนวนบิตที่ต่างกันระหว่างสอง bit pattern
• distance ต่ำสุด 2 → ตรวจจับ error 1 บิต (เช่น parity code) · distance 3 → แก้ error 1 บิต (SEC) และตรวจจับ 2 บิต
• Encoding: นับบิตจาก 1 ทางซ้าย · ตำแหน่งที่เป็นกำลังของ 2 = parity bit (1, 2, 4, 8, …) · แต่ละ parity bit ตรวจ data bit บางตำแหน่ง
• Decoding: ค่า parity bits บอกว่าบิตไหนผิด — 0000 = ไม่มี error · 1010 = บิต 10 พลิก

SEC/DEC (Single Error Correct / Double Error Detect)

เพิ่ม parity bit p_n ให้ทั้ง word → Hamming distance = 4 · ให H = SEC parity bits

ECC DRAM ใช้ SEC/DEC โดย 8 bit ปกป้องทุก 64 bit

4.9 Virtual Machines

• Host จำลอง guest OS และทรัพยากรเครื่อง · แยก (isolation) ดีขึ้น หลีกเลี่ยงปัญหา security/reliability · ช่วยแชร์ทรัพยากร · มี performance impact บ้าง · ตัวอย่าง: IBM VM/370 (ยุค 1970), VMware, Microsoft Virtual PC
• VMM (Virtual Machine Monitor): map virtual resource → physical (memory, I/O, CPU); guest code รันบนเครื่องจริงใน user mode, trap ไป VMM เมื่อใช้ privileged instruction หรือเข้าถึงทรัพยากรที่ป้องกัน; guest OS ต่างจาก host ได้; VMM จัดการ I/O จริงและจำลอง virtual I/O
• ตัวอย่าง Timer: เครื่องจริง OS ระงับ process → handle → เลือก process ถัดไป · มี VMM: VMM ระงับ VM → handle → เลือก VM ถัดไป; ถ้า VM ต้องการ timer → VMM จำลอง virtual timer และสร้าง interrupt ให้ VM เมื่อ timer จริงเกิด
• Instruction set support: มี user mode / system mode; privileged instruction ใช้ได้ใน system mode เท่านั้น (ใน user mode → trap) · ทรัพยากรกายภาพทั้งหมด (page table, interrupt control, I/O register) เข้าถึงผ่าน privileged instruction

4.10 Virtual Memory, Page Table, TLB

• Address translation แบ่งเป็น page ขนาดคงที่ (เช่น 4 KB)
• Page fault penalty: ต้องดึง page จาก disk — ใช้เวลา หลายล้าน clock cycle · OS จัดการ · ลด page fault rate ด้วย fully associative placement และ replacement algorithm ฉลาด

Page table

• เก็บข้อมูล placement · เป็น array ของ PTE (page table entry) ที่ index ด้วย virtual page number · page table register ใน CPU ชี้ page table ใน physical memory
• page อยู่ใน memory → PTE เก็บ physical page number + status bits (reference, dirty, …) · ไม่อยู่ → PTE ชี้ตำแหน่งใน swap space บน disk

Replacement & writes

• ใช้ LRU เพื่อลด page fault: reference bit (use bit) ใน PTE ตั้งเป็น 1 เมื่อเข้าถึง page; OS เคลียร์เป็น 0 เป็นระยะ — reference bit = 0 แปลว่าไม่ได้ใช้เร็ว ๆ นี้
• เขียน disk ช้าหลายล้าน cycle → เขียนทั้ง block ครั้งเดียว; write-through ไม่เหมาะ → ใช้ write-back พร้อม dirty bit ใน PTE

TLB (Translation Look-aside Buffer)

• ปัญหา: translation ต้องอ้าง memory เพิ่ม (1 ครั้งเพื่ออ่าน PTE + 1 ครั้งสำหรับ access จริง) แต่ page table มี locality ดี → ใช้ cache ของ PTE ใน CPU = TLB
• ทั่วไป: 16–512 PTEs, hit 0.5–1 cycle, miss 10–100 cycle, miss rate 0.01%–1% · miss จัดการได้ทั้ง hardware หรือ software

TLB & Cache interaction / Protection

• cache tag ใช้ physical address → ต้องแปลก่อน lookup; ทางเลือก virtual address tag มีปัญหา aliasing (virtual address ต่างกันชี้ physical เดียวกัน)
• Memory protection: task แชร์ virtual space บางส่วนได้ แต่ต้องกันการเข้าถึงผิดพลาด — ต้องมี OS ช่วย และ hardware: supervisor (kernel) mode, privileged instructions, page table เข้าถึงได้เฉพาะ supervisor mode, system call exception (เช่น ecall ใน RISC-V)

4.11 Common Framework & Sources of Misses

หลักการเดียวกันที่ ทุกระดับ ของ hierarchy (ใช้แนวคิด caching): ① Block placement ② Finding a block ③ Replacement on a miss ④ Write policy

• Placement: ตาม associativity — สูงขึ้น miss rate ลด แต่ซับซ้อน/ต้นทุน/เวลาเพิ่ม · VM ใช้ full table lookup ทำ fully associative ได้
• Replacement: LRU (hardware ซับซ้อนเมื่อ associativity สูง) หรือ Random · VM ใช้ LRU approximation
• Write policy: write-through (ง่ายต่อ replacement อาจต้อง write buffer) / write-back (เก็บ state เพิ่ม) · VM ใช้ได้เฉพาะ write-back

3Cs — แหล่งที่มาของ Miss

Cache design trade-offs

4.12 Cache Control FSM & Cache Coherence

Simple cache + FSM

• ตัวอย่าง: direct-mapped, write-back, write allocate · block 4 words (16 B) · cache 16 KB (1024 blocks) · address 32 บิต · valid bit และ dirty bit ต่อ block · blocking cache (CPU รอจนจบ)
• แบ่ง address: Offset 4 bit (0–3) + Index 10 bit (4–13) + Tag 18 bit (14–31)
• สัญญาณ CPU ↔ Cache: Read/Write, Valid, Address (32), Write Data (32), Read Data (32), Ready · Cache ↔ Memory: Address 32, data 128 บิต (หลายรอบต่อ access)
• FSM: ชุด state เปลี่ยนที่ clock edge; Next state = fn(current state, inputs); Control outputs = fo(current state) · state เก็บใน register

Cache Coherence

ปัญหา: 2 core แชร์ physical address space แต่ cache แยก (เช่น write-through) → CPU A เขียน X=1 แต่ cache ของ CPU B ยังเป็น 0

• Protocol: migration (ย้ายข้อมูลมา cache ท้องถิ่น ลดภาระ shared memory) + replication (สำเนา read-shared ลดการแย่ง)
• Snooping — ทุก cache คอยดู bus read/write · Directory-based — cache และ memory บันทึกสถานะแชร์ของ block ใน directory
• Invalidating snooping: cache ขอสิทธิ์ exclusive ก่อนเขียน → broadcast invalidate บน bus → read ถัดไปใน cache อื่น miss → cache เจ้าของส่งค่าใหม่ให้
• Memory consistency: write ถือว่าสำเร็จเมื่อทุก processor เห็น; processor ไม่จัดลำดับ write ใหม่ → ถ้า P เขียน X แล้ว Y ใครเห็น Y ใหม่ต้องเห็น X ใหม่ด้วย · อ่านจัดลำดับใหม่ได้ แต่เขียนไม่ได้

ตัวอย่างจริง: ARM Cortex-A53 & Intel Core i7

• cache หลายระดับบนชิป, 2-level TLB, multi-banked cache (เข้าถึงหลายครั้ง/cycle ถ้าไม่ชน bank)
• optimization: return requested word first, non-blocking cache (hit under miss, miss under miss), data prefetching

RISC-V system instructions: memory ordering (fence.i, fence, sfence.vm) · CSR access (csrrw/rs/rc และแบบ immediate) · system (ecall, ebreak, sret, wfi)

4.13 Pitfalls & Concluding Remarks

• Byte vs word addressing: cache 32 byte direct-mapped, block 4 byte → byte 36 ไป block 1 แต่ word 36 ไป block 4
• เขียนโค้ดโดยไม่สนใจ memory system (เช่น วน row vs column ของ array — stride ใหญ่ = locality แย่)
• multiprocessor ที่แชร์ L2/L3: associativity น้อยกว่าจำนวน core → conflict miss; core มากขึ้นต้องเพิ่ม associativity
• ใช้ AMAT ประเมิน out-of-order CPU ไม่ได้ (ไม่รวม non-blocked accesses) → ใช้ simulation
• ขยาย address ด้วย segment (Intel 80286) — segment ไม่พอ ทำให้คำนวณ address ซับซ้อน
• ทำ VMM บน ISA ที่ไม่ได้ออกแบบสำหรับ virtualization (non-privileged instruction เข้าถึง hardware) → ต้องขยาย ISA หรือห้าม guest OS ใช้คำสั่งเหล่านั้น

5.1 External Devices & I/O Module

External device แลกเปลี่ยนข้อมูลระหว่างโลกภายนอกกับคอมพิวเตอร์ เชื่อมผ่าน link ไปที่ I/O module · มี transducer (ตัวแปลงสัญญาณ) ในอุปกรณ์

5 หน้าที่หลักของ I/O module

1. Control and timing — ประสานการไหลของข้อมูลระหว่างทรัพยากรภายในกับอุปกรณ์ภายนอก
2. Processor communication — command decoding, data, status reporting, address recognition
3. Device communication — คำสั่ง สถานะ ข้อมูลกับอุปกรณ์
4. Data buffering — บัฟเฟอร์เพื่อ ปรับสมดุลความเร็ว ระหว่างอุปกรณ์กับ memory
5. Error detection — ตรวจและรายงานความผิดพลาดการส่ง

5.2 สามเทคนิคของ I/O

I/O Commands (4 ชนิดที่ module รับจาก processor)

1. Control — activate peripheral และบอกให้ทำอะไร
2. Test — ตรวจสถานะของ module และอุปกรณ์
3. Read — ให้ module รับข้อมูลหนึ่งรายการจาก peripheral ไปไว้ใน internal buffer
4. Write — ให้ module รับข้อมูลจาก data bus แล้วส่งให้ peripheral

5.3 I/O Addressing: Memory-mapped vs Isolated

แต่ละอุปกรณ์ที่ต่อผ่าน I/O module มี unique identifier / address; command ที่ CPU ออกมี address ของอุปกรณ์ที่ต้องการ → I/O module ต้อง แปลความ address lines ว่าเป็นของตัวเองไหม

5.4 Interrupt-Driven I/O

Simple interrupt processing

1. I/O module ส่งสัญญาณ interrupt
2. CPU ทำคำสั่งปัจจุบันจนเสร็จ
3. CPU เก็บ PC และ PSW (Status register) ลง stack ก่อน
4. เริ่มทำงานที่ ISR (Interrupt Service Routine)
5. เสร็จแล้ว restore PC/PSW กลับไปทำโปรแกรมเดิม

Design issues 2 ข้อ

1. มี I/O module หลายตัว — CPU รู้ได้อย่างไรว่าอุปกรณ์ไหนเป็นผู้ interrupt?
2. ถ้ามีหลาย interrupt พร้อมกัน — CPU เลือกทำตัวไหนก่อน?

Device identification — 4 เทคนิค

Intel 82C59A Interrupt Controller — ตัวจัดการ interrupt หลายแหล่งและ priority · Intel 8255A Programmable Peripheral Interface — ชิป I/O ที่ตั้งค่าด้วย control word (ต่อ keyboard/display ผ่าน 82C55A)

5.5 DMA (Direct Memory Access)

• ใช้ DMA controller ถ่ายข้อมูลระหว่าง I/O กับ memory โดยตรง · CPU เพียง เริ่มต้นและรับ interrupt ตอนจบ
• DMA ขอใช้ system bus; จุดที่ processor หยุดตรวจคำขอ: DMA แทรกได้เร็วและถี่กว่า (เกี่ยวกับ hardware bus ตรง ๆ แทรกได้ในหลาย จุดของ instruction cycle) · Interrupt ต้องรอจน instruction ปัจจุบันเสร็จ
• ตัวอย่างชิป: Intel 8237A มี register: Command, Status (channel 0–3 reached TC = terminal count), Mode (verify/write/read transfer, auto-init, address increment/decrement, demand/single/block/cascade), Single Mask, All Mask
• Alternative DMA configurations: DMA module แยกบน bus / เชื่อมหลาย I/O ผ่าน DMA เดียว / I/O bus แยก — ลดจำนวนการใช้ system bus

5.6 Direct Cache Access (DCA)

• ปัญหา: DMA ไม่ scale พอเมื่อ data rate เพิ่มมาก — Ethernet 10/100 Gbps ที่ database server, Wi-Fi ระดับ Gbps (3.2 และ 6.76 Gbps)
• Network traffic เป็น packet (protocol data unit): link level ปกติ Ethernet โดยมี IP และ TCP ซ้อนอยู่ใน payload · ขาออก packet ถูกสร้างที่ NIC/I/O controller · ขาเข้า controller ลอก Ethernet header ส่ง TCP/IP packet ให้ host CPU
• ทั้งขาเข้า-ขาออก core, main memory และ cache ล้วนเกี่ยวข้อง: แอปวางข้อมูลใน application buffer → core ย้ายไป system buffer สร้าง TCP/IP header → DMA ดึงไปส่งที่ NIC

DCA strategies

• ได้ผลมากกว่าถ้าตัด system buffer ใน main memory ทิ้ง — core เข้าถึง packet/descriptor ใน system buffer แค่ครั้งเดียว (อ่านแล้วย้าย payload ไป application buffer)
• วิธีง่ายสุด (prototype บน Xeon ปี 2006–2010): DCA ใช้ได้เฉพาะ incoming network traffic · DCA function อยู่ใน memory controller ส่ง prefetch hint ให้ core ทันทีที่ข้อมูลอยู่ใน system memory → core prefetch data packet จาก system buffer
• Cache injection = วางข้อมูลลง cache โดยตรง — ใน Intel Xeon เรียก Direct Data I/O (DDIO)

5.7 Evolution of the I/O Function (6 ขั้น)

1. CPU ควบคุมอุปกรณ์ต่อพ่วงโดยตรง
2. เพิ่ม controller/I/O module — CPU ใช้ programmed I/O ไม่มี interrupt
3. เหมือนข้อ 2 แต่ใช้ interrupt — CPU ไม่ต้องรอ I/O เสร็จ ประสิทธิภาพเพิ่ม
4. I/O module มี DMA เข้าถึง memory ตรง — ย้ายข้อมูลทั้ง block โดย CPU เกี่ยวข้องเฉพาะตอนเริ่มและจบ
5. I/O module พัฒนาเป็น processor ในตัวเอง มี instruction set เฉพาะ I/O (I/O channel)
6. I/O module มี local memory เป็นคอมพิวเตอร์ในตัวเอง (I/O processor) — ควบคุมอุปกรณ์จำนวนมากด้วย CPU ยุ่งน้อยที่สุด

ตัวอย่าง: IBM zEC12 I/O Channel Subsystem (I/O frames และโครงสร้างระบบ I/O ของ mainframe)

5.8 I/O Interfaces ที่ควรรู้ (9 เรื่อง)

6.1 Magnetic Disk

• จานกลม (platter) ทำจากวัสดุ ไม่เป็นแม่เหล็ก เรียก substrate เคลือบด้วยวัสดุที่ทำให้เป็นแม่เหล็กได้ · เดิมใช้ อะลูมิเนียม/โลหะผสม ปัจจุบันมี แก้ว
• ข้อดีของ glass substrate: ผิวฟิล์มแม่เหล็กสม่ำเสมอขึ้น (reliability สูง) · ข้อบกพร่องผิวลดมาก (read-write error ต่ำ) · รองรับ fly height ต่ำกว่า · แข็งกว่า (disk dynamics ดีขึ้น) · ทนแรงกระแทก/เสียหายได้ดี

Read / Write

• ทิศทางของอนุภาคแม่เหล็ก บนผิวจานแทนค่า "0" และ "1" (N/S)
• Head แบบ Inductive write / Magnetoresistive (MR) read: เขียนด้วย inductive write element (write current สร้างสนามแม่เหล็ก) · อ่านด้วย MR sensor (ต้านทานเปลี่ยนตามทิศสนาม)

6.2 Disk Data Layout & Classification

โครงสร้างข้อมูล

วิธีจัดเรียง layout

รูปแบบ sector (Winchester, Seagate ST506)

แต่ละ physical sector = 600 bytes ประกอบด้วย Gap1 · ID field (synch byte, track #, head #, sector #, CRC) · Gap2 · Data field (synch byte, 512 byte data, CRC) · Gap3 — มี 30 sector/track (physical sector 0–29) และ index

Physical characteristics (Table 6.1)

ตัวอย่างพารามิเตอร์ HDD (Table 6.2)

6.3 Disk Performance Parameters

ดิสก์หมุนด้วยความเร็วคงที่; ก่อนอ่าน/เขียน head ต้องไปที่ track ที่ต้องการ แล้วรอให้ sector หมุนมาตรงหัว

Timing ของ disk I/O transfer: Wait for device → Wait for channel → Seek → Rotational delay → Data transfer (ช่วงนี้ device busy)

6.4 RAID (Redundant Array of Independent Disks)

เทคนิคนำ HDD หลายตัวมารวมทำงานเป็นกลุ่มเดียว มี 7 ระดับ (0–6) — ระดับ ไม่ได้ซ้อนเป็นลำดับชั้น แต่เป็นสถาปัตยกรรมต่างกัน ที่มี 3 คุณสมบัติร่วม:

1. ชุด physical disk หลายตัว OS มองเป็น logical drive เดียว
2. ข้อมูลถูกกระจายข้าม disk ใน array ด้วย striping
3. ใช้ความจุส่วนเกินเก็บ parity เพื่อ กู้ข้อมูล เมื่อ disk เสีย

เกี่ยวกับ RAID 0 ไม่มีการเก็บ redundancy (จริง ๆ ไม่ครบเงื่อนไขข้อ 3)

ตารางสรุป RAID levels (N = จำนวน data disks)

รายละเอียดแต่ละระดับ

6.5 SSD (Solid State Drive)

SSD vs HDD (Table 6.5)

ข้อดีของ SSD เทียบ HDD: IOPS สูง · ทนทาน (durability) · อายุยาวกว่า · กินไฟต่ำ · เงียบและเย็น · access time/latency ต่ำ

SSD architecture

Host system (OS software, file system, I/O driver) → Interface → SSD: Interface controller + Addressing + Data buffer/cache + Error correction → Flash memory components หลายตัว

Practical issues เฉพาะ SSD (HDD ไม่เจอ)

1. ช้าลงเมื่อใช้งานนาน: การเขียนต้อง ① อ่านทั้ง block จาก flash ไปไว้ใน RAM buffer ② erase ทั้ง block ③ เขียนทั้ง block จาก buffer กลับ flash
2. Flash เสื่อมใช้งานไม่ได้หลังจำนวนครั้งการเขียนจำกัด

วิธียืดอายุ: ใส่ cache หน้า flash เพื่อหน่วงและรวมการเขียน · wear-leveling กระจายการเขียนให้ทั่ว block · bad-block management · flash ส่วนใหญ่ประเมินอายุที่เหลือเองเพื่อให้ระบบเตรียมรับ

6.6 Optical Memory

CD-ROM

• เทคโนโลยีเหมือน audio CD; CD-ROM player ทนกว่าและมี error correction เพื่อให้ข้อมูลถูกต้อง
• การผลิต: แผ่นจากเรซิน (polycarbonate) → บันทึกข้อมูลเป็น pit จิ๋วด้วยเลเซอร์ความเข้มสูงสร้าง master → ทำ die ปั๊มสำเนา → เคลือบชั้นสะท้อน (aluminum/ทอง) → ชั้นป้องกัน acrylic → พิมพ์ label
• การอ่าน: เลเซอร์ส่องผ่าน polycarbonate ไปที่ pit/land หน้าชั้นสะท้อน (Pit สะท้อนต่าง Land)
• CD-ROM block format: 12 byte Sync + 4 byte ID (Min, Sec, Sector, Mode) + 2048 byte data + 288 byte L-ECC (layered ECC) = 2352 byte
• ข้อดี: ผลิตซ้ำจำนวนมากราคาถูก · ถอดได้ เก็บถาวรได้ · ข้อเสีย: อ่านอย่างเดียว อัปเดตไม่ได้ · access time ช้ากว่า magnetic disk มาก · ต้นทุนการเขียนต้นฉบับสูงจึงไม่เหมาะงานเฉพาะบุคคล

CD-R และ CD-RW

เปรียบเทียบ CD / DVD / Blu-ray

ตัวเลข track/pit ในภาพสไลด์ (Fig 6.12): 2.11, 1.2, 0.6, 0.1, 1.32, 0.58 µm — ความหมาย: wavelength สั้นลง → beam spot เล็กลง → pit/track เล็กลง → จุข้อมูลได้มากขึ้น (CD → DVD → Blu-ray)

รูปที่ 6.11: CD-ROM (ความจุ 682 MB, หนา 1.2 mm, ชั้น polycarbonate + reflective aluminum + acrylic + label) vs DVD-ROM double-sided dual-layer (17 GB; แต่ละด้านมี semireflective + fully reflective layer; เลเซอร์ focus ทีละชั้นทีละด้าน ต้องพลิกแผ่น เพื่ออ่านอีกด้าน)

6.7 Magnetic Tape

• ใช้เทคนิคอ่าน/บันทึกเหมือน disk · สื่อเป็น เทปโพลีเอสเตอร์ยืดหยุ่น เคลือบแม่เหล็ก (ผงโลหะบริสุทธิ์ในตัวประสาน หรือฟิล์มโลหะ vapor-plated)
• ข้อมูลเป็น แทร็กขนานตามความยาวเทป · serial recording (บิตเรียงต่อกันตาม track) · อ่าน/เขียนเป็นบล็อกต่อเนื่องเรียก physical records คั่นด้วย inter-record gaps
• Serpentine recording: เขียนไปตามความยาว track 0 → ถึงปลายเทป → กลับทิศไป track 1 (ตัวอย่างระบบอ่าน/เขียน 4 track พร้อมกัน — block 1,2,3,4 ลง 4 track ขนาน แล้ว block 5…)

LTO Tape Drives (Linear Tape-Open)

รุ่นแรก ๆ: tape length 609→846 m, กว้าง 1.27 cm, write elements 8→16, linear density 4,880→15,142 bits/mm (LTO-1→5)

7.1 Pipelining Overview

RISC-V pipeline 5 stage — "ทำ 1 ขั้นต่อ 1 stage"

7.2 Pipeline Performance

สมมติเวลา: register read/write = 100 ps, stage อื่น = 200 ps → เปรียบเทียบ pipelined กับ single-cycle datapath

ISA ที่ออกแบบมาเพื่อ pipelining (RISC-V)

• instruction ยาว 32 บิตเท่ากันทุกตัว → fetch/decode ง่ายใน 1 cycle (เทียบ x86: ยาว 1–17 byte)
• format น้อยและสม่ำเสมอ → decode และอ่าน register ได้ในขั้นเดียว
• Load/store addressing: คำนวณ address ใน stage 3 (EX) แล้วเข้าถึง memory ใน stage 4 (MEM)

7.3 Hazards — สถานการณ์ที่ขวางการเริ่ม instruction ถัดไปใน cycle ถัดไป

Structure hazard

• ตัวอย่าง: pipeline RISC-V ที่มี memory เดียว — load/store ต้อง access data ตรงกับ IF ของอีกคำสั่ง → IF ต้อง stall 1 cycle → เกิด bubble
• แก้: pipelined datapath ต้องมี instruction memory / data memory แยก (หรือ I-cache/D-cache แยก)

Data hazard

Forwarding (bypassing) = นำผลมาใช้ ทันทีที่คำนวณได้ ไม่ต้องรอเขียนลง register · ต้องเพิ่มการเชื่อมต่อใน datapath

Load-use data hazard: forwarding แก้ได้ไม่เสมอ — ถ้าค่ายังไม่ถูกคำนวณตอนต้องใช้ ("ส่งย้อนเวลาไม่ได้!") ต้อง stall 1 cycle

Code scheduling เพื่อเลี่ยง stall

Control hazard

• branch กำหนดทิศทาง — การ fetch คำสั่งถัดไปขึ้นกับผล branch แต่ branch ยังอยู่ใน ID
• ใน RISC-V pipeline ต้อง เปรียบเทียบ register และคำนวณ target เร็ว → เพิ่ม hardware ทำใน ID stage
• Stall on branch — รอผล branch ก่อน fetch ต่อ (ช้า)

7.4 Pipelined Datapath & Control

• datapath แบ่งเป็น IF, ID, EX, MEM, WB · ข้อมูลไหล ซ้ายไปขวา ยกเว้น 2 จุดที่ไหล ขวาไปซ้าย (WB เขียน register, และเลือก PC ใหม่) → เป็นต้นเหตุของ hazards
• ต้องมี pipeline registers คั่นระหว่าง stage เพื่อเก็บข้อมูลที่ได้จาก cycle ก่อน: IF/ID, ID/EX, EX/MEM, MEM/WB
• Single-clock-cycle diagram = สถานะ pipeline ใน 1 cycle (เห็นทรัพยากรที่ใช้) vs multi-clock-cycle diagram = กราฟตามเวลา (รูปแบบ "traditional" และแบบแสดงทรัพยากร)
• ตัวอย่าง load: IF → ID → EX (คำนวณ address) → MEM (อ่าน memory) → WB (เขียน register) · จุดผิดพลาดที่แก้: ใน WB หมายเลข register ปลายทาง (Rd) ต้อง ส่งต่อผ่าน pipeline registers มาจนถึง MEM/WB — เดิมใช้ผิดตัว ("wrong register number") → "Corrected datapath for load"
• Pipelined control (simplified): สัญญาณควบคุมถูกสร้างใน ID แล้วส่งไปตาม pipeline registers ตามสถานะของแต่ละ stage (EX, MEM, WB)

7.5 Data Hazards: Forwarding vs Stalling

Detecting the need to forward

ส่ง เลข register ไปตาม pipeline · ใน EX stage ALU operand คือ ID/EX.RegisterRs1 และ ID/EX.RegisterRs2

แต่ เฉพาะเมื่อ instruction ที่ forward เขียน register จริง (EX/MEM.RegWrite, MEM/WB.RegWrite) และ Rd ≠ x0 (RegisterRd ≠ 0)

Double data hazard

7.6 Load-Use Hazard Detection & Stalling

• ตรวจใน ID stage ตอนถอดรหัสคำสั่งที่ใช้ค่า: operand คือ IF/ID.RegisterRs1, IF/ID.RegisterRs2
• Load-use hazard เมื่อ: ID/EX.MemRead และ (ID/EX.RegisterRd = IF/ID.RegisterRs1 หรือ = IF/ID.RegisterRs2) (สไลด์พิมพ์ Rs1 ซ้ำสองครั้ง — ตัวที่สองควรเป็น Rs2)
• ถ้าตรวจพบ: stall และสอด bubble

วิธี stall pipeline

1. บังคับค่าควบคุมใน ID/EX register เป็น 0 → EX, MEM, WB ทำ nop (no-operation)
2. ห้ามอัปเดต PC และ IF/ID register → คำสั่งที่ใช้ค่าถูก decode ซ้ำ และคำสั่งถัดไปถูก fetch ซ้ำ
3. stall 1 cycle ให้ MEM อ่านข้อมูลของ ld ได้ แล้วจึง forward เข้า EX ได้

7.7 Control Hazards & Branch Prediction

Branch hazard

• ถ้ารู้ผล branch ที่ MEM stage: คำสั่งที่ fetch ผิดไปแล้ว (3 คำสั่ง) ต้อง flush (ตั้งค่า control เป็น 0)
• Reducing branch delay: ย้าย hardware ตัดสินผลมาที่ ID stage — เพิ่ม target address adder + register comparator

Branch prediction

• pipeline ยาวขึ้นรู้ผลเร็วไม่ได้ → stall penalty รับไม่ได้ → ทำนายผล branch และ stall เฉพาะเมื่อ ทำนายผิด
• RISC-V pipeline: ทำนายว่า ไม่ taken — fetch คำสั่งถัดไปได้เลยไม่เสียเวลา

8.1 Introduction & ความยากของ Parallel Programming

• เป้าหมาย: เชื่อมต่อคอมพิวเตอร์หลายเครื่อง/หลาย processor เพื่อ performance สูงขึ้น — ได้ scalability, availability, power efficiency
• Task-level (process-level) parallelism: throughput สูงสำหรับงานอิสระหลายงาน
• Parallel processing program: โปรแกรมเดียวรันบนหลาย processor · Multicore microprocessor: ชิปที่มีหลาย processor (core)

ซอฟต์แวร์ sequential/concurrent รันบน hardware serial/parallel ได้ · ความท้าทาย = ใช้ parallel hardware ให้ได้ผลจริง

สิ่งที่เรียนมาแล้วเกี่ยวกับ parallelism: Synchronization (§2.11) · Subword parallelism (§3.6) · Advanced ILP (§4.10) · Cache coherence (§5.10)

8.2 SISD, SIMD, MIMD, SPMD และ Vector

SPMD (Single Program Multiple Data) = โปรแกรม parallel บนเครื่อง MIMD ที่มี conditional code ให้ processor ต่างตัวทำต่างกัน

Vector processors

• function unit แบบ pipeline สูง · stream ข้อมูลจาก/ไป vector registers · ข้อมูลถูกเก็บจาก memory เข้า register และผลเก็บกลับ
• ตัวอย่าง Vector extension ของ RISC-V: v0–v31 = 32 registers × 64 element (element 64 บิต) · fld.v / fsd.v load/store vector · fadd.d.v บวก vector double · fadd.d.vs บวก scalar เข้าทุก element · fmul.d.vs คูณ vector กับ scalar
• ลด instruction-fetch bandwidth ได้มาก

// Conventional RISC-V                         // Vector RISC-V
fld   f0, a(x3)      // load scalar a            fld     f0, a(x3)
addi  x5, x19, 512   // end of array X           fld.v   v0, 0(x19)       // load vector x
loop: fld f1, 0(x19)                             fmul.d.vs v0, v0, f0     // vector-scalar multiply
      fmul.d f1, f1, f0                          fld.v   v1, 0(x20)       // load vector y
      fld f2, 0(x20)                             fadd.d.v v1, v1, v0      // vector-vector add
      fadd.d f2, f2, f1                          fsd.v   v1, 0(x20)       // store vector y
      fsd f2, 0(x20)
      addi x19,x19,8 ; addi x20,x20,8
      bltu x19,x5,loop

Vector vs Scalar

• ทำ data-parallel programming ง่ายขึ้น · ระบุชัดว่าไม่มี loop-carried dependence → hardware ตรวจน้อยลง
• access pattern สม่ำเสมอได้ประโยชน์จาก interleaved และ burst memory
• เลี่ยง control hazard เพราะไม่มี loop
• general กว่า media extension แบบ ad-hoc (MMX, SSE) และเข้ากับ compiler ดีกว่า

SIMD

• ทำงานกับ vector of data ทีละ element · เช่น MMX, SSE ของ x86 — เก็บหลาย element ใน register กว้าง 128 บิต
• ทุก processor ทำ instruction เดียวกันในเวลาเดียวกัน (แต่ address ข้อมูลต่างกัน) → sync ง่าย, instruction control hardware น้อย · เหมาะกับงาน data-parallel สูง

8.3 Hardware Multithreading

รันหลาย thread พร้อมกัน · replicate registers, PC ฯลฯ · สลับ thread เร็ว

อนาคต: ด้วย power → microarchitecture ง่ายขึ้น · multithreading แบบง่าย ทน cache-miss latency · หลาย core ง่าย ๆ อาจแชร์ทรัพยากรได้ดีกว่า

8.4 Shared Memory & Multicore

• SMP (Shared memory Multiprocessor): hardware ให้ single physical address space สำหรับทุก processor · sync ตัวแปรร่วมด้วย locks
• เวลาเข้าถึง memory: UMA (Uniform Memory Access — เท่ากันทุก processor) vs NUMA (Nonuniform — ขึ้นกับว่า memory อยู่ใกล้ไกล)

half = 64;
do {
  synch();
  if (half%2 != 0 && Pn == 0)
      sum[0] += sum[half-1];   // half เป็นเลขคี่ — P0 รับ element ที่ขาด
  half = half/2;
  if (Pn < half) sum[Pn] += sum[Pn+half];
} while (half > 1);

8.5 Introduction to GPUs

• ประวัติ: video card ยุคแรก = frame buffer memory + address generation ส่งออกวิดีโอ → 3D graphics (เริ่มจากเครื่องระดับสูงเช่น SGI) → Moore's Law ทำให้ถูกลง ความหนาแน่นสูง → 3D graphics card ใน PC และ game console
• GPU = Graphics Processing Unit: processor ที่มุ่งงาน 3D graphics: vertex/pixel processing, shading, texture mapping, rasterization

สถาปัตยกรรม GPU

• การประมวลผล data-parallel สูง · GPU เป็น highly multithreaded — ใช้ thread switching ซ่อน memory latency จึงพึ่ง multi-level cache น้อย
• graphics memory กว้างและ bandwidth สูง · แนวโน้ม general-purpose GPU
• Heterogeneous CPU/GPU: CPU ทำโค้ด sequential, GPU ทำโค้ด parallel
• Languages/APIs: DirectX, OpenGL, C for Graphics (Cg), HLSL, CUDA (Compute Unified Device Architecture)

Classifying GPUs

ไม่เข้าโมเดล SIMD/MIMD เป๊ะ: conditional execution ใน thread ให้ภาพลวง MIMD แต่ performance ตก ต้องเขียนโค้ด general-purpose อย่างระวัง

เปรียบเทียบ Multicore with SIMD vs GPU

8.6 Clusters & Message Passing

Loosely coupled clusters

• เครือข่ายของคอมพิวเตอร์อิสระ — แต่ละเครื่องมี private memory และ OS · เชื่อมผ่าน I/O system (เช่น Ethernet/switch, Internet)
• เหมาะกับงานอิสระ: web server, database, simulation · high availability, scalable, ราคาไม่แพง
• ปัญหา: ค่าบริหารจัดการ (นิยมใช้ virtual machine) · interconnect bandwidth ต่ำ เมื่อเทียบ processor/memory bandwidth ของ SMP

Grid computing

คอมพิวเตอร์แยกกันเชื่อมด้วย long-haul network (เช่น Internet) · แจก work unit ไปประมวลผลแล้วส่งผลกลับ · ใช้ เวลาว่างของ PC ได้ — เช่น SETI@home, World Community Grid

8.7 Interconnection Network Topologies

Network topology = การจัดเรียง processor, switch และ link

Network characteristics

• Performance: latency ต่อ message (เครือข่ายไม่โหลด) · throughput: link bandwidth, total network bandwidth, bisection bandwidth · congestion delays (ขึ้นกับ traffic)
• และ Cost, Power, Routability in silicon

8.8 Parallel Benchmarks & Performance Model

• Code or applications? Benchmark ดั้งเดิมใช้โค้ด/ข้อมูลตายตัว แต่ parallel programming กำลังวิวัฒน์ → ควรเปรียบเทียบระบบจากการที่มัน implement application ที่กำหนด (เช่น Linpack, Berkeley Design Patterns) เพื่อกระตุ้นนวัตกรรม

Modeling performance (Roofline)

• metric ที่สนใจ: achievable GFLOPs/sec (วัดด้วย computational kernels จาก Berkeley Design Patterns)
• Arithmetic intensity ของ kernel = FLOPs ต่อ byte ของ memory ที่เข้าถึง
• สำหรับแต่ละเครื่องหา: Peak GFLOPS (จาก data sheet) และ Peak memory bytes/sec (ใช้ Stream benchmark)