Rust कोड का प्रोफाइलिंग: बाधाएं खोजें और प्रोग्राम को गति दें

परिचय: Rust कोड को प्रोफाइल क्यों करें?

Rust अपनी गति और सुरक्षा के लिए प्रसिद्ध है, लेकिन सबसे तेज़ कोड भी स्पष्ट न होने वाली बाधाओं के कारण धीमा चल सकता है। प्रोफाइलिंग निष्पादन समय, मेमोरी उपयोग और अन्य संसाधनों को मापने की प्रक्रिया है, जो "अड़चनों" को खोजने में मदद करती है। प्रोफाइलिंग के बिना, अनुकूलन अनुमान लगाने जैसा हो जाता है: आप कोड के उन हिस्सों को "बेहतर" कर सकते हैं जो प्रदर्शन को बिल्कुल प्रभावित नहीं करते हैं।

इस लेख में, हम Rust प्रोफाइलिंग के मुख्य टूल्स पर चर्चा करेंगे: perf, flamegraph, cargo-flamegraph और अंतर्निहित बेंचमार्किंग। आप सीखेंगे कि धीमे फंक्शन, आवंटन और कैश मिस को कैसे खोजें, और प्राप्त डेटा की व्याख्या कैसे करें।

Rust प्रोफाइलिंग टूल्स: सही दृष्टिकोण चुनना

1. #[bench] के साथ अंतर्निहित बेंचमार्किंग

प्रोफाइलिंग की ओर पहला कदम बेंचमार्क लिखना है। Rust में बेंचमार्क के लिए अंतर्निहित समर्थन है (अस्थिर, nightly की आवश्यकता है)। उदाहरण:

// फ़ाइल benches/my_bench.rs में#![feature(test)]extern crate test;

use test::Bencher;

#[bench]fn bench_my_function(b: &mut Bencher) {    let data = vec![1, 2, 3, 4, 5];    b.iter(|| {        // परीक्षण किया जा रहा फंक्शन        let _ = data.iter().sum::<i32>();    });}

चलाएं: cargo bench। आपको सटीक समय माप मिलेगा, लेकिन यह नहीं दिखाएगा कि फंक्शन के अंदर समय कहाँ खर्च हो रहा है।

2. perf — कर्नेल-स्तरीय प्रोफाइलर

टूल perf (Linux) प्रोसेसर काउंटर के नमूने एकत्र करता है। यह दिखाता है कि कोड की कौन सी पंक्तियाँ सबसे अधिक बार निष्पादित होती हैं।

स्थापना: sudo apt install linux-tools-common linux-tools-generic।

उपयोग का उदाहरण:

# डीबग प्रतीकों के साथ कंपाइल करेंcargo build --release

# प्रोफाइलिंग चलाएंsudo perf record ./target/release/my_program

# रिपोर्ट देखेंsudo perf report

रिपोर्ट में आप निष्पादन समय के प्रतिशत के अनुसार क्रमबद्ध फंक्शन देखेंगे। यह अनुकूलन के लिए पहला उम्मीदवार है।

3. flamegraph — कॉल स्टैक का विज़ुअलाइज़ेशन

Flamegraph एक SVG आरेख है, जहाँ प्रत्येक आयत की चौड़ाई फंक्शन के निष्पादन समय के अनुरूप होती है। आयत जितना चौड़ा होगा, उस फंक्शन या उसके चाइल्ड कॉल में उतना ही अधिक समय खर्च होता है।

cargo-flamegraph की स्थापना:

cargo install flamegraph

चलाएं:

cargo flamegraph --bin my_program

परिणाम — फ़ाइल flamegraph.svg। इसे ब्राउज़र में खोलें। चौड़े "पठार" देखें — ये बाधाएं हैं।

व्यावहारिक उदाहरण: Rust कोड में बाधा खोजना

एक सरल प्रोग्राम पर विचार करें जो डेटा की एक बड़ी सरणी को संसाधित करता है:

fn process(data: &[u8]) -> Vec<u8> {    let mut result = Vec::with_capacity(data.len());    for &byte in data {        result.push(byte.wrapping_mul(2));    }    result}

fn main() {    let data = vec![0u8; 10_000_000];    let _ = process(&data);}

कंपाइल करें और प्रोफाइलिंग चलाएं:

cargo build --releasecargo flamegraph --bin my_program

flamegraph खोलने पर, हम देखते हैं कि अधिकांश समय for लूप और wrapping_mul कॉल पर खर्च होता है। ध्यान दें कि Vec::push पुनः आवंटन का कारण बन सकता है यदि क्षमता सटीक रूप से निर्धारित नहीं की गई है। हमारे मामले में, with_capacity सही ढंग से सेट किया गया है, लेकिन लूप ही बाधा है।

अनुकूलन: इटरेटर और map का उपयोग करें:

fn process_optimized(data: &[u8]) -> Vec<u8> {    data.iter().map(|&b| b.wrapping_mul(2)).collect()}

पुनः मापने पर वेक्टराइज़ेशन (LLVM ऑटो-वेक्टराइज़ेशन) के कारण 10-15% की गति वृद्धि दिखती है।

उन्नत तकनीकें: आवंटन