Parallel Systems · บทที่ 4 จาก 9

Parallel Architecture

เมื่อมีหน่วยประมวลผลมากกว่าหนึ่งตัวแล้ว จะจัดวางและเชื่อมต่อกันอย่างไร? บทนี้วางกรอบคิดตั้งแต่ทฤษฎีจำแนกประเภท (Flynn's Taxonomy) ไปจนถึงสถาปัตยกรรมจริงที่เคยใช้งาน และเทียบกับสถาปัตยกรรมที่ครองตลาดอยู่ในปัจจุบัน

📚

สังเคราะห์จากเอกสาร "Parallel Architecture" (2110732) และบทนำของ "Large Scale Computing Systems" รุ่นปี 2008-2009 ซึ่งมีเนื้อหา Flynn's Taxonomy อยู่ (รุ่นหลัง ๆ ตัดหัวข้อนี้ออกไปเน้นเรื่อง cloud แทน) — นำมารวมกันใหม่เพราะเป็นกรอบคิดที่จำเป็นสำหรับเข้าใจสถาปัตยกรรมยุคปัจจุบันอย่าง GPU

1Flynn's Taxonomy (1966): กรอบคิดจำแนกที่ยังใช้ได้ถึงทุกวันนี้

เกณฑ์การจำแนก

Michael Flynn เสนอกรอบคิดจำแนกสถาปัตยกรรมคอมพิวเตอร์จาก 2 มิติ: จำนวนกระแสคำสั่ง (instruction stream) และ จำนวนกระแสข้อมูล (data stream) ที่ระบบประมวลผลพร้อมกันได้

ประเภท	ความหมาย	ตัวอย่าง
SISD	Single Instruction, Single Data — สถาปัตยกรรม von Neumann ดั้งเดิม ไม่มีพารัลเลลิซึม	คอมพิวเตอร์ตั้งโต๊ะยุคแรก ๆ
SIMD	Single Instruction, Multiple Data — หน่วยควบคุมเดียวสั่งให้หลาย processing element ทำ operationเดียวกันกับข้อมูลคนละชุดพร้อมกัน	เอกสารต้นฉบับปี 2009 ระบุไว้ตรง ๆ ว่า "Modern GPU" คือตัวอย่างของ SIMD — เป็นข้อสังเกตที่ถูกต้องและยังใช้ได้จนถึงทุกวันนี้
MISD	Multiple Instruction, Single Data — หมวดที่แม้แต่เอกสารต้นฉบับก็ยอมรับว่า "ไม่มีใครเห็นตรงกันว่ามีจริงหรือไม่" บางคนจัด systolic array และ pipeline processor ไว้ในกลุ่มนี้	ตัวอย่างเชิงพาณิชย์แท้จริงหาได้ยากมาก
MIMD	Multiple Instruction, Multiple Data — แต่ละหน่วยประมวลผลรันคำสั่งของตัวเองอิสระกับข้อมูลของตัวเอง สื่อสารกันเป็นครั้งคราว	เอกสารต้นฉบับยกตัวอย่าง IBM SP, Cluster และ "Multi-Core CPU" — ตรงกับซีพียูทุกตัวที่ใช้งานกันทุกวันนี้

SPMD — รูปแบบผสมที่ใช้จริงมากที่สุด

Single Program, Multiple Data — ทุกหน่วยประมวลผลรันโปรแกรมเดียวกัน (ต่าง MIMD ตรงที่ไม่ต่างโปรแกรมกัน) แต่แต่ละตัวทำงานกับข้อมูลคนละส่วนและตัดสินใจแยกกันได้ตาม process ID ของตัวเอง — เป็นโมเดลที่ MPI (บทที่ 5) ใช้จริงเกือบทั้งหมด เพราะง่ายกว่าการเขียนโปรแกรมต่างกันสำหรับแต่ละหน่วยประมวลผลจริง ๆ

2สถาปัตยกรรมฮาร์ดแวร์ในยุคที่เอกสารต้นฉบับเขียน

สถาปัตยกรรม	ลักษณะ	ข้อจำกัด
SMP Symmetric Multiprocessor	หลายซีพียูใช้ memory ร่วมกันผ่าน bus หรือ crossbar เดียว (shared-memory) — เชื่อมกันแน่น (tightly coupled)	Bus/crossbar เป็นคอขวด ไม่ scale เกินราว 2-64 ตัว ราคาแพงเพราะเป็นระบบเฉพาะทาง
PVP Parallel Vector Processor	ใช้ vector processor เฉพาะทางประสิทธิภาพสูงมาก เหมาะกับงานวิทยาศาสตร์ (ตัวอย่าง: Cray X1, Earth Simulator)	แพงมาก เป็นระบบผูกขาดของผู้ผลิตแต่ละราย (proprietary)
MPP Massively Parallel Processor	โหนดจำนวนมาก (หลักพัน) แต่ละโหนดมีซีพียู+memory+ดิสก์ของตัวเอง เชื่อมด้วยเครือข่ายออกแบบเฉพาะ (custom-designed network) — physically distributed	Overhead การซิงโครไนซ์สูง ต้นทุนเครือข่ายเฉพาะทางสูงมาก (ตัวอย่าง: ASCI, Blue Gene)
DSM Distributed Shared Memory	Memory กระจายตัวจริงทางกายภาพ แต่ซอฟต์แวร์/ฮาร์ดแวร์ทำให้โปรแกรมเมอร์ "รู้สึก" เหมือนเป็น shared memory เดียว (logically shared, physically distributed)	ตรงข้ามกับ SMP — scale ได้ดีกว่าแต่ latency การเข้าถึง memory ไม่สม่ำเสมอ
NOW / COW / Cluster Network/Cluster of Workstations	เครื่อง PC ธรรมดาต่อกันผ่านเครือข่ายความเร็วสูงทั่วไป (เช่น Fast Ethernet) ใช้ชิ้นส่วนสำเร็จรูปราคาถูก (COTS — Commercial Off-The-Shelf)	ประสิทธิภาพต่อโหนดต่ำกว่า MPP/PVP มาก แต่ scale ได้ดีมากและถูกกว่าหลายเท่า (ตัวอย่าง: Beowulf cluster, Tungsten — 1,250 Dell PowerEdge)

3สถาปัตยกรรมเดิมเปลี่ยนรูปอย่างไรในเครื่องปัจจุบัน

แล้ว · ~2008–2012

ตอนนี้ · 2026

SMP เป็นระบบเฉพาะทางราคาแพง scale ได้จำกัดถึงราว 64 ซีพียู

SMP คือโครงสร้างภายในซีพียู multicore ทุกตัวที่ใช้งานทั่วไปในปัจจุบัน — core หลายสิบตัวใน CPU เดียวกันแชร์ memory ผ่าน bus/interconnect ภายในชิป กลายเป็นของธรรมดาที่มีในโน้ตบุ๊กทุกเครื่อง ไม่ใช่ระบบเฉพาะทางราคาแพงอีกต่อไป

PVP เป็นระบบ vector processor เฉพาะทางที่แพงที่สุดในกลุ่ม เข้าถึงได้เฉพาะซูเปอร์คอมพิวเตอร์ระดับชาติ

GPU สมัยใหม่ (NVIDIA/AMD) คือทายาททางแนวคิดของ PVP — เป็นหน่วยประมวลผลจำนวนมากที่ทำ SIMD-style operation กับข้อมูลจำนวนมหาศาล เพียงแต่ราคาถูกลงหลายพันเท่าเพราะผลิตขายทั่วไปสำหรับตลาดเกมและ AI ไม่ใช่แค่งานวิทยาศาสตร์เฉพาะทาง (ดูรายละเอียด CUDA ในบทที่ 5)

MPP ต้องใช้เครือข่ายเฉพาะทางราคาแพงมาก เข้าถึงได้เฉพาะห้องแล็บระดับชาติ

Cloud data center สมัยใหม่ (AWS, GCP, Azure) ให้เช่าโครงสร้างที่ทำงานคล้าย MPP ได้ในราคาที่ทุกคนเข้าถึงได้ — เครือข่ายความเร็วสูงระดับ data center (เช่น InfiniBand หรือ 100/400 Gbps Ethernet) ทำหน้าที่แทน custom network เดิม

NOW/COW/Cluster คือทางเลือกราคาถูกที่กำลังได้รับความนิยมเพิ่มขึ้น

กลายเป็นมาตรฐานหลักของระบบขนาดใหญ่แทบทั้งหมด — Kubernetes cluster และ cloud instance ทั้งหมดคือวิวัฒนาการโดยตรงของแนวคิด NOW/COW เพียงแต่มี orchestration layer (บทที่ 8) จัดการความซับซ้อนแทนที่จะต้อง manage เครื่องแต่ละตัวเอง

ข้อสังเกตสำคัญ

ไม่มีสถาปัตยกรรมไหนใน "5 แบบดั้งเดิม" หายไปจริง ๆ — สิ่งที่เกิดขึ้นคือราคาถูกลงมหาศาลและเข้าถึงได้ง่ายขึ้นจนกลายเป็นของธรรมดา (SMP ในซีพียูทุกตัว, cluster บน cloud ที่เช่าได้เป็นชั่วโมง) ในขณะที่ระบบที่เคย "แพงที่สุด" อย่าง PVP ถูกแทนที่ด้วย GPU ที่ผลิตจำนวนมากเพื่อตลาดผู้บริโภคก่อน แล้วค่อยถูกนำมาใช้งานวิทยาศาสตร์/AI ทีหลัง — สลับทิศทางจากเดิมที่เทคโนโลยีประสิทธิภาพสูงไหลจากงานวิทยาศาสตร์ลงมาสู่ผู้บริโภค

4NUMA: จุดกึ่งกลางระหว่าง SMP และ DSM ที่เอกสารต้นฉบับยังไม่ได้แยกให้ชัด

Non-Uniform Memory Access

สถาปัตยกรรมที่ครองตลาดเซิร์ฟเวอร์และซีพียู multicore ขนาดใหญ่ในปัจจุบัน — memory กระจายตัวทางกายภาพผูกกับแต่ละกลุ่ม core (คล้าย DSM) แต่โปรแกรมเมอร์มองเห็นเป็น address space เดียว (คล้าย SMP) ความต่างจาก SMP ล้วน ๆ คือเวลาการเข้าถึง memory ไม่เท่ากัน ขึ้นกับว่า core ที่เข้าถึงอยู่ "ใกล้" หรือ "ไกล" จาก memory ส่วนนั้นแค่ไหน

ทำไมเรื่องนี้สำคัญกับโปรแกรมเมอร์จริง

ซีพียู server สมัยใหม่ (เช่น AMD EPYC, Intel Xeon รุ่นใหม่) ที่มี core หลายสิบตัวเกือบทั้งหมดเป็น NUMA ภายในตัว — โปรแกรมที่ไม่คำนึงถึง NUMA (เช่น thread เข้าถึง memory ที่ "ไกล" บ่อยเกินไป) อาจช้ากว่าที่ควรมากแม้จะรันบนซีพียูตัวเดียวกันเป๊ะ นี่คือเหตุผลที่ระบบปฏิบัติการและ runtime สมัยใหม่ต้องมี NUMA-aware scheduling

คำถามซ้อมสอบ

อธิบาย Flynn's Taxonomy ทั้ง 4 ประเภท พร้อมยกตัวอย่างระบบจริงของแต่ละประเภท
อธิบายว่า SPMD ต่างจาก MIMD และ SIMD อย่างไร และทำไม MPI จึงนิยมใช้โมเดลนี้
เปรียบเทียบ SMP, MPP, และ Cluster (NOW/COW) ในแง่ความคับคั่งของการเชื่อมต่อ (coupling) และความสามารถในการ scale
อธิบายว่า GPU สมัยใหม่สืบทอดแนวคิดจาก PVP อย่างไร และอะไรที่ทำให้ราคาถูกลงมหาศาลเมื่อเทียบกับยุคก่อน
อธิบาย NUMA และผลกระทบต่อประสิทธิภาพโปรแกรมที่ไม่ได้ออกแบบมาให้ NUMA-aware

5Flynn's Taxonomy เป็นจุดเริ่มต้น ไม่ใช่แผนที่ทั้งหมด

Flynn จำแนกสถาปัตยกรรมจากจำนวน instruction streams และ data streams เป็น SISD, SIMD, MISD และ MIMD กรอบนี้ยังมีประโยชน์เพราะบังคับให้ถามว่าใครควบคุมคำสั่งและข้อมูลกี่ชุด แต่เครื่องสมัยใหม่ซ้อนหลายแบบไว้ในชิปเดียว

CPU สมัยใหม่หนึ่งตัวอยู่หลายช่องพร้อมกัน

แต่ละ core รัน instruction stream ของตนแบบ MIMD หลาย cores ขณะใน core มี SIMD vector instruction และ superscalar execution ส่วน SMT ให้หลาย thread แชร์ core ดังนั้นอย่าใช้ Flynn เป็นป้ายชื่อผลิตภัณฑ์แบบตายตัว ให้ใช้เป็นเลนส์ดู parallelism แต่ละระดับ

ประเภท	ภาพรวม	ตัวอย่างร่วมสมัย
SISD	คำสั่งหนึ่งสาย ข้อมูลหนึ่งสาย	Sequential execution model บน core หนึ่ง
SIMD	คำสั่งเดียวทำกับข้อมูลหลายชุด	AVX, NEON, vector unit และส่วนหนึ่งของ GPU
MISD	หลายคำสั่งทำกับ data stream เดียว	พบเป็นแนวคิดใน redundant/safety pipeline มากกว่าสถาปัตยกรรมทั่วไป
MIMD	หลายคำสั่ง หลายข้อมูล	Multicore CPU, SMP, cluster และ cloud

6Shared Memory กับ Distributed Memory

มิติ	Shared Memory	Distributed Memory
การสื่อสาร	อ่านเขียน address space ร่วม	ส่ง message ระหว่าง address spaces
เครื่องมือ	Thread, OpenMP, pthreads	MPI, RPC และ distributed runtime
ปัญหาหลัก	Race, coherence, lock และ contention	Partition, placement, serialization และ failure
ขอบเขต	มักอยู่ภายในเครื่องหรือ coherent domain	ขยายได้หลายเครื่องและหลาย fault domains

โต๊ะกลางกับสำนักงานหลายสาขา

Shared memory เหมือนทีมทำงานบนโต๊ะเอกสารกลาง ทุกคนหยิบได้เร็วแต่ต้องระวังแก้กระดาษแผ่นเดียวกัน Distributed memory เหมือนสำนักงานหลายสาขา แต่ละแห่งมีตู้เอกสารของตน ต้องส่งสำเนาผ่านพนักงานส่งเอกสาร ช้ากว่าแต่ขยายพื้นที่ได้มากกว่า

ระบบ HPC มักเป็น hybrid: MPI ระหว่าง nodes และ threads/SIMD ภายใน node การออกแบบจึงต้องรู้ว่าข้อมูลใดแชร์ได้ราคาถูก และข้อมูลใดต้องข้าม network

7UMA และ NUMA: Address เดียวกัน แต่เวลาไม่เท่ากัน

ใน Uniform Memory Access การเข้าถึง memory มี latency ใกล้เคียงกันจากทุก processor เหมาะกับระบบขนาดไม่ใหญ่มาก เมื่อจำนวน socket และ core เพิ่ม การต่อทุกคนเข้าหน่วยความจำเดียวกลายเป็นคอขวด NUMA จึงแบ่ง memory controller ตาม socket

ทุก core ยังเห็น address space เดียว แต่ memory ที่ต่อกับ socket ตนเข้าถึงเร็วกว่า remote memory การวาง thread โดยไม่วางข้อมูลตามอาจทำให้ traffic วิ่งข้าม interconnect และ performance ตกมาก

First-touch policy — page มักถูก allocate ใกล้ core ที่เขียนครั้งแรก
Thread affinity — pin thread ให้ไม่ย้าย socket โดยไม่จำเป็น
Data partitioning — ให้ thread ทำข้อมูลที่อยู่บน NUMA node เดียวกัน
Replication — ข้อมูล read-only บางชนิดมีสำเนาต่อ socket เพื่อลด remote read

Shared address ไม่ได้แปลว่า shared cost

โปรแกรมอาจถูกต้องทุกประการแต่ช้าลงสองเท่าเพราะ operating system วาง page คนละ socket กับ thread ปัญหานี้มองไม่เห็นจาก source code หากไม่รู้ topology และวัด remote access

8Cache Coherence: สำเนาหลายชุดต้องรู้ว่าใครใหม่ที่สุด

แต่ละ core มี private cache เพื่อให้ข้อมูลอยู่ใกล้ หากสอง core cache address เดียวกัน แล้ว core หนึ่งเขียน อีก core ต้องไม่อ่านสำเนาเก่าต่อ Coherence protocol จึงติดตามสถานะ cache line และส่ง invalidate หรือข้อมูลระหว่าง cores

แนวคิด MESI แบบย่อ

สถานะ	ความหมาย
Modified	Cache นี้มีสำเนาใหม่กว่าหน่วยความจำและเป็นเจ้าของเพียงตัวเดียว
Exclusive	มีสำเนาเดียวแต่ยังตรงกับ memory เขียนต่อได้โดยไม่แจ้งผู้อื่น
Shared	หลาย cache มีสำเนาที่อ่านได้
Invalid	Cache line นี้ใช้ไม่ได้ ต้องดึงใหม่

Coherence ทำให้ shared-memory programming เป็นไปได้ง่ายขึ้น แต่ traffic ของ protocol โตเมื่อหลาย core เขียนข้อมูลร่วมกัน โปรแกรมจึงยังต้องลด sharing แม้ฮาร์ดแวร์รักษาความถูกต้องให้

9False Sharing: ไม่ได้แชร์ตัวแปร แต่แชร์ Cache Line

Thread A เขียน counter[0] และ B เขียน counter[1] ดูเป็นคนละตัวแปร แต่ถ้าอยู่ cache line เดียวกัน ทุกการเขียนทำให้ line ของอีก core invalid แล้ว ownership วิ่งไปมา เรียกว่า cache line ping-pong

ห้องทำงานคนละโต๊ะแต่ใช้กระดาษแผ่นเดียว

แม้แต่ละคนเขียนคนละช่อง ทุกครั้งที่คนหนึ่งจะเขียนต้องดึงกระดาษทั้งแผ่นมาที่โต๊ะตน อีกคนจึงต้องรอ False sharing แก้ได้ด้วย padding, alignment, per-thread buffer และรวมผลภายหลัง

อาการคือ CPU utilization สูงแต่ scaling แย่ และ coherence traffic สูง การเปลี่ยนตำแหน่งตัวแปรโดยไม่เปลี่ยน algorithm อาจทำให้เร็วขึ้นหลายเท่า แสดงว่า data layout เป็นส่วนหนึ่งของ parallel architecture

10Interconnect Topology: วิธีต่อกันกำหนดราคาการสื่อสาร

Topology	จุดเด่น	ข้อจำกัด
Bus	ง่าย ราคาต่ำสำหรับระบบเล็ก	Bandwidth ร่วมและ scale ไม่ดี
Crossbar	เชื่อมหลายคู่พร้อมกันได้	พื้นที่และต้นทุนโตเร็วตามจำนวนปลายทาง
Ring	โครงสร้างเรียบง่ายและเป็นระเบียบ	Latency โตตามระยะและ link อาจอิ่ม
Mesh/Torus	Scale เป็นหลายมิติ เหมาะ manycore/HPC	Routing และ placement มีผลมาก
Fat-tree/Clos	Bandwidth สูงสำหรับ cluster และ data center	Switch/cabling ซับซ้อนและ oversubscription ขึ้นกับการออกแบบ

จำนวน hops, bisection bandwidth และ contention กำหนดว่า collective communication จะเร็วเพียงใด Algorithm ที่สื่อสารกับเพื่อนบ้านเหมาะกับ mesh มากกว่า all-to-all ที่ส่งข้ามระบบ

11Vector Processor, SIMD Unit และ GPU

Vector processor ออกคำสั่งกับ vector ยาวและมี pipeline คำนวณต่อเนื่อง SIMD extension ใน CPU ใช้ vector register ขนาดจำกัด ส่วน GPU ใช้ threads จำนวนมากซ่อน latency และแบ่ง execution เป็น warps/wavefronts แม้มีรากความคิดเดียวกัน แต่ programming model และ memory hierarchy ต่างกัน

มิติ	CPU SIMD	GPU
เป้าหมาย	ลด latency และเร่ง loop ภายในโปรแกรมทั่วไป	Throughput สูงบนงาน data-parallel จำนวนมาก
Control	Core ซับซ้อน branch predictor และ cache ใหญ่	หลาย execution lanes และ threads จำนวนมาก
เหมาะกับ	งานผสม control flow กับ vectorizable regions	Matrix, image, simulation และ ML kernels
ข้อจำกัด	Vector width และ memory bandwidth	Transfer, divergence, occupancy และ device memory

12GPU Memory Hierarchy และ Data Movement

GPU มี register ต่อ thread, shared memory ต่อ block, caches และ global memory ความเร็วต่างกันมาก Kernel ที่คำนวณเร็วแต่โหลด global memory ซ้ำอาจช้า การทำ tiling นำ block ข้อมูลเข้า shared memory แล้วใช้ซ้ำช่วยเพิ่ม arithmetic intensity

Arithmetic intensity

AI = จำนวน operations / จำนวน bytes ที่ย้าย

ถ้า AI ต่ำ งานมัก memory-bound ถ้า AI สูงพอจึงมีโอกาส compute-bound แต่เพดานจริงขึ้นกับ bandwidth และ compute throughput ของอุปกรณ์

ต้องรวมเวลา host-to-device และ device-to-host ด้วย งานเล็กอาจเสียเวลากับ transfer มากกว่า kernel การ batch และ overlap transfer กับ compute ช่วยได้เมื่อมีข้อมูลต่อเนื่อง

13Roofline Model: สถาปัตยกรรมพบกับลักษณะของงาน

Roofline เชื่อม peak compute, memory bandwidth และ arithmetic intensity เพื่อบอกขอบเขต performance โดยคร่าว ๆ

Roofline bound

Performance ≤ min(Peak Compute, Memory Bandwidth × Arithmetic Intensity)

ด้านซ้ายของกราฟงานถูกจำกัดด้วย bandwidth เพิ่ม FLOPs ของเครื่องไม่ช่วยมาก ด้านขวางานมีข้อมูลใช้ซ้ำพอและชน compute ceiling

โมเดลนี้ช่วยตอบว่าควร optimize อะไร หาก memory-bound ให้ลด bytes, เพิ่ม reuse หรือปรับ layout หาก compute-bound ให้ vectorize, เพิ่ม occupancy หรือใช้ execution units ให้เต็ม

14Cluster: ขยายด้วยเครื่องมาตรฐานและเครือข่าย

Cluster รวม nodes ที่มี CPU, memory และ storage ของตน เชื่อมผ่าน network ข้อดีคือขยาย capacity และ fault domain ได้ด้วยเครื่องมาตรฐาน แต่ remote access แพงกว่าหน่วยความจำหลายลำดับและ node อาจล่มแยกจากกัน

Compute cluster เน้น batch jobs และ low-latency interconnect
Data cluster เน้นวาง computation ใกล้ partition และทน node failure
Service cluster เน้น throughput, availability และ load balancing
GPU cluster ต้องจัดทั้ง network ระหว่าง nodes และ interconnect ระหว่าง accelerators

คำว่า cluster บอกเพียงว่ามีหลายเครื่อง ยังไม่บอก programming model, consistency, scheduler หรือ failure semantics ต้องอ่านสถาปัตยกรรมส่วนอื่นประกอบ

15Network ของ Cluster: Latency, Bandwidth และ Topology

Message ขนาดเล็กมักถูกจำกัดด้วย latency ส่วน message ใหญ่ถูกจำกัดด้วย bandwidth เวลาสื่อสารประมาณได้จาก startup latency บวกขนาดหาร bandwidth

โมเดลอย่างง่าย

Tmessage ≈ α + n/β

α คือ latency เริ่มต้น, n คือจำนวน bytes และ β คือ bandwidth การรวม message เล็กช่วยลดจำนวนครั้งที่จ่าย α แต่ batch ใหญ่เกินไปอาจเพิ่ม waiting time

Placement ต้องสัมพันธ์กับ topology เช่น workers ที่แลกข้อมูลถี่ควรอยู่ rack หรือ node ใกล้กัน Collective library อาจเลือก tree, ring หรือ hierarchical algorithm ตามขนาดข้อความและโครง network

16Storage Architecture กับงานขนาน

Parallel job อ่านข้อมูลพร้อมกันหลาย worker หากทุกคนอ่าน disk เดียว storage กลายเป็นคอขวด ระบบอาจใช้ parallel file system striping ข้อมูลข้าม servers, local SSD ต่อ node หรือ object storage พร้อม caching

รูปแบบ	ข้อดี	สิ่งที่ต้องระวัง
Shared parallel file system	Namespace เดียวและ throughput รวมสูง	Metadata hotspot และ small-file workload
Local scratch	เร็วและใกล้ compute	ต้อง stage data และหายเมื่อ node เสีย
Object storage	Scale, durability และแยก compute/storage	Latency, API semantics และรายการ object จำนวนมาก

Data locality ที่ดีอาจหมายถึงย้าย compute ไปหาข้อมูลแทนย้ายข้อมูลหลาย terabytes ไปหา compute ซึ่งเป็นหลักเดียวกับ cache locality แต่เกิดในสเกล data center

17Heterogeneous Architecture: CPU, GPU และ Accelerator ทำงานร่วมกัน

ระบบหนึ่งอาจใช้ CPU จัด control flow, GPU ทำ dense computation, FPGA ทำ pipeline latency ต่ำ และ SmartNIC/DPU จัด network/storage offload การแบ่งตามจุดแข็งให้ performance ต่อวัตต์ดีขึ้น แต่เพิ่มปัญหา programming, scheduling และ data transfer

Accelerator idle ก็ยังเสียต้นทุน

ซื้อ GPU แพงแต่ปล่อยรอ preprocessing หรือ network เป็นการเร่งส่วนที่ไม่ใช่คอขวด การออกแบบ heterogeneous system ต้องวัด utilization ทุกองค์ประกอบและจัด pipeline ไม่ให้หน่วยแพงที่สุดว่าง

18Memory Consistency Model: Core อื่นเห็นการเขียนเมื่อใด

Cache coherence ตอบว่าสำหรับ address เดียวกัน ค่าจะลู่เข้าหากันอย่างไร ส่วน memory consistency ตอบเรื่องลำดับการสังเกตหลาย addresses Compiler และ CPU อาจ reorder load/store เพื่อ performance หากโปรแกรมไม่มี synchronization ที่ถูกต้อง thread อื่นอาจเห็นลำดับต่างจาก source code

Sequential consistency เข้าใจง่ายเหมือนมีลำดับรวมเดียว แต่ architecture สมัยใหม่มักใช้ relaxed memory model และให้ programmer ใช้ atomic, acquire/release หรือ fence ระบุตำแหน่งที่ต้องรักษาลำดับ

ประกาศกับเอกสาร

Thread A วางเอกสารแล้วแขวนป้ายว่า “พร้อม” Thread B เห็นป้ายแต่ไม่เห็นเอกสาร หาก hardware reorder การเขียนและไม่มี release/acquire synchronization โปรแกรมที่ดูสมเหตุสมผลอาจผิด การมี cache coherence อย่างเดียวไม่ได้สร้าง happens-before ให้โปรแกรม

19Topology-Aware Placement

วาดลำดับชั้น: core → cache group → socket/NUMA → node → rack → zone
วัดว่า task คู่ใดสื่อสารกันมากและข้อมูลก้อนใดถูกใช้ซ้ำ
วาง communication-heavy tasks ใกล้กัน แต่กระจายงานที่แย่ง bandwidth เดียวกัน
Pin thread และ allocate memory ตาม first-touch อย่างมีแผน
วาง GPU process ใกล้ NIC/NUMA node ที่ต่อกับอุปกรณ์นั้น
ตรวจผลด้วย counter และ topology tool ไม่เชื่อ configuration เพียงอย่างเดียว

Placement ที่ดีอาจให้ speedup โดยไม่เพิ่ม processor เพราะลดระยะทางของข้อมูล เป็น optimization แบบเดียวกับจัดของไว้ใกล้มือ แต่ขยายจาก cache line ไปถึง network rack

20เลือก Architecture จาก Workload

ลักษณะงาน	สถาปัตยกรรมที่ควรพิจารณา	เหตุผล
Vector operation จำนวนมาก	SIMD/GPU	Data parallelism สูงและ control flow สม่ำเสมอ
Graph irregular ขนาดกลาง	Multicore shared memory	Pointer-heavy และต้องการ dynamic scheduling
Simulation grid ขนาดใหญ่	MPI cluster + accelerator	แบ่ง domain และแลก boundary ได้
Request จำนวนมากอิสระ	Service cluster	Scale throughput ด้วย replication/load balancing
Pipeline latency ต่ำคงที่	FPGA/stream accelerator	Dataflow เฉพาะงานและ predictable latency

ตารางนี้เป็นจุดเริ่ม ไม่ใช่คำตอบสุดท้าย ต้องดูขนาดข้อมูล latency target, precision, ecosystem, งบพลังงาน และทักษะทีมด้วย Architecture ที่เร็วที่สุดใน benchmark อาจไม่คุ้มที่สุดตลอดอายุระบบ

21กรณีศึกษา: Matrix Multiplication เดินทางผ่าน Architecture

บน CPU core เดียว ใช้ blocking ให้ tile พอดีกับ cache
ใช้ SIMD คำนวณหลาย element ต่อ instruction
ใช้หลาย threads แบ่ง output tiles โดยหลีกเลี่ยง false sharing
บน NUMA แบ่ง matrix และ first-touch memory ใกล้ thread
บน GPU ทำ tiling ผ่าน shared memory และ coalesced access
บน cluster ใช้ 2D block distribution ลด communication เทียบกับแบ่งแถวอย่างเดียว

Algorithm ทางคณิตศาสตร์ดูเหมือนเดิม แต่ implementation เปลี่ยนตาม memory hierarchy และ interconnect ทุกระดับ แก่นของ optimization คือเพิ่ม reuse และลดระยะทางข้อมูล ไม่ใช่เพียงเพิ่มจำนวน multiply units

22สิ่งที่ควรวัดเมื่อเทียบ Architecture

Time-to-solution และ throughput บน input ที่แทนงานจริง
Energy per result และค่าใช้จ่ายต่อการรัน ไม่ใช่ peak FLOPS อย่างเดียว
Memory bandwidth, cache miss, NUMA remote access และ interconnect traffic
Utilization ของ CPU/GPU และเวลาที่ accelerator รอข้อมูล
Scaling efficiency เมื่อเพิ่ม core, socket, GPU และ node
เวลาพัฒนา ความยากในการ debug และ portability

Peak ไม่เท่ากับ sustained

Peak FLOPS คือขอบเขตภายใต้ instruction และข้อมูลที่เหมาะมาก งานจริงอาจได้เพียงบางส่วนเพราะ bandwidth, dependency, divergence หรือ communication การเทียบเครื่องจากตัวเลข peak อย่างเดียวคล้ายเลือกครัวจากจำนวนเตาโดยไม่ดูทางเดินและวัตถุดิบ

23แล็บและแบบฝึกที่แนะนำ

แล็บ 1: False Sharing

ให้ threads เพิ่ม counter ของตนใน array วัดผลก่อนและหลัง padding/alignment พร้อมเก็บ cache/coherence counter อธิบายว่าทำไมเปลี่ยน layout แล้ว runtime เปลี่ยนทั้งที่จำนวน operation เท่าเดิม

แล็บ 2: NUMA First-Touch

Allocate array จาก thread เดียวเทียบกับ parallel initialization แล้วรัน parallel scan โดย pin threads วัด local/remote bandwidth และสร้างแผนภาพการวาง memory page

แล็บ 3: CPU กับ GPU

ทดลอง vector addition และ matrix multiplication หลายขนาด แยกเวลาส่งข้อมูล, kernel และรับผล หาจุดที่ GPU เริ่มคุ้ม พร้อมอธิบายด้วย arithmetic intensity

24สรุปและขั้นตอนถัดไป

Parallel architecture ไม่ได้แบ่งได้ด้วยตารางเดียวอย่างเด็ดขาด เครื่องปัจจุบันซ้อน MIMD, SIMD, shared memory, NUMA และ accelerator อยู่ร่วมกัน ราคาของการเข้าข้อมูลเปลี่ยนตั้งแต่ register, cache, remote socket, GPU memory ไปจนถึง network และ storage

ดังนั้นคำถามสำคัญไม่ใช่เพียง “มี core กี่ตัว” แต่คือ core เหล่านั้นแชร์อะไร ติดต่อกันผ่านอะไร และ workload มี arithmetic intensity, locality และ communication pattern แบบไหน บทถัดไปจะนำความเข้าใจนี้ไปสู่ programming model โดยเฉพาะ MPI และ CUDA ซึ่งเปิดให้โปรแกรมเมอร์ระบุการแบ่งงานและการเคลื่อนข้อมูลอย่างชัดเจนครับ