บทนำสู่การเขียนโปรแกรมด้วย ROCm และ HIP: บทเรียนปฏิบัติจริง

📚 สรุปเนื้อหา

คู่มือปฏิบัติที่ทันสมัยเกี่ยวกับการเขียนโปรแกรม GPU ของ AMD โดยใช้ ROCm และ HIP ครอบคลุมชุดซอฟต์แวร์ทั้งหมด ตั้งแต่การติดตั้ง การจัดทำโครงการ (build workflows) การเขียนโค้ดเคอร์เนล การจัดการหน่วยความจำ การวิศวกรรมประสิทธิภาพ การใช้งานไลบรารี การย้ายจาก CUDA ไปยัง HIP และแนวทางการตรวจสอบข้อผิดพลาดในสภาพแวดล้อมผลิตภัณฑ์

เรียนรู้การเขียนโปรแกรม GPU ของ AMD และการย้ายจาก CUDA ไปยัง HIP อย่างมืออาชีพด้วยบทวิเคราะห์เชิงเทคนิค

ผู้เขียน: EvoClass

คำขอบคุณ: เอกสารทางเทคนิคของ AMD เกี่ยวกับ ROCm และ HIP ซึ่งรวมถึงโครงการต่าง ๆ เช่น ROCm, HIP และ ROCm LLVM

🎯 เป้าหมายการเรียนรู้

1. นิยาม HIP และบทบาทของมันในระบบนิเวศของ ROCm ด้วยประโยคเดียวที่กระชับ
2. แยกแยะความแตกต่างระหว่าง ROCm (แพลตฟอร์ม), HIP (อินเทอร์เฟซ), และไลบรารีของ ROCm (ส่วนประกอบหลัก)
3. ระบุระดับโครงสร้างของสถาปัตยกรรม ROCm จากฮาร์ดแวร์ถึงกรอบงานแอปพลิเคชัน
4. อธิบายความสัมพันธ์ระหว่าง SDK ของ HIP กับแพลตฟอร์ม ROCm ในระบบปฏิบัติการต่าง ๆ
5. ดำเนินการตามขั้นตอนการติดตั้งอย่างเป็นระบบ รวมถึงการตรวจสอบแมทริกซ์รองรับและตั้งค่าเส้นทางหลังติดตั้ง
6. คอมไพล์และรันโปรแกรมตรวจสอบขั้นพื้นฐานเพื่อแก้ไขปัญหาทั่วไปเกี่ยวกับไดรเวอร์และสิทธิ์การเข้าถึงสภาพแวดล้อม
7. เข้าใจว่ากลยุทธ์การจัดทำโครงการที่แข็งแรงมีความสำคัญอย่างไรในการประสานความเข้ากันได้ของรหัสต้นฉบับกับประสิทธิภาพเฉพาะสถาปัตยกรรม
8. ประยุกต์ใช้ hipLaunchKernelGGL เพื่อเรียกใช้เคอร์เนลแบบสามารถย้ายได้แทนการใช้รูปแบบสามเหลี่ยมสามชั้นของ CUDA
9. ตั้งค่าโปรเจกต์ CMake ระดับองค์กรที่กำหนดเป้าหมายไปยังสถาปัตยกรรม ROCm ที่เฉพาะเจาะจง และจัดการความพึ่งพาไลบรารีภายนอก
10. วิเคราะห์โครงสร้างของเคอร์เนล HIP และนำไปใช้สูตรพื้นฐานในการจัดลำดับเธรด

🔹 บทเรียนที่ 1: บทนำเกี่ยวกับสถาปัตยกรรม ROCm และ HIP

ภาพรวม: บทเรียนนี้ให้มุมมองพื้นฐานเกี่ยวกับแพลตฟอร์ม ROCm และภาษาโปรแกรม HIP มุ่งเน้นชี้แจงความสัมพันธ์ระหว่างชุดเต็มของ ROCm ทั้งหมด อินเทอร์เฟซของ HIP และไลบรารีระดับสูง พร้อมทั้งสร้างความคาดหวังที่เหมาะสมเกี่ยวกับการย้ายจาก CUDA ไปยัง AMD และการวิศวกรรมประสิทธิภาพ

ผลการเรียนรู้:

• นิยาม HIP และบทบาทของมันในระบบนิเวศของ ROCm ด้วยประโยคเดียวที่กระชับ
• แยกแยะความแตกต่างระหว่าง ROCm (แพลตฟอร์ม), HIP (อินเทอร์เฟซ), และไลบรารีของ ROCm (ส่วนประกอบหลัก)
• ระบุระดับโครงสร้างของสถาปัตยกรรม ROCm จากฮาร์ดแวร์ถึงกรอบงานแอปพลิเคชัน

🔹 บทเรียนที่ 2: การติดตั้งและการตั้งค่าสภาพแวดล้อม

ภาพรวม: บทเรียนนี้นำแนวทางสำคัญสำหรับนักพัฒนา GPU และวิศวกร HPC ในการตั้งค่าสภาพแวดล้อมที่พร้อมใช้งานกับ HIP ทั้งบนระบบปฏิบัติการ Linux และ Windows โดยเน้นแนวทาง "ความจริงของแพลตฟอร์ม" ที่นักพัฒนาต้องยืนยันความเข้ากันได้ระหว่างฮาร์ดแวร์และซอฟต์แวร์ก่อนดำเนินการติดตั้งตามขั้นตอนที่เป็นระบบ และตรวจสอบผลสุดท้ายโดยใช้ตัวคอมไพล์ hipcc

ผลการเรียนรู้:

• นิยามความสัมพันธ์ระหว่าง SDK ของ HIP กับแพลตฟอร์ม ROCm ในระบบปฏิบัติการต่าง ๆ
• ดำเนินการตามขั้นตอนการติดตั้งอย่างเป็นระบบ รวมถึงการตรวจสอบแมทริกซ์รองรับและตั้งค่าเส้นทางหลังติดตั้ง
• คอมไพล์และรันโปรแกรมตรวจสอบขั้นพื้นฐานเพื่อแก้ไขปัญหาทั่วไปเกี่ยวกับไดรเวอร์และสิทธิ์การเข้าถึงสภาพแวดล้อม

🔹 บทเรียนที่ 3: เครื่องมือการจัดทำโครงการ: hipcc และโครงสร้างโปรเจกต์

ภาพรวม: บทเรียนนี้สำรวจเครื่องมือสำคัญและกลยุทธ์การจัดระเบียบสำหรับการพัฒนาแอปพลิเคชัน HIP บนฮาร์ดแวร์ของ AMD ช่วยให้นักพัฒนาเปลี่ยนจากกระบวนการคอมไพล์แบบบรรทัดคำสั่งง่าย ๆ ด้วย hipcc มาสู่การตั้งค่าโปรเจกต์ระดับมืออาชีพที่พร้อมใช้งานจริง โดยใช้ CMake โฟกัสหลัก ๆ ได้แก่ แมโครการเรียกใช้เคอร์เนลที่สามารถย้ายได้ การปรับแต่งเฉพาะสถาปัตยกรรม และความแตกต่างที่สำคัญระหว่างความเข้ากันได้ระดับแหล่งโค้ดกับประสิทธิภาพของไบนารี

ผลการเรียนรู้:

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

🔹 บทเรียนที่ 4: โมเดลการเขียนโปรแกรมและพัฒนาเคอร์เนลของ HIP

ภาพรวม: บทเรียนนี้สำรวจสถาปัตยกรรมพื้นฐานของเคอร์เนล HIP โดยเน้นวิธีการแปลงงานจากปัญหาเชิงตรรกะไปยังการประมวลผลบนฮาร์ดแวร์ผ่านกริดและบล็อก ให้แผนผังสำหรับการเขียนโปรแกรม GPU ที่มั่นคง ครอบคลุมสูตรการประมวลผลพื้นฐาน จุดหยุดประสิทธิภาพ (ความเร็วหน่วยความจำเทียบกับการคำนวณ) และการบังคับใช้การตรวจสอบข้อผิดพลาดและการซิงโครไนซ์สำหรับโค้ดที่พร้อมใช้งานในสภาพแวดล้อมผลิตภัณฑ์

ผลการเรียนรู้:

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

🔹 บทเรียนที่ 5: การจัดการหน่วยความจำและรูปแบบข้อมูล

