Skip to content

Fixed method signature of Atomics.waitAsync #51602

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 6 commits into from
Dec 2, 2022
Merged

Fixed method signature of Atomics.waitAsync #51602

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
71f6c9c
Added method overloading for Atomics.waitAsync(Int32Array, number, nu…
Eyal-Shalev Nov 20, 2022
da59cd1
fixed types
Eyal-Shalev Nov 20, 2022
fff03ff
fixed types
Eyal-Shalev Nov 20, 2022
a105b9e
fixed line ending
Eyal-Shalev Nov 20, 2022
29e1141
CR fix
Eyal-Shalev Nov 21, 2022
235d98b
Forgot the baseline
Eyal-Shalev Nov 21, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 15 additions & 1 deletion src/lib/es2022.sharedmemory.d.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,20 @@ interface Atomics {
/**
* A non-blocking, asynchronous version of wait which is usable on the main thread.
* Waits asynchronously on a shared memory location and returns a Promise
* @param typedArray A shared Int32Array or BigInt64Array.
* @param index The position in the typedArray to wait on.
* @param value The expected value to test.
* @param [timeout] The expected value to test.
*/
waitAsync(typedArray: BigInt64Array | Int32Array, index: number, value: bigint, timeout?: number): { async: false, value: "ok" | "not-equal" | "timed-out" } | { async: true, value: Promise<"ok" | "not-equal" | "timed-out"> };
waitAsync(typedArray: Int32Array, index: number, value: number, timeout?: number): { async: false, value: "not-equal" | "timed-out" } | { async: true, value: Promise<"ok" | "timed-out"> };

/**
* A non-blocking, asynchronous version of wait which is usable on the main thread.
* Waits asynchronously on a shared memory location and returns a Promise
* @param typedArray A shared Int32Array or BigInt64Array.
* @param index The position in the typedArray to wait on.
* @param value The expected value to test.
* @param [timeout] The expected value to test.
*/
waitAsync(typedArray: BigInt64Array, index: number, value: bigint, timeout?: number): { async: false, value: "not-equal" | "timed-out" } | { async: true, value: Promise<"ok" | "timed-out"> };
}
48 changes: 38 additions & 10 deletions tests/baselines/reference/es2022SharedMemory.symbols
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,32 +11,60 @@ const int32 = new Int32Array(sab);
>Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 1 more)
>sab : Symbol(sab, Decl(es2022SharedMemory.ts, 0, 5))

const sab64 = new SharedArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT * 1024);
>sab64 : Symbol(sab64, Decl(es2022SharedMemory.ts, 2, 5))
>SharedArrayBuffer : Symbol(SharedArrayBuffer, Decl(lib.es2017.sharedmemory.d.ts, --, --), Decl(lib.es2017.sharedmemory.d.ts, --, --))
>BigInt64Array.BYTES_PER_ELEMENT : Symbol(BigInt64ArrayConstructor.BYTES_PER_ELEMENT, Decl(lib.es2020.bigint.d.ts, --, --))
>BigInt64Array : Symbol(BigInt64Array, Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2022.array.d.ts, --, --))
>BYTES_PER_ELEMENT : Symbol(BigInt64ArrayConstructor.BYTES_PER_ELEMENT, Decl(lib.es2020.bigint.d.ts, --, --))

const int64 = new BigInt64Array(sab64);
>int64 : Symbol(int64, Decl(es2022SharedMemory.ts, 3, 5))
>BigInt64Array : Symbol(BigInt64Array, Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2022.array.d.ts, --, --))
>sab64 : Symbol(sab64, Decl(es2022SharedMemory.ts, 2, 5))

const waitValue = Atomics.wait(int32, 0, 0);
>waitValue : Symbol(waitValue, Decl(es2022SharedMemory.ts, 2, 5))
>waitValue : Symbol(waitValue, Decl(es2022SharedMemory.ts, 4, 5))
>Atomics.wait : Symbol(Atomics.wait, Decl(lib.es2017.sharedmemory.d.ts, --, --), Decl(lib.es2020.sharedmemory.d.ts, --, --))
>Atomics : Symbol(Atomics, Decl(lib.es2017.sharedmemory.d.ts, --, --), Decl(lib.es2017.sharedmemory.d.ts, --, --), Decl(lib.es2020.sharedmemory.d.ts, --, --), Decl(lib.es2022.sharedmemory.d.ts, --, --))
>wait : Symbol(Atomics.wait, Decl(lib.es2017.sharedmemory.d.ts, --, --), Decl(lib.es2020.sharedmemory.d.ts, --, --))
>int32 : Symbol(int32, Decl(es2022SharedMemory.ts, 1, 5))

