Technology

ทำไม Apple M1 ถึงเป็นเรื่องที่น่าตื่นเต้น

By Arnon Puitrakul - 25 สิงหาคม 2021 - 4 min read min(s)

ทำไม Apple M1 ถึงเป็นเรื่องที่น่าตื่นเต้น

เมื่อตอนก่อน เราได้รีวิว Macbook Air M1 ไปแล้ว ถ้าใครที่อ่าน หรือ ได้ไปดูรีวิว หลาย ๆ ที่จะพบว่า มันเร็วมาก ๆ เร็วแบบ ตกใจมาก ๆ ไปเลย แน่นอนว่า เราที่เรียนคอมพิวเตอร์มา เรายังตกใจเลยว่า มันเร็วได้ขนาดนั้นเลยเหรอ ถึงกับ Blow up Macbook Air รุ่นที่ออกในปีเดียวกันขาดลอย หรือแม้กระทั่ง iMac ที่เป็น Desktop PC แบบเละเทะได้ขนาดนั้น วันนี้เรามาหาคำตอบกันว่า ทำไม Chip M1 มันถึงทรงพลังได้ แต่ยังใช้พลังงานน้อยอยู่กัน

SoC คืออะไร ?

หลาย ๆ คนอาจจะเคยได้ยินมีคนบอกว่า M1 มันเป็น SoC แล้วมันคืออะไรละ เพื่อตอบคำถามนี้ ย้อนกลับไปที่เครื่องคอมพิวเตอร์ทั่ว ๆ ไปที่เราใช้งานกันก่อน เวลาเราไปซื้อ เราจะต้องไปเลือกว่า เราอยากได้ CPU ตัวไหน RAM ตัวไหน ความเร็วเท่าไหร่ ความจุเท่าไหร่ GPU อะไร และอื่น ๆ อีกมากมาย แต่ SoC (System on Chip) มันเป็นการรวมเอาทุกอย่างเข้ามาอยู่ใน Chip ตัวเดียวสำเร็จมาเลย ไม่ว่าจะเป็น CPU, RAM, GPU รวมไปถึง Coprocessor ที่ช่วยในการทำงานด้านต่าง ๆ

ซึ่งจริง ๆ แล้ว การทำ SoC ไม่ใช่เรื่องใหม่อะไรเลย มันเป็นเรื่องที่เราทำกันมานานมากแล้ว สำหรับการออกแบบ Chip สำหรับการทำงานที่อาจจะเฉพาะทางมาก ๆ เพราะข้อดีของมันก็คือ ทำให้ราคามันถูกลงไปมาก ๆ จากเมื่อก่อนที่เราอาจจะต้องไปจ้าง Supplier ผลิต Chip แต่ละตัว แล้วเราก็ไปซื้อและต้องมาเสียค่าประกอบมันรวมกันอีก เราก็ผลิตเป็น Chip เดียวไปเลย ก็ทำให้ลดต้นทุนลงอีก นอกจากนั้น การที่มันอยู่ใน Chip เดียวกัน ทำให้เราสามารถที่จะสร้าง Interconnect หรือ การเชื่อมต่อที่ค่อนข้างเร็วได้ ต่างจากเครื่องคอมพิวเตอร์ทั่ว ๆ ไปที่อาจจะต้องมีการเดินแผงวงจรที่ยาวกว่า พอการเดินทางของสัญญาณมันสั้นกว่า ก็ย่อมทำให้พลังงานที่ใช้น้อยลง ทำให้ Chip พวกนี้มีการบริโภคพลังงานที่ตำ่กว่าการแยก Chip กัน

แต่การรวมกัน มันก็ไม่ได้ดีเสมอไป นั่นแปลว่า เมื่อเราซื้อเครื่องมา เราก็ไม่สามารถที่จะ Upgrade ได้เหมือนคอมพิวเตอร์ Desktop ที่บ้านได้ เพราะทุกอย่างมันรวมกันอยู่ใน Chip หมดแล้ว และ ถ้ามีอุปกรณ์ใดสักอย่างใน Chip เสียก็คือ เราต้องเปลี่ยนทั้งก้อนเลย ต่างจากเครื่องคอมพิวเตอร์ Desktop ทั่ว ๆ ไปที่เสียชิ้นไหน เราก็เปลี่ยนแค่ชิ้นนั้นชิ้นเดียว

ใน M1 SoC มีอะไรบ้าง

Apple M1 SoC

ใน Chip Apple M1 ก็จะมาพร้อมกับหลาย ๆ องค์ประกอบด้วยกัน อย่างน้อยที่สุด ก็จะมีเท่ากับเครื่องคอมพิวเตอร์ทั่ว ๆ ไป คือ CPU, Primary Memory และ GPU นอกจากนั้น ความเป็น SoC ทำให้ Apple เลือกที่จะใส่ Coprocessor หรือส่วนที่ออกแบบมาเพื่อทำงานเฉพาะอย่างเช่น Secure Enclave ที่จัดการเรื่องของความปลอดภัยในเครื่อง เช่นการควบคุมพวก Touch ID หรือจะเป็นพวก Neural Engine สำหรับการทำงานพวกงานที่เป็น Machine Learning

ในตัว CPU Apple ก็จะแบ่ง CPU ออกเป็น 2 ส่วนคือ High Performance CPU ที่ใส่มาให้ 4 Core สำหรับการประมวลผลหนัก ที่จะกินพลังงานเยอะหน่อย แต่ให้พลังการประมวลผลที่แรงมาก ๆ กลับกัน ก็ใส่อีก 4 Core ที่เป็น High Efficiency เข้ามา สำหรับประมวลผลงานเบา ๆ ที่จะใช้พลังงานน้อยมาก ๆ

ส่วน GPU ก็ยังเลือกที่จะใส่มาให้ถึง 8 Core สำหรับ Macbook Air รุ่น Top และ Macbook Pro 13-inch ทุกรุ่น และ 7 Core ใน Macbook Air รุ่นเริ่มต้น เอาไว้ประมวลผล Graphic ต่าง ๆ ซึ่งอันนี้เราก็ไม่รู้เหมือนกันว่า Apple มีการออกแบบยังไง หรือใช้อะไรทำให้มันแรงได้ขนาดนี้ จาก Benchmark ในรีวิว Macbook Air M1 ของเรา มันไม่ได้แรงไปกว่า Dedicated Graphic บน iMac แต่มันก็ใกล้กันจนหายใจรดต้นคอกันได้เลย ซึ่งเป็นเรื่องที่มหัศจรรย์มาก

