PERFORMANCE

Large values. Parallel execution.
Durable writes.

From small application records to large stored objects. Thunder brings together reactor-local processing, dedicated memory arenas, and asynchronous I/O—with writes journaled before acknowledgement.

01 / YOUR APPLICATION’S WORKLOAD

What does your
application move?

A state update and a large object ask different things of a database. Start with the data you store, then evaluate how Thunder handles it.

01

Small records.

State that changes often.

Read session state, update metadata, and save agent checkpoints as requests arrive.

  • Session state
  • Metadata
  • Checkpoints
WHAT TO MEASURE

Latency under concurrency

Completed operations per second and p50, p95, and p99 latency as the number of active clients grows.

02

Large values.

Objects with more to carry.

Store conversation snapshots, retrieved context bundles, generated artifacts, and serialized application objects as values.

  • Context bundles
  • Snapshots
  • Artifacts
WHAT TO MEASURE

Complete-object throughput

Completed bytes per second and read/write latency at each payload size, with memory and client CPU usage.

03

Both, together.

The workload in between.

Update small control records while other requests read and write large objects. Evaluate the traffic that shares your server.

  • State updates
  • Object transfers
  • Concurrent clients
WHAT TO MEASURE

Each request class

Small-request latency alongside large-value throughput. Keep their results separate to see how the mix behaves.

These are evaluation scenarios. Published throughput and latency benchmarks will be added when available.

02 / THE ENGINEERING BEHIND IT

Give the work
a place to run.

Thunder assigns ownership, memory, and I/O explicitly. These design choices shape how requests use the machine.

ROUTING

Connect to the owner.

The client discovers the shard map and connects to the reactor responsible for each key. Routing happens before the request reaches the server.

Follow a key
EXECUTION

Divide work across reactors.

Each reactor owns a shard range and an arena. The host’s usable CPU topology determines how many reactor groups run in parallel.

See core execution
I/O

Submit I/O asynchronously.

Disk and network operations use Linux io_uring. Evaluate the complete request path with the storage device and network your application will use.

Check host requirements
CAPACITY

Room for 512 MiB values.

Store large objects under a single key. For 512 MiB values, configure a 4 GiB arena per reactor; a SET needs two copies of its value in the arena.

Size memory and storage

03 / PART OF EVERY WORKLOAD

Durable writes.
Encrypted data.

These are Thunder’s operating conditions. Include them when you evaluate performance.

BEFORE ACKNOWLEDGEMENTJournaled to disk.
The write’s journal record reaches disk before success is returned to the client.
IN TRANSITTLS 1.3 connections.
Client connections use TLS. Network measurements include the encrypted connection.
AT RESTEvery value encrypted.
Stored values are encrypted. Include that work in the configuration you measure.

04 / PUT THUNDER TO WORK

Start with a round trip.
Then bring your data.

Get a healthy instance running, verify the connection, and move on to the workload that matters to your application.

  1. 01

    Start an instance.

    The setup guide takes you through the release kit, CPU and memory allocation, TLS, and server health.

    Set up Thunder
  2. 02

    Verify the round trip.

    From a configured release kit, check that the server is healthy and run the sample. It reads back every value it writes and compares the bytes.

    Exit code 0 means no mismatches and no errors.

    SHELL · CONFIGURED RELEASE KIT
    docker compose ps
    docker compose run --rm sample

    8 connections · 30 seconds
    256 B · 4 KiB · 64 KiB · 2 MiB · 16 MiB

    This checks correctness, not maximum throughput. The sample does not test 512 MiB values.

  3. 03

    Evaluate your workload.

    Use your application or a dedicated load generator to reproduce your payload sizes, access patterns, and concurrency.

    Connect your application

    Keep the useful measurements.

    Record completed operations, bytes transferred, latency percentiles, and errors. For mixed traffic, report each request class separately.

    View the evaluation checklist

05 / MEASUREMENT DETAILS

Make the result
reproducible.

Record the conditions alongside the numbers, so you can repeat a run and understand what changed.

Release & hardware

Record the server image tag and digest, client version, CPU model, physical cores, SMT, affinity or quota, and derived reactor count.

Include total RAM, arena bytes per reactor, container memory limits, storage device, filesystem, volume type, and available disk space.

Traffic & client placement

Capture payload sizes, key distribution, dataset size, read/write ratio, concurrency, and connection count. Separate cached reads from reads that reach storage.

Record client placement and network bandwidth. Watch load-generator CPU and serialization costs so you know whether the client is limiting the run.

Durability & security

Document when writes are acknowledged, whether data is encrypted at rest, and how connections are secured. Thunder journals before acknowledgement, encrypts stored values, and requires TLS.

Use equivalent conditions when comparing systems.

Duration, latency & errors

Record warmup, run duration, and repeated runs. Include sustained overwrite and delete activity when it reflects your application.

Report completed operations and bytes per second, p50/p95/p99 latency, timeouts, rejected work, and errors. Preserve variation across runs and check returned data for correctness.

YOUR NEXT STEP

Try Thunder with
the data you actually store.