const { async, value } = Atomics.waitAsync(int32, 0, BigInt(0));
>async : Symbol(async, Decl(es2022SharedMemory.ts, 3, 7))
>value : Symbol(value, Decl(es2022SharedMemory.ts, 3, 14))
>Atomics.waitAsync : Symbol(Atomics.waitAsync, Decl(lib.es2022.sharedmemory.d.ts, --, --))
const { async, value } = Atomics.waitAsync(int32, 0, 0);
>async : Symbol(async, Decl(es2022SharedMemory.ts, 5, 7))
>value : Symbol(value, Decl(es2022SharedMemory.ts, 5, 14))
>Atomics.waitAsync : Symbol(Atomics.waitAsync, Decl(lib.es2022.sharedmemory.d.ts, --, --), Decl(lib.es2022.sharedmemory.d.ts, --, --))
>Atomics : Symbol(Atomics, Decl(lib.es2017.sharedmemory.d.ts, --, --), Decl(lib.es2017.sharedmemory.d.ts, --, --), Decl(lib.es2020.sharedmemory.d.ts, --, --), Decl(lib.es2022.sharedmemory.d.ts, --, --))
>waitAsync : Symbol(Atomics.waitAsync, Decl(lib.es2022.sharedmemory.d.ts, --, --))
>waitAsync : Symbol(Atomics.waitAsync, Decl(lib.es2022.sharedmemory.d.ts, --, --), Decl(lib.es2022.sharedmemory.d.ts, --, --))
>int32 : Symbol(int32, Decl(es2022SharedMemory.ts, 1, 5))

const { async: async64, value: value64 } = Atomics.waitAsync(int64, 0, BigInt(0));
>async : Symbol(async, Decl(lib.es2022.sharedmemory.d.ts, --, --), Decl(lib.es2022.sharedmemory.d.ts, --, --))
>async64 : Symbol(async64, Decl(es2022SharedMemory.ts, 6, 7))
>value : Symbol(value, Decl(lib.es2022.sharedmemory.d.ts, --, --), Decl(lib.es2022.sharedmemory.d.ts, --, --))
>value64 : Symbol(value64, Decl(es2022SharedMemory.ts, 6, 23))
>Atomics.waitAsync : Symbol(Atomics.waitAsync, Decl(lib.es2022.sharedmemory.d.ts, --, --), Decl(lib.es2022.sharedmemory.d.ts, --, --))
>Atomics : Symbol(Atomics, Decl(lib.es2017.sharedmemory.d.ts, --, --), Decl(lib.es2017.sharedmemory.d.ts, --, --), Decl(lib.es2020.sharedmemory.d.ts, --, --), Decl(lib.es2022.sharedmemory.d.ts, --, --))
>waitAsync : Symbol(Atomics.waitAsync, Decl(lib.es2022.sharedmemory.d.ts, --, --), Decl(lib.es2022.sharedmemory.d.ts, --, --))
>int64 : Symbol(int64, Decl(es2022SharedMemory.ts, 3, 5))
>BigInt : Symbol(BigInt, Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2020.bigint.d.ts, --, --))

const main = async () => {
>main : Symbol(main, Decl(es2022SharedMemory.ts, 5, 5))
>main : Symbol(main, Decl(es2022SharedMemory.ts, 8, 5))

if (async) {
>async : Symbol(async, Decl(es2022SharedMemory.ts, 3, 7))
>async : Symbol(async, Decl(es2022SharedMemory.ts, 5, 7))

await value;
>value : Symbol(value, Decl(es2022SharedMemory.ts, 3, 14))
>value : Symbol(value, Decl(es2022SharedMemory.ts, 5, 14))
}
if (async64) {
>async64 : Symbol(async64, Decl(es2022SharedMemory.ts, 6, 7))

await value64;
>value64 : Symbol(value64, Decl(es2022SharedMemory.ts, 6, 23))
}
}
main();
>main : Symbol(main, Decl(es2022SharedMemory.ts, 5, 5))
>main : Symbol(main, Decl(es2022SharedMemory.ts, 8, 5))

52 changes: 44 additions & 8 deletions tests/baselines/reference/es2022SharedMemory.types
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,22 @@ const int32 = new Int32Array(sab);
>Int32Array : Int32ArrayConstructor
>sab : SharedArrayBuffer

const sab64 = new SharedArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT * 1024);
>sab64 : SharedArrayBuffer
>new SharedArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT * 1024) : SharedArrayBuffer
>SharedArrayBuffer : SharedArrayBufferConstructor
>BigInt64Array.BYTES_PER_ELEMENT * 1024 : number
>BigInt64Array.BYTES_PER_ELEMENT : number
>BigInt64Array : BigInt64ArrayConstructor
>BYTES_PER_ELEMENT : number
>1024 : 1024

