FilesExpand file tree

 typeOperations

/

lib.es2017.sharedmemory.d.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

138 lines (113 loc) · 6.02 KB

 typeOperations

/

lib.es2017.sharedmemory.d.ts

Copy path

Top

File metadata and controls

• Code
• Blame

138 lines (113 loc) · 6.02 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

/*! *****************************************************************************

Copyright (c) Microsoft Corporation. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use

this file except in compliance with the License. You may obtain a copy of the

License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED

WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,

MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions

and limitations under the License.

***************************************************************************** */

/// <reference no-default-lib="true"/>

/// <reference path="lib.es2015.symbol.d.ts" />

/// <reference path="lib.es2015.symbol.wellknown.d.ts" />

interface SharedArrayBuffer {

/**

* Read-only. The length of the ArrayBuffer (in bytes).

*/

readonly byteLength: number;

/*

* The SharedArrayBuffer constructor's length property whose value is 1.

*/

length: number;

/**

* Returns a section of an SharedArrayBuffer.

*/

slice(begin: number, end?: number): SharedArrayBuffer;

readonly [Symbol.species]: SharedArrayBuffer;

readonly [Symbol.toStringTag]: "SharedArrayBuffer";

}

interface SharedArrayBufferConstructor {

readonly prototype: SharedArrayBuffer;

new (byteLength: number): SharedArrayBuffer;

}

declare var SharedArrayBuffer: SharedArrayBufferConstructor;

interface ArrayBufferTypes {

SharedArrayBuffer: SharedArrayBuffer;

}

interface Atomics {

/**

* Adds a value to the value at the given position in the array, returning the original value.

* Until this atomic operation completes, any other read or write operation against the array

* will block.

*/

add(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;

/**

* Stores the bitwise AND of a value with the value at the given position in the array,

* returning the original value. Until this atomic operation completes, any other read or

* write operation against the array will block.

*/

and(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;

/**

* Replaces the value at the given position in the array if the original value equals the given

* expected value, returning the original value. Until this atomic operation completes, any

* other read or write operation against the array will block.

*/

compareExchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, expectedValue: number, replacementValue: number): number;

/**

* Replaces the value at the given position in the array, returning the original value. Until

* this atomic operation completes, any other read or write operation against the array will

* block.

*/

exchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;

/**

* Returns a value indicating whether high-performance algorithms can use atomic operations

* (`true`) or must use locks (`false`) for the given number of bytes-per-element of a typed

* array.

*/

isLockFree(size: number): boolean;

/**

* Returns the value at the given position in the array. Until this atomic operation completes,

* any other read or write operation against the array will block.

*/

load(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number): number;

/**

* Stores the bitwise OR of a value with the value at the given position in the array,

* returning the original value. Until this atomic operation completes, any other read or write

* operation against the array will block.

*/

or(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;

/**

* Stores a value at the given position in the array, returning the new value. Until this

* atomic operation completes, any other read or write operation against the array will block.

*/

store(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;

/**

* Subtracts a value from the value at the given position in the array, returning the original

* value. Until this atomic operation completes, any other read or write operation against the

* array will block.

*/

sub(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;

/**

* If the value at the given position in the array is equal to the provided value, the current

* agent is put to sleep causing execution to suspend until the timeout expires (returning

* `"timed-out"`) or until the agent is awoken (returning `"ok"`); otherwise, returns

* `"not-equal"`.

*/

wait(typedArray: Int32Array, index: number, value: number, timeout?: number): "ok" | "not-equal" | "timed-out";

/**

* Wakes up sleeping agents that are waiting on the given index of the array, returning the

* number of agents that were awoken.

*/

wake(typedArray: Int32Array, index: number, count: number): number;

/**

* Stores the bitwise XOR of a value with the value at the given position in the array,

* returning the original value. Until this atomic operation completes, any other read or write

* operation against the array will block.

*/

xor(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;

readonly [Symbol.toStringTag]: "Atomics";

}

declare var Atomics: Atomics;