• องค์ประกอบหลักของคอมพิวเตอร์: CPU, Input/Output, Memory, Storage, Motherboard, Power Supply
• ภายใน CPU: Control Unit, Arithmetic (ALU), Registers และ Bus สำหรับเชื่อมต่อ
• อาจารย์บอกว่าเป็นเรื่อง "basic มากๆ" จดไว้ในโน้ตได้เลย

• อาจารย์พูดเสมอว่า CPU ทำงานเป็น "สเต็ป" (3 หรือ 5 สเต็ปแล้วแต่รุ่น/แบรนด์) แต่หลัก ๆ หนีไม่พ้น:
  1. Fetch ดึงคำสั่ง
  2. Decode ถอดรหัสว่าต้องทำอะไร แล้วเตรียมข้อมูล
  3. Execute ประมวลผล (บวก ลบ คูณ หาร)
  4. Store เก็บผลลัพธ์ลง Register หรือ Memory
• บางที่เรียกขั้นสุดท้ายว่า Write back ขึ้นกับประเภท/แบรนด์ของ CPU

• PC (Program Counter) เก็บ ตำแหน่ง ของคำสั่งที่จะประมวลผลถัดไป
• IR (Instruction Register) เก็บ คำสั่งที่ Fetch มาแล้ว
• กลุ่ม Status / Flag register เก็บสถานะ เช่น Overflow, Negative flag
• อาจารย์บอกว่าส่วนนี้ "ไม่น่ามีประเด็น"

• เป็นรูป สามเหลี่ยมพีระมิด: บนสุดเร็วสุดคือ Register → รองลงมาคือ Cache (พักข้อมูลจาก Memory ให้ CPU คุยได้เร็วขึ้น)
• รายละเอียดของ Cache อาจารย์ให้ไปดูสไลด์ส่วนขยายภายหลัง (Ch04)
• ส่วน overview ของ multi-core / multi-thread อยู่ในสไลด์ถัดไป อาจารย์บอกว่าจะกลับมาพูดอีกครั้ง

• Performance = ความเร็ว/ประสิทธิภาพ ถ้าบอกว่า CPU A เร็วกว่า B กี่เท่า ให้เอา Performance A ÷ Performance B
• ในทางเวลาคือกลับด้าน: Execution time ของ B ÷ Execution time ของ A
• อาจารย์เรียกว่า "บัญญัติไตรยางศ์ง่ายๆ" แค่ อ่านโจทย์ดีๆ: เร็วกว่า = ใช้เวลาน้อยกว่า, ใช้เวลามากกว่า = ช้ากว่า

• Clock frequency (speed) = 1 ÷ Clock period (คาบ)
• CPU time หาได้จาก CPU clock cycles ÷ clock rate
• CPI = Clock cycles per Instruction (อาจารย์ให้ "ดูดีๆ")
• CPU time = Instruction count × CPI × Cycle time เมื่อเทียบสองเครื่อง ตัวแปร Instruction count ตัดทิ้งได้ (ถ้าไม่รู้ค่าก็ติดตัวแปรไว้ก่อน) แล้วหารกันเพื่อดูว่าเร็วกว่ากี่เท่า

• อาจารย์เช็กว่าทุกคนตามทัน แล้วให้นักศึกษาช่วยอัดวิดีโอ (ระหว่าง 08:39–11:30 เป็นช่วงหาปุ่มอัด ไม่มีเนื้อหาวิชา)
• ตอนไปสไลด์ที่ 2 อาจารย์ย้ำว่า "สไลด์ที่ 1 พอจับได้นะว่าอาจารย์เน้นตรงจุดไหน" และเรียกว่าเป็นฮินต์สุดๆ

• Von Neumann: Input → CPU → Output โดย Memory เป็นก้อนเดียว เก็บทั้งคำสั่งและข้อมูล (แบ่งกันภายใน)
• Harvard: Control Unit อยู่กลางคุยกับ ALU, Data Memory และ Instruction Memory ที่ แยกกัน พร้อม I/O
• กลุ่ม Harvard ส่วนใหญ่เป็นตระกูล Microcontroller
• คำศัพท์รวม: "structure model ของคอมพิวเตอร์มี 2 ไทป์"

• Bus แยกหน้าที่: Address bus (บอกตำแหน่งใน Memory), Data bus (ส่งข้อมูล), Control bus (สัญญาณเปิด/ปิด/เลือกอุปกรณ์ เช่น I/O)
• Point-to-point: แยกทุกหน้าที่ออกจากกัน ง่ายสุดแต่ เปลืองเส้น (Data ชุดหนึ่ง Address ชุดหนึ่ง Control ชุดหนึ่ง)
• Multipoint: ประหยัดเส้น เหมือน ถนนไฮเวย์ (เส้นหลัก) + ถนนซอย ที่แยกไปหา CPU/Memory/Disk/I/O แต่การสื่อสารซับซ้อนขึ้น จึงต้องมี โปรโตคอลควบคุม

1. Daisy chain: ให้สิทธิ์ตาม priority คนสูงสุดได้ใช้ก่อน ไม่ต้องคิดเยอะ (นิยมสุด ใช้กันถึงทุกวันนี้) ปกติ CPU สูงสุด ตามด้วย Memory ข้อเสีย: อุปกรณ์ priority ต่ำ (เช่น I/O) แทบไม่ได้ใช้ bus
2. Centralized parallel: แต่ละอุปกรณ์ต่อตรงเข้าวงจรควบคุมกลาง (arbitration circuit) มีตัวกลางคอย observe ว่าใครจะใช้
3. Distributed with self-detection: ไม่มีตัวกลาง อุปกรณ์ตัดสินกันเอง ต้องเช็กเองว่ามีใครส่งอยู่ไหม
4. Distributed with collision-detection: เช็กเองเหมือนข้อ 3 แต่เพิ่มวงจรตรวจจับการชน ถ้าข้อมูลชนกันเสียหาย ส่งซ้ำ (retransmit)

