MariaDB Foundation: Exploring TidesDB Performance with TAF

TidesDB now exists inside MariaDB as a pluggable storage engine.

With the TideSQL plugin available, anyone can load TidesDB into a MariaDB server and begin experimenting with it.

But having a plugin is only the first step — you still need a practical, reproducible way to run real workloads against it, that’s where TAF comes in.

This blog exists to give anyone interested in TidesDB a roadmap to the city of benchmarking it — a clear, reproducible starting point for running TidesDB inside TAF.

Once you’re in the city benchmarking, where you go is entirely up to you.

The goal isn’t to dictate how people should test TidesDB. It’s to make sure they can get started without friction, using the exact properties, shell scripts, and wiring that pushed into TAF.

From there, readers can take the work in any direction:

• more threads
• turn threadpool on
• larger or smaller datasets
• different sysbench workloads

This blog is simply the jumping‑off point — the baseline that gets you into the city with working TidesDB + TAF integration.

After that, the exploration is yours.

And fair warning: this is a details blog. It’s not a high‑level overview or a marketing piece.

Some readers may find parts of it dry or overly technical — that’s fine.

This post is aimed at people who actually want to run tests, understand what’s required to make those tests work, and have a solid foundation they can extend however they want.

About TidesDB

TidesDB is a high‑performance, open‑source, transactional embedded key‑value storage engine written in C. It isn’t a standalone database server — there’s no daemon, no port, no SQL parser, no authentication layer. Instead, it’s designed to be embedded directly into other systems as a durable storage layer that writes bytes to disk and retrieves them in sorted order.

Through the TideSQL plugin, TidesDB can be used inside MariaDB as a pluggable storage engine. This makes it possible to run SQL workloads on top of TidesDB’s internal architecture. But it’s important to be clear: switching from InnoDB to TidesDB is not a one‑line ENGINE=TIDESDB change. You need the plugin installed, configured, and wired correctly — which is exactly what this blog helps with.

TidesDB differs from traditional engines like InnoDB in several key ways:

• LSM‑style design: TidesDB uses a log‑structured merge approach rather than a B‑tree. Writes are append‑only, and background compaction organizes data later.
• Key/value separation: Keys live in the sorted LSM structure; values are stored in a sequential value log. This reduces write amplification and changes how compaction behaves under load.
• Concurrency model: Internally, TidesDB uses lock‑free structures designed for many‑core CPUs and NVMe storage.
• MVCC behavior: TidesDB implements optimistic multi‑version concurrency control with multiple isolation levels. Readers and writers don’t block each other, and conflicts resolve at commit time.

Prerequisites

Before running TidesDB inside TAF, you need a few specific components in place. TidesDB currently ships inside MariaDB 11.4.13, and the required RPMs can be downloaded directly from the MariaDB mirror:

MariaDB 11.4.13 RPMs: https://mirror.mariadb.org/yum/11.4/rhel9-amd64/rpms/

For TAF to run TidesDB correctly, you will need the following packages:

• MariaDB-server-11.4.13-1.el9.x86_64.rpm
• MariaDB-client-11.4.13-1.el9.x86_64.rpm
• MariaDB-common-11.4.13-1.el9.x86_64.rpm
• MariaDB-devel-11.4.13-1.el9.x86_64.rpm
• MariaDB-plugin-tidesdb-11.4.13_5.0.0-1.el9.x86_64.rpm
• MariaDB-shared-11.4.13-1.el9.x86_64.rpm

You will also need TAF itself:

TAF GitHub: https://github.com/MariaDB/TAF

Commit containing all new TidesDB properties + shell scripts:

https://github.com/MariaDB/TAF/commit/e55a32691c1234e6fea20ac86ba6b59575fdd520

These downloads are all you should need to get started.

Installing MariaDB with TidesDB

Once TAF is in place and the MariaDB 11.4.13 RPMs have been downloaded, the next step is installing MariaDB along with the TidesDB plugin. TAF handles the installation automatically when you provide the full list of RPMs.

The following command, with paths adjusted, will install both MariaDB Server along with TidesDB Plugin.

perl taf.pl –verbose –db-software-install –db-software-install-packages=/<path to>/MariaDB-server-11.4.13-1.el9.x86_64.rpm, /<path to>/MariaDB-client-11.4.13-1.el9.x86_64.rpm, /<path to>/MariaDB-common-11.4.13-1.el9.x86_64.rpm,/<path to>/MariaDB-devel-11.4.13-1.el9.x86_64.rpm,/<path to>/MariaDB-plugin-tidesdb-11.4.13_5.0.0-1.el9.x86_64.rpm,/<path to>/MariaDB-shared-11.4.13-1.el9.x86_64.rpm

