Investigate implementing table.copy and table.init with a memcpy
#983
Labels
Comments
fitzgen
changed the title
table.copy with a memcpytable.copy and table.init with a memcpy
|
Note: this also applies to our implementation of |
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Dec 8, 2020
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Dec 8, 2020
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Dec 9, 2020
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Dec 15, 2020
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Dec 16, 2020
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Jan 12, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Jan 22, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Jan 22, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Jan 22, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Jan 27, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Jan 29, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Feb 4, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Feb 4, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Feb 4, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Feb 4, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Feb 11, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Feb 12, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Feb 18, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Feb 19, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
peterhuene
added a commit
to peterhuene/wasmtime
that referenced
this issue
Feb 26, 2021
This commit refactors `Table` in the runtime such that it can be created from a pointer to existing table data. The current `Vec` backing of the `Table` is considered to be "dynamic" storage. This will be used for the upcoming pooling allocator where table memory is managed externally to the instance. The `table.copy` implementation was improved to use slice primitives for doing the copying. Fixes bytecodealliance#983.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
#976 (comment)
I originally didn't do this in order to (a) conform with the spec in an obvious way, and (b) because I was unsure if table elements are something we can safely
memcpyaround, and (c) I wasn't sure that this actually matches the spec's behavior but I think it does.(Note: we shouldn't literally, actually use
memcpydirectly. We would usecopy_from_slice.)spec link: https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-copy
The text was updated successfully, but these errors were encountered: