Postgres 18 beta1: small server, CPU-bound Insert Benchmark (v2)

This is my second attempt at a CPU-bound Insert Benchmark results with a small server. The first attempt is here and has been deprecated because sloppy programming by me meant the benchmark client was creating too many connections and that hurt results in some cases for Postgres 18 beta1.

tl;dr

• Performance between 17.5 and 18 beta1 is mostly similar on read-heavy steps
• 18 beta1 might have small regressions from new CPU overheads on write-heavy steps

Builds, configuration and hardware

I compiled Postgres from source using -O2 -fno-omit-frame-pointer for versions  14.0, 14.18, 15.0, 15.13, 16.0, 16.9, 17.0, 17.5 and 18 beta1.

The server is an ASUS ExpertCenter PN53 with and AMD Ryzen 7 7735HS CPU, 8 cores, SMT disabled, 32G of RAM and one NVMe device for the database. The OS has been updated to Ubuntu 24.04 -- I used 22.04 prior to that. More details on it are here.

For Postgres versions 14.0 through 17.5 the configuration files are in the pg* subdirectories here with the name conf.diff.cx10a_c8r32. For Postgres 18 beta1 I used 3 variations, which are here:

• conf.diff.cx10b_c8r32
• uses io_method='sync' to match Postgres 17 behavior
• conf.diff.cx10c_c8r32
• uses io_method='worker' and io_workers=16 to do async IO via a thread pool. I eventually learned that 16 is too large.
• conf.diff.cx10d_c8r32
• uses io_method='io_uring' to do async IO via io_uring

The Benchmark

The benchmark is explained here and is run with 1 client and 1 table with 20M rows. I provide two performance reports:

• one to compare Postgres 14.0 through 18 beta1, all using synchronous IO
• one to compare Postgres 17.5 with 18 beta1 using 3 configurations for 18 beta1 -- one for each of io_method= sync, workers and io_uring.

The benchmark steps are:

• l.i0
• insert 20 million rows per table in PK order. The table has a PK index but no secondary indexes. There is one connection per client.
• l.x
• create 3 secondary indexes per table. There is one connection per client.
• l.i1
• use 2 connections/client. One inserts 40M rows per table and the other does deletes at the same rate as the inserts. Each transaction modifies 50 rows (big transactions). This step is run for a fixed number of inserts, so the run time varies depending on the insert rate.
• l.i2
• like l.i1 but each transaction modifies 5 rows (small transactions) and 10M rows are inserted and deleted per table.
• Wait for X seconds after the step finishes to reduce variance during the read-write benchmark steps that follow. The value of X is a function of the table size.
• qr100
• use 3 connections/client. One does range queries and performance is reported for this. The second does does 100 inserts/s and the third does 100 deletes/s. The second and third are less busy than the first. The range queries use covering secondary indexes. This step is run for 1800 seconds. If the target insert rate is not sustained then that is considered to be an SLA failure. If the target insert rate is sustained then the step does the same number of inserts for all systems tested.
• qp100
• like qr100 except uses point queries on the PK index
• qr500
• like qr100 but the insert and delete rates are increased from 100/s to 500/s
• qp500
• like qp100 but the insert and delete rates are increased from 100/s to 500/s
• qr1000
• like qr100 but the insert and delete rates are increased from 100/s to 1000/s
• qp1000
• like qp100 but the insert and delete rates are increased from 100/s to 1000/s

Results: overview

The performance report is here for Postgres 14 through 18 and here for Postgres 18 configurations.

The summary sections (here and here) have 3 tables. The first shows absolute throughput by DBMS tested X benchmark step. The second has throughput relative to the version from the first row of the table. The third shows the background insert rate for benchmark steps with background inserts. The second table makes it easy to see how performance changes over time. The third table makes it easy to see which DBMS+configs failed to meet the SLA.

Below I use relative QPS (rQPS) to explain how performance changes. It is: (QPS for $me / QPS for $base) where $me is the result for some version $base is the result from Postgres 17.4.

When rQPS is > 1.0 then performance improved over time. When it is < 1.0 then there are regressions. When it is 0.90 then I claim there is a 10% regression. The Q in relative QPS measures: 

