Core และ Thread ใน CPU คืออะไร ?

เวลาเราจะไปซื้อ CPU ในปัจจุบัน ปัจจัยหนึ่งที่เรามักจะดูกันคือ พี่ ๆ CPU นี้มีกี่ Core กี่ Thread ซึ่งก็ไม่รู้เหมือนกันว่าถามไปทำไม ฮ่า ๆ อ้าวเหรอ วันนี้เราจะมาเล่าให้อ่านกันว่า เจ้า 2 คำนี้มันคืออะไร และ ที่มาของมันคืออะไร

คำเตือน เราพยายามเล่า ให้คนทั่วไปอ่านแล้วเข้าใจได้ ดังนั้น จะไม่มีการลงลึกในเรื่องของพวก RISC และ Von Neumann Machine เอาแค่ ให้จินตนาการออกพอว่า มันทำอะไรบ้าง อยากรู้ลึกขึ้นให้ไปอ่านเอา ช่วยตัวเองบ้างสิ ห๊ะ !!! ปัดโธ่ !!!

Traditional CPU

เมื่อก่อน ย้อนกลับไปเมื่อนานมาแล้ว ก่อนที่ CPU จะมีหลาย Core หลาย Thread ในปัจจุบัน มันก็มีอยู่ Core เดียว และ ยังไม่มี Thread ด้วยซ้ำ

ทำให้ปัจจัยที่เราดูว่า CPU ตัวไหนเร็ว ในช่วงเวลานั้น ก็น่าจะมีแค่ ความเร็วของสัญญาณนาฬิกา ภาษาอังกฤษเราเรียกว่า Clock Speed นั่นเอง ซึ่งเราใช้หน่วยเป็น Hz นั่นเอง

สำหรับใครที่ไม่เข้าใจคำว่า Clock Speed ให้เรานึกถึงว่า CPU อยู่ ๆ มันจะทำงานเลยไม่ได้ มันเป็นของที่ต้องมีจังหวะในหัวใจ มันต้องการอะไรที่มาบอกให้มันทำงานเป็นจังหวะยังไง วิธีนึงที่ทำได้คือ เราก็ให้นาฬิกามันไป เช่นเราบอกว่า 1 นาที ให้ ทำงาน 1 ครั้ง

แต่ในโลกแห่งความเป็นจริง 1 นาที ทำงาน 1 ครั้ง ก็คือ ช้าตายไปพอดี ทำให้เวลาเราคุยเรื่อง Clock Speed เราคุยกันในระดับ Hz หรือ ครั้งต่อวินาที เช่น CPU ตัวนี้ ทำงานที่สัญญาณนาฬิกา 600 MHz ก็คือ มันทำงานได้ 600 ล้านครั้ง ต่อ วินาที ซึ่งในปัจจุบัน CPU ตัวแรง ๆ หน่อย ก็ทำงานได้ที่ 5 GHz กันเลยทีเดียว

ถ้าเราบอกว่า ยิ่งเพิ่ม Clock Speed CPU ของเราก็จะทำงานได้เร็วขึ้น เราก็เพิ่ม ๆ มันขึ้นไปเรื่อย ๆ ก็จบแล้ว อ่าาาห์ มันก็ถูกแหละ แต่ การเพิ่ม Clock Speed ขึ้นไป มันก็ต้องแลกมากับอะไรบางอย่างนั่นคือ ไฟเลี้ยง ที่ต้องเยอะขึ้น และ ความร้อนที่เพิ่มขึ้น ซึ่งมันก็นำไปสู่ข้อจำกัดที่ว่า วัสดุที่เราใช้ผลิต CPU มันไหวมั้ยอีก ทำให้เราไม่สามารถพา CPU เราไปรันที่ Clock Speed ที่สูงมาก ๆ อย่าง ระดับ 50 GHz ได้นั่นเอง

CPU Core คืออะไร ?

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

นั่นแหละ คือ Concept ของ CPU Core ทำให้เกิด CPU ที่เป็น Multicore ขึ้นมา ที่มีตั้งแต่ 2,4,6,8,16 Core ไปเรื่อย ๆ ถึงระดับ 64 Core ใน CPU ระดับ Data Centre เลยทีเดียว

ถ้านึกภาพตาม มันก็คือ เหมือนเรามีคนงานเพิ่ม เพื่อทำงานเดียวกัน นั่นทำให้ งานที่ควรจะใช้เวลาทำหนึ่ง เสร็จเร็วขึ้น (ตามทฤษฏี จริง ๆ มันไม่ได้ทำให้งานเสร็จเร็วขึ้น เป็นเท่าตัวขนาดนั้น ไปหาอ่านตามหนังสือ Parallel Computing เอาละกัน)