const int64 = new BigInt64Array(sab64);
>int64 : BigInt64Array
>new BigInt64Array(sab64) : BigInt64Array
>BigInt64Array : BigInt64ArrayConstructor
>sab64 : SharedArrayBuffer

const waitValue = Atomics.wait(int32, 0, 0);
>waitValue : "ok" | "not-equal" | "timed-out"
>Atomics.wait(int32, 0, 0) : "ok" | "not-equal" | "timed-out"
Expand All @@ -25,29 +41,49 @@ const waitValue = Atomics.wait(int32, 0, 0);
>0 : 0
>0 : 0

const { async, value } = Atomics.waitAsync(int32, 0, BigInt(0));
const { async, value } = Atomics.waitAsync(int32, 0, 0);
>async : boolean
>value : "ok" | "not-equal" | "timed-out" | Promise<"ok" | "not-equal" | "timed-out">
>Atomics.waitAsync(int32, 0, BigInt(0)) : { async: false; value: "ok" | "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "not-equal" | "timed-out">; }
>Atomics.waitAsync : (typedArray: Int32Array | BigInt64Array, index: number, value: bigint, timeout?: number | undefined) => { async: false; value: "ok" | "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "not-equal" | "timed-out">; }
>value : "not-equal" | "timed-out" | Promise<"ok" | "timed-out">
>Atomics.waitAsync(int32, 0, 0) : { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }
>Atomics.waitAsync : { (typedArray: Int32Array, index: number, value: number, timeout?: number | undefined): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }; (typedArray: BigInt64Array, index: number, value: bigint, timeout?: number | undefined): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }; }
>Atomics : Atomics
>waitAsync : (typedArray: Int32Array | BigInt64Array, index: number, value: bigint, timeout?: number | undefined) => { async: false; value: "ok" | "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "not-equal" | "timed-out">; }
>waitAsync : { (typedArray: Int32Array, index: number, value: number, timeout?: number | undefined): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }; (typedArray: BigInt64Array, index: number, value: bigint, timeout?: number | undefined): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }; }
>int32 : Int32Array
>0 : 0
>0 : 0

const { async: async64, value: value64 } = Atomics.waitAsync(int64, 0, BigInt(0));
>async : any
>async64 : boolean
>value : any
>value64 : "not-equal" | "timed-out" | Promise<"ok" | "timed-out">
>Atomics.waitAsync(int64, 0, BigInt(0)) : { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }
>Atomics.waitAsync : { (typedArray: Int32Array, index: number, value: number, timeout?: number | undefined): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }; (typedArray: BigInt64Array, index: number, value: bigint, timeout?: number | undefined): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }; }
>Atomics : Atomics
>waitAsync : { (typedArray: Int32Array, index: number, value: number, timeout?: number | undefined): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }; (typedArray: BigInt64Array, index: number, value: bigint, timeout?: number | undefined): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }; }
>int64 : BigInt64Array
>0 : 0
>BigInt(0) : bigint
>BigInt : BigIntConstructor
>0 : 0

const main = async () => {
>main : () => Promise<void>
>async () => { if (async) { await value; }} : () => Promise<void>
>async () => { if (async) { await value; } if (async64) { await value64; }} : () => Promise<void>

if (async) {
>async : boolean

await value;
>await value : "ok" | "not-equal" | "timed-out"
>value : Promise<"ok" | "not-equal" | "timed-out">
>await value : "ok" | "timed-out"
>value : Promise<"ok" | "timed-out">
}
if (async64) {
>async64 : boolean

await value64;
>await value64 : "ok" | "timed-out"
>value64 : Promise<"ok" | "timed-out">
}
}
main();
Expand Down
8 changes: 7 additions & 1 deletion tests/cases/conformance/es2022/es2022SharedMemory.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,12 +5,18 @@

const sab = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 1024);
const int32 = new Int32Array(sab);
const sab64 = new SharedArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT * 1024);
const int64 = new BigInt64Array(sab64);
const waitValue = Atomics.wait(int32, 0, 0);
const { async, value } = Atomics.waitAsync(int32, 0, BigInt(0));
const { async, value } = Atomics.waitAsync(int32, 0, 0);
const { async: async64, value: value64 } = Atomics.waitAsync(int64, 0, BigInt(0));

const main = async () => {
if (async) {
await value;
}
if (async64) {
await value64;
}
}
main();