• Programming in hardware: ข้อมูลกับ logic ถูกสร้างเป็น วงจร ใส่ข้อมูลเข้าไปก็ได้คำตอบออกมา ทำได้ เร็ว เพราะออกแบบมาเฉพาะงาน แต่ ล็อกตายตัว
• Software (general purpose): มีชุดคำสั่งบอกว่าจะให้ทำอะไร ยืดหยุ่น ต้อง "คิด" ก่อนทุกครั้งว่าคำสั่งนี้ต้องทำอะไร
• เปรียบเทียบของอาจารย์: ร้านอาหารตามสั่ง (สั่งได้ทุกเมนู) vs เครื่องที่ถูกโปรแกรมมาให้ผัดข้าวผัดอย่างเดียว
• ฝั่งซอฟต์แวร์มองเป็น ลำดับคำสั่ง ที่ทำทีละบรรทัด ส่วน component ในสถาปัตยกรรมคือ ฮาร์ดแวร์/วงจร เช่น CPU, I/O

• MAR (Memory Address Register): เก็บ Address ของตำแหน่งใน Memory ที่จะคุยด้วย
• MBR (Memory Buffer Register): เก็บ data ที่โหลดออกจาก Memory หรือที่กำลังจะเขียนเข้า Memory
• IOAR (I/O Address Register): เก็บ Address ของอุปกรณ์ I/O (เช่น 001 = คีย์บอร์ด, 002 = อีกตัว ตามที่โปรแกรมแม็ปไว้)
• IOBR (I/O Buffer Register): เก็บข้อมูลที่รับมาจาก I/O

• Fetch + Decode ไปด้วยกัน แล้ว Execute
• ตัวอย่างบนสไลด์: PC = 300 → ไปดู Memory ตำแหน่ง 300 ได้ 1940 → โหลดเข้า IR
• ดู instruction format: 4 บิตบน = opcode → 0001 หมายถึง Load AC จาก Memory ส่วนที่เหลือ (940) คือ Address
• Memory ตำแหน่ง 940 มีค่า 0003 → โหลดมาใส่ใน AC ได้ 0003
• อาจารย์บอกว่านี่คือ assignment ที่เคยทำ ให้เข้าใจว่า opcode บอกว่าทำอะไร ส่วนที่เหลือเป็น Address ของข้อมูล

ปกติคำสั่งทำงาน Fetch → Decode → Execute วนไปเรื่อย ๆ จนกว่าจะมี Interrupt มาขัดจังหวะ อาจารย์ย้ำว่า "จำไว้เลย":

1. เซฟค่า ตัวแปรและ Register ปัจจุบันไว้ก่อน
2. ดูว่าใครเป็นคนเรียก โดยเปิด Interrupt Vector table (เช่น Interrupt เบอร์ 003 = คีย์บอร์ด) เพื่อหา ISR Address
3. เอา Address นั้นใส่ใน PC แล้วกระโดดไปทำ ISR (Interrupt Service Routine)
4. ทำเสร็จ Restore ค่า Register ที่เซฟไว้ แล้วกระโดดกลับไปทำงานเดิมต่อ

อาจารย์บอกว่าตอนท้ายสไลด์มีเรื่อง Interrupt อีกครั้งแบบจริงจัง

• Sequential: Interrupt เกิด → ไปทำ → กลับมา → เกิดอีกครั้ง → ไปทำ → กลับมา ตามลำดับ
• Nested interrupt: ระหว่างทำ service routine ของ Interrupt X มี Interrupt Y ซ้อนเข้ามา → ต้อง เซฟสถานะของ X ก่อนไปทำ Y เสร็จแล้ว คืนค่าของ X ทำ X ต่อจนจบ แล้วค่อย return กลับโปรแกรมปกติ
• ซ้อนได้กี่ชั้นขึ้นกับสถาปัตยกรรม CPU ของแต่ละแบรนด์ ว่ามี Register ให้เซฟค่าจากการ Interrupt กี่ชุด (มี 2 ชุด = ซ้อนได้ 2 ที) ถ้าซ้อนเกินกว่าที่ Register เก็บได้ก็ซ้อนต่อไม่ได้
• Interrupt คือสิ่งที่ ขัดขวางการทำงานแบบ sequence ของ CPU

• ต้องรู้ว่า Sign-Magnitude บวกลบกันอย่างไร
• 2's Complement: เวลาเอามาลบกัน ทำให้เป็น 2's Complement โดย กลับบิต (invert) แล้วบวก 1

• มีคนถามว่า Assembly ออกอย่างไร อาจารย์ตอบว่า ข้อสอบเป็นช้อยส์ ไม่ได้ให้เขียนโค้ด ต้องเข้าใจเพียงว่าคำสั่ง ทำอะไร
• ตัวอย่าง: ADD A, B, C = เอา B บวก C แล้วเก็บใน A
• อาจารย์ ไม่ได้เจาะจงว่าเป็น RISC-V ไม่ได้ระบุว่าต้องเป็น MIPS, ARM หรือตระกูลไหน เป็นแค่ความรู้ทั่วไป ไม่ต้องไปท่องเฉพาะเจาะจงตระกูล