การเพิ่มจำนวน Core ก็ดูเหมือนจะเป็นทางออกที่ดี แต่ การเพิ่ม Core ขึ้นไปเรื่อย ๆ ทำให้มีผลต่อ 3 เรื่องใหญ่ ๆ

เรื่องแรกคือ จำนวนของชิ้นส่วน IC ที่เพิ่มขึ้นเยอะมาก ๆ เพราะ 1 Core มันไม่ได้เป็นของชิ้นเล็ก ๆ เลย มันประกอบด้วย หลายชิ้นส่วนเช่น ​ALU และอื่น ๆ อีกมากมาย เพื่อประกอบให้เป็นหน่วยประมวลผล 1 Core ได้ นั่นส่งผลต่อพวกเราโดยตรงคือ ราคาเพิ่มขึ้นอย่างถล่มทลาย

เรื่องที่ 2 คือ เรื่องของ การทำงานระหว่าง Core เมื่อมันทำงานด้วยกัน มันจะต้องมีการคุยกันว่า ใครจะทำอะไร และ การส่งข้อมูลกันไปมา ทำให้มันต้องมีการออกแบบโครงสร้างของหน่วยประมวลผลให้แต่ละ Core สามารถคุยกันได้ อย่างเช่น Cache ที่ใช้เก็บข้อมูลชั่วคราวใน CPU ก็จะมีหลาย Level อย่าง L3 Cache ที่ไม่ได้อยู่ตาม Core แต่เป็น Shared Cache ที่ทุก Core สามารถใช้งานร่วมกันได้

เรื่องสุดท้ายคือ กำลังไฟที่มากขึ้น ด้วยความที่มีอุปกรณ์มากขึ้น ทำให้มันต้องใช้ไฟเยอะขึ้นตามไปได้ นั่นทำให้ผู้ใช้อาจจะไม่ชอบเท่าไหร่ที่เครื่องคอมพิวเตอร์ของเขากินไฟมหาศาลมาก ๆ บางเครื่องคิดเล่น ๆ เปิดใช้งานไป แบบโหลดหนัก ๆ เลย อาจจะเท่ากับแอร์เครื่องเล็ก ๆ ได้เลย

Core เยอะ ทำให้เร็วกว่าจริงเหรอ ?

เป็นคำถามที่หลาย ๆ คนที่ไม่ได้รู้เครื่องของ Computer Architecture อาจจะไม่เข้าใจเท่าไหร่ ต้องมาเข้าใจเรื่องของการทำงานของโปรแกรมกัน

ย้อนกลับไปเมื่อก่อนเลย เมื่อตอนที่ CPU ยังมี Core เดียว โปรแกรมก็เขียนตรง ๆ ได้เลย เช่นเราบอกว่า เราอยากให้มันบวกเลข ตั้งแต่ 1-100 เราก็จะไล่บวก เลขตรง ๆ ไปเรื่อย ๆ จนจบ

ถามว่า แล้วถ้าเราเอาโปรแกรมเดียวกันมารันใน CPU ที่เป็น Multicore มันจะทำให้เร็วขึ้นมั้ย คำตอบคือ ไม่ เพราะ สุดท้ายโปรแกรม ที่เขียนมาก่อนหน้านั้น มันไม่ได้มีส่วนที่ ส่งงาน และ รับงาน กลับมาของแต่ละ Core ทำให้เราเรียกโปรแกรมพวกนี้ว่า Single Core Application

ทำให้จริง ๆ ไม่ใช่ทุกโปรแกรมบนโลกนี้ ที่จะรันเป็น Multicore ได้ ดังนั้น การที่เราบอกว่า เราอยากให้เครื่องเราทำงานเร็วขี้น การเพิ่ม Core อาจจะไม่ได้ทำให้การทำงานเร็วขึ้นเสมอไป ต้องไปเช็คก่อนว่า โปรแกรมที่เราใช้ทำงานนั้น มันทำงานเป็น Multicore ได้

อันนี้เป็น htop ที่ลงผ่าน brew มันบอกรายละเอียดได้ดีกว่า top เยอะ

ถ้าใช้ Mac หรือ Linux ถ้าเราสั่ง top ขึ้นมา เราจะเห็นว่า มัน CPU Usage ของ Process นั้น มันเกิน 100% นั่นแหละใช่เลย

