Thursday, June 8, 2017

Insert benchmark, IO-bound & Intel NUC for MySQL 5.6, 5.7 & 8

Update - the regression isn't as bad as I have been reporting. Read this post to understand why.

Next up in my series on low-concurrency performance is the insert benchmark on Intel NUC servers with an IO-bound workload. The database and working set are much larger than RAM and there are many reads from and writes to storage. This is part of my work on bug 86215. One day I will stop running tests and start working on code improvements but not yet. Read this for more on the insert benchmark.

tl;dr
  • New MySQL releases do better on the i3 NUC but worse on the i5 NUC. This is similar to results for the in-memory test, but the differences are larger for IO-bound. One theory for why I don't see a regression for the i3 NUC is that the SSD has much higher read response times which mask CPU overheads. Per StorageReview the read latency on the i3 NUC might be 1.5X slower for a read-only workload. I will guess the difference is larger for a mixed workload.
  • I hope to repeat the tests for the i3 NUC because the speedup on the q100 test is odd. I have repeated some of the results for the in-memory insert benchmark. It is possible that the device wasn't in a steady state for all of the IO-bound tests. Perhaps I need to run tests for more time.
  • In case you missed the previous two points, my results for the i3 NUC are confusing and I hope to repeat tests to explain that. But the i5 NUC results match previous tests and show the impact from the CPU regression in new MySQL releases, even for IO-bound workloads.

Configuration

I tested MySQL using upstream 5.6.35, 5.7.17 and 8.0.1. For 8.0.1 I repeated the test: first with the default charset/collation and then with latin1/latin1_swedish_ci.

My servers are described here. The charts below refer to the servers as i3 NUC and i5 NUC. Compared to the i3 NUC, the i5 NUC is newer, has a CPU that is 2X faster, 2X more RAM and storage that is more than 2X faster.

The my.cnf used for each database engine is described here. The my.cnf files I share were for the i3 NUC. For the i5 NUC the InnoDB buffer pool and IO capacity options were increased using these values. I use the same server for mysqld and the sysbench clients. The binlog is enabled but sync-on-commit is disabled.

My usage of the insert benchmark is described here. For this test I used 1 client for the load test and then 1 writer + 1 query client for the tests that do inserts & queries concurrently. The load test loads 250M rows for the i3 NUC, 500M rows for the i5 NUC and the insert+query tests run for about 2 hours per test.

Results

The first pair of graphs shows the absolute and relative insert rates during the load test. For the i3 NUC there is no regression from MySQL 5.6 to 5.7 and 8. For the i5 NUC there is a regression and about half is from 5.6 to 5.7.

The next pair of graphs is the absolute and relative query rate for the q1000 test where another client does 1000 inserts/second. For the i3 NUC there is no regression. For the i5 NUC there is a large regression and about half is from MySQL 5.6 to 5.7.

The next pair of graphs is the absolute and relative query rate for the q100 test where another client does 100 inserts/second. For the i3 NUC there a speedup from MySQL 5.6 to recent releases. For the i5 NUC there is a small regression after MySQL 5.6.

CPU regression

I run vmstat and iostat when the tests run to determine how much hardware is used per insert and per query. For each of the tests (load, q1000, q100) the graphs show the inverse of the relative CPU overhead per insert and per query. For the i5 NUC the results here are similar to the throughput results above and more CPU overhead in recent MySQL releases is likely to explain the throughput regression. For the i3 NUC the CPU overhead appears to be reduced on recent releases. I don't understand that yet. Note that my CPU measurement includes everything on the host, not just mysqld.
Metrics

All of the performance data is here. This includes metrics from the benchmark client and from vmstat and iostat.

Friday, June 2, 2017

Insert benchmark, in-memory & Intel NUC for MySQL 5.6, 5.7 and 8

Update - the regression isn't as bad as I have been reporting. Read this post to understand why.

Next up in my series on low-concurrency performance is results for the insert benchmark on Intel NUC servers with an in-memory workload. The database is cached so there are no reads from but many writes to storage. This is part of my work on bug 86215. One day I will stop running tests and start working on code improvements but not yet. Read this for more on the insert benchmark.

tl;dr
  • MySQL 5.7 and 8 get about 85% of the insert throughput and 72% of the query throughput compared to MySQL 5.6.
  • For the i3 NUC about half of the regression is from MySQL 5.6 to 5.7 and the other half from 5.7 to 8. For the i5 NUC most of the regression is from MySQL 5.6 to 5.7. This is true for all of the tests (load, q1000 and q100).
  • MySQL 5.7 and 8 use more CPU per insert and per query and that explains the regression. Note that I run the benchmark client on the same host as mysqld and the client uses a lot of CPU so the real CPU regression is larger than I report here.