• มี 2 ไทป์ที่เคยคุยกัน คือ Big-Endian กับ Little-Endian (สลับกันแค่นี้เอง)
• ตามที่อาจารย์อธิบาย (เรียงบนกระดาษซ้าย–ขวา เช่น 8 บิต 0–7): Little-Endian = บิต 0 (บิตล่าง/น้อยสุด) อยู่ขวามือ ส่วน Big-Endian = บิต 0 อยู่ซ้ายมือ
• เวลาเขียนเลขฐาน 16 ที่เราคุ้นเคย มักคุ้นกับแบบ Little-Endian มากกว่า แต่ ในโลกจริงมีทั้งสองค่าย

ผมเสริมจากสไลด์: สไลด์นิยามด้วย byte address ดูรูป address mapping ด้านล่างประกอบ (ไม่ใช่คำพูดของอาจารย์)

• LOAD (บางที่เขียน LD, LOD): เอาค่าจาก Memory → Register
• STORE (ST, STOR): ตรงข้าม เอาจาก Register → Memory
• ADD: บวกธรรมดา
• ADDI: แทนที่จะบวก Register 2 ตัว จะ บวก Register กับค่าคงที่ (immediate) เช่น เอา x22 + 4 แล้วเก็บใส่ x22

• ถ้าข้อสอบออก จะ มีแผนภาพ (chart) ให้ เพื่อบอกว่า opcode คืออะไร
• 7 บิตล่าง = opcode บอกว่าเป็นคำสั่งบวก/ลบ/คูณ/หาร → มี opcode ได้ 2⁷ แบบ
• rs1 = source register ตัวที่ 1, rs2 = source ตัวที่ 2, rd = destination register ทั้ง 3 ตัว ละ 5 บิต → มี Register ได้ 2⁵ ตัว
• ตัวอย่างที่อาจารย์ยก: add x9, x20, x21 (เอา Register 20 บวก 21 เก็บใน 9) แปลงเป็น machine code: opcode = 51 (คำสั่งบวก), rd = 9, rs1 = 20, rs2 = 21
• I-format: ใช้ 12 บิตบน เป็นค่าคงที่ (immediate) สำหรับคำสั่งที่มีค่าคงที่
• คำสั่งอื่นที่อาจเจอ: OR (OR ระดับบิต), Exclusive-OR (XOR) เป็น exclusive ธรรมดา

ซับของคลิปนี้จบที่ 37:32 ตรงช่วงที่อาจารย์กำลังพูดถึงคำสั่งที่ "น่าสนใจ" ต่อ ส่วนที่เหลือไม่มีข้อมูล

• คำสั่ง Logic: AND, OR, XOR เอาค่าใน Register มา AND / OR / Exclusive-OR กัน "ไม่ยาก"
• Shift left = เลื่อนบิตไปทางซ้ายทีละตำแหน่ง ตีความได้ว่าเป็น การคูณ
• Shift right = เลื่อนไปทางขวา ตีความได้ว่าเป็น การหาร

• คำสั่งกระโดดมี jump และ branch ส่วน branch จะ เช็กเงื่อนไขก่อน ใช้เวลาเขียนลูป
• 4 ตัวที่อาจารย์ชี้ว่าน่าสนใจ:
  • beq (branch equal): ถ้าค่าใน register 1 กับ 2 เท่ากัน กระโดดไป L1
  • bne (branch not equal): กระโดดเมื่อ ไม่เท่ากัน
  • blt (less than): กระโดดเมื่อ rs1 น้อยกว่า rs2
  • bge (greater than or equal): กระโดดเมื่อ rs1 มากกว่าหรือเท่ากับ rs2

• Procedure คือฟังก์ชัน เมื่อโปรแกรมเรียกไปยัง procedure อื่น เปรียบเหมือน software interrupt (ขัดจังหวะโดยซอฟต์แวร์เอง)
• ต้อง save ค่าทั้งหมดลง stack ก่อนกระโดดไป เมื่อทำ procedure เสร็จแล้วกลับมา ก็ return ค่าจาก stack เข้าไป
• อาจารย์บอกว่า ส่วนที่เหลือของ Assembly "ไม่น่ามีอะไร"

• ยอดพีระมิด: ทำงานเร็ว แต่ แพง จึงเก็บได้น้อย
• ฐานพีระมิด: ทำงานช้า ราคาถูก เก็บได้เยอะมาก
• เรียงจากบนลงล่าง: Register → Cache → Main memory → (นอกบอร์ด) Magnetic disk, CD-ROM, DVD, Blu-ray → Magnetic tape
• Magnetic tape ราคาถูกมาก ใช้ใน big data center เป็น offline storage เก็บได้มหาศาล

• Main memory ช้า ถ้า CPU เรียกใช้บ่อยจะติดขีดจำกัด จึงสร้าง Cache เป็นหน่วยความจำเร็วๆ มาคั่นกลาง
• Cache เก็บ ข้อมูลที่ใช้บ่อย/ใช้ซ้ำ และเตรียมโค้ดที่จะรันไว้ จึงไม่ต้องเสียเวลา access Memory
• มีหลายระดับ L1, L2, L3 (กี่ level ขึ้นกับงบ/รุ่นของ CPU)
• L1 อยู่ชิด CPU และอยู่ในก้อนเดียวกัน ส่วน L2 / L3 อยู่ออกมาจากตัว CPU

