การปฏิวัติการเขียนโปรแกรมแบบขนาน: ทำไม Multi-Core ควรเป็นค่าเริ่มต้น

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

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

คำมั่นสัญญาและความเสี่ยงของการประมวลผลแบบขนานอัตโนมัติ

วิสัยทัศน์ของโค้ดที่ถูกประมวลผลแบบขนานอัตโนมัติได้ทำให้เหล่านักพัฒนาตื่นตะลึงมาหลายปี แนวคิดนี้ดูเหมือนจะวิเศษมาก - เขียนโค้ดปกติแล้วปล่อยให้ระบบดึงการทำงานแบบขนานออกมาโดยอัตโนมัติ วิธีการนี้สัญญาว่าจะปลดปล่อยโปรแกรมเมอร์จากความซับซ้อนของการจัดการเธรด มิวเท็กซ์ และความปวดหัวเรื่องการซิงโครไนซ์ ดังที่ผู้แสดงความคิดเห็นหนึ่งระบุเกี่ยวกับภาษา Array:

งานรวมรายการในโพสต์เป็นเพียงการลดรายการ (list reduction) และการลดรายการสามารถถูกประมวลผลแบบขนานอัตโนมัติสำหรับตัวดำเนินการเชื่อมโยงใดๆ ก็ได้ รายละเอียดการประมวลผลแบบขนานที่ยุ่งยากในโพสต์เป็นสิ่งที่ผู้ใช้จำเป็นต้องสนใจเฉพาะในภาษาเชิงคำสั่งล้วนๆ ที่ขาดการดำเนินการ Array โดยธรรมชาติ

อย่างไรก็ตาม ประวัติศาสตร์ของความขนานโดยนัยเผยให้เห็นถึงความท้าทายที่สำคัญ การวิจัยทางวิชาการเมื่อ 10-20 ปีที่แล้วสำรวจว่าวิธีการปรับแต่งสามารถดึงความขนานออกจากโค้ดปกติโดยอัตโนมัติได้หรือไม่ โดยสันนิษฐานว่าสิ่งนี้จะให้ผลลัพธ์ด้านประสิทธิภาพที่มากขึ้นอย่างมหาศาล ผลลัพธ์ที่ได้ทำให้ต้องไตร่ตรอง - แม้จะสมมติว่าการประมวลผลแบบขนานเป็นอิสระ แต่การปรับปรุงประสิทธิภาพสูงสุดมักจะอยู่ที่ประมาณ 2 เท่า สัญชาตญาณของเราที่คิดว่าโค้ดมีความขนานมากมายกลับกลายเป็นเรื่องผิดบ่อยครั้ง

ปัญหาพื้นฐานอยู่ที่การพึ่งพาข้อมูล อัลกอริทึมในโลกจริงส่วนใหญ่มีความสัมพันธ์ที่ซับซ้อนระหว่างขั้นตอนการคำนวณที่ต้านทานการประมวลผลแบบขนานอัตโนมัติ ในขณะที่การดำเนินการอย่างง่ายเช่น การคูณเมทริกซ์ทำงานได้ดี แต่แอปพลิเคชันเชิงปฏิบัติหลายอย่างเกี่ยวข้องกับรูปแบบที่คอมไพเลอร์ต่อสู้เพื่อประมวลผลแบบขนานอย่างปลอดภัย

แนวทางการเขียนโปรแกรมแบบขนานที่สำคัญที่กล่าวถึง:

• Automatic Parallelization: การแยกดึงความขนานจากโค้ดแบบลำดับโดยใช้คอมไพเลอร์ (ในอดีตแสดงผลลัพธ์ที่จำกัดเพียงประมาณ 2 เท่า)
• Entity Component System (ECS): รูปแบบการพัฒนาเกมที่ช่วยให้สามารถประมวลผลเอนทิตีแบบแยกส่วนแบบขนานได้
• Message-Passing/Channels: การสื่อสารระหว่างเธรดเฉพาะผ่านอินเทอร์เฟซที่กำหนดไว้อย่างชัดเจน
• Array Languages: การดำเนินการแบบขนานในตัวสำหรับตัวดำเนินการเชิงสมาคม (การลดทอน ฯลฯ)
• Structured Concurrency: แอบสแทรกชันระดับสูงสำหรับการจัดการงานแบบขนาน (Kotlin coroutines, Java Project Loom)

แนวทางปฏิบัติสำหรับการเขียนโปรแกรม Multi-Core

แม้จะมีอุปสรรค แนวทางปฏิบัติหลายอย่างก็ปรากฏขึ้นสำหรับการเขียนโปรแกรม Multi-Core ที่มีประสิทธิภาพ การพัฒนาเกมได้บุกเบิกรูปแบบ Entity Component System (ECS) ซึ่งจัดโครงสร้างโค้ดเพื่อให้สามารถประมวลผลเอนทิตีแบบไม่ต่อเนื่องแบบขนานได้ สิ่งนี้แสดงถึงการเปลี่ยนกระบวนทัศน์จากแนวทางเชิงวัตถุแบบดั้งเดิม โดยออกแบบระบบสำหรับการทำงานแบบขนานอย่างชัดเจนแทนที่จะหวังว่าคอมไพเลอร์จะสามารถดึงมันออกมาได้ในภายหลัง

