The Curious Engineer

All blogs / Databases

Small Datum

smalldatum.blogspot.com

DatabasesPerformance / optimization

’15’20’25
Posts
794 from 23 Feb 2014 to 20 Jun 2026
Posting
weekly (45 in the last year)
Kind
personal blog
Feed
https://smalldatum.blogspot.com/feeds/posts/default

2026 33

  1. CPU-bound sysbench on a large server: Postgres 12 to 19 beta1
  2. The insert benchmark on a small server, IO-bound workload : Postgres 19 beta1
  3. HammerDB tproc-c on a large server, Postgres 14 to 19 beta1
  4. Write-heavy sysbench tests, a large server, modern Postgres and MySQL
  5. The insert benchmark on a small server, cached workload : Postgres 19 beta1
  6. Postgres 19 beta1 vs sysbench on a small server
  7. MySQL 9.7.0 vs sysbench on a small server
  8. Sysbench vs MySQL on a small server: another way to view the regressions
  9. The Insert Benchmark vs MariaDB 10.2 to 13.0 on a 32-core server
  10. The Insert Benchmark vs MariaDB 10.2 to 13.0 on a 24-core server
  11. Sysbench vs MariaDB on a small server: using the same charset for all versions
  12. CPU-bound sysbench on a large server: Postgres, MySQL and MariaDB
  13. gcc vs clang for sysbench on a small server with Postgres, MySQL and MariaDB
  14. The insert benchmark on a small server : Postgres 12.22 through 18.3
  15. Selecting a character set for MySQL and MariaDB clients
  16. Sysbench vs MySQL on a small server: no new regressions, many old ones
  17. MariaDB innovation: binlog_storage_engine, 32-core server, Insert Benchmark
  18. MariaDB innovation: binlog_storage_engine, 48-core server, Insert Benchmark
  19. CPU efficiency for MariaDB, MySQL and Postgres on TPROC-C with a small server
  20. The first rule of database fight club: admit nothing
  21. MariaDB innovation: vector index performance
  22. Explaining why throughput varies for Postgres with a CPU-bound Insert Benchmark
  23. MariaDB innovation: binlog_storage_engine, small server, Insert Benchmark
  24. MariaDB innovation: binlog_storage_engine
  25. HammerDB tproc-c on a large server, Postgres and MySQL
  26. HammerDB tproc-c on a small server, Postgres and MySQL
  27. CPU-bound Insert Benchmark vs Postgres on 24-core and 32-core servers
  28. IO-bound Insert Benchmark vs MySQL on 24-core and 32-core servers
  29. CPU-bound Insert Benchmark vs MySQL on 24-core and 32-core servers
  30. Debugging regressions with Postgres in IO-bound sysbench
  31. Postgres vs tproc-c on a small server
  32. SSDs, power loss protection and fsync latency
  33. Common prefix skipping, adaptive sort

2025 63

  1. Performance for RocksDB 9.8 through 10.10 on 8-core and 48-core servers
  2. IO-bound sysbench vs Postgres on a 48-core server
  3. IO-bound sysbench vs MySQL on a 48-core server
  4. Performance regressions in MySQL 8.4 and 9.x with sysbench
  5. Sysbench for MySQL 5.6 through 9.5 on a 2-socket, 24-core server
  6. The insert benchmark on a small server : MySQL 5.6 through 9.5
  7. The insert benchmark on a small server : Postgres 12.22 through 18.1
  8. RocksDB performance over time on a small Arm server
  9. Using db_bench to measure RocksDB performance with gcc and clang
  10. Using sysbench to measure how Postgres performance changes over time, November 2025 edition
  11. Using sysbench to measure how MySQL performance changes over time, November 2025 edition
  12. Challenges compiling old C++ code on modern Linux
  13. How efficient is RocksDB for IO-bound, point-query workloads?
  14. Determine how much concurrency to use on a benchmark for small, medium and large servers
  15. Why is RocksDB spending so much time handling page faults?
  16. Is it time for TPC-BLOB?
  17. Postgres 18.0 vs sysbench on a 32-core server
  18. My time at Oracle: functional and design specification reviews
  19. Measuring scaleup for Postgres 18.0 with sysbench
  20. Measuring scaleup for MariaDB with sysbench
  21. Postgres 18.0 vs sysbench on a 24-core, 2-socket server
  22. Postgres 18.0 vs sysbench on a small server
  23. Postgres 18rc1 vs sysbench
  24. Postgres 18 beta3, large server, sysbench
  25. Postgres 18 beta3, small server, sysbench
  26. MySQL 5.6 thru 9.4: small server, Insert Benchmark
  27. Sysbench for MySQL 5.6 thru 9.4 on a small server
  28. Postgres 18 beta2: large server, Insert Benchmark, part 2
  29. Postgres 18 beta2: large server, sysbench
  30. Postgres 18 beta2: large server, Insert Benchmark
  31. Postgres 18 beta1: small server, IO-bound Insert Benchmark (v2)
  32. Postgres 18 beta1: small server, CPU-bound Insert Benchmark (v2)
  33. Postgres 18 beta1: large server, IO-bound Insert Benchmark
  34. Postgres 18 beta1: large server, CPU-bound Insert Benchmark
  35. Postgres 18 beta1: large server, Insert Benchmark, bad configurations
  36. Postgres 18 beta1: small server, IO-bound Insert Benchmark
  37. Postgres 18 beta1: small server, cached Insert Benchmark
  38. Postgres 18 beta1: large server, sysbench
  39. Postgres 18 beta1: small server, sysbench, IO-bound
  40. Postgres 18 beta1: small server, sysbench
  41. RocksDB 10.2 benchmarks: large & small servers with a cached workload
  42. RocksDB 10.2 benchmarks: large server
  43. The impact of innodb_doublewrite_pages in MySQL 8.0.41
  44. Battle of the Mallocators: part 2
  45. Battle of the Mallocators
  46. Postgres 17.4 vs sysbench on a large server, revisited part 2
  47. At what level of concurrency do MySQL 5.7 and 8.0 become faster than 5.6?
  48. Postgres 17.4 vs sysbench on a large server, revisited
  49. Postgres 17.4 vs sysbench on a large server
  50. Feedback from the Postgres community about the vector index benchmarks
  51. How to find Lua scripts for sysbench using LUA_PATH
  52. My database communities
  53. Vector indexes, large server, dbpedia-openai dataset: MariaDB, Qdrant and pgvector
  54. Vector indexes, MariaDB & pgvector, large server, dbpedia-openai dataset
  55. Vector indexes, MariaDB & pgvector, large server, large dataset: part 1
  56. Vector indexes, MariaDB & pgvector, large server, small dataset: part 2
  57. Vector indexes, MariaDB & pgvector, large server, small dataset: part 1
  58. Evaluating vector indexes in MariaDB and pgvector: part 2
  59. Evaluating vector indexes in MariaDB and pgvector: part 1
  60. Sysbench performance over time for InnoDB and MyRocks: part 4
  61. Sysbench performance over time for InnoDB and MyRocks: part 3
  62. Sysbench performance over time for InnoDB and MyRocks: part 2
  63. Sysbench performance over time for InnoDB and MyRocks: part 1

