Skip to main content

vibe/extension_registry/
gpu_inference_providers.rs

1//! Stage S6 (`VS03-12`) GPU compute (`EtalonGpuComputeProvider`, re-exported from `etalon-vibe`)
2//! and governed inference (`GovernedInferenceProvider`) extension providers with canonical
3//! contract digests and direct-call reference oracles.
4
5pub use etalon_vibe::{
6    oracle_rmsnorm_f32 as oracle_gpu_rmsnorm_f32, oracle_rope_f32 as oracle_gpu_rope_f32,
7    EtalonGpuComputeProvider,
8};
9
10/// Direct-call oracle for `gpu::compute::affine_f32`.
11#[inline]
12pub fn oracle_gpu_affine_f32(x: [f32; 4], scale: f32, bias: f32) -> [f32; 4] {
13    [
14        x[0] * scale + bias,
15        x[1] * scale + bias,
16        x[2] * scale + bias,
17        x[3] * scale + bias,
18    ]
19}
20
21/// Direct-call oracle for `gpu::compute::gemv4_f32`.
22#[inline]
23pub fn oracle_gpu_gemv4_f32(mat: [f32; 16], vec4: [f32; 4]) -> [f32; 4] {
24    etalon_vibe::oracle_gemv4_f32(&mat, &vec4).unwrap_or([0.0; 4])
25}
26
27/// Direct-call oracle for `gpu::compute::topk2_f32`.
28#[inline]
29pub fn oracle_gpu_topk2_f32(scores: &[f32]) -> [f32; 2] {
30    etalon_vibe::oracle_topk2_f32(scores).unwrap_or([f32::NEG_INFINITY; 2])
31}
32
33use vibescript_abi::{
34    q_hash, q_hash_str, BorrowedSliceView, CallerOutputSlice, CanonicalIri, ContractVersionAxes,
35    DeterminismGuarantee, EffectSet, FuncDescriptor, NQuin48, OntologicalContract, ParamSpec,
36    PrimitiveKind, ProviderDescriptor, ResourceEnvelope, ReversibilityKind, SemVer64, StableFuncId,
37    SubNamespaceDescriptor, TargetProfileMask, VibeNamespaceProvider, VibeTrap,
38};
39
40const INFER_TARGETS: TargetProfileMask = TargetProfileMask(
41    TargetProfileMask::ALL_CPU.0 | TargetProfileMask::GPU_COMPUTE.0,
42);
43
44// ---------------------------------------------------------------------------
45// GovernedInferenceProvider (VS03-12)
46// ---------------------------------------------------------------------------
47
48const RMS_NORM_PARAMS: &[ParamSpec] = &[
49    ParamSpec::slice("x", PrimitiveKind::F64, 4, 4),
50    ParamSpec::slice("weight", PrimitiveKind::F64, 4, 4),
51    ParamSpec::scalar("eps", PrimitiveKind::F64),
52];
53
54const SOFTMAX_PARAMS: &[ParamSpec] = &[ParamSpec::slice("logits", PrimitiveKind::F64, 4, 4)];
55
56const TOKEN_STEP_PARAMS: &[ParamSpec] = &[
57    ParamSpec::slice("logits", PrimitiveKind::F64, 4, 4),
58    ParamSpec::scalar("kv_state_hash", PrimitiveKind::U64),
59    ParamSpec::scalar("step_index", PrimitiveKind::U64),
60];
61
62const RMS_ENV: ResourceEnvelope = ResourceEnvelope::hot_zero_heap(48, 32);
63const SOFTMAX_ENV: ResourceEnvelope = ResourceEnvelope::hot_zero_heap(48, 32);
64const TOKEN_STEP_EFFECTS: EffectSet =
65    EffectSet::HARDWARE_IO.union(EffectSet::GRAPH_MUTATE);
66const TOKEN_STEP_ENV: ResourceEnvelope = ResourceEnvelope {
67    max_ticks: 64,
68    max_scratch_bytes: 0,
69    max_vram_bytes: 128,
70    max_output_bytes: 24,
71    max_spawned_tasks: 0,
72    flags: 0,
73};
74
75const INFER_ACTIVATION_FUNCS: &[FuncDescriptor] = &[
76    FuncDescriptor {
77        name: "rms_norm_f64",
78        canonical_iri: CanonicalIri::new(
79            "https://qualiadb.org/ext/qualia/inference/activations/rms_norm_f64",
80        ),
81        stable_id: StableFuncId::new(0, 0),
82        params: RMS_NORM_PARAMS,
83        output_kind: PrimitiveKind::F64,
84        required_output_elems: 4,
85        effects: EffectSet::PURE_COMPUTE,
86        determinism: DeterminismGuarantee::DeterministicTolerance,
87        reversibility: ReversibilityKind::PureNoState,
88        envelope: RMS_ENV,
89        contract: OntologicalContract {
90            contract_digest: OntologicalContract::canonical_digest(
91                q_hash_str("https://qualiadb.org/ext/qualia/inference/activations/rms_norm_f64"),
92                StableFuncId::new(0, 0),
93                q_hash_str("(f64[4],f64[4],f64)->f64[4]"),
94                EffectSet::PURE_COMPUTE,
95                DeterminismGuarantee::DeterministicTolerance,
96                ReversibilityKind::PureNoState,
97                RMS_ENV,
98                (0, 1),
99                (1, 1),
100                (2, 1),
101            ),
102            schema_hash: q_hash_str("(f64[4],f64[4],f64)->f64[4]"),
103            precondition_quin_span: (0, 1),
104            postcondition_quin_span: (1, 1),
105            invariant_quin_span: (2, 1),
106        },
107    },
108    FuncDescriptor {
109        name: "softmax_f64",
110        canonical_iri: CanonicalIri::new(
111            "https://qualiadb.org/ext/qualia/inference/activations/softmax_f64",
112        ),
113        stable_id: StableFuncId::new(0, 1),
114        params: SOFTMAX_PARAMS,
115        output_kind: PrimitiveKind::F64,
116        required_output_elems: 4,
117        effects: EffectSet::PURE_COMPUTE,
118        determinism: DeterminismGuarantee::DeterministicTolerance,
119        reversibility: ReversibilityKind::PureNoState,
120        envelope: SOFTMAX_ENV,
121        contract: OntologicalContract {
122            contract_digest: OntologicalContract::canonical_digest(
123                q_hash_str("https://qualiadb.org/ext/qualia/inference/activations/softmax_f64"),
124                StableFuncId::new(0, 1),
125                q_hash_str("(f64[4])->f64[4]"),
126                EffectSet::PURE_COMPUTE,
127                DeterminismGuarantee::DeterministicTolerance,
128                ReversibilityKind::PureNoState,
129                SOFTMAX_ENV,
130                (0, 1),
131                (1, 1),
132                (2, 1),
133            ),
134            schema_hash: q_hash_str("(f64[4])->f64[4]"),
135            precondition_quin_span: (0, 1),
136            postcondition_quin_span: (1, 1),
137            invariant_quin_span: (2, 1),
138        },
139    },
140];
141
142const INFER_DECODE_FUNCS: &[FuncDescriptor] = &[FuncDescriptor {
143    name: "governed_token_step",
144    canonical_iri: CanonicalIri::new(
145        "https://qualiadb.org/ext/qualia/inference/decode/governed_token_step",
146    ),
147    stable_id: StableFuncId::new(1, 0),
148    params: TOKEN_STEP_PARAMS,
149    output_kind: PrimitiveKind::U64,
150    required_output_elems: 3,
151    effects: TOKEN_STEP_EFFECTS,
152    determinism: DeterminismGuarantee::DeterministicExact,
153    reversibility: ReversibilityKind::StagedReversible,
154    envelope: TOKEN_STEP_ENV,
155    contract: OntologicalContract {
156        contract_digest: OntologicalContract::canonical_digest(
157            q_hash_str("https://qualiadb.org/ext/qualia/inference/decode/governed_token_step"),
158            StableFuncId::new(1, 0),
159            q_hash_str("(f64[4],u64,u64)->u64[3]"),
160            TOKEN_STEP_EFFECTS,
161            DeterminismGuarantee::DeterministicExact,
162            ReversibilityKind::StagedReversible,
163            TOKEN_STEP_ENV,
164            (0, 1),
165            (1, 1),
166            (2, 1),
167        ),
168        schema_hash: q_hash_str("(f64[4],u64,u64)->u64[3]"),
169        precondition_quin_span: (0, 1),
170        postcondition_quin_span: (1, 1),
171        invariant_quin_span: (2, 1),
172    },
173}];
174
175const INFER_SUB_NAMESPACES: &[SubNamespaceDescriptor] = &[
176    SubNamespaceDescriptor {
177        name: "activations",
178        sub_id: 0,
179        functions: INFER_ACTIVATION_FUNCS,
180    },
181    SubNamespaceDescriptor {
182        name: "decode",
183        sub_id: 1,
184        functions: INFER_DECODE_FUNCS,
185    },
186];
187
188const INFER_DESCRIPTOR: ProviderDescriptor = ProviderDescriptor {
189    canonical_iri: CanonicalIri::new("https://qualiadb.org/ext/qualia/inference"),
190    short_alias: "infer",
191    versions: ContractVersionAxes::v0_3_default(
192        SemVer64::release(0, 3, 0),
193        SemVer64::release(0, 1, 0),
194    ),
195    supported_targets: INFER_TARGETS,
196    sub_namespaces: INFER_SUB_NAMESPACES,
197    max_ontology_quins: 16,
198};
199
200const INFER_ONTOLOGY_QUINS: &[NQuin48] = &[
201    NQuin48::from_parts(
202        q_hash_str("https://qualiadb.org/ext/qualia/inference"),
203        q_hash_str("https://qualiadb.org/schema/vibe#hasPrecondition"),
204        q_hash_str("https://qualiadb.org/schema/vibe#PerTokenSentinelTicketActive"),
205        q_hash_str("https://qualiadb.org/context/public"),
206        1,
207    ),
208    NQuin48::from_parts(
209        q_hash_str("https://qualiadb.org/ext/qualia/inference"),
210        q_hash_str("https://qualiadb.org/schema/vibe#hasPostcondition"),
211        q_hash_str("https://qualiadb.org/schema/vibe#NormalizedDistributionOrRolledBackKv"),
212        q_hash_str("https://qualiadb.org/context/public"),
213        2,
214    ),
215    NQuin48::from_parts(
216        q_hash_str("https://qualiadb.org/ext/qualia/inference"),
217        q_hash_str("https://qualiadb.org/schema/vibe#preservesInvariant"),
218        q_hash_str("https://qualiadb.org/schema/vibe#ZeroUncommittedTokenLeakage"),
219        q_hash_str("https://qualiadb.org/context/public"),
220        3,
221    ),
222];
223
224/// Governed inference extension provider (`VS03-12`).
225#[derive(Debug, Clone, Copy, Default)]
226pub struct GovernedInferenceProvider;
227
228impl VibeNamespaceProvider for GovernedInferenceProvider {
229    fn descriptor(&self) -> &'static ProviderDescriptor {
230        &INFER_DESCRIPTOR
231    }
232
233    fn static_ontology_nquins(&self) -> &'static [NQuin48] {
234        INFER_ONTOLOGY_QUINS
235    }
236
237    fn call(
238        &self,
239        stable_id: StableFuncId,
240        inputs: &[BorrowedSliceView<'_>],
241        output: &mut CallerOutputSlice<'_>,
242    ) -> Result<u64, VibeTrap> {
243        match (stable_id.sub_namespace_id, stable_id.func_id) {
244            (0, 0) => {
245                // activations::rms_norm_f64
246                let mut x = [0.0f64; 4];
247                let mut w = [0.0f64; 4];
248                for i in 0..4 {
249                    x[i] = inputs[0].read_f64_le(i)?;
250                    w[i] = inputs[1].read_f64_le(i)?;
251                    if !x[i].is_finite() || !w[i].is_finite() {
252                        return Err(VibeTrap::NumericalDomainError);
253                    }
254                }
255                let eps = inputs[2].read_f64_le(0)?;
256                if !eps.is_finite() || eps < 0.0 {
257                    return Err(VibeTrap::NumericalDomainError);
258                }
259                let normed = oracle_rms_norm_f64(x, w, eps);
260                for &val in &normed {
261                    output.push_f64_le(val)?;
262                }
263                Ok(28)
264            }
265            (0, 1) => {
266                // activations::softmax_f64
267                let mut logits = [0.0f64; 4];
268                for (i, slot) in logits.iter_mut().enumerate() {
269                    let v = inputs[0].read_f64_le(i)?;
270                    if !v.is_finite() {
271                        return Err(VibeTrap::NumericalDomainError);
272                    }
273                    *slot = v;
274                }
275                let probs = oracle_softmax_f64(logits);
276                for &p in &probs {
277                    output.push_f64_le(p)?;
278                }
279                Ok(24)
280            }
281            (1, 0) => {
282                // decode::governed_token_step
283                let mut logits = [0.0f64; 4];
284                for (i, slot) in logits.iter_mut().enumerate() {
285                    let v = inputs[0].read_f64_le(i)?;
286                    if !v.is_finite() {
287                        return Err(VibeTrap::NumericalDomainError);
288                    }
289                    *slot = v;
290                }
291                let kv_state_hash = inputs[1].read_u64_le(0)?;
292                let step_index = inputs[2].read_u64_le(0)?;
293                let (token_id, next_kv_hash, next_step) =
294                    oracle_governed_token_step(logits, kv_state_hash, step_index);
295                output.push_u64_le(token_id)?;
296                output.push_u64_le(next_kv_hash)?;
297                output.push_u64_le(next_step)?;
298                Ok(36)
299            }
300            _ => Err(VibeTrap::FunctionNotFound),
301        }
302    }
303}
304
305/// Direct-call oracle for `infer::activations::rms_norm_f64`.
306#[inline]
307pub fn oracle_rms_norm_f64(x: [f64; 4], weight: [f64; 4], eps: f64) -> [f64; 4] {
308    let mean_sq = 0.25 * (x[0] * x[0] + x[1] * x[1] + x[2] * x[2] + x[3] * x[3]);
309    let inv_rms = 1.0 / (mean_sq + eps).sqrt();
310    [
311        x[0] * inv_rms * weight[0],
312        x[1] * inv_rms * weight[1],
313        x[2] * inv_rms * weight[2],
314        x[3] * inv_rms * weight[3],
315    ]
316}
317
318/// Direct-call oracle for `infer::activations::softmax_f64`.
319#[inline]
320pub fn oracle_softmax_f64(logits: [f64; 4]) -> [f64; 4] {
321    let max_l = logits[0].max(logits[1]).max(logits[2]).max(logits[3]);
322    let e0 = (logits[0] - max_l).exp();
323    let e1 = (logits[1] - max_l).exp();
324    let e2 = (logits[2] - max_l).exp();
325    let e3 = (logits[3] - max_l).exp();
326    let inv_sum = 1.0 / (e0 + e1 + e2 + e3);
327    [e0 * inv_sum, e1 * inv_sum, e2 * inv_sum, e3 * inv_sum]
328}
329
330/// Direct-call oracle for `infer::decode::governed_token_step`.
331#[inline]
332pub fn oracle_governed_token_step(
333    logits: [f64; 4],
334    kv_state_hash: u64,
335    step_index: u64,
336) -> (u64, u64, u64) {
337    let mut best_idx = 0usize;
338    let mut best_val = logits[0];
339    let mut i = 1;
340    while i < 4 {
341        if logits[i] > best_val {
342            best_val = logits[i];
343            best_idx = i;
344        }
345        i += 1;
346    }
347    let token_id = best_idx as u64;
348    let mut step_bytes = [0u8; 16];
349    step_bytes[..8].copy_from_slice(&kv_state_hash.to_le_bytes());
350    step_bytes[8..16].copy_from_slice(&token_id.to_le_bytes());
351    let next_kv_hash = q_hash(&step_bytes) ^ step_index.rotate_left(7);
352    (token_id, next_kv_hash, step_index.saturating_add(1))
353}