ลูปแบบก้าวตามกริด
จัดการอาร์เรย์ที่มีขนาดใหญ่กว่ากริด
ลูปแบบก้าวตามกริด เป็นบทเรียน CUDA Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน CUDA Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส CUDA Academy มีบทเรียนทั้งหมด 4 บทเรียน
เมื่ออาร์เรย์มีขนาดใหญ่มาก
บางครั้งข้อมูลมีขนาดใหญ่กว่าเธรดที่คุณเปิดใช้งานมาก การใช้หนึ่งเธรดต่อหนึ่งสมาชิกไม่เพียงพออีกต่อไป ดังนั้นแต่ละเธรดจึงต้องจัดการสมาชิก หลายตัว
กริดมีขนาด
จำนวนเธรดทั้งหมดคือขนาดกริด ซึ่งเท่ากับจำนวนบล็อกคูณด้วยจำนวนเธรดต่อบล็อก ค่า ระยะก้าวนี้คือระยะห่างระหว่างสมาชิกที่แต่ละเธรดจัดการ
int stride = blockDim.x * gridDim.x;เริ่มต้น แล้วก้าวไป
แต่ละเธรดเริ่มต้นที่ดัชนีโกลบอลตามปกติ จากนั้นกระโดดไปข้างหน้าครั้งละขนาดกริดซ้ำ ๆ จนกว่าจะพ้น อาร์เรย์
ลูปแบบกริด-ระยะก้าว
ลูปนี้คือรูปแบบทั้งหมด: เริ่มที่ i เพิ่มทีละระยะก้าว และหยุดที่ n อาร์เรย์ทุกขนาดจะได้รับการประมวลผล ไม่ว่าคุณจะ เปิดใช้งานเธรดกี่ตัว
for (int i = blockIdx.x * blockDim.x + threadIdx.x;
i < n;
i += stride) {
out[i] = a[i] + b[i];
}ตัวป้องกันในตัว
สังเกตว่าเงื่อนไขลูป i < n เป็นการตรวจสอบขอบเขตในตัว เธรดที่เริ่มต้นเลยจุดสิ้นสุดจะไม่ เข้าสู่ลูปเลย
การแบ่งงาน
เมื่อระยะก้าวเท่ากับ 4 เธรด เธรด 0 จะจัดการสมาชิก 0, 4, 8 ส่วนเธรด 1 จะจัดการ 1, 5, 9 งานจะถูก สลับแทรกกัน ไม่ได้แบ่งเป็นช่วง ๆ
การสลับแทรกช่วยให้รวมการเข้าถึงได้
เนื่องจากเธรดข้างเคียงยังคงเข้าถึงแอดเดรสข้างเคียงกันในแต่ละขั้น การเข้าถึงจึงยังคง รวมเป็นชุด และแบนด์วิดท์หน่วยความจำยังคงสูง
แยกเธรดออกจากข้อมูล
ตอนนี้ขนาดการเปิดใช้งานไม่ขึ้นอยู่กับ n อีกต่อไป คุณเลือกจำนวนเธรดที่เหมาะกับ GPU ได้ แล้วให้ลูปรองรับ ปริมาณงานใด ๆ
ปรับให้เหมาะกับฮาร์ดแวร์
ตัวเลือกทั่วไปคือใช้จำนวนบล็อกมากพอที่จะเติมทุกหน่วยประมวลผลหลายตัว จากนั้นให้แต่ละเธรดทำงานวนซ้ำ วิธีนี้ทำให้ GPU ทำงานอยู่เสมอโดยไม่เปิดใช้งานมากเกินไป
ใช้ได้แม้ข้อมูลมีขนาดเล็ก
หาก n มีขนาดเล็กกว่ากริด แต่ละเธรดจะทำส่วนลูปไม่เกินหนึ่งครั้ง รูปแบบนี้ ลดรูปลงอย่างราบรื่นเป็นกรณีพื้นฐาน
ค่าเริ่มต้นที่เชื่อถือได้
ผู้เชี่ยวชาญ CUDA หลายคนเขียนเคอร์เนลแบบสมาชิกต่อสมาชิกทุกตัวเป็นลูปแบบกริด-ระยะก้าว รูปแบบนี้ยืดหยุ่น ปลอดภัย และแทบไม่ใช่ ตัวเลือกที่ผิด 🚀
ตรวจสอบอย่างรวดเร็ว
ระบุระยะก้าว
สรุปทบทวน
คุณได้เรียนรู้ลูปแบบกริด-ระยะก้าว: เริ่มที่ดัชนีโกลบอล แล้วเพิ่มทีละ blockDim.x * gridDim.x จน i ถึง n ตอนนี้เคอร์เนลเดียวรองรับอาร์เรย์ทุกขนาด 🎉
คำถามที่พบบ่อย
บทเรียน “ลูปแบบก้าวตามกริด” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ลูปแบบก้าวตามกริด” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส CUDA Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส CUDA Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ลูปแบบก้าวตามกริด”
จัดการอาร์เรย์ที่มีขนาดใหญ่กว่ากริด คุณปฏิบัติ CUDA Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน CUDA Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน CUDA Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “ลูปแบบก้าวตามกริด” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน CUDA Academy นี้ได้ไหม
ได้ บทเรียน CUDA Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- สูตรดัชนีแบบคลาสสิก
- ป้องกันดัชนีเกินช่วง
- ปัดจำนวนบล็อกขึ้น
- ลูปแบบก้าวตามกริด