The impact of PGO, LTO and more for MySQL on a small CPU: insert benchmark

This post has results for the impact of PGO, LTO and other compiler options for MySQL using the Insert Benchmark. I previously shared results like this for sysbench. The PGO builds here were created from profiles captured during sysbench and I am curious to understand whether the benefit from those builds extends to other workloads. 

tl;dr

• PGO builds created using sysbench also help other workloads like the Insert Benchmark
• results here are similar to results from sysbench
• gcc does slightly better than clang without LTO or PGO
• clang does slightly better than gcc with PGO
• clang does more than slightly better than gcc with PGO + LTO
• gcc with PGO has similar performance as with PGO + LTO

Builds

I compiled upstream MySQL 8.0.28 from source. The my.cnf file is here. 

All work (builds & tests) are done on a server that uses Ubuntu 22.04.5. The gcc version is 11.4.0 and the clang version is 14.0.0-1ubuntu1.1.

The CMake command lines for all of the builds are here. All builds use CMAKE_BUILD_TYPE =Release. The builds are listed below and the name of the CMake command line file per build is cmk.80.$val where $val is the build name listed below:

• rel_o2nofp
• uses gcc, -O2 instead of -O3, adds -fno-omit-frame-pointer, works great for flamegraphs
• rel_o2nofp_clang
• uses clang, -O2 instead of -O3, adds -fno-omit-frame-pointer, works great for flamegraphs
• rel
• uses gcc, -O3, doesn't work great for flamegraphs
• rel_clang
• uses clang, -O3, doesn't work great for flamegraphs
• rel_o2nofp_lto
• like rel_o2nofp but adds -DWITH_LTO=ON to get link-time optimization
• rel_o2nofp_lto_clang
• like rel_o2nofp_clang but adds -DWITH_LTO=ON to get link-time optimization
• rel_lto
• like rel but adds -DWITH_LTO=ON to get link-time optimization
• rel_lto_clang
• like rel_clang but adds -DWITH_LTO=ON to get link-time optimization
• rel_o2nofp_native
• like rel_o2nofp but adds -march=native -mtune=native
• rel_o2nofp_native_clang
• like rel_o2nofp_clang but adds -march=native -mtune=native
• rel_native
• like rel but adds -march=native -mtune=native
• rel_native_clang
• like rel_clang but adds -march=native -mtune=native
• rel_o2nofp_native_lto
• like rel_o2nofp but adds -march=native -mtune=native and -DWITH_LTO=ON
• rel_o2nofp_native_lto_clang
• like rel_o2nofp_clang but adds -march=native -mtune=native and -DWITH_LTO=ON
• rel_native_lto
• like rel but adds -march=native -mtune=native and -DWITH_LTO=ON
• rel_native_lto_clang
• like rel_clang but adds -march=native -mtune=native and -DWITH_LTO=ON
• rel_pgo_use
• like rel but uses PGO via -fprofile-generate. The profiles for PGO were captured while running sysbench.
• rel_pgo_use_clang
• like rel_clang but uses PGO via -fprofile-generate. The profiles for PGO were captured while running sysbench.
• rel_lto_pgo_use
• like rel but uses PGO via -fprofile-generate and -DWITH_LTO=ON. The profiles for PGO were captured while running sysbench.
• rel_lto_pgo_use_clang
  
• like rel_clang but uses PGO via -fprofile-generate and -DWITH_LTO=ON. The profiles for PGO were captured while running sysbench.

Hardware

The server here is a Beelink SER4 with an AMD Ryzen 7 4700 CPU with SMT disabled, 8 cores, 16G of RAM and Ubuntu 22.04. The storage is 1 NVMe device.

The CPU used here (AMD 4700u) is described as a laptop class CPU. The server is configured to use the performance frequency governor and acpi-cpufreq scaling driver.

The Benchmark

The benchmark is explained here and is run with 1 client and 1 table. The database is cached by InnoDB.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.

The summary section in the performance report has 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 and all systems sustained the target rates. 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 to explain how performance changes. It is: (QPS for $me / QPS for $base) where $me is my version and $base is the version of the base case. The base case MySQL 8.0.28 with the rel_o2nofp build.

When relative QPS is > 1.0 then performance improved over time. When it is < 1.0 then there are regressions. 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.95, green for >= 1.05 and grey for values between 0.95 and 1.05.

Normally I summarize performance here but I think the summary in the tl;dr above is sufficient.