New compiler?

[davazp]

Half joking I used claude to generate a basic wasm compiler with GC and ref types to be able to interact with existing JS side:

JSCL> (compile-wat '(lambda (x) (* x 2)))
(MODULE (REC (TYPE $CONS (SUB FINAL (STRUCT (FIELD $CAR (MUT ANYREF)) (FIELD $CDR (MUT ANYREF))))) (TYPE $ENTRY (FUNC (RESULT ANYREF))) (TYPE |$fn_1| (FUNC (PARAM ANYREF) (RESULT ANYREF)))) (IMPORT "rt" "wrap_wasm_func" (FUNC |$f_wrap_wasm_func| (PARAM I32) (RESULT ANYREF))) (FUNC |$lambda_0| (TYPE |$fn_1|) (PARAM ANYREF) (RESULT ANYREF) (LOCAL.GET 0) (REF.CAST_I31) (I31.GET_S) (I32.CONST 2) (REF.I31) (REF.CAST_I31) (I31.GET_S) (I32.MUL) (REF.I31)) (FUNC $MAIN (TYPE $ENTRY) (RESULT ANYREF) (I32.CONST 0) (CALL 0)) (EXPORT "main" (FUNC $MAIN)) (EXPORT "lambda_0" (FUNC |$lambda_0|)))
JSCL> (defvar *f* (eval-toplevel-wasm '(lambda (x) (* x 2))))
*F*
JSCL> (funcall *f* 20)
40

It makes me wonder if that is a direction worth considering longer term. It'd gain performance, fixnums. Probably it'd make FFI slower.

wasm doesn't support goto. So tagbody and such would still need some reconstruction work rebuild structures when possible from a set of gotos.

If we were to write a new compiler, would this be a good choice? or would you stick to JS?

I don't think I'll have the time to do this properly myself. But I could help experiment and setup some infrastructure for it.

[kchanqvq]

1. Passing objects between will need some ID table and trampoline for reader/writer.
2. As for performance, I think the only obvious win comes from SIMD, but maybe we'll never go that far! Sequence functions on lists is already faster in JSCL than WASM ECL after my optimizations :) JS can be pretty fast.
3. We can do numeric tower in JS. Without type inference it will be slow on both JS and WASM. The cure is type inference.

Overall I don't think WASM compiler wins big.

One compiler project to win big: revive the statement based compiler so we compile block/tagbody to labeled break/continue instead of try/catch.

Another one: type inference. Maybe based on the famous Henry Baker paper.

[davazp]

Passing objects between will need some ID table and trampoline for reader/writer.

I haven’t looked into it at low level but I think that is what reference types solve though.

JS is super fast. At work I usually experience a 2x speed up at most with very C like code in web assembly vs C like code in JS.

For sure not ground breaking. I would like to understand better where most of the JSCL performance penalty come from. Type checks ? Too many dynamic calls ? It’s hard to figure out with such a large jscl.js. This would be a good project.

[kchanqvq]

For sure not ground breaking. I would like to understand better where most of the JSCL performance penalty come from. Type checks ? Too many dynamic calls ? It’s hard to figure out with such a large jscl.js. This would be a good project.

Indeed! One way to go is a suite of micro-benchmarks.