พวก Coprocessor ที่ใส่เข้ามาเพิ่ม ทำให้การทำงานบางอย่างของเครื่อง มันก็จะทำงานได้เร็วอย่างไม่น่าเชื่อ ตัวอย่างเช่น Neural Engine ที่จาก Benchmark ที่ใช้ iMac 27-inch 2019 ที่มี GPU แยก เพราะ Neural Engine ที่ออกแบบมาเพื่องานประเภทนี้โดยเฉพาะ ทำให้เร็วกว่า และ ใช้พลังงานน้อยกว่ามาก ๆ

Unified Memory Architecture (UMA)

อีกสิ่งที่ทำให้มันเจ๋ง เข้าไปอีก ก็คือ การเลือกใช้ UMA (Unified Memory Archtecture) เข้ามา หรือก็คือ การออกแบบระบบที่แชร์ Memory กันระหว่างอุปกรณ์ทั้งหมด ลดเวลาในการย้ายข้อมูลไปมา แล้วพอ เราออกแบบมันให้อยู่ใน SoC หรือก็คือ Chip เดียวกันเลย ทำให้ Apple สามารถเชื่อมต่อในความเร็วที่สูงมาก ๆ พร้อมกับใช้พลังงานน้อยลงด้วย ซึ่ง Apple เลือกใช้ Primary Memory แบบ LPDDR4X SDRAM (synchronous DRAM) 4266 MHz ที่มีความเร็วสูงมาก ๆๆๆ คอมพิวเตอร์ประกอบทั่ว ๆ ไปก็อาจจะไปใช้ 2400 MHz หรือ 3200 MHz ซึ่งจะเห็นได้เลยว่า เร็วกว่ากันเยอะมาก ๆ (จริง ๆ ในตลาดมีขาย RAM แบบ DDR4 4500 MHz ด้วยนะ แต่ 16 GB ราคาเฉียดหมื่นได้เลยมั่ง)

อีกเหตุผลที่เราชอบมาก ๆ มาจากการที่ใช้ UMA ที่ยัดเอา Memory มาอยู่ใน Pool รวมกันกับทุกอุปกรณ์เลย ทำให้การจัดสรร Memory ทำได้อย่างมีประสิทธิภาพมากขึ้น เพราะจากเดิมที่เมื่อก่อน เราอาจจะซื้อ GPU ที่ Memory ไม่ได้เยอะมาก แต่ RAM อาจจะมี RAM เยอะ แต่ถึงเวลาจริง GPU ก็ใช้ได้เท่าที่มันมีเลย ในขณะที่ CPU อาจจะใช้ Memory ไม่เท่าไหร่ แต่พอเป็น UMA ทุกอย่างไว้ที่เดียวกันหมด ใครอยากใช้เยอะ เอาไป ทำให้การจัดสรรทรัพยากรทำได้อย่างมีประสิทธิภาพมากขึ้นนั่นเอง

ตัวอย่างที่ทำให้ UMA มันได้เปรียบมาก ๆ คือ GPU สำหรับคนที่อาจจะเคยซื้อ GPU มาก่อน น่าจะเคยได้ยินว่า เวลาเราซื้อเราต้องดูขนาด Memory ของมันด้วย สำหรับการเล่นเกมที่มีความซับซ้อนมาก ๆ นั่นแหละ เวลามันทำงานจริง ๆ CPU จะต้องไปโหลดข้อมูลจาก SSD หรือ HDD ของเรามาเก็บไว้ที่ RAM แล้วต้อง Copy ไปไว้ที่ GPU อีกทีเพื่อให้มันคำนวณ ซึ่งการทำแบบนี้ มันเสียเวลาการย้ายข้อมูลไปมามาก ๆ ใน M1 ที่ใช้ UMA มันสามารถที่จะ Copy จาก Storage ได้ตรง ๆ และเก็บไว้ใน Unified Memory แล้วให้ GPU มาเรียกได้เลย ลดเวลาไปเยอะมาก ๆ เลยทีเดียว

ถามว่า ทำไมเจ้าอื่นเข้าไม่ทำบ้างละ เหตุผลนึง คือธรรมชาติของการทำงาน CPU และ GPU ค่อนข้างมีความแตกต่างสูงมาก ๆ โดยที่ CPU จะต้องการข้อมูลทีละนิด แต่ต้องการบ่อย ๆ กลับกัน GPU ต้องการ ข้อมูลทีละเยอะ ๆ แต่กินไม่บ่อย ถ้าเกิดเราทำ UMA แล้วไม่ได้คิดถึงเรื่องนี้เลย เวลาทำงานจริง ๆ นึกถึงตอนที่ GPU Fetch ข้อมูลใหญ่ ๆ อยู่ แปลว่า Bandwidth มันก็จะหมดไปกับ GPU เยอะ แล้ว CPU ทำยังไง มันก็ต้องรอ ๆ ทำให้การทำงานมันก็ช้าลงนั่นเอง

Apple แก้ปัญหาด้วยการใช้ Memory แบบพิเศษนิดนึงคือ High Bandwidth Memory (HBM) สำหรับการแก้ปัญหาเรื่อง Bandwith ที่อาจจะเกิดขึ้นจาก GPU พร้อมกับการใช้ข้อดีของการเป็น SoC คือสามารถวาง Memory ไว้ใกล้กับ CPU มาก ๆ ทำให้ Latency มันต่ำลงมาก ๆ ซึ่งเป็นการแก้ปัญหาที่เกิดขึ้นจากฝั่ง CPU ได้เลย

SSD ที่โคตรแรง ทำให้ทำงานได้เร็วขึ้นอีก

นอกจาก UMA ที่รวม Memory ทั้งหมดเข้าด้วยกันแล้ว SSD ที่ Apple เลือกใส่ลงมาในเครื่องที่เป็น M1 ก็ไม่เบาเลย เพราะมันสามารถอ่านเขียนได้ถึงระดับเกือบ 3 GB/s ต้องบอกเลยว่า โคตรแรงพอตัวเลย แรงกว่า Macbook Air รุ่นก่อนหน้าถึง 3 เท่า หรือถ้าเทียบกับ NVMe SSD ในตลาด ต้องบอกเลยว่า Performance การเขียนของมันคือ พระเจ้าเลย ขนาด WD Black NVMe SN750 ที่เราว่าเร็วมาก ๆ แล้ว ความเร็วในการเขียนยังได้อยู่ที่ 1.6 GB/s ซึ่งช้ากว่า SSD ที่ Apple เลือกใส่มาถึง 2 เท่าตัวเลยทีเดียว