Configuration

I tested MySQL using upstream 5.6.35, 5.7.17 and 8.0.1. For 8.0.1 I repeated the test: first with the default charset/collation and then with latin1/latin1_swedish_ci.

My servers are described here. The charts below refer to the servers as i3 NUC and i5 NUC. Compared to the i3 NUC, the i5 NUC is newer, has a CPU that is 2X faster, 2X more RAM and storage that is more than 2X faster.

The my.cnf used for each database engine is described here. The my.cnf files I share were for the i3 NUC. For the i5 NUC the InnoDB buffer pool and IO capacity options were increased using these values. I use the same server for mysqld and the sysbench clients. The binlog is enabled but sync-on-commit is disabled.

My usage of the insert benchmark is described here. For this test I used 1 client for the load test and then 1 writer + 1 query client for the tests that do inserts & queries concurrently. The load test loads 10M rows and the insert+query tests run for about 2 hours per test.

Results

The first pair of graphs shows the absolute and relative insert rates during the load test. On the i3 NUC about half of the regression is from MySQL 5.6 to 5.7 and the other half from 5.7 to 8 On the i5 NUC about 2/3 of the regression is from MySQL 5.6 to 5.7 and 1/3 from 5.7 to 8.
The next pair of graphs is the absolute and relative query rate for the q1000 test where another client does 1000 inserts/second. For the i3 NUC about half of the regression is from MySQL 5.6 to 5.7 and the other half from 5.7 to 8. For the i5 NUC most of the regression is from MySQL 5.6 to 5.6. This is similar to the results for the load test above.

The next pair of graphs is the absolute and relative query rate for the q100 test where another client does 100 inserts/second. For the i3 NUC about half of the regression is from MySQL 5.6 to 5.7 and the other half from 5.7 to 8. For the i5 NUC most of the regression is from MySQL 5.6 to 5.6. This is similar to the results for the load and q1000 tests above.


CPU regression

I run vmstat and iostat when the tests run to determine how much hardware is used per insert and per query. Here I show that almost all of the throughput differences are due to a CPU regression from MySQL 5.6 to 5.7 and 8. For each of the tests (load, q1000, q100) the graphs show the inverse of the relative CPU overhead per insert and per query. In the charts you can see that value is similar to the relative insert and query rates above.
Metrics

All of the performance data is here. This includes metrics from the benchmark client and from vmstat and iostat.

Thursday, June 1, 2017

The Insert Benchmark

The insert benchmark was first published by Tokutek in C++. Since then I converted it to Python, they made my Python version faster, I added support for MongoDB and I have been using it to evaluate storage engine efficiency. I think it is about 10 years old and been useful at finding things we can make better in storage engines. I hope to convert it to a faster language but in Python the code is still faster than storage engines for IO-bound workloads.

I use a helper script to run a sequence of tests. For all tests there is either one table shared by all clients or a separate table per client. Some storage engines suffer more from concurrency within a table. For MySQL each table has a primary key index up to 3 secondary indexes. I configure the tests to use 3 secondary indexes. The inserts during the load are in PK order but random for the secondary indexes. InnoDB benefits from the change buffer. MyRocks and MongoRocks benefit from read-free secondary index maintenance. MongoRocks and WiredTiger suffer from the hidden index used by MongoDB for engines that use clustered indexes, but the overhead is less with the insert benchmark than for Linkbench. The tests are:
  1. load - this is the first test and uses N clients to load into the test table(s).
  2. scan - scan in order: the primary index, each secondary index, the primary index. So there are 5 scans total. The scan uses 1 client per index. For the test with 16 tables there are 16 concurrent scans per index. For the test with 1 table there is 1 client (no concurrency). Each scan is index only and returns no rows as non-indexed predicates exclude all rows.
  3. q1000 - this is the second test and uses N query clients and N writer clients. Each writer client is rate limited to 1000 inserts/second. With some storage engines the writer clients are unable to sustain that rate. With N writer clients the global write rate should be N*1000 inserts/second. The query clients perform range scans as fast as possible. The usage of tables is the same as 
  4. q100 - this is the third test and uses N query clients and N writer clients. Each writer client is rate limited to 100 inserts/second. With N writer clients the global write rate should be N*100 inserts/second. The query clients perform range scans as fast as possible.