• Hit = เปิดดูแล้ว เจอข้อมูลใน cache
• Miss = ไม่เจอ → ไปเอาข้อมูลจริงจาก main memory มาใส่ cache แล้วค่อยส่งให้ CPU ใช้

• SRAM (Static RAM): ใช้ transistor เปิด-ปิด (on-off) แค่ไม่กี่ตัว เร็วกว่า DRAM เกือบ 100 เท่า แต่ราคาแพงกว่า
• DRAM (Dynamic RAM): transistor น้อยกว่า เก็บข้อมูลเป็น ประจุใน capacitor ต้องคอยชาร์จประจุอยู่ตลอด จึง ช้ากว่า แต่ ถูกกว่า
• Flash (NOR gate หรือ NAND gate): เก็บ logic 0/1 ด้วย transistor ใช้เป็น storage ทั่วไป
• Hard disk: จุได้เยอะกว่า flash เขียนข้อมูลด้วย magnetic (ไปดูรายละเอียดอีกครั้งในบท storage)

ตัวเลขในตารางมาจากสไลด์ Memory Technology (ไม่ใช่คำพูดของอาจารย์)

• cache มีหลักการหลัก ๆ 2–3 แบบ แบบแรกที่ง่ายสุดคือ direct-mapped
• ตำแหน่งใน cache = block address modulo จำนวนบล็อกใน cache
• ตัวอย่าง: cache 8 บล็อก (index 000–111) → เอา block address mod 8 ก็คือดู 3 บิตล่าง เป็น index
• ข้อดี: ง่าย · ข้อเสีย: ตำแหน่งเดียวกันมีหลายเลขที่อยากเข้ามาอยู่ (เช่น ตำแหน่ง 1 กับ 11 ลงท้าย 1 เหมือนกัน) จึงแย่งกันได้

• สไลด์: cache 8 บล็อก, 1 word/block, direct-mapped เริ่มต้น cache ว่างเปล่า (Valid = N)
• แยก address: ตัวอย่าง 10110 (= ที่ 22): 2 บิตบน = Tag (10) · 3 บิตล่าง = Index (110)
• ครั้งแรกที่ขอ 22 → Miss แน่นอน (cache ว่าง) → ไปเอาจาก main memory เขียนลง cache ช่อง 110, ตั้ง V = Y, ใส่ tag 10 แล้วส่งข้อมูลให้ CPU
• ขอ 26 (11010): Miss เหมือนกัน → เก็บที่ index 010, tag 11
• ขอ 22 และ 26 อีกครั้ง → มีข้อมูลแล้ว จึง Hit ไม่ต้องไป main memory
• ขอ 16 (10 000) Miss, 3 (00 011) Miss, ขอ 16 ซ้ำ = Hit
• ขอ 18 (10 010): index 010 มีข้อมูลเดิมอยู่ แต่ tag ไม่ตรง (เดิม 11 ใหม่ 10) → Miss แล้วเขียนทับ
• วิธีเช็กว่า hit หรือ miss: ดู Index → เทียบ Tag → ดูว่า V (Valid) เป็น Y หรือไม่
• ถ้ามี index (บล็อก) เยอะ โอกาสเจอ (hit) ก็มากขึ้น

• โจทย์ตัวอย่างบนสไลด์: cache 64 บล็อก, บล็อกละ 16 ไบต์ ถามว่า address 1200 ไปอยู่บล็อกที่เท่าไร
• ขั้นที่ 1: Block address = ⌊1200 / 16⌋ = 75
• ขั้นที่ 2: Block number = 75 modulo 64 = 11

ซับของ Gemini ถอดตัวเลขกลางทางสลับกัน (ได้ยินเป็น 17/75) ผมยึดตัวเลขตามสไลด์ที่อาจารย์เปิดอยู่ ซึ่งสอดคล้องกับคำตอบสุดท้ายที่อาจารย์บอก "ประมาณ 11"

• เมื่อ miss ต้องไปเอาข้อมูลจาก main memory เขียนลง cache แล้วส่งให้ CPU:
  • Write-through: เขียนลง cache แล้ว ส่งให้ CPU เลย (ตามคำอธิบายของอาจารย์)
  • Write-back: ส่งข้อมูลให้ CPU ก่อน แล้วค่อย อัปเดตบล็อกใน cache ทีหลัง
  • Write-allocation: อีกทางเลือกหนึ่งของ write-through
• เรื่องเล่าของอาจารย์: เมื่อ 10 กว่าปีก่อนมีงานวิจัย (paper) แข่งกันเรื่องกลไกการเขียนค่าเยอะมาก เพราะ cache สมัยนั้นยังไม่เร็ว แต่ ปัจจุบัน transistor เล็กลงเหลือระดับ 2–4 นาโนเมตร memory เร็วและจุได้มากขึ้น เรื่องความเร็วไม่ใช่ปัญหาหนัก algorithm การเขียนค่าเหล่านี้จึงค่อย ๆ หายไป เพราะ "ลงทุนทำเยอะ แต่ improvement ไม่มีนัยสำคัญ"
• ปัจจุบันเน้นแค่ ยัดโค้ดที่ execute บ่อยๆ เข้า cache L1 ให้ได้เยอะที่สุด ทุกอย่างก็ hit และ performance ดีขึ้น

• นอกจาก direct-mapped ยังมี set-associative กับ fully-associative
• แทนที่จะให้ index 0 เก็บได้ 1 ชุด ก็ให้เก็บได้หลายชุดเป็น set:
  • 2-way เก็บ 2 · 4-way เก็บ 4 · 8-way เก็บ 8 · 16-way เก็บ 16
