วันจันทร์ได้มีโอกาสไปสัมนาเรื่องการเขียนโปรแกรมแบบ Parallel จัดโดย Intel อาจารย์ที่เป็นผู้บรรยายชื่อ ดร.วรวรรณ ดีอัซ การ์บาโย มาจากธรรมศาสตร์ สำหรับผมที่เคยเขียน Parallel เพียงเล็กน้อยก็นับว่าได้ประโยชน์และไอเดียจากอาจารย์มหาศาล ก็เลยคิดว่าน่าจะนำสิ่งที่อาจารย์เล่ามาเล่าต่อ ฉลองวันวาเลนไทน์ เอ๊ย วัน 090909 ครับ ...

สรุป Parallel Programming and VTune Performance Analyzer

โดย ดร.วรวรรณ ดีอัซ การ์บาโย (ภาควิชาวิทยาการคอมพิวเตอร์, มหาวิทยาลัยธรรมศาสตร์)

1. นับแต่ปี ค.ศ. 2010 เครื่องใหม่ทั้งหมดจะใช้ซีพียูแบบมัลติคอร์ แนวโน้มการเพิ่มสมรรถนะคอมพิวเตอร์จากกฎของมัวร์ จะมองอีกมุมหนึ่งได้ว่าเทคโนโลยีการผลิตจะทำให้จำนวนคอร์เพิ่มขึ้น 2 เท่าทุกสองปี ปัจจุบันเรามีเครื่องสมรรถนะสูงอยู่ในมือ ในห้าปีนี้ 2009-2014 เรายังอยู่ในยุค Multicore (2-100 คอร์) แต่ภายในสิบปีจะเข้าสู่ยุค Manycore (ซีพียูมีคอร์มากกว่า 100 คอร์) ซึ่งหมายถึงเราจะมีเครื่องสมรรถนะสูงขึ้นไปอีกอยู่ในมือ
2. โอเอส ดึงสมรรถนะสูงสุดจากฮาร์ดแวร์นี้ได้จำกัด โปรแกรมเมอร์หวังพึ่งโอเอสใหม่ เพิ่มแรม เพิ่มซีพียูคล็อก เพื่อให้ซอฟต์แวร์เร็วขึ้นไปเองเรื่อยๆ ไม่ได้อีกต่อไป เพราะว่า
   
   • คอมไพเลอร์ โอเอส และซีพียู ดึงคำสั่งที่ทำงานพร้อมกันได้ขึ้นมาทำพร้อมกันได้เต็มที่แล้ว (ILP ถึงจุดอิ่มตัว)
   • นับแต่อดีตโปรแกรมเมอร์ ไม่เคยตั้งเป้าที่ performance และแทบจะไม่เคยเปลี่ยนวิธีเขียนโปรแกรม (การเปลี่ยนครั้งใหญ่ เกิดขึ้นเพียงครั้งเดียวตอนปรับเข้าสู่ Object-oriented และ Visual Programming)
   • หากไม่ปรับปรุง ซอฟต์แวร์จะไม่มีทางดึงสมรรถนะจากเครื่องมัลติคอร์ได้ (ถ้าไม่สนใจ ลองอ่านต่อไป)
   • ซอฟต์แวร์ที่ไม่ได้ปรับปรุง จะไม่มีทางเร็วขึ้น เมื่อเครื่องเพิ่มคอร์ หรือเพิ่มแรม สุดท้ายจะตกตลาดไป!!
   • โปรแกรมเมอร์ส่วนใหญ่ ไม่รู้วิธีการเขียน Parallel Programs เราควรจะเป็นส่วนใหญ่หรือ?
3. สิ่งที่ต้องทำ 6 ขั้นตอน เพื่อเขียนโปรแกรมเชิงขนานและดึงสมรรถนะสูงสุดจากเครื่องมัลติคอร์
   1. ขั้นที่ 1 หาจุด Hot Spot ในโปรแกรม หาว่าฟังก์ชั่น โมดูล ใดในโปรแกรมใช้เวลาสูงที่สุด
   2. ขั้นที่ 2 หา Parallelism ในโค้ดส่วนที่เป็น Hot Spot
      1. จุดที่มี Parallelism จะไม่มี Data, Control หรือ Structural Hazards
      2. เมื่อพบแล้ว ให้ระบุว่าโค้ดส่วนไหนจะทำเป็น Parallel Tasks
      3. ก่อนเริ่มลงแรงทำอะไร ให้วิเคราะห์เสียก่อนว่าทำแล้วจะเร็วขึ้นเท่าไร (Expected Speedup) ไม่คุ้มจะได้ไม่ทำ
   3. ขั้นที่ 3 เลือกวิธีทำ Parallel Tasks ที่เหมาะสมกับแพลตฟอร์มมากที่สุด กรณี UMA Shared Memory เช่น Intel Platform ต้องดูโครงสร้างภายในซีพียู อาจจะเลือกแบ่งParallel Tasks เป็น หลายเทรดหรือหลายโพรเซส สำหรับเครื่อง 2-4 คอร์ แนะนำให้ใช้แบบหลายเทรด
   4. ขั้นที่ 4 เลือกภาษาและเครื่องมือ ในการสร้าง Parallel Tasks เป็น เทรดหรือโพรเซส
   5. ขั้นที่ 5 ดีบักเพื่อให้โปรแกรมทำงานถูกต้อง เช่นเดียวกับโปรแกรมเวอร์ชั่นก่อนปรับปรุง เรียกว่ามีคุณสมบัติ Thread Safe
      • ปัญหา เทรดแย่งกันเขียนข้อมูล (Race Condition) แก้ด้วย Synchronization, Mutual Exclusion, Semaphore
      • ปัญหา Deadlock, Livelock แก้ด้วย การตรวจจับ และจัดวิธีการใช้ทรัพยากรร่วมกัน
   6. ขั้นที่ 6 ปรับสมรรถนะให้สูงที่สุด (Performance Tuning) โดยระบุให้ได้ว่าเพราะอะไรโค้ดปัจจุบันจึงช้า
      • หากเป็นเพราะ Software Overhead แก้ปัญหาด้วยการ reuse threads เช่นใช้ ThreadPool ใน .NET หรือแบ่งงานหยาบลง
      • หากเป็นเพราะ Synchronization แก้ปัญหาด้วยการใช้ Lightweight locks, การแยกล็อกสาหรับตัวแปรแต่ละตัว, การใช้ Local Variables
      • หากเป็นเพราะ Load Imbalance แก้ปัญหาด้วยการแบ่งงานด้วยวิธีใหม่
      • หากเป็นเพราะ False Sharing (จะพบในเครื่อง 4 คอร์) แก้ปัญหาด้วยการปรับความหยาบหรือละเอียดของงาน

ครับ ต้องขอขอบคุณอาจารย์มากครับ ส่วนตัวผมได้กลับมาหาความรู้เพิ่มเติมนิดหน่อยแล้ว ถ้ามีอะไรเกี่ยวกะเรื่องนี้อีกจะนำมาแชร์ครับ

ปล.พยายามหา link ของอาจารย์แต่ไม่รู้จะ link ไปไหนดี ใครสนใจผลงานอาจารย์ก็ google ไปก่อนนะครับ ขออภัย