Struct WeightedCache 

pub struct WeightedCache<K, V> { /* private fields */ }

Implementations

impl<K: Hash + Eq + Clone, V> WeightedCache<K, V>

pub fn with_capacity_bytes<F>(capacity_bytes: usize, size_of: F) -> Self

where F: Fn(&V) -> usize + 'static,

Examples found in repository

examples/sample_app.rs (line 154)

fn weighted_byte_budget() {
    use subms_block_cache::WeightedCache;
    println!("\n== weighted: byte-budgeted page cache ==");
    let mut cache: WeightedCache<u64, Vec<u8>> =
        WeightedCache::with_capacity_bytes(4096, |page: &Vec<u8>| page.len());

    let mut evicted_total = 0;
    for id in 0u64..64 {
        let size = 128 + (id as usize % 8) * 128;
        evicted_total += cache.put(id, vec![0u8; size]).len();
    }
    println!(
        "  used {} / 4096 bytes, {} pages, {evicted_total} evicted",
        cache.used_bytes(),
        cache.len()
    );
    assert!(cache.used_bytes() <= 4096, "byte budget is a hard bound");

    let too_big = cache.put(999, vec![0u8; 8192]);
    assert_eq!(too_big.len(), 1, "oversized page is rejected, not admitted");
    assert!(cache.get(&999).is_none());
}

examples/perf_features.rs (line 188)

fn main() -> io::Result<()> {
    let canon = SIZES[SIZES.len() - 1];

    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("..")
        .join(".subms")
        .join("features")
        .join("rust.json");
    let existing = std::fs::read_to_string(&path).unwrap_or_default();
    let mut manifest = SubMsFeatureManifest::load_str("rust", &existing);
    // Stamp the box these numbers came from. The bench runs wherever it is
    // invoked, so an unstamped manifest is indistinguishable from a fleet
    // capture; the renderer will not publish one it cannot attribute.
    let (source, instance) = SubMsP99Source::from_env();
    manifest.set_p99_source(source, instance.as_deref());

    // ---------- base (clock-sweep): the baseline, not a feature ----------
    // Every feature is classified against this. A variant whose lookup lands
    // within a whisker of the base is a capability, not a latency change, and
    // classify_feature says so rather than calling it hot-path by default.
    // The baseline is a p50, because the sweep values are p50s. Handing
    // classify_feature a base p99 against p50 sweep points compares two
    // different statistics: the p50 sits below the p99 almost by construction,
    // so every feature reads as "within 10% of base" and lands auxiliary.
    let base_p50 = {
        use subms_block_cache::BlockCache;
        let mut c: BlockCache<u32, u64> = BlockCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (p50, _) = get_hit(canon, |key| c.get(&key).is_some());
        p50
    };

    // ---------- arc: adaptive replacement, recency + frequency lists ----------
    #[cfg(feature = "arc")]
    {
        use subms_block_cache::ArcCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: ArcCache<u32, u64> = ArcCache::with_capacity(n);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: ArcCache<u32, u64> = ArcCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("arc", cat, &p99, &reason);
    }

    // ---------- tinylfu: frequency-sketch admission ----------
    #[cfg(feature = "tinylfu")]
    {
        use subms_block_cache::TinyLfuCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: TinyLfuCache<u32, u64> = TinyLfuCache::with_capacity(n);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: TinyLfuCache<u32, u64> = TinyLfuCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("tinylfu", cat, &p99, &reason);
    }

    // ---------- weighted: a byte budget rather than a slot count ----------
    #[cfg(feature = "weighted")]
    {
        use subms_block_cache::WeightedCache;
        // 1 byte per entry so capacity_bytes == slot capacity; eviction behaves
        // like the base cache, which isolates the weight bookkeeping itself.
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: WeightedCache<u32, u64> =
                    WeightedCache::with_capacity_bytes(n, |_v: &u64| 1);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: WeightedCache<u32, u64> =
            WeightedCache::with_capacity_bytes(canon, |_v: &u64| 1);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            let _ = c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("weighted", cat, &p99, &reason);
    }

    // ---------- concurrent-shards: measured single-threaded ----------
    // Uncontended on purpose. This isolates the sharding INDIRECTION from the
    // contention it exists to relieve; a multi-threaded number here would say
    // more about the thread count than about the feature.
    #[cfg(feature = "concurrent-shards")]
    {
        use subms_block_cache::ShardedCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let c: ShardedCache<u32, u64> = ShardedCache::with_capacity(n, 16);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let c: ShardedCache<u32, u64> = ShardedCache::with_capacity(canon, 16);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("concurrent-shards", cat, &p99, &reason);
    }

    // ---------- metrics: hit/miss counters on the lookup path ----------
    #[cfg(feature = "metrics")]
    {
        use subms_block_cache::MetricsCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: MetricsCache<u32, u64> = MetricsCache::with_capacity(n);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: MetricsCache<u32, u64> = MetricsCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("metrics", cat, &p99, &reason);
    }

    std::fs::create_dir_all(path.parent().unwrap())?;
    std::fs::write(&path, manifest.to_json())?;
    io::stdout().write_all(manifest.to_json().as_bytes())?;
    Ok(())
}

