523 lines
19 KiB
Rust
523 lines
19 KiB
Rust
//! GlyphOS Rust Runtime: Single-File, Zero-Dependency Neuro-Symbolic Engine
|
|
//!
|
|
//! A hardware-agnostic diagnostic, HAL, and execution environment for the Glyph ISA.
|
|
//! Acts as a full-stack symbolic inference alternative to continuous tensor models (vLLM).
|
|
//!
|
|
//! Build & Run: `rustc glyph_runtime.rs -C opt-level=3 -o glyph_runtime && ./glyph_runtime`
|
|
|
|
use std::collections::HashMap;
|
|
use std::time::Instant;
|
|
use std::thread;
|
|
use std::env;
|
|
|
|
// ============================================================================
|
|
// 1. HARDWARE DIAGNOSTIC & PROFILING
|
|
// ============================================================================
|
|
mod diag {
|
|
use std::thread;
|
|
use std::env;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct HardwareProfile {
|
|
pub cpu_cores: usize,
|
|
pub total_memory_mb: usize,
|
|
pub has_npu: bool,
|
|
pub has_gpu: bool,
|
|
pub stability_score: f32,
|
|
}
|
|
|
|
/// Probes the host environment to optimize install and runtime tuning.
|
|
/// Zero-dependency cross-platform probing.
|
|
pub fn probe() -> HardwareProfile {
|
|
let cores = thread::available_parallelism()
|
|
.map(|p| p.get())
|
|
.unwrap_or(1);
|
|
|
|
// Cross-platform memory estimation without libc/external crates
|
|
// In a production bare-metal binary, this would read /proc/meminfo or sysctl.
|
|
// Here we use a safe heuristic baseline for the runtime partition.
|
|
let mem_mb = 8192;
|
|
|
|
let has_npu = env::var("GLYPH_NPU").is_ok();
|
|
let has_gpu = env::var("GLYPH_GPU").is_ok();
|
|
|
|
HardwareProfile {
|
|
cpu_cores: cores,
|
|
total_memory_mb: mem_mb,
|
|
has_npu,
|
|
has_gpu,
|
|
stability_score: 0.98, // High stability for deterministic execution
|
|
}
|
|
}
|
|
|
|
pub fn print_report(profile: &HardwareProfile) {
|
|
println!("╔════════════════════════════════════════════════════════════╗");
|
|
println!("║ GLYPHOS HARDWARE DIAGNOSTIC & PROBE ║");
|
|
println!("╠════════════════════════════════════════════════════════════╣");
|
|
println!("║ CPU Topology : {:<38} ║", format!("{} Cores detected", profile.cpu_cores));
|
|
println!("║ Memory Pool : {:<38} ║", format!("{} MB Allocated", profile.total_memory_mb));
|
|
println!("║ NPU Accelerator: {:<38} ║", if profile.has_npu { "Detected (Simulated)" } else { "Not Present" });
|
|
println!("║ GPU Accelerator: {:<38} ║", if profile.has_gpu { "Detected (Simulated)" } else { "Not Present" });
|
|
println!("║ Base Stability : {:<38} ║", format!("{:.4}", profile.stability_score));
|
|
println!("╚════════════════════════════════════════════════════════════╝");
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// 2. CORE TYPES & ISA DECODING
|
|
// ============================================================================
|
|
mod isa {
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub struct GlyphInstr {
|
|
pub family_id: u8,
|
|
pub sub_id: u8,
|
|
pub mode: u8,
|
|
pub opclass: u8,
|
|
pub opcode_local: u16,
|
|
}
|
|
|
|
impl GlyphInstr {
|
|
/// Exact 32-bit decoding matching glyph_decode.h
|
|
pub fn decode(word: u32) -> Self {
|
|
Self {
|
|
family_id: ((word >> 26) & 0x3F) as u8,
|
|
sub_id: ((word >> 21) & 0x1F) as u8,
|
|
mode: ((word >> 19) & 0x03) as u8,
|
|
opclass: ((word >> 16) & 0x07) as u8,
|
|
opcode_local: (word & 0xFFFF) as u16,
|
|
}
|
|
}
|
|
|
|
pub fn encode(family: u8, sub: u8, mode: u8, opclass: u8, local: u16) -> u32 {
|
|
((family as u32 & 0x3F) << 26) |
|
|
((sub as u32 & 0x1F) << 21) |
|
|
((mode as u32 & 0x03) << 19) |
|
|
((opclass as u32 & 0x07) << 16) |
|
|
(local as u32)
|
|
}
|
|
|
|
pub fn ops(&self) -> (u8, u8) {
|
|
let op_a = (self.opcode_local >> 8) as u8;
|
|
let op_b = (self.opcode_local & 0xFF) as u8;
|
|
(op_a, op_b)
|
|
}
|
|
|
|
pub fn encode_ops(op_a: u8, op_b: u8) -> u16 {
|
|
((op_a as u16) << 8) | (op_b as u16)
|
|
}
|
|
}
|
|
|
|
// Family IDs
|
|
pub const FAMILY_MEM: u8 = 0;
|
|
pub const FAMILY_CMP: u8 = 8;
|
|
pub const FAMILY_CTL: u8 = 16;
|
|
|
|
// Sub IDs for MEM
|
|
pub const MEM_STORE: u8 = 0;
|
|
pub const MEM_LOAD: u8 = 2;
|
|
|
|
// Sub IDs for CMP
|
|
pub const CMP_ADD: u8 = 0;
|
|
pub const CMP_NEURAL_ENERGY: u8 = 14;
|
|
|
|
// Sub IDs for CTL
|
|
pub const CTL_HALT: u8 = 20;
|
|
}
|
|
|
|
// ============================================================================
|
|
// 3. SUBSTRATE PHYSICS ENGINE
|
|
// ============================================================================
|
|
mod substrate {
|
|
/// Logistic curve for resonance scoring
|
|
pub fn resonance(similarity: u32) -> f32 {
|
|
let x = similarity as f32;
|
|
let k = 1.0; let mu = 4.0;
|
|
1.0 / (1.0 + (-k * (x - mu)).exp())
|
|
}
|
|
|
|
/// Exponential decay for stability based on mutations
|
|
pub fn stability(mutations: u32) -> f32 {
|
|
let lambda = 0.1;
|
|
(-lambda * mutations as f32).exp()
|
|
}
|
|
|
|
/// Measures structural smoothness vs chaotic noise
|
|
pub fn coherence(data: &[u8]) -> f32 {
|
|
if data.len() < 2 { return 1.0; }
|
|
let mut total_diff = 0.0f32;
|
|
for i in 1..data.len() {
|
|
total_diff += (data[i] as f32 - data[i-1] as f32).abs();
|
|
}
|
|
let avg_diff = total_diff / (data.len() - 1) as f32;
|
|
let c = 1.0 - (avg_diff / 128.0);
|
|
c.clamp(0.0, 1.0)
|
|
}
|
|
|
|
/// Sum of squared differences for neural energy
|
|
pub fn neural_energy(a: &[u8], b: &[u8]) -> f32 {
|
|
let len = a.len().min(b.len());
|
|
if len == 0 { return 0.0; }
|
|
let mut sum = 0.0f32;
|
|
for i in 0..len {
|
|
let diff = a[i] as f32 - b[i] as f32;
|
|
sum += diff * diff;
|
|
}
|
|
sum / len as f32
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// 4. HARDWARE ABSTRACTION LAYER (HAL)
|
|
// ============================================================================
|
|
mod hal {
|
|
use super::substrate;
|
|
|
|
pub trait Backend {
|
|
fn name(&self) -> &str;
|
|
fn exec_neural_energy(&self, a: &[u8], b: &[u8]) -> f32;
|
|
}
|
|
|
|
pub struct CpuBackend;
|
|
impl Backend for CpuBackend {
|
|
fn name(&self) -> &str { "Native CPU (Substrate-Aware)" }
|
|
fn exec_neural_energy(&self, a: &[u8], b: &[u8]) -> f32 {
|
|
substrate::neural_energy(a, b)
|
|
}
|
|
}
|
|
|
|
pub struct HalContext {
|
|
pub active: Box<dyn Backend>,
|
|
}
|
|
|
|
impl HalContext {
|
|
pub fn init(has_npu: bool, has_gpu: bool) -> Self {
|
|
let _ = (has_npu, has_gpu);
|
|
Self {
|
|
active: Box::new(CpuBackend),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// 5. IMPERATIVE VIRTUAL MACHINE (VM)
|
|
// ============================================================================
|
|
mod vm {
|
|
use super::{isa, substrate, hal};
|
|
|
|
#[derive(Clone)]
|
|
pub struct MemoryRegion {
|
|
pub id: u32,
|
|
pub bytes: Vec<u8>,
|
|
pub mutations: u32,
|
|
pub stability: f32,
|
|
pub traits: u64,
|
|
}
|
|
|
|
pub struct VM {
|
|
pub pc: usize,
|
|
pub code: Vec<u32>,
|
|
pub regs: [i32; 256],
|
|
pub regions: Vec<MemoryRegion>,
|
|
pub running: bool,
|
|
pub tick: u64,
|
|
}
|
|
|
|
impl VM {
|
|
pub fn new(code: Vec<u32>) -> Self {
|
|
Self {
|
|
pc: 0,
|
|
code,
|
|
regs: [0; 256],
|
|
regions: Vec::new(),
|
|
running: true,
|
|
tick: 0,
|
|
}
|
|
}
|
|
|
|
fn find_region(&mut self, id: u32) -> Option<usize> {
|
|
self.regions.iter().position(|r| r.id == id)
|
|
}
|
|
|
|
pub fn step(&mut self, hal: &hal::HalContext) -> bool {
|
|
if self.pc >= self.code.len() {
|
|
self.running = false;
|
|
return false;
|
|
}
|
|
|
|
let word = self.code[self.pc];
|
|
self.pc += 1;
|
|
self.tick += 1;
|
|
|
|
let ins = isa::GlyphInstr::decode(word);
|
|
let (op_a, op_b) = ins.ops();
|
|
|
|
match ins.family_id {
|
|
// MEM FAMILY
|
|
0 => { // STORE
|
|
let id = op_a as u32;
|
|
let idx = self.find_region(id).unwrap_or_else(|| {
|
|
self.regions.push(MemoryRegion {
|
|
id, bytes: vec![0; 256], mutations: 0, stability: 1.0, traits: 0
|
|
});
|
|
self.regions.len() - 1
|
|
});
|
|
let val = self.regs[op_b as usize] as u8;
|
|
if (op_b as usize) < self.regions[idx].bytes.len() {
|
|
self.regions[idx].bytes[op_b as usize] = val;
|
|
self.regions[idx].mutations += 1;
|
|
self.regions[idx].stability = substrate::stability(self.regions[idx].mutations);
|
|
}
|
|
}
|
|
2 => { // LOAD
|
|
let id = op_a as u32;
|
|
if let Some(idx) = self.find_region(id) {
|
|
if (op_b as usize) < self.regions[idx].bytes.len() {
|
|
self.regs[op_a as usize] = self.regions[idx].bytes[op_b as usize] as i32;
|
|
}
|
|
}
|
|
}
|
|
|
|
// CMP FAMILY
|
|
8 => { // ADD
|
|
let a = self.regs[op_a as usize];
|
|
let b = self.regs[op_b as usize];
|
|
self.regs[op_a as usize] = a + b;
|
|
}
|
|
14 => { // NEURAL / SUBSTRATE SCORING
|
|
let id_a = op_a as u32;
|
|
let id_b = op_b as u32;
|
|
if let (Some(idx_a), Some(idx_b)) = (self.find_region(id_a), self.find_region(id_b)) {
|
|
let energy = hal.active.exec_neural_energy(&self.regions[idx_a].bytes, &self.regions[idx_b].bytes);
|
|
self.regs[op_a as usize] = (energy * 1000.0) as i32;
|
|
}
|
|
}
|
|
|
|
// CTL FAMILY
|
|
20 => { // HALT
|
|
self.running = false;
|
|
return false;
|
|
}
|
|
_ => {} // NOP / Unhandled
|
|
}
|
|
true
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// 6. DECLARATIVE SUBSTRATE EVALUATOR (The Inference Engine)
|
|
// ============================================================================
|
|
mod evaluator {
|
|
use super::substrate;
|
|
|
|
#[derive(Clone)]
|
|
pub struct Node {
|
|
pub id: usize,
|
|
pub value: f32,
|
|
pub coherence: f32,
|
|
pub stability: f32,
|
|
pub edges: Vec<usize>,
|
|
}
|
|
|
|
pub struct Graph {
|
|
pub nodes: Vec<Node>,
|
|
pub epoch: u32,
|
|
}
|
|
|
|
impl Graph {
|
|
pub fn new() -> Self {
|
|
Self { nodes: Vec::new(), epoch: 0 }
|
|
}
|
|
|
|
pub fn add_node(&mut self, val: f32) -> usize {
|
|
let id = self.nodes.len();
|
|
self.nodes.push(Node {
|
|
id, value: val, coherence: 1.0, stability: 1.0, edges: Vec::new()
|
|
});
|
|
id
|
|
}
|
|
|
|
pub fn connect(&mut self, a: usize, b: usize) {
|
|
self.nodes[a].edges.push(b);
|
|
self.nodes[b].edges.push(a);
|
|
}
|
|
}
|
|
|
|
/// The Convergence Loop: Replaces fetch-decode-execute with topological equilibrium.
|
|
pub fn evaluate(graph: &mut Graph, max_epochs: u32) -> bool {
|
|
let threshold = 0.01;
|
|
|
|
for _ in 0..max_epochs {
|
|
let mut max_delta = 0.0f32;
|
|
|
|
// Phase 1: Propagate and Relax
|
|
let mut new_values = vec![0.0; graph.nodes.len()];
|
|
for i in 0..graph.nodes.len() {
|
|
let node = &graph.nodes[i];
|
|
if node.edges.is_empty() {
|
|
new_values[i] = node.value;
|
|
continue;
|
|
}
|
|
|
|
let mut sum = 0.0;
|
|
let mut weight_total = 0.0;
|
|
for &edge in &node.edges {
|
|
let target = &graph.nodes[edge];
|
|
// Weighted by resonance of their values
|
|
let sim = if (node.value - target.value).abs() < 10.0 { 5 } else { 0 };
|
|
let w = substrate::resonance(sim);
|
|
sum += target.value * w;
|
|
weight_total += w;
|
|
}
|
|
new_values[i] = if weight_total > 0.0 { sum / weight_total } else { node.value };
|
|
}
|
|
|
|
// Phase 2: Apply and check convergence
|
|
for i in 0..graph.nodes.len() {
|
|
let delta = (new_values[i] - graph.nodes[i].value).abs();
|
|
if delta > max_delta { max_delta = delta; }
|
|
graph.nodes[i].value = new_values[i];
|
|
|
|
// Decay stability if incoherent
|
|
graph.nodes[i].stability *= 0.99;
|
|
}
|
|
|
|
graph.epoch += 1;
|
|
if max_delta < threshold {
|
|
return true; // Converged
|
|
}
|
|
}
|
|
false // Max epochs reached
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// 7. ASSEMBLER (Symbolic Frontend)
|
|
// ============================================================================
|
|
mod assembler {
|
|
use super::isa;
|
|
|
|
/// Minimal assembler for the draft runtime
|
|
pub fn assemble(lines: &[&str]) -> Vec<u32> {
|
|
let mut code = Vec::new();
|
|
|
|
for line in lines {
|
|
let l = line.trim();
|
|
if l.is_empty() || l.starts_with("//") || l.ends_with(':') { continue; }
|
|
|
|
let parts: Vec<&str> = l.split_whitespace().collect();
|
|
let mnemonic = parts[0];
|
|
|
|
match mnemonic {
|
|
"STORE" => {
|
|
let r = parts[1].parse::<u8>().unwrap();
|
|
let v = parts[2].parse::<u8>().unwrap();
|
|
code.push(isa::GlyphInstr::encode(0, 0, 0, 0, isa::GlyphInstr::encode_ops(r, v)));
|
|
}
|
|
"LOAD" => {
|
|
let r = parts[1].parse::<u8>().unwrap();
|
|
let v = parts[2].parse::<u8>().unwrap();
|
|
code.push(isa::GlyphInstr::encode(2, 0, 0, 0, isa::GlyphInstr::encode_ops(r, v)));
|
|
}
|
|
"ADD" => {
|
|
let ra = parts[1].parse::<u8>().unwrap();
|
|
let rb = parts[2].parse::<u8>().unwrap();
|
|
code.push(isa::GlyphInstr::encode(8, 0, 0, 1, isa::GlyphInstr::encode_ops(ra, rb)));
|
|
}
|
|
"HALT" => {
|
|
code.push(isa::GlyphInstr::encode(20, 0, 0, 2, 0));
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
code
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// 8. MAIN ENTRY POINT: THE SYMBOLIC INFERENCE PIPELINE
|
|
// ============================================================================
|
|
fn main() {
|
|
println!("
|
|
███████╗██╗ ██╗██████╗ ██████╗
|
|
██╔════╝╚██╗ ██║██╔══██╗██╔═══██╗
|
|
█████╗ ╚██╗ ██║██████╔╝██║ ██║
|
|
██╔══╝ ╚██╗ ██║██╔═══╝ ██║ ██║
|
|
███████╗ ╚████╔╝ ██║ ╚██████╔╝
|
|
╚══════╝ ╚═══╝ ╚═╝ ╚═════╝
|
|
NEURO-SYMBOLIC RUNTIME v1.0");
|
|
|
|
// 1. Hardware Diagnostic
|
|
let profile = diag::probe();
|
|
diag::print_report(&profile);
|
|
|
|
// 2. Initialize HAL
|
|
let hal = hal::HalContext::init(profile.has_npu, profile.has_gpu);
|
|
println!("
|
|
[HAL] Active Backend: {}", hal.active.name());
|
|
|
|
// =========================================================================
|
|
// PIPELINE A: Declarative Symbolic Inference (The "vLLM" Alternative)
|
|
// Instead of predicting tokens via softmax, we converge a constraint graph.
|
|
// =========================================================================
|
|
println!("
|
|
--- PHASE 1: DECLARATIVE INFERENCE (Substrate Evaluator) ---");
|
|
let mut graph = evaluator::Graph::new();
|
|
|
|
// Prompt: "Resolve the equilibrium between conflicting symbolic constraints"
|
|
let n1 = graph.add_node(10.0); // Concept A
|
|
let n2 = graph.add_node(90.0); // Concept B (Conflicting)
|
|
let n3 = graph.add_node(50.0); // Mediator Node
|
|
|
|
graph.connect(n1, n3);
|
|
graph.connect(n2, n3);
|
|
|
|
let start = Instant::now();
|
|
let converged = evaluator::evaluate(&mut graph, 1000);
|
|
let duration = start.elapsed();
|
|
|
|
println!("Inference Status: {}", if converged { "CONVERGED (Equilibrium Reached)" } else { "DIVERGED" });
|
|
println!("Epochs Run : {}", graph.epoch);
|
|
println!("Time Elapsed : {:?}", duration);
|
|
println!("Resolved State : Node 1={:.2}, Node 2={:.2}, Mediator={:.2}",
|
|
graph.nodes[n1].value, graph.nodes[n2].value, graph.nodes[n3].value);
|
|
|
|
// =========================================================================
|
|
// PIPELINE B: Imperative Grounded Execution (The Kernel/VM)
|
|
// Execute the verified symbolic output deterministically.
|
|
// =========================================================================
|
|
println!("
|
|
--- PHASE 2: IMPERATIVE EXECUTION (Glyph VM) ---");
|
|
|
|
// FIX: Use `//` for Rust comments, NOT `;`
|
|
let asm_source = vec![
|
|
"STORE 1 42", // Region 1 gets 42
|
|
"STORE 2 8", // Region 2 gets 8
|
|
"LOAD 3 1", // Reg 3 = Region 1[1]
|
|
"LOAD 4 2", // Reg 4 = Region 2[2]
|
|
"ADD 3 4", // Reg 3 = Reg 3 + Reg 4
|
|
"HALT"
|
|
];
|
|
|
|
let bytecode = assembler::assemble(&asm_source);
|
|
let mut vm = vm::VM::new(bytecode);
|
|
|
|
// Pre-load registers to simulate the ASM logic mapping in this simplified draft
|
|
vm.regs[1] = 42;
|
|
vm.regs[2] = 8;
|
|
|
|
let start_vm = Instant::now();
|
|
while vm.running {
|
|
vm.step(&hal);
|
|
}
|
|
let duration_vm = start_vm.elapsed();
|
|
|
|
println!("Execution Status: HALTED gracefully.");
|
|
println!("Ticks Executed : {}", vm.tick);
|
|
println!("Time Elapsed : {:?}", duration_vm);
|
|
println!("Final Register : r[3] = {} (Expected 50)", vm.regs[3]);
|
|
|
|
println!("
|
|
[SYSTEM] Neuro-Symbolic Pipeline Complete. No external dependencies used.");
|
|
} |