สถาปัตยกรรมแบบส่งข้อความ (Message-passing) นำเสนออีกแนวทางที่น่าสนใจ ดังที่นักพัฒนาคนหนึ่งแบ่งปัน: ฉันคิดอย่างจริงจังว่าการเขียนสิ่งต่างๆ ในรูปแบบการทำงานพร้อมกันแบบส่งข้อความ/基于通道 (channel-based) มักจะง่ายกว่าการทำสิ่งต่างๆ ใน Single-Core แบบจำลองนี้ให้การแยกความกังวลที่ชัดเจน โดยมีเธรดเฉพาะทางจัดการงานเฉพาะและสื่อสารผ่านช่องทางที่กำหนดไว้อย่างดี

ภูมิทัศน์ทางเทคโนโลยีสะท้อนถึงวิวัฒนาการนี้ Java ได้เดินทางเต็มวงจาก green threads ไปสู่ virtual threads กับ Project Loom coroutines ของ Kotlin และ structured concurrency ให้การ abstraction ระดับสูง แม้แต่ Python ก็กำลังแก้ไขข้อจำกัดของ Global Interpreter Lock ในที่สุด การพัฒนาต่างๆ เหล่านี้ชี้ให้เห็นว่าอุตสาหกรรมกำลังค่อยๆ เคลื่อนไปสู่รูปแบบการเขียนโปรแกรมแบบขนานที่เข้าถึงได้ง่ายขึ้น

วิวัฒนาการของภาษาโปรแกรมมิงในการรองรับการประมวลผลแบบขนาน:

ช่องว่างระหว่างฮาร์ดแวร์และซอฟต์แวร์

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

ประสิทธิภาพการใช้พลังงานนำเสนอการพิจารณาอีกประการหนึ่ง จะดีกว่าหรือไม่ที่จะคำนวณให้เสร็จโดยเร็วที่สุดโดยใช้ความขนานสูงสุด หรือยอมรับเวลาการคำนวณที่ยาวนานขึ้นด้วยค่าใช้จ่ายและการรวมที่น้อยกว่า? คำตอบขึ้นอยู่กับบริบทของแอปพลิเคชัน - ระบบเรียลไทม์ให้ความสำคัญกับความเร็ว ในขณะที่แอปพลิเคชันมือถือและแบบฝังตัวอาจให้ความสำคัญกับการใช้พลังงานทั้งหมด

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

อนาคตของการเขียนโปรแกรมแบบขนาน

เมื่อมองไปข้างหน้า แนวโน้มหลายอย่างชี้ให้เห็นว่าการเขียนโปรแกรม Multi-Core จะมีความสำคัญมากขึ้นเรื่อยๆ ภาษาใหม่เช่น Mojo ถูกออกแบบมาโดยชัดเจนสำหรับการประมวลผลแบบขนานอัตโนมัติ การวิจัยยังคงดำเนินต่อไปในการวิเคราะห์การพึ่งพาและอัลกอริทึมการจัดตารางที่ดีขึ้น วิวัฒนาการของฮาร์ดแวร์อาจให้การสนับสนุนที่ดีขึ้นสำหรับความขนานระดับละเอียดในที่สุด

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

การเปลี่ยนไปสู่ Multi-Core เป็นค่าเริ่มต้นแสดงให้เห็นมากกว่าแค่การปรับแต่งทางเทคนิค - มันเป็นการคิดใหม่พื้นฐานเกี่ยวกับวิธีที่เราเข้าถึงการออกแบบซอฟต์แวร์ ดังที่ผู้แสดงความคิดเห็นหนึ่งจับความรู้สึกของชุมชนได้อย่างสมบูรณ์แบบ: การแลกเปลี่ยนที่แตกต่างกันสำหรับโดเมนที่แตกต่างกัน แต่ทั้งสองกำลังตอบสนองต่อความเป็นจริงที่ย้อนแย้งเดียวกันที่เราเขียนโปรแกรมแบบ Single-Core ก่อนบนฮาร์ดแวร์ Multi-Core การยอมรับว่ารูปแบบการเขียนโปรแกรมของเราไม่ทันกับวิวัฒนาการของฮาร์ดแวร์นี้ขับเคลื่อนการค้นหาอย่างต่อเนื่องสำหรับแนวทางที่ดีกว่าในการทำงานแบบขนาน

การเดินทางสู่การเขียนโปรแกรม Multi-Core ที่มีประสิทธิภาพยังคงดำเนินต่อไป โดยชุมชนกำลังสำรวจทุกอย่างตั้งแต่การเขียนโปรแกรมระบบระดับต่ำไปจนถึง abstraction ระดับสูง สิ่งที่ชัดเจนคือยุคแห่งการคิดแบบ Single-Core กำลังจะจบลง และนักพัฒนาที่ยอมรับ Multi-Core เป็นค่าเริ่มต้นจะอยู่ในตำแหน่งที่ดีที่สุดสำหรับภูมิทัศน์การคำนวณของวันพรุ่งนี้

อ้างอิง: Multi-Core By Default