Clarify structured clone behavior for WebAssembly objects. #1074

flagxor · 2017-05-23T05:34:34Z

PTAL
(Particularly around the MAY for secure origins)

jfbastien · 2017-05-23T05:44:42Z

Web.md

+### Structured Clone of a `WebAssembly.Memory`
+
+A `WebAssembly.Memory` is under some circumstances a
+[cloneable object](https://html.spec.whatwg.org/multipage/infrastructure.html#cloneable-objects), and will impact the


"will impact"? How solid is this prediction? Reference?

Revised to to say "will require changes to"
We could structure these as changes against said standards?
Domenic / Anne, WDYT?

jfbastien · 2017-05-23T05:45:34Z

Web.md

+
+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if `value` has an [[WebAssembly.Memory]] internal slot, then:


"has a" slot, no?

jfbastien · 2017-05-23T05:48:41Z

Web.md

+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if `value` has an [[WebAssembly.Memory]] internal slot, then:
+  1. Let `size` be value.[[BufferObject].


Brackets mismatch.

jfbastien · 2017-05-23T05:49:13Z

Web.md

+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if `value` has an [[WebAssembly.Memory]] internal slot, then:
+  1. Let `size` be value.[[BufferObject].


Code quotes mismatch on value compared to above? Or is that on purpose?

jfbastien · 2017-05-23T05:49:50Z

Web.md

+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if `value` has an [[WebAssembly.Memory]] internal slot, then:
+  1. Let `size` be value.[[BufferObject].


There's no such slot according to this snippet from above:

A WebAssembly.Module object represents the stateless result of compiling a WebAssembly binary-format module and contains one internal slot: [...]

jfbastien · 2017-05-23T05:50:16Z

Web.md

+
+* Otherwise, if `value` has an [[WebAssembly.Memory]] internal slot, then:
+  1. Let `size` be value.[[BufferObject].
+  2. If !  [IsSharedArrayBuffer](https://tc39.github.io/ecma262/#sec-issharedarraybuffer) is true, then:


What's with the bang? "If it's not shared is true"?

The bang means not throwing. It's a convention from the JavaScript Standard.

jfbastien · 2017-05-23T05:50:50Z

Web.md

+       [[AgentCluster]]: the [current Realm Record](https://tc39.github.io/ecma262/#current-realm)'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) }.
+    3. Otherwise:
+       1. Let `dataCopy` be [CreateByteDataBlock](https://tc39.github.io/ecma262/#sec-createbytedatablock)(size).
+          NOTE: This can throw a RangeError exception on allocation failure.


RangeError? Ew. That's standard?

Yeah, see the link.

jfbastien · 2017-05-23T05:51:13Z

Web.md

+    1. If `forStorage` is true, then throw a
+       ["DataCloneError" DomException](https://heycam.github.io/webidl/#datacloneerror).
+    2. Set `serialized` to { [[Type]]: "WebAssembly.Memory",
+       [[ArrayBufferData]]: value.[[BufferObject]].[[ArrayBufferData],


Mismatched bracket.

jfbastien · 2017-05-23T05:52:46Z

Web.md

+          value.[[BufferObject]].[[ArrayBufferData]], 0, size).
+       3. Set `serialized` to { [[Type]]: "WebAssembly.Memory",
+          [[ArrayBufferData]]: dataCopy, [[ArrayBufferByteLength]]: size }.
+


What if it's the reverse of 2. above with the weird bang? Doesn't seem to have a sequel for the opposite.

Shuffled round.

annevk · 2017-05-23T06:18:30Z

Web.md

@@ -124,6 +124,81 @@ MIME type mismatch or `opaque` response types
 [reject](http://tc39.github.io/ecma262/#sec-rejectpromise) the Promise with a
 `WebAssembly.CompileError`.

+### Structured Clone of a `WebAssembly.Memory`
+
+A `WebAssembly.Memory` is under some circumstances a


"Under some circumstances"?

Right, it's always a serializable object. But sometimes that serialization throws.

annevk · 2017-05-23T06:19:49Z

I'm a bit confused. This seems to address #1048 to some extent, yet you didn't address the design questions raised there.

annevk · 2017-05-23T06:22:21Z

Web.md

+* Otherwise, if `value` has an [[WebAssembly.Module]] internal slot, then:
+  1. If `forStorage` is true, implementations MAY chose to exclude
+     "insecure origins", in which case they should throw a
+     ["DataCloneError" DomException](https://heycam.github.io/webidl/#datacloneerror).


This isn't precise enough. (Needs a source to base "insecure origins" on and the should needs to be a must. It also doesn't seem optimal to have varying behavior between implementations here.

Yes. This needs to decide which object's origin is being tested, per whatwg/html#2518 (comment), and needs to link to https://w3c.github.io/webappsec-secure-contexts/#settings-object applied to one of the settings objects involved (depending on which one you choose).

Revised.
JF + others. Are other browsers willing to require the more strict behavior on IDB + secure origins?

domenic · 2017-05-23T10:51:13Z

Web.md

@@ -124,6 +124,81 @@ MIME type mismatch or `opaque` response types
 [reject](http://tc39.github.io/ecma262/#sec-rejectpromise) the Promise with a
 `WebAssembly.CompileError`.

+### Structured Clone of a `WebAssembly.Memory`


This should be Structured serialization; structured cloning is no longer a thing at the spec level (although it can be used as an informal term outside of specs).

domenic · 2017-05-23T10:51:39Z

Web.md

+### Structured Clone of a `WebAssembly.Memory`
+
+A `WebAssembly.Memory` is under some circumstances a
+[cloneable object](https://html.spec.whatwg.org/multipage/infrastructure.html#cloneable-objects), and will impact the


Should be "serializable object" and link to https://html.spec.whatwg.org/multipage/infrastructure.html#serializable-objects

domenic · 2017-05-23T10:52:04Z

Web.md

@@ -124,6 +124,81 @@ MIME type mismatch or `opaque` response types
 [reject](http://tc39.github.io/ecma262/#sec-rejectpromise) the Promise with a
 `WebAssembly.CompileError`.

+### Structured Clone of a `WebAssembly.Memory`
+
+A `WebAssembly.Memory` is under some circumstances a


Right, it's always a serializable object. But sometimes that serialization throws.

domenic · 2017-05-23T10:52:47Z

Web.md

+
+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if `value` has an [[WebAssembly.Memory]] internal slot, then:


Nit: generally we use value for variables, not value.

domenic · 2017-05-23T10:53:30Z

Web.md

+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if `value` has an [[WebAssembly.Memory]] internal slot, then:
+  1. Let `size` be value.[[BufferObject].


Is size a number or an object?

number, changed (was the wrong one).

domenic · 2017-05-23T10:54:50Z

Web.md

+  1. Let `size` be value.[[BufferObject].
+  2. If !  [IsSharedArrayBuffer](https://tc39.github.io/ecma262/#sec-issharedarraybuffer) is true, then:
+    1. If `forStorage` is true, then throw a
+       ["DataCloneError" DomException](https://heycam.github.io/webidl/#datacloneerror).


Formatting:

"`[DataCloneError](https://heycam.github.io/webidl/#datacloneerror)" `[DOMException](https://heycam.github.io/webidl/#dfn-DOMException)`

domenic · 2017-05-23T10:56:06Z

Web.md

+       [[ArrayBufferData]]: value.[[BufferObject]].[[ArrayBufferData],
+       [[ArrayBufferByteLength]]: size,
+       [[AgentCluster]]: the [current Realm Record](https://tc39.github.io/ecma262/#current-realm)'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) }.
+    3. Otherwise:


So WebAssembly.Memory objects can be backed by non-shared array buffers!? Wow, interesting.

Yeah memories and modules need to opt in to being shared. Can't instantiate a not-share-aware module with a shared memory.

domenic · 2017-05-23T10:58:19Z

Web.md

+* Otherwise, if `value` has an [[WebAssembly.Module]] internal slot, then:
+  1. If `forStorage` is true, implementations MAY chose to exclude
+     "insecure origins", in which case they should throw a
+     ["DataCloneError" DomException](https://heycam.github.io/webidl/#datacloneerror).


Yes. This needs to decide which object's origin is being tested, per whatwg/html#2518 (comment), and needs to link to https://w3c.github.io/webappsec-secure-contexts/#settings-object applied to one of the settings objects involved (depending on which one you choose).

domenic · 2017-05-23T10:59:45Z

Web.md

+     whose [[Module]] internal slot value is `serialized`.[[Module]].
+
+The semantics of a structured clone is as-if the binary source, from which the
+`WebAssembly.Module` was compiled, were cloned and recompiled into the target realm.


"serialized, then deserialized and recompiled the target realm"

domenic · 2017-05-23T11:00:16Z

Web.md

+The semantics of a structured clone is as-if the binary source, from which the
+`WebAssembly.Module` was compiled, were cloned and recompiled into the target realm.
+Engines should attempt to share/reuse internal compiled code when performing
+a structured clone although, in corner cases like CPU upgrade or browser


Nit: comma should be maybe "when performing structured serialization, although in corner cases..."

domenic · 2017-05-23T11:02:29Z

This seems to address #1048 to some extent, yet you didn't address the design questions raised there.

Right, it seems to go the route of treating these as non-Web IDL-defined objects. Which is fine for now, I guess, since they aren't defined using Web IDL yet.

annevk · 2017-05-23T11:25:16Z

Well, #1068 added some IDL syntax. It would be a lot better to first make a choice there as the current mismatch will just end up being super confusing the moment anyone outside the people closely involved starts looking at this.

flagxor · 2017-05-23T21:52:00Z

PTAL
JF + others, are you ok with the secure origin requirement around forStorage?

Not sure how to resolve the syntax concern, advice appreciated.

jfbastien · 2017-05-23T22:45:49Z

Let me ping others in my team about the details.

domenic · 2017-05-24T01:43:58Z

Web.md

@@ -124,6 +124,86 @@ MIME type mismatch or `opaque` response types
 [reject](http://tc39.github.io/ecma262/#sec-rejectpromise) the Promise with a
 `WebAssembly.CompileError`.

+### Structured serialization of a `WebAssembly.Memory`
+
+A `WebAssembly.Memory` is under some circumstances a


Remove "under some circumstances", here and below. It's always a serializable object; sometimes serialization throws.

domenic · 2017-05-24T01:44:25Z

Web.md

+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if *value* has a [[WebAssembly.Memory]] internal slot, then:
+  1. Let `size` be the number value.[[BufferObject]].[[ArrayBufferByteLength]].


Nit: size, forStorage should all be italicized, not code-ified.

domenic · 2017-05-24T01:45:01Z

Web.md

+       2. Otherwise:
+         1. Let *dataCopy* be [CreateByteDataBlock](https://tc39.github.io/ecma262/#sec-createbytedatablock)(size).
+            NOTE: This can throw a RangeError exception on allocation failure.
+         2. Perform `CopyDataBlockBytes`(https://tc39.github.io/ecma262/#sec-copydatablockbytes)


Link, not code, for CopyDataBlockBytes

domenic · 2017-05-24T01:45:17Z

Web.md

+  1. Let `size` be the number value.[[BufferObject]].[[ArrayBufferByteLength]].
+  2. If !  [IsSharedArrayBuffer](https://tc39.github.io/ecma262/#sec-issharedarraybuffer)(*value*) is true, then:
+    1. If `forStorage` is true, then throw a
+       "`[DataCloneError](https://heycam.github.io/webidl/#datacloneerror)"


Missing closing backtick

domenic · 2017-05-24T01:46:18Z

Web.md

+* Otherwise, if *serialized*.[[Type]] is "WebAssembly.Memory", then:
+  1. If *targetRealm*'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) is not
+     *serialized*.[[AgentCluster]], then throw a
+     ["DataCloneError" DomException](https://heycam.github.io/webidl/#dfn-DOMException).


Use the above formatting for the DOMException.

domenic · 2017-05-24T01:50:13Z

Web.md

+  1. If *forStorage* is true and the environmental settings
+     object of *value* is not "Secure" per
+     [this](https://w3c.github.io/webappsec-secure-contexts/#settings-object)
+     algorithm, throw a


It'd be more conventional to say

per the "Is the environment settings object a secure context?" algorithm

with a link, instead of "this".

domenic · 2017-05-24T01:50:23Z

Web.md

+     object of *value* is not "Secure" per
+     [this](https://w3c.github.io/webappsec-secure-contexts/#settings-object)
+     algorithm, throw a
+     ["DataCloneError" DomException](https://heycam.github.io/webidl/#datacloneerror).


Copy DOMException formatting from above.

domenic · 2017-05-24T01:50:36Z

Web.md

+* Otherwise, if *serialized*.[[Type]] is "WebAssembly.Module", then:
+  1. If *targetRealm*'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) is not
+     *serialized*.[[AgentCluster]], then throw a
+     ["DataCloneError" DomException](https://heycam.github.io/webidl/#dfn-DOMException).


Copy DOMException formatting from above.

domenic · 2017-05-24T01:51:08Z

Web.md

+     whose [[Module]] internal slot value is *serialized*.[[Module]].
+
+The semantics of a structured serialization is as-if the binary source, from which the
+`WebAssembly.Module` was compiled, serialized, then deserialized, and recompiled into the target realm.


Missing word in this sentence? I think it should be "is serialized"

domenic · 2017-05-24T01:51:27Z

Web.md

+a structured seraialization, although in corner cases like CPU upgrade or browser
+update, this may not be possible and full recompilation may be necessary.
+
+Given the above engine optimizations, structured cloning provides developers


structured serialization

flagxor · 2017-05-24T03:34:09Z

PTAL

annevk · 2017-05-24T04:48:25Z

We could structure these as changes against said standards?

Sounds good to me. We usually call these kind of things "monkey patches". It would be good to file an issue upstream (against HTML at least) to make them aware of this. Having said that, this again somewhat depends on your strategy. If you do go with IDL you don't need to change HTML. IDL objects are more extensible than objects that are defined using more primitive means.

domenic

Mostly nits by now :)

domenic · 2017-05-24T19:39:50Z

Web.md

+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if *value* has a [[WebAssembly.Memory]] internal slot, then:
+  1. Let *size* be the number value.[[BufferObject]].[[ArrayBufferByteLength]].


Nit: remove "the number"; italicize value and size everywhere throughout.

domenic · 2017-05-24T19:41:35Z

Web.md

+  1. Let *size* be the number value.[[BufferObject]].[[ArrayBufferByteLength]].
+  2. If ! [IsSharedArrayBuffer](https://tc39.github.io/ecma262/#sec-issharedarraybuffer)(*value*.[[BufferObject]]) is true, then:
+    1. If *forStorage* is true, then throw a
+       "`[DataCloneError](https://heycam.github.io/webidl/#datacloneerror)`"


It appears I gave bad advice here, viewing the output: https://github.com/flagxor/design/blob/5fa0fbf29437688f86fcff1efeaabcff0770a0bc/Web.md

I think the backticks need to be inside the brackets, e.g.

"[`DataCloneError`](...)"

Here and everywhere.

domenic · 2017-05-24T19:42:28Z

Web.md

+         1. Let *dataCopy* be [CreateByteDataBlock](https://tc39.github.io/ecma262/#sec-createbytedatablock)(size).
+            NOTE: This can throw a RangeError exception on allocation failure.
+         2. Perform [CopyDataBlockBytes](https://tc39.github.io/ecma262/#sec-copydatablockbytes)
+            (dataCopy, 0,


Nits: no space before the open paren; dataCopy should be italicized here and everywhere

domenic · 2017-05-24T19:48:54Z

Web.md

+     `[DOMException](https://heycam.github.io/webidl/#dfn-DOMException)`.
+  2. Otherwise,
+     if ! [IsSharedArrayBuffer](https://tc39.github.io/ecma262/#sec-issharedarraybuffer)(*serialized*.[[ArrayBufferData]]) is true, then:
+     Set *value* to a new WebAssembly.Memory object in *targetRealm*


Nit: just say "then set" instead of "then: Set"

domenic · 2017-05-24T19:50:02Z

Web.md

+     "`[DataCloneError](https://heycam.github.io/webidl/#datacloneerror)`"
+     `[DOMException](https://heycam.github.io/webidl/#dfn-DOMException)`.
+  2. Otherwise,
+     if ! [IsSharedArrayBuffer](https://tc39.github.io/ecma262/#sec-issharedarraybuffer)(*serialized*.[[ArrayBufferData]]) is true, then:


You can't use IsSharedArrayBuffer on a data block (which is the type of [[ArrayBufferData]]). You can only say "is a Shared Data Block"

domenic · 2017-05-24T19:50:19Z

Web.md

+     2. The `SharedArrayBuffer`'s internal slot [[ArrayBufferByteLength]]
+        is set to *serialized*.[[BufferObject]].[[ArrayBufferByteLength]].
+  3. Otherwise,
+     Set *value* to a new WebAssembly.Memory object in *targetRealm*


Nit: lowercase "set"

domenic · 2017-05-24T19:51:03Z

Web.md

+     whose [[BufferObject]] internal slot is set to a new
+     [[ArrayBufferData]] internal slot value is
+     set to a new `SharedArrayBuffer`, where:
+     1. The `SharedArrayBuffer`'s internal slot [[ArrayBufferData]]


Nit: this should be consistified with the below; this says "The SharedArrayBuffer's internal slot" whereas the below gives a name to it and says "mem's internal slot"

lukewagner · 2017-05-26T22:18:56Z

Web.md

+          [[ArrayBufferData]]: value.[[BufferObject]].[[ArrayBufferData]],
+          [[ArrayBufferByteLength]]: size,
+          [[AgentCluster]]: the [current Realm Record](https://tc39.github.io/ecma262/#current-realm)'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) }.
+       2. Otherwise:


I think this "Otherwise:" step is meant to apply to the not-SAB case in which case it should be unindented. Also, the same comment about losing 'maximum' applies. Moreover, looking at the rich preview I think the indenting is messed up in a few other places as well.

Oops. Done.

lukewagner · 2017-05-26T22:23:17Z

Web.md

+  1. If *targetRealm*'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) is not
+     *serialized*.[[AgentCluster]], then throw a
+     "`[DataCloneError](https://heycam.github.io/webidl/#datacloneerror)`"
+     `[DOMException](https://heycam.github.io/webidl/#dfn-DOMException)`.


If we want to be symmetric with AB/SAB, I think we only need this AgentCluster check for the shared-Memory case.

Ah yes. Done.

lukewagner · 2017-05-26T22:25:25Z

Web.md

+     Set *value* to a new WebAssembly.Memory object in *targetRealm*
+     whose [[BufferObject]] internal slot is set to a new
+     [[ArrayBufferData]] internal slot value is
+     set to a new `SharedArrayBuffer`, where:


The deserialization of shared and unshared Memory seems to shear off the maximum property.

Good point!. Fixing.

flagxor · 2017-07-16T23:17:55Z

Long delay on this one, sorry about that.

PTAL

annevk · 2017-07-17T07:29:01Z

So you decided not to go with IDL? That will make it harder once you eventually get to wasm bindings.

domenic · 2017-07-18T22:08:34Z

Web.md

+     1. Let *dataCopy* be [CreateByteDataBlock](https://tc39.github.io/ecma262/#sec-createbytedatablock)(*size*).
+        NOTE: This can throw a RangeError exception on allocation failure.
+     2. Perform [CopyDataBlockBytes](https://tc39.github.io/ecma262/#sec-copydatablockbytes)
+        (*dataCopy*, 0,


Nit: there shouldn't be a linebreak before the open paren

domenic · 2017-07-18T22:09:06Z

Web.md

+        [`DOMException`](https://heycam.github.io/webidl/#dfn-DOMException).
+     2. Set *value* to a new WebAssembly.Memory object in *targetRealm*
+        whose [[BufferObject]] internal slot is set to a new
+        [[ArrayBufferData]] internal slot *value* is


It looks like "a new [[ArrayBufferData]] internal slot value is set to a new" should be deleted; this sentence is a bit jumbled.

domenic · 2017-07-18T22:09:13Z

Web.md

+        [[ArrayBufferData]] internal slot *value* is
+        set to a new `SharedArrayBuffer` *mem*, where:
+        1. *mem*'s internal slot [[ArrayBufferData]]
+           if set to *serialized*.[[BufferObject]].[[ArrayBufferData]].


domenic · 2017-07-18T22:10:52Z

Web.md

+        2. *mem*'s internal slot [[ArrayBufferByteLength]]
+           is set to *serialized*.[[BufferObject]].[[ArrayBufferByteLength]].
+        3. *mem*'s internal slot [[WebAssembly.Memory]].[[maximum]]
+           is set to *serialized*.[[MemoryMaximum]].


mem does not have a [[WebAssembly.Memory]] internal slot; value does.

oops, fixed.

domenic · 2017-07-18T22:11:49Z

Web.md

+        *serialized*.[[AgentCluster]], then throw a
+        "[`DataCloneError`](https://heycam.github.io/webidl/#datacloneerror)"
+        [`DOMException`](https://heycam.github.io/webidl/#dfn-DOMException).
+     2. Set *value* to a new WebAssembly.Memory object in *targetRealm*


In both branches you need to set value's [[WebAssembly.Memory]] to a new Memory.memory object before you can set properties on [[WebAssembly.Memory]].

It seems like you also need to create some kind of alias between the Memory.memory and the [[ArrayBufferData]]? Like CreateMemoryObject does?

domenic · 2017-07-18T22:15:22Z

Web.md

+     "[`DataCloneError`](https://heycam.github.io/webidl/#datacloneerror)"
+     [`DOMException`](https://heycam.github.io/webidl/#dfn-DOMException).
+  2. Otherwise, set *value* to a new WebAssembly.Module object in *targetRealm*
+     whose [[Module]] internal slot *value* is *serialized*.[[Module]].


s/Module/WebAssembly.Module

domenic · 2017-07-18T22:15:36Z

Web.md

+The semantics of a structured serialization is as-if the binary source, from which the
+`WebAssembly.Module` was compiled, is serialized, then deserialized, and recompiled into the target realm.
+Engines should attempt to share/reuse internal compiled code when performing
+a structured seraialization, although in corner cases like CPU upgrade or browser


Typo "seraialization"

lukewagner · 2017-07-18T23:34:57Z

Web.md

+        [[ArrayBufferByteLength]]: *size*,
+        [[MemoryMaximum]]: *maximum*,
+        [[AgentCluster]]: the [current Realm Record](https://tc39.github.io/ecma262/#current-realm)'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) }.
+  4. Otherwise:


Based on today's poll, I think this case would throw (and be asserted not to happen on the deserialize side).

I'm curious if this should throw or be a messageerror instead.

IIUC, messageerrors only pop out when the error condition is dependent on the recipient; if the error is only depending on the argument's type (and we could consider shared-ness to be part of the memory's type), then I think this would throw just as if you tried to pass a Function.

I see, makes sense.

changed to throw in the non-shared case as per our poll.

lukewagner · 2017-07-18T23:40:47Z

Web.md

+
+* Otherwise, if *value* has a [[WebAssembly.Memory]] internal slot, then:
+  1. Let *size* be *value*.[[BufferObject]].[[ArrayBufferByteLength]].
+  2. Let *maximum* be *value*.[[WebAssembly.Memory]].[[maximum]].


IIUC, [[maximum]] is "reaching into" the memory defined by the core wasm spec. In that case, could you add a link to https://webassembly.github.io/spec/exec/runtime.html#memory-instances, rename to max and note that the value is a u32? (optional u32)?

Reworked to lean on that.

flagxor · 2017-07-27T06:49:56Z

PTAL

annevk@ Unsure on the whether WebIDL makes more sense for the Web embedding, JS.md likely needs this notation to match up with the ES spec. Will talk more to domenic next week on notation preferences. Mainly trying to narrow what's currently here (as before the PR it just says structured clone).
Do I understand correctly your preference is WebIDL here, or throughout?

annevk · 2017-07-27T07:10:45Z

@flagxor based on the discussion in #1048 it's my understanding that eventually these objects need to be exposed inside wasm (Wasm?) as well. It's also my understanding that there will be a wasm bindings for Web IDL. It would therefore be much "cheaper" to define these in IDL (and also provide a more consistent API from the eventual wasm side of things).

And as a lesser concern, it matters for how we organize the specifications. If you define these without IDL we'll need to define the serialization/deserialization in HTML, but if you define them with IDL you can define everything in the wasm standard (or wasm API standard or whatever it is).

domenic · 2017-07-27T18:46:03Z

Although I think it's good to have a discussion about IDL vs. not, I think this PR can proceed without resolving that. This PR does an admiral job of formalizing the semantics of structured serialization, which is sorely needed. It provides a precise specification implementations can use to get interoperable behavior. The spec structuring (IDL vs. not) can be fixed later, without changing any observable behavior.

Now, to continue the review efforts...

domenic

LGTM, only two nits left. Please feel free to merge after fixing instead of going through another round-trip :).

domenic · 2017-07-27T20:36:42Z

Web.md

+[StructuredDeserialize](https://html.spec.whatwg.org/multipage/infrastructure.html#structureddeserialize) adds a new step after step 12:
+
+* Otherwise, if *serialized*.[[Type]] is "WebAssembly.Memory", then:
+  1. Assert [IsSharedArrayBuffer](https://tc39.github.io/ecma262/#sec-issharedarraybuffer)(*serialized*.[[ArrayBufferData]]) is true.


You can't use IsSharedArrayBuffer on a data block, only on JavaScript objects. Instead, this should be "Assert: serialized.[[ArrayBufferData]] is a Shared Data Block.

domenic · 2017-07-27T20:38:42Z

Web.md

+`WebAssembly.Module` was compiled, is serialized, then deserialized, and recompiled into the target realm.
+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 may not be possible and full recompilation may be necessary.


Nit: s/may/might

lukewagner · 2017-07-27T22:35:03Z

Web.md

+        1. *buf*'s internal slot [[ArrayBufferData]]
+           aliases *mem*'s linear memory.
+        2. *buf*'s internal slot [[ArrayBufferByteLength]]
+           is set to the byte length of *mem*'s linear memory.


I think there is a spec-level "race" here with concurrent grow_memory: the byte length can be different than when it was tupled on the serialization side. I think the fix is to pull length from the core spec memory instance so it's "fresh". Here (and above, where you have Memory.memory), it'd be good to link to https://webassembly.github.io/spec/exec/runtime.html#memory-instances to say exactly what you're referring to.

There's also a question of whether grow_memory invalidates the tupled [[ArrayBufferData]]. Actually, I'm not clear what the relationship is to the data : vec(byte) field of meminst and [[ArrayBufferData]]. I think there's not a real question here; it's just a matter of getting the spec concepts to line up with reality.

Thinking about this, it probably would make sense if the core spec provided an allochostmem function to delegate to for creating that memory instance, just like it does for functions. (And similarly for tables and globals.) I can add that.

Yeah, I was thinking something like that might be necessary. You also have to think about growing and avoiding (at a spec level) leaving "stale" pointers to old buffers around in extant SABs.

@lukewagner Agreed there is a spec race in terms of getting to the other side of serialization, I think I've now fixed that. Additionally (just to make sure we're on the same page), there's an actually race around two parties accessing the buffer (and then later its size). Or said another way: once you've fished out the SAB, it's size stays fixed even if wasm grows the memory.

@rossberg-chromium Adding the op seems to make sense, but trying to clarify here without it for now.

lukewagner · 2017-07-27T22:39:19Z

Web.md

+  1. If *targetRealm*'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) is not
+     *serialized*.[[AgentCluster]], then throw a
+     "[`DataCloneError`](https://heycam.github.io/webidl/#datacloneerror)"
+     [`DOMException`](https://heycam.github.io/webidl/#dfn-DOMException).


@domenic Just to be clear, this means a Module can be post-messaged between some windows (linked by owner and same-origin, same-origin and iframe, and maybe even cross-origin; I'm not sure how to read the could in "could be same-origin" in 8.1.3.10). Is that right?

Basically windows that can document.domain each other are in the same agent (similar-origin window agent). And therefore also in the same agent cluster.

Yes, sorry for not getting back to you earlier, but @annevk covered it. Also note that "same origin" and "same origin-domain" are distinct concepts; whether a Window is same origin with another is immutable, but whether it's same origin-domain can change (by changing document.domain). Thus the "could be".

Gotcha, thanks. So my root question was whether this definition was permissive enough to allow cross-origin code caching (e.g., in the local IDB of a CDN origin), but it looks like 'no', that'll have to wait for foreign-fetch.

Yep, that matches my understanding too.

Actually, it looks like foreign fetch is no longer being proposed. So what's the recommended mechanism for explicit sharing of compiled code that doesn't rely on pure HTTP cache magic? I think this is a really important capability for frameworks/middleware in the future.

What was the reasoning for restricting Modules from being postMessage'd across agent clusters?

It's hard for me to understand how this squares with serializing Modules in IndexedDB (which this patch seems to allow AFAICT, though I don't see how it specifies the sub-serialization of the agent cluster).

rossberg · 2017-07-28T11:32:00Z

JS.md

- * [[Memory]] : a [`Memory.memory`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/memory.mli)
- * [[BufferObject]] : the current `ArrayBuffer` whose [[ArrayBufferByteLength]]
-   matches the current byte length of [[Memory]]
+ * [[WebAssembly.Memory]] : a [`Memory.memory`](https://webassembly.github.io/spec/exec/runtime.html#memory-instances)


s/Memory.memory/memory instance/

done, yeah, that was goofy.

rossberg · 2017-07-28T11:32:30Z

JS.md

@@ -571,7 +555,7 @@ Return the result of [`CreateMemoryObject`](#creatememoryobject)(`memory`).

 ### CreateMemoryObject

-Given a [`Memory.memory`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/memory.mli#L1)
+Given a [`Memory.memory`](https://webassembly.github.io/spec/exec/runtime.html#memory-instances)


rossberg · 2017-07-28T11:33:28Z

JS.md

@@ -639,7 +623,7 @@ A `WebAssembly.Table` object contains a single [table](Semantics.md#table)
 which can be simultaneously referenced by multiple `Instance` objects. Each
 `Table` object has two internal slots:

- * [[Table]] : a [`Table.table`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/table.mli#L1)
+ * [[Table]] : a [`Table.table`](https://webassembly.github.io/spec/exec/runtime.html#table-instances)


s/Table.table/table instance/

rossberg · 2017-07-28T11:45:27Z

Web.md

+        1. *buf*'s internal slot [[ArrayBufferData]]
+           aliases *mem*'s linear memory.
+        2. *buf*'s internal slot [[ArrayBufferByteLength]]
+           is set to the byte length of *mem*'s linear memory.


Thinking about this, it probably would make sense if the core spec provided an allochostmem function to delegate to for creating that memory instance, just like it does for functions. (And similarly for tables and globals.) I can add that.

flagxor · 2017-08-12T01:52:32Z

PTAL

domenic

A few more questions and nits, but still seems mergeable from my perspective. I'm not sure I fully understand all the memory instance stuff though.

domenic · 2017-08-14T17:13:35Z

JS.md

-aliases `M.[[Memory]]` and whose 
-[[[ArrayBufferByteLength]]](http://tc39.github.io/ecma262/#sec-properties-of-the-arraybuffer-prototype-object)
-is set to the new byte length of `M.[[Memory]]`.
+If `M.[[BufferObject]]` is a not Shared Data Block:


Should be M.[[BufferObject]].[[ArrayBufferData]]

Also, I think you need to drop the "not"

domenic · 2017-08-14T17:13:56Z

JS.md

+     aliases `M.[[WebAssembly.Memory]]` and whose
+     [[[ArrayBufferByteLength]]](http://tc39.github.io/ecma262/#sec-properties-of-the-arraybuffer-prototype-object)
+     is set to the new byte length of `M.[[WebAssembly.Memory]]`.
+  2. Do the same in all Shared Data Block which mirror `M.[[BufferObject]]`,


"Blocks", not "Block", I guess

I was expecting this to look more like: "Perform step 1 to all WebAssembly.Memory objects N in the same Agent Cluster as M where N.[[BufferObject]].[[ArrayBufferData]] == M.[[BufferObject]].[[ArrayBufferData]]..."

domenic · 2017-08-14T17:14:17Z

JS.md

+  2. Do the same in all Shared Data Block which mirror `M.[[BufferObject]]`,
+     doing so atomically in relation to other updates of such blocks.
+Otherwise:
+  1. perform [`DetachArrayBuffer`](http://tc39.github.io/ecma262/#sec-detacharraybuffer)(`M.[[BufferObject]]`).


Uppercase "P"

domenic · 2017-08-14T17:16:33Z

Web.md

+* Otherwise, if *value* has a [[WebAssembly.Memory]] internal slot, then:
+  1. Let *memory* be *value*.[[WebAssembly.Memory]], which is a
+     [`memory instance`](https://webassembly.github.io/spec/exec/runtime.html#memory-instances).
+  2. Let *data* be *memory*'s `data` field, which is a sizable vector of bytes.


Is "sizable" standard terminology here? If not, "resizable" is probably more clear, as I usually think of "sizable" as a synonym for "large"

domenic · 2017-08-14T17:17:48Z

Web.md

+* Otherwise, if *value* has a [[WebAssembly.Memory]] internal slot, then:
+  1. Let *memory* be *value*.[[WebAssembly.Memory]], which is a
+     [`memory instance`](https://webassembly.github.io/spec/exec/runtime.html#memory-instances).
+  2. Let *data* be *memory*'s `data` field, which is a sizable vector of bytes.


I'm confused. Is data a Shared Data Block, or a sizable vector of bytes? Are the two concepts the same somehow?

lukewagner · 2017-08-14T20:24:15Z

JS.md

+     is set to the new byte length of `M.[[WebAssembly.Memory]]`.
+  2. Do the same in all Shared Data Block which mirror `M.[[BufferObject]]`,
+     doing so atomically in relation to other updates of such blocks.
+Otherwise:


nit: markdown puts this at the end of item 2, I think you need a \n before or something to render correctly

lukewagner · 2017-08-14T20:29:47Z

JS.md

@@ -571,7 +555,7 @@ Return the result of [`CreateMemoryObject`](#creatememoryobject)(`memory`).

 ### CreateMemoryObject

-Given a [`Memory.memory`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/memory.mli#L1)
+Given a [memory instance](https://webassembly.github.io/spec/exec/runtime.html#memory-instances)
 `m`, to create a `WebAssembly.Memory`:

 Let `buffer` be a new `ArrayBuffer` whose


Should this be changed to create a new SharedArrayBuffer depending on whether m is shared? Or is that a separate proposal?

I probably should just update it in the threads repo, I think.

littledan · 2018-02-21T14:52:32Z

I've put a version of this patch which just handles Modules and not Memory out for review at WebAssembly/spec#711 .

The semantics here are - forStorage serialization is disallowed - Transfers are only permitted within an agent cluster - Transfer of Memory backed by SharedArrayBuffers makes the buffer available in the source and the destination, with no resulting detached buffer. - Transfer of Memory backed by ArrayBuffers is disallowed. This specification attempts to be well-integrated with HTML by defining n terms of the serialization behavior of Memory as a platform object, and using the sub-serialization of the underlying SharedArrayBuffer to check for transferring within an agent cluster, and not to IndexedDB. Based on the earlier PR at WebAssembly/design#1074

littledan · 2018-03-04T17:54:29Z

For the SharedArrayBuffer side, I put up a PR in the threads fork at WebAssembly/threads#90 . Is there anything important in this PR which is missing from these patches? If not, maybe this thread could be closed. Thanks for the great work on this thread which made my job in these two PRs straightforward.

* [spec] Normative: Store is per agent cluster With the WebAssembly threads proposal, a single Memory can be shared between multiple agents within an agent cluster. This patch associates a WebAssembly store with an agent cluster, rather than an agent, and updates the WebAssembly JS API to define the store for an agent as the store for its surrounding agent cluster. * [spec] Normative: Define serialization for SAB Memory The semantics here are - forStorage serialization is disallowed - Transfers are only permitted within an agent cluster - Transfer of Memory backed by SharedArrayBuffers makes the buffer available in the source and the destination, with no resulting detached buffer. - Transfer of Memory backed by ArrayBuffers is disallowed. This specification attempts to be well-integrated with HTML by defining n terms of the serialization behavior of Memory as a platform object, and using the sub-serialization of the underlying SharedArrayBuffer to check for transferring within an agent cluster, and not to IndexedDB. Based on the earlier PR at WebAssembly/design#1074

numbermaniac · 2019-04-26T02:42:00Z

JS.md

@@ -219,7 +219,7 @@ is thrown.

 This function returns a new `Array` every time it is called. Each such `Array` is produced by mapping each
 [`Ast.export`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L152)
-`e` of [moduleObject.[[Module]].exports](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L187)
+`e` of [moduleObject.[[WebAssemby.Module]].exports](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L187)


WebAssembly is spelt incorrectly here.

littledan · 2019-04-26T04:56:54Z

This has landed in the specification; I think we can close this PR.

binji · 2019-04-29T19:05:10Z

This has landed in the specification; I think we can close this PR.

Agreed.

flagxor requested review from jfbastien, domenic, rossberg and lukewagner May 23, 2017 05:34

jfbastien reviewed May 23, 2017

View reviewed changes

annevk reviewed May 23, 2017

View reviewed changes

domenic suggested changes May 23, 2017

View reviewed changes

flagxor force-pushed the clone1 branch 2 times, most recently from d0d94d9 to 63ceaaa Compare May 23, 2017 21:50

domenic suggested changes May 24, 2017

View reviewed changes

flagxor force-pushed the clone1 branch from 63ceaaa to 5fa0fbf Compare May 24, 2017 03:32

domenic suggested changes May 24, 2017

View reviewed changes

lukewagner requested changes May 26, 2017

View reviewed changes

flagxor force-pushed the clone1 branch 4 times, most recently from a868d19 to 97f0e42 Compare July 16, 2017 23:17

domenic reviewed Jul 18, 2017

View reviewed changes

lukewagner reviewed Jul 18, 2017

View reviewed changes

binji mentioned this pull request Jul 18, 2017

Structured{De,}Serialize of WebAssembly.Memory WebAssembly/threads#47

Closed

lukewagner reviewed Jul 18, 2017

View reviewed changes

flagxor force-pushed the clone1 branch 2 times, most recently from 7a9b50d to 10e0424 Compare July 27, 2017 06:47

domenic approved these changes Jul 27, 2017

View reviewed changes

lukewagner reviewed Jul 27, 2017

View reviewed changes

rossberg reviewed Jul 28, 2017

View reviewed changes

flagxor force-pushed the clone1 branch from 10e0424 to 4c24594 Compare August 12, 2017 01:49

Clarify structured clone behavior for WebAssembly objects.

6e33a99

flagxor force-pushed the clone1 branch from 4c24594 to 6e33a99 Compare August 12, 2017 01:51

domenic reviewed Aug 14, 2017

View reviewed changes

lukewagner reviewed Aug 14, 2017

View reviewed changes

flagxor requested a review from littledan October 3, 2017 22:05

binji mentioned this pull request Oct 30, 2017

Need JS API: postMessage a Memory WebAssembly/threads#77

Closed

domenic mentioned this pull request Dec 7, 2017

[audioworklet] Passing AudioWorkletNodeOptions to AudioWorkletProcessor constructor WebAudio/web-audio-api#1459

Closed

littledan mentioned this pull request Feb 21, 2018

[spec] Normative: Support [Serializable] for WebAssembly.Module WebAssembly/spec#711

Merged

littledan mentioned this pull request Mar 4, 2018

Define postMessage of shared Memory WebAssembly/threads#90

Merged

numbermaniac reviewed Apr 26, 2019

View reviewed changes

binji closed this Apr 29, 2019


		[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:

		* Otherwise, if `value` has an [[WebAssembly.Memory]] internal slot, then:

Clarify structured clone behavior for WebAssembly objects. #1074

Clarify structured clone behavior for WebAssembly objects. #1074

Uh oh!

Conversation

flagxor commented May 23, 2017

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

annevk commented May 23, 2017

Uh oh!

annevk May 23, 2017 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jfbastien May 23, 2017 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

annevk May 23, 2017 •

edited

Loading

jfbastien May 23, 2017 •

edited

Loading