สิ่งที่ฟังดูเหมือนงานง่ายๆ - การทำให้คอมพิวเตอร์ของคุณทำงานหนักขึ้น - กลับกลายเป็นเรื่องยากอย่างน่าประหลาดใจในโลกปัจจุบันที่เต็มไปด้วย compiler ที่ฉลาดและ processor ที่ถูกปรับให้เหมาะสม การอพิปรายทางเทคนิคเมื่อเร็วๆ นี้ได้เน้นย้ำถึงความซับซ้อนที่คาดไม่ถึงที่นักพัฒนาต้องเผชิญเมื่อพวกเขาต้องการใช้ CPU cycles อย่างตั้งใจ ไม่ว่าจะเพื่อการทดสอบ การวัดประสิทธิภาพ หรือความต้องการของแอปพลิเคชันเฉพาะ
ความท้าทายนี้เกิดจาก compiler สมัยใหม่ที่ฉลาดเกินไป เครื่องมือที่ซับซ้อนเหล่านี้ถูกออกแบบมาเพื่อปรับโค้ดให้เหมาะสมโดยอัตโนมัติ มักจะลบสิ่งที่พวกมันมองว่าเป็นการดำเนินการที่ไม่จำเป็น สิ่งนี้สร้างเกมแมวไล่หนูระหว่างนักพัฒนาที่ต้องการสิ้นเปลือง cycles กับ compiler ที่มุ่งมั่นจะทำให้ทุกอย่างมีประสิทธิภาพ
 |
|---|
| การเขียนโปรแกรมสมัยใหม่เผชิญกับความท้าทายที่ไม่คาดคิดแม้จะมีความงามของเทคโนโลยี เหมือนกับดอกไม้เหล่านี้ท่ามกลางใบไม้เขียว |
ปัญหา Compiler Optimization
Compiler สมัยใหม่อย่าง GCC และ Clang ใช้เทคนิคการปรับให้เหมาะสมแบบรุกรานที่สามารถกำจัดโค้ดที่พวกมันมองว่าไร้ประโยชน์ออกไปได้อย่างสมบูรณ์ loop ง่ายๆ ที่ดูเหมือนจะสิ้นเปลือง CPU time มักถูกปรับให้เหมาะสมจนหายไปทั้งหมด ทำให้นักพัฒนาต้องงงงวยเมื่อโค้ดที่ออกแบบมาให้ทำงานหนักกลับทำงานเสร็จในทันทีแทนที่จะใช้เวลาประมวลผลตามที่ตั้งใจไว้
ปัญหานี้จะยิ่งซับซ้อนขึ้นเมื่อใช้ optimization flags อย่าง -O3 ซึ่งเปิดใช้งานการปรับให้เหมาะสมแบบรุกรานที่สุดของ compiler สิ่งที่ดูเหมือนโค้ดที่ใช้ CPU อย่างหนักใน source code มักจะกลายเป็นเกือบไม่มีอะไรเลยในไฟล์ executable สุดท้าย
เทคนิคการปรับปรุงประสิทธิภาพคอมไพเลอร์ทั่วไปที่รบกวนการใช้ CPU อย่างสิ้นเปลือง:
- การกำจัดโค้ดที่ตายแล้ว (กำจัดลูปที่ไม่ได้ใช้งาน)
- การพับค่าคงที่ (คำนวณการดำเนินการง่ายๆ ล่วงหน้า)
- การปรับปรุงลูป (อาจกำจัดหรือลดความซับซ้อนของการดำเนินการที่ทำซ้ำ)
- การแทรกโค้ดแบบอินไลน์ (สามารถเปิดโอกาสให้มีการปรับปรุงประสิทธิภาพมากขึ้น)
วิธีแก้ปัญหาทางเทคนิคและการแก้ไขชั่วคราว
ชุมชนได้พัฒนาแนวทางสร้างสรรค์หลายวิธีเพื่อเอาชนะ compiler สมัยใหม่ คำสำคัญ volatile กลายเป็นเครื่องมือหลัก ที่บังคับให้ compiler ถือว่าการดำเนินการกับ memory เป็นสิ่งที่อาจสำคัญและป้องกันการลบออก อย่างไรก็ตาม แนวทางนี้ก็มีข้อจำกัดและอาจไม่ให้ลักษณะการโหลด CPU ที่ต้องการอย่างแม่นยำ
คำสั่ง inline assembly เป็นอีกหนึ่งวิธีแก้ปัญหา ด้วยคำสั่ง no operation ง่ายๆ ที่ compiler มักจะเคารพ function attributes อย่าง noinline ยังสามารถป้องกันไม่ให้ compiler ปรับ function ทั้งหมดที่ออกแบบมาเพื่อใช้ cycles ให้เหมาะสม
การสิ้นเปลือง user space CPU cycles เป็นเรื่องที่ทำได้ยากปานกลางเมื่อเรามี optimising compiler
การอพิปรายเผยให้เห็นว่าแนวทางต่างๆ ส่งผลต่อประสิทธิภาพของระบบในรูปแบบต่างๆ ตั้งแต่การใช้ memory bandwidth ไปจนถึงผลกระทบต่อ cache coherence ทำให้การเลือกเทคนิคขึ้นอยู่กับความต้องการในการทดสอบเฉพาะ
โซลูชันทางเทคนิคสำหรับป้องกันการปรับปรุงประสิทธิภาพของคอมไพเลอร์:
- คีย์เวิร์ด
volatileสำหรับการดำเนินการหน่วยความจำ - แอตทริบิวต์ฟังก์ชัน
__attribute__((noinline)) - Inline assembly ด้วย
asm volatile("nop") - Memory barriers และ synchronization primitives
- การเรียกใช้ฟังก์ชันภายนอกที่คอมไพเลอร์ไม่สามารถปรับปรุงประสิทธิภาพได้
 |