ภาพรวม: บทเรียนนี้เน้นจุดศูนย์กลางของการเขียนโปรแกรม GPU: การจัดการหน่วยความจำ ครอบคลุมการจำแนกประเภทหน่วยความจำ (ตัวที่สามารถสลับหน่วยความจำได้, ตัวที่ถูกตรึง, ตัวที่อยู่บนอุปกรณ์ และตัวที่จัดการได้), ผลกระทบด้านประสิทธิภาพจากการถ่ายโอนข้อมูล และบทบาทสำคัญของรูปแบบการเข้าถึงหน่วยความจำ โดยเฉพาะการรวมกัน (coalescing) ในการบรรลุประสิทธิภาพสูงสุด นักเรียนจะได้เรียนรู้วิธีสมดุลความสะดวกในการใช้งานจากหน่วยความจำที่จัดการได้ กับการควบคุมอย่างละเอียดที่จำเป็นสำหรับแอปพลิเคชัน HPC ประสิทธิภาพสูง

ผลการเรียนรู้:

• แยกแยะระหว่างหน่วยความจำโฮสต์ที่สามารถสลับหน่วยความจำได้และหน่วยความจำที่ถูกตรึง และระบุเมื่อใดควรใช้แต่ละแบบเพื่อให้การถ่ายโอนรวดเร็วที่สุด
• ประยุกต์ใช้การจัดสรรหน่วยความจำบนอุปกรณ์และหน่วยความจำแบบรวม/จัดการได้โดยใช้ API ของ HIP (hipMalloc, hipHostMalloc, hipMallocManaged)
• วิเคราะห์รูปแบบการเข้าถึงหน่วยความจำเพื่อให้เกิดการเข้าถึงแบบรวมกัน และหลีกเลี่ยงจุดหยุดประสิทธิภาพเช่น การเข้าถึงแบบแบ่งระยะ

🔹 บทเรียนที่ 6: สตรีม คือเหตุการณ์ และการดำเนินการแบบไม่ซิงโครนัส

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

ผลการเรียนรู้:

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

🔹 บทเรียนที่ 7: วิศวกรรมประสิทธิภาพบน GPU ของ AMD

ภาพรวม: บทเรียนนี้วางกรอบทางวิทยาศาสตร์สำหรับการปรับปรุงซอฟต์แวร์บนฮาร์ดแวร์ของ AMD โดยย้ายออกจากแนวทางเดาๆ มาสู่แนวทางที่มีระบบและขึ้นอยู่กับการวัดผล ครอบคลุมความสัมพันธ์ทางสถาปัตยกรรมระหว่างหน่วยคำนวณ (Compute Units), คลื่น (wavefronts) และแรงกดดันต่อเรจิสเตอร์ พร้อมทั้งเสนอวิธีการปฏิบัติจริงในการโปรไฟล์ด้วย rocprofv3 และการตั้งโครงสร้างการทดสอบที่มั่นคง

ผลการเรียนรู้:

• ประยุกต์ใช้ขั้นตอนการปรับปรุงประสิทธิภาพ HIP 6 ขั้นตอนเพื่อระบุและแก้ไขจุดหยุดประสิทธิภาพ
• วิเคราะห์ข้อจำกัดระหว่างแรงกดดันต่อเรจิสเตอร์กับอัตราการใช้งาน (occupancy) เพื่อเพิ่มประสิทธิภาพการใช้งานฮาร์ดแวร์
• ดำเนินการวัดผลประสิทธิภาพอย่างแม่นยำโดยใช้เหตุการณ์ฮาร์ดแวร์และแนวทางการทดสอบหลายรอบที่ดีที่สุด

🔹 บทเรียนที่ 8: ระบบนิเวศไลบรารีของ ROCm

ภาพรวม: บทเรียนนี้นำเสนอแนวคิดวิศวกรรมแบบ "ใช้ไลบรารีก่อน" โดยเน้นการใช้ไลบรารีของ ROCm ที่มีประสิทธิภาพสูงและเตรียมไว้ล่วงหน้ามากกว่าการพัฒนาเคอร์เนลเอง ครอบคลุมการจำแนกไลบรารีของ ROCm (คณิตศาสตร์, ฟูเรียร์, ฟังก์ชันพื้นฐาน และ ML/AI) และให้กรอบการตัดสินใจในการเลือกระหว่างอินเทอร์เฟซที่สามารถย้ายได้ hip* กับการใช้ roc* ที่เฉพาะเจาะจงกับอุปกรณ์ของ AMD นักเรียนยังจะได้สำรวจข้อกำหนดสำคัญด้าน "ความปลอดภัยของกราฟ" เมื่อรวมไลบรารีเข้ากับกระบวนการทำงานที่จับภาพกราฟของ HIP

