0Pricing
CUDA Academy · บทเรียน

แรงกดดันของรีจิสเตอร์และการสปิล

สร้างสมดุลระหว่างการนำกลับมาใช้ใหม่กับการครอบครอง

แรงกดดันของรีจิสเตอร์และการสปิล เป็นบทเรียน CUDA Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน CUDA Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส CUDA Academy มีบทเรียนทั้งหมด 4 บทเรียน

รีจิสเตอร์มีค่ามาก

รีจิสเตอร์เป็นพื้นที่จัดเก็บที่เร็วที่สุดของเธรด แต่แต่ละ SM มีจำนวนจำกัด ปริมาณรีจิสเตอร์ที่เคอร์เนลใช้เรียกว่า แรงกดดันต่อรีจิสเตอร์

พูลกลางที่มีขนาดตายตัว

เธรดที่ทำงานอยู่ทุกเธรดใช้ ไฟล์รีจิสเตอร์ ร่วมกันหนึ่งชุดต่อ SM ยิ่งแต่ละเธรดต้องใช้รีจิสเตอร์มากเท่าใด ก็ยิ่งมีเธรดอยู่พร้อมกันได้น้อยลงเท่านั้น

แรงกดดันลดความหนาแน่นการทำงาน

การใช้รีจิสเตอร์สูงจะจำกัดจำนวนวาร์ปที่อยู่บน SM ได้โดยตรง การลดลงของ ความหนาแน่นการทำงาน นี้อาจทำให้ฮาร์ดแวร์มีงานน้อยเกินกว่าจะซ่อนเวลาหน่วงได้

การล้นรีจิสเตอร์คืออะไร

เมื่อเธรดต้องการรีจิสเตอร์มากกว่าที่มี คอมไพเลอร์จะย้ายค่าเพิ่มเติมออกไป การล้นนี้เรียกว่า การล้นรีจิสเตอร์ ไปยังหน่วยความจำที่ช้ากว่า

การล้นจะไปอยู่ในหน่วยความจำเฉพาะที่

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

ดูจำนวนรีจิสเตอร์ของคุณ

ขอให้คอมไพเลอร์รายงานการใช้งาน การเพิ่ม --ptxas-options=-v ให้กับ nvcc จะแสดงจำนวนรีจิสเตอร์ต่อเธรดและจำนวนไบต์ที่ล้นสำหรับเคอร์เนลแต่ละตัว

nvcc --ptxas-options=-v kernel.cu

อ่านตัวเลขการล้น

รายงานจะแสดงการเขียนและการอ่านค่าที่ล้น จำนวน การล้น ที่ไม่ใช่ศูนย์เป็นสัญญาณเตือนว่าเคอร์เนลกำลังเสียเวลาไปกับการรับส่งข้อมูลในหน่วยความจำเฉพาะที่ที่ช้า

จำกัดรีจิสเตอร์ต่อเธรด

คุณกำหนดเพดานได้ขณะคอมไพล์ แฟล็ก --maxrregcount จะจำกัดจำนวนรีจิสเตอร์ต่อเธรด แลกกับความเร็วที่ลดลงเล็กน้อยเพื่อเพิ่มความหนาแน่นการทำงาน

nvcc --maxrregcount=32 kernel.cu

บอกใบ้ด้วย __launch_bounds__

การบอกใบ้แยกตามเคอร์เนลมักดีกว่า __launch_bounds__ แจ้งขนาดบล็อกให้คอมไพเลอร์ทราบ เพื่อให้จัดสรรรีจิสเตอร์ตามความหนาแน่นการทำงานที่คุณต้องการ

__global__ void __launch_bounds__(256)
myKernel() { /* ... */ }

ลดชุดค่าที่ยังใช้งานอยู่

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

สร้างสมดุลระหว่างการใช้ซ้ำกับความหนาแน่นการทำงาน

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

ตรวจสอบอย่างรวดเร็ว

เมื่อเคอร์เนลใช้รีจิสเตอร์จนหมด ค่าเหล่านั้นจะถูกส่งไปที่ใด

สรุป: ควบคุมแรงกดดันให้ดี

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

คำถามที่พบบ่อย

บทเรียน “แรงกดดันของรีจิสเตอร์และการสปิล” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “แรงกดดันของรีจิสเตอร์และการสปิล” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การขนานระดับคำสั่ง
  2. คลี่ลูปด้วย #pragma unroll
  3. โหลดแบบเวกเตอร์ด้วย float4
  4. แรงกดดันของรีจิสเตอร์และการสปิล
← กลับไปที่ CUDA Academy