Function test_eviction_probability

src/models/lru_cache.rs:583–624

()

    #[test]
    fn test_eviction_probability() {
        let prob = ProbEviction::new(f16::from_f32_const(0.03125));

        // Without wraparound
        let global_counter = 1000;
        let results = (1..=global_counter)
            .map(|n| prob.eviction_probability(global_counter, n))
            .collect::<Vec<f32>>();
        // Check that the eviction probability reduces with decrease
        // in counter age, i.e. the results vector is sorted in
        // descending order.
        assert!(results.as_slice().windows(2).all(|w| w[0] >= w[1]));

        // With wraparound
        let global_counter = 2147483647_u32;
        let mut rng = rand::thread_rng();
        // Generate some counter values before wraparound. These will
        // be > global_counter and < u32::MAX
        let mut counter_vals: Vec<u32> = gen_rand_nums(&mut rng, 100, global_counter, u32::MAX);
        counter_vals.sort();
        // Generate some counter values after wraparound. These will
        // be > 0 and < global_counter
        let mut after_wraparound: Vec<u32> = gen_rand_nums(&mut rng, 100, 0, global_counter);
        after_wraparound.sort();
        // As the global counter is very large, add some known values
        // closer to the global counter
        let mut recent: Vec<u32> = (1..=100).map(|n| global_counter - n).collect();
        recent.sort();

        // Concatenate the above inputs in order
        counter_vals.append(&mut after_wraparound);
        counter_vals.append(&mut recent);

        let results = counter_vals
            .into_iter()
            .map(|n| prob.eviction_probability(global_counter, n))
            .collect::<Vec<f32>>();
        // Check that the eviction probability reduces with increase
        // in counter value, i.e. the results vector is sorted in
        // descending order.
        assert!(results.as_slice().windows(2).all(|w| w[0] >= w[1]));
    }

    #[test]
    fn test_eviction_index() {