TAF will:

• unpack the layered RPMs
• flatten the installation tree
• place the final MariaDB + TidesDB installation under taf-perl/database_software_installs/
• prepare the server binaries and plugin directory for use in TAF workloads
• mark install as “active”

Once the installation completes, TAF prints the confirmation message:

“Install has completed. Happy benchmarking!”

That’s your signal that MariaDB 11.4.13 with the TidesDB plugin is fully installed and ready for use inside TAF.

The Elephant in the Room: Configuration Paths You Must Adjust

Before anyone can run TidesDB inside TAF, they need to deal with the one unavoidable reality: paths matter, and none of them are “default.” Both the .properties files and the shell scripts contain configuration values that must be updated to match the user’s environment.

This section lays out every path you need to consider, why it exists, and what you must change.

1. Properties Files: Required Path Adjustments

There are two categories of paths inside the TAF properties files:

1.1 TidesDB data path

This configuration setting is inside the properties files [db_config_start]/[db_config_end] section

• tidesdb_data_home_dir=/<path to>/taf-perl/data/

1.2 TAF plugin directory path

MariaDB needs to know where the TidesDB plugin .so file actually lives. This is not the default MariaDB plugin directory. In TAF, we use a property to pass to database as CLI on start.

• taf.db_plugin_dir=/<path to>/taf-perl/database_software_installs/MariaDB-server-11.4.13-1.el9.x86_64/lib64/mysql/plugin/

2. Shell Scripts: Required Path Adjustments

The shell scripts have their own set of paths that must be updated.

These control where TAF looks for properties and where it finds the MariaDB/TidesDB installation.

2.1 Properties directory

• PROP_DIR=”/<path to>/taf-perl/properties/mariadb/tidesdb”

2.2 MariaDB + TidesDB installation directory

• INSTALL_DIR=”/<path to>/taf-perl/database_software_installs/MariaDB-server-11.4.13-1.el9.x86_64″

Tides Test Case User Properties Files

NOTE: Before running, see “Building Sysbench” below.

The TidesDB test case properties files are the core of how TAF knows what to run. These files define the sysbench workloads, dataset sizes, isolation levels, and engine configuration for both small and large hosts. All of them live under:

• properties/mariadb/tidesdb/

These properties files are written specifically for two different host classes. To see the exact hardware specifications for each host, refer to the Hardware Sponsor section below.

Each properties file contains the minimum configuration needed to implement the sysbench test cases. They are split into read‑focused and write‑focused workloads:

Read Workloads

• POINT_SELECT
• OLTP_RO

Write Workloads

• OLTP_RW
• OLTP_WO_MODIFIABLE

And they are further divided by host size:

• sysbench_tidesdb_small_host_reads.properties
• sysbench_tidesdb_small_host_writes.properties
• sysbench_tidesdb_large_host_reads.properties
• sysbench_tidesdb_large_host_writes.properties

Each file sets up:

• the correct sysbench test type
• the dataset size appropriate for the host
• the concurrency levels
• the TidesDB engine selection
• the required TidesDB configuration parameters
• the correct plugin directory path (which users must adjust)
• the correct data directory path (which users must adjust)

Shell Scripts for Running TidesDB Tests

TAF includes two shell scripts that act as simple drivers for running the TidesDB sysbench workloads. These scripts are intentionally minimal: they set deterministic CPU behavior, point TAF to the correct properties directory, point TAF to the correct MariaDB + TidesDB installation, and then execute the read and write workloads for the selected host class.

Both scripts live under:

• scripts/mariadb/tidesdb/

and are named:

• tidesdb_small.sh
• tidesdb_large.sh

Each script performs the following steps:

1. Deterministic CPU Behavior

Before running any workload, the scripts configure the host for deterministic CPU frequency. This ensures consistent benchmarking across runs and prevents frequency scaling or boost logic from affecting results.

2. Required Path Variables

Each script defines two variables that every user must update:

• PROP_DIR — the directory containing the TidesDB sysbench properties files
• INSTALL_DIR — the directory containing the MariaDB + TidesDB installation produced by the RPM install step

These paths must match the user’s environment. If either path is incorrect, TAF will fail to locate the properties or the server binaries.

3. Running the Workloads

Each script runs two workloads:

• the read workload (POINT_SELECT and OLTP_RO)
• the write workload (OLTP_RW and OLTP_WO_MODIFIABLE)