• อาจารย์สรุปว่า "ไม่ได้ฉลาดอะไรมากขึ้น" แค่ ขยายจำนวนที่เก็บใน index เดียวกัน เพื่อเพิ่มความน่าจะเป็นของการ hit
• จึงทำให้ set-associative มีโอกาส hit มากกว่า direct-mapped แบบ 1 ต่อ 1

• มีการวิจัยดูว่าเพิ่มทีละ 2, 4, 8, 16 แล้ว performance ไปถึงไหน: ความน่าจะเป็นที่ hit ดีขึ้นแต่ได้น้อยลงเรื่อย ๆ (diminishing returns)
• ตัวเลขบนสไลด์ (miss rate): 1-way 10.3% · 2-way 8.6% · 4-way 8.3% · 8-way 8.1%

ซับหยุดที่ 25:00 จากภาพในคลิป ช่วง 25:30 อาจารย์ยังอยู่ที่สไลด์นี้ และเมื่อถึง 26:20 เปิดสไลด์ Dependability Measures (MTTF, MTTR, Availability) คำพูดช่วง 25:00–26:51 ไม่มีข้อมูล จึงสรุปไม่ได้ว่าอาจารย์พูดอะไร

• I/O = Input / Output ใช้ buffer เก็บข้อมูลที่ผ่านเข้า-ออก
• ข้อมูลอาจเป็น digital หรือ analog ขึ้นกับว่าส่งผ่านทางสายหรืออากาศ (ในแผนภาพคือ Transducer ที่แปลงสัญญาณ)
• ในสไลด์ External Device ประกอบด้วย Control Logic, Buffer, Transducer มีเส้น Control, Status, Data

1. Control & timing: ควบคุมการไหลของข้อมูลระหว่างภายในกับอุปกรณ์ภายนอก
2. Processor communication: ถอดรหัส command, ส่งข้อมูล, รายงาน status, จดจำ address ปลายทาง
3. Device communication: คุยกับอุปกรณ์ด้วย command
4. Data buffering: เก็บข้อมูลที่ส่งเข้ามาไว้ก่อน (ถ้า input ก็เอาเข้า memory ถ้า output ก็ส่งออกไปอุปกรณ์)
5. Error detection: ตรวจจับ error ที่เกิดขึ้นระหว่างส่งผ่าน I/O

• Address lines: บอกว่าจะคุยกับ I/O ตัวไหน
• Control lines: บอกว่า I/O ต้องทำอะไร
• Data lines / data bus: ชุดข้อมูลที่ส่งผ่าน
• กลุ่ม Status และ control ต่าง ๆ ที่เกี่ยวข้อง

1. Programmed I/O (ง่ายที่สุด): processor ยิงคำสั่งไปให้ I/O แล้ว รอจนกว่า I/O ตอบกลับ จึงได้ข้อมูล คำสั่งไม่ยาก แต่ เสียเวลา processor เพราะต้องนั่งรอ (ไม่มี interrupt)
2. Interrupt-driven I/O: processor สั่งแล้ว ไปทำงานอื่นต่อได้ เมื่อ I/O พร้อมส่งข้อมูลจึง interrupt กลับมา แล้ว processor ค่อยหันมารับ/ส่งข้อมูล
3. DMA (Direct Memory Access): I/O กับ main memory แลกเปลี่ยนข้อมูลกันตรง ๆ โดย CPU ไม่ต้องยุ่ง CPU ไปคำนวณงานของตัวเอง

• คำสั่ง (command) ของ I/O มี 4 แบบ: Control (บอกให้ทำอะไร), Test (ดู status ก่อน), Read, Write (I/O มีทั้ง input และ output)
• แบบ Programmed: flowchart เรียงเป็น sequence ไม่ยาก
• แบบ Interrupt: processor แยกออกมาทำงานของตัวเองได้ และทำงานกับ I/O ก็ต่อเมื่อถูก interrupt
• แบบ DMA: flow ของ CPU ง่ายสุด เพราะแยกออกจากกัน

• ทุกครั้งที่เกิด interrupt ต้อง เก็บค่า PC และ status register ไว้ก่อนเริ่มทำงาน (เหมือน flow ที่เคยเรียนใน Ch02)
• จากนั้น PC ถูกเปลี่ยนเป็นค่าเริ่มต้นของ ISR แล้วเข้าไปรัน
• เมื่อรัน interrupt เสร็จ return: เอาค่า PC เดิมก่อนกระโดดกลับเข้า PC และ คืนค่าใน stack ทั้งหมด แล้วจึงกลับมาทำงานต่อ

1. Multiple interrupt lines: แยกเส้น interrupt คนละเส้น ตรงไปตรงมา ทำให้รู้ทันทีว่าใครเรียก ข้อเสีย: ถ้ามี I/O เยอะ เส้น interrupt ก็เยอะตาม
2. Software poll: processor กระโดดไปที่ routine ที่ไล่ถาม (poll) ทีละ I/O module ว่าใครเป็นคนเรียก (ใช้เวลานาน)
3. Daisy chain (hardware poll, vectored): กำหนด priority ว่าใครสำคัญสูง/ต่ำ ส่งสัญญาณ interrupt acknowledge ต่อกันเป็นลูกโซ่
4. Bus arbitration (vectored): I/O module ต้อง ขอสิทธิ์คุม bus ก่อน จึงจะขอ interrupt ได้ เมื่อได้รับ request แล้ว module จะส่ง address/vector ของ device ผ่านสาย data/address