The benchmark client and my helper scripts are on github. The client is iibench.py and the top-level helper scripts is iq.sh. One day I will add a few comments to iq.sh to explain the command line. An example command line to run it for 500M rows, 16 clients and each client using a separate table is:
    bash iq.sh innodb "" ~/b/orig801/bin/mysql /data/m/my/data nvme0n1 1 1 no no no 0 no 500000000

When it finishes there will be four directories named l, scan, q1000 and q100. In each directory there is a file named o.res.$something that has performance and efficiency metrics. The l directory has results from the load step. The scan directory has the results from the scans. The q1000 and q100 directories have results from the write+query step where each writer is rate limited to 1000/second and 100/second. An example o.res.$something file for a test with 500M rows and 1 client is here for the load test and here for the q1000 test. Each file has a section with efficiency metrics normalized by the insert rate and then efficiency metrics normalized by the query rate. For the load test only the first section is interesting. For the q1000 test both sections are interesting. For the q100 test only the second section is interesting because the insert rates are too low. Efficiency metrics from the scan are normalized by the number of rows scanned.

Metrics for load, q1000 and q100

The first section starts with the text iostat, vmstat normalized by insert rate and the second section starts with the text iostat, vmstat normalized by query rate. They both have similar data -- rates from iostat and vmstat normalized by the insert and query rate. An example is:
iostat, vmstat normalized by insert rate
samp    r/s     rkb/s   wkb/s   r/q     rkb/q   wkb/q   ips             spi

501     3406.8  54508   91964   3.410   54.563  92.057  999.0           0.100100

samp    cs/s    cpu/c   cs/q    cpu/q
525     16228   17.3    16.244  0.017276

iostat, vmstat normalized by query rate
samp    r/s     rkb/s   wkb/s   r/q     rkb/q   wkb/q   qps             spq
501     3406.8  54508   91964   4.023   64.370  108.602 846.8           0.118092

samp    cs/s    cpu/c   cs/q    cpu/q
525     16228   17.3    19.164  0.02038

The metric names are:
  • samp - number of iostat or vmstat samples collected during the test
  • r/s, rkb/s, wkb/s - average values for iostat r/s, rKB/s and wKB/s during the test
  • r/q - iostat r/s divided by the insert or query rate
  • rKB/q, wKB/q - iostat rKB/s and wKB/s divided by the insert or query rate
  • ips, qps - average insert and query rate
  • spi, spq - seconds per insert, seconds per query - average response time for inserts and queries
  • cs/s - average vmstat cs/s rate (cs is context switch)
  • cpu/c - average CPU utilization from vmstat us & sy (user & system)
  • cs/q - context switches per insert or per query
  • cpu/q - CPU utilization divided by insert or query rate then multiplied by a constant. This is only comparable between servers with the same CPU count.
Metrics for scan

Metrics for scan are measured differently. Absolute rates from iostat and vmstat are collected. But normalized rates are computed by dividing by the row scan rate (rows read / second). The header for the metrics looks like:
secs    rMB/s   wMB/s   r/o     rKB/o   wKB/o   rGB     cs/o    Mcpu/o  wa.sec  engine

And a legend for these columns is:
  • secs - seconds to finish the full scan of the index
  • rMB/s, wMB/s - iostat read MB/second and write/MB second
  • r/o, rKB/o, wKB/o - iostat reads/row, KB read/row and KB written/row. There can be writes because the index scans are done immediately after the load and compaction or page writeback can be in progress.
  • cs/o - context switches per row read using the vmstat cs column
  • Mcpu/o - normalized CPU overhead per row
  • wa.sec - number of seconds in IO wait state computed from iostat wa

Wednesday, May 31, 2017

Sysbench, IO-bound & Intel NUC for MySQL 5.6, 5.7 & 8

Update - the regression isn't as bad as I have been reporting. Read this post to understand why.

In this post I share results from sysbench with an IO-bound workload on Intel NUC servers. My previous post shared results from an in-memory workload. This is part of my work from bug 86215 as I identify CPU performance regressions from MySQL 5.6 to 5.7 and 8.

tl;dr
  • The results here are similar to, but not as bad as, the results from the in-memory workload. This is reasonable because CPU regressions can be hidden by IO-bound tests. But if you scroll to the bottom of this page and look at the graph for the point-query test you will see there are problems even for IO-bound tests.
  • For the i5 NUC most of the regression is from 5.6 to 5.7
  • For the i3 NUC, MySQL 5.7 did better especially on range scans but there is still a regression from 5.6 to 8. From many tests I have run it looks like someone did great work in MySQL 5.7 to make range scans more efficient in InnoDB.
  • For long scans the overhead from the default charset/collation in MySQL 8 is significant compared to latin1/latin1_swedish_ci.
