poker-flopsolve 0.3.0 → 0.3.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +186 -180
- package/dist/browser.js.map +1 -1
- package/dist/engine-worker.js.map +1 -1
- package/dist/index.js +209 -200
- package/dist/index.js.map +1 -1
- package/dist/worker.js.map +1 -1
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -2084,6 +2084,189 @@ var ENGINE_WASM = "AGFzbQEAAAABTglgAX8AYAZ/f39/f38Bf2AFf39/f38AYAd/f39/f3x/AGADf
|
|
|
2084
2084
|
// src/wasm/engine-shared.ts
|
|
2085
2085
|
var ENGINE_SHARED_WASM = "AGFzbQEAAAABTglgAX8AYAZ/f39/f38Bf2AFf39/f38AYAd/f39/f3x/AGADf39/AGACf38AYAR/f39/AGAKf39/f399fX19fwF/YAl/f39/fX19fX8BfwISAQNlbnYGbWVtb3J5AgMAgIAEAwsKAQIDBAUABgcIAAaOAjJ/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt8AUQAAAAAAADwPwt/AUF/C38BQQALfwFBAAt/AUEAC38BQQELfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC30BQwAAgD8LfQFDAAAAAAt9AUMAAIA/C30BQwAAgD8LfwFBAAt/AUEBCwdXCAhzZXRTaGFyZAADC3NldEV4Y2hhbmdlAAYIc2V0UGhhc2UABARpbml0AAkNc2V0TWF4QWN0aW9ucwAFA3J1bgAICXJ1bkNoYW5jZQAHBm1lbW9yeQIACqshCuIYBBV/An0FewN8Ix0gBSMebGohDSACIwkjASABai0AACIHQQJ0aigCAGpBAXQiCCAAaiIPQQJ0IgkjCmooAgAhCiMLIAlqKAIAIQtBASAAayIQIAhqIghBAnQiESMKaigCACESIwsgEWooAgAhESMAIAFqLQAAIhNBAkYEQCMUIAlqKAIAIQIjBiABQQJ0aigCALciIpogIiAAQQFGGyMaIAdBA3RqKwMAoiMhoyEkQQAhAANAIAAgEUgEQCAjIAQgAEECdGoqAgC7IiKgISMjICAAIBJqIgEjDGotAABBA3RqIgMgAysDACAioDkDACMgIw0gAWotAABBA3RqIgEgASsDACAioDkDACAAQQFqIQAMAQsLQQAhAANAIAAgC0gEQCANIABBAnRqICQgIyMgIAAgCmoiASMMai0AAEEDdGorAwAjICMNIAFqLQAAQQN0aisDAKAjFSAAIAJqQQJ0aigCACIBQQBOBHwgBCABQQJ0aioCALsFRAAAAAAAAAAAC6GhorY4AgAgAEEBaiEADAELCyMgQQBBoAP8CwAgDQ8LIBNBAksEQCAEIBIgESAKIAsjBiABQQJ0aigCALcjGiAHQQN0aisDAKIjIaMgDRACIA0PCyATQQFGBEAgDUEAIAtBAnQiBvwLACAHQQFqIgcjIkYjJUEAR3EEQCMnIAFBAnRqKAIAIghBAE4EQCMlQQFGBEAjKCMqIAhBAXRsaiIAIAMgBvwKAAAgACMqaiAEIBFBAnT8CgAABSANIykgCCMqbGogC0ECdPwKAAALIA0PCwsjBSMDIAFBAnRqKAIAQQJ0aigCACEIIxkgB0ECdCIBIxhqKAIAQQJ0aiEJIxIjESABaigCAEECdGohCiMdIAUjHmxqIgYjHyAAQQFqbGohCyMJIAFqKAIAIQ8jFyMWIAFqKAIAQQJ0aiIMIAJBAnRqKAIAIQEgDCACQQFqQQJ0aigCACEMIAcjIkYEQCMkIAwjJCAMSBshDCMjIAEjIyABShshAQsgBiMfIBBBAWpsaiEHA0AgASAMSARAIwsgASAPakEBdCICIABqQQJ0aigCACERIwsgAiAQakECdGooAgAhEiAJIAFBAWpBAnRqKAIAIRNBACEGIAkgAUECdGooAgAiFCECA0AgAiATSARAIxMgCiACQQF0Ig4gAGpBAnRqKAIAQQF0aiEVIAIgFEYEQCMTIAogDiAQakECdGooAgBBAXRqIQZBACEOA0AgDiARSARAIAsgDkECdGogAyAVIA5BAXRqLwEAQQJ0aioCADgCACAOQQFqIQ4MAQsLQQAhDgNAIA4gEkgEQCAHIA5BAnRqIAQgBiAOQQF0ai8BAEECdGoqAgA4AgAgDkEBaiEODAELCyAAIAggASALIAcgBUEBahAAIQYLQQAhDgNAIA4gEUgEQCANIBUgDkEBdGovAQBBAnRqIhYgFioCACAGIA5BAnRqKgIAkjgCACAOQQFqIQ4MAQsLIAJBAWohAgwBCwsgAUEBaiEBDAELCyANDwsgAUECdCIHIwNqKAIAIQojByAHaigCACMEIAFqLQAAIgkjCCAPIAgjAiABai0AACIQIABGIggbIhJBAnRqKAIAbGpBAnQiASMbaiETIxwgAWohFCMdIAUjHmxqIx9BA2xqIRUgCyARIAgbIhFBAnQiASEWIysEQCAVIAEgCWxqIgdBACAB/AsAA0AgCSAOSgRAIAEgDmwiBiAUaiEXIAYgFWohBkEAIQ8DQCAPIBFIBEAgD0ECdCIYIBdqKgIAIRsgBiAYaiAbOAIAIAcgGGoiGCAYKgIAIBuSOAIAIA9BAWohDwwBCwsgDkEBaiEODAELC0EAIQ4DQCAOIBFIBEAgDkECdCIGIAdqKgIAQwAAAABeRQRAQwAAAAAhG0EAIQ8DQCAJIA9KBEAgASAPbCIXIBNqIAZqKgIAIhxDAAAAACAcQwAAAABeGyEcIBUgF2ogBmogHDgCACAbIBySIRsgD0EBaiEPDAELCyAGIAdqIBs4AgALIA5BAWohDgwBCwsFIBFBfHEhASAVIBFBAnQiDiAJbGoiB0EAIA78CwADQCAGIAlIBEAgBiAObCIPIBNqIRcgDyAVaiEYQQAhDwNAIAEgD0oEQCAPQQJ0IhkgF2r9AAQA/QwAAAAAAAAAAAAAAAAAAAAA/ekBIR0gGCAZaiAd/QsEACAHIBlqIhkgGf0ABAAgHf3kAf0LBAAgD0EEaiEPDAELCwNAIA8gEUgEQCAPQQJ0IhkgF2oqAgAiG0MAAAAAIBtDAAAAAF4bIRsgGCAZaiAbOAIAIAcgGWoiGSAZKgIAIBuSOAIAIA9BAWohDwwBCwsgBkEBaiEGDAELCwtBACEPIBFBAnQhBkMAAIA/IAmylf0TIR0gEUF8cSEOA0AgCSAPSgRAIBUgBiAPbGohF0EAIQEDQCABIA5IBEAgAUECdCIYIAdq/QAEACEeIBcgGGoiGCAY/QAEACAe/ecBIB0gHv0MAAAAAAAAAAAAAAAAAAAAAP1E/VL9CwQAIAFBBGohAQwBCwsDQCABIBFIBEAgAUECdCIYIAdqKgIAIRsgFyAYaiIYIBtDAAAAAF4EfSAYKgIAIBuVBUMAAIA/IAmylQs4AgAgAUEBaiEBDAELCyAPQQFqIQ8MAQsLIytBAUYgCHEEQANAIAkgDEoEQCAAIwUgCiAMakECdGooAgAgAiADIAQgBUEBahAAIQYgDARAQQAhAQNAIAEgC0gEQCABQQJ0IgcgBmoqAgAiGyAHIA1qIgcqAgBeBEAgByAbOAIACyABQQFqIQEMAQsLBSANIAYgC0ECdPwKAAALIAxBAWohDAwBCwsgDQ8LIA1BACALQQJ0/AsAIx0gBSMebGoiASMfIBBBAWpsaiEGIAEjH0EDbGojMSMfbGohASADIAQgCBshByARQXxxIQwgC0F8cSEQQQAhDgNAIAkgDkoEQCAVIA4gFmxqIRdBACEPA0AgDCAPSgRAIA9BAnQiGCAGaiAHIBhq/QAEACAXIBhq/QAEAP3mAf0LBAAgD0EEaiEPDAELCwNAIA8gEUgEQCAPQQJ0IhggBmogByAYaioCACAXIBhqKgIAlDgCACAPQQFqIQ8MAQsLIAgEfyAAIwUgCiAOakECdGooAgAgAiAGIAQgBUEBahAABSAAIwUgCiAOakECdGooAgAgAiADIAYgBUEBahAACyEYIAgEQCABIA4gFmxqIBggFvwKAABBACEPA0AgDyAQSARAIA9BAnQiGSANaiIaIBr9AAQAIBcgGWr9AAQAIBggGWr9AAQA/eYB/eQB/QsEACAPQQRqIQ8MAQsLA0AgCyAPSgRAIA9BAnQiGSANaiIaIBoqAgAgFyAZaioCACAYIBlqKgIAlJI4AgAgD0EBaiEPDAELCwVBACEPA0AgDyAQSARAIA9BAnQiFyANaiIZIBn9AAQAIBcgGGr9AAQA/eQB/QsEACAPQQRqIQ8MAQsLA0AgCyAPSgRAIA9BAnQiFyANaiIZIBkqAgAgFyAYaioCAJI4AgAgD0EBaiEPDAELCwsgDkEBaiEODAELCyMmQQAjK0UgCHEbBEBBACEFIBFBAnQhACMs/RMhICMt/RMhHyMu/RMhHiMv/RMhHSARQXxxIQQDQCAFIAlIBEAgACAFbCEGQQAhAgNAIAIgBEgEQCAGIBNqIgcgAkECdCIIav0ABAAiISAgIB8gIf0MAAAAAAAAAAAAAAAAAAAAAP1E/VL95gEgASAGaiAIav0ABAAgCCANav0ABAD95QH95AEhISAHIAhqICH9DAAAAAAAAAAAAAAAAAAAAAD96QEgISMwG/0LBAAgBiAUaiAIaiIHIAf9AAQAIB795gEgHSADIAhq/QAEACAGIBVqIAhq/QAEAP3mAf3mAf3kAf0LBAAgAkEEaiECDAELCwNAIAIgEUgEQCACQQJ0IgcgBiATamoqAgAiGyMsIy0gG0MAAAAAXhuUIAEgBmogB2oqAgCSIAcgDWoqAgCTIhtDAAAAAF1BACMwGwRAQwAAAAAhGwsgBiATaiAHaiAbOAIAIAYgFGogB2oiCCAIKgIAIy6UIy8gAyAHaioCAJQgBiAVaiAHaioCAJSSOAIAIAJBAWohAgwBCwsgBUEBaiEFDAELCyMPIBJBAnRqKAIAIgAjDyASQQFqQQJ0aigCACIBSARAIBMgCSARIAAgARABIBQgCSARIAAgARABCwsgDQvHAQIFfwF9IAJBAnQhCQNAIAEgB0oEQCAAIAcgCWxqIQggAyECA0AgAiAESARAIxAgAkECdGooAgAhBkMAAAAAIQpBASEFA0AgBSAGTARAIAogCCMQIAIgBWpBAnRqKAIAQQJ0aioCAJIhCiAFQQFqIQUMAQsLIAogBrKVIQpBASEFA0AgBSAGTARAIAgjECACIAVqQQJ0aigCAEECdGogCjgCACAFQQFqIQUMAQsLIAIgBkEBamohAgwBCwsgB0EBaiEHDAELCwvxAwIGfwJ8IyBBoANqIQkDQCAEIAhKBEAjDiADIAhqQQJ0aigCACELA0AgAiAHSgR/Iw4gASAHakECdGooAgAgC0gFQQALBEAgDSAAIAdBAnRqKgIAuyIOoCENIyAgASAHaiIKIwxqLQAAQQN0aiIMIAwrAwAgDqA5AwAjICMNIApqLQAAQQN0aiIKIAorAwAgDqA5AwAgB0EBaiEHDAELCyAJIAhBA3RqIA0jICADIAhqIgojDGotAABBA3RqKwMAIyAjDSAKai0AAEEDdGorAwCgoTkDACAIQQFqIQgMAQsLIyBBAEGgA/wLAEQAAAAAAAAAACENIAJBAWshByAEQQFrIQIDQCACQQBOBEAjDiACIANqQQJ0aigCACEEA0AgB0EATgR/Iw4gASAHakECdGooAgAgBEoFQQALBEAgDSAAIAdBAnRqKgIAuyIOoCENIyAgASAHaiIIIwxqLQAAQQN0aiIKIAorAwAgDqA5AwAjICMNIAhqLQAAQQN0aiIIIAgrAwAgDqA5AwAgB0EBayEHDAELCyAGIAJBAnRqIAUgCSACQQN0aisDACANIyAgAiADaiIEIwxqLQAAQQN0aisDACMgIw0gBGotAABBA3RqKwMAoKGhorY4AgAgAkEBayECDAELCyMgQQBBoAP8CwALDgAgACQiIAEkIyACJCQLDQAgACQlIAFBAEckJgsGACAAJDELFQAgACQnIAEkKCACJCkgA0ECdCQqCysAIAAkKyAFJCwgBiQtIAckLiAIJC8gCUEARyQwIAEgAkEAIAMgBEEAEAALKwAgACQrIAQkLCAFJC0gBiQuIAckLyAIQQBHJDAgAUEAQQAgAiADQQAQAAv2AQAgACgCACQAIAAoAgQkASAAKAIIJAIgACgCDCQDIAAoAhAkBCAAKAIUJAUgACgCGCQGIAAoAhwkByAAKAIgJAggACgCJCQJIAAoAigkCiAAKAIsJAsgACgCMCQMIAAoAjQkDSAAKAI4JA4gACgCPCQPIABBQGsoAgAkECAAKAJEJBEgACgCSCQSIAAoAkwkEyAAKAJQJBQgACgCVCQVIAAoAlgkFiAAKAJcJBcgACgCYCQYIAAoAmQkGSAAKAJoJBogACgCbCQbIAAoAnAkHCAAKAJ0JB0gACgCeCQeIAAoAnwkHyAAKAKAASQgIAAoAoQBuCQhCw==";
|
|
2086
2086
|
|
|
2087
|
+
// src/platform/browser.ts
|
|
2088
|
+
var PLATFORM = "browser";
|
|
2089
|
+
var THREADS_AVAILABLE = false;
|
|
2090
|
+
var DEFAULT_MAX_BYTES = 512 * 1024 * 1024;
|
|
2091
|
+
function defaultWorkerCount() {
|
|
2092
|
+
return 1;
|
|
2093
|
+
}
|
|
2094
|
+
function spawnWorker(_setup, _onError) {
|
|
2095
|
+
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2096
|
+
}
|
|
2097
|
+
function spawnEngineWorker(_setup, _onError) {
|
|
2098
|
+
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2099
|
+
}
|
|
2100
|
+
|
|
2101
|
+
// src/parallel.ts
|
|
2102
|
+
var CONTROL = {
|
|
2103
|
+
generation: 0,
|
|
2104
|
+
done: 1,
|
|
2105
|
+
command: 2,
|
|
2106
|
+
traverser: 3,
|
|
2107
|
+
iterWeight: 4,
|
|
2108
|
+
ready: 5,
|
|
2109
|
+
mode: 6,
|
|
2110
|
+
size: 8
|
|
2111
|
+
};
|
|
2112
|
+
var COMMAND = { work: 0, exit: 1 };
|
|
2113
|
+
var WORKER_START_MS = 3e4;
|
|
2114
|
+
var WORKER_START_ERROR = "Worker threads did not start within 30 s. Run with workers: 1, or check that worker threads can load this package.";
|
|
2115
|
+
function planShards(tree, runouts, workers) {
|
|
2116
|
+
if (workers < 2) return null;
|
|
2117
|
+
let round = -1;
|
|
2118
|
+
for (let r = 1; r < runouts.rounds; r++) {
|
|
2119
|
+
if (runouts.counts[r] > 1) {
|
|
2120
|
+
round = r;
|
|
2121
|
+
break;
|
|
2122
|
+
}
|
|
2123
|
+
}
|
|
2124
|
+
if (round < 0) return null;
|
|
2125
|
+
const boards = runouts.counts[round];
|
|
2126
|
+
if (boards < workers * 2) return null;
|
|
2127
|
+
const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
|
|
2128
|
+
const entryNodes = [];
|
|
2129
|
+
for (let node = 0; node < tree.nodeCount; node++) {
|
|
2130
|
+
if (tree.kind[node] !== NodeKind.Chance) continue;
|
|
2131
|
+
if (tree.round[node] + 1 !== round) continue;
|
|
2132
|
+
entryIndexOf[node] = entryNodes.length;
|
|
2133
|
+
entryNodes.push(node);
|
|
2134
|
+
}
|
|
2135
|
+
if (entryNodes.length === 0) return null;
|
|
2136
|
+
const bounds = new Int32Array(workers + 1);
|
|
2137
|
+
for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
|
|
2138
|
+
return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
|
|
2139
|
+
}
|
|
2140
|
+
function startPool(ctx, solver, plan, payload, workers) {
|
|
2141
|
+
const entryCount = plan.entryNodes.length;
|
|
2142
|
+
const spawned = workers - 1;
|
|
2143
|
+
const reachFloats = entryCount * 2 * COMBOS;
|
|
2144
|
+
const partialFloats = spawned * entryCount * COMBOS;
|
|
2145
|
+
const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
|
|
2146
|
+
const exchange = new Float64Array(exchangeBuffer);
|
|
2147
|
+
const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
|
|
2148
|
+
const control = new Int32Array(controlBuffer);
|
|
2149
|
+
const threads = [];
|
|
2150
|
+
let failure = null;
|
|
2151
|
+
for (let w = 0; w < spawned; w++) {
|
|
2152
|
+
const setup = {
|
|
2153
|
+
workerId: w,
|
|
2154
|
+
payload,
|
|
2155
|
+
plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
|
|
2156
|
+
shardStart: plan.bounds[w + 1],
|
|
2157
|
+
shardEnd: plan.bounds[w + 2],
|
|
2158
|
+
regret: ctx.regret.buffer,
|
|
2159
|
+
strategySum: ctx.strategySum.buffer,
|
|
2160
|
+
regretScale: ctx.regretScale?.buffer ?? null,
|
|
2161
|
+
sumScale: ctx.sumScale?.buffer ?? null,
|
|
2162
|
+
control: controlBuffer,
|
|
2163
|
+
exchange: exchangeBuffer,
|
|
2164
|
+
entryCount
|
|
2165
|
+
};
|
|
2166
|
+
const thread = spawnWorker(setup, (error) => {
|
|
2167
|
+
failure ??= error;
|
|
2168
|
+
Atomics.store(control, CONTROL.ready, spawned);
|
|
2169
|
+
Atomics.add(control, CONTROL.done, spawned);
|
|
2170
|
+
Atomics.notify(control, CONTROL.done);
|
|
2171
|
+
Atomics.notify(control, CONTROL.ready);
|
|
2172
|
+
});
|
|
2173
|
+
threads.push(thread);
|
|
2174
|
+
}
|
|
2175
|
+
const deadline = Date.now() + WORKER_START_MS;
|
|
2176
|
+
for (; ; ) {
|
|
2177
|
+
const ready = Atomics.load(control, CONTROL.ready);
|
|
2178
|
+
if (ready >= spawned || failure) break;
|
|
2179
|
+
if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
|
|
2180
|
+
else Atomics.wait(control, CONTROL.ready, ready, 20);
|
|
2181
|
+
}
|
|
2182
|
+
if (failure) {
|
|
2183
|
+
for (const thread of threads) thread.terminate();
|
|
2184
|
+
throw failure;
|
|
2185
|
+
}
|
|
2186
|
+
const total = new Float64Array(COMBOS);
|
|
2187
|
+
const chanceValues = new Float64Array(entryCount * COMBOS);
|
|
2188
|
+
const mainReachMe = new Float64Array(COMBOS);
|
|
2189
|
+
const mainReachOpp = new Float64Array(COMBOS);
|
|
2190
|
+
const dispatch = (mode, traverser, iterWeight) => {
|
|
2191
|
+
Atomics.store(control, CONTROL.done, 0);
|
|
2192
|
+
Atomics.store(control, CONTROL.mode, mode);
|
|
2193
|
+
Atomics.store(control, CONTROL.traverser, traverser);
|
|
2194
|
+
Atomics.store(control, CONTROL.iterWeight, iterWeight);
|
|
2195
|
+
Atomics.store(control, CONTROL.command, COMMAND.work);
|
|
2196
|
+
Atomics.add(control, CONTROL.generation, 1);
|
|
2197
|
+
Atomics.notify(control, CONTROL.generation);
|
|
2198
|
+
const fullStart = ctx.shardStart;
|
|
2199
|
+
const fullEnd = ctx.shardEnd;
|
|
2200
|
+
ctx.shardStart = plan.bounds[0];
|
|
2201
|
+
ctx.shardEnd = plan.bounds[1];
|
|
2202
|
+
ctx.applyUpdates = true;
|
|
2203
|
+
try {
|
|
2204
|
+
for (let entry = 0; entry < entryCount; entry++) {
|
|
2205
|
+
for (let i = 0; i < COMBOS; i++) {
|
|
2206
|
+
mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
|
|
2207
|
+
mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
|
|
2208
|
+
}
|
|
2209
|
+
const value = solver.traverseChance(
|
|
2210
|
+
mode,
|
|
2211
|
+
traverser,
|
|
2212
|
+
iterWeight,
|
|
2213
|
+
plan.entryNodes[entry],
|
|
2214
|
+
mainReachMe,
|
|
2215
|
+
mainReachOpp
|
|
2216
|
+
);
|
|
2217
|
+
chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
|
|
2218
|
+
}
|
|
2219
|
+
} finally {
|
|
2220
|
+
ctx.shardStart = fullStart;
|
|
2221
|
+
ctx.shardEnd = fullEnd;
|
|
2222
|
+
}
|
|
2223
|
+
for (; ; ) {
|
|
2224
|
+
const done = Atomics.load(control, CONTROL.done);
|
|
2225
|
+
if (done >= spawned) break;
|
|
2226
|
+
if (failure) throw failure;
|
|
2227
|
+
Atomics.wait(control, CONTROL.done, done, 50);
|
|
2228
|
+
}
|
|
2229
|
+
if (failure) throw failure;
|
|
2230
|
+
};
|
|
2231
|
+
return {
|
|
2232
|
+
workers,
|
|
2233
|
+
traverse(mode, traverser, iterWeight) {
|
|
2234
|
+
ctx.applyUpdates = false;
|
|
2235
|
+
ctx.chanceOverride = null;
|
|
2236
|
+
ctx.chanceCollect = (node, reachMe, reachOpp) => {
|
|
2237
|
+
const entry = plan.entryIndexOf[node];
|
|
2238
|
+
exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
|
|
2239
|
+
exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
|
|
2240
|
+
};
|
|
2241
|
+
try {
|
|
2242
|
+
solver.traverseRoot(mode, traverser, iterWeight);
|
|
2243
|
+
} finally {
|
|
2244
|
+
ctx.chanceCollect = null;
|
|
2245
|
+
}
|
|
2246
|
+
dispatch(mode, traverser, iterWeight);
|
|
2247
|
+
for (let w = 0; w < spawned; w++) {
|
|
2248
|
+
const base = reachFloats + w * entryCount * COMBOS;
|
|
2249
|
+
for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
|
|
2250
|
+
}
|
|
2251
|
+
ctx.chanceOverride = chanceValues;
|
|
2252
|
+
ctx.applyUpdates = true;
|
|
2253
|
+
try {
|
|
2254
|
+
const value = solver.traverseRoot(mode, traverser, iterWeight);
|
|
2255
|
+
total.set(value.subarray(0, COMBOS));
|
|
2256
|
+
} finally {
|
|
2257
|
+
ctx.chanceOverride = null;
|
|
2258
|
+
}
|
|
2259
|
+
return total;
|
|
2260
|
+
},
|
|
2261
|
+
close() {
|
|
2262
|
+
Atomics.store(control, CONTROL.command, COMMAND.exit);
|
|
2263
|
+
Atomics.add(control, CONTROL.generation, 1);
|
|
2264
|
+
Atomics.notify(control, CONTROL.generation);
|
|
2265
|
+
for (const thread of threads) thread.terminate();
|
|
2266
|
+
}
|
|
2267
|
+
};
|
|
2268
|
+
}
|
|
2269
|
+
|
|
2087
2270
|
// src/engine.ts
|
|
2088
2271
|
var wasm2 = globalThis.WebAssembly;
|
|
2089
2272
|
var modules = { plain: void 0, shared: void 0 };
|
|
@@ -2255,10 +2438,12 @@ function createEngine(input, pool) {
|
|
|
2255
2438
|
Atomics.notify(control, ENGINE_CONTROL.ready);
|
|
2256
2439
|
}));
|
|
2257
2440
|
}
|
|
2441
|
+
const deadline = Date.now() + WORKER_START_MS;
|
|
2258
2442
|
for (; ; ) {
|
|
2259
2443
|
const ready = Atomics.load(control, ENGINE_CONTROL.ready);
|
|
2260
2444
|
if (ready >= threads - 1 || failure) break;
|
|
2261
|
-
|
|
2445
|
+
if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
|
|
2446
|
+
else Atomics.wait(control, ENGINE_CONTROL.ready, ready, 20);
|
|
2262
2447
|
}
|
|
2263
2448
|
if (failure) {
|
|
2264
2449
|
for (const worker of workers) worker.terminate();
|
|
@@ -2464,185 +2649,6 @@ function warmStart(to, from, averages) {
|
|
|
2464
2649
|
return { matchedNodes: matched, decisionNodes: tree.decisionNodes.length, averages };
|
|
2465
2650
|
}
|
|
2466
2651
|
|
|
2467
|
-
// src/platform/browser.ts
|
|
2468
|
-
var PLATFORM = "browser";
|
|
2469
|
-
var THREADS_AVAILABLE = false;
|
|
2470
|
-
var DEFAULT_MAX_BYTES = 512 * 1024 * 1024;
|
|
2471
|
-
function defaultWorkerCount() {
|
|
2472
|
-
return 1;
|
|
2473
|
-
}
|
|
2474
|
-
function spawnWorker(_setup, _onError) {
|
|
2475
|
-
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2476
|
-
}
|
|
2477
|
-
function spawnEngineWorker(_setup, _onError) {
|
|
2478
|
-
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2479
|
-
}
|
|
2480
|
-
|
|
2481
|
-
// src/parallel.ts
|
|
2482
|
-
var CONTROL = {
|
|
2483
|
-
generation: 0,
|
|
2484
|
-
done: 1,
|
|
2485
|
-
command: 2,
|
|
2486
|
-
traverser: 3,
|
|
2487
|
-
iterWeight: 4,
|
|
2488
|
-
ready: 5,
|
|
2489
|
-
mode: 6,
|
|
2490
|
-
size: 8
|
|
2491
|
-
};
|
|
2492
|
-
var COMMAND = { work: 0, exit: 1 };
|
|
2493
|
-
function planShards(tree, runouts, workers) {
|
|
2494
|
-
if (workers < 2) return null;
|
|
2495
|
-
let round = -1;
|
|
2496
|
-
for (let r = 1; r < runouts.rounds; r++) {
|
|
2497
|
-
if (runouts.counts[r] > 1) {
|
|
2498
|
-
round = r;
|
|
2499
|
-
break;
|
|
2500
|
-
}
|
|
2501
|
-
}
|
|
2502
|
-
if (round < 0) return null;
|
|
2503
|
-
const boards = runouts.counts[round];
|
|
2504
|
-
if (boards < workers * 2) return null;
|
|
2505
|
-
const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
|
|
2506
|
-
const entryNodes = [];
|
|
2507
|
-
for (let node = 0; node < tree.nodeCount; node++) {
|
|
2508
|
-
if (tree.kind[node] !== NodeKind.Chance) continue;
|
|
2509
|
-
if (tree.round[node] + 1 !== round) continue;
|
|
2510
|
-
entryIndexOf[node] = entryNodes.length;
|
|
2511
|
-
entryNodes.push(node);
|
|
2512
|
-
}
|
|
2513
|
-
if (entryNodes.length === 0) return null;
|
|
2514
|
-
const bounds = new Int32Array(workers + 1);
|
|
2515
|
-
for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
|
|
2516
|
-
return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
|
|
2517
|
-
}
|
|
2518
|
-
function startPool(ctx, solver, plan, payload, workers) {
|
|
2519
|
-
const entryCount = plan.entryNodes.length;
|
|
2520
|
-
const spawned = workers - 1;
|
|
2521
|
-
const reachFloats = entryCount * 2 * COMBOS;
|
|
2522
|
-
const partialFloats = spawned * entryCount * COMBOS;
|
|
2523
|
-
const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
|
|
2524
|
-
const exchange = new Float64Array(exchangeBuffer);
|
|
2525
|
-
const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
|
|
2526
|
-
const control = new Int32Array(controlBuffer);
|
|
2527
|
-
const threads = [];
|
|
2528
|
-
let failure = null;
|
|
2529
|
-
for (let w = 0; w < spawned; w++) {
|
|
2530
|
-
const setup = {
|
|
2531
|
-
workerId: w,
|
|
2532
|
-
payload,
|
|
2533
|
-
plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
|
|
2534
|
-
shardStart: plan.bounds[w + 1],
|
|
2535
|
-
shardEnd: plan.bounds[w + 2],
|
|
2536
|
-
regret: ctx.regret.buffer,
|
|
2537
|
-
strategySum: ctx.strategySum.buffer,
|
|
2538
|
-
regretScale: ctx.regretScale?.buffer ?? null,
|
|
2539
|
-
sumScale: ctx.sumScale?.buffer ?? null,
|
|
2540
|
-
control: controlBuffer,
|
|
2541
|
-
exchange: exchangeBuffer,
|
|
2542
|
-
entryCount
|
|
2543
|
-
};
|
|
2544
|
-
const thread = spawnWorker(setup, (error) => {
|
|
2545
|
-
failure ??= error;
|
|
2546
|
-
Atomics.store(control, CONTROL.ready, spawned);
|
|
2547
|
-
Atomics.add(control, CONTROL.done, spawned);
|
|
2548
|
-
Atomics.notify(control, CONTROL.done);
|
|
2549
|
-
Atomics.notify(control, CONTROL.ready);
|
|
2550
|
-
});
|
|
2551
|
-
threads.push(thread);
|
|
2552
|
-
}
|
|
2553
|
-
for (; ; ) {
|
|
2554
|
-
const ready = Atomics.load(control, CONTROL.ready);
|
|
2555
|
-
if (ready >= spawned || failure) break;
|
|
2556
|
-
Atomics.wait(control, CONTROL.ready, ready, 20);
|
|
2557
|
-
}
|
|
2558
|
-
if (failure) {
|
|
2559
|
-
for (const thread of threads) thread.terminate();
|
|
2560
|
-
throw failure;
|
|
2561
|
-
}
|
|
2562
|
-
const total = new Float64Array(COMBOS);
|
|
2563
|
-
const chanceValues = new Float64Array(entryCount * COMBOS);
|
|
2564
|
-
const mainReachMe = new Float64Array(COMBOS);
|
|
2565
|
-
const mainReachOpp = new Float64Array(COMBOS);
|
|
2566
|
-
const dispatch = (mode, traverser, iterWeight) => {
|
|
2567
|
-
Atomics.store(control, CONTROL.done, 0);
|
|
2568
|
-
Atomics.store(control, CONTROL.mode, mode);
|
|
2569
|
-
Atomics.store(control, CONTROL.traverser, traverser);
|
|
2570
|
-
Atomics.store(control, CONTROL.iterWeight, iterWeight);
|
|
2571
|
-
Atomics.store(control, CONTROL.command, COMMAND.work);
|
|
2572
|
-
Atomics.add(control, CONTROL.generation, 1);
|
|
2573
|
-
Atomics.notify(control, CONTROL.generation);
|
|
2574
|
-
const fullStart = ctx.shardStart;
|
|
2575
|
-
const fullEnd = ctx.shardEnd;
|
|
2576
|
-
ctx.shardStart = plan.bounds[0];
|
|
2577
|
-
ctx.shardEnd = plan.bounds[1];
|
|
2578
|
-
ctx.applyUpdates = true;
|
|
2579
|
-
try {
|
|
2580
|
-
for (let entry = 0; entry < entryCount; entry++) {
|
|
2581
|
-
for (let i = 0; i < COMBOS; i++) {
|
|
2582
|
-
mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
|
|
2583
|
-
mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
|
|
2584
|
-
}
|
|
2585
|
-
const value = solver.traverseChance(
|
|
2586
|
-
mode,
|
|
2587
|
-
traverser,
|
|
2588
|
-
iterWeight,
|
|
2589
|
-
plan.entryNodes[entry],
|
|
2590
|
-
mainReachMe,
|
|
2591
|
-
mainReachOpp
|
|
2592
|
-
);
|
|
2593
|
-
chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
|
|
2594
|
-
}
|
|
2595
|
-
} finally {
|
|
2596
|
-
ctx.shardStart = fullStart;
|
|
2597
|
-
ctx.shardEnd = fullEnd;
|
|
2598
|
-
}
|
|
2599
|
-
for (; ; ) {
|
|
2600
|
-
const done = Atomics.load(control, CONTROL.done);
|
|
2601
|
-
if (done >= spawned) break;
|
|
2602
|
-
if (failure) throw failure;
|
|
2603
|
-
Atomics.wait(control, CONTROL.done, done, 50);
|
|
2604
|
-
}
|
|
2605
|
-
if (failure) throw failure;
|
|
2606
|
-
};
|
|
2607
|
-
return {
|
|
2608
|
-
workers,
|
|
2609
|
-
traverse(mode, traverser, iterWeight) {
|
|
2610
|
-
ctx.applyUpdates = false;
|
|
2611
|
-
ctx.chanceOverride = null;
|
|
2612
|
-
ctx.chanceCollect = (node, reachMe, reachOpp) => {
|
|
2613
|
-
const entry = plan.entryIndexOf[node];
|
|
2614
|
-
exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
|
|
2615
|
-
exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
|
|
2616
|
-
};
|
|
2617
|
-
try {
|
|
2618
|
-
solver.traverseRoot(mode, traverser, iterWeight);
|
|
2619
|
-
} finally {
|
|
2620
|
-
ctx.chanceCollect = null;
|
|
2621
|
-
}
|
|
2622
|
-
dispatch(mode, traverser, iterWeight);
|
|
2623
|
-
for (let w = 0; w < spawned; w++) {
|
|
2624
|
-
const base = reachFloats + w * entryCount * COMBOS;
|
|
2625
|
-
for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
|
|
2626
|
-
}
|
|
2627
|
-
ctx.chanceOverride = chanceValues;
|
|
2628
|
-
ctx.applyUpdates = true;
|
|
2629
|
-
try {
|
|
2630
|
-
const value = solver.traverseRoot(mode, traverser, iterWeight);
|
|
2631
|
-
total.set(value.subarray(0, COMBOS));
|
|
2632
|
-
} finally {
|
|
2633
|
-
ctx.chanceOverride = null;
|
|
2634
|
-
}
|
|
2635
|
-
return total;
|
|
2636
|
-
},
|
|
2637
|
-
close() {
|
|
2638
|
-
Atomics.store(control, CONTROL.command, COMMAND.exit);
|
|
2639
|
-
Atomics.add(control, CONTROL.generation, 1);
|
|
2640
|
-
Atomics.notify(control, CONTROL.generation);
|
|
2641
|
-
for (const thread of threads) thread.terminate();
|
|
2642
|
-
}
|
|
2643
|
-
};
|
|
2644
|
-
}
|
|
2645
|
-
|
|
2646
2652
|
// src/index.ts
|
|
2647
2653
|
var DEFAULT_CHIP_SCALE = 100;
|
|
2648
2654
|
var OPS_PER_SECOND = 2e8;
|