ตอนท้ายคลิป (ประมาณ 10:24–10:58) อาจารย์พูดถึงเทคนิคการต่อพ่วงกับ I/O ที่คล้ายวงจรประเภท multiplexer (เลือก 1 จาก 8) ซับถอดได้ไม่ครบ จึงไม่สรุปรายละเอียด

• ตัวเลือกแบบ 8-to-1 คุยกับ I/O ได้ 8 ตัว เลือกมาได้ 1 ตัว
• ถ้ามี I/O มากกว่า 8 ตัว เช่น 64 ตัว ก็ใช้ 8 ชุด ของ 8-to-1 แล้วใช้ 8-to-1 อีกตัวเลือกจากกลุ่มทั้ง 8 ให้เหลือ 1 ตัว (ตรงกับสไลด์ Interrupt Controller แบบ master/slave)

• Programmed I/O และ Interrupt-driven I/O ไปยุ่งกับ processor จึง ช้า
• DMA คุยกับ memory ได้ ในทุก slot ของ processor cycle (ก่อน fetch, หลัง decode, หลัง execute แทรกได้ตลอด)
• ถ้า I/O จะ interrupt processor ตรง ๆ processor จะถูกขัดจังหวะไม่ได้กลางทางที่กำลังทำงาน ต้องรอให้ จบ instruction cycle ก่อน เช่นมี pipeline 4–5 stage ก็ต้องรอครบ 4–5 cycle
• DMA จึงเร็วกว่า แทรกได้ตรง ๆ โดยไม่ต้องรอให้คำสั่งเสร็จ ปัจจุบัน I/O ใช้ DMA เป็นส่วนใหญ่

• อาจารย์ย้ำว่า storage ออกไม่เยอะมาก เน้น hard disk ว่า หลักการทำงาน/การใช้งาน เป็นอย่างไร
• เขียน: จ่าย กระแสไฟฟ้าเข้าหัวเขียน (ขดลวด) → เกิด สนามแม่เหล็ก → ทำให้ ทิศทางของอนุภาคแม่เหล็กบนผิวจาน เรียงไปทางซ้ายหรือขวา แทนค่า 0 กับ 1
• อ่าน: หัวอ่านใช้ขดลวด เหนี่ยวนำสัญญาณ ดูว่าทิศไปทางซ้ายหรือขวา เพื่อแปลงเป็น 0 หรือ 1
• HDD ประกอบด้วย platter หลายชั้น หัวอ่านเข้าไปเสียบตามจำนวนชั้น โดยทั่วไป 1 หัว ต่อ 1 ผิว

• แบบเก่า (a) แบ่งเหมือน หั่นเค้ก แล้วแต่ละ track แบ่งเป็น sector ข้อเสียคือ ขนาด sector ไม่เท่ากัน
• แบบ Multi-zone recording (b): ความหนาแน่นของข้อมูล / ขนาด sector ใกล้เคียงกัน ดีกว่า
• ปัจจุบัน hard disk ส่วนใหญ่ใช้ multiple zone recording

• SSD ดีกว่า HDD: เร็วกว่า (performance ดี) และ ใช้พลังงานน้อยกว่า แต่ ราคาแพงกว่า
• Storage ที่ ถูกและเก็บได้เยอะ: CD-ROM, DVD (ข้อมูลทั่วไป)
• Magnetic tape: storage ที่ ถูกที่สุด (อาจารย์ย้ำอีกรอบ)

• แทนที่จะทำ fetch → decode → execute → เขียนค่า เรียงเป็น sequence ใช้วิธี แบ่งเป็น stage ย่อย แล้วใช้ resource ไม่ให้ชนกันในเวลาเดียวกัน
• ตัวอย่างของอาจารย์: ซักผ้า–อบผ้า–รีดผ้า–เก็บผ้า แต่ละอย่างใช้ resource ต่างกัน จึงทำคำสั่ง 1 2 3 4 ที่ใช้ resource ไม่ตรงกันไปพร้อม ๆ กันได้
• Stage แบ่งตามชนิด CPU (RISC-V, Arm, Intel ไม่เหมือนกัน) ตัวอย่างบนสไลด์: IF, ID, EX, MEM, WB
• ผลลัพธ์: ทำงาน เร็วขึ้น แต่เกิดปัญหา 3 เรื่อง (hazards)

• ปัญหา 3 แบบ: structural hazard, data hazard, control hazard
• Structural hazard = การใช้ resource ชนกัน (conflict) ในเวลาเดียวกัน
• วิธีแก้: stall = หยุด pipeline (เกิดช่องว่าง/bubble) จนกว่า resource จะว่าง แล้วจึงทำต่อ

Data hazard = resource ไม่ได้ชน แต่ ข้อมูลชน/ยังไม่พร้อม

1. Stall: ง่ายที่สุด แต่ต้องหยุดหลาย cycle ("นักวิจัยบอกว่าไม่ค่อยดี")
2. Forwarding (Bypassing): สร้าง เส้นทางพิเศษใน datapath ส่งผลลัพธ์จากสถานะ Execute ของคำสั่ง add กลับไปเป็น input ของคำสั่งถัดไปเลย โดยไม่ต้องรอ write back
3. Code scheduling (จัดเรียงโค้ดใหม่): แก้ที่ assembly หรือ compiler เช่น หลัง load x2 แทนที่จะ add ทันที ให้เอาคำสั่งที่ไม่เกี่ยวข้อง (load x4) มาทำคั่นก่อน วิธีนี้ ไม่ต้องเพิ่ม hardware (bus forward) แต่ไปแก้ที่ compiler/assembler แทน

