Menentukan Ukuran Pool Berdasarkan Jumlah Inti CPU

A common mistake is treating the connection pool as a buffer you can grow freely. With PgBouncer in front of PostgreSQL, you actually run two limits: how many clients can talk to PgBouncer, and how many server connections PgBouncer keeps open to PostgreSQL.

• max_client_conn can be large (thousands) — these are cheap proxied sockets.
• default_pool_size (and PostgreSQL max_connections) is the expensive number — each one is a real backend process.

This lesson is about choosing that expensive number from your CPU core count and workload, so the database does real work instead of thrashing between too many backends.

Each PostgreSQL connection is backed by a dedicated OS process. When you have more active backends than CPU cores, the kernel time-slices them. Past a point, adding connections does not add throughput — it adds context switches, lock contention, and memory pressure.

You can see how many backends exist right now and how many are actually running queries:

The widely cited baseline for a CPU-bound, mostly-active workload is:

• connections = (core_count * 2) + effective_spindle_count

The * 2 accounts for backends that briefly stall on I/O or locks while others use the CPU. The effective_spindle_count approximates how many concurrent I/O operations your storage can absorb (think 0 for a fully cached working set, higher for many-disk arrays).

For an 8-core server on SSD with a mostly-cached dataset, this lands around 16-20 server connections — not 200.

You don't have to do the arithmetic by hand. PostgreSQL exposes detected core counts, so you can compute a starting pool size directly. The query below is self-contained and runs anywhere:

The formula sizes for active work. Pools fail in practice because of backends parked in idle in transaction — they hold a slot (and often locks) without doing anything. These eat your budget just as much as busy queries.

Audit them before you size up the pool:

How aggressively PgBouncer reuses server connections depends on pool_mode:

• session: a server connection is tied to a client for its whole session. You need roughly as many server connections as concurrent clients — pooling buys little.
• transaction: a server connection is returned after each transaction. A small pool can serve many clients. This is what lets (cores*2)-sized pools handle thousands of clients.
• statement: returned after each statement; most aggressive, but forbids multi-statement transactions.

Sizing against core count assumes transaction mode for OLTP workloads.

Putting the numbers together for an 8-core OLTP database, a typical pgbouncer.ini looks like this. Note how max_client_conn is huge while default_pool_size stays near the formula's output:

PostgreSQL's max_connections is a hard ceiling across all PgBouncer pools plus reserved superuser slots. If you run several databases/users, each gets its own pool of up to default_pool_size, and they all draw from the same backend budget.

Rule of thumb: max_connections ≥ sum of all pool sizes + reserve_pool_size + superuser_reserved_connections + a margin for maintenance and replication.

Cores cap useful concurrency, but RAM caps how high max_connections can safely go. Each backend can allocate up to work_mem per sort/hash node, and a single query may use it several times over.

• Worst case ≈ max_connections * work_mem * (nodes per query).
• Set work_mem with the real connection ceiling in mind — a small pool lets you afford a larger work_mem.

This is a strong argument for pooling: fewer backends means more memory per query.

The formula is a starting point, not gospel. After deploying, watch whether backends are CPU-bound (good — cores are the limit) or stuck on LWLock/Lock waits (a sign the pool is too large and contention is rising).

Sample the wait events under load:

Use a tight feedback loop instead of guessing:

• Start at (cores * 2) for default_pool_size.
• Load test. If throughput is flat and latency rises while CPUs are saturated, the pool is already big enough — shrink it.
• If CPUs sit idle while clients queue at PgBouncer (rising cl_waiting), the pool may be too small or queries are I/O-bound — raise effective_spindle_count and retest.

Check PgBouncer's own view of pressure with the admin console:

You have a 16-core PostgreSQL server, NVMe storage, and a working set that fits entirely in RAM (effectively zero spindles). The app currently opens 800 direct connections and CPUs are pegged with rising lock waits. Using the standard sizing approach with PgBouncer in transaction mode, what is the best starting default_pool_size?

Key takeaways for sizing pools against core count:

• Separate the cheap limit (max_client_conn) from the expensive one (default_pool_size / max_connections).
• Start from (cores * 2) + effective_spindle_count — usually tens of connections, not hundreds.
• The formula assumes transaction pool mode; session mode needs far more server connections.
• Ensure max_connections covers the sum of all pools plus reserved slots, and budget RAM via work_mem * max_connections.
• Hunt down idle in transaction backends and validate with real wait-event and SHOW POOLS data — shrink when CPU-bound, only grow when CPUs idle and clients queue.