กลับไปที่คำถามเดิมว่า โปรแกรมบวกเลข 1-100 ถ้าเราอยากเขียนให้มันทำงานแบบ Multicore ได้ เราก็ต้องปรับเปลี่ยนโปรแกรม เช่น เราบอกว่า แทนที่จะบวกไปเรื่อย ๆ ตรง ๆ ทำไมเราไม่แบ่งกลุ่มของตัวเลขเป็น 10 กลุ่ม (สมมุติว่า CPU เรามี 10 Core) หรือก็คือ เอามาหารด้วย 10 ก็จะได้เลขที่แต่ละกลุ่มต้องบวกละ แล้วเราก็ยื่นกลุ่มตัวเลข ให้แต่ละ Core ไปบวกมา แล้วเก็บผลไว้ที่นึง พอเสร็จ ถ้าเอาง่าย ๆ เราก็เขียนโปรแกรมให้มันเอา 10 ผลลัพธ์บวกกัน เราก็จะได้ผลลัพธ์ หรือ อยากให้เร็วกว่าน้ัน เราก็อาจจะเขียนเป็นว่า แบ่งผลลัพธ์ออกเป็น 5 กลุ่ม หรือ แต่ละกลุ่มก็จะมีตัวเลขอยู่ 2 ตัวเป็นคู่ ก็ให้แต่ละ Core บวกเลข แล้วโยนผลลัพธ์ แล้วทำแบบนี้ไปเรื่อย ๆ จนกว่าจะเหลือผลลัพธ์แค่อันเดียวก็คืนค่าออกมา ก็ทำได้เหมือนกัน นี่แหละ คือการทำ Parallel Programming ที่จริง ๆ มันมีวิธีการทำ กฏ และ ทฤษฎีอีกเยอะ ถ้าสนใสลองไปหาอ่านได้

Threading คืออะไร

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

ทำให้ต้องย้อนกลับไปดู การทำงานของ CPU ว่า มันทำงานยังไง เราต้องเข้าใจก่อนว่า การทำงานของ CPU จริง ๆ แล้วมัน ทำงานเป็น Pipeline ซึ่งใน Pipeline มันมีหลายขั้นตอนมาก ๆ

พอเรามองเข้าไปดูที่ Process การทำงาน เราจะเห็นว่า เมื่อเราเริ่มขั้นตอน และ ข้อมูลมันผ่านไปที่ขั้นตอนต่อไปแล้ว ขั้นตอนแรก มันก็จะว่างไม่ได้ทำอะไรเลย แล้วถ้าเราเพิ่ม Core เยอะขึ้นเรื่อย ๆ ส่วนนึงของ Pipeline ที่ว่างก็จะมีเยอะขึ้นเรื่อย ๆ

ทำให้เกิดการทำ Threading ขึ้นมา แทนที่เราจะปล่อย ให้ขั้นตอนนึงมันว่าง เราก็ยัดข้อมูลลงไป ทำให้มันทำงานเหมือนโรงงานปลากระป๋อง 🐟 ที่แต่ละขั้นตอน ก็จะมีวัตถุดิบ Feed เข้ามาเรื่อย ๆ โดยที่ไม่มีขั้นตอนไหนว่างเลย

แต่ปัญหามันอยู่ที่ว่า ขั้นตอนบางขั้นตอน มันใช้เวลามากกว่า อีกขั้นตอนนึง เช่น ขั้นตอนก่อนหน้าคือ การอ่านไฟล์จาก HDD และขั้นตอนต่อไป คือ การคำนวณ ทำให้ ตรงส่วนที่มันต้องใช้คำนวณมันต้องรออ่านไฟล์ ให้เสร็จก่อน ซึ่งมันจะใช้เวลามากกว่า

นั่นทำให้ การที่เราจะทำ Threading ได้จริง ๆ มันไม่ได้แค่ Feed ข้อมูลอย่างต่อเนื่อง แต่ระหว่างการทำงานมันต้องมีการรอ ทำให้มันต้องการที่เก็บข้อมูลชั่วคราวไว้ก่อน ซึ่งการเก็บข้อมูลที่ต้องการความเร็วในการอ่านเขียนสูง ๆ ก็คงไม่สามารถใช้ SSD ที่ว่าเร็วได้เลย แต่เราใช้สิ่งที่โคตรเร็วกว่านั้นเยอะคือ Register

Reference : Wikipedia