Configuration

I tested MySQL using upstream 5.6.35, 5.7.17 and 8.0.1. For 8.0.1 I repeated the test: first with the default charset/collation and then with latin1/latin1_swedish_ci.

My servers are described here. The charts below refer to the servers as i3 NUC and i5 NUC. Compared to the i3 NUC, the i5 NUC is newer, has a CPU that is 2X faster, 2X more RAM and storage that is more than 2X faster.

My usage of sysbench, including the tests run, and the my.cnf used for each database engine is described here. The my.cnf files I share were for the i3 NUC. For the i5 NUC the InnoDB buffer pool and IO capacity options were increased using these values. I use the same server for mysqld and the sysbench clients. The binlog is enabled but sync-on-commit is disabled. Sysbench is run with 4 tables and 40M rows per table. The database is larger than RAM. Although in future tests I might need to use larger tables for the i5 NUC which has twice the memory of the i3 NUC.

Results

I first ran these tests on the i3 NUC and then was curious about performance on a more modern CPU so I setup a cluster of new i5 NUC servers. I am a big fan of Intel NUC and have 6 at home and have yet to trip a circuit breaker, overheat my office or suffer from too much fan noise. The results on the i5 NUC are different than on the i3 NUC. On the i3 NUC MySQL 5.7 has much less of a regression from 5.6. While on the i5 NUC most of the regression is from MySQL 5.6 to 5.7. Perhaps one day I will have time to explain that, but I am too busy right now.

The results are in the order in which tests are run.

There is a small regression from 5.6 to 5.7/8 for update-index on the i5 NUC. This test requires secondary index maintenance as part of the update (read-modify-write of secondary index leaf pages). 
The regression for i5 NUC for update-nonindex is larger than for update-index. This test is less IO-bound than update-index because secondary index maintenance is not needed.
The regression for delete is worse on the i5 NUC. If fact, there isn't a regression on the i3 NUC.

The regression for write-only is worse on the i5 NUC and there isn't a regression on the i3 NUC.
For read-write the regression is worse on the i5 NUC. MySQL 5.7 does better than 5.6 on the i3 NUC and that difference is larger for the larger range scan (10,000 row) than the smaller (100 row).
For read-only using latin1/latin1_swedish_ci improves QPS at 1000 and 10,000 row range scans with MySQL 8 compared to the default charset/collation. Again, MySQL 5.7 does great on the i3 NUC and does better as the range scan increases. MySQL 8 has regressions on both the i3 and i5 NUC and that isn't explained by charset.



For point-query the regression on the i3 NUC starts with MySQL 8 and on the i5 NUC starts with MySQL 5.7.
For insert the regression is larger on the i5 NUC.

Tuesday, May 30, 2017

Sysbench, in-memory & Intel NUC

Update - the regression isn't as bad as I have been reporting. Read this post to understand why.

This continues my series on low-concurrency performance regressions, Here I share results for in-memory sysbench using my home Intel NUC servers. The results were first shared in bug 86215 and the numbers for the charts in this post are here.

tl;dr
  • For the i5 NUC most of the regression is from MySQL 5.6 to 5.7
  • For the i3 NUC MySQL 5.7.17 matches 5.6.35 in many tests and does much better on range scans. Alas I have yet to debug this. But MySQL 8.0.1 is much worse than 5.6.35. At first I only had results for the i3 NUC and assumed the regression was from 5.7 to 8 but now I think that most of the regression comes from MySQL 5.6 to 5.7. Soon I will repeat these tests on servers I use at work that have a better CPU than what I get in the i5 NUC.
  • For long range scans there is more overhead with the default charset/collation in MySQL 8.0.1 and switching back to latin1/latin1_swedish_ci improves QPS.

Configuration

I tested MySQL using upstream 5.6.35, 5.7.17 and 8.0.1. For 8.0.1 I repeated the test: first with the default charset/collation and then with latin1/latin1_swedish_ci.

My servers are described here. The charts below refer to the servers as i3 NUC and i5 NUC. Compared to the i3 NUC, the i5 NUC is newer, has a CPU that is 2X faster, 2X more RAM and storage that is more than 2X faster.

