CUDA Academy · บทเรียน

โครงสร้างของเคอร์เนล

ลายเซ็น ชนิดค่าที่ส่งกลับ และกฎของ void

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

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

เคอร์เนลคืออะไร

เคอร์เนลคือฟังก์ชัน C++ เดียวที่ทำงานบน GPU และถูกเรียกใช้พร้อมกันโดยเธรดหลายพันเธรด คุณเขียนฟังก์ชันเพียงครั้งเดียว แล้วฮาร์ดแวร์จะกระจายงานออกไป 🚀

ตัวระบุ global

คุณระบุว่าเคอร์เนลเป็นเคอร์เนลด้วยตัวระบุ __global__ ซึ่งบอก nvcc ว่าฟังก์ชันนี้ถูกเรียกจาก CPU แต่ทำงานจริงบนอุปกรณ์

__global__ void myKernel() {
    // runs on the GPU
}

เคอร์เนลคืนค่าเป็น void

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

__global__ void k() { /* void only */ }

เหตุใดจึงไม่คืนค่า

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

พารามิเตอร์ส่งแบบค่า

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

__global__ void add(float* out, float* a, int n) {}

ส่งพอยน์เตอร์ ไม่ใช่อาร์เรย์

หากต้องการส่งอาร์เรย์ให้เคอร์เนล ให้ส่งพอยน์เตอร์ของอุปกรณ์ เคอร์เนลจะอ่านและเขียนหน่วยความจำ GPU ตามตำแหน่งที่พอยน์เตอร์นั้นชี้

__global__ void scale(float* data, float k) {}

แต่ละเธรดเลือกงานของตัวเอง

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

int i = threadIdx.x; // who am I?

เคอร์เนลฉบับสมบูรณ์ขนาดเล็ก

นี่คือตัวอย่างเคอร์เนลฉบับสมบูรณ์ ซึ่งคูณสมาชิกหนึ่งตัวเป็นสองเท่าต่อหนึ่งเธรด สังเกตตัวระบุ __global__ การคืนค่าเป็น void และพารามิเตอร์พอยน์เตอร์ที่อยู่ด้วยกัน

__global__ void doubleIt(float* x) {
    int i = threadIdx.x;
    x[i] = x[i] * 2.0f;
}

โค้ดโฮสต์แยกต่างหาก

ฟังก์ชัน CPU ปกติของคุณ ซึ่งมักชื่อ main คือโค้ดโฮสต์ โดยจะเตรียมสิ่งต่าง ๆ แล้วขอให้ GPU เรียกใช้เคอร์เนล

int main() {
    // host side: prepare and launch
}

ไม่มีการเรียกตัวเองซ้ำหรือ I/O ที่คาดไม่ถึง

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

การตั้งชื่อเคอร์เนล

ปฏิบัติต่อเคอร์เนลเหมือนฟังก์ชันทั่วไป โดยตั้งชื่อที่ชัดเจนและเป็นคำกริยา เช่น vectorAdd ชื่อที่ดีช่วยให้อ่านการเรียกใช้งานได้ง่ายขึ้นมาก

__global__ void vectorAdd(float* c, float* a, float* b);

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

มาทบทวนกฎของรูปแบบการประกาศเคอร์เนลกัน

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุป: โครงสร้างของเคอร์เนล

เคอร์เนลคือฟังก์ชัน __global__ void ที่ถูกเรียกใช้โดยเธรดจำนวนมาก ให้ส่งพอยน์เตอร์และค่าขนาดเล็ก แล้วปล่อยให้แต่ละเธรดใช้ดัชนีของตัวเอง ทำได้ดีมาก! 🎉

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

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

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

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

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “โครงสร้างของเคอร์เนล” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “โครงสร้างของเคอร์เนล” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส CUDA Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส CUDA Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “โครงสร้างของเคอร์เนล”

ลายเซ็น ชนิดค่าที่ส่งกลับ และกฎของ void คุณปฏิบัติ CUDA Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน CUDA Academy หรือไม่

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

บทเรียน “โครงสร้างของเคอร์เนล” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน CUDA Academy นี้ได้ไหม

ได้ บทเรียน CUDA Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

← กลับไปที่ CUDA Academy