ถามว่า การที่ SSD เร็วขนาดนี้ มันช่วยอะไรกันละ ถ้าเป็นการที่โปรแกรมโหลดเร็วขึ้น เหมือนตอนที่เราเปลี่ยนจาก HDD เป็น SSD ก็ไม่ใช่เรื่องแปลกอะไร แต่สิ่งที่ทำให้ระบบโดยรวมมันทำงานเร็วขึ้น เกิดจากสิ่งที่เรียกว่า Paging

ใน Modern OS มีการนำ Concept ในเรื่องของการทำ Paging เข้ามาใช้ ในกรณีที่ Primary Memory หรือ RAM ในเครื่องคอมพิวเตอร์ทั่วไปหรือ Unified Memory ใน M1 มันไม่พอ มันจะย้ายข้อมูลบางส่วนที่คิดว่า มันยังไม่ได้ใช้ ใส่ลงไปใน Secondary Memory หรือก็คือพวก SSD ของเรา และพอเราต้องการจะเรียกมันขึ้นมาใช้ มันก็จะเรียกกลับขึ้นมาใหม่ แล้วอาจจะสลับของที่ไม่ใช้ลงไปอีก

สำหรับคนที่ใช้เครื่องที่ RAM น้อย ๆ หน่อย อาจจะเคยเจออาการที่เมื่อเราเปิดโปรแกรมเยอะ ๆ ทำไม่เครื่องถึงอืด เพราะมันจะต้องอ่านพวก Paging ขึ้นมาจาก SSD หรือ HDD ขึ้นมาบน RAM และ กลับกัน เขียนข้อมูลจาก RAM ไปฝากที่ SSD หรือ HDD เพราะกระบวนการตรงนี้แหละ ทำให้เครื่องของเราบางทีมันก็จะอืด

แต่ด้วยความเร็วของ SSD บน Mac M1 ทำให้กระบวนการเหล่านี้ ลดเวลาการทำงานลงไปได้เยอะมาก ๆ เมื่อก่อน เราอาจจะเขียนได้แค่ 1.5 GB/s แต่ตอนนี้เราเขียนได้เกือบ 3 GB/s ก็คือ ลดเวลาในการเขียนลงไปได้ถึง 2 เท่าตัวเลย ทำให้ระบบเมื่อเราใช้งาน Unified Memory เต็ม และต้องทำ Paging ทำให้ระบบมี Responsive ที่ดีขึ้น ลดอาการค้าง ๆ อ๋อง ๆ เหมือนก่อนหน้านี้นั่นเอง

แต่ก็เพราะ Paging นั่นแหละที่ทำให้ผู้ใช้ M1 บางคนมีความกังวล เพราะ SSD มีอายุที่นับจากจำนวนข้อมูลที่เขียนลงไป ถ้าเขียนเยอะ ก็มีโอกาสที่ SSD จะพังเร็วขึ้น และ SSD มันก็มาเป็น SoC กับ M1 เลย ทำให้การเปลี่ยนแค่ SSD จึงเป็นได้แค่ฝัน แล้วพบปัญหาว่า macOS มีการทำ Paging ลง SSD เป็นจำนวนมาก แต่ปัญหานี้ ก็เจอแค่บางคน ซึ่ง ณ วันที่เขียน ส่วนใหญ่ก็บอกว่า จะเกิดจาก App ที่ทำงานผ่าน Rosetta ก็คือ ถ้าเว้นได้ก็เว้นการใช้ App ที่ต้องใช้ Rosetta ไปก่อน (Rosetta คืออะไร รออ่านใน Section ด้านล่าง)

เราสามารถเช็คปริมาณที่ macOS เรียกการอ่านและเขียน SSD ในการทำ Paging ได้ผ่าน App Activity Monitor ที่มากับเครื่อง ให้เข้าไปที่ Tab Disk และค้นหา Process ที่ชื่อว่า kernel_task ในช่อง Byte Written จะเป็นส่วนที่ Paging เขียนลง SSD และ Byte Read จะเป็นส่วนที่ Paging อ่านจาก SSD ไป ซึ่งค่าที่อยากให้ดูคือ Byte Written เพราะอย่างที่บอกว่า อายุของ SSD ขึ้นกับจำนวนข้อมูลที่เขียนลงไปเป็นหลัก

การเปลี่ยนแปลงสู่ ARM

เมื่อเราอ่านรีวิว M1 ทั้งหลาย เราอาจจะเคยได้ยินมาบ้างแหละว่า M1 มันเป็น ARM นะ มันต่างจาก Intel มาก ๆ จนทำให้โปรแกรมที่ทำงานบน Intel เมื่อก่อนจะมาทำงานบน M1 ไม่ได้เลย ต้องรันผ่าน Rosetta เท่านั้น เพื่อการอธิบายได้ลึกมากขึ้น เราต้องพาเข้าไปดูไส้ในของ CPU (ที่ไม่ใช่ Case น่ะ CPU คือชิพที่ใส่อยู่ใน Mainboard น่ะ) คอมพิวเตอร์กัน

การทำงานของ CPU จริง ๆ แล้ว ถ้านึกถึงโปรแกรมที่เหล่า Programmer เขียนขึ้นมา มันก็จะถูกแปลงไปเป็น Machine Code หรือ ในสมัยก่อน ภาษาที่ใกล้กับ Machine Code ที่สุดก็น่าจะเป็น Assembly ซึ่งถ้าเราเคยลองเขียนกัน มันก็จะเป็นคำสั่งเช่น JMP, ADD, MOV ซึ่งนี่แหละ เวลามันแปลงเป็น Machine Code มันก็จะเป็นคำสั่งพวกนี้แหละตรง ๆ เลย

