Skip to main content

qualia_core_db/query/graph_accel/
sieve.rs

1//! Equality sieve + compact. GPU bitmask when eligible, else CPU scan.
2
3use crate::NQuin;
4
5use super::cpu::{sieve_eq_cpu, sieve_eq_indices_cpu, QuinField};
6use super::path::{gpu_available, AccelPath, AccelPolicy, GPU_SIEVE_MIN};
7
8#[derive(Debug, Clone, Copy, PartialEq, Eq)]
9pub struct SieveOutcome {
10    pub path: AccelPath,
11    pub written: usize,
12}
13
14/// Compact Quins whose `field == needle` into `out`. Returns count + path.
15pub fn sieve_eq(quins: &[NQuin], field: QuinField, needle: u64, out: &mut [NQuin]) -> SieveOutcome {
16    if quins.is_empty() || out.is_empty() {
17        return SieveOutcome {
18            path: AccelPath::Cpu,
19            written: 0,
20        };
21    }
22    let policy = AccelPolicy::from_env();
23    if policy != AccelPolicy::CpuOnly && quins.len() >= GPU_SIEVE_MIN && gpu_available() {
24        if let Some(idx) = super::gpu::sieve_eq_indices_gpu(quins, field, needle) {
25            let mut n = 0;
26            for i in idx {
27                if n >= out.len() {
28                    break;
29                }
30                let i = i as usize;
31                if i < quins.len() {
32                    out[n] = quins[i];
33                    n += 1;
34                }
35            }
36            return SieveOutcome {
37                path: AccelPath::Gpu,
38                written: n,
39            };
40        }
41    }
42    let written = sieve_eq_cpu(quins, field, needle, out);
43    SieveOutcome {
44        path: AccelPath::Cpu,
45        written,
46    }
47}
48
49/// Indices only (caller gathers). Same fallback contract.
50pub fn sieve_eq_indices(
51    quins: &[NQuin],
52    field: QuinField,
53    needle: u64,
54    out: &mut [u32],
55) -> SieveOutcome {
56    if quins.is_empty() || out.is_empty() {
57        return SieveOutcome {
58            path: AccelPath::Cpu,
59            written: 0,
60        };
61    }
62    let policy = AccelPolicy::from_env();
63    if policy != AccelPolicy::CpuOnly && quins.len() >= GPU_SIEVE_MIN && gpu_available() {
64        if let Some(idx) = super::gpu::sieve_eq_indices_gpu(quins, field, needle) {
65            let n = idx.len().min(out.len());
66            out[..n].copy_from_slice(&idx[..n]);
67            return SieveOutcome {
68                path: AccelPath::Gpu,
69                written: n,
70            };
71        }
72    }
73    let written = sieve_eq_indices_cpu(quins, field, needle, out);
74    SieveOutcome {
75        path: AccelPath::Cpu,
76        written,
77    }
78}