มันเป็นหน่วยความจำที่ผู้ผลิต ใส่อยู่ใน CPU ให้ทำหน้าที่เป็น Cache Memory เช่นมันจะมีตั้งแต่ L3, L2 และ L1 Cache ถ้าเราไปดูในสเปกของหน่วยประมวลผลเอง เราจะเห็นว่ายิ่ง Level น้อย ขนาดมันจะเล็กลงเรื่อย ๆ ในการทำงานจริง ๆ Register ในทั้ง 3 ระดับ (อาจจะมากกว่านั้น ในบางรุ่น) มีความเร็วที่แตกต่างกันอีก เพราะเวลาทำงาน เครื่องมันจะไล่เช็คที่ละระดับเลยว่า ใครมีข้อมูลที่เราต้องการบ้าง ไปเรื่อย ๆ เป็นลำดับ ทำให้ L1 ที่อยู่ใกล้จุดที่ประมวลผลที่สุด มีความเร็วเยอะที่สุด แล้วก็ไล่ลงไปเรื่อย ๆ ถ้าอยากอ่านต่อลองไปดูพวกเรื่องของ Memory Hierachy

ซึ่ง Register ที่ใช้เก็บข้อมูลระหว่างขั้นตอนใน Pipeline มันต้องมีความเร็วมาก ๆ ทำให้ การทำหน่วยประมวลผลที่มี Thread เยอะ ๆ นั้น อาจจะไม่ใช่คำตอบเท่าไหร่ เพราะมัน แพงงงงงงงงง แล้วใครจะซื้อละ

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

ถ้าเราไปดู หรือ เคยเห็น หน่วยประมวลผลที่เราใช้กันอยู่ในปัจจุบัน เวลาเขียนพวกสเปก ชอบเขียนเป็น 6/12 หรือ 8/16 หรือมากกว่านั้น พวกนี้แหละ มันบอก จำนวน Core และ จำนวน Thread

ตัวอย่างเช่น 6/12 คือ หน่วยประมวลผลนี้มี 6 Physical Core และ มี 12 Logical Core นั่นเอง และ ถ้าเราสังเกตเข้าไปอีก เอ๊ะ ทำไม จำนวน Logical Core มันมักจะเป็น 2 เท่าของ Physical Core กันละ มันเป็นตัวเลขอื่นได้มั้ย

คำตอบคือ ได้ เราอาจจะทำให้มันเป็น 4 เท่าหรือเท่าไหร่ ก็ขึ้นกับการออกแบบสถาปัตยกรรมของหน่วยประมวลผลนั้น ๆ ที่เคยเห็นเยอะสุดน่าจะเป็น 128 Threads ต่อ Core เลยทีเดียว คือ อลังการงานสร้างมาก ๆ

อีกคำถามที่น่าจะถามกันเหมือนกับเรื่องของ CPU Core คือ แล้วโปรแกรมที่เขียนเดิม ๆ แบบ Single Core จะทำงานแบบ Multi-thread ได้เลยมั้ย คำตอบคือ ไม่ได้ เหมือนกัน ยังไง ๆ ก็ต้องเขียนโปรแกรมให้มันรองรับ การกระจายงานอยู่ดีนาจา

เทคโนโลยีหน่วยประมวลผลตันแล้วจริงเหรอ ?

อันนี้แถม... เอาจริง ๆ เรื่องจริงเลย เราว่า ณ วันที่เขียน เทคโนโลยีของหน่วยประมวลผล เราว่ามันตันมานานแล้ว ตันจน การเพิ่มพลังการประมวลผลแบบ Sequential มันทำได้ยากมาก ๆ ถ้าเราลองเอาผลทดสอบประสิทธิภาพต่อ Core มา Plot เป็น Line Chart เราจะเห็นเลยว่า จริง ๆ แล้ว หน่วยประมวลผลแต่ละรุ่นที่ออกมา การเพิ่มประสิทธิภาพต่อ Core มันช้าลง

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

ตอนที่เราเรียน ก็จะมีการพูดถึงเรื่อง Moore's law ที่บอกไว้ว่าปริมาณ Transistor ในแผงวงจรรวม จะเพิ่มขึ้นเท่าตัว ในทุก 2 ปี ถามว่า เยอะขึ้นแล้วไง หนักหัวใคร คำตอบคือ ถ้าเราสามารถยัดของลงไปในวงจรได้มากขึ้น นั่นคือ วงจรของเราก็ทำงานได้หลายอย่างมากขึ้น และ ทำงานได้เร็วขึ้น เหมือนที่เรายัด CPU Core ลงไปในตัว Chip ได้มากขึ้น ก็ส่งผลมาจาก การที่เรายัด วงจรได้มากขึ้นในขนาดที่เท่าเดิมนั่นแหละ

via GIPHY