• insert/s for l.i0, l.i1, l.i2
• indexed rows/s for l.x
• range queries/s for qr100, qr500, qr1000
• point queries/s for qp100, qp500, qp1000

Below I use colors to highlight the relative QPS values with red for <= 0.97, green for >= 1.03 and grey for values between 0.98 and 1.02.

Results: Postgres 14.0 through 18 beta1

The performance summary is here. 

See the previous section for the definition of relative QPS (rQPS). For the rQPS formula, Postgres 14.0 is the base version and that is compared with more recent Postgres versions.

For 14.0 through18 beta1, QPS on ...

• l.i0 (the initial load)
• Slightly faster starting in 15.0
• Throughput was ~4% faster starting in 15.0 and that drops to ~2% in 18 beta1
• 18 beta1 and 17.5 have similar performance
• l.x (create index) 
• Faster starting in 15.0
• Throughput is between 9% and 17% faster in 15.0 through 18 beta1
• 18 beta1 and 17.5 have similar performance
• l.i1 (write-only)
• Slower starting in 15.0
• It is ~3% slower in 15.0 and that increases to between 6% and 10% in 18 beta1
• 18 beta1 and 17.5 have similar performance
• l.i2 (write-only)
• Slower starting in 15.13 with a big drop in 17.0
• 18 beta1 with io_method= sync and io_uring is worse than 17.5. It isn't clear but one problem might be more CPU/operation (see cpupq here)
• qr100, qr500, qr1000 (range query)
• Stable from 14.0 through 18 beta1
• qp100, qp500, qp1000 (point query) 
• Stable from 14.0 through 18 beta1

Results: Postgres 17.5 vs 18 beta1

The performance summary is here. 

See the previous section for the definition of relative QPS (rQPS). For the rQPS formula, Postgres 17.5 is the base version and that is compared with results from 18 beta1 using the three configurations explained above:

• x10b with io_method=sync
• x10c with io_method=worker and io_workers=16
• x10d with io_method=io_uring

The summary of the summary is:

• initial load step (l.i0)
• 18 beta1 is 1% to 3% slower than 17.5
• This step is short running so I don't have a strong opinion on the change
• create index step (l.x)
• 18 beta1 is 0% to 2% faster than 17.5
• This step is short running so I don't have a strong opinion on the change
• write-heavy step (l.i1)
• 18 beta1 with io_method= sync and workers has similar perf as 17.5
• 18 beta1 with io_method=io_uring is ~4% slower than 17.5. The problem might be more CPU/operation, see cpupq here
• write-heavy step (l.i2)
• 18 beta1 with io_method=workers is ~2% faster than 17.5
• 18 beta1 with io_method= sync and workers is 6% and 8% slower than 17.5. The problem might be more CPU/operation, see cpupq here
• range query steps (qr100, qr500, qr1000)
• 18 beta1 and 17.5 have similar performance
• point query steps (qp100, qp500, qp1000)
• 18 beta1 and 17.5 have similar performance

The summary is:

• initial load step (l.i0)
• rQPS for (x10b, x10c, x10d) was (0.98, 0.99, 0.97)
• create index step (l.x)
• rQPS for (x10b, x10c, x10d) was (1.00, 1.02, 1.00)
• write-heavy steps (l.i1, l.i2)
• for l.i1 the rQPS for (x10b, x10c, x10d) was (1.01, 1.00, 0.96)
• for l.i2 the rQPS for (x10b, x10c, x10d) was (0.94, 1.02, 0.92)
• range query steps (qr100, qr500, qr1000)
• for qr100 the rQPS for (x10b, x10c, x10d) was (0.99, 1.00, 1.00)
• for qr500 the rQPS for (x10b, x10c, x10d) was (0.99, 1.01, 1.00)
• for qr1000 the rQPS for (x10b, x10c, x10d) was (0.99, 1.00, 1.00)
• point query steps (qp100, qp500, qp1000)
• for qp100 the rQPS for (x10b, x10c, x10d) was (1.00, 1.00, 1.00)
• for qp500 the rQPS for (x10b, x10c, x10d) was (0.99, 1.00, 1.00)
• for qp1000 the rQPS for (x10b, x10c, x10d) was (0.99, 1.00, 0.98)