มันคือสิ่งที่เรียกว่า Instructions หรือก็คือ คำสั่งที่บอกให้ CPU ไปทำอะไรต่อ เพื่อให้ทำงานได้นั่นเอง ซึ่งบนโลกเรามันก็มี CPU จากหลายค่ายเยอะมาก ๆ เช่น AMD และ Intel ที่เป็นเจ้าตลาด (Intel การ์ดตกแล้วนะะะะ) ทำให้ชุดคำสั่งที่มีใน CPU มีความแตกต่างกัน ซึ่ง ณ ตอนนี้ เราก็จะใช้กันอยู่ใน 2 Concept ใหญ่ ๆ ด้วยกันคือ CISC ที่ใช้กันบน Intel และ AMD บนสถาปัตยกรรมแบบ x86 ยาวจนมาถึง x64 และ RISC ที่อยู่ใน ARM ที่เราใช้กันในโทรศัพท์มือถือซะเยอะ

ถ้าใครเป็น Mac User ในยุคเก่า ๆ หน่อย เราก็อาจจะเคยเห็น Apple มีการเปลี่ยนแปลง CPU มาก่อน ในปี 2006 ที่ Steve Job ออกมาเปลี่ยน CPU จาก PowerPC ซึ่งใช้ชุดคำสั่งแบบ RISC เป็น Intel ที่ใช้แบบ CISC ตอนนั้นก็คือเรียกได้ว่า เป็นการเปลี่ยนผ่านครั้งใหญ่เลยก็ว่าได้ จนปีนี้ Apple ก็เข้าสู่การเปลี่ยนผ่านอีกครั้งด้วยการหันไปใช้ ARM ที่เป็น RISC

CISC และ RISC คืออะไร และต่างกันยังไง

เพื่อความอินที่มากขึ้น เราจะมาอธิบายถึง Instruction Set Architecture (ISA) ของ CISC (Complex Instruction Set Computer) และ RISC (Reduced Instruction Set Computer) กัน

เวลาเราไปซื้อ CPU เราน่าจะเคยได้ยินว่า CPU ตัวนี้ความเร็วเท่านี้ ๆ GHz นะ แล้วแต่ตัวเลย ความเร็วนี้เราเรียกมันว่า Clock Speed หรือแปลเป็นไทยตรง ๆ เลยคือ ความเร็วของสัญญาณนาฬิกา มันคือ ความเร็วที่ CPU สามารถทำงานได้ใน 1 วินาที เช่น CPU ตัวนึงมี Clock Speed ที่ 4.5 GHz หมายความว่าใน 1 วินาที CPU ตัวนี้จะทำงานอยู่ที่ 4,500,000,000 ครั้ง (Cycle) ด้วยกัน ยิ่ง Clock Speed เยอะเท่าไหร่ก็ทำให้ CPU ประมวลผลได้เร็วขึ้นเท่านั้น ทำให้มันเลยมีการ Overclock หรือการพยายามเพิ่ม Clock Speed เข้าไป เพื่อให้ CPU ทำงานเร็วขึ้นนั่นเอง แต่ก็แลกมากับ การกินไฟ และ ความร้อนที่มากขึ้นด้วยเป็นเงาตามตัว

หลักการออกแบบ Instruction Set บน CISC และ RISC มีความแตกต่างกันมาก ๆ โดยที่ RISC จะออกแบบ Instruction มาให้ สามารถทำงานได้ภายใน 1 Cycle กับมีความยาวเท่ากันหมด แต่ในขณะที่ CISC เน้นการออกแบบ Instruction ที่มีความซับซ้อน เพื่อให้การเขียน และ Compile โปรแกรมทำได้ง่ายขึ้นมาก โดยที่ในแต่ละ Instruction ก็อาจจะใช้จำนวน Cycle ในการทำงานที่ไม่เท่ากัน

ตัวอย่างเช่น การบวกเลข ใน CISC เวลาเราเขียนโปรแกรม เราอาจจะเขียน ADD แล้วเราไม่ต้องไปสนใจอะไรแล้ว ว่าข้างในมันมีการโหลดข้อมูลลง Register ตัวไหนบ้าง แล้วไปอะไรยังไง เพราะ CISC มันคิดมาให้เราแล้ว ทำให้ข้างในการทำงานจริง ๆ แล้วมันอาจจะใช้ 4 CPU Cycle ในการทำงานเลย ตั้งแต่การ LOAD ตัวเลขชุดที่ 1 และ 2 ลง Register แต่ละตัว บวกเลข และ เก็บผลลัพธ์ลง Register อีกชุด แต่ใน RISC จะเน้นการออกแบบให้ Instruction มันทำงานใน Cycle เดียวเลย ทำให้เรา Programmer ต้องเขียนคำสั่งมากขึ้นเพื่อสร้าง Pipeline การทำงานที่เทียบเท่ากับ CISC ถ้าอยากรู้รายละเอียดเพิ่มเติมมีคนเขียนไว้ดีมาก Why Pipeline a Microprocessor?

จากตัวอย่างด้านบน ทำให้เห็นได้ชัดเจนเลยว่า CISC ทำให้ Compiler ทำงานได้ง่ายมาก ๆ ถ้าโปรแกรมเขียนมาให้บวกเลข มันก็สามารถเปลี่ยนเป็น ADD ใน Machine Code ได้เลยบรรทัดเดียว แต่ถ้า RISC มันจะต้องเปลี่ยนไปเป็นชุดคำสั่งหลาย ๆ บรรทัดหน่อย แต่นั่นก็ทำให้ Instruction Set ของ CISC มีขนาดใหญ่กว่า RISC มาก ทำให้ขนาดของ Address ที่ใช้เก็บก็ต้องยาวขึ้นด้วยเช่นกัน ทำให้เราต้องการที่เก็บ Address เหล่านั้นเยอะขึ้นด้วยเช่นกัน เช่น RISC อาจจะใช้แค่ 32 Bits แต่ CISC อาจจะใช้มากกว่านั้นถึง 64 Bits

มองภาพง่าย ๆ ความต่างระหว่าง CISC และ RISC คือหลักการในการออกแบบ Instruction Set ที่ CISC จะพยายามออกแบบให้มาในลักษณะของ Microprogramming Language ที่มีคำสั่งอยู่เยอะมาก ๆ ทำงานที่ซับซ้อนได้ในคำสั่งเดียว แต่ในคำสั่งเหล่านั้น ตอนแปลงเพื่อมาใช้จริง ๆ ก็อาจจะประกอบด้วยหลายคำสั่งข้างใน ทำให้แต่ละคำสั่งใช้จำนวน Cycle ที่ไม่เท่ากัน แต่ในขณะที่ RISC เน้นการออกแบบ Instruction Set ให้มีความ Premitive มาก ๆ ทำให้มีจำนวนที่น้อยกว่า แต่บอกว่า ทุก Instruction จะใช้เวลาการทำงานแค่ Cycle เดียวเท่านั้น

