Been meaning to learn Wasm? Now's your chance to grab our book for CHEAP.
Patrick Dubroy
@dubroy.com
1.6K followers 293 following 670 posts
Programmer & researcher, co-creator of ohmjs.org. 🇨🇦 🇩🇪 🇪🇺 Co-author of wasmgroundup.com — learn Wasm by building a simple compiler in JavaScript. Prev: CDG/HARC, Google, BumpTop
![Details
Structured cloning of WebAssembly.Module
Normally you'd instantiate a Wasm module with WebAssembly.instantiate, which gives you a module instance. Here, we use WebAssembly.compile, which gives us a WebAssembly.Module. This is a stateless object that is structured-cloneable, which allows it to be safely shared across realm boundaries.
Serialization (an implicit part of structured cloning) of WebAssembly modules is defined in §3 of the WebAssembly Web API, which says:
Engines should attempt to share/reuse internal compiled code when performing a structured serialization, although in corner cases like CPU upgrade or browser update, this might not be possible and full recompilation may be necessary.
Shared memory
WebAssembly.Memory also support structured cloning. When we pass shared: true, the buffer property is a SharedArrayBuffer:
The structured clone algorithm accepts SharedArrayBuffer objects and typed arrays mapped onto SharedArrayBuffer objects. In both cases, the SharedArrayBuffer object is transmitted to the receiver resulting in a new, private SharedArrayBuffer object in the receiving agent (just as for ArrayBuffer). However, the shared data block referenced by the two SharedArrayBuffer objects is the same data block, and a side effect to the block in one agent will eventually become visible in the other agent.
Atomic add
The last piece of the puzzle is the i32.atomic.rmw.add instruction used in the addId function:
(func (export "add") (result i32)
;; mem[0] += workerId
i32.const 0
global.get 0
i32.atomic.rmw.add))
This instruction is defined in the threads proposal (a Stage 4 proposal, so not finalized yet), which defines "a new shared linear memory type and some new operations for atomic memory access".
i32.atomic.rmw.add is equivalent to LOCK XADD on x86. As described in the threads proposal:](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:zcycfvljdjkc2ywtj33blgdl/bafkreibmpgcsj3nhuo35vp6yqywpa4dax6x56v37pnpcoq274fq2vdxkby)
![There is a natural tendency in designing interfaces to try to make
them as fast as possible, to rapidly, and seamlessly [36], automate
tasks that are not essential facets of the task at hand. Yet, this speed
can lead users to race past useful experiences, particularly ones
that are artistically or pedagogically helpful.
5.1.1 Slowing Things Down. Reducing the rate at which different
tasks can be performed gives space for both artistry and learning,
giving users time for reflection and personal growth.
Reflection. slowness seemed to have value for the production
of and critical engagement with art.
PTega suggested that “in the arts, there’s a real value to slowing down and taking the hood off things. Because it lets you ask
critical questions, [such as] if you’re truly engaging with it as a
medium”. PBaku argued for the value of integrating tedium into his
workflow, noting that it is useful to “integrate procedural ways of
thinking with more manual or repetitive or more tedious works”.
He went on to describe how a photographer friend intentionally
used an older and slower computer to guide the type of works he
could create. Emphasizing the importance of user agency in this](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:zcycfvljdjkc2ywtj33blgdl/bafkreida6hniokyzbmzx3ywjimff2mzqrbcdt553os3pjxi2m4g5avl6u4)
![Valgrind is in essence a virtual machine using just-in-time compilation techniques, including dynamic recompilation. Nothing from the original program ever gets run directly on the host processor. Instead, Valgrind first translates the program into a temporary, simpler form called intermediate representation (IR), which is a processor-neutral, static single assignment form-based form. After the conversion, a tool (see below) is free to do whatever transformations it would like on the IR, before Valgrind translates the IR back into machine code and lets the host processor run it. Valgrind recompiles binary code to run on host and target (or simulated) CPUs of the same architecture. It also includes a GDB stub to allow debugging of the target program as it runs in Valgrind, with "monitor commands" that allow querying the Valgrind tool for various information.
A considerable amount of performance is lost in these transformations (and usually, the code the tool inserts); usually, code run with Valgrind and the "none" tool (which does nothing to the IR) runs at 20% to 25% of the speed of the normal program.[7][8]](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:zcycfvljdjkc2ywtj33blgdl/bafkreighxogjwjq66ed5qqsnmghnt4dzkwkt5xzy4ccsyqn52ck5fmyc6i)