2024 102

  1. Speedb vs RocksDB on a large server
  2. RocksDB on a big server: LRU vs hyperclock, v2
  3. RocksDB benchmarks: large server, universal compaction
  4. Fixing some of the InnoDB scan perf regressions in a MySQL fork
  5. RocksDB benchmarks: large server, leveled compaction
  6. RocksDB on a big server: LRU vs hyperclock
  7. RocksDB benchmarks: small server, universal compaction
  8. Too many performance regressions for InnoDB in MySQL 8.0.29 and 8.0.30
  9. Trying out Advanced MySQL
  10. RocksDB benchmarks: small server, leveled compaction
  11. InnoDB busy-wait loops changed in MySQL 8.0.30
  12. The impact of PGO, LTO and more for MySQL on a small CPU: insert benchmark
  13. MySQL 8.0.40 does not fix the regressions I hoped it would fix
  14. The impact of PGO, LTO and more for MySQL on a small CPU
  15. Sysbench vs c-state on an AMD 4700u
  16. Code bloat vs memory system bloat : why is something getting slower
  17. I recently published results with
  18. Managing CPU frequency for AMD on Ubuntu 22.04
  19. What does "perf stat" tell us about MySQL performance regressions on an AMD Threadripper CPU
  20. What does "perf stat" tell us about MySQL performance regressions on an Intel Xeon CPU
  21. What does "perf stat" tell us about MySQL performance regressions on a Ryzen 7 7735HS CPU
  22. What does "perf stat" tell us about MySQL performance regressions on a Ryzen 7 4700u CPU
  23. How to run MySQL with text in huge pages
  24. InnoDB code bloat in MySQL 8.0 makes me sad
  25. Configuration options that make writes faster or slower with MySQL and Postgres
  26. The size of the mysqld binary as a proxy for innovation
  27. Why do table scans get slower with MySQL from 5.6 to 8.0?
  28. Ubuntu 22.04, Linux kernels and me
  29. MySQL and Postgres vs the Insert Benchmark on a large server
  30. HTAP benchmarks: trying out HATrick with MySQL
  31. MySQL + InnoDB vs sysbench on a large server
  32. InnoDB, compiler options and sysbench
  33. Postgres 17rc1 vs sysbench on small & large servers: looking great
  34. RocksDB benchmarks: cached database
  35. Postgres 17beta3 vs sysbench on a large server: looking great
  36. Trying out a dedicated server from Hetzner
  37. Postgres 17beta3 vs the Insert Benchmark on a medium server: looking good
  38. Postgres 17beta3 vs sysbench on a small server: looking good
  39. Postgres 17beta3 vs sysbench on a medium server: looking good
  40. MySQL regressions: delete vs InnoDB
  41. MySQL regressions: update-nonindex vs InnoDB
  42. MySQL regressions: skip_concurrency_ticket
  43. MySQL regressions: binlog_log_row
  44. Sysbench on a medium server: MariaDB is faster than MySQL
  45. Searching for regressions in RocksDB with db_bench: part 2
  46. MyRocks vs InnoDB on cached sysbench: revised
  47. MySQL 8.0.38 vs cached Sysbench on a medium server
  48. Searching for regressions in RocksDB with db_bench
  49. Make MyRocks 2X faster by changing the CPU frequency governor
  50. MySQL 8.0.38 vs the Insert Benchmark on a medium server
  51. Postgres 17beta2 vs the Insert Benchmark on a medium server:: looking good
  52. MyRocks vs InnoDB on cached sysbench
  53. Postgres 17beta2 vs sysbench: looking good
  54. The journey to explain performance regressions in MySQL
  55. The impact of PGO for MySQL
  56. The impact of link time optimization for MySQL with sysbench
  57. A simple test to measure CPU per IO
  58. The Insert Benchmark: Postgres 17beta1, large server, IO-bound
  59. Stalls from TRIM after deleting a lot of data
  60. The Insert Benchmark vs MyRocks and InnoDB, small server, IO-bound database
  61. The Insert Benchmark vs MyRocks and InnoDB, small server, cached database
  62. MyRocks and InnoDB vs sysbench on a small server
  63. The Insert Benchmark, Postgres 17beta1, a large server and cached database
  64. Postgres 17beta1 vs sysbench on a large server
  65. Postgres 17beta1 vs sysbench on a small server
  66. Does disabling full_page_writes reduce variance for Postgres with a cached Insert Benchmark
  67. The Insert Benchmark, Postgres 17beta1, a small server and cached database
  68. Sysbench on a new small server: MariaDB vs MySQL
  69. Space vs CPU tradeoffs with universal compaction in RocksDB
  70. The Insert Benchmark: MariaDB, MySQL, new small server, cached workload, some concurrency
  71. The Insert Benchmark: MariaDB, MySQL, small server, cached workload, some concurrency
  72. Changes to managing turbo boost in Ubuntu 22.04 and Linux 6.5
  73. The Insert Benchmark: MariaDB, MySQL, small server, cached workload
  74. Sysbench on a (less) small server: MariaDB and MySQL
  75. Sysbench on a small server: MariaDB and MySQL
  76. Comparing Postgres and MySQL on the insert benchmark with a small server
  77. Yet another Insert Benchmark result: MyRocks, MySQL and a small server
  78. Yet another Insert Benchmark result: MySQL, InnoDB and a small server
  79. Trying to tune Postgres for the Insert Benchmark: small server
  80. Perf regressions in Postgres from 9.0 to 16 with sysbench and a small server
  81. Perf regressions in MySQL from 5.6.21 to 8.0.36 using sysbench and a small server
  82. It wasn't a performance regression in Postgres 14
  83. Updated Insert benchmark: InnoDB/MySQL 5.6, 5.7 and 8.0, small server, IO-bound database
  84. Updated Insert benchmark: Postgres 9.x to 16.x, large server, cached database
  85. Explaining a performance regression in Postgres 14
  86. Updated Insert benchmark: Postgres 9.x to 16.x, small server, IO-bound database
  87. Updated Insert benchmark: InnoDB/MySQL 5.6, 5.7 and 8.0, small server, cached database
  88. Updated Insert benchmark: Postgres 9.x to 16.x, small server, cached database, v3
  89. Updated Insert benchmark: MyRocks 5.6 and 8.0, medium server, IO-bound database, v2
  90. Updated Insert benchmark: MyRocks 5.6 and 8.0, small(est) server, cached database, v2
  91. Updated Insert benchmark: MyRocks 5.6 and 8.0, small server, cached database, v2
  92. Updated Insert benchmark: MyRocks 5.6 and 8.0, medium server, cached database, v2
  93. Updated Insert benchmark: Postgres 9.x to 16.x, small server, cached database, v2
  94. Explaining changes in RocksDB performance for IO-bound workloads
  95. RocksDB 8.x benchmarks: large server, IO-bound
  96. innodb_log_writer_threads and the Insert Benchmark
  97. Updated Insert benchmark: MyRocks 5.6 and 8.0, small server, cached database
  98. Updated Insert benchmark: Postgres 9.x to 16.x, small server, cached database
  99. Updated Insert benchmark: MyRocks 5.6 and 8.0, medium/large server, cached database
  100. Updated Insert benchmark: MyRocks 5.6 and 8.0, medium server, cached database
  101. Updated Insert benchmark: InnoDB, MySQL 5.6 to 8.0, medium server, cached database
  102. Updated Insert benchmark: MyRocks 5.6 and 8.0, large server, cached database