The small‑host script runs the small‑host properties files, and the large‑host script runs the large‑host properties files. Output from both workloads is logged to a single file for convenience.

4. Simple, Extensible Design

These scripts are intentionally kept simple so anyone can run TidesDB workloads inside TAF with zero friction. Users can extend them however they want:

• add logging or timestamps
• add loops for multi‑run experiments
• add threadpool toggles
• add dataset scaling logic
• add host‑specific tuning
• add environment validation

But the baseline scripts remain minimal and reproducible.

Building Sysbench

Being a fresh install, sysbench will need to be compiled.

Sysbench can be compile against MariaDB, MySQL and/or PostgreSQL.

To compile, simple take the properties file you plan to run first and on commandline add

–action=build-client

For Example:

• perl ./taf.pl –properties=/home/jeb/taf-perl/properties/mariadb/tidesdb/sysbench_tidesdb_large_host_writes.properties –action=build-client

This will compile sysbench code against current install.

Once built, it only need to be rebuilt if moving from MariaDB to PostgreSQL.

Hardware Sponsor: Host Specifications

None of this work would have been possible without our hardware sponsor, Hetzner.com, who provided two dedicated high‑performance benchmarking machines for all TidesDB + TAF integration testing.

These hosts weren’t just “nice to have” — they were essential. Every properties file, every shell script, every reproducible baseline in this blog exists because Hetzner supplied stable, repeatable, production‑grade hardware that could handle both moderate and heavy sysbench workloads without compromise.

Their contribution gave this project real legs: consistent environments, reliable performance characteristics, and the ability to push TidesDB hard enough to expose real behavior — not theory, not guesses, but actual engine dynamics under load.

Small Host (hz‑bench)

A reliable, mid‑range Intel platform ideal for controlled, moderate‑scale benchmarking.

• CPU: 13th Gen Intel® Core™ i5‑13500
• CPU Count: 20
• Core Count: 14
• Socket Count: 1
• RAM: 62.33 GB
• OS: AlmaLinux 9.7 (Moss Jungle Cat)
• Kernel: 5.14.0‑811.35.1.el9_7.x86_64

This machine provided the stable baseline needed to validate TidesDB behavior under smaller datasets, lower concurrency, and predictable CPU characteristics.

Large Host (hz‑bench2)

A high‑core‑count AMD EPYC system built for serious load, ideal for exploring TidesDB’s scaling characteristics.

• CPU: AMD EPYC 9454 48‑Core Processor
• CPU Count: 96
• Core Count: 48
• Socket Count: 1
• RAM: 124.98 GB
• OS: AlmaLinux 9.8 (Olive Jaguar)
• Kernel: 5.14.0‑427.28.1.el9_8.x86_64

This host made it possible to push TidesDB into high‑concurrency territory, test larger datasets, and observe how the engine behaves when the workload actually stresses the underlying architecture.

Closing Thoughts

At this point, you have everything you need to get TidesDB running inside TAF: the RPMs, the install command, the configuration paths, the properties files, the shell drivers, and the hardware context.

At this point it, it a matter of executing the shell script of interest.

But before closing, it’s important to acknowledge the person who made all of this possible.

Congratulations to Alex (Gaetano) Padula

TidesDB didn’t appear in MariaDB by accident. It wasn’t a weekend project or a casual experiment. It was the result of months of work, long nights, long days, refactors, rewrites, design pivots, and relentless iteration.

Alex pushed TidesDB from an idea into a real, production‑grade storage engine — and then pushed further to make it a first‑class MariaDB plugin through TideSQL.

Getting a new storage engine into MariaDB is not a small achievement. It requires:

• deep understanding of MariaDB internals
• careful engineering around MVCC, isolation, and crash recovery
• plugin architecture work
• performance tuning
• correctness validation
• and the persistence to keep going when the work gets hard

Alex did all of that. And he did it with clarity, enthusiasm, and a level of engineering pride that shows in every conversation and every commit.

TidesDB being available as a MariaDB plugin is a milestone — not just for Alex, but for the entire MariaDB ecosystem.

It opens the door for new workloads, new performance characteristics, and new exploration.

This blog exists because Alex built something worth exploring.

So congratulations, Alex. You earned this.

To all “Happy benchmarking!”

Jonathan (Jeb) Miller has experience in military leadership, Fire/EMS leadership, computer operations leadership, teaching, and more than 27 years of database performance engineering (PervasiveSQL, MySQL, MariaDB).

TAF is the third benchmarking framework he has helped design and build.

#MariaDB #MySQL #PostgreSQL #Database #TAF #DatabasePerformance #Performance #TidesDB