Rust效能分析之測試及火焰圖，附(lru,lfu,arc)測試

问蒙服务框架發表於2024-06-18
Rust

效能測試，在編寫程式碼後，單元測試及效能測試是重要的驗收點，好的效能測試可以讓我們提前發現程式中存在的問題。

測試用例

在Rust中，測試通常有兩部分，一部分是文件測試，一部分是模組測試。
通常我們在函式定義的開始可以看到以///三斜槓開頭的就是文件註釋釋出的時候會將自動生成到docs.rs中，其中以///包含的程式碼片斷會就判斷為文件測試，這樣子就可以把功能與測試完美的結合在一起。
以下是Lru的例子：

/// LRU 全稱是Least Recently Used，即最近最久未使用的意思
/// 一個 LRU 快取普通級的實現, 介面參照Hashmap保持一致
/// 設定容量之後將最大保持該容量大小的資料
/// 後進的資料將會淘汰最久沒有被訪問的資料
///
/// # Examples
///
/// ```
/// use algorithm::LruCache;
/// fn main() {
///     let mut lru = LruCache::new(3);
///     lru.insert("now", "ok");
///     lru.insert("hello", "algorithm");
///     lru.insert("this", "lru");
///     lru.insert("auth", "tickbh");
///     assert!(lru.len() == 3);
///     assert_eq!(lru.get("hello"), Some(&"algorithm"));
///     assert_eq!(lru.get("this"), Some(&"lru"));
///     assert_eq!(lru.get("now"), None);
/// }
/// ```
pub struct LruCache<K, V, S> {
    /// 儲存資料結構
    map: HashMap<KeyRef<K>, NonNull<LruEntry<K, V>>, S>,
    /// 快取的總容量
    cap: usize,
    /// 雙向列表的頭
    head: *mut LruEntry<K, V>,
    /// 雙向列表的尾
    tail: *mut LruEntry<K, V>,
}

模組測試，在lru.rs檔案底下會定義：#[cfg(test)] mod tests，這個將變成模組化測試

#[cfg(test)]
mod tests {
    use std::collections::hash_map::RandomState;

    use super::LruCache;

    #[test]
    fn test_insert() {
        let mut m = LruCache::new(2);
        assert_eq!(m.len(), 0);
        m.insert(1, 2);
        assert_eq!(m.len(), 1);
        m.insert(2, 4);
        assert_eq!(m.len(), 2);
        m.insert(3, 6);
        assert_eq!(m.len(), 2);
        assert_eq!(m.get(&1), None);
        assert_eq!(*m.get(&2).unwrap(), 4);
        assert_eq!(*m.get(&3).unwrap(), 6);
    }
}

我們將在執行cargo test的時候將會自動執行這些函式進行測試：可以顯示如下內容：

   Compiling algorithm v0.1.5 (D:\my\algorithm)

    Finished test [unoptimized + debuginfo] target(s) in 1.95s
     Running unittests src\lib.rs (target\debug\deps\algorithm-3ecde5aa4c430e91.exe)

running 142 tests
test arr::circular_buffer::tests::test_iter ... ok
...

test result: ok. 142 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.16s    

   Doc-tests algorithm

running 147 tests

test src\cache\lruk.rs - cache::lruk::LruKCache (line 65) ... ok
...

test result: ok. 147 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 11.03s

如果出錯則會指出錯誤內容。

bench測試

在Rust中的bench可以測出每次迭代的耗時，但bench模組需要啟用#![feature(test)]，即無法在stable版本的進行效能測試。
我們需要安裝nightly版本，那麼我們執行

rustup install nightly

如果需要在國內加速可以設定

$ENV:RUSTUP_DIST_SERVER='https://mirrors.ustc.edu.cn/rust-static' 
$ENV:RUSTUP_UPDATE_ROOT='https://mirrors.ustc.edu.cn/rust-static/rustup'

安裝完之後我們可以用臨時啟用nightly版本進行執行，當前我們建立了benches/lru.rs檔案
以下是bench的部分內容

#![feature(test)]

extern crate test;

use algorithm::{ArcCache, LfuCache, LruCache, LruKCache};
use test::Bencher;

static BENCH_SIZE: usize = 10000;

macro_rules! do_test_bench {
    ($cache: expr) => {
        for i in 0..BENCH_SIZE {
            $cache.insert(i, i);
            $cache.get(&i);
        }
    };
}

#[bench]
fn calc_lru(b: &mut Bencher) {
    b.iter(|| {
        let mut lru = LruCache::new(BENCH_SIZE / 2);
        do_test_bench!(lru);
    })
}