2023 130

  1. Updated Insert benchmark: InnoDB, MySQL 5.6 to 8.0, large server, cached database
  2. Updates for the Insert Benchmark, December 2023
  3. RocksDB 8.x benchmarks: large server, cached database
  4. Create InnoDB indexes 2X faster with this simple trick
  5. What is the cost of the performance schema in MySQL 5.7 and 8.0: small server, cached database, simple queries
  6. Perf regressions in MySQL from 5.6 to 8.0 using the Insert Benchmark and a small server, Dec23: part 1
  7. Explaining changes in MySQL performance via hardware perf counters: part 4
  8. Explaining changes in MySQL performance via hardware perf counters: part 3
  9. Explaining changes in MySQL performance via hardware perf counters: part 2
  10. Explaining changes in MySQL performance via hardware perf counters: part 1
  11. Checking RocksDB 8.x for performance regressions on a large server, part 2
  12. Perf regressions in MySQL from 5.6.21 to 8.0.34 using the Insert Benchmark and a medium server, part 1
  13. Fixing bug 109595 makes MySQL almost 4X faster on the Insert Benchmark
  14. Checking RocksDB 4.x thru 8.x for performance regressions on a small server: IO-bound with O_DIRECT
  15. Checking RocksDB 4.x thru 8.x for performance regressions on a small server: IO-bound with buffered IO
  16. Checking RocksDB 4.x thru 8.x for performance regressions on a small server: cached workload
  17. Debugging perf changes in RocksDB 8.6 on a small server
  18. Postgres vs MySQL: the impact of CPU overhead on performance
  19. Perf regressions in MySQL from 5.6.21 to 8.0.35 using sysbench and a medium server, part 5
  20. Perf regressions in MySQL from 5.6.21 to 8.0.35 using sysbench and a medium server, part 4
  21. Perf regressions in MySQL from 5.6.21 to 8.0.35 using sysbench and a medium server, part 3
  22. Perf regressions in MySQL from 5.6.21 to 8.0.35 using sysbench and a medium server, part 2
  23. Perf regressions in MySQL from 5.6.21 to 8.0.35 using sysbench and a medium server, part 1
  24. Perf regressions for MySQL/InnoDB vs the Insert Benchmark: 8.0.28 to 8.0.30
  25. Checking RocksDB 7.x and 8.x for performance regressions on a large server
  26. Variance in RocksDB benchmarks
  27. Perf regressions in MySQL from 5.6.21 to 8.0.34 using the Insert Benchmark and a small server, part 2
  28. Variance in peak RSS with jemalloc 5.2.1, part 2
  29. Postgres versions 11, 12, 13, 14, 15, and 16 vs sysbench with a medium server
  30. Trying out OrioleDB
  31. Checking MyRocks 5.6 for regressions with the Insert Benchmark and a large server, revisited
  32. Checking Postgres for perf regressions from 11.21 to 16.0 with sysbench and a small server
  33. Variance in peak RSS with jemalloc 5.2.1
  34. Postgres 16.0, sysbench and a medium server
  35. Postgres 16.0, sysbench and a small server
  36. Hello world!
  37. Perf regressions in MySQL from 5.6.21 to 8.0.34 using the Insert Benchmark and a small server
  38. Postgres 16.0 vs the Insert Benchmark on a medium server
  39. Postgres 16.0 vs the Insert Benchmark on a small server
  40. Perf regressions in MySQL from 5.6.21 to 8.0.34 using sysbench and a small server
  41. Checking jemalloc versions for RSS regressions with MyRocks and the Insert Benchmark
  42. Chasing a performance regression in MyRocks vs the Insert Benchmark
  43. Postgres 16, sysbench and a small server
  44. RocksDB and glibc malloc don't play nice together
  45. Postgres 16 beta3 and the Insert Benchmark on a small server
  46. Checking MyRocks 5.6 for regressions with the Insert Benchmark and a large server
  47. Checking MyRocks 5.6 for regressions with sysbench and a small server, part 2
  48. The impact from hyperthreading for RocksDB db_bench on a medium server
  49. Checking MyRocks 5.6 for regressions with sysbench and a medium server, part 3
  50. Checking MyRocks 5.6 for regressions with the Insert Benchmark and a small server, part 2
  51. Checking MyRocks 5.6 for regressions with the Insert Benchmark and a medium server, part 2
  52. Tuning Postgres 15.2 and 15.3 for the Insert Benchmark on a small server
  53. Postgres 16 beta3 and the Insert Benchmark on a medium server
  54. Compiling all MySQL 5.7 versions on modern Ubuntu
  55. Tuning MyRocks to reduce MVCC GC debt
  56. InnoDB vs the Insert Benchmark on a medium server, includes Percona Server
  57. Tuning InnoDB for the Insert Benchmark on a small server
  58. One path for an open source database project
  59. Checking MyRocks 5.6 for regressions with the Insert Benchmark and a medium server
  60. Tuning Postgres and the Insert Benchmark, round 6
  61. Checking MyRocks 5.6 for regressions with the Insert Benchmark and a small server
  62. Tuning InnoDB for the Insert Benchmark on a large server
  63. Tuning MyRocks for the Insert Benchmark on a large server
  64. Tuning MyRocks for the Insert Benchmark on a small server
  65. How do you limit MVCC GC debt?
  66. Insert benchmark perf over time for MyRocks 5.6 on a large server
  67. MyRocks, InnoDB and Postgres as a queue
  68. Tuning InnoDB for the insert benchmark on a medium server, part 2
  69. my.cnf options that influence create index performance
  70. Keeping up with the SQL DBMS market
  71. Insert+delete benchmark, medium server and MyRocks, part 2
  72. Tuning Postgres and the new insert benchmark on a small server, part 2
  73. Tuning Postgres and the new insert benchmark, round 5
  74. Write stalls with RocksDB from a too small block cache and/or too many block cache shards
  75. innodb_page_cleaners, part 2: big server, database not cached
  76. Fun with innodb_page_cleaners
  77. Dynamic leveled compaction in RocksDB
  78. Insert+delete benchmark, medium server and MyRocks
  79. Universal Compaction in RocksDB and me
  80. Tuning Postgres and the new insert benchmark, round 4
  81. Tuning Postgres and the new insert benchmark on a small server
  82. Tuning InnoDB for the insert benchmark on a medium server
  83. Insert+delete benchmark: small server, MyRocks and IO-bound
  84. Create index, MyRocks and memory
  85. Tuning Postgres and the new insert benchmark, round 3
  86. Tuning Postgres and the new insert benchmark, round 2
  87. Insert+delete benchmark, small server and MyRocks
  88. Updates to the insert benchmark
  89. Postgres 16beta1 looks good vs sysbench
  90. Tuning Postgres and the new insert benchmark
  91. Compiling all releases of MySQL 8.0
  92. Summary of another round of benchmarks
  93. The Insert Benchmark, MySQL 5.6, 5.7, 8.0 and a small server
  94. Understanding the insert benchmark results: variance and write stalls
  95. The Insert Benchmark, MySQL 5.6, 5.7, 8.0 and a big server
  96. The insert benchmark, Postgres versions 11 to 15, a big server
  97. The insert benchmark, Postgres versions 11 to 15, a small server
  98. Time to compile Postgres, MySQL and MyRocks
  99. Perf regressions in MySQL/InnoDB, a big server & sysbench, part 2
  100. Perf regressions in MySQL/InnoDB, a big server & sysbench
  101. Revisiting perf regressions in Postgres, a larger server and sysbench, part 2
  102. Revisiting perf regressions in Postgres, a larger server and sysbench
  103. Perf regressions in MyRocks with the insert benchmark
  104. The case of the missing NVMe device
  105. GC for MVCC - MyRocks, InnoDB and Postgres
  106. MyRocks vs InnoDB with sysbench
  107. Impact of writes on read performance
  108. Perf regressions in MyRocks, a larger server and sysbench
  109. Perf regressions in MyRocks, a small server & sysbench
  110. Perf regressions in MySQL/InnoDB, a small server & sysbench
  111. Perf regressions in Postgres, a larger server and sysbench
  112. Searching for performance regressions in Postgres
  113. How I run sysbench
  114. Huge pages with Postgres & InnoDB: better perf, but a bit more work
  115. Compiler optimizations, MyRocks and a small server
  116. Adventures in compiling MySQL: RelWithDebInfo vs Release
  117. Can RocksDB use all of the IOPs from fast storage?
  118. Sysbench, Arm & x86, public cloud
  119. I'd prefer not to update firmware for Samsung SSD on Linux
  120. CMAKE_BUILD_TYPE: RelWithDebInfo vs Release for MySQL
  121. Adventures in compiling MySQL
  122. Sysbench with huge pages for Postgres & InnoDB
  123. The value of the InnoDB change buffer
  124. RocksDB microbenchmarks: compilers, Arm and x86
  125. Statistical rigor and database benchmarks
  126. The insert benchmark on ARM and x86 cloud servers
  127. clang, gcc & compiler flags vs the insert benchmark & ARM
  128. Insert benchmark on an 8-core AMD server
  129. RocksDB microbenchmarks: crc32c, xxh3 and lz4 uncompress
  130. Variance in RocksDB benchmarks on cloud HW