|---|
| สำรวจ JEP 509 : การปรับปรุงฟีเจอร์ JDK เพื่อรับมือกับความท้าทายระดับ CPU ในการเขียนโปรแกรมสมัยใหม่ |
การประยุกต์ใช้จริงและทางเลือกอื่น
แม้ว่าความท้าทายทางเทคนิคจะน่าสนใจ แต่ชุมชนยังชี้ไปที่ทางเลือกที่ใช้ได้จริงสำหรับการทดสอบความเครียดของ CPU เครื่องมือที่มีอยู่แล้วอย่างคำสั่ง stress ให้วิธีแก้ปัญหาที่พร้อมใช้สำหรับกรณีการใช้งานทั่วไปส่วนใหญ่ ทำให้ไม่จำเป็นต้องเขียนโค้ดเองในหลายสถานการณ์
การสนทนายังสัมผัสถึงธีมที่กว้างขึ้น โดยนักพัฒนาบางคนสังเกตเห็นความขัดแย้งของการต่อสู้เพื่อสิ้นเปลือง CPU cycles ในยุคที่ประสิทธิภาพเป็นสิ่งสำคัญที่สุด คนอื่นๆ เปรียบเทียบกับการพัฒนา embedded systems ซึ่งการควบคุมเวลาที่แม่นยำเป็นทักษะที่จำเป็นมาอย่างยาวนาน
บริบทสมัยใหม่
ความท้าทายทางเทคนิคนี้สะท้อนการเปลี่ยนแปลงที่กว้างขึ้นในการคอมพิวติ้ง เมื่อ processor มีประสิทธิภาพมากขึ้นและ compiler ซับซ้อนมากขึ้น ช่องว่างระหว่างสิ่งที่นักพัฒนาเขียนกับสิ่งที่ถูกประมวลผลจริงๆ ยังคงเพิ่มขึ้น การเข้าใจการปรับให้เหมาะสมเหล่านี้กลายเป็นสิ่งสำคัญไม่เพียงแค่สำหรับการปรับประสิทธิภาพ แต่ยังรวมถึงสถานการณ์ใดๆ ที่ต้องการพฤติกรรมของระบบที่คาดเดาได้
การอพิปรายยังเน้นย้ำว่าสถาปัตยกรรม processor ที่แตกต่างกัน ตั้งแต่ x86 แบบดั้งเดิมไปจนถึงการออกแบบ ARM สมัยใหม่ อาจตอบสนองต่อเทคนิคการโหลด CPU แตกต่างกัน ซึ่งเพิ่มความซับซ้อนอีกชั้นหนึ่งให้กับสิ่งที่ดูเหมือนงานตรงไปตรงมาในตอนแรก
อ้างอิง: How to waste CPU like a Professional