Clarification about the wording in SharedArrayBuffer

[Jumbub]

In the docs for SharedArrayBuffer there is the use of the word "eventually" to describe when side effects will become visible in other agents.

"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."

Is the data not instantaneously available to all agents when the buffer is modified?

I can't seem to find any other docs to indicate only "eventual" consistency, but my Google-foo on low level JS isn't the best.

[hamishwillee]

@wbamberg Do you know the answer to this, or can you suggest someone who might?

The text is consistent in that it indicates that updates in one context might take a while to "eventually" become visible in another. Later on it says:

Shared memory can be created and updated simultaneously in workers or the main thread. Depending on the system (the CPU, the OS, the Browser) it can take a while until the change is propagated to all contexts. To synchronize, atomic operations are needed.

That is a little confusing because as a naïve reader I assume that two things looking at the same thing (shared data) will see any changes instantly. My assumption is that even though the underlying data is the same it is protected by mutexes/semaphore-like thingy to ensure that changes are atomic, and it is not read in a half-way state. So probably the "eventually" means that you might have to wait a bit before you can read some data if it is in the process of being written.

[wbamberg]

I would try asking @sideshowbarker :).

But I think "eventually" is correct: because the data is shared among multiple threads it's not predictable when other threads will see the update, and as you say, that's what the Atomics stuff is for. What is weird to me in that sentence is "side effect" - why not just say "change" here?

[Jumbub]

Thanks for the clarification. I feel a bit silly because I've just now realised that, ofcourse, no matter how low level SharedArrayBuffer is implemented, data will never be instantaneously available to any cpu core / worker because of cpu caching (assuming cpu has cache layer ofcourse).

[hamishwillee]

Cool. I'm not planning on doing anything else with this unless you decide to add a PR to make this completely clear in the page. I wouldn't consider that silly - if one person can wonder why it isn't instant, then others might reasonably do so too.