pub fn capacity_bytes(&self) -> usize

pub fn used_bytes(&self) -> usize

Examples found in repository

examples/sample_app.rs (line 163)

fn weighted_byte_budget() {
    use subms_block_cache::WeightedCache;
    println!("\n== weighted: byte-budgeted page cache ==");
    let mut cache: WeightedCache<u64, Vec<u8>> =
        WeightedCache::with_capacity_bytes(4096, |page: &Vec<u8>| page.len());

    let mut evicted_total = 0;
    for id in 0u64..64 {
        let size = 128 + (id as usize % 8) * 128;
        evicted_total += cache.put(id, vec![0u8; size]).len();
    }
    println!(
        "  used {} / 4096 bytes, {} pages, {evicted_total} evicted",
        cache.used_bytes(),
        cache.len()
    );
    assert!(cache.used_bytes() <= 4096, "byte budget is a hard bound");

    let too_big = cache.put(999, vec![0u8; 8192]);
    assert_eq!(too_big.len(), 1, "oversized page is rejected, not admitted");
    assert!(cache.get(&999).is_none());
}

pub fn len(&self) -> usize

Examples found in repository

examples/sample_app.rs (line 164)

fn weighted_byte_budget() {
    use subms_block_cache::WeightedCache;
    println!("\n== weighted: byte-budgeted page cache ==");
    let mut cache: WeightedCache<u64, Vec<u8>> =
        WeightedCache::with_capacity_bytes(4096, |page: &Vec<u8>| page.len());

    let mut evicted_total = 0;
    for id in 0u64..64 {
        let size = 128 + (id as usize % 8) * 128;
        evicted_total += cache.put(id, vec![0u8; size]).len();
    }
    println!(
        "  used {} / 4096 bytes, {} pages, {evicted_total} evicted",
        cache.used_bytes(),
        cache.len()
    );
    assert!(cache.used_bytes() <= 4096, "byte budget is a hard bound");

    let too_big = cache.put(999, vec![0u8; 8192]);
    assert_eq!(too_big.len(), 1, "oversized page is rejected, not admitted");
    assert!(cache.get(&999).is_none());
}

pub fn is_empty(&self) -> bool

pub fn get(&mut self, key: &K) -> Option<&V>

Examples found in repository

examples/sample_app.rs (line 170)

fn weighted_byte_budget() {
    use subms_block_cache::WeightedCache;
    println!("\n== weighted: byte-budgeted page cache ==");
    let mut cache: WeightedCache<u64, Vec<u8>> =
        WeightedCache::with_capacity_bytes(4096, |page: &Vec<u8>| page.len());

    let mut evicted_total = 0;
    for id in 0u64..64 {
        let size = 128 + (id as usize % 8) * 128;
        evicted_total += cache.put(id, vec![0u8; size]).len();
    }
    println!(
        "  used {} / 4096 bytes, {} pages, {evicted_total} evicted",
        cache.used_bytes(),
        cache.len()
    );
    assert!(cache.used_bytes() <= 4096, "byte budget is a hard bound");

    let too_big = cache.put(999, vec![0u8; 8192]);
    assert_eq!(too_big.len(), 1, "oversized page is rejected, not admitted");
    assert!(cache.get(&999).is_none());
}

examples/perf_features.rs (line 192)

fn main() -> io::Result<()> {
    let canon = SIZES[SIZES.len() - 1];

    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("..")
        .join(".subms")
        .join("features")
        .join("rust.json");
    let existing = std::fs::read_to_string(&path).unwrap_or_default();
    let mut manifest = SubMsFeatureManifest::load_str("rust", &existing);
    // Stamp the box these numbers came from. The bench runs wherever it is
    // invoked, so an unstamped manifest is indistinguishable from a fleet
    // capture; the renderer will not publish one it cannot attribute.
    let (source, instance) = SubMsP99Source::from_env();
    manifest.set_p99_source(source, instance.as_deref());

    // ---------- base (clock-sweep): the baseline, not a feature ----------
    // Every feature is classified against this. A variant whose lookup lands
    // within a whisker of the base is a capability, not a latency change, and
    // classify_feature says so rather than calling it hot-path by default.
    // The baseline is a p50, because the sweep values are p50s. Handing
    // classify_feature a base p99 against p50 sweep points compares two
    // different statistics: the p50 sits below the p99 almost by construction,
    // so every feature reads as "within 10% of base" and lands auxiliary.
    let base_p50 = {
        use subms_block_cache::BlockCache;
        let mut c: BlockCache<u32, u64> = BlockCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (p50, _) = get_hit(canon, |key| c.get(&key).is_some());
        p50
    };

    // ---------- arc: adaptive replacement, recency + frequency lists ----------
    #[cfg(feature = "arc")]
    {
        use subms_block_cache::ArcCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: ArcCache<u32, u64> = ArcCache::with_capacity(n);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: ArcCache<u32, u64> = ArcCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("arc", cat, &p99, &reason);
    }

    // ---------- tinylfu: frequency-sketch admission ----------
    #[cfg(feature = "tinylfu")]
    {
        use subms_block_cache::TinyLfuCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: TinyLfuCache<u32, u64> = TinyLfuCache::with_capacity(n);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: TinyLfuCache<u32, u64> = TinyLfuCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("tinylfu", cat, &p99, &reason);
    }

    // ---------- weighted: a byte budget rather than a slot count ----------
    #[cfg(feature = "weighted")]
    {
        use subms_block_cache::WeightedCache;
        // 1 byte per entry so capacity_bytes == slot capacity; eviction behaves
        // like the base cache, which isolates the weight bookkeeping itself.
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: WeightedCache<u32, u64> =
                    WeightedCache::with_capacity_bytes(n, |_v: &u64| 1);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: WeightedCache<u32, u64> =
            WeightedCache::with_capacity_bytes(canon, |_v: &u64| 1);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            let _ = c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("weighted", cat, &p99, &reason);
    }

    // ---------- concurrent-shards: measured single-threaded ----------
    // Uncontended on purpose. This isolates the sharding INDIRECTION from the
    // contention it exists to relieve; a multi-threaded number here would say
    // more about the thread count than about the feature.
    #[cfg(feature = "concurrent-shards")]
    {
        use subms_block_cache::ShardedCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let c: ShardedCache<u32, u64> = ShardedCache::with_capacity(n, 16);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let c: ShardedCache<u32, u64> = ShardedCache::with_capacity(canon, 16);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("concurrent-shards", cat, &p99, &reason);
    }

    // ---------- metrics: hit/miss counters on the lookup path ----------
    #[cfg(feature = "metrics")]
    {
        use subms_block_cache::MetricsCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: MetricsCache<u32, u64> = MetricsCache::with_capacity(n);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: MetricsCache<u32, u64> = MetricsCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("metrics", cat, &p99, &reason);
    }

    std::fs::create_dir_all(path.parent().unwrap())?;
    std::fs::write(&path, manifest.to_json())?;
    io::stdout().write_all(manifest.to_json().as_bytes())?;
    Ok(())
}

pub fn put(&mut self, key: K, value: V) -> Vec<(K, V)>

Insert or update. May evict multiple entries to fit the new one. Returns a Vec of evicted (key, value) pairs in eviction order; empty if nothing was evicted.

Examples found in repository

examples/sample_app.rs (line 159)

fn weighted_byte_budget() {
    use subms_block_cache::WeightedCache;
    println!("\n== weighted: byte-budgeted page cache ==");
    let mut cache: WeightedCache<u64, Vec<u8>> =
        WeightedCache::with_capacity_bytes(4096, |page: &Vec<u8>| page.len());

    let mut evicted_total = 0;
    for id in 0u64..64 {
        let size = 128 + (id as usize % 8) * 128;
        evicted_total += cache.put(id, vec![0u8; size]).len();
    }
    println!(
        "  used {} / 4096 bytes, {} pages, {evicted_total} evicted",
        cache.used_bytes(),
        cache.len()
    );
    assert!(cache.used_bytes() <= 4096, "byte budget is a hard bound");

    let too_big = cache.put(999, vec![0u8; 8192]);
    assert_eq!(too_big.len(), 1, "oversized page is rejected, not admitted");
    assert!(cache.get(&999).is_none());
}

