vyre-libs 0.7.2

vyre Category A library ecosystem - pure-IR compositions over foundation IR and primitive-owned kernels
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

//! Atomic LRU update: safely update access timestamps/priority in a shared buffer.
//!
//! Category-B composition over `AtomicOp::Max`.

use crate::region::wrap_anonymous;
use vyre_foundation::ir::{AtomicOp, BufferAccess, BufferDecl, DataType, Expr, Node, Program};
use vyre_foundation::memory_model::MemoryOrdering;

/// Build a Program that atomically updates an LRU slot.
#[must_use]
pub fn atomic_lru_update_u32(buffer: &str, index: Expr, timestamp: Expr) -> Program {
    let body = vec![
        Node::let_bind("idx", index),
        Node::let_bind("ts", timestamp),
        Node::let_bind(
            "_prev",
            Expr::Atomic {
                op: AtomicOp::Max,
                buffer: buffer.into(),
                index: Box::new(Expr::var("idx")),
                expected: None,
                value: Box::new(Expr::var("ts")),
                ordering: MemoryOrdering::SeqCst,
            },
        ),
    ];

    Program::wrapped(
        vec![BufferDecl::storage(buffer, 0, BufferAccess::ReadWrite, DataType::U32).with_count(1)],
        [1, 1, 1],
        vec![wrap_anonymous(
            "vyre-libs::math::atomic::lru_update_u32",
            body,
        )],
    )
}

inventory::submit! {
    vyre_foundation::operation::OperationRegistration {
        semantic_version: 1,
        signature: None,
        tier: vyre_foundation::operation::OperationTier::Library,
        laws: &[],
        tolerance: vyre_foundation::operation::TolerancePolicy::EXACT,
        id: "vyre-libs::math::atomic::lru_update_u32",
        build: Some(|| atomic_lru_update_u32("buffer", Expr::u32(0), Expr::u32(12345))),
        test_inputs: Some(|| {
            let to_bytes = vyre_primitives::wire::pack_u32_slice;
            vec![vec![
                to_bytes(&[0u32]), // buffer (single slot, initial value 0)
            ]]
        }),
        expected_output: Some(|| {
            let to_bytes = vyre_primitives::wire::pack_u32_slice;
            // Single lane writes timestamp 12345 into slot 0.
            vec![vec![to_bytes(&[12345u32])]]
        }),
        category: Some("math"),
    }
}