5993bb7 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

5993bb7 — Peter John 2026-11-03T19:09:47+05:30

trmc_test: guard that std List.map stays within 3x of a build with a presized GC heap

Files changed (1) hide show

plum-core/tests/trmc_test.rs +89 -0

plum-core/tests/trmc_test.rs CHANGED Viewed

@@ -367,3 +367,92 @@ fun main() -> Int =
     assert!(isRewritten("nth1", &p, "replaceNth"));
     assert_eq!(runInt("nth2", &p), 1);
 }
+/// Whether the wasm fn named `name` (or a specialised copy of it) contains an op
+/// matching `pred`.
+fn hasOp(wasm: &[u8], name: &str, pred: fn(&wasmparser::Operator) -> bool) -> bool {
+    let mut names = std::collections::HashMap::new();
+    let mut imports = 0u32;
+    for p in wasmparser::Parser::new(0).parse_all(wasm) {
+        match p.unwrap() {
+            wasmparser::Payload::ImportSection(r) => imports = r.count(),
+            wasmparser::Payload::CustomSection(c) => {
+                if let wasmparser::KnownCustom::Name(r) = c.as_known() {
+                    for n in r {
+                        if let Ok(wasmparser::Name::Function(m)) = n {
+                            for e in m.into_iter().flatten() {
+                                names.insert(e.index, e.name.to_string());
+                            }
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    let mut idx = imports;
+    let mut seen = false;
+    let mut hit = false;
+    for p in wasmparser::Parser::new(0).parse_all(wasm) {
+        if let wasmparser::Payload::CodeSectionEntry(b) = p.unwrap() {
+            if names.get(&idx).is_some_and(|n| n == name || n.starts_with(&format!("{name}[")) || n.starts_with(&format!("{name}$c"))) {
+                seen = true;
+                let mut r = b.get_operators_reader().unwrap();
+                while !r.eof() {
+                    hit |= pred(&r.read().unwrap());
+                }
+            }
+            idx += 1;
+        }
+    }
+    assert!(seen, "no fn {name}");
+    hit
+}
+/// F-T2-1: std `List.map` (TRMC `mapCells`) looked ~10x slower than building a
+/// list. The loop is not the cause: one `struct.new` per cell, closure inlined.
+/// The time was wasmtime's copying GC copying every live cell on each heap
+/// growth, landing on whichever phase grew the heap (`build` gets the same
+/// spikes). With the GC heap pre-sized so no collection runs, a 1M map must cost
+/// at most 3x a 1M build.
+#[test]
+fn std_map_1m_within_3x_of_build() {
+    let head = "import std/Int\nimport std/List\n\nfun build(n: Int, acc: List[Int]) -> List[Int] = if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))\n\n";
+    let buildSrc = format!("{head}fun main() -> Int =\n  nil: List[Int] := Nil\n  xs := build(1000000, nil)\n  xs.length()\n");
+    let mapSrc = format!("{head}fun main() -> Int =\n  nil: List[Int] := Nil\n  xs := build(1000000, nil)\n  ys := xs.map(|x| x * 2)\n  xs.length() + ys.length()\n");
+    let mapBytes = compileSource(&load("stdmap", &mapSrc)).unwrap();
+    assert!(
+        !hasOp(&mapBytes, "mapCells", |o| matches!(o, wasmparser::Operator::CallRef { .. })),
+        "closure not inlined into mapCells"
+    );
+    assert_eq!(structNewCount(&mapBytes, "mapCells"), 1);
+    let mut config = wasmtime::Config::new();
+    config.wasm_gc(true);
+    config.wasm_function_references(true);
+    config.wasm_tail_call(true);
+    config.gc_heap_initial_size(512 << 20);
+    let engine = wasmtime::Engine::new(&config).unwrap();
+    let time = |name: &str, src: &str, want: i64| -> std::time::Duration {
+        let bytes = compileSource(&load(name, src)).unwrap();
+        let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+        (0..3)
+            .map(|_| {
+                let mut store = wasmtime::Store::new(&engine, ());
+                let mut linker = wasmtime::Linker::new(&engine);
+                linker.define_unknown_imports_as_default_values(&mut store, &module).unwrap();
+                let instance = linker.instantiate(&mut store, &module).unwrap();
+                let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();
+                let t = std::time::Instant::now();
+                assert_eq!(main.call(&mut store, ()).unwrap(), want);
+                t.elapsed()
+            })
+            .min()
+            .unwrap()
+    };
+    let tBuild = time("stdbuild", &buildSrc, 1_000_000);
+    let tBoth = time("stdmap2", &mapSrc, 2_000_000);
+    let tMap = tBoth.saturating_sub(tBuild);
+    eprintln!("build {tBuild:?} build+map {tBoth:?} map {tMap:?}");
+    assert!(tMap <= tBuild * 3, "map {tMap:?} vs build {tBuild:?}");
+}