Multi-Value All the Wasm(hacks.mozilla.org)
hacks.mozilla.org
Multi-Value All the Wasm
https://hacks.mozilla.org/2019/11/multi-value-all-the-wasm/
38 comments
I feel like you could do the same thing with tuples and "splats", like in Ruby. Just wrap your values in thunks, and call it the same.
You can't because in CL if you only want first return value, you can pretend that the function only returns one value.
For example, the CL integer division functions (it has each of floor, truncate, and round) all return the remainder as a second value, but you can ignore that fact if all you wanted was division:
For example, the CL integer division functions (it has each of floor, truncate, and round) all return the remainder as a second value, but you can ignore that fact if all you wanted was division:
(floor 5 3) -> 1 ; 2
(let ((x (floor 5 3)) x) -> 1
(setf (values x y) (floor 5 3)) (list x y) -> (1 2)Well seeing as I can't find an optimization in CLISP for changing the underlying div instruction, I'm assuming this is going to run the same. Is this correct?
My only point here is, I guess, that a thunk (0 argument function) acts a similar way. If we had need to call two instructions (or increase bitwidth) this might suffice:
My only point here is, I guess, that a thunk (0 argument function) acts a similar way. If we had need to call two instructions (or increase bitwidth) this might suffice:
def floor(n, d = 1)
[-> { n.div(d) }, -> { n.modulo(d) }]
end
p *floor(10.3)
#<Proc:[email protected]:4 (lambda)>
#<Proc:[email protected]:4 (lambda)>
p floor(10.3).first.call
# 10
p *floor(10.3).map(&:call)
# 10
# 0.3000000000000007I guess my point is that multiple values are transparent; lots of times there are functions for which it's sometimes useful to have auxiliary values, but most of the time the primary value is all that is needed.
There are certainly arguments for why this might be a bad idea (if your the sort of person who likes rich type systems, you're unlikely to like this), but there is no way to do this in WASM efficiently, while there is for pretty much all real machines.
FWIW, I'm not sure about CLISP; I haven't used it for almost 20 years. Sbcl and ccl will both omit the calculation of the modulo when it is not needed. The ergonomics of a thunk or a tuple are different.
There are certainly arguments for why this might be a bad idea (if your the sort of person who likes rich type systems, you're unlikely to like this), but there is no way to do this in WASM efficiently, while there is for pretty much all real machines.
FWIW, I'm not sure about CLISP; I haven't used it for almost 20 years. Sbcl and ccl will both omit the calculation of the modulo when it is not needed. The ergonomics of a thunk or a tuple are different.
Please don't tell anyone. WASM can be better, but they need to not think it's Lisp.
I was reminded of Go and Forth :-)
It's not really Forth because in WASM, each block of code needs to have a statically determined stack effect. I wonder if there might be a nice Forth-like syntax for WASM, though?
It's not really Forth because in WASM, each block of code needs to have a statically determined stack effect. I wonder if there might be a nice Forth-like syntax for WASM, though?
At https://github.com/darius/idel is a Wasm-like VM I made in the early 2000s with a Forth-like source syntax and static stack effects. (Tail-call optimization too.) I regret making it a little too simple and then abandoning it -- it seemed too hard to try to get traction with such a thing.
It's kinda unrealistic to endow a Forth-like syntax with things like types and pre-determined stack effects. You end up with something not too different from the usual lambda syntax aside from postfix application, which in this context would simply be De Bruijn notation for lambda-like terms.
I think Factor is an existence proof that you're mistaken about this.
Check out the section of the docs labeled "The stack": https://docs.factorcode.org/content/article-handbook-languag...
Note that, in particular, there is full support for stack-effect declarations and that there is a static static-effect checker.
Check out the section of the docs labeled "The stack": https://docs.factorcode.org/content/article-handbook-languag...
Note that, in particular, there is full support for stack-effect declarations and that there is a static static-effect checker.
"Turning into" is the wrong phrasing. It's enabling Lisp.
And also Python, Go, Rust, Haskell...
And also Python, Go, Rust, Haskell...
pretty hard to enable lisp without eval or garbage collection
You might find these interesting:
- https://github.com/WebAssembly/gc
- https://github.com/WebAssembly/reference-types
- https://github.com/WebAssembly/funclets
As for the eval thing, you surely can compile and execute code on the fly. Such features would be enabled by the aforementioned proposals, but should be possible today as well (through shared memory).
- https://github.com/WebAssembly/gc
- https://github.com/WebAssembly/reference-types
- https://github.com/WebAssembly/funclets
As for the eval thing, you surely can compile and execute code on the fly. Such features would be enabled by the aforementioned proposals, but should be possible today as well (through shared memory).
you mean you can compile code into a separate module, right? Which could then access the original module only via marshaled calls through the javascript layer? I guess anything can be compiled into anything but I wouldn't prefer to target lisp to such an environment.
Yes, what you are saying, but that can be optimized very well after the proposals come through.
My Intel CPU also doesn't have garbage collection or eval opcodes and yet it runs Lisp...
your intel CPU allows you to iterate through the stack and jump to a location in the heap though (as long as you don't mark the page NX). These features are used by most gc and jit implementations respectively. wasm requires all functions to be specified at module creation time and gives no access to the stack.
There are plenty of GC algorithms to chose from, and several examples how to implement them in WebAssembly already.
https://github.com/appcypher/awesome-wasm-langs/blob/master/...
No need to get everything served on a plate.
https://github.com/appcypher/awesome-wasm-langs/blob/master/...
No need to get everything served on a plate.
Those have suboptimal GC implementations because of the lack of primitives to do better. Some just straight up use reference counting and leak anything with circular references.
So what?
Yes some have buggy implementations, others could do better, yet they exist.
I rather have a half working bicycle that takes me to town than none at all.
Yes some have buggy implementations, others could do better, yet they exist.
I rather have a half working bicycle that takes me to town than none at all.
What is a "half working bicycle that takes me to town". Like by definition it fulfills it purpose.
A garbage collector that breaks down on circular references is crazy town for real work. Like there's even AI Lab Koan about that specifically. http://catb.org/jargon/html/koans.html
A better example would be a bicycle without the front wheel. Yeah, if you're real good and real careful you can probably treat it as a unicycle and get to where you're going, but you'd be real pissed if someone sold it to you as a working bicycle, no?
A garbage collector that breaks down on circular references is crazy town for real work. Like there's even AI Lab Koan about that specifically. http://catb.org/jargon/html/koans.html
A better example would be a bicycle without the front wheel. Yeah, if you're real good and real careful you can probably treat it as a unicycle and get to where you're going, but you'd be real pissed if someone sold it to you as a working bicycle, no?
Not all GC enabled languages that currently target WebAssembly are buggy as you make it to be.
PNaCL also did not have direct GC support, yet it got released with working OCaml support.
PNaCL also did not have direct GC support, yet it got released with working OCaml support.
IIUC, Lua also handles multiple return values the way you're advocating. I like the way Lua does it.
AFAICT this is very different from lisp's multiple values because, unlike lisp, you need to explicitly handle any extra values.
When new features are added to WASM, how does it all get deployed and how does it fit in with existing browsers and such? Do compilers avoid using the new pattern unless you say to, put in both and do some kind of runtime feature detection for which they’ll use, or something else altogether?
When ready, browsers simply enable new features. Until then, it's usually behind a flag you can test with.
Compilers generally require flags to enable features. There hasn't been a post-MVP feature that has widespread enough adoption that it would make sense for us to enable it by default.
For developers, the best thing is to make separate builds with the sets of features you want, and pick the right build using something like wasm-feature-detect
https://github.com/GoogleChromeLabs/wasm-feature-detect
There is some discussion on something like "fat binaries" which would contain multiple builds and pick between them,
https://github.com/WebAssembly/feature-detection
Compilers generally require flags to enable features. There hasn't been a post-MVP feature that has widespread enough adoption that it would make sense for us to enable it by default.
For developers, the best thing is to make separate builds with the sets of features you want, and pick the right build using something like wasm-feature-detect
https://github.com/GoogleChromeLabs/wasm-feature-detect
There is some discussion on something like "fat binaries" which would contain multiple builds and pick between them,
https://github.com/WebAssembly/feature-detection
WAVM has had support for multiple values for a long time.
Glad to see that feature finally getting more traction. This will be extremely useful for languages such as Go.
Glad to see that feature finally getting more traction. This will be extremely useful for languages such as Go.
Is there any particular reason why functions and blocks had arity restrictions until now?
It's great all this additions on Cranelift for supporting multi-value returns. We will update Wasmer soon to support it as well.
Here's the multivalue return proposal (Phase 3 in the WebAssembly proposals): https://github.com/WebAssembly/multi-value
Quick question: Is multivalue return supported in LLVM? Or said in other way ...code compiled from Rust or C/C++ will output Wasm with multivalue returns? Or only written-by-hand WebAssembly can take advantage of this at the moment?
EDIT: after reading the article more thoroughly: LLVM doesn't support multivalue returns in Wasm yet. They are using Walrus to do wasm to wasm transformation from the return metadata info they have in wasm-bindgen (Rust).
Quick question: Is multivalue return supported in LLVM? Or said in other way ...code compiled from Rust or C/C++ will output Wasm with multivalue returns? Or only written-by-hand WebAssembly can take advantage of this at the moment?
EDIT: after reading the article more thoroughly: LLVM doesn't support multivalue returns in Wasm yet. They are using Walrus to do wasm to wasm transformation from the return metadata info they have in wasm-bindgen (Rust).
I am currently working on multivalue in both LLVM and Binaryen. Watch for celebratory tweets when I finish ;)
Rust will be able to benefit immediately once LLVM has multivalue function support since they use their own ABI internally. But C, C++, and Rust extern functions will not be able to benefit until we additionally define a new C ABI that takes advantage of multivalue returns.
It's also worth noting that multivalue blocks only bring a code size win of a couple percent on real wasm modules, so those are much lower priority.
WebAssembly features are all different in how difficult they are to add to the specification, engines, and tools. Multivalue is unique in that it is trivial for the spec and for engines, but is extremely difficult to implement in tools.
Rust will be able to benefit immediately once LLVM has multivalue function support since they use their own ABI internally. But C, C++, and Rust extern functions will not be able to benefit until we additionally define a new C ABI that takes advantage of multivalue returns.
It's also worth noting that multivalue blocks only bring a code size win of a couple percent on real wasm modules, so those are much lower priority.
WebAssembly features are all different in how difficult they are to add to the specification, engines, and tools. Multivalue is unique in that it is trivial for the spec and for engines, but is extremely difficult to implement in tools.
I'm looking forward to seeing this supported in Wasmer as well. A lot of these announcements seem to target wasmtime as the default standalone runtime (and it has come a long way, especially with the addition of the JIT) but having the option to compile WASM to native code ahead-of-time is still very valuable.
Both Wasmtime and Lucet can AOT compile Wasm, for what it's worth.
WAVM can also compile WebAssembly code to an optimized, native object file.
It can also embed the compiled code into the WebAssembly module, so that the same module can directly run the precompiled code (when using WAVM) or be executed as a standard module by another runtime.
It can also embed the compiled code into the WebAssembly module, so that the same module can directly run the precompiled code (when using WAVM) or be executed as a standard module by another runtime.
TIL! Lucet is being switched over to Wasmtime as well [1]. I'll have to take another look at it.
[1] https://hacks.mozilla.org/2019/11/announcing-the-bytecode-al...
[1] https://hacks.mozilla.org/2019/11/announcing-the-bytecode-al...
I kid, sort of. Greenspun and all that.
(Common Lisp has support for multiple values built in. They’re not a “data structure” like a tuple, but rather an extension to data flow and control. Returning a tuple vs returning multiple values are different things, especially when the consumer of the values-produced only actually uses a single value, as is usually the case with e.g. multiple-value-returning functions like GETHASH or FLOOR. FLOOR returns the quotient of floor(x/y), as well as the remainder as a second value. Most of the time you don’t need the second value, and there’s no need to “opt-out”.)