2022 46

  1. Benchmark(et)ing RocksDB vs SplinterDB
  2. Compiling MySQL 5.6 & 5.7 on Ubuntu 22.04
  3. Insert benchmark: Postgres, InnoDB and MyRocks with low concurrency
  4. SSD read response time: raw device vs a filesystem
  5. s/optimal/better/g - on reviewing conference papers
  6. Quantifying storage on Linux
  7. Small servers for performance testing, v4
  8. Early lock release and InnoDB
  9. Hyping the hyper clock cache in RocksDB
  10. Reasons for writeback with an update-in-place B-Tree
  11. Magma, a new storage engine for Couchbase
  12. Storage engines, efficiency and large documents, rows, objects
  13. Understanding some jemalloc stats for RocksDB
  14. Configuring the RocksDB block cache
  15. How to ask questions
  16. Using SPIN to validate the InnoDB read-write lock
  17. How I do RocksDB performance tests, part 2
  18. When is a secondary index-only query not index-only for InnoDB and Postgres?
  19. How I do performance tests for RocksDB
  20. The impact of max_background_threads, part 2
  21. The impact of max_background_jobs on write throughput for RocksDB
  22. Setting up a server on GCP
  23. Fixing mmap performance for RocksDB
  24. Insert Benchmark for Postgres 12, 13, 14 and 15: part 2
  25. Insert Benchmark for Postgres 12, 13, 14 and 15
  26. The benefit of lz4 and zstd for Postgres WAL compression
  27. Defining "X has too many options"
  28. RocksDB internals: LRU
  29. Performance bugs: p50 vs p99
  30. Using mmap with RocksDB
  31. To compress or not compress
  32. clang vs crc32c in RocksDB
  33. Becoming less confused about perf record
  34. Examples of the RocksDB trivial move optimization
  35. One problem with flamegraphs
  36. The db_bench mixgraph benchmark
  37. RocksDB externals: avoiding problems with db_bench --seed
  38. RocksDB externals: the series
  39. RocksDB internals: trivial move and benchmarks
  40. RocksDB internals: trivial move
  41. RocksDB internals: the series
  42. RocksDB internals: prefetch and/or readahead
  43. RocksDB internals: write rate limiter
  44. RocksDB internals: compaction stall counters
  45. RocksDB internals: intra-L0 compaction
  46. RocksDB internals: bytes pending compaction

