CUDA Academy · บทเรียน

ออกแบบไปป์ไลน์การประมวลผล

ขั้นตอน บัฟเฟอร์ และการไหลของข้อมูล

บทเรียน 1 จาก 413 ขั้นตอน

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

คิดเป็นขั้นตอน

กระบวนการประมวลผลภาพจริงคือห่วงโซ่ของขั้นตอน: โหลด เบลอ เพิ่มความคม ปรับสี และบันทึก แต่ละขั้นตอนคือการแปลงที่ชัดเจนหนึ่งรายการ ซึ่งคุณสามารถทำความเข้าใจแยกกันได้ 🧩

ข้อมูลไหลไปทางเดียว

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

บัฟเฟอร์เก็บข้อมูลระหว่างทาง

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

float* d_stage1;
cudaMalloc(&d_stage1, width * height * sizeof(float));

สลับใช้บัฟเฟอร์สองรายการ

โดยทั่วไปคุณไม่จำเป็นต้องสร้างบัฟเฟอร์ใหม่สำหรับทุกขั้นตอน ให้สลับบัฟเฟอร์สองรายการ: อ่านจากรายการหนึ่ง เขียนไปยังอีกรายการ แล้วสลับกัน บัฟเฟอร์สองรายการรองรับกระบวนการทั้งห่วงโซ่ได้

std::swap(d_in, d_out);

ใช้เคอร์เนลหนึ่งรายการต่อขั้นตอนไปก่อน

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

จับคู่พิกเซลกับเธรด

การจับคู่ตามธรรมชาติคือหนึ่งเธรดต่อหนึ่งพิกเซล กริดสองมิติครอบคลุมความกว้างและความสูง ดังนั้นแต่ละเธรดจึงรับผิดชอบตำแหน่ง (x, y) หนึ่งตำแหน่งโดยเฉพาะ

int x = blockIdx.x * blockDim.x + threadIdx.x;
int y = blockIdx.y * blockDim.y + threadIdx.y;

สร้างดัชนีด้วยระยะห่างแถว

ภาพถูกจัดเก็บทีละแถว แปลง (x, y) เป็นออฟเซ็ตแบบแบนด้วยการทำดัชนีแบบเรียงตามแถว เพื่อให้ทุกเธรดอ่านพิกเซลที่ถูกต้อง

int idx = y * width + x;

ป้องกันขอบภาพ

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

if (x >= width || y >= height) return;

เลือกรูปร่างบล็อกสองมิติ

บล็อกขนาด 16x16 หรือ 32x8 ให้การครอบคลุมที่ดีและมีแถวที่เหมาะกับวาร์ป เลือกรูปร่างบล็อกสองมิติที่หารขนาดภาพลงตัวเมื่อทำได้

dim3 block(16, 16);
dim3 grid((width+15)/16, (height+15)/16);

จองครั้งเดียว ใช้ซ้ำบ่อย ๆ

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

ร่างก่อนเขียนโค้ด

วาดขั้นตอน บัฟเฟอร์ และลูกศรระหว่างขั้นตอนเหล่านั้นก่อนแผนภาพการไหลของข้อมูลที่ชัดเจนช่วยจับข้อผิดพลาดด้านการออกแบบได้ตั้งแต่ก่อนที่เคอร์เนลใด ๆ จะทำงาน ✏️

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

คุณมีห่วงโซ่ของขั้นตอนอยู่ วิธีใดช่วยหลีกเลี่ยงการจองบัฟเฟอร์ใหม่สำหรับทุกขั้นตอน

สรุป

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

เริ่มต้นได้ฟรี

เรียนรู้ C++ ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
30
บทเรียน
120

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

บทเรียน “ออกแบบไปป์ไลน์การประมวลผล” ฟรีหรือไม่

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

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

  1. ออกแบบไปป์ไลน์การประมวลผล
  2. รวมตัวกรองเป็นเคอร์เนลเดียว
  3. สตรีมไทล์สำหรับภาพขนาดใหญ่
  4. วิเคราะห์ ปรับให้เหมาะสม ส่งมอบ
← กลับไปที่ CUDA Academy