speakrs 0.7.0

Fast Rust speaker diarization with pyannote-level accuracy and native CPU/CoreML/CUDA inference
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! Model-load advice for a device without measured kernel choices

use std::sync::Once;

use super::super::PtxTier;
use super::super::device::DeviceAttributes;
use super::super::implementation::policy::Recipe;

static HINT: Once = Once::new();

pub(super) fn log(device: &DeviceAttributes, tier: PtxTier, tune_loaded: bool) {
    if !eligible(device, tier, tune_loaded, super::super::driver_only()) {
        return;
    }

    HINT.call_once(|| {
        let name = device.name();
        let capability = device.capability();
        let (major, minor) = (capability.major, capability.minor);
        tracing::info!("No measured CUDA recipe for {name} (cc {major}.{minor}); run `speakrs cuda tune` to tune kernel choices for this GPU");
    });
}

fn eligible(
    device: &DeviceAttributes,
    tier: PtxTier,
    tune_loaded: bool,
    driver_only: bool,
) -> bool {
    !driver_only && !tune_loaded && !Recipe::measured_device(device, tier)
}

#[cfg(test)]
mod tests {
    use super::eligible;
    use crate::inference::cuda::device::test_support::Builder;
    use crate::inference::cuda::{ComputeCapability, PtxTier};

    #[test]
    fn hint_is_only_for_an_untuned_unmeasured_hybrid_device() {
        let device = Builder::new(ComputeCapability::new(9, 0))
            .name("unknown GPU")
            .build();
        assert!(eligible(&device, PtxTier::Sm80, false, false));
        assert!(!eligible(&device, PtxTier::Sm80, true, false));
        assert!(!eligible(&device, PtxTier::Sm80, false, true));
        assert!(!eligible(&device, PtxTier::Sm80, true, true));
    }

    #[test]
    fn measured_device_points_stay_silent_at_their_recipe_tier() {
        for (cc, sms, name, tier) in [
            (
                ComputeCapability::new(8, 9),
                34,
                "NVIDIA GeForce RTX 4060 Ti",
                PtxTier::Sm80,
            ),
            (
                ComputeCapability::new(12, 0),
                36,
                "NVIDIA GeForce RTX 5060 Ti",
                PtxTier::Sm80,
            ),
            (ComputeCapability::new(7, 5), 40, "Tesla T4", PtxTier::Sm75),
            (
                ComputeCapability::new(8, 0),
                108,
                "NVIDIA A100-PCIE-40GB",
                PtxTier::Sm80,
            ),
            (
                ComputeCapability::new(8, 0),
                108,
                "NVIDIA A100-SXM4-40GB",
                PtxTier::Sm80,
            ),
        ] {
            let device = Builder::new(cc).multiprocessors(sms).name(name).build();
            if !tier.is_compiled_in() {
                continue;
            }
            assert!(!eligible(&device, tier, false, false), "{name}");
            let unknown = Builder::new(cc).multiprocessors(sms + 1).name(name).build();
            assert!(eligible(&unknown, tier, false, false), "{name}");
        }
    }
}