Memory: big spots & fallbacks

Solver memory grows with tree size. A flop solve with many bet sizes and deep stacks can need 10-30 GB of RAM. ARTGTO has a layered system to keep solves within your machine's limits.

Pre-solve memory guard

Before allocating anything, the solver estimates how much RAM the spot will need and checks it against your available free memory (with a safety margin). If the spot does not fit, the solve is refused up front with a message telling you how much memory it needs and how much you have.

This prevents the solver from committing into the Windows page file, which would freeze your machine. You get a clear error instead of a system hang.

16-bit compression

Enable the 16-bit compress checkbox to store solver data in half-precision (16-bit) instead of full 32-bit. This cuts memory use roughly in half.

Tradeoffs:

• Solves use about half the RAM.
• Solves are slightly slower per iteration (quantize/dequantize overhead).
• The solver still reaches the standard 0.30% target on virtually all boards.
• On very polarized boards, you may not be able to refine below roughly 0.20% exploitability. For most study this does not matter.

16-bit compression is off by default for single solves. In the batch runner (Jobs), the solver can automatically fall back to 16-bit if a board does not fit at full precision.

Low-memory fallback (river bucketing)

This is the last resort for spots that do not fit even with 16-bit compression. It is on by default.

How it works: On large spots, the river is where almost all the memory goes — each river hand gets its own strategy row. The fallback groups river hands of similar strength into buckets, and hands in the same bucket share one strategy. The solver picks the largest bucket count that fits in memory, from a ladder of 400 down to 50.

What stays exact:

• Flop and turn strategies keep full per-hand detail.
• Showdown and blocker math stays exact (per-hand).

What changes:

• River hands with similar strength play the same mixed strategy instead of independent ones.
• The approximation is mild for most boards — hands with rank 1042 and rank 1044 were already playing nearly identically. But it is an approximation, and you should know it is there.

How to tell it is active: During the solve, the status bar shows Very low memory — solving with river bucketing @ N.... When the solve finishes, the done message reads Done — X iters … river-bucketed @ N. In the Multi Job run log, the line reads SOLVED (river buckets @ N).

The fallback only engages when a spot cannot solve otherwise. It never activates on spots that fit in memory.

How the layers stack

The solver tries to solve your spot in this order:

1. Full precision (32-bit) — if it fits, this is what runs. No compromises.
2. 16-bit compression — if full precision does not fit but 16-bit does, falls back automatically (in batch mode) or tells you to enable the checkbox (in single-solve mode).
3. River bucketing + 16-bit — if even 16-bit does not fit, groups river hands by strength. Only in batch mode (Jobs with the low-memory fallback enabled).
4. Refused — if none of the above fit, the solve is refused with an explanatory message.

In single-solve mode, the solver does not silently fall back. It tells you what is happening and lets you decide. In batch mode (Jobs), automatic fallback is the default so overnight runs do not stop on one oversized board.

Practical guidance

• 16 GB RAM: comfortable for most 3-bet pot and 4-bet pot boards. Some deep SRP boards may need 16-bit.
• 32 GB RAM: handles most SRP boards at full precision.
• 64 GB RAM: solves nearly everything at full precision, including aggressive sizing trees.

Closing other applications before a large solve frees RAM for the solver. The memory guard checks free memory, not total.