My usage of sysbench, including the tests run, and the my.cnf used for each database engine is described here. The my.cnf files I share were for the i3 NUC. For the i5 NUC the InnoDB buffer pool and IO capacity options were increased using these values. I use the same server for mysqld and the sysbench clients. The binlog is enabled but sync-on-commit is disabled. Sysbench is run with 4 tables and 1M rows per table. The database fits in the InnoDB buffer pool.

Results

I first ran these tests on the i3 NUC and assumed that the regression was mostly from MySQL 5.6 to MySQL 8. Then I acquired the i5 NUC servers and repeated tests and it looks like more of the regression is from MySQL 5.6 to 5.7. Regardless, I hope we can make this better.

The results are in the order in which the tests are run. For several tests MySQL 5.7.17 does better on the i3 NUC than the i5 NUC, relative to MySQL 8. That is most apparent on the tests that do longer range scans. I thought that was a mistake but the result is repeatable. From past tests there appears to be improvements to range scan performance for InnoDB in MySQL 5.7. Perhaps this is an artifact of that improvement.

The results for update-index are typical. The regression is worse on the i5 NUC.
The regression for update-nonindex is worse than for update-index and worse on the i5 NUC.
The regression for delete is worse on the i5 NUC.
The regression for write-only is worse on the i5 NUC.
For read-write with a 100 row range scan MySQL 5.7.17 does better on the i3 NUC. I didn't debug that. Otherwise the regressions are similar between the i3 NUC and i5 NUC. Switching the charset for MySQL 8.0.1 from utf to latin1 has a small impact.
For read-write with a 10,000 row range scan MySQL 5.7.17 does better on the i3 NUC. I didn't debug that. Otherwise the regressions are similar between the i3 NUC and i5 NUC. Switching the charset for MySQL 8.0.1 from utf to latin1 has a big impact.
For the read-only tests using latin1/latin1_swedish_ci improves QPS at 1000 and 10,000 row range scans. MySQL 5.7.17 does great on the i3 NUC but has regressions on the i5 NUC. MySQL 8.0.1 has regressions on the i3 and i5 NUC.
For point-query MySQL 5.7.17 does better on the i3 NUC. Otherwise the regressions from MySQL 5.6 to newer releases are similar.
For insert MySQL 5.7.17 does better on the i3 NUC. Otherwise the regressions from MySQL 5.6 to newer releases are similar.

Short guide on using performance_schema for user & table stats

It took me too long to figure this out while reading the chapter on PS in the MySQL manual. Hopefully this saves me time the next time I need to figure it out. I think it gives me the equivalent of the data I get from IS.user_statistics and IS.table_statistics when using FB MySQL. From a few tests I ran the overhead from the PS was small, maybe less than 5%, while collecting this data.
  1. Add performance_schema=1 to my.cnf
  2. For table stats: select * from table_io_waits_summary_by_table
  3. For user stats: select * from events_statements_summary_by_account_by_event_name
Update - great advice from Mark Leith for MySQL 5.7 and newer
For table stats see the docs and run: SELECT * FROM sys.schema_table_statistics
For user stats see the docs and run: SELECT * FROM sys.user_summary

Monday, May 29, 2017

The history of low-concurrency performance regressions in MySQL 5.6, 5.7 and 5.8

Update - the regression isn't as bad as I have been reporting. Read this post to understand why.

What is a reasonable goal for performance regressions between major releases of MySQL (5.6, 5.7, 5.8)? Some regressions are expected because more features means longer code paths. But what if MySQL 5.7 and 5.8 only get 2/3 of the QPS versus MySQL 5.6 at low concurrency?

The low-concurrency performance regressions from MySQL 5.6 to 5.7 continue in MySQL 8. That isn't a surprise for two reasons. First, more features usually make a DBMS slower. Second, all of the performance marketing for new MySQL releases focuses on high-concurrency workloads. One example of the regression occurs for in-memory sysbench where MySQL 5.7 and MySQL 8 get 60% to 70% of the QPS compared to 5.6, which is the same as writing that 5.6 gets 1.43X to 1.67X more QPS than MySQL 5.7 and MySQL 8.

A deployment that I care about uses MySQL 5.6 and we want to use MySQL 8. Alas, we need to reduce the performance regressions for that to happen. I am excited that the community has another chance to make MySQL better because I don't think this will be fixed without us. I have been writing about this problem since 2013. I am also happy to note that the performance schema isn't the problem. I rediscovered this problem when using MySQL 8 on my home test servers and filed bug 86215. While I have published results showing the regression from earlier releases to MySQL 5.6 -- at this point I just want to get back to the low-concurrency QPS we get from MySQL 5.6. I have good memories from MySQL 4.0, 5.0 and 5.1, but I can do without the excitement of running those releases at web-scale.