2021 36

  1. Summarizing the different implementations of tiered compaction
  2. Sysbench: MySQL 5.6, 5.7 & 8.0 on a small server
  3. Sysbench: PostgreSQL 12, 13 and 14 on a small server
  4. Insert benchmark: MySQL 5.6, 5.7 & 8.0 on a small server
  5. Insert benchmark: PostgreSQL 12, 13 and 14 on a small server
  6. Welll actually, LSM and B-tree
  7. DeWitt Clause vs the public cloud
  8. Compatible with MySQL or Postgres?
  9. The other way to compress InnoDB: outsource it
  10. Automating memory management in a DBMS
  11. Developer experience, what about the other stakeholders?
  12. Review of DiffKV
  13. Happy 15th to Percona
  14. On storage engines
  15. Sequential IO and an LSM tree
  16. How to submit a PR for RocksDB
  17. More on read-only benchmarks and an LSM
  18. Read-only benchmarks with an LSM are complicated
  19. Still not finding CPU regressions in RocksDB
  20. Not finding CPU regressions across RocksDB releases
  21. Summary of my search for regressions with MySQL & Postgres
  22. Sysbench: MySQL vs Postgres for an IO-bound workload
  23. Sysbench: IO-bound and InnoDB
  24. Sysbench: IO-bound and Postgres
  25. Sysbench: in-memory scans for MyRocks, InnoDB and Postgres
  26. Sysbench: IO-bound and MyRocks
  27. Insert Benchmark: InnoDB
  28. Insert Benchmark: Postgres is still boring
  29. Insert benchmark: MyRocks
  30. T is for Tuning amplification
  31. Sysbench: Postgres vs MySQL and the impact of regressions
  32. Sysbench: in-memory Postgres, Postgres is boring
  33. Sysbench: in-memory InnoDB, MySQL 5.6, 5.7 & 8.0, take 3
  34. Sysbench: in-memory MyRocks, MySQL 5.6 & 8.0, take 3
  35. Sysbench: in-memory MyRocks, MySQL 5.6 & 8.0, take 2
  36. Sysbench: in-memory InnoDB, MySQL 5.6 & 8.0, take 2

2020 60

  1. Sysbench: IO-bound InnoDB in MySQL 5.6, 5.7 and 8.0
  2. Sysbench: in-memory InnoDB in MySQL 5.6, 5.7 and 8.0
  3. Sysbench: IO-bound MyRocks in 5.6 vs 8.0
  4. Sysbench: MyRocks in MySQL 5.6 vs 8.0
  5. Tuning for the Insert Benchmark: Postgres, InnoDB & MyRocks
  6. Tuning for the Insert Benchmark: MyRocks
  7. Tuning for the Insert Benchmark: Postgres
  8. Tuning for the Insert Benchmark: InnoDB
  9. Blind-writes and an LSM
  10. Max row per group, sad answers only
  11. InnoDB, fsync and fdatasync - reducing commit latency
  12. Overloading the meaning of "copy-on-write" for index structures
  13. LSM local secondary indexes (LSM LSI)
  14. Self-aware DBMS, RID-lists for LSM trees
  15. MyRocks in MySQL 5.6 and 8.0
  16. Better vs optimal
  17. Comments on: The Unwritten Contract of Solid State Drives
  18. MySQL 8 is greater with MyRocks
  19. Comments on: Optimizing Databases by Learning Hidden Parameters of Solid State Drives
  20. Performance results and DBMS experts
  21. When is it OK to lose a commit?
  22. iostat output format changes again
  23. Review of PrismDB: Read-aware LSM Tree for Heterogeneous Storage
  24. Over fetching in a DBMS
  25. Sustaining high insert rates despite secondary indexes
  26. Postgres, vacuum and the insert benchmark
  27. Review of -- TimescaleDB: SQL made scalable for time-series data
  28. Indexing and write-heavy workloads
  29. Review: The Design of the Postgres Storage System
  30. Updates for the insert benchmark
  31. Something changed for the better in create index between MySQL 8.0.18 and 8.0.20
  32. Java GC and Linkbench
  33. Avoiding reads in write-optimized index structures
  34. Reviving mstat
  35. Creating performance reports
  36. Compiling from source for Amazon Linux 2
  37. kernel lockdown vs blktrace
  38. Insert Benchmark v3
  39. Tuning space and write amplification to minimize cost
  40. Review of Benchmarking RocksDB Key-Value Workloads at Facebook
  41. Building MySQL 5.6 from source on Ubuntu 18.04
  42. RDBMS != SQL DBMS
  43. New school vs old school DBMS
  44. Describing replication
  45. Benchmarks vs real workloads
  46. Short guide to MongoDB monitoring
  47. How long should you wait for a JVM JIT before attaching a CPU profiler?
  48. Websites that report your browsing to Facebook
  49. Podcasts I love
  50. Durability vs Availability
  51. Copyleft vs the DeWitt Clause
  52. Aggregate PMP call stacks for one thread
  53. Deletes are fast and slow in an LSM
  54. Comparative benchmarks and a question about describing data
  55. PMP for on-cpu profiling?
  56. The slow perf movement
  57. Setting up Ubuntu 18.04 server on an Intel NUC
  58. 480p is my friend - video streaming when you don't have fiber
  59. It is all about the constant factors
  60. From disk to flashcache to flash

