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 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 = "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";
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
- Atomics.wait(control, ENGINE_CONTROL.ready, ready, 20);
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;