ถามว่า แล้วระหว่าง RISC กับ CISC อันไหนดีกว่า อื้ม.... เป็นคำถามที่ตอบยากมากเลย ตอนเรียนก็เคยถามอาจารย์เรื่องนี้เหมือนกัน เรามองว่า มันก็มีข้อดีข้อเสียต่างกัน แต่เรามองว่า RISC มันเป็นอนาคตมากกว่า เพราะเทคโนโลยีบางอย่างที่ดีขึ้น เช่น Memory ที่ราคาถูกลง ที่เคยเป็นข้อเสียของ RISC คือกิน Memory เยอะ หรือจะเป็นการสร้าง Compiler ที่เก่งขึ้นพอที่จะ Compile High Level Programming Language อย่าง C++ ให้เป็น Machine Code ได้ดีขึ้น และ การทำ Pipelining ที่ทำให้ CPU สามารถ Scheduling งานได้อย่างมีประสิทธิภาพมากขึ้น ทั้งหมดนี้ เราเลยว่า มันเลยทำให้ Concept ของการทำ RISC มันดูดีขึ้นกว่าเมื่อก่อนมาก ประกอบกับ จาก M1 ที่ออกมายิ่งช่วย Confirm ไอเดียนี้ของเราเลย เพราะมันโคตรเร็วเลย

M1 isn’t magical but f_cking CLEVER

via GIPHY

ตอนเราดู Keynote ของ Apple ครั้งแรก คิดแล้วนะว่า Apple โม้ป่าวเนี่ยยยย ทำไมมันทำได้ดีกว่าทุกด้านขนาดนั้น ตั้งแต่ Performance ในการทำงาน หรือจะเป็นเรื่องของการบริโภคพลังงานที่น้อยจนน่าตกใจมาก ๆ ดูเป็นอะไรที่ Magical มาก ๆ แต่พอเราเข้ามาอ่านจริง ๆ แล้วต้องบอกเลยว่า มันเป็นอะไรที่โคตรฉลาดชิบหายเลยละ

เวลาเราออกแบบ CPU เพื่อให้มีประสิทธิภาพสูงสุดเท่าที่จะเป็นไปได้ สิ่งที่เราต้องทำคือ การที่เราสามารถทำให้ทุกส่วนของ CPU ทำงานได้โดยที่มีคนว่างให้น้อยที่สุด ทุกคนต้องมีงานทำตลอดเวลาเท่าที่จะเป็นไปได้ ทำให้ ต่อ 1 หน่วยเวลา CPU จะประมวลผลได้เยอะที่สุดนั่นเอง

สิ่งที่ Apple ทำอย่างแรกคือ ทำให้ส่วนที่รับ และอ่าน Instruction เข้ามาใน CPU หรือ Instruction Decoder มีขนาดใหญ่ขึ้นเป็น 8 ตัว เมื่อเทียบกับ CPU อื่น ๆ ที่อาจจะมีแค่ 5 ตัว ทำให้ใน 1 Cycle Performance Core ของ M1 สามารถอ่าน Instruction ที่เข้ามาได้ถึง 8 ตัวพร้อม ๆ กันเลย

Instruction Decoder เป็นส่วนนึง ที่มันจะทำงานอยู่ใน CPU ทำหน้าที่ในการอ่าน Instruction ที่ได้รับมา และส่งไปทำงานตามส่วนต่าง ๆ ของ CPU เช่น Integer Unit และ Floating Point Unit เป็นเหมือนกับ Switch ใน CPU นั่นเอง เช่นเจอ ADD Instruction หรือก็คือ บวกเลข มันก็จะส่งไปที่ส่วนของการทำงานกับจำนวนเต็ม (Integer Unit) ทำงานและเอาผลลัพธ์ออกมานั่นเอง

เมื่อ Instruction Decoder ถูกเพิ่มขึ้น ทำให้โอกาสที่ส่วนประมวลผลต่าง ๆ ของ CPU จะว่างมันก็มีน้อยลง เพราะมันสามารถ Generate งานให้ CPU ทำงานได้เร็วขึ้นนั่นเอง แต่มันก็มีข้อเสียเหมือนกัน ส่งผลทำให้ Latency หรือความหน่วงในการทำงานมากขึ้น และแน่นอน การเพิ่ม Component เข้าไปทำให้มันกินไฟมากขึ้นอีกด้วย แต่เพราะการที่ Apple เลือกใช้ ARM ซึ่งใช้ ISA แบบ RISC ซึ่งในแต่ละ Instruction มีขนาดเท่ากัน ทำให้ Instruction Decoder มีการออกแบบที่ง่ายกว่า และ มีประสิทธิภาพสูงมาก ๆ

เพิ่มความมันส์เข้าไปอีก หลังจากที่ CPU ทำการ Decode Instruction ออกมาเรียงคิวกันตามโปรแกรมที่เขียนมาแล้ว ถ้าเราค่อย ๆ ให้ CPU มันส่งทีละ Instruction เข้าไปทำงาน เช่น เราส่งคำสั่ง ADD ไปที่ Integer Unit มันก็ทำงานไป แต่ Unit ที่เหลือเช่น Floating Point Unit หรือ LOAD/STORE Unit มันว่างมันก็เสียเวลา

ทำให้ CPU สมัยใหม่ ทำสิ่งที่เรียกว่า Out-of-Order Execution (OoOE) หรือก็คือการยัด Instruction ที่ไม่ได้เรียงตามที่โปรแกรมเขียนไว้ แต่มันมีเงื่อนไขอยู่ด้วยว่า อันที่เราจะแหกโปรแกรมแล้วยัดเข้าไปพร้อม ๆ กันจะต้องไม่เป็น Dependency ของกันและกัน

1: a = 1 + 2
2: a = a + 1
3: c = 1 + 1