• เกิดเมื่อ fetch คำสั่งถัดไปมาแล้ว แต่ คำสั่งก่อนหน้าเป็น branch/jump → กระโดดไปที่อื่น คำสั่งที่ fetch มา ไม่ถูกใช้
• วิธีแก้ที่ง่ายสุด: ใช้ bubble / stall จนกว่า pipeline จะกลับมาทำงานปกติ
• แต่ stall ไปเรื่อย ๆ เสียเวลา (waste) จึงมีความพยายามออกแบบ prediction: ใช้ สถิติ/probability เดาว่า branch นี้จะกระโดดจริงไหม
• ตัวอย่างของอาจารย์: ลูป ที่เช็กเงื่อนไขว่า i เท่ากับ 0 ไหม เมื่อยังลบไม่ถึง 0 ก็ ไม่มีทางกระโดดออกจากลูป จึง fetch คำสั่งถัดไปมาก่อนได้
• แต่ prediction มีต้นทุนฮาร์ดแวร์สูง ต้องออกแบบวงจรเก็บสถิติเพิ่มใน CPU อาจารย์บอกว่าส่วนใหญ่ นิยมใช้วิธี stall มากกว่า เพราะความซับซ้อนของวงจรทำ prediction มี cost สูงกว่าอยู่ดี

• สรุป: pipeline ทำงานได้เร็ว ปัญหาที่พบมี 3 type:
  • Structural hazard – ใช้ resource ซ้ำกัน
  • Data hazard – ข้อมูลยังไม่เสร็จ แต่ถูกเรียกใช้
  • Control hazard – เกิด jump/branch ทำให้คำสั่งที่ fetch มาไม่ถูกใช้
• ทุก stage ของ datapath ต้องมี pipeline registers (ตัวสีฟ้าในรูป) เก็บข้อมูลจาก stage ก่อนหน้า ไม่งั้น ข้อมูลจะถูกคำสั่งถัดไปทับทันที เป็น hardware ที่เพิ่ม (ต้นทุน) แต่ทำให้ CPU ทำงานแบบ pipeline เร็วขึ้นได้

• กลุ่มที่ต้องการ high performance แบบมี hardware/core จริง (เช่น 8 core, 16 core) ≠ แบบ แบ่งงานเป็น task บน resource เดียว (เช่น VM ที่ซอย hardware ให้) ซึ่งไม่มี hardware จริงรองรับ
• Multi-core = ออกแบบ duplicate core ไปเลย ของใครของมัน

• Vector processor: CPU บางประเภท เช่นตระกูล RISC-V มี version ที่เป็น vector processor มาผสม ส่วนใหญ่ใช้กับคำสั่งคำนวณคณิตศาสตร์เยอะ เช่น คูณ-บวก-คูณ-บวก (multiply–accumulate) ใน digital filter, vector ของภาพ, background subtraction, พีชคณิตเชิงเส้น (ตัวอย่างบนสไลด์: DAXPY)
• Multithread: ไม่ได้มี hardware เพิ่มจริง แต่ ซอยคำสั่งออกเป็น thread แล้วทำ scheduling processor ตาม thread — ไม่ต้องลงทุนเรื่อง CPU/hardware แต่ได้ลักษณะ parallel ได้เยอะ

• Shared memory (multiprocessor แบบ share): ข้อดี ไม่ต้อง duplicate memory ไปในแต่ละ core และ ไม่ต้อง sync ข้อมูล เมื่อใช้ข้อมูลก้อนเดียวกัน · ข้อเสีย ทุก core อ่าน/เขียนที่ memory ตัวเดียว ทำให้ รุมกัน access ยุ่งยาก
• Distributed memory (แต่ละ processor มี memory ของตัวเอง): update/sync ข้อมูลระหว่างกัน ทำได้ยาก ต้องมี กระบวนการเพิ่มเติม

• GPU ตระกูล Nvidia เริ่มจากการ์ดธรรมดา/การ์ดเกม ทำ acceleration กราฟิกและการคำนวณคณิตศาสตร์
• GPU แบบใหม่สำหรับ AI: มี CPU (Intel/AMD/Arm) เป็น control unit ใช้การคำนวณคณิตศาสตร์หนักมาก ตระกูล DGX ใช้ train / สร้าง AI model ราคาสูง
• เมื่อได้ AI model แล้ว (เป็นสูตร/ตัวเลข) ตอน execute ใช้ การ์ดเกมหรือการ์ดปกติ ใน PC ก็ได้ ไม่จำเป็นต้องใช้ GPU ตัวใหญ่
• หลักการ GPU = SIMD: คำสั่งชนิดเดียว (เช่นบวก/ลบ) ทำ พร้อมกันทีเดียวกับข้อมูลจำนวนมาก เช่นลบ background ของภาพก่อนทำ object detection (pixel เป็น array/vector)
• บางค่ายออกแบบเป็น vector-based (สไลด์ตัวอย่าง Nvidia Fermi) ส่วน Tesla ใช้แบบ multiprocessor คือใช้หน่วย compute หลายหน่วยทำร่วมกันทีละเยอะ ๆ

