Learn Rust Coding · บทเรียน

การวัดประสิทธิภาพและการปรับแต่งประสิทธิภาพ

สำรวจเครื่องมือและเทคนิคสำหรับวัดประสิทธิภาพโค้ด Rust ระบุจุดคอขวด และปรับโค้ดให้มีประสิทธิภาพสูงสุด

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

เหตุใดจึงต้องปรับปรุงประสิทธิภาพโค้ด Rust

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

เรื่องนี้สำคัญอย่างยิ่งสำหรับแอปพลิเคชันอย่างเอนจินเกม ระบบฝังตัว หรือบริการเว็บที่รองรับปริมาณงานสูง ซึ่งทุกมิลลิวินาทีและทุกไบต์ล้วนมีความหมาย

ทำความเข้าใจการวัดประสิทธิภาพ

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

เวลาการทำงาน: ฟังก์ชันหรือส่วนของโค้ดใช้เวลานานเท่าใด
การใช้หน่วยความจำ: งานหนึ่ง ๆ ใช้ RAM มากเพียงใด
อัตราการประมวลผล: สามารถดำเนินการได้กี่รายการต่อวินาที

การวัดประสิทธิภาพช่วยขจัดการคาดเดาออกจากการปรับปรุงประสิทธิภาพ โดยแสดงผลลัพธ์จากการวัดจริง

การค้นหาคอขวดด้านประสิทธิภาพ

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

เครื่องมืออย่างตัววิเคราะห์ประสิทธิภาพ เช่น perf บน Linux และ Instruments บน macOS ช่วยแสดงให้เห็นว่าโปรแกรมใช้เวลาอยู่ที่ใด จากนั้นการวัดประสิทธิภาพจะให้ค่าที่แม่นยำสำหรับส่วนสำคัญเหล่านั้น

แนะนำ `Criterion.rs`

สำหรับการวัดประสิทธิภาพใน Rust ที่แข็งแกร่งและเชื่อถือได้ ครейт Criterion.rs เป็นตัวเลือกหลัก ไลบรารีนี้มีประสิทธิภาพและวิเคราะห์ทางสถิติเพื่อให้ผลลัพธ์ที่แม่นยำและสม่ำเสมอ

Criterion.rs จัดการการทำงานช่วงอุ่นเครื่อง การวิเคราะห์ทางสถิติ และยังสร้างรายงาน HTML ที่สวยงามเพื่อให้เห็นแนวโน้มด้านประสิทธิภาพได้ง่าย

การตั้งค่า `Criterion.rs`

หากต้องการใช้ Criterion.rs ขั้นแรกคุณต้องเพิ่มเป็นสิ่งที่ต้องพึ่งพาสำหรับการพัฒนาใน Cargo.toml จากนั้นสร้างไฟล์การวัดประสิทธิภาพใหม่

มาเพิ่ม criterion และกำหนดเป้าหมายการวัดประสิทธิภาพใน Cargo.toml กัน สร้างไฟล์ใหม่ เช่น benches/my_benchmark.rs

[package]
name = "performance_app"
version = "0.1.0"
edition = "2021"

[dev-dependencies]
criterion = { version = "0.5", features = ["html_reports"] }

[[bench]]
name = "my_benchmark"
harness = false # Crucial for Criterion.rs

การเขียนการวัดประสิทธิภาพครั้งแรก

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

บันทึกโค้ดนี้ไว้ใน benches/my_benchmark.rs อย่าลืมนำเข้า Criterion และกำหนดฟังก์ชันการวัดประสิทธิภาพของคุณ

use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn factorial(n: u64) -> u64 {
    (1..=n).product()
}

fn bench_factorial(c: &mut Criterion) {
    c.bench_function("factorial 20", |b| b.iter(|| factorial(black_box(20))));
}

criterion_group!(benches, bench_factorial);
criterion_main!(benches);

การเรียกใช้และตีความผลการวัดประสิทธิภาพ

หากต้องการเรียกใช้การวัดประสิทธิภาพ ให้เรียกใช้ cargo bench ในไดเรกทอรีโปรเจกต์ของคุณ Criterion.rs จะดำเนินการซ้ำหลายรอบและวิเคราะห์ทางสถิติ

ผลลัพธ์จะแสดงเวลาเฉลี่ยในการทำงาน ส่วนเบี่ยงเบนมาตรฐาน และช่วงความเชื่อมั่น หากคุณเปิดใช้ html_reports ให้ตรวจสอบโฟลเดอร์ target/criterion เพื่อดูกราฟโดยละเอียด