I first wrote about this problem in 2013 when comparing MySQL 5.6 to previous releases and filed bugs 68825 and 69236. My favorite low-concurrency performance regression will always be bug 29921. I still remember debugging that over a weekend. Parsers are hard to profile when code is generated and everything is in one function. Fortunately I was able to use rdtsc.

Bugs for low-concurrency performance regressions

Bugs filed by me:
  • 68825 - April 2013 -- performance regressions for single-threaded workloads
  • 69236 - May 2013 -- performance regressions for single-threaded workloads, part 2
  • 74325 - October 2014 (fixed) -- updates to indexed column much slower in 5.7.5
  • 74342 - October 2014 -- InnoDB disk reads at 1 thread much slower in 5.7.5
  • 86215 - May 2017 -- MySQL is much slower in 5.7 than 5.6
Bugs not filed by me:
  • 71130 - December 2013 -- 5.6 SQL thread is much slower than 5.1/5.5
  • 78176 - August 2015 -- 5.6.20 is almost twice as slow as 5.0.96
Finally, there are two interesting bugs for high-concurrency regressions in InnoDB that I want to revisit: bug 74280 (open) and bug 74283 (fixed). I wrote about this in a post on range scan performance.

Content for low-concurrency performance regressions

Reports from me
  • March 2013 - MySQL 5.6: single-threaded, read-only
  • April 2013 - MySQL 5.6: single-thread, update-only
  • May 2013 - MySQL 5.6 versus 4.0 for a read-only workload
  • May 2013 - MySQL 5.6: single-threaded performance regressions
  • September 2013 - MySQL 5.7.2 single threaded performance needs improvement
  • September 2013 - MySQL 4.1 forever
  • October 2014 - Single thread performance in MySQL 5.7.5 versus older releases via sql-bench
  • October 2014 - Low-concurrency performance for point lookups: MySQL 5.7.5 vs previous releases
  • October 2014 - Low-concurrence performance regressions for range queries: MySQL 5.7 vs previous releases
  • October 2014 - Low-concurrency performance for updates and the Heap engine: MySQL 5.7 vs previous releases
  • October 2014 - Low-concurrency performance for updates with InnoDB: MySQL 5.7 vs previous releases
  • October 2014 - Page read performance: MySQL 5.7 vs previous releases
  • October 2014 - Sysbench cached updates: MySQL 5.7 vs previous releases
  • October 2014 - Sysbench IO-bound updates: MySQL 5.7 vs previous releases
  • October 2014 - Updates with secondary index maintenance: 5.7 vs previous releases
  • August, 2015 - Single-threaded linkbench performance for MySQL 5.7, 5.6, WebScale and MyRocks
  • February 2017 - Using modern sysbench to compare MyRocks and InnoDB on a small server
  • February 2017 - Part 2 - sysbench, MyRocks, InnoDB and a small server
  • May 2017 - Sysbench, in-memory & Intel NUC
  • May 2017 - Sysbench, IO-bound & Intel NUC for MySQL 5.6, 5.7 & 8
  • June 2017 - Insert benchmark, in-memory & Intel NUC for MySQL 5.6, 5.7 and 8
  • June 2017 - Insert benchmark, IO-bound & Intel NUC for MySQL 5.6, 5.7 & 8
  • June 2017 - Linkbench, in-memory & Intel NUC for MySQL 5.6, 5.7 & 8
  • June 2017 - Linkbench, IO-bound & Intel NUC for MySQL 5.6, 5.7 & 8
  • June 2017 - Sysbench for MySQL 5.0, 5.1, 5.5, 5.6, 5.7 and 8
  • June 2017 - Impact of perf schema on sysbench at low concurrency
  • June 2017 - MyISAM, small servers and sysbench at low concurrency
  • June 2017 - One more time with sysbench, a small server & MySQL 5.7, 5.7 and 8.0
  • June 2017 - Linux perf and the CPU regression in MySQL 5.7

Reports from others:
  • March 2013 - Why MySQL Performance at Low Concurrency is Important
  • December 2013 - Single thread performance regression in 5.6 - Replication

CPU-bound sysbench on a large server: Postgres 12 to 19 beta1

This has results from sysbench on a small server with Postgres versions 12 through 19 beta1. Sysbench is run with high concurrency (40 conne...