examples/perf_features.rs (line 190)

fn main() -> io::Result<()> {
    let canon = SIZES[SIZES.len() - 1];

    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("..")
        .join(".subms")
        .join("features")
        .join("rust.json");
    let existing = std::fs::read_to_string(&path).unwrap_or_default();
    let mut manifest = SubMsFeatureManifest::load_str("rust", &existing);
    // Stamp the box these numbers came from. The bench runs wherever it is
    // invoked, so an unstamped manifest is indistinguishable from a fleet
    // capture; the renderer will not publish one it cannot attribute.
    let (source, instance) = SubMsP99Source::from_env();
    manifest.set_p99_source(source, instance.as_deref());

    // ---------- base (clock-sweep): the baseline, not a feature ----------
    // Every feature is classified against this. A variant whose lookup lands
    // within a whisker of the base is a capability, not a latency change, and
    // classify_feature says so rather than calling it hot-path by default.
    // The baseline is a p50, because the sweep values are p50s. Handing
    // classify_feature a base p99 against p50 sweep points compares two
    // different statistics: the p50 sits below the p99 almost by construction,
    // so every feature reads as "within 10% of base" and lands auxiliary.
    let base_p50 = {
        use subms_block_cache::BlockCache;
        let mut c: BlockCache<u32, u64> = BlockCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (p50, _) = get_hit(canon, |key| c.get(&key).is_some());
        p50
    };

    // ---------- arc: adaptive replacement, recency + frequency lists ----------
    #[cfg(feature = "arc")]
    {
        use subms_block_cache::ArcCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: ArcCache<u32, u64> = ArcCache::with_capacity(n);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: ArcCache<u32, u64> = ArcCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("arc", cat, &p99, &reason);
    }

    // ---------- tinylfu: frequency-sketch admission ----------
    #[cfg(feature = "tinylfu")]
    {
        use subms_block_cache::TinyLfuCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: TinyLfuCache<u32, u64> = TinyLfuCache::with_capacity(n);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: TinyLfuCache<u32, u64> = TinyLfuCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("tinylfu", cat, &p99, &reason);
    }

    // ---------- weighted: a byte budget rather than a slot count ----------
    #[cfg(feature = "weighted")]
    {
        use subms_block_cache::WeightedCache;
        // 1 byte per entry so capacity_bytes == slot capacity; eviction behaves
        // like the base cache, which isolates the weight bookkeeping itself.
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: WeightedCache<u32, u64> =
                    WeightedCache::with_capacity_bytes(n, |_v: &u64| 1);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: WeightedCache<u32, u64> =
            WeightedCache::with_capacity_bytes(canon, |_v: &u64| 1);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            let _ = c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("weighted", cat, &p99, &reason);
    }

    // ---------- concurrent-shards: measured single-threaded ----------
    // Uncontended on purpose. This isolates the sharding INDIRECTION from the
    // contention it exists to relieve; a multi-threaded number here would say
    // more about the thread count than about the feature.
    #[cfg(feature = "concurrent-shards")]
    {
        use subms_block_cache::ShardedCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let c: ShardedCache<u32, u64> = ShardedCache::with_capacity(n, 16);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let c: ShardedCache<u32, u64> = ShardedCache::with_capacity(canon, 16);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("concurrent-shards", cat, &p99, &reason);
    }

    // ---------- metrics: hit/miss counters on the lookup path ----------
    #[cfg(feature = "metrics")]
    {
        use subms_block_cache::MetricsCache;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut c: MetricsCache<u32, u64> = MetricsCache::with_capacity(n);
                for k in 0..n as u32 {
                    c.put(k, k as u64);
                }
                let (p50, _) = get_hit(n, |key| c.get(&key).is_some());
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, Some(base_p50), None);

        let mut c: MetricsCache<u32, u64> = MetricsCache::with_capacity(canon);
        for k in 0..canon as u32 {
            c.put(k, k as u64);
        }
        let (_, get99) = get_hit(canon, |key| c.get(&key).is_some());
        let (_, put99) = put_evicting(canon, |key| {
            c.put(key, key as u64);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("get_hit".to_string(), get99);
        p99.insert("put".to_string(), put99);
        manifest.set_feature("metrics", cat, &p99, &reason);
    }

    std::fs::create_dir_all(path.parent().unwrap())?;
    std::fs::write(&path, manifest.to_json())?;
    io::stdout().write_all(manifest.to_json().as_bytes())?;
    Ok(())
}