map-get-bigint.js (4827B)
1 // Similar test as "cacheir/map-get-bigint.js", except that we now perform 2 // duplicate lookups to ensure GVN works properly. 3 4 // Return a new map, possibly filling some dummy entries to enforce creating 5 // multiple hash buckets. 6 function createMap(values, n) { 7 var xs = [...values]; 8 for (var i = 0; i < n; ++i) { 9 xs.push({}); 10 } 11 return new Map(xs.map((x, i) => [x, i + 1])); 12 } 13 14 function runTest(fn) { 15 fn(0); 16 fn(100); 17 } 18 19 function testInlineDigitsSameSign_same_map(n) { 20 var xs = [1n, 2n]; 21 var ys = [3n, 4n]; 22 var zs = [...xs, ...ys]; 23 var map = createMap(xs, n); 24 25 var N = 100; 26 var c = 0; 27 for (var i = 0; i < N; ++i) { 28 var z = zs[i & 3]; 29 var v = map.get(z); 30 if (v !== undefined) c += v; 31 var w = map.get(z); 32 if (w !== undefined) c += w; 33 } 34 assertEq(c, N + N / 2); 35 } 36 runTest(testInlineDigitsSameSign_same_map); 37 38 function testInlineDigitsDifferentSign_same_map(n) { 39 var xs = [-1n, 2n]; 40 var ys = [1n, -2n]; 41 var zs = [...xs, ...ys]; 42 var map = createMap(xs, n); 43 44 var N = 100; 45 var c = 0; 46 for (var i = 0; i < N; ++i) { 47 var z = zs[i & 3]; 48 var v = map.get(z); 49 if (v !== undefined) c += v; 50 var w = map.get(z); 51 if (w !== undefined) c += w; 52 } 53 assertEq(c, N + N / 2); 54 } 55 runTest(testInlineDigitsDifferentSign_same_map); 56 57 function testHeapDigitsSameSign_same_map(n) { 58 // Definitely uses heap digits. 59 var heap = 2n ** 1000n; 60 61 var xs = [heap + 1n, heap + 2n]; 62 var ys = [heap + 3n, heap + 4n]; 63 var zs = [...xs, ...ys]; 64 var map = createMap(xs, n); 65 66 var N = 100; 67 var c = 0; 68 for (var i = 0; i < N; ++i) { 69 var z = zs[i & 3]; 70 var v = map.get(z); 71 if (v !== undefined) c += v; 72 var w = map.get(z); 73 if (w !== undefined) c += w; 74 } 75 assertEq(c, N + N / 2); 76 } 77 runTest(testHeapDigitsSameSign_same_map); 78 79 function testHeapDigitsDifferentSign_same_map(n) { 80 // Definitely uses heap digits. 81 var heap = 2n ** 1000n; 82 83 var xs = [-(heap + 1n), heap + 2n]; 84 var ys = [heap + 1n, -(heap + 2n)]; 85 var zs = [...xs, ...ys]; 86 var map = createMap(xs, n); 87 88 var N = 100; 89 var c = 0; 90 for (var i = 0; i < N; ++i) { 91 var z = zs[i & 3]; 92 var v = map.get(z); 93 if (v !== undefined) c += v; 94 var w = map.get(z); 95 if (w !== undefined) c += w; 96 } 97 assertEq(c, N + N / 2); 98 } 99 runTest(testHeapDigitsDifferentSign_same_map); 100 101 // Duplicate the above tests, but this time use a different map. 102 103 function testInlineDigitsSameSign_different_map(n) { 104 var xs = [1n, 2n]; 105 var ys = [3n, 4n]; 106 var zs = [...xs, ...ys]; 107 var map1 = createMap(xs, n); 108 var map2 = createMap(xs, n); 109 110 var N = 100; 111 var c = 0; 112 for (var i = 0; i < N; ++i) { 113 var z = zs[i & 3]; 114 var v = map1.get(z); 115 if (v !== undefined) c += v; 116 var w = map2.get(z); 117 if (w !== undefined) c += w; 118 } 119 assertEq(c, N + N / 2); 120 } 121 runTest(testInlineDigitsSameSign_different_map); 122 123 function testInlineDigitsDifferentSign_different_map(n) { 124 var xs = [-1n, 2n]; 125 var ys = [1n, -2n]; 126 var zs = [...xs, ...ys]; 127 var map1 = createMap(xs, n); 128 var map2 = createMap(xs, n); 129 130 var N = 100; 131 var c = 0; 132 for (var i = 0; i < N; ++i) { 133 var z = zs[i & 3]; 134 var v = map1.get(z); 135 if (v !== undefined) c += v; 136 var w = map2.get(z); 137 if (w !== undefined) c += w; 138 } 139 assertEq(c, N + N / 2); 140 } 141 runTest(testInlineDigitsDifferentSign_different_map); 142 143 function testHeapDigitsSameSign_different_map(n) { 144 // Definitely uses heap digits. 145 var heap = 2n ** 1000n; 146 147 var xs = [heap + 1n, heap + 2n]; 148 var ys = [heap + 3n, heap + 4n]; 149 var zs = [...xs, ...ys]; 150 var map1 = createMap(xs, n); 151 var map2 = createMap(xs, n); 152 153 var N = 100; 154 var c = 0; 155 for (var i = 0; i < N; ++i) { 156 var z = zs[i & 3]; 157 var v = map1.get(z); 158 if (v !== undefined) c += v; 159 var w = map2.get(z); 160 if (w !== undefined) c += w; 161 } 162 assertEq(c, N + N / 2); 163 } 164 runTest(testHeapDigitsSameSign_different_map); 165 166 function testHeapDigitsDifferentSign_different_map(n) { 167 // Definitely uses heap digits. 168 var heap = 2n ** 1000n; 169 170 var xs = [-(heap + 1n), heap + 2n]; 171 var ys = [heap + 1n, -(heap + 2n)]; 172 var zs = [...xs, ...ys]; 173 var map1 = createMap(xs, n); 174 var map2 = createMap(xs, n); 175 176 var N = 100; 177 var c = 0; 178 for (var i = 0; i < N; ++i) { 179 var z = zs[i & 3]; 180 var v = map1.get(z); 181 if (v !== undefined) c += v; 182 var w = map2.get(z); 183 if (w !== undefined) c += w; 184 } 185 assertEq(c, N + N / 2); 186 } 187 runTest(testHeapDigitsDifferentSign_different_map); 188 189 // Test the alias information is correct. 190 191 function test_alias(n) { 192 var xs = [1n, 2n]; 193 var map = createMap([], n); 194 195 var N = 100; 196 var c = 0; 197 for (var i = 0; i < N; ++i) { 198 var x = xs[i & 1]; 199 200 map.set(x, 1); 201 var v = map.get(x); 202 203 map.delete(x); 204 var w = map.get(x); 205 206 c += v; 207 assertEq(w, undefined); 208 } 209 assertEq(c, N); 210 } 211 runTest(test_alias);