我們可以執行來進行bench測試

rustup run nightly cargo bench --bench lru

測試結果可以看出執行時間的變化

running 4 tests
test calc_arc  ... bench:   4,361,427.70 ns/iter (+/- 983,661.07)
test calc_lfu  ... bench:   3,170,039.17 ns/iter (+/- 571,925.64)
test calc_lru  ... bench:   1,306,854.55 ns/iter (+/- 198,070.97)
test calc_lruk ... bench:   1,282,446.16 ns/iter (+/- 226,388.14)

但是我們無法看出命中率這些引數，單純時間的消耗並快取結構並不公平。

測試命中率

我們將從速度和命中率兩個維度來衡量，但是資料集目前不是很優，看不到Lfu及Arc的大優勢。
完整程式碼放置在：https://github.com/tickbh/algorithm-rs/blob/master/examples/bench_lru.rs

順序的資料集

插入資料的時候就快速獲取該資料

名字 耗時 命中率
LruCache 4121 100.00%
LruKCache 3787 100.00%
LfuCache 12671 100.00%
ArcCache 13953 100.00%

前部分資料相對高頻

插入資料的時候就獲取之前插入的隨機資料

名字 耗時 命中率
LruCache 3311 77.27%
LruKCache 4040 77.47%
LfuCache 10268 93.41%
ArcCache 10907 89.92%

相對來說，在非高頻的場景中，Lfu需要維護頻次的列表資訊，耗時會Lru高很多，但是高頻的訪問場景中命中率的提高相對於cpu的消耗是可以接受的。

此處編寫測試的時候不想大量的重複程式碼，且我們的例項並沒有trait化，此處我們用的是運用宏處理來指的處理：

macro_rules! do_test_bench {
    ($name: expr, $cache: expr, $num: expr, $evict: expr, $data: expr) => {
        let mut cost = vec![];
        let now = Instant::now();
        let mut all = 0;
        let mut hit = 0;
        for v in $data {
            if v.1 == 0 {
                all += 1;
                if $cache.get(&v.0).is_some() {
                    hit += 1;
                }
            } else {
                $cache.insert(v.0, v.1);
            }
        }
        cost.push(now.elapsed().as_micros());
        println!("|{}|{}|{:.2}%|", $name, cost.iter().map(|v| v.to_string()).collect::<Vec<_>>().join("\t"), hit as f64 * 100.0 / all as f64);
    };
}

後續呼叫均可呼叫該宏進行處理：

fn do_bench(num: usize) {
    let evict = num * 2;
    let mut lru = LruCache::<usize, usize, RandomState>::new(num);
    let mut lruk = LruKCache::<usize, usize, RandomState>::new(num);
    let mut lfu = LfuCache::<usize, usize, RandomState>::new(num);
    let mut arc = ArcCache::<usize, usize, RandomState>::new(num / 2);
    println!("|名字|耗時|命中率|");
    println!("|---|---|---|");
    // let data = build_freq_data(evict);
    let data = build_high_freq_data(evict);
    // let data = build_order_data(evict);
    do_test_bench!("LruCache", lru, num, evict, &data);
    do_test_bench!("LruKCache", lruk, num, evict, &data);
    do_test_bench!("LfuCache", lfu, num, evict, &data);
    do_test_bench!("ArcCache", arc, num, evict, &data);
}

進行資料最佳化

編寫程式碼儘量的不要過早最佳化，先實現完整功能，然後再根據火焰圖耗時佔比來進行熱點函式最佳化。所以此時我們需要實現火焰圖的顯示：

安裝火焰圖https://github.com/flamegraph-rs/flamegraph

cargo install flamegraph

在這裡我使用的wsl啟用的debian系統，安裝perf

sudo apt install -y linux-perf

然後安裝完之後就可以執行：

cargo flamegraph --example bench_lru

如果出現以下提前錯誤，則證明沒有正確的連線perf版本，可以複製一個或者建一個軟連線

/usr/bin/perf: line 13: exec: perf_5.15.133: not found
E: linux-perf-5.15.133 is not installed.

那麼用如下的解決方案：

cp /usr/bin/perf_5.10 /usr/bin/perf_5.15.133

如果是macOs需要安裝dtrace,如果未安裝直接進行安裝即可

brew install dtrace

此處需注意，macOs許可權控制，需要用sudo許可權。

然後執行完之後就可以得到一個flamegraph.svg的火焰圖就可以檢視耗時的程式了。

總結

好的測試用例及效能測試是對一個庫的穩定及優秀的重要標準，儘量的覆蓋全的單元測試，能及早的發現bug，使程式更穩定。

相關文章