ruda_runtime/runtime/tune/stack/
cache.rs

1//! Bounded persistent records. Files contain the FULL key; the filename hash is only an index.
2use std::{fs::{self, OpenOptions}, io::{self, Read, Write}, path::{Path, PathBuf},
3    string::{String, ToString}, sync::atomic::{AtomicU64, Ordering}, time::{SystemTime, UNIX_EPOCH}, vec::Vec};
4
5const MAGIC: &[u8; 8] = b"RUDATN01";
6const MAX_FILE: usize = 512 * 1024;
7const MAX_KEY: usize = 384 * 1024;
8const MAX_NAME: usize = 4096;
9static NEXT_FILE: AtomicU64 = AtomicU64::new(0);
10
11#[derive(Debug, Clone)]
12pub struct Record {
13    pub scope: u8,
14    pub key: String,
15    pub winner: String,
16    pub created: u64,
17    pub reference_ns: u64,
18    pub winner_ns: u64,
19    pub ratio: f64,
20    pub verified: bool,
21}
22/// This is NOT a cryptographic authenticity check. Caches must be in a trusted user directory.
23pub fn digest(bytes: &[u8]) -> String {
24    let mut a = 0xcbf29ce484222325u64;
25    let mut b = 0x84222325cbf29ce4u64;
26    for &v in bytes {
27        a = (a ^ v as u64).wrapping_mul(0x100000001b3);
28        b = (b ^ (v as u64).wrapping_add(1)).wrapping_mul(0x100000001b3);
29    }
30    std::format!("{a:016x}{b:016x}")
31}
32pub fn now_seconds() -> u64 { SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs() }
33impl Record {
34    pub fn is_fresh(&self, now: u64, ttl: u64) -> bool {
35        self.created <= now && now - self.created < ttl
36    }
37    fn encode(&self) -> io::Result<Vec<u8>> {
38        if self.scope > 2 || self.key.len() > MAX_KEY || self.winner.len() > MAX_NAME || self.winner.is_empty()
39            || self.reference_ns == 0 || self.winner_ns == 0 || !self.ratio.is_finite() || self.ratio <= 0.0 {
40            return Err(invalid("invalid tuning record"));
41        }
42        let mut bytes = MAGIC.to_vec();
43        for text in [&self.key, &self.winner] {
44            bytes.extend_from_slice(&(text.len() as u32).to_le_bytes());
45            bytes.extend_from_slice(text.as_bytes());
46        }
47        for value in [self.created, self.reference_ns, self.winner_ns, self.ratio.to_bits()] {
48            bytes.extend_from_slice(&value.to_le_bytes());
49        }
50        bytes.push(u8::from(self.verified));
51        bytes.push(self.scope);
52        let checksum = digest(&bytes);
53        bytes.extend_from_slice(checksum.as_bytes());
54        Ok(bytes)
55    }
56    fn decode(bytes: &[u8]) -> io::Result<Self> {
57        if bytes.len() > MAX_FILE || bytes.len() < 83 || !bytes.starts_with(MAGIC) { return Err(invalid("bad tuning cache header/length")); }
58        let end = bytes.len() - 32;
59        if digest(&bytes[..end]).as_bytes() != &bytes[end..] { return Err(invalid("tuning cache checksum mismatch")); }
60        let mut p = 8;
61        fn take<'a>(bytes: &'a [u8], p: &mut usize, count: usize) -> io::Result<&'a [u8]> {
62            let stop = p.checked_add(count).ok_or_else(|| invalid("cache length overflow"))?;
63            let value = bytes.get(*p..stop).ok_or_else(|| invalid("truncated tuning cache"))?;
64            *p = stop; Ok(value)
65        }
66        let mut text = |limit: usize| -> io::Result<String> {
67            let length = u32::from_le_bytes(take(&bytes[..end], &mut p, 4)?.try_into().map_err(|_| invalid("bad length"))?) as usize;
68            if length > limit { return Err(invalid("cache field too large")); }
69            String::from_utf8(take(&bytes[..end], &mut p, length)?.to_vec()).map_err(|_| invalid("invalid cache UTF-8"))
70        };
71        let key = text(MAX_KEY)?;
72        let winner = text(MAX_NAME)?;
73        let mut number = || -> io::Result<u64> {
74            Ok(u64::from_le_bytes(take(&bytes[..end], &mut p, 8)?.try_into().map_err(|_| invalid("bad u64"))?))
75        };
76        let created = number()?;
77        let reference_ns = number()?;
78        let winner_ns = number()?;
79        let ratio = f64::from_bits(number()?);
80        let verified = match take(&bytes[..end], &mut p, 1)?[0] { 0 => false, 1 => true, _ => return Err(invalid("invalid validation flag")) };
81        let scope = take(&bytes[..end], &mut p, 1)?[0];
82        if scope > 2 || p != end || winner.is_empty() || reference_ns == 0 || winner_ns == 0 || !ratio.is_finite() || ratio <= 0.0 { return Err(invalid("invalid cache record")); }
83        Ok(Self { scope, key, winner, created, reference_ns, winner_ns, ratio, verified })
84    }
85}
86fn invalid(message: &str) -> io::Error { io::Error::new(io::ErrorKind::InvalidData, message.to_string()) }
87
88#[derive(Debug)]
89pub struct DiskCache { root: PathBuf, capacity: usize }
90impl DiskCache {
91    /// A dedicated directory is used, never the legacy autotune cache directory itself.
92    pub fn new(root: PathBuf, capacity: usize) -> Self { Self { root: root.join("stack-autotune-v1"), capacity } }
93    fn path(&self, key: &str) -> PathBuf { self.root.join(std::format!("stack-v1-{}.rtune", digest(key.as_bytes()))) }
94    pub fn load(&self, key: &str) -> io::Result<Option<Record>> {
95        let path = self.path(key);
96        let mut file = match fs::File::open(path) { Ok(f) => f, Err(e) if e.kind() == io::ErrorKind::NotFound => return Ok(None), Err(e) => return Err(e) };
97        if file.metadata()?.len() > MAX_FILE as u64 { return Err(invalid("tuning cache file too large")); }
98        let mut bytes = Vec::new();
99        (&mut file).take((MAX_FILE + 1) as u64).read_to_end(&mut bytes)?;
100        let record = Record::decode(&bytes)?;
101        // Hash collision or copied cache files are misses, not alternate executable choices.
102        if record.key == key { Ok(Some(record)) } else { Ok(None) }
103    }
104    pub fn remove(&self, key: &str) -> io::Result<()> {
105        match fs::remove_file(self.path(key)) { Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(()), r => r }
106    }
107    pub fn save(&self, record: &Record) -> io::Result<()> {
108        let bytes = record.encode()?;
109        fs::create_dir_all(&self.root)?;
110        let temp = self.root.join(std::format!(".tmp-{}-{}", std::process::id(), NEXT_FILE.fetch_add(1, Ordering::Relaxed)));
111        // create_new avoids silently following an existing temporary path or symlink.
112        let result = (|| {
113            let mut file = OpenOptions::new().write(true).create_new(true).open(&temp)?;
114            file.write_all(&bytes)?; file.sync_all()?; drop(file);
115            // Unix atomically replaces. Platforms rejecting replacement report a cache warning;
116            // they never delete a known good record first to force a rename.
117            fs::rename(&temp, self.path(&record.key))?;
118            self.prune()
119        })();
120        if result.is_err() { let _ = fs::remove_file(&temp); }
121        result
122    }
123    fn prune(&self) -> io::Result<()> {
124        let mut files = Vec::new();
125        for entry in fs::read_dir(&self.root)? {
126            let entry = entry?; let name = entry.file_name(); let name = name.to_string_lossy();
127            if name.starts_with("stack-v1-") && name.ends_with(".rtune") && entry.file_type()?.is_file() {
128                files.push((entry.metadata()?.modified()?, entry.path()));
129            }
130        }
131        files.sort_by(|a,b| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));
132        let extra = files.len().saturating_sub(self.capacity);
133        for (_, path) in files.into_iter().take(extra) {
134            if let Err(e) = fs::remove_file(path) { if e.kind() != io::ErrorKind::NotFound { return Err(e); } }
135        }
136        Ok(())
137    }
138    pub fn directory(&self) -> &Path { &self.root }
139}
140
141#[cfg(test)]
142mod tests {
143    use super::*;
144    fn record() -> Record { Record { scope: 0, key: "test/测试".into(), winner: "safe".into(), created: 50, reference_ns: 100, winner_ns: 75, ratio: 0.75, verified: true } }
145    #[test] fn python_generated_golden_fixture() {
146        let raw = include_bytes!("testdata/cache_v1.fixture");
147        let record = Record::decode(raw).unwrap();
148        assert_eq!(record.key, "known/测试"); assert_eq!(record.winner, "reference-plan");
149        assert_eq!(record.scope, 1); assert_eq!(record.ratio, 0.8); assert_eq!(record.encode().unwrap(), raw.to_vec());
150    }
151    #[test] fn binary_round_trip() { let r = record(); let d = Record::decode(&r.encode().unwrap()).unwrap(); assert_eq!(d.key, r.key); assert_eq!(d.winner, r.winner); assert!(d.verified); }
152    #[test] fn all_truncations_rejected() { let b = record().encode().unwrap(); for i in 0..b.len() { assert!(Record::decode(&b[..i]).is_err()); } }
153    #[test] fn corruption_rejected() { let mut b = record().encode().unwrap(); b[14] ^= 1; assert!(Record::decode(&b).is_err()); }
154    #[test] fn oversized_field_rejected() { let mut r = record(); r.key = "x".repeat(MAX_KEY+1); assert!(r.encode().is_err()); }
155    #[test] fn nan_ratio_rejected() { let mut r = record(); r.ratio = f64::NAN; assert!(r.encode().is_err()); }
156    #[test] fn zero_duration_rejected() { let mut r = record(); r.winner_ns = 0; assert!(r.encode().is_err()); }
157    #[test] fn future_and_expired_records_miss() { let r = record(); assert!(!r.is_fresh(49, 100)); assert!(!r.is_fresh(150, 100)); assert!(r.is_fresh(149, 100)); }
158    #[test] fn file_round_trip_and_prune() {
159        let dir = std::env::temp_dir().join(std::format!("ruda-stack-test-{}-{}", std::process::id(), NEXT_FILE.fetch_add(1, Ordering::Relaxed)));
160        let c = DiskCache::new(dir.clone(), 1); let r = record();
161        c.save(&r).unwrap(); assert!(c.load(&r.key).unwrap().is_some());
162        let mut r2 = r; r2.key = "another".into(); c.save(&r2).unwrap();
163        assert_eq!(fs::read_dir(c.directory()).unwrap().count(), 1);
164        fs::remove_dir_all(dir).unwrap();
165    }
166}
ruda_runtime/runtime/tune/stack/cache.rs

ruda_runtime/runtime/tune/stack/
cache.rs