ตัวอย่างจาก Code ด้านบน เราจะเห็นว่า คำสั่งที่ 1 และ 2 มี Dependency ต่อกัน เพราะการที่คำสั่งที่ 2 จะทำงานได้ มันจะต้องรอผลจากคำสั่งอันที่ 1 ซึ่งเป็นคำสั่งก่อนหน้า ทำให้ CPU จะไม่เลือกคำสั่งนี้เข้าไปก่อน มันก็จะรอผลจากคำสั่งแรก เข้าไปก่อน แล้วค่อยยัดคำสั่งที่ 2 เข้าไป แต่คำสั่งที่ 3 ไม่ได้เป็น Dependency กับใครเลย เพราะมันไม่ได้ใช้ค่าอะไรจากใคร มันก็จะถูกยัดเข้าไปพร้อม ๆ กับคำสั่งที่ 1 ถ้า Integer Unit สำหรับการบวกมันมีมากกว่า 1 ตัวนั่นเอง (ซึ่งจริง ๆ มันมีมากกว่า 1 แหละ)

ปัญหาคือ โปรแกรมมันคาดหวังว่า ให้เราส่งผลของคำสั่งที่ 1,2, และ 3 เรียงกลับไปเหมือนเดิม แต่เราดันรันสลับกันไปหมด โปรแกรมก็น่าจะ งง แย่ละ ดังนั้น เราต้องทำยังไงดีถึงจะส่งผลกลับไปได้โดยที่เรียงตามเดิม ?

งั้น ถ้าเรามีผลของ 1 และ 3 แล้ว เรารอ 2 เราก็ต้องเก็บผลของ 1 และ 3 เอาไว้ เพื่อรอ 2 จะได้ส่ง 1,2,3 ไปหมด ทำให้มันจะต้องมีที่เก็บผลของที่มันรันไม่เรียงกันไว้ ส่วนนี้เราเรียกว่า Reorder Buffer (ROB) นี่แหละที่ทำให้ M1 มันบ้าาาา คือ มันใช้ ROB ที่โคตรใหญ่ ใหญ่กว่าชาวบ้านชาวเมืองเขาเป็นอย่างมาก ทำให้โอกาสที่ ROB จะเต็ม และ CPU จะต้องรอ มันก็จะน้อยลงไปอีก ทำให้ประสิทธิภาพมันสูงขึ้นไปอีก

สุดท้าย พอเราโหลด Instruction ได้เร็วขึ้น และ เราเก็บผลได้เยอะขึ้น แปลว่า Throughput ของ CPU มันสูงขึ้นมาก ทำให้สิ่งที่ตามมาคือ เราจะต้องทำให้การ Fetch หรือการโหลด Instruction จาก Memory ก่อนหน้าก็คือ CPU Cache และ RAM ทำได้ทันทีที่ CPU ต้องการ

ซึ่ง Apple ก็เลือกใช้ CPU Cache ที่มีขนาดใหญ่พอตัวเลย และเมื่อเรารวมกับความเป็น SoC และ UMA ด้วย ที่ทำให้ Bandwidth และ Latency ของ Memory มันน้อยลง ก็ทำให้การโหลดคำสั่งจาก Unified Memory ต้องเร็วพอที่จะทำให้ CPU สามารถทำงานได้โดยที่ไม่ต้องรอเลย

จากทั้งหมดที่เล่ามาทำให้ Apple M1 มันเร็วแบบ บ้าคลั่ง แต่มันไม่ใช่ Magical แบบที่หลาย ๆ คนมอง แต่มันเป็นความโคตรฉลาดในการออกแบบ Chip ของ Apple ที่ต้องยอมรับว่า Apple โคตรเก่งในการทำเรื่องนี้เลย ตั้งแต่ออก Chip A ทั้งหลายสำหรับ Mobile Platform แล้ว อันนั้นก็บ้ามานานแล้ว แซงคู่แข่งอย่าง Snapdragon แบบเละเทะ

การกินไฟที่น้อยจนน่าตกใจ

ทีนี้ถามว่า แล้วทำไม M1 มันกินไฟน้อยขนาดที่ทำให้ Macbook อยู่ได้เกิน 10 ชั่วโมงไปอีก ทั้ง ๆ ที่ Laptop ตัวอื่น เราว่า 5 ชั่วโมงในการใช้งานจริงก็เก่งแล้ว ส่วนนึงเป็นเพราะการออกแบบโดยใช้ สิ่งที่เรียกว่า Heterogeneous computing

Heterogeneous computing คือการออกแบบระบบให้มีการใช้ CPU หรือ Processor Core หลาย ๆ แบบเข้าด้วยกัน เพื่อให้ยังคงความแรง แต่ก็ยังทำให้การกินไฟต่ำได้อยู่ ซึ่งอันนี้ก็ไม่ใช่เรื่องแปลกใหม่อีกเหมือนกัน เพราะในฝั่ง Mobile Device ก็ทำกันมานานมากแล้ว ที่เราอาจจะเคยได้ยินคำว่า big.LITTLE ที่เป็น Heterogeneous computing จากฝั่ง ARM นั่นเอง ที่เราอาจจะเคยได้ยินว่า CPU ของโทรศัพท์ เครื่องนึงมี 4 Core ทำงานไว ๆ และ 2 Core ประหยัดไฟอะไรแบบนั้นแหละ

ใน M1 ก็ทำเหมือนกัน โดยแบ่งออกเป็น 4+4 Core คือ 4 Performance Core และ 4 High Efficiency เข้ามาพร้อมกับมีการทำ Scheduling เลือกงานไปใส่ให้ถูกประเภทของ Core ได้อย่างมีประสิทธิภาพสูงมาก ๆ ทำให้ M1 มันกินไฟน้อยมาก ๆ เมื่อเทียบกับ Computer อื่น ๆ ที่ใช้ CPU อย่าง Intel และ AMD ที่มีแค่ Core ที่ประสิทธิภาพเท่ากัน เท่านั้น

นอกจากนั้น เราเชื่อว่า เพราะการออกแบบ High Efficiency Core ที่ดีมาก ๆ เข้ากับงานมาก ๆ ทำให้ ยิ่งกินไฟน้อยเข้าไปอีก ถ้าได้ลองใช้จะรู้ว่า เราใช้กันเป็นวัน ๆ กว่ามันจะหมด หรือหลายวันในบางคนเลย น่าตกใจมาก ๆ

ทำไม AMD และ Intel ถึงเลียนแบบไม่ได้ ?