2019 62

  1. What is the future of off-cpu analysis?
  2. Readahead
  3. Slides for talks I have given on MySQL, MongoDB and RocksDB
  4. Historical - summary of the Google MySQL effort
  5. Historical - InnoDB IO Performance
  6. Historical - Patch for MySQL 5.0
  7. Historical - Make User Delayed
  8. Historical - Adding Roles to MySQL
  9. Historical - changes to my.cnf
  10. Historical - SHOW INNODB STATUS
  11. Historical - SHOW STATUS changes
  12. Historical - design doc for semisync replication
  13. Historical - SemiSync replication
  14. Historical - SQL changes for MySQL
  15. Historical - Transactional Replication
  16. Historical - UserTable Monitoring
  17. Historical - InnoDB SMP performance
  18. Fixing the InnoDB RW-lock
  19. Still web scale
  20. iostat output changes in Ubuntu 18.04
  21. Throttling writes: LSM vs B-Tree
  22. The delta+main index structure
  23. Always be upgrading
  24. My theory on technical debt and OSS
  25. The joy of database configuration
  26. Using an LSM for analytics
  27. Linux syscall performance regressions explained
  28. Jungle - LSM plus copy-on-write B-Tree
  29. Revisiting Kudu
  30. Fun setting up Ubuntu on Win 10 Home
  31. USL, universal scalability law, is good to know
  32. Review of "5 Minute rule - thirty years later"
  33. Nitpicking papers in the LSM space
  34. Tuning space and write amplification to minimize cost
  35. Write vs space amplification for an LSM and index+log
  36. A review of uDepot - keeping up with fast storage
  37. How many storage devices does a workload require?
  38. Just put the cold data over there
  39. Learned indexes for an LSM?
  40. Reducing write and space amplification in a b-tree
  41. Review of Spanner: Becoming a SQL System
  42. Optimal Tuning for an LSM
  43. FoundationDB Record Layer
  44. Vinyl - the LSM in Tarantool
  45. Adapting TPC-C for MongoDB - reviewing a VLDB paper
  46. Tunable Consistency in MongoDB - reviewing a VLDB paper
  47. InnoDB repeatable read in a nutshell
  48. Open Core Summit and OSS glue code
  49. Interesting indexing in Rockset and MongoDB
  50. index+log: implementations
  51. index+log: open issues
  52. Index+log, v2
  53. CRUM conjecture - read, write, space and cache amplification
  54. A research paper on Optane performance
  55. Less "mark" in MySQL benchmarking
  56. Optimal configurations for an LSM and more
  57. Bugs in Windows 10 parental controls
  58. Geek code for LSM trees
  59. LSM math: fixing mistakes in my last post
  60. LSM math: revisiting the number of levels that minimizes write amplification
  61. Define "better"
  62. Review of LSM-based Storage Techniques: A Survey

2018 36

  1. New small servers for performance testing
  2. LSM math - size of search space for LSM tree configuration
  3. LSM math - how many levels minimizes write amplification?
  4. Pixelbook review
  5. Review of TRIAD: Creating Synergies Between Memory, Disk and Log in Log Structured Key-Value Stores
  6. Converting an LSM to a B-Tree and back again
  7. Combining tiered and leveled compaction
  8. Minimizing write amplification in an LSM
  9. Describing tiered and leveled compaction
  10. Transaction Processing in NewSQL
  11. Durability debt
  12. Bloom filter and cuckoo filter
  13. Review of SlimDB from VLDB 2018
  14. 5 things to set when configuring RocksDB and MyRocks
  15. Name that compaction algorithm
  16. Review of "Concurrent Log-Structured Memory" from VLDB 2018.
  17. Default configuration benchmarks
  18. Lock elision, pthreads and MySQL
  19. Fast shutdown, fast startup
  20. Tiered or leveled compaction, why not both via adaptive compaction?
  21. Default options in MyRocks
  22. Index+log - an alternative to LSM
  23. CPU overheads for RocksDB queries
  24. The original LSM paper
  25. Geek code for database algorithms
  26. Where to ask questions about MyRocks and RocksDB
  27. MyRocks, malloc and fragmentation -- a strong case for jemalloc
  28. Fun with caching_sha2_password in MySQL 8.0.11
  29. Index Structures, Access Methods, whatever
  30. Missing documentation
  31. Cache amplification
  32. Sharded replica sets - MySQL and MongoDB
  33. Meltdown vs storage
  34. Meltdown vs MySQL part 2: in-memory sysbench and a core i5 NUC
  35. XFS, nobarrier and the 4.13 Linux kernel
  36. Meltdown vs MySQL part 1: in-memory sysbench and a core i3 NUC

