พื้นที่แอดเดรสแยกจากกัน
ทำไมพอยน์เตอร์ของโฮสต์จึงใช้บนอุปกรณ์ไม่ได้
พื้นที่แอดเดรสแยกจากกัน เป็นบทเรียน CUDA Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน CUDA Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส CUDA Academy มีบทเรียนทั้งหมด 4 บทเรียน
หน่วยความจำสองส่วนแยกจากกัน
CPU และ GPU ต่างมี RAM ของตนเอง ทั้งสองไม่ได้ใช้พื้นที่ที่อยู่ร่วมกัน และข้อเท็จจริงนี้เป็นพื้นฐานของ CUDA ทั้งหมด 🧠
ที่อยู่หมายถึงอะไร
ตัวชี้เป็นเพียงตัวเลขที่ระบุตำแหน่งหนึ่งในหน่วยความจำ ตำแหน่งนั้นจะมีความหมายเฉพาะใน พื้นที่ที่อยู่ที่ตัวชี้ถูกสร้างขึ้น
ตัวชี้โฮสต์ใช้ได้เฉพาะในโฮสต์
ตัวชี้จาก malloc ระบุ หน่วยความจำโฮสต์ GPU ไม่มีตำแหน่งดังกล่าว ดังนั้นการส่งตัวชี้นี้ให้เคอร์เนลจึงชี้ไปยังตำแหน่งที่ใช้ไม่ได้
int* h = (int*)malloc(n * sizeof(int));ตัวชี้อุปกรณ์ก็ใช้ได้เฉพาะในอุปกรณ์
ตัวชี้จาก cudaMalloc ระบุ หน่วยความจำอุปกรณ์ CPU ไม่สามารถอ่านได้โดยตรง การเข้าถึงตัวชี้นี้จากโฮสต์จะทำให้โปรแกรมหยุดทำงาน
int* d;
cudaMalloc(&d, n * sizeof(int));ข้อผิดพลาดคลาสสิก
การส่ง ตัวชี้โฮสต์เข้าไปในเคอร์เนลคอมไพล์ผ่านได้ตามปกติ แต่ล้มเหลวขณะทำงาน ตัวเลขนั้นถูกต้อง แต่หน่วยความจำที่ระบุไม่ได้อยู่บน GPU
เหตุใดจึงคอมไพล์ผ่านได้
ตัวชี้ทั้งสองดูเหมือนเป็นชนิดเดียวกันสำหรับ C++ ดังนั้นคอมไพเลอร์จึงไม่แจ้งเตือน ความ ไม่ตรงกันจะแสดงปัญหาเมื่อ GPU เข้าถึงที่อยู่นั้นเท่านั้น
เชื่อมพื้นที่ด้วย cudaMemcpy
เมื่อต้องการย้ายข้อมูลระหว่างพื้นที่ คุณต้องคัดลอกอย่างชัดเจนด้วย cudaMemcpy ไม่มีการใช้ข้อมูลร่วมกันโดยอัตโนมัติระหว่างสองฝั่ง
cudaMemcpy(d, h, bytes, cudaMemcpyHostToDevice);ใช้รูปแบบการตั้งชื่อช่วย
โปรแกรมเมอร์จำนวนมากเติมคำนำหน้า h_ ให้ตัวชี้โฮสต์ และ d_ ให้ตัวชี้อุปกรณ์ นี่เป็นนิสัยที่ช่วยป้องกันการสับสนที่แก้ไขได้ยาก
float *h_a, *d_a;เคอร์เนลมองเห็นพื้นที่อุปกรณ์
ภายในเคอร์เนล ตัวชี้ทุกตัวที่คุณเข้าถึงค่าต้องอยู่ใน หน่วยความจำอุปกรณ์ นี่เป็นพื้นที่เดียวที่เธรด GPU เข้าถึงได้
คำใบ้เรื่องหน่วยความจำแบบรวม
ภายหลังคุณจะได้รู้จัก หน่วยความจำแบบรวม ซึ่งใช้ตัวชี้เดียวที่ถูกต้องได้ทั้งสองฝั่ง แต่ตอนนี้ให้แยกตัวชี้โฮสต์และอุปกรณ์ออกจากกันอย่างเคร่งครัด
แบบจำลองในใจ
ลองนึกภาพห้องสองห้องที่ไม่มีชั้นวางร่วมกัน หากต้องการใช้ข้อมูลในอีกห้อง คุณต้อง ถือสำเนาข้ามไป ห้ามเพียงชี้ข้ามห้อง
ตรวจสอบอย่างรวดเร็ว
มาทบทวนว่าคุณเข้าใจพื้นที่ที่อยู่แยกจากกันหรือไม่
สรุปทบทวน
คุณได้เรียนรู้ว่าโฮสต์และอุปกรณ์อยู่ใน พื้นที่ที่อยู่แยกจากกัน ตัวชี้ไม่สามารถใช้แทนกันได้ และ cudaMemcpy คือวิธีส่งข้อมูลข้ามช่องว่างนี้ ✅
เรียนรู้ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “พื้นที่แอดเดรสแยกจากกัน” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน CUDA Academy นี้ได้ไหม
ได้ บทเรียน CUDA Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ตัวระบุคุณสมบัติฟังก์ชัน __global__
- ฟังก์ชัน __device__ และ __host__
- พื้นที่แอดเดรสแยกจากกัน
- วงจรชีวิตของโปรแกรม CUDA