Rust/wasm32: is SharedArrayBuffer ever useful?

anon80458984 · June 27, 2022, 7:13am

For those using Rust on wasm32 (say Chrome), is there any time where SharedArrayBuffer is useful?

In all cases I have examined so far, usage of js_sys::SharedArrayBuffer can be replaced by js_sys::ArrayBuffer.

alice · June 27, 2022, 8:08am

My understanding is that a SharedArrayBuffer can be shared between multiple web workers running in parallel.

anon80458984 · June 27, 2022, 9:28am

To the best of my knowledge, yes. However, to the best of my knowledge:

there aren't any synchronization primitives over SharedArrayBuffer
in Rust/wasm, the only useful commands over SharedArrayBuffer are copy to vec / copy from slice; and even here, it is not clear what guarantees there are

So I am having a difficult time thinking of situations where SharedArrayBuffer is useful (maybe some external sync to say web worker thread 1 writes to first 10MB, web worker thread 2 writes to 2nd MB, ...) but in these cases, it's not obvious why not use ArrayBuffer instead with zero copy:

Transferrable objects are commonly used to share resources that can only be safely exposed to a single JavaScript thread at a time. For example, an ArrayBuffer is a transferrable object that owns a block of memory. When such a buffer is transferred between threads, the associated memory resource is detached from the original buffer and attached to the buffer object created in the new thread. The buffer object in the original thread is no longer usable because it no longer owns a memory resource.

Quoting:

Yandros · June 27, 2022, 9:50am

The following guide seems to clarify a bunch of things:

github.com

tc39/proposal-ecmascript-sharedmem/blob/55dfee88564e075a68b98ff4116121f6161953f4/TUTORIAL.md

# Shared memory - a brief tutorial

## Concurrent agents

In a browser setting it's natural to use WebWorkers for shared agents.  To recap, workers are created by allocating ```Worker``` objects, passing a URL of the script to be run in the worker:
```js
   var w = new Worker("myworker.js")
```
The worker and its creator communicate over a message channel.  In the creator,  a call to ```w.postMessage``` sends a message to the worker, and a handler on the worker object receives messages as events:
```js
w.postMessage("hi");     // send "hi" to the worker
w.onmessage = function (ev) {
  console.log(ev.data);  // prints "ho"
}
```
Meanwhile, in the worker, a global handler receives messages as events, and a call to the global ```postMessage``` function sends a message back to the worker's creator:
```js
onmessage = function (ev) {
  console.log(ev.data);  // prints "hi"
  postMessage("ho");     // sends "ho" back to the creator

This file has been truncated. show original

This is thus the culprit: the API of SharedArrayBuffers that ends up being exposed from within Rust does not include the actual usefulness of them; I guess because of browser compatibility (SABs have remained disabled for a few years due to spectre-related memory leakage and security implications; it's only somewhat recently that a new generation of SABs robust to these issues is being released, thus bringing back support for them).

bjorn3 · June 27, 2022, 10:12am

There are. It supports a futex like api and if you compile the sysroot with atomics support, this will be used to implement Mutexes and other synchronization primitives.

system · September 25, 2022, 10:13am

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.

Topic		Replies	Views
Sharedarraybuffer mechanics	11	427	February 13, 2024
postMessage(js_sys::SharedArrayBuffer): O(1) or O(n) time?	6	346	November 20, 2022
Rust / wasm multi threading	4	1614	January 20, 2021
Same origin shared memory: index.html + webworker	4	291	October 19, 2023
Question about https://github.com/rustwasm/wasm-bindgen/blob/main/examples/raytrace-parallel/src/pool.rs#L119	2	259	August 26, 2022

Rust/wasm32: is SharedArrayBuffer ever useful?

Related Topics