• ถามเรื่องสไลด์หน้า 23 (รูป Graphics in the System): ตัวไหนใช้ train AI → รูปด้านบน ที่เป็น GPU + Intel CPU (ซ้าย) และแบบเดียวกันแต่เปลี่ยนเป็น AMD CPU (ขวา) ส่วนตอนเอาโมเดลมาใช้ → ใช้ รูปล่างซ้าย ซึ่งเหมือนการ์ดเกม/การ์ด VGA เสียบ slot PCI ปกติ
• ข้อสอบเป็น multiple choice ทั้ง 60 ข้อไหม? → อาจารย์ตอบ "ใช่เลยครับ multiple choice"
• CD กับ DVD ต่างกันอย่างไร → ดูหัวข้อ "SSD vs HDD และสื่อเก็บข้อมูลอื่น ๆ" ด้านบน (sector ของ DVD เล็กกว่า ความหนาแน่นมากกว่า เก็บได้มากกว่า)

ภาพในคลิปช่วง 35:00–38:46 เป็นหน้าจอประชุม (ไม่มีสไลด์แล้ว) ข้อความของ Gemini ช่วงนี้ซ้ำกับเนื้อหาที่เคยถอดไปแล้ว ผมจึงไม่เพิ่มรายละเอียดอื่น

• DVD เก็บข้อมูลได้มากกว่า CD: ทางกายภาพเป็นแผ่นกลมเหมือนกัน ความต่างอยู่ที่ การแบ่ง sector ใน CD sector ห่างกว่า/ใหญ่กว่า ส่วน DVD แบ่งเป็น sector เล็กกว่า จึงมี density มากกว่า
• Track = วงกลม/วงแหวนหนึ่งวง บนแผ่น (เปรียบเหมือนลู่วิ่งทั้งลู่)
• Sector = ส่วนย่อยของ track ที่ซอยออกมา (เหมือนตัดลู่วิ่งออกเป็นพาร์ตหนึ่ง/แบ่งเค้ก)
• เป็นข้อ "ถูกหรือผิด": ที่ว่า sector คือ "กลุ่มของ track" ผิด เพราะ sector คือส่วนย่อยของ track

• โจทย์: สถาปัตยกรรมแบบ Single Instruction, Single Data ประมวลผลคำสั่งหลาย ๆ ตัวในชุดเดียวกันพร้อมกันได้ใช่ไหม → ไม่ใช่ ประมวลผลได้ 1 คำสั่ง 1 ข้อมูล

• โจทย์: "Pipeline ใช้งานได้เฉพาะสถาปัตยกรรมแบบ RISC เท่านั้น" ถูกหรือผิด → ผิด ทั้ง RISC (เช่น ARM) และ CISC (เช่น Intel) ก็มี pipeline หมด
• ลำดับ stage ของ CPU ทั่วไป: Fetch → Decode → Execute → Write back (อาจารย์ย้ำเรื่องลำดับ)

• มาตรฐานเลขทศนิยม = IEEE 754 (มีหน้าสไลด์ให้เปิดดูในห้องเรียน)
• จำนวนบิตของ exponent: single precision = 8 บิต · double precision (64 บิต) = 11 บิต

• หน่วยความจำที่ จุได้มากที่สุด ในพีระมิด memory hierarchy → Offline storage / Magnetic tape
• RAM vs ROM: RAM เป็นแบบ ชั่วคราว (temporal/volatile) ข้อมูลหายได้เมื่อไม่มีไฟ · ROM ถาวรกว่า ปิดไฟแล้วข้อมูลยังอยู่
• SRAM vs DRAM: SRAM เร็วกว่า · DRAM ช้ากว่า แต่ราคาถูกกว่า

• เลือกระหว่าง Direct-mapped, Two-way, Fully associative แบบไหนช่วยลด miss ได้ดีที่สุด → Fully associative (miss น้อยที่สุด / hit มากที่สุด)
• วิธีเขียนข้อมูลลง cache มี Write-through, Write-back และ Write-allocate (อาจารย์ยืนยันว่าถูก)

• Daisy chain: เกี่ยวกับ priority — ให้ความสำคัญกับตัวที่ priority สูงก่อน แล้วลดหลั่นลงมา
• เมื่อมี I/O หลายตัวต่ออยู่ที่ bus แล้วขอใช้พร้อมกัน ตัวที่เลือกว่าอุปกรณ์ไหนมีสิทธิ์ใช้ bus เรียกว่า Bus Arbitrator / Arbitration circuit
• ไม่ใช่ Control Unit และ ไม่ใช่ control line (นักศึกษาเดาผิด 2 ครั้งก่อนได้คำตอบที่ถูก)

• ระหว่าง Programmed I/O, Interrupt-driven I/O, DMA ตัวที่เร็วที่สุด → DMA เพราะ แทรกเข้าไปได้ทุกขั้นตอน (ทุก cycle)
• การ์ดจอ (GPU กราฟิกการ์ด เช่น GeForce) ต่อเข้าเมนบอร์ดผ่านอะไร: เลือกจาก USB / FireWire / Thunderbolt / PCIe → PCIe (เป็นการ์ดเสียบ slot)

• "คำถามสไตล์ประมาณแบบเนี้ย ไปทบทวนเนาะ แล้วก็ อย่าลืมชอร์ตโน้ต 2 แผ่น"
• เอากระดาษเข้าห้องสอบได้ 2 แผ่น A4 ปริ้นต์ได้ ไม่ต้องเขียนก็ได้ · เปิดสไลด์ไม่ได้
• นักศึกษาสอบถามเพิ่มเรื่องตัวเลือกอุปกรณ์ที่ได้ใช้ bus → คำตอบ Bus Arbitrator (อาจารย์พิมพ์ในแชทให้)