การปรับปรุงประสิทธิภาพ: ประสิทธิภาพของอัลกอริทึม

หนึ่งในวิธีเพิ่มประสิทธิภาพที่ส่งผลมากที่สุดคือการเลือกอัลกอริทึมที่ดีกว่า อัลกอริทึมที่มีความซับซ้อนด้านเวลาต่ำกว่า (เช่น O(n) แทน O(n^2)) สามารถทำให้โค้ดของคุณทำงานเร็วขึ้นอย่างมากเมื่อมีข้อมูลนำเข้าขนาดใหญ่

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

การเพิ่มประสิทธิภาพ: โครงสร้างข้อมูล

การเลือกโครงสร้างข้อมูลอาจส่งผลต่อประสิทธิภาพอย่างมาก โครงสร้างแต่ละแบบเหมาะกับการดำเนินการที่แตกต่างกัน:

Vec (อาร์เรย์แบบปรับขนาดได้): เข้าถึงข้อมูลแบบสุ่มได้เร็ว แต่เพิ่มหรือลบข้อมูลตรงกลางได้ช้า
LinkedList: เพิ่มหรือลบข้อมูลได้เร็วทุกตำแหน่ง แต่เข้าถึงข้อมูลแบบสุ่มได้ช้า
HashMap (ตารางแฮช): ค้นหาข้อมูลได้เร็ว (โดยเฉลี่ย)

ทำความเข้าใจรูปแบบการเข้าถึงข้อมูลของคุณ เพื่อเลือกโครงสร้างที่เหมาะสมที่สุด

การเพิ่มประสิทธิภาพ: ลดการจองหน่วยความจำ

การจองหน่วยความจำ (โดยเฉพาะบนฮีป) อาจมีค่าใช้จ่ายสูง การจองแต่ละครั้งต้องร้องขอหน่วยความจำจากระบบปฏิบัติการ ซึ่งใช้เวลา

สแตกเทียบกับฮีป: หากเป็นไปได้ ควรเลือกใช้ข้อมูลที่จัดสรรบนสแตก (มีขนาดคงที่)
จัดสรรล่วงหน้า: ใช้ Vec::with_capacity เพื่อหลีกเลี่ยงการจัดสรรหน่วยความจำใหม่
นำกลับมาใช้ซ้ำ: การนำโครงสร้างข้อมูลเดิมกลับมาใช้ซ้ำอาจเร็วกว่าการสร้างโครงสร้างใหม่

การลดการจองหน่วยความจำให้น้อยที่สุดอาจช่วยเพิ่มความเร็วได้อย่างมาก

แบบทดสอบการวัดประสิทธิภาพ

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

ทบทวนและขั้นตอนถัดไป

คุณได้เรียนรู้ความสำคัญของการวัดประสิทธิภาพ และวิธีใช้ Criterion.rs เพื่อวัดประสิทธิภาพของโค้ด Rust แล้ว นอกจากนี้ เรายังได้กล่าวถึงกลยุทธ์สำคัญในการเพิ่มประสิทธิภาพดังนี้:

ระบุจุดคอขวดด้วยการวิเคราะห์ประสิทธิภาพ
เลือกอัลกอริทึมที่มีประสิทธิภาพ
เลือกโครงสร้างข้อมูลที่เหมาะสม
ลดการจองหน่วยความจำ

โปรดจำไว้ว่า ควรวัดผลก่อนเพิ่มประสิทธิภาพเสมอ! ฝึกฝนต่อไปเพื่อสร้างแอปพลิเคชัน Rust ที่ทำงานได้อย่างมีประสิทธิภาพ

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

บทเรียน “การวัดประสิทธิภาพและการปรับแต่งประสิทธิภาพ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การวัดประสิทธิภาพและการปรับแต่งประสิทธิภาพ”

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

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

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

บทเรียน “การวัดประสิทธิภาพและการปรับแต่งประสิทธิภาพ” ใช้เวลานานแค่ไหน

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

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

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

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

อินเทอร์เฟซฟังก์ชันภายนอก (FFI)
Rust สู่ WebAssembly (WASM)
การวัดประสิทธิภาพและการปรับแต่งประสิทธิภาพ

← กลับไปที่ Learn Rust Coding