b22a714840
The JIT that runs makepad apps from source: lexer, front end, type checker, lazy borrow checker (Gandalf; `--check-first` opts in), codegen, session and warm/cold caches keyed by compiler stamp, provided crates bound late, startup images, live patching. User-facing name is `makepad run` (binary `makepad`, MAKEPAD_RUN_* env, ~/.makepad-run); libs/relax stays the internal library name. `makepad check` reports rustc-style diagnostics with rustc error codes and checks a whole workspace (`--workspace`). Runs on macOS, Linux, Windows and Android. makepad-remote: one tool schema for apps and the WM (app/1): grabs, captures, traces, frame profiles and tweaks. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
99 lines
2.6 KiB
Rust
99 lines
2.6 KiB
Rust
// Loops with a small constant trip count, fully unrolled at O3 (codegen loops.rs unroll_const_loops): a probe
|
|
// loop `for _ in 0..3` with an early return (deflate's hash-chain shape), a counted loop stepping by 2 with
|
|
// `<=`, a 4-trip loop whose counter feeds an index, a 5-trip loop (left as a loop), a loop whose counter is read
|
|
// after it (left alone), and a do-while that runs once. Called often enough for O3; output = rustc --test.
|
|
#[inline(never)]
|
|
fn probe(next: &[u16; 64], mut p: usize, want: u16) -> (u32, usize) {
|
|
let mut hits = 0u32;
|
|
for _ in 0..3 {
|
|
let n = next[p & 63] as usize;
|
|
if n == 0 {
|
|
return (hits + 100, p);
|
|
}
|
|
p = n;
|
|
if n as u16 == want {
|
|
hits += 1;
|
|
}
|
|
}
|
|
(hits, p)
|
|
}
|
|
|
|
#[inline(never)]
|
|
fn step2(a: &[u32; 16], o: usize) -> u32 {
|
|
let mut s = 0u32;
|
|
let mut i = 0usize;
|
|
while i <= 6 {
|
|
s = s.wrapping_mul(31).wrapping_add(a[(o + i) & 15]);
|
|
i += 2;
|
|
}
|
|
s
|
|
}
|
|
|
|
#[inline(never)]
|
|
fn four(a: &[u64; 8], k: u64) -> u64 {
|
|
let mut s = 0;
|
|
for j in 0..4 {
|
|
s ^= a[j * 2].rotate_left(j as u32) ^ k;
|
|
}
|
|
s
|
|
}
|
|
|
|
#[inline(never)]
|
|
fn five(a: &[u8; 8]) -> u32 {
|
|
let mut s = 0u32;
|
|
for j in 0..5u32 {
|
|
s = s * 7 + a[j as usize] as u32 + j;
|
|
}
|
|
s
|
|
}
|
|
|
|
#[inline(never)]
|
|
fn counter_after(a: &[i32; 8]) -> i32 {
|
|
let mut j = 0;
|
|
while j < 3 {
|
|
if a[j] < 0 {
|
|
break;
|
|
}
|
|
j += 1;
|
|
}
|
|
j as i32 * 1000 + a[j.min(7)]
|
|
}
|
|
|
|
#[inline(never)]
|
|
fn once(x: u64) -> u64 {
|
|
let mut i = 0u32;
|
|
let mut v = x;
|
|
loop {
|
|
v = v.wrapping_mul(0x9E37_79B9_7F4A_7C15) ^ i as u64;
|
|
i += 1;
|
|
if i >= 1 {
|
|
break;
|
|
}
|
|
}
|
|
v
|
|
}
|
|
|
|
#[test]
|
|
fn const_trip_loops() {
|
|
let mut next = [0u16; 64];
|
|
for i in 0..64 {
|
|
next[i] = ((i * 37 + 11) % 64) as u16 * (i % 9 != 0) as u16;
|
|
}
|
|
let a32: [u32; 16] = core::array::from_fn(|i| (i as u32).wrapping_mul(2654435761));
|
|
let a64: [u64; 8] = core::array::from_fn(|i| (i as u64 + 1).wrapping_mul(0x0123_4567_89ab_cdef));
|
|
let a8: [u8; 8] = [3, 1, 4, 1, 5, 9, 2, 6];
|
|
let ai: [i32; 8] = [5, 7, -1, 4, 2, -8, 9, 1];
|
|
let mut h = 0u64;
|
|
for r in 0..300_000u64 {
|
|
let (x, p) = probe(&next, r as usize, (r % 64) as u16);
|
|
h = h.rotate_left(3) ^ x as u64 ^ p as u64;
|
|
h = h.wrapping_add(step2(&a32, r as usize) as u64);
|
|
h ^= four(&a64, r);
|
|
h = h.wrapping_add(five(&a8) as u64);
|
|
let mut b = ai;
|
|
b[(r % 8) as usize] = -(r as i32 % 5);
|
|
h = h.wrapping_add(counter_after(&b) as u64);
|
|
h ^= once(r);
|
|
}
|
|
println!("| {:016x}", h);
|
|
}
|