เปิดใช้เคอร์เนลจากเคอร์เนล
การเรียกซ้ำและการปรับปรุงจากฝั่งอุปกรณ์
เปิดใช้เคอร์เนลจากเคอร์เนล เป็นบทเรียน CUDA Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน CUDA Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส CUDA Academy มีบทเรียนทั้งหมด 4 บทเรียน
เคอร์เนลเรียกใช้เคอร์เนล
ด้วย การทำงานแบบขนานแบบไดนามิก เคอร์เนล GPU ที่กำลังทำงานอยู่สามารถเรียกใช้เคอร์เนลอื่นได้ด้วยตนเอง โดยไม่ต้องย้อนกลับไปยัง CPU 🚀
ไวยากรณ์เดิม แต่ทำงานบนอุปกรณ์
การเรียกใช้มีรูปแบบเหมือนการเรียกใช้จากโฮสต์ทุกประการ: วงเล็บสามเหลี่ยมสามชั้นที่คุ้นเคยสามารถใช้ได้โดยตรงภายในโค้ดของอุปกรณ์
__global__ void child(int* d);
__global__ void parent(int* d) {
child<<<1, 32>>>(d);
}คำนวณสิ่งที่จะต้องคำนวณในอนาคต
เธรด parent จะตัดสินใจขณะทำงานว่าต้องใช้ปริมาณงานเท่าใด จากนั้นจึงสร้าง เคอร์เนล child ที่มีขนาดพอดีกับงานนั้น
child<<<blocks, threads>>>(buf);ออกแบบมาสำหรับรูปร่างที่ไม่สม่ำเสมอ
ความสามารถนี้โดดเด่นเมื่อปริมาณงานขึ้นอยู่กับข้อมูล: เธรดที่พบว่ายังมีงานต้องทำสามารถ เรียกใช้เธรดเพิ่ม ได้ทันที
การเรียกตัวเองซ้ำบนอุปกรณ์
เคอร์เนลอาจเรียกใช้ตัวเองได้ด้วย ทำให้เกิด การเรียกซ้ำอย่างแท้จริงบน GPU สำหรับปัญหาแบบแบ่งแล้วพิชิต
__global__ void solve(int lo, int hi) {
if (hi - lo > 1) solve<<<1, 2>>>(lo, mid);
}สตรีมของ parent และ child
การเรียกใช้ child แต่ละครั้งจะเข้าร่วมสตรีม โดยค่าเริ่มต้น child จะใช้สตรีมของบล็อกเธรด parent แต่คุณสามารถระบุ สตรีมของตนเองได้
child<<<g, b, 0, myStream>>>(d);ซิงโครไนซ์ภายในเคอร์เนล
parent สามารถรอ child ได้โดยเรียกใช้ cudaDeviceSynchronize จากโค้ดของอุปกรณ์ แล้วจึงอ่านผลลัพธ์ของ child
child<<<1, 64>>>(d);
cudaDeviceSynchronize();การเสร็จสิ้นของ child โดยอัตโนมัติ
แม้ไม่มีการรอด้วยตนเอง child ที่ถูกเรียกใช้ทั้งหมดจะเสร็จสิ้นแน่นอนก่อนที่ เคอร์เนล parent จะส่งคืนการทำงาน
หน่วยความจำที่ทั้งสองฝ่ายมองเห็น
parent และ child ใช้ หน่วยความจำส่วนกลางร่วมกัน ดังนั้นตัวชี้ที่ส่งต่อไปจึงยังใช้ได้ แต่ข้อมูลเฉพาะที่และข้อมูลที่ใช้ร่วมกันจะไม่ข้ามการเรียกใช้
คอมไพล์เพื่อเรียกใช้บนอุปกรณ์
คุณต้องคอมไพล์ด้วย โค้ดอุปกรณ์ที่ย้ายตำแหน่งได้ และลิงก์รันไทม์ของอุปกรณ์ เพื่อให้การเรียกใช้แบบซ้อนทำงานได้จริง
nvcc -rdc=true -lcudadevrt prog.cuขีดจำกัดการเรียกใช้ที่เข้มงวด
การเรียกใช้ซ้อนกันมีขีดจำกัด: มี ระดับความลึกของการเรียกใช้สูงสุด และหากซ้อนลึกเกินไป ระบบจะส่งคืนข้อผิดพลาดแทนการสร้างเคอร์เนลเพิ่ม
ตรวจสอบความเข้าใจอย่างรวดเร็ว
เคอร์เนลที่ถูกเรียกใช้แบบไดนามิกเริ่มต้นจากที่ใด
สรุปทบทวน: การเรียกใช้บนอุปกรณ์
เคอร์เนลสามารถเรียกใช้เคอร์เนลอื่นด้วยไวยากรณ์ วงเล็บสามเหลี่ยมแบบเดียวกัน หรือแม้แต่เรียกใช้ตัวเองได้ ใช้หน่วยความจำส่วนกลางร่วมกันและคอมไพล์ด้วย -rdc=true ทำได้ดีมาก! 🎉
คำถามที่พบบ่อย
บทเรียน “เปิดใช้เคอร์เนลจากเคอร์เนล” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “เปิดใช้เคอร์เนลจากเคอร์เนล” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส CUDA Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส CUDA Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “เปิดใช้เคอร์เนลจากเคอร์เนล”
การเรียกซ้ำและการปรับปรุงจากฝั่งอุปกรณ์ คุณปฏิบัติ CUDA Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน CUDA Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน CUDA Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “เปิดใช้เคอร์เนลจากเคอร์เนล” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน CUDA Academy นี้ได้ไหม
ได้ บทเรียน CUDA Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- เปิดใช้เคอร์เนลจากเคอร์เนล
- เมื่อการประมวลผลแบบพลวัตคุ้มค่า
- บันทึกงานลงในกราฟ
- เล่นกราฟซ้ำเพื่อลดค่าใช้จ่ายแฝง