เวลากว่า 50 ปีที่ผ่านมา กฏนี้ก็ยังคงเป็นจริงอยู่ จนมาช่วงหลาย ๆ ปีที่ผ่านมา ที่กฏนี้ ก็แทบจะลาโลกไปแล้ว เพราะ เอาเข้าจริง การที่เราย่อส่วนไปเรื่อย ๆ มันก็ต้องมีจุดนึงที่มันเล็กโคตร ๆ จนย่อต่อนี่คือความท้าทายทางวิศกรรมมากขึ้นเรื่อย ๆ เรื่องที่น่าสนใจคือ ฟิสิกส์ ไม่ถูกใจสิ่งนี้

ถ้าเราเรียนฟิสิกส์มาบ้าง เราจะรู้ว่า จักรวาล เรา ไม่ได้ใช้ฟิสิกส์แขนงเดียวในการอธิบายของทั้งจักรวาล มันมีฟิสิกส์ที่เราใช้กันทั่ว ๆ ไป (Classical Physic) และ ฟิสิกส์ที่อธิบายของที่โคตรเล็กมาก ๆๆๆๆ (Quantum Physic) อย่างปัญหาที่เราเดาว่า น่าจะได้เจอแน่ ๆ คือ Quantum Tunneling ลองไปหาอ่านดูได้ มันมีปัญหาอยู่หลายอย่างที่ทำให้เราย่อแผงวงจรรวม ให้มีขนาดเล็กมาก ๆ ได้ยากมากกกกก

ถามเรา เราให้ความเห็นว่า จริง ๆ แล้ว Quantum Computer ก็ถือว่าเป็นอนาคตที่ดี สำหรับการประมวลผลในอนาคตอันใกล้นี้ เราว่า ถ้าเราใช้มันได้แบบจริง ๆ จัง ๆ เรื่องนึงที่จะชิบหายวายป่วง มากคือ การเข้ารหัส (Encryption) ที่ตอนนี้เราอาศัยการออกแบบทางคณิตศาสตร์ที่มี Combination ในการเดาที่เยอะมาก ๆ จนเครื่องคอมพิวเตอร์มันใช้เวลาเป็นพัน ๆ ปีในการเดา แต่ถ้าเจอ Quantum Computer การเดาของที่เครื่องที่เราใช้ตอนนี้เดาเป็นพันปีอาจจะเสร็จใน 1 นาทีก็ได้นะ

สรุป

ในปัจจุบันหน่วยประมวลผลที่เราใช้งานกัน ก็ถูกออกแบบมาให้เป็น Multi-Core และสามารถทำ Threading ได้ซะเป็นส่วนใหญ่ เพื่อเพิ่มประสิทธิภาพการทำงานโดยรวมของมัน CPU Core ที่เป็นเหมือนสายการผลิต และ Thread ที่เป็นเหมือนสถานีในสายการผลิตที่ทำให้การผลิต หรือ ในที่ดีคือ การประมวลผลมีได้เร็วขึ้นกว่า หน่วยประมวลผลในยุคก่อนที่เป็น Single Core และ Single Thread แต่จริง ๆ แล้ว การเพิ่ม Core และ Thread ไม่ได้ทำให้ ทุก โปรแกรมที่เราใช้งาน ทำงานได้เร็วขึ้นเลย เพราะโปรแกรมเหล่านั้นไม่ได้ถูกออกแบบ มาให้ทำงานแบบ Parallel ได้ ก็หง่อยไป

ดังนั้น การเลือก CPU ต้องดูโปรแกรมที่เราใช้ก่อนว่ามันทำงานเป็น Single Core หรือ Multicore กันแน่ แล้วก็เลือกใช้ CPU ที่เหมาะสมกับงานของเรา ถ้ามันทำงานเป็น Single Core ก็พยายามเลือกหน่วยประมวลผลที่ประสิทธิภาพการทำงานต่อ Core สูง กลับกัน ถ้าเป็น Multi Core ก็กดอันที่ Core เยอะ ๆ ก็มันส์ดี

อ่านมาถึงตรงนี้ได้ เก่งมาก เราพยายาม อธิบายให้มันง่ายที่สุด เท่าที่จะทำได้ ถ้าอยากเรียนเรื่องแบบนี้ เราเรียนในวิชา Computer Architecture ลองไปหาหนังสือในวิชาพวกนี้อ่านได้ และ เนื้อหาที่เราเอามาเล่าในวันนี้อาจจะไม่ถูกต้องตามหลักวิชาการ 100% เราเอามาปรับแต่งเล็กน้อย เพื่อให้อธิบายแล้วเข้าใจได้มากขึ้น ไม่สามารถเอาไปใช้อ้างอิงได้นาจา สวัสดี