2017 84

  1. MyRocks and InnoDB: a summary
  2. Sysbench: IO-bound and a fast server, part 2
  3. Sysbench: IO-bound and a fast server
  4. Sysbench: in-memory and a fast server, part 2
  5. Sysbench: in-memory and a fast server
  6. Insert benchmark: IO-bound, high-concurrency, fast server, part 2
  7. Insert benchmark: IO-bound, high-concurrency, fast server
  8. Insert benchmark: in-memory, high-concurrency, fast server - part 2
  9. Insert benchmark: in-memory, high-concurrency, fast server
  10. Insert benchmark: in-memory, low-concurrency, fast server
  11. tpcc-mysql, IO-bound, high-concurrency: MyRocks, InnoDB and TokuDB
  12. Linkbench: IO-bound, small server, MyRocks and InnoDB
  13. Linkbench: in-memory, small server, MyRocks and InnoDB
  14. tpcc-mysql, in-memory, low-concurrency: MyRocks and InnoDB
  15. IO-bound linkbench and a fast server: MyRocks, InnoDB and TokuDB
  16. In-memory linkbench and a fast server: MyRocks, InnoDB and TokuDB
  17. Sysbench, IO-bound, small server: MyRocks and InnoDB
  18. Marketing and the Dunning-Kruger effect
  19. Sysbench, IO-bound, small server: MyRocks over time
  20. Concurrent large allocations: glibc malloc, jemalloc and tcmalloc
  21. Sysbench: IO-bound, InnoDB, a small server, MySQL 5.0 to 8.0
  22. A new optimization in gcc 5.x and MySQL
  23. Sysbench, in-memory, small server: MyRocks over time
  24. Sysbench, in-memory, small server: InnoDB & MyRocks
  25. Sysbench: in-memory, InnoDB and a small server, MySQL 5.0 to 8.0
  26. Sysbench: in-memory, MyISAM and a small server, MySQL 5.0 to 8.0
  27. Advice on advice
  28. IO-bound insert benchmark for InnoDB on a small server: MySQL 5.0 to 8.0
  29. In-memory insert benchmark for InnoDB on a small server: MySQL 5.0 to 8.0
  30. Questions I have about workloads with high write rates
  31. Insert benchmark for MyISAM from MySQL 5.0 to 8.0
  32. Insert benchmark, IO-bound, Intel NUC: MyRocks vs InnoDB
  33. Insert benchmark, in-memory, Intel NUC: MyRocks vs InnoDB
  34. Wearing out an SSD
  35. Linkbench: IO-bound, large server
  36. Making it easier to read Linux perf output
  37. Linkbench - in-memory, low-concurrency
  38. IO-bound table scan performance for MyRocks, InnoDB and TokuDB
  39. Timing load & index for sysbench tables
  40. Write-heavy workloads with MyRocks
  41. In-memory sysbench and a small server
  42. In-memory sysbench, a larger server and contention - part 2
  43. All things RocksDB at Percona Live Europe 2017
  44. In-memory sysbench, a larger server and contention - part 1
  45. How to build MongoRocks for MongoDB 3.4
  46. In-memory sysbench and a large server
  47. IO-bound sysbench on a smaller server
  48. Sysbench, a large server and fast SSD vs MyRocks, InnoDB and TokuDB: part 2
  49. Sysbench, a large server and fast SSD vs MyRocks, InnoDB and TokuDB
  50. MyRocks my.cnf changes from June 16 to Aug 15
  51. I overstated the CPU regression in MySQL 5.7
  52. One more time with sysbench, a small server & MySQL 5.6, 5.7 and 8.0
  53. MyISAM, small servers and sysbench at low concurrency
  54. Linux perf and the CPU regression in MySQL 5.7
  55. Impact of perf schema on sysbench at low concurrency
  56. Sysbench for MySQL 5.0, 5.1, 5.5, 5.6, 5.7 and 8
  57. Linkbench, IO-bound & Intel NUC for MySQL 5.6, 5.7 & 8
  58. Summary of recent performance tests for MySQL 5.6, 5.7 and 8
  59. Linkbench, in-memory & Intel NUC for MySQL 5.6, 5.7 & 8
  60. All about Linkbench
  61. Insert benchmark, IO-bound & Intel NUC for MySQL 5.6, 5.7 & 8
  62. Insert benchmark, in-memory & Intel NUC for MySQL 5.6, 5.7 and 8
  63. The Insert Benchmark
  64. Sysbench, IO-bound & Intel NUC for MySQL 5.6, 5.7 & 8
  65. Sysbench, in-memory & Intel NUC
  66. Short guide on using performance_schema for user & table stats
  67. The history of low-concurrency performance regressions in MySQL 5.6, 5.7 and 5.8
  68. MyRocks in MariaDB 10.2.6
  69. Small servers for database performance tests
  70. Database IO performance tests
  71. InnoDB, MyRocks and TokuDB on the insert benchmark
  72. Benchmark(et)ing with InnoDB redo log size
  73. How to build MongoRocks for MongoDB 3.4
  74. Part 5: sysbench, a larger server, and IO-bound database and really fast storage
  75. Part 4: sysbench, a large server and small database
  76. Part 3: sysbench, a large server and small database
  77. Part 2 - sysbench, MyRocks, InnoDB and a small server
  78. Using modern sysbench to compare MyRocks and InnoDB on a small server
  79. MyRocks, InnoDB and in-memory insert performance
  80. Why MyRocks?
  81. Compaction stalls: something to make better in RocksDB
  82. The value of write efficiency for the insert benchmark
  83. Insert benchmark, MyRocks and InnoDB
  84. MyRocks, MongoRocks and RocksDB at Percona Live 2017

2016 36

  1. The MyRocks community in 2016
  2. MyRocks: use less IO on writes to have more IO for reads
  3. Why is MyRocks more write-efficient than InnoDB?
  4. Sysbench, InnoDB, transaction isolation and the performance schema
  5. Benchmarketing MyRocks
  6. Make MyRocks 2X less slow
  7. scons verbose command line
  8. MongoRocks and WiredTiger versus linkbench on a small server
  9. Making the case for MyRocks. It is all about efficiency.
  10. MyRocks, MongoRocks, RocksDB and Mr. Mime
  11. MyRocks and InnoDB with large objects and compression
  12. Peak benchmarketing season for MySQL
  13. Excited about Percona Live Amsterdam
  14. zlib vs zstd for MyRocks running Linkbench
  15. Tuning the RocksDB block cache
  16. Web-scale MySQL back in the day
  17. RocksDB, InnoDB and the insert benchmark
  18. smartctl and Samsung 850 EVO
  19. Fun with scons while building MongoDB from source
  20. TRIM, iostat and Linux
  21. Using jemalloc heap profiling with MySQL
  22. MyRocks and sql-bench
  23. Concurrent transaction performance in RocksDB
  24. Less slow versus faster
  25. RocksDB, InnoDB and TokuDB vs sysbench
  26. RocksDB vs the world for loading Linkbench tables
  27. Compaction priority in RocksDB
  28. Concurrent inserts and the RocksDB memtable
  29. MyRocks vs InnoDB with Linkbench over 7 days
  30. How to build MongoRocks for MongoDB 3.2
  31. MyRocks vs InnoDB, the insert benchmark and a disk array
  32. The advantages of an LSM vs a B-Tree
  33. MyRocks vs InnoDB via Linkbench with a disk array
  34. Faster loads for MyRocks
  35. Even more write amplification when InnoDB meets flash GC
  36. RocksDB vs InnoDB via Linkbench : performance and efficiency

