Mojo Academy · บทเรียน

กายวิภาคของเคอร์เนลคำนวณ

ลูปด้านในส่วนสำคัญที่ลงมือประมวลผล

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

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

Kernel คืออะไร

kernel สำหรับการคำนวณคือรูทีนขนาดเล็กที่มุ่งทำงานเฉพาะด้าน ซึ่งทำงานคำนวณตัวเลขจริง ๆ เช่น การบวกอาร์เรย์สองชุดทีละสมาชิก

ลูปด้านในที่เป็นเส้นทางร้อน

เวลาส่วนใหญ่ของ kernel อยู่ในลูปด้านในที่กระชับเพียงลูปเดียว เร่งลูปนั้น แล้วทั้งโปรแกรมก็จะเร็วขึ้น

for i in range(n):
    out[i] = a[i] + b[i]

ข้อมูลนำเข้าและผลลัพธ์

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

fn add(a: UnsafePointer[Float32], b: UnsafePointer[Float32], out: UnsafePointer[Float32], n: Int):
    pass

ใช้ fn เพื่อความเข้มงวด

เขียน kernel ด้วย fn ไม่ใช่ def รูปแบบที่เข้มงวดและมีชนิดข้อมูลช่วยให้ Mojo คอมไพล์โค้ดเครื่องที่กระชับได้โดยไม่มีเรื่องไม่คาดคิด

fn kernel(n: Int):
    pass

ทำให้ส่วนเนื้อหามีขนาดเล็ก

kernel ที่เร็วที่สุดทำงานเพียงอย่างเดียว ส่วนเนื้อหาด้านในที่สั้นและคาดเดาได้ง่ายต่อการปรับให้เหมาะสมอย่างเต็มที่โดยคอมไพเลอร์

ไม่มีเรื่องไม่คาดคิดภายใน

หลีกเลี่ยงงานหนัก เช่น การจองหน่วยความจำหรือ I/O ในลูปร้อน การทำซ้ำแต่ละครั้งควรมีต้นทุนต่ำและสม่ำเสมอเพื่อให้ได้อัตราการประมวลผลสูงสุด

นับปริมาณงาน

คิดในแง่จำนวนการดำเนินการทั้งหมด kernel ที่ทำงานกับสมาชิก n ตัวจะมีปริมาณงานประมาณ n หน่วย ดังนั้น n จึงเป็นตัวขับต้นทุน

หน่วยความจำคือข้อจำกัด

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

วางแผนเพื่อทำเวกเตอร์

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

Kernel saxpy ขนาดเล็ก

kernel แบบคลาสสิกคือ saxpy: out = scale คูณ a บวก b มันมีขนาดเล็ก สม่ำเสมอ และเป็นค่าพื้นฐานที่ดีสำหรับการปรับให้เหมาะสม

for i in range(n):
    out[i] = scale * a[i] + b[i]

วัดผลก่อนปรับแต่ง

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

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

คุณกำลังจะปรับแต่ง kernel เวลาส่วนใหญ่เกือบทั้งหมดของมันหมดไปกับอะไร

สรุปทบทวน

kernel คือ fn ขนาดเล็กที่มีลูปด้านในอันกระชับเป็นผู้ทำงาน รักษาความสม่ำเสมอ ใส่ใจหน่วยความจำ และวัดค่าพื้นฐานก่อนเสมอ 🔧

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

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

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

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

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

บทเรียน “กายวิภาคของเคอร์เนลคำนวณ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “กายวิภาคของเคอร์เนลคำนวณ”

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

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

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

บทเรียน “กายวิภาคของเคอร์เนลคำนวณ” ใช้เวลานานแค่ไหน

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

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

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

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

  1. กายวิภาคของเคอร์เนลคำนวณ
  2. การผสาน SIMD กับลูป
  3. การลดการรับส่งข้อมูลในหน่วยความจำ
  4. การแบ่งบล็อกเพื่อความใกล้เคียงของแคช
← กลับไปที่ Mojo Academy