อ่านมาถึงตรงนี้ เราอาจจะสงสัยกันว่า เออ M1 มันก็ไม่ได้เป็นเทคโนโลยีที่ใหม่เลย มันแค่เอาส่วนผสมที่มีอยู่แล้วมาหาว่าตรงไหนใส่เท่าไหร่ถึงจะอร่อย ซึ่ง Intel และ AMD ก็มีส่วนผสมพวกนั้นอยู่แล้ว

นั่นเป็นเพราะ Intel และ AMD ออกแบบ CPU สำหรับเครื่องคอมพิวเตอร์หลากหลายรูปแบบ และทำงานบนหลากหลายอุปกรณ์เป็นอย่างมาก ทำให้การออกแบบมันจะต้องทำมากลาง ๆ เพื่อให้รองรับ Hardware และ Software เป็นจำนวนมาก หรือ Microsoft ที่ต้องออกแบบ Windows ให้รองรับ Hardware กว้าง ๆ แต่ Apple ไม่ได้เป็นแบบนั้น

อย่าลืมว่า Apple ตอนแรก นางถือแค่ Software แต่การมาถึงของ M1 ทำให้ Apple ถือ Hardware ด้วย ทำให้ Apple สามารถออกแบบ Hardware และ Software ที่ทำงานกันได้อย่างเข้ากันมาก ๆ มากว่า เจ้าอื่น ๆ ที่ถือแค่ฝั่งใดฝั่งหนึ่งเท่านั้น เหมือนกับที่ Apple เคยทำกับ iPhone และ iPad ด้วยการออก Chip ตระกูล A มาก่อนหน้านี้นั่นเอง

การเตรียมพร้อมล่วงหน้าหลายปี

แน่นอนว่า การเปลี่ยนผ่านแบบนี้ ทำให้ Application ที่อยู่บน macOS ซึ่งเขียนและ Compile มาเพื่อฝั่ง Intel มาโดยตลอด ใช้ไม่ได้แน่นอน เพราะคนละ ISA เลย แต่สิ่งที่ Apple เตรียมการมาดี และเราว่ามันทำให้การเปลี่ยนผ่านนนี้ทำได้เร็ว และ ราบลื่นที่สุดเท่าที่เคยเจอมามีอยู่ 2 เรื่องด้วยกัน

อย่างแรกคือ การพลักให้ Developer พัฒนา App โดยการใช้ภาษา ที่ Apple ทำขึ้นมาเอง คือ Swift ซึ่งพอ Apple เป็นคนพัฒนาภาษาเอง ถึงตอนที่ Apple จะย้ายเป็น ARM เขาก็ทำแค่ Compiler ขึ้นมาใหม่ แล้วให้ Developer สามารถแทบจะ Compile โปรแกรมใหม่ ก็พร้อมทำงานบน ARM อย่างเต็มรูปแบบแล้ว เผลอ ๆ อาจจะใช้เวลาแค่หลักวันเท่านั้น ในการแปลง เหมือนคิดมาแล้ว ฮ่า ๆ

แต่มันก็จะมี Legacy Application ด้วยเช่นกัน ที่อาจจะเลิกพัฒนาไปแล้ว หรือไม่สามารถที่จะ Recompile เป็น ARM ได้ Apple ก็ทำเหมือนวุ้นแปลภาษาขึ้นมาชื่อว่า Rosetta 2

Rosetta 2

Rosetta 2 เป็น วุ้นแปลภาษาที่ Apple สร้างขึ้นเพื่อให้เราสามารถรัน Intel-Based App บน ARM ได้ สิ่งที่มันทำคือ มันจะเข้าไปแปลง Instruction การทำงานของ App ให้กลายเป็นคำสั่งที่ ARM เข้าใจได้ ครั้งแรกที่เราได้ยิน เราคาดหวังแล้วว่า มันต้องไม่รอดแน่ ๆ เพราะมันเป็นความยากทางวิศวกรรม Software มาก ๆ ที่เราจะทำอะไรแบบนี้ได้ และการทำ Emulator ที่ออกมาก่อนหน้านี้ มันก็ไม่ได้ดีขนาดนั้นเลย

แต่พอได้มาลองใช้จริง ๆ Performance ที่เราได้ มันช้าลงแน่ ๆ แหละ เพราะมันต้องมี Rosetta 2 คอยแปลภาษาให้เรา แต่ พอทดสอบออกมา ในบางโปรแกรม ที่รันผ่าน Rosetta 2 กลับทำงานได้เร็วกว่า Intel ซะอีก อันนี้เป็นผลจากการออกแบบ Rosetta 2 มาดีมาก ๆ เพราะการ Emulate x86 และ x64 App มาเพื่อทำงานบน ARM มันมีการทำงานหลายอย่างที่แตกต่างกันมาก ๆ และอาศัย Performance ของ CPU พอตัวเลยในการจัดการปัญหาเหล่านั้น แต่ Apple ก็ทำได้อย่างน่าประทับใจมาก ๆ อันนี้ขอชื่นชมเลย

นอกจากนั้น การทำงานของ Rosetta 2 ที่ดูยาก และ น่าจะ งง มันทำให้เป็นเรื่องที่เราไม่ต้องสนใจ ไม่ต้องมองเห็นเลย เพราะตัวเครื่องมันจะถามให้เราติดตั้ง Rosetta 2 แค่ครั้งแรกที่เราเรียก Intel-Based App มา หลังจากนั้น เมื่อเรารันโปรแกรมอื่น ๆ ที่ไม่ได้ทำมาสำหรับ Apple Silicon มันก็จะไม่ถามอะไรเลย รันได้เหมือน App ปกติเลย ทำให้ผู้ใช้ทั่วไป ไม่ต้องกังวลเรื่องความซับซ้อนนี้เลย

สำหรับใครที่อยากรู้ว่า App ที่เราทำงานอยู่มันเป็น App แบบไหนให้เราเข้าไปดูได้ที่ Activity Monitor ใน Tab ของ CPU ใน Column Kind มันจะแสดงอยู่ ถ้าบอกว่าเป็น Intel ก็คือเป็น App ที่รันผ่าน Rosetta 2 อยู่ แต่ถ้าเป็น Apple ก็คือ Compile มาสำหรับ Apple Silicon เป็นที่เรียบร้อยแล้ว

และถ้าเราอยากรู้ว่า App ตัวไหนรองรับ การทำงานผ่าน Rosetta หรือไม่ หรือ Compile มาเป็น Apple Silicon แล้ว เราสามารถเข้าไปดูได้ที่ Is Apple silicon ready? ได้เลย

