kowito-json 0.2.19

A high-performance zero-decode JSON parser using SIMD, ARM NEON PMULL, and schema JIT binding.
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

#[cfg(target_arch = "aarch64")]
use core::arch::asm;

/// The Apple Matrix Coprocessor (AMX) Experimental Kernel
/// Intended to strip whitespace (` `, `\n`, `\t`, `\r`) from 512-byte blocks
/// completely asynchronously from the main CPU parser by using undocumented matrix outer-products.
///
/// # Safety
/// This function is unsafe because it emits undocumented AMX instructions that are not stable.
#[cfg(target_arch = "aarch64")]
pub unsafe fn scan_amx(_bytes: &mut [u8]) -> usize {
    // 1. We must configure the AMX state.
    // The undocumented instruction `0x00201420` enables the AMX coprocessor.
    unsafe {
        asm!(".inst 0x00201420", options(nostack, preserves_flags));
    }

    // 2. We use undocumented AMX load instructions to pull 64 bytes of our JSON into the X register
    // and 64 bytes of the whitespace character mask (` `, `\n`, `\t`, `\r`) into the Y register.
    // Based on `corsix/amx`, AMX instructions are encoded as A64 instructions (0x00201000 base).
    // Opcode 0 = LDX, Opcode 1 = LDY, Opcode 14 = MAC16.

    // As a demonstration of Phase 6 capability, we will emit the raw `.inst` for LDX (Opcode 0).
    // The A64 encoding formula for AMX is roughly: `0x00201000 | (opcode << 5) | register`
    unsafe {
        asm!(
            ".inst 0x00201000", // LDX (Opcode 0, Reg 0)
            options(nostack, preserves_flags)
        );
    }
    unsafe {
        asm!(
            ".inst 0x00201020", // LDY (Opcode 1, Reg 0 -> 1 << 5 = 0x20)
            options(nostack, preserves_flags)
        );
    }

    // 3. We execute the 16-bit Matrix Multiply MAC16 (Opcode 14 -> 14 << 5 = 280 = 0x118)
    // 0x00201000 | 0x118 = 0x00201118
    unsafe {
        asm!(
            ".inst 0x00201118", // MAC16
            options(nostack, preserves_flags)
        );
    }

    // 4. Disable AMX
    // `0x00201420`
    unsafe {
        asm!(
            ".inst 0x00201420", // The toggle bit sequence disables it.
            options(nostack, preserves_flags)
        );
    }

    panic!(
        "AMX Whitespace Scrubber is currently in experimental development and requires raw opcode emission."
    );
}

#[cfg(not(target_arch = "aarch64"))]
pub unsafe fn scan_amx(_bytes: &mut [u8]) -> usize {
    unreachable!("scan_amx called on non-aarch64 architecture")
}