andodeki/makepad
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
makepad/libs/relax/compiler/tests/web_diff/web_diff.rs

470 lines
19 KiB
Rust
Raw Permalink Blame History

// Web target differential program (run.sh): the same output from rustc's build of it (a
// wasm32-unknown-unknown cdylib run in node for wasm32; a host binary for wasm64, whose data
// layout is x86_64's) and from Relax running it as the web target in the trace host's mode
// (MAKEPAD_RUN_CHECK_TARGET=wasm{32,64}-unknown-unknown). Output goes through the page-side
// import `js_console_log` (a page has no stdout). Pointer-heavy on purpose: fat pointers,
// trait objects, vtables, statics holding pointers, Box/Rc/Vec/String, enums with pointer niches,
// fn pointers, closures, unaligned/packed fields, 64- and 128-bit math, atomics.
#![allow(dead_code)]
use std::cell::{Cell, RefCell};
use std::collections::{BTreeMap, VecDeque};
use std::fmt::Write;
use std::rc::Rc;
use std::sync::atomic::{AtomicPtr, AtomicU64, AtomicUsize, Ordering};
use std::sync::Mutex;
#[cfg(target_family = "wasm")]
extern "C" {
fn js_console_log(ptr: *const u8, len: usize);
}
#[cfg(target_family = "wasm")]
fn out(s: &str) {
unsafe { js_console_log(s.as_ptr(), s.len()) }
}
#[cfg(not(target_family = "wasm"))]
fn out(s: &str) {
use std::io::Write;
let _ = std::io::stderr().write_all(s.as_bytes());
}
macro_rules! say {
($($t:tt)*) => {{
let mut s = String::new();
let _ = writeln!(s, $($t)*);
out(&s);
}};
}
trait Shape {
fn area(&self) -> f64;
fn name(&self) -> String;
}
struct Sq(f64);
struct Circ { r: f64, label: &'static str }
impl Shape for Sq {
fn area(&self) -> f64 { self.0 * self.0 }
fn name(&self) -> String { format!("sq{}", self.0) }
}
impl Shape for Circ {
fn area(&self) -> f64 { 3.0 * self.r * self.r }
fn name(&self) -> String { format!("circ:{}", self.label) }
}
static NAMES: [&str; 3] = ["alpha", "beta", "gamma"];
static TABLE: &[(&str, fn(u32) -> u32)] = &[("dbl", dbl), ("sq", sqr), ("inc", |x| x + 1)];
static COUNT: AtomicUsize = AtomicUsize::new(0);
static BIG: AtomicU64 = AtomicU64::new(1 << 40);
static mut CELL: [u32; 4] = [1, 2, 3, 4];
thread_local! {
static TL: Cell<u32> = const { Cell::new(7) };
}
fn dbl(x: u32) -> u32 { x * 2 }
fn sqr(x: u32) -> u32 { x * x }
struct OnceState<const N: usize>([u8; N]);
impl<const N: usize> Drop for OnceState<N> {
fn drop(&mut self) { ONCE_DROPS.fetch_add(1, Ordering::SeqCst); }
}
static ONCE_DROPS: AtomicUsize = AtomicUsize::new(0);
#[inline(never)]
fn take_once<const N: usize>(state: OnceState<N>) -> usize {
state.0.iter().map(|&x| x as usize).sum()
}
#[inline(never)]
fn call_once_box(f: Box<dyn FnOnce() -> usize>) -> usize { f() }
fn once_size<const N: usize>() -> usize {
let state = OnceState([3; N]);
call_once_box(Box::new(move || take_once(state)))
}
#[repr(align(256))]
struct OnceAligned(OnceState<24>);
#[inline(never)]
fn take_aligned(state: OnceAligned) -> usize { take_once(state.0) }
#[derive(Debug, Clone, PartialEq)]
enum Node {
Leaf(i64),
Pair(Box<Node>, Box<Node>),
Name(String),
Empty,
}
fn eval(n: &Node) -> i64 {
match n {
Node::Leaf(v) => *v,
Node::Pair(a, b) => eval(a) * 3 + eval(b),
Node::Name(s) => s.len() as i64,
Node::Empty => -1,
}
}
#[repr(C, packed)]
struct Packed { a: u8, b: u32, c: u16 }
#[repr(C)]
struct Header { tag: u8, ptr: *const u8, len: usize, next: Option<&'static Header> }
unsafe impl Sync for Header {}
static H2: Header = Header { tag: 2, ptr: b"two".as_ptr(), len: 3, next: None };
static H1: Header = Header { tag: 1, ptr: b"one!".as_ptr(), len: 4, next: Some(&H2) };
fn walk(h: &Header) -> String {
let mut s = String::new();
let mut cur = Some(h);
while let Some(x) = cur {
let bytes = unsafe { std::slice::from_raw_parts(x.ptr, x.len) };
let _ = write!(s, "{}:{} ", x.tag, std::str::from_utf8(bytes).unwrap());
cur = x.next;
}
s
}
// C-unwind callbacks have the ScriptProtoPropsFn shape. Keep the table and its
// invocation out of line so these exercise the indirect C ABI, including taking
// the address of a by-value argument and returning an aggregate by value.
#[repr(C)]
#[derive(Clone, Copy)]
struct Object8 { index: u32, generation: u16 }
#[repr(C)]
#[derive(Clone, Copy)]
struct Object12 { a: u32, b: u32, c: u32 }
#[repr(C)]
#[derive(Clone, Copy)]
struct Object24 { a: u64, b: u64, c: u64 }
#[repr(C)]
#[derive(Clone, Copy)]
struct ObjectMixed { a: f64, b: u32 }
#[repr(C)]
#[derive(Clone, Copy)]
struct ObjectFloat24 { a: f64, b: f64, c: f64 }
#[repr(C, packed)]
#[derive(Clone, Copy)]
struct ObjectPacked { a: u8, b: u32 }
#[repr(C)]
struct Vm { words: [u64; 96] }
#[repr(C)]
struct Props { sum: u64, calls: u32 }
trait Object: Copy {
fn sum(&self) -> u64;
fn changed(self) -> Self;
}
impl Object for Object8 {
fn sum(&self) -> u64 { self.index as u64 + self.generation as u64 }
fn changed(self) -> Self { Self { index: self.index + 7, generation: self.generation + 3 } }
}
impl Object for Object12 {
fn sum(&self) -> u64 { self.a as u64 + self.b as u64 + self.c as u64 }
fn changed(self) -> Self { Self { a: self.a + 1, b: self.b + 2, c: self.c + 3 } }
}
impl Object for Object24 {
fn sum(&self) -> u64 { self.a + self.b + self.c }
fn changed(self) -> Self { Self { a: self.a + 4, b: self.b + 5, c: self.c + 6 } }
}
impl Object for ObjectMixed {
fn sum(&self) -> u64 { self.a as u64 + self.b as u64 }
fn changed(self) -> Self { Self { a: self.a + 0.5, b: self.b + 9 } }
}
impl Object for ObjectFloat24 {
fn sum(&self) -> u64 { (self.a + self.b + self.c) as u64 }
fn changed(self) -> Self { Self { a: self.a + 0.25, b: self.b + 0.5, c: self.c + 0.75 } }
}
impl Object for ObjectPacked {
fn sum(&self) -> u64 { self.a as u64 + self.b as u64 }
fn changed(self) -> Self { Self { a: self.a + 1, b: self.b + 19 } }
}
struct Callbacks<T> {
props: extern "C-unwind" fn(&mut Vm, T, &mut Props),
result: extern "C-unwind" fn(&mut Vm, T, &mut Props) -> T,
}
#[inline(never)]
fn object_sum<T: Object>(object: &T) -> u64 { object.sum() }
#[inline(never)]
extern "C-unwind" fn proto_props_c<T: Object>(vm: &mut Vm, object: T, props: &mut Props) {
let n = object_sum(&object);
vm.words[83] += n;
props.sum += n * 3;
props.calls += 1;
}
#[inline(never)]
extern "C-unwind" fn proto_return_c<T: Object>(vm: &mut Vm, object: T, props: &mut Props) -> T {
proto_props_c(vm, object, props);
object.changed()
}
#[inline(never)]
fn call_callbacks<T: Object>(table: &Callbacks<T>, vm: &mut Vm, object: T, props: &mut Props) -> T {
(table.props)(vm, object, props);
(table.result)(vm, object, props)
}
struct SpillCallback {
f: extern "C-unwind" fn(&mut Vm, u64, u64, u64, u64, u64, Object12, &mut Props) -> Object12,
}
#[inline(never)]
extern "C-unwind" fn proto_spill_c(vm: &mut Vm, a: u64, b: u64, c: u64, d: u64, e: u64, object: Object12, props: &mut Props) -> Object12 {
// All six SysV integer registers are occupied before the 12-byte object.
vm.words[7] = a + b + c + d + e;
proto_return_c(vm, object, props)
}
#[inline(never)]
fn call_spill(table: &SpillCallback, vm: &mut Vm, object: Object12, props: &mut Props) -> Object12 {
(table.f)(vm, 101, 203, 307, 409, 503, object, props)
}
fn c_aggregates() {
let mut vm = Vm { words: [0; 96] };
let mut props = Props { sum: 0, calls: 0 };
let a = call_callbacks(&Callbacks { props: proto_props_c, result: proto_return_c }, &mut vm,
Object8 { index: 0x12345678, generation: 0x4321 }, &mut props);
say!("c8 {} {} {} {} {}", a.index, a.generation, vm.words[83], props.sum, props.calls);
let b = call_callbacks(&Callbacks { props: proto_props_c, result: proto_return_c }, &mut vm,
Object12 { a: 11, b: 23, c: 47 }, &mut props);
say!("c12 {} {} {} {} {} {}", b.a, b.b, b.c, vm.words[83], props.sum, props.calls);
let c = call_callbacks(&Callbacks { props: proto_props_c, result: proto_return_c }, &mut vm,
Object24 { a: 1 << 40, b: 101, c: 203 }, &mut props);
say!("c24 {} {} {} {} {} {}", c.a, c.b, c.c, vm.words[83], props.sum, props.calls);
let m = call_callbacks(&Callbacks { props: proto_props_c, result: proto_return_c }, &mut vm,
ObjectMixed { a: 17.25, b: 31 }, &mut props);
say!("c_mixed {} {} {} {} {}", m.a, m.b, vm.words[83], props.sum, props.calls);
let f = call_callbacks(&Callbacks { props: proto_props_c, result: proto_return_c }, &mut vm,
ObjectFloat24 { a: 1.5, b: 2.25, c: 3.75 }, &mut props);
say!("c_float24 {} {} {} {} {} {}", f.a, f.b, f.c, vm.words[83], props.sum, props.calls);
let p = call_callbacks(&Callbacks { props: proto_props_c, result: proto_return_c }, &mut vm,
ObjectPacked { a: 3, b: 98765 }, &mut props);
let pb = p.b;
say!("c_packed {} {} {} {} {}", p.a, pb, vm.words[83], props.sum, props.calls);
let s = call_spill(&SpillCallback { f: proto_spill_c }, &mut vm,
Object12 { a: 17, b: 37, c: 73 }, &mut props);
say!("c_spill {} {} {} {} {} {} {}", s.a, s.b, s.c, vm.words[7], vm.words[83], props.sum, props.calls);
}
// Coverage probes execute between pointer uses in these small callees and in
// the string/lock implementations. Keep them hot and cross call boundaries.
#[inline(never)]
fn coverage_chars(text: &str, total: &Mutex<u64>, count: &AtomicUsize) -> u64 {
let mut sum = 0u64;
for (offset, ch) in text.char_indices() {
sum = sum.wrapping_add(ch as u64 + offset as u64);
count.fetch_or(1 << (offset % 16), Ordering::Relaxed);
}
*total.lock().unwrap() += sum;
sum + count.load(Ordering::Acquire) as u64
}
fn coverage_hot() {
let total = Mutex::new(0u64);
let count = AtomicUsize::new(0);
let texts = [String::from("ASCII"), String::from("Grüße ✓ 🦀"), String::new()];
let mut sum = 0u64;
for i in 0..4096 {
sum += coverage_chars(&texts[i % texts.len()], &total, &count);
}
say!("coverage {} {} {}", sum, *total.lock().unwrap(), count.load(Ordering::Relaxed));
}
fn body() {
numeric_casts();
web_runtime_cases();
coverage_hot();
c_aggregates();
say!("usize {} ptr {} fat {} dyn {} opt_box {} vec {} string {}",
std::mem::size_of::<usize>(), std::mem::size_of::<*const u8>(), std::mem::size_of::<&[u8]>(),
std::mem::size_of::<&dyn Shape>(), std::mem::size_of::<Option<Box<u8>>>(), std::mem::size_of::<Vec<u8>>(),
std::mem::size_of::<String>());
// trait objects through vtables, in a Vec<Box<dyn>>
let shapes: Vec<Box<dyn Shape>> = vec![Box::new(Sq(2.0)), Box::new(Circ { r: 1.5, label: "c1" }), Box::new(Sq(0.5))];
let total: f64 = shapes.iter().map(|s| s.area()).sum();
let names: Vec<String> = shapes.iter().map(|s| s.name()).collect();
say!("shapes {:.3} {:?}", total, names);
// statics of pointers: &str arrays, fn pointer tables, a linked list of statics
for (i, n) in NAMES.iter().enumerate() {
say!("name {} {} {}", i, n, n.len());
}
for (n, f) in TABLE {
say!("fn {} {}", n, f(7));
}
say!("walk {}", walk(&H1));
// recursive boxed enum
let tree = Node::Pair(Box::new(Node::Pair(Box::new(Node::Leaf(4)), Box::new(Node::Name("hello".to_string())))), Box::new(Node::Leaf(-9)));
say!("tree {} {:?}", eval(&tree), tree.clone() == tree);
say!("empty {} {:?}", eval(&Node::Empty), Node::Name("x".into()));
// Rc / RefCell graph
let shared = Rc::new(RefCell::new(Vec::<u32>::new()));
let handles: Vec<Rc<RefCell<Vec<u32>>>> = (0..4).map(|_| shared.clone()).collect();
for (i, h) in handles.iter().enumerate() {
h.borrow_mut().push(i as u32 * 10);
}
say!("rc {} {:?}", Rc::strong_count(&shared), shared.borrow());
// closures capturing by reference and by move, boxed FnMut
let mut acc = 0u64;
let mut add = |x: u64| acc += x;
for i in 1..=10 {
add(i * i);
}
let k = 5u64;
let mut fs: Vec<Box<dyn FnMut(u64) -> u64>> = Vec::new();
fs.push(Box::new(move |x| x * k));
let mut st = 0u64;
fs.push(Box::new(move |x| { st += x; st }));
let r: Vec<u64> = (0..3).map(|i| { let a = fs[0](i); fs[1](a) }).collect();
say!("closures {} {:?}", acc, r);
// Box<dyn FnOnce> moves its environment out before freeing the allocation. Its
// compiler-called free helper must retain the vtable on both wasm pointer widths.
let state = OnceAligned(OnceState([7; 24]));
let aligned = call_once_box(Box::new(move || take_aligned(state)));
say!("box once {} {} {} {} {} drops {}", once_size::<0>(), once_size::<1>(),
once_size::<24>(), once_size::<4096>(), aligned, ONCE_DROPS.load(Ordering::SeqCst));
// strings, chars, formatting
let mut s = String::from("Grüße, wasm32!");
s.push_str(" ✓");
let up: String = s.chars().rev().filter(|c| !c.is_whitespace()).collect();
say!("str {} {} {} {:?}", s.len(), s.chars().count(), up, s.find("wasm"));
say!("fmt {:>8}|{:<6}|{:^7}|{:08.3}|{:x}|{:#b}|{:e}", "r", "l", "c", -3.14159, 0xdead_beefu32, 5u8, 1234.5f64);
// collections
let mut m = BTreeMap::new();
for w in "the quick brown fox jumps over the lazy dog the end".split(' ') {
*m.entry(w).or_insert(0usize) += 1;
}
say!("btree {:?}", m);
let mut q: VecDeque<i32> = (1..=5).collect();
q.rotate_left(2);
q.push_front(-1);
say!("deque {:?}", q);
let mut v: Vec<i64> = (0..40).map(|i| (i * 7919) % 101 - 50).collect();
v.sort_unstable();
v.dedup();
say!("sorted {} {:?} {:?}", v.len(), &v[..5], v.binary_search(&0));
// 64/128-bit integer math, wrapping, checked
let a: u64 = 0xffff_ffff_0000_0001;
let b: u128 = (a as u128) * (a as u128);
say!("int {} {} {:?} {:?} {}", a.wrapping_mul(3), b, a.checked_add(u64::MAX), 7usize.checked_sub(9), (-7i64).rem_euclid(3));
say!("usize {} {} {}", usize::MAX, isize::MIN, (usize::MAX as u64).count_ones());
// floats
let xs = [0.1f64, 2.5, -3.75, 1e10, 1.0 / 3.0];
let prod: f64 = xs.iter().product();
say!("float {} {:.6} {} {}", prod, xs.iter().map(|x| x.abs().sqrt()).sum::<f64>(), (2.5f32).powi(3), f64::EPSILON);
// packed and repr(C) fields
let p = Packed { a: 1, b: 0x0102_0304, c: 0x0506 };
let pb = p.b;
let pc = p.c;
say!("packed {} {} {} {}", std::mem::size_of::<Packed>(), p.a, pb, pc);
// atomics on pointers and wide integers
let x = Box::into_raw(Box::new(41u32));
let ap = AtomicPtr::new(std::ptr::null_mut());
ap.store(x, Ordering::SeqCst);
unsafe { *ap.load(Ordering::SeqCst) += 1 };
COUNT.fetch_add(3, Ordering::Relaxed);
BIG.fetch_add(5, Ordering::Relaxed);
say!("atomic {} {} {}", unsafe { *x }, COUNT.load(Ordering::Relaxed), BIG.load(Ordering::Relaxed));
unsafe { drop(Box::from_raw(x)) };
// raw pointer arithmetic, pointer <-> integer casts
let arr = [10u16, 20, 30, 40];
let p0 = arr.as_ptr();
let p3 = unsafe { p0.add(3) };
let diff = (p3 as usize - p0 as usize) / std::mem::size_of::<u16>();
let back = (p0 as usize + 2 * std::mem::size_of::<u16>()) as *const u16;
say!("ptr {} {} {}", diff, unsafe { *back }, unsafe { p3.offset_from(p0) });
unsafe {
let c = &mut *std::ptr::addr_of_mut!(CELL);
c[2] += 40;
say!("static mut {:?}", c);
}
TL.with(|t| t.set(t.get() * 6));
say!("tls {}", TL.with(|t| t.get()));
// Option<&T> / Option<Box<T>> niches
let some: Option<&u32> = arr.iter().map(|_| &7u32).next();
let none: Option<Box<u64>> = None;
say!("niche {:?} {:?} {}", some, none, std::mem::size_of_val(&none));
say!("done");
}
/// rustc's wasm32 build: node calls this (run.sh)
#[no_mangle]
pub extern "C" fn run() {
body()
}
fn main() {
body()
}
fn web_runtime_cases() {
use std::hint::black_box;
let unsigned = [0u128, 1, u64::MAX as u128, 1u128 << 64, 1u128 << 127, u128::MAX];
let mut sum = 0u128;
for a in unsigned {
for b in unsigned {
if b != 0 {
let a = black_box(a);
let b = black_box(b);
sum = sum.wrapping_add(a / b).wrapping_add(a % b);
}
}
}
let signed = [i128::MIN, -123456789012345678901i128, -1, 0, 1, i128::MAX];
for a in signed {
for b in signed {
if b != 0 && !(a == i128::MIN && b == -1) {
let a = black_box(a);
let b = black_box(b);
sum = sum.wrapping_add((a / b) as u128).wrapping_add((a % b) as u128);
}
}
}
let text = String::from("a runtime string longer than sixteen bytes");
let same = text.clone();
let mut different = text.clone();
different.push('!');
assert!(black_box(text.as_str()) == black_box(same.as_str()));
assert!(black_box(text.as_str()) != black_box(different.as_str()));
different.pop();
different.replace_range(20..21, "X");
assert!(black_box(text.as_str()) != black_box(different.as_str()));
unsafe {
use std::alloc::{GlobalAlloc, Layout, System};
let layout = Layout::from_size_align(131072, 256).unwrap();
let p = System.alloc_zeroed(layout);
assert!(!p.is_null());
assert_eq!(p as usize % 256, 0);
for i in 0..layout.size() { assert_eq!(*p.add(i), 0); *p.add(i) = (i % 251) as u8; }
let q = System.realloc(p, layout, 393216);
assert!(!q.is_null());
for i in 0..layout.size() { assert_eq!(*q.add(i), (i % 251) as u8); }
let large = Layout::from_size_align(393216, 256).unwrap();
let p = System.realloc(q, large, 65536);
assert!(!p.is_null());
for i in 0..65536 { assert_eq!(*p.add(i), (i % 251) as u8); }
System.dealloc(p, Layout::from_size_align(65536, 256).unwrap());
}
say!("web_runtime {sum}");
}
fn numeric_casts() {
use std::hint::black_box;
// Both signednesses and precisions, including halfway values on either side
// of an even significand and carries into the next exponent (f32 infinity).
for value in [0u128, 1, (1u128 << 24) + 1, (1u128 << 24) + 3,
(1u128 << 53) + 1, (1u128 << 53) + 3, 1u128 << 63,
u64::MAX as u128, 1u128 << 64, (1u128 << 100) + (1u128 << 76) + 1,
(1u128 << 100) + (1u128 << 47) + 1, 1u128 << 127, u128::MAX] {
let x = black_box(value);
let y = black_box(value as i128);
say!("wide_cast {} {} {} {} {}", x, (x as f32).to_bits(), (x as f64).to_bits(),
(y as f32).to_bits(), (y as f64).to_bits());
let n = black_box(y.wrapping_neg());
say!("wide_negative {} {} {}", n, (n as f32).to_bits(), (n as f64).to_bits());
let x = black_box(value as u64);
let y = black_box(value as i64);
say!("int_cast {} {} {} {} {}", x, (x as f32).to_bits(), (x as f64).to_bits(),
(y as f32).to_bits(), (y as f64).to_bits());
}
for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -0.0, 0.0, -1.0, 1.5,
-129.0, 256.0, -32769.0, 65536.0, -2147483649.0, 4294967296.0,
9007199254740992.0, 9223372036854775808.0, 18446744073709551616.0,
170141183460469231731687303715884105728.0, 340282366920938463463374607431768211456.0] {
let x = black_box(value);
let y = black_box(value as f32);
say!("f64_cast {} {} {} {} {} {} {} {} {} {}", x as i8, x as u8, x as i16,
x as u16, x as i32, x as u32, x as i64, x as u64, x as i128, x as u128);
say!("f32_cast {} {} {} {} {} {} {} {} {} {}", y as i8, y as u8, y as i16,
y as u16, y as i32, y as u32, y as i64, y as u64, y as i128, y as u128);
}
}
Reference in a new issue View git blame Copy permalink