Apple ไม่ใช่คนแรก Microsoft ก็เคยพยายามที่จะทำมาก่อน

Apple ไม่ใช่คนแรกที่พยายามจะเอา Full Desktop OS เข้าไปเล่นกับ CPU ARM เพราะย้อนกลับไปเมื่อปี 2012 Microsoft ก็ออก Windows RT ซึ่งเป็น Windows ที่ทำงานบน CPU แบบ ARM ซึ่งตอนนั้น ต้องบอกเลยว่า เจ๊งจ้าาาา ส่วนนึง เราว่าเป็นเพราะการสื่อสารระหว่าง Microsoft และผู้ใช้ที่ไม่ตรงกัน ทำให้ผู้ใช้ทั่วไปคิดว่า มันสามารถรัน App ที่เป็น x86 ได้ แต่สุดท้าย มันก็กลายเป็นว่าทำอะไรแทบไม่ได้เลย ก็เลยเจ๊งไปซะงั้น

จนอีก 7 ปีให้หลังคือปี 2019 Microsoft ก็นำไอเดียการใช้ ARM กลับมาอีกครั้ง แต่มารอบนี้ Microsoft เล่นใหญ่ขึ้นด้วยการไปจับมือกับ Snapdragon ซึ่งเป็นค่ายที่ผลิต CPU ARM รายใหญ่ ที่เรามักจะได้เห็นกันในโทรศัพท์มือถือ Android หลาย ๆ ยี่ห้อมาก ๆ เรียกได้ว่า Snapdragon น่าจะเป็นชิพอันดับต้น ๆ ที่ถูกใช้เลยก็ว่าได้ ด้วยการออก Chip ในรุ่น SQ1 ออกมา แต่แน่นอนว่า สุดท้ายเราว่าไม่รอดอยู่ดี แต่ไม่ใช่เรื่องของการสื่อสารแล้ว แต่เป็นเรื่องของ App ที่สามารถทำงานได้แบบ Native เขาไม่ได้มีการเตรียมการอะไรมากเท่าไหร่

ถ้าเราเข้าไปใน Microsoft Store แล้วลองหา App ส่วนใหญ่ที่ได้ออกมา มักจะเป็น App ขยะซะเยอะ ไม่ค่อยได้เจอ App ที่ใช้ได้จริง ๆ เท่าไหร่ ทำให้เราคิดว่า การเลือก หรือคัดสรร App ของ Microsoft ไม่ได้ทำได้แน่นเท่ากับ Apple เท่าไหร่ และช่วงปลายปี 2020 Microsoft ก็ออก x64 Emulator ที่รันบน ARM แบบเป็น Preview ซึ่งต้องบอกเลยว่า การติดตั้งปวดหัว และ พอใช้จริง ๆ เข้ามันก็ไม่ได้ราบลื่นเท่าไหร่ เจอ Error โน่นนี่สารพัด คือรู้สึกโชคดีที่เคยยยืมของเพื่อนมาเล่น ไม่ได้ซื้อเอง ไม่งั้นเสียดายเงินแย่

ทำให้เราสามารถถอดบทเรียนจากเรื่องของ Microsoft การเปลี่ยนแปลงสถาปัตยกรรมถือว่าเป็นเรื่องใหญ่มาก ๆ สำหรับบริษัทนึงที่มีผู้ใช้เป็นจำนวนมาก ดังนั้น การจะเปลี่ยนแปลงให้ราบลื่นที่สุด มันไม่ได้อาศัยแค่ความสามารถของ Software Engineer เท่านั้น ที่จะสร้าง Technology เพื่อให้การเปลี่ยนผ่านมันเป็นไปได้อย่างราบลื่น แต่มันยังต้องอาศัยการสื่อสารกับผู้ใช้ด้วย ถึงข้อจำกัดต่าง ๆ ณ ปัจจุบันว่า มันทำอะไรได้ หรือไม่ได้ เรื่องนึงที่เราคิดว่า Apple ทำได้ดีมาก ๆ คือ การที่เขาพูดชัดเลยนะว่า App ปกติมันจะรันไม่ได้ และมีการแบ่งประเภท App อย่างชัดเจน พร้อมกับมีการเตรียมการมาอย่างยาวนาน ทำให้การเปลี่ยนผ่านครั้งนี้มันราบลื่นที่สุด

สรุป

Apple M1 เป็น SoC ที่น่าตื่นเต้นมาก ๆ ตอนที่ฟัง Present และเมื่อเอามาใช้จริง ๆ มันก็น่าตื่นเต้นตามที่ Apple เคลมเลย ด้วยความเร็วที่โคตรแรง และ ยังกินไฟน้อยมาก ๆ จนทำให้ Macbook Air ที่เราใช้คือ ชาร์จแทบจะสัปดาห์ละครั้งเท่านั้น นับว่าเป็นความก้าวหน้าในการออกแบบ SoC จาก Apple มาก ๆ และ Apple เองก็ยังเป็นคนที่ดึงประสิทธิภาพของ M1 ได้อย่างเต็มที่อีกด้วย เพราะ Apple กุมทั้งฝั่งของ Software คือ macOS และ Hardware ที่เป็น Apple Silicon ทำให้ Apple เหมือน Hack Map เลย รู้แล้วว่าขุมทรัพย์ หรือแอบมีพลังการประมวลผลซ่อนอยู่ตรงไหนมั้ย Apple ก็สามารถขุดคุ้ยออกมาได้หมดเลย ส่วนเรื่องของ Software Compatibility เรามองว่า ณ วันที่เราเขียนมันดีขึ้นเยอะแล้ว หลาย ๆ App ก็ออกมารองรับ Apple Silicon กันแล้ว ส่วนนี้ก็เป็นเพราะ Apple คิดมาแล้ววางแผนมาล่วงหน้า พร้อมกับนักพัฒนาก็พร้อมที่จะเปลี่ยนด้วยเช่นกัน ในงาน Software Development Tools ตัวหลัก ๆ ที่น่าจะใช้กันคือ Docker ก็ Support แล้ว ทำให้ M1 เป็น SoC ที่น่าสนใจมาก ๆ ในปัจจุบัน อยากรู้เลยว่า รุ่นต่อไปมันจะทำอะไรได้อีก โหดมาก ๆ