ผลการเรียนรู้:

• ประยุกต์ใช้แนวคิดวิศวกรรม "ใช้ไลบรารีก่อน" เพื่อสนับสนุนการใช้ฟังก์ชันที่ผ่านการทดสอบแล้วแทนการใช้เคอร์เนลที่พัฒนาเอง
• แยกแยะระหว่างไลบรารี hip* และ roc* ตามความต้องการด้านความเข้ากันได้และความต้องการด้านประสิทธิภาพ
• จำแนกไลบรารีของ ROCm ตามโดเมนหน้าที่ต่าง ๆ (คณิตศาสตร์, ฟูเรียร์, ฟังก์ชันพื้นฐาน, ML/AI)

🔹 บทเรียนที่ 9: การย้ายแอปพลิเคชันจาก CUDA ไปยัง HIP

ภาพรวม: บทเรียนนี้ครอบคลุมการเปลี่ยนแปลงอย่างเป็นระบบจากโค้ดแหล่งที่มาของ CUDA ไปยังเฟรมเวิร์กของ C++ ที่สามารถย้ายได้ของ HIP นักเรียนจะได้เรียนรู้วิธีดำเนินการย้ายแบบขั้นตอนโดยใช้เครื่องมืออัตโนมัติ เช่น hipify-perl และ hipify-clang ระบุจุดอันตรายด้านความเข้ากันได้ที่สำคัญ เช่น การสมมติว่า warpSize ขึ้นกับฮาร์ดแวร์ และตั้งค่ากระบวนการตรวจสอบอย่างเข้มงวดเพื่อเปรียบเทียบประสิทธิภาพและความถูกต้องหลังการย้าย

ผลการเรียนรู้:

• ดำเนินการย้ายแบบขั้นตอน 6 ขั้นตอนเพื่อลดภาระการแก้ไขข้อผิดพลาด
• เลือกและใช้เครื่องมือแปลงอัตโนมัติที่เหมาะสม (hipify-perl หรือ hipify-clang) ตามความซับซ้อนของโค้ดต้นฉบับ
• ระบุและแก้ไขจุดอันตรายด้านความเข้ากันได้ที่เกี่ยวข้องกับสถาปัตยกรรม โดยเฉพาะเรื่อง warpSize และข้อผิดพลาดจากการแปลงอัตโนมัติ

🔹 บทเรียนที่ 10: การตรวจสอบข้อผิดพลาด การทดสอบ และแนวทางปฏิบัติในสภาพแวดล้อมผลิตภัณฑ์

ภาพรวม: บทเรียนนี้ครอบคลุมเครื่องมือและแนวทางสำคัญสำหรับการนำเคอร์เนล GPU จากสภาพแวดล้อมการพัฒนาไปสู่สภาพแวดล้อมผลิตภัณฑ์บนแพลตฟอร์ม ROCm รายละเอียดการใช้ ROCgdb และ AddressSanitizer สำหรับตรวจจับข้อผิดพลาด ตั้งกลยุทธ์การทดสอบ 4 ชั้นอย่างเข้มงวด และให้รายการตรวจสอบสำหรับการผลิตเพื่อให้มั่นใจในความถูกต้องของเคอร์เนลและเสถียรภาพด้านประสิทธิภาพ

ผลการเรียนรู้:

• ใช้ ROCgdb, ltrace, และ AddressSanitizer เพื่อระบุข้อผิดพลาดระดับแหล่งที่มาและข้อผิดพลาดการเข้าถึงหน่วยความจำในโค้ด GPU
• ประยุกต์ใช้ กลยุทธ์การทดสอบ 4 ชั้น เพื่อยืนยันความสามารถของฟังก์ชันช่วย, ความถูกต้องของเคอร์เนล, กรณีขอบ และการลดประสิทธิภาพ
• ประยุกต์ใช้ รูปแบบโค้ดในสภาพแวดล้อมผลิตภัณฑ์ และรายการตรวจสอบเพื่อจัดการอินเทอร์เฟซของเคอร์เนล คู่มือ และการตรวจสอบที่ขึ้นอยู่กับสภาพแวดล้อม