2015 51

  1. IO-bound linkbench for MongoDB 3.2
  2. Read, write & space amplification - B-Tree vs LSM
  3. Read, write & space amplification - pick 2
  4. How does MongoDB do on Linkbench with concurrency?
  5. Define better for a small-data DBMS
  6. MongoDB 3.2 vs Linkbench
  7. Losing it?
  8. Problems not worth fixing
  9. MyRocks versus allocators: glibc, tcmalloc, jemalloc
  10. Wanted: a file system on which InnoDB transparent page compression works
  11. Third day with InnoDB transparent page compression
  12. Linkbench for MySQL 5.7.8 with an IO-bound database
  13. Second day with InnoDB transparent page compression
  14. Cached linkbench performance for MySQL 5.7.8, 5.6, WebScale and MyRocks
  15. First day with InnoDB transparent page compression
  16. Single-threaded linkbench performance for MySQL 5.7, 5.6, WebScale and MyRocks
  17. How to use iTunes family sharing
  18. Transactions with RocksDB
  19. Reducing write amplification in MongoRocks
  20. Insert benchmark and queries on slow storage for MongoDB
  21. Different kinds of copy-on-write for a b-tree: CoW-R, CoW-S
  22. Insert benchmark & queries for MongoDB on fast storage
  23. Reducing the overhead of secondary index maintenance with write-optimized database engine
  24. Write-heavy workload vs the MongoDB optimizer
  25. Linkbench, MongoDB and a disk array, now with TokuMX
  26. Performance impact from too-small RAID stripes
  27. Summary of Linkbench for MongoDB & MySQL
  28. Linkbench, MongoDB and a disk array
  29. Linkbench for MySQL and MongoDB with a large database
  30. WiredTiger improvements from MongoDB 3.0 to 3.1
  31. The impact of long-running transactions on Linkbench QPS: InnoDB vs RocksDB
  32. LinkBenchX and MongoDB on a small server
  33. Linkbench for MySQL & MongoDB with a cached database
  34. Examining performance for MongoDB and the insert benchmark
  35. Insert benchmark for MongoDB, memory allocators and the oplog
  36. RocksDB & ForestDB via the ForestDB benchmark: cached database
  37. RocksDB & ForestDB via the ForestDB benchmark: IO-bound and SSD
  38. RocksDB & ForestDB via the ForestDB benchmark: IO-bound and disks
  39. RocksDB & ForestDB via the ForestDB benchmark, part 1
  40. Comparing LevelDB and RocksDB, take 2
  41. Much ado about nothing
  42. Big numbers for web scale MySQL
  43. How to win at IO-bound benchmarks
  44. Capacity planning and QPS
  45. Compared to what?
  46. Fast index create
  47. A few possibly true facts about indexes in MongoDB, RocksDB and WiredTiger
  48. Formal methods in the real world
  49. Helping make MySQL better
  50. Storage efficiency
  51. I don't get marketing

2014 55

  1. malloc and MongoDB performance
  2. Storage overhead for attribute names in MongoDB
  3. Read-modify-write optimized
  4. Aurora for MySQL is coming
  5. Updates with secondary index maintenance: 5.7 vs previous releases
  6. Sysbench IO-bound updates: MySQL 5.7 vs previous releases
  7. Sysbench cached updates: MySQL 5.7 vs previous releases
  8. Page read performance: MySQL 5.7 vs previous releases
  9. Low-concurrency performance for updates with InnoDB: MySQL 5.7 vs previous releases
  10. Low-concurrency performance for updates and the Heap engine: MySQL 5.7 vs previous releases
  11. Details on range scan performance regression in MySQL 5.7
  12. Impact from adaptive hash index and innodb_thread_concurrency in MySQL 5.7.5
  13. Low-concurrency performance for range queries: MySQL 5.7 vs previous releases
  14. Low-concurrency performance for point lookups: MySQL 5.7.5 vs previous releases
  15. Single thread performance in MySQL 5.7.5 versus older releases via sql-bench
  16. Sync replication in MySQL 5.X
  17. Get help from an MBA - MySQL Benchmark Advisors
  18. VLDB & MySQL in China
  19. The InnoDB Mutex, part 3
  20. The InnoDB Mutex, part 2
  21. The InnoDB mutex
  22. Bug marketing - fixing MongoDB replication bugs in TokuMX
  23. How to answer questions
  24. Benchmarking the leveldb family
  25. Benchmark(et)ing
  26. Write amplification from log writes
  27. Overhead of reading the Nth attribute in a document for MongoDB & TokuMX
  28. The impact of read ahead and read size on MongoDB, TokuMX and MySQL
  29. Concurrent, read-only, not cached: MongoDB, TokuMX, MySQL
  30. RW locks are hard
  31. Concurrent, read-only & cached: MongoDB, TokuMX, MySQL
  32. Hierarchical CPU profiling for MongoDB
  33. Biebermarks
  34. TokuMX, MongoDB and InnoDB, IO-bound update-only with fast storage
  35. Types of writes
  36. More details on disk IO-bound, update only for MongoDB, TokuMX and InnoDB
  37. MongoDB, TokuMX and InnoDB for disk IO-bound, update-only by PK
  38. Why aren't you using X, version 2
  39. MongoDB, TokuMX and InnoDB for concurrent inserts
  40. Why aren't multi-object updates atomic?
  41. MongoDB, TokuMX and InnoDB for disk IO-bound, read-only point queries
  42. Notes on the storage stack
  43. Insert benchmark on disks, part 2
  44. Insert benchmark for flash, part 2
  45. TokuMX, MongoDB and InnoDB on IO-bound point queries
  46. TokuMX, MongoDB and InnoDB versus the insert benchmark with disks
  47. Redo logs in MongoDB and InnoDB
  48. A few comments on MongoDB and InnoDB replication
  49. Insert benchmark for InnoDB, MongoDB and TokuMX and flash storage
  50. Bigger data
  51. When does MongoDB make a transaction visible?
  52. Exceptions versus returning an error code
  53. Write Amplification: write-optimized versus update-in-place
  54. Notes on MongoDB space allocation
  55. Use case?