Editors Note: The Last Pickle was recently acquired by DataStax and as part of the new DataStax mission of reorienting to embrace open source Apache Cassandra, this is the first in a series of blog posts that will compare new open source offerings, particularly those now coming out of the new DataStax. In open source spirit we want to embrace you, the community, in choosing the right tool for the right job.
Benchmarking and stress testing Apache Cassandra are important exercises that both operators and developers do regularly. Approaches come in numerous flavours, from “look how my code is better than everyone else’s”, to “what do I need to run this?” and “how much money will this save me?”, and my favourite, “when this dies a horrible death what will that look like?”.
Knowing what you want to achieve and how to interpret the results of these tests is a big part of the challenge. With a run through of these available tools, hopefully that will become easier.
Comparing stress tools for Apache Cassandra
This blog post will look at and compare the following three stress tools:
With these three tools we will step through a number of basic use cases:
- Just Generate Some Load
- Using a Real Cluster
- Iteration and Thread Counts
- Batch sizes and Overwrites
- Predefined Workloads
- Custom Workloads
- Client Contention and Server Saturation
The versions of the tools used in these steps are 3.11.6 for cassandra-stress, 4.0.0 for tlp-stress, and 3.12.77 for nosqlbench.
1. Just Generate Some Load
Sometimes all you want to do is generate some load or data. This is good for when all we want is a cassandra node that is doing something. It can be just to raise the CPU, or to generate some commitlogs, memtables, or sstables on disk.
Each tool will generate a slightly different load configuration for these tests:
$ cassandra-stress write
Performs over a million writes (after an initial 50k warmup writes) iterating a number of times increasing the number of threads used in the client, starting with four threads.
$ tlp-stress run BasicTimeSeries -i 1M
Performs exactly one million requests with a 9:1 write-to-read ratio.
$ nb cql-iot write_cl=LOCAL_ONE
Performs ten million writes during a warmup phase and then ten million requests with a 9:1 write-to-read ratio.
All of them execute writes connected to a localhost Cassandra node, using the java-driver and consistency level LOCAL_ONE.
There is a difference in the model, however, as cassandra-stress uses a simple key value table, while tlp-stress and nosqlbench are using time-series data models.
2. Using a Real Cluster
This repeats the exercise of just generating any load or data, but is used when you have an actual cluster you are targeting.
$ cassandra-stress write -node cassandra1 $ tlp-stress run BasicTimeSeries --host cassandra1 $ nb cql-iot host=cassandra1
Note: There is no need to specify multiple hosts with any of these stress tools. These are contact hosts that are passed to the java driver, and unlike a coded application where you would want multiple contact hosts specified for reliability during deployment and startup, with a stress tool invocation it is reasonable to expect the single contact host specified to be up and running.
3. Iteration and Thread Counts
The following shows how to specify the number of iterations and the number of threads to use, in each of the tools.
$ cassandra-stress write n=100000 -rate threads=16 $ tlp-stress run BasicTimeSeries -n 100k -t 16 $ nb cql-iot write_cl=LOCAL_ONE main-cycles=100k threads=16
Even with well-designed workloads there is a lot more to benchmarking than the final throughput numbers. We want to see how the cluster operates over time. This can be from spikes in traffic to the many background operations Cassandra can perform. Taking a closer look at how Cassandra performs helps plan for a healthy and stable cluster over a longer period of time than what we are able to benchmark.
$ cassandra-stress write -graph file=example-benchmark.html title=example revision=benchmark-0
For more information on this, read our previous blog post on Cassandra-Stress and Graphs.
$ nb cql-iot write_cl=LOCAL_ONE --docker-metrics
Note: tlp-stress has no similar observability feature, but does export Prometheus metrics on port 9501.
The out of the box generated graphs from cassandra-stress are a nice feature. For any serious benchmarking activity though you will want to have metrics from Cassandra graphed and to have insight into the stress tools behaviour beyond just performance numbers.
5. Batch sizes and Overwrites
The following invocation is of particular interest because it has been a pain for those using cassandra-stress. In Cassandra, unlogged batches are not normal and not recommended unless for very small groupings (10-20) of rows within the one partition.
cassandra-stress, by default, puts all writes for any partition into single batches, which makes for poor and unrealistic results. It is impossible to get cassandra-stress to not use batches, and quite convoluted to get it to write batches that consist only of single inserts. More info on this can be read in this ticket CASSANDRA-11105
Overwrite and deletes are not something we see a lot of among published Cassandra benchmarks because its harder to implement. Often this makes sense as workloads like key-value and time-series are likely not overwrite data models. Yet, there are plenty of data models out there that do require these patterns and that we would like to benchmark.
First download batch_too_large.yaml.
$ cassandra-stress user profile=batch_too_large.yaml ops\(insert=1\) -insert visits=FIXED\(10M\)
tlp-stress does not perform unlogged batches by default like cassandra-stress. If unlogged batches are desired you need to write your own workload, see the
Custom Workloads section.
tlp-stress does make deletes very easy, treating them in a similar fashion to the read rate flag. This will make 10% of the operations deletes of previously written data
$ tlp-stress run KeyValue --deletes 0.1
tlp-stress does overwrites in a similar way to cassandra-stress. This will write 100k operations over 100 partitions. Without clustering keys, this is roughly 1k overwrites on each partition
$ tlp-stress run KeyValue -p 100 -n 100k
nosqlbench can handle overwrites in the same manner as cassandra-stress and tlp-stress by providing a smaller partition count than the iteration count. nosqlbench does not currently provide any deletes or unlogged batch examples. Logged batches have been implemented with custom workloads, so deletes and unlogged batches are probably possible with a custom implemented workload.
6. Predefined Workloads
cassandra-stress does not have built in workloads. You need to specify the
user mode and supply your own configuration as shown in the next section.
tlp-stress has the most extensive list of workloads. These workloads have been used at TLP to demonstrate real limitations with certain features and to provide a hands on approach to recommending the best production solutions.
$ tlp-stress list Available Workloads: AllowFiltering BasicTimeSeries CountersWide KeyValue LWT Locking Maps MaterializedViews RandomPartitionAccess Sets UdtTimeSeries $ tlp-stress run CountersWide
nosqlbench lists the workloads from its predefined yaml workload files. Within these workloads it lists the different phases that are used, and that can be combined. This offers us our first glimpse of how complex and specific a workload can be defined. It also lists the sequences workload, which is not based on the cql driver.
$ nb --list-workloads from: cql-keyvalue.yaml … from: cql-iot.yaml … from: cql-iot-dse.yaml … from: cql-tabular.yaml … from: sequences.yaml … $ nb cql-tabular
7. Custom Workloads
A benchmark that is part of a feasibility or capacity planning exercise for production environments will nearly always require a custom defined workload.
For cassandra-stress an example of this was done for the Zipkin project. cassandra-stress can not benchmark more than one table at a time, so there is a separate workload yaml for each table and these have to run as separate invocations. Here we see that cassandra-stress does not support Zipkin’s original schema, specifically UDTs and collections, so the folder above also contains some cql files to create a schema we can stress.
Create the zipkin test schema
cqlsh -f zipkin2-test-schema.cql
Fill this schema with some data, throttle as appropriate
$ cassandra-stress user profile=span-stress.yaml ops\(insert=1\) no-warmup duration=1m -rate threads=4 throttle=50/s
Now benchmark a mixed read and write workload, again throttle as appropriate
$ cassandra-stress user profile=span-stress.yaml ops\(insert=1,by_trace=1,by_trace_ts_id=1,by_annotation=1\) duration=1m -rate threads=4 throttle=50/s
As can be seen above, creating custom workloads in cassandra-stress has always been an involved and difficult experience. While tlp-stress and nosqlbench improve on this situation, they each do so in different ways.
nosqlbench provides all of its workload configurations via yaml files. Getting the hang of these will be quite daunting for the newcomer, but along with the documentation provided, and practicing first with taking and tweaking the predefined workloads, there’s a wealth of possibility here.
tlp-stress on the other hand focuses on writing workloads in the code. tlp-stress is written in Kotlin, so if you find Kotlin enjoyable you will find it quick and intuitive to write workloads. The existing workloads can be found here, take a peek and you will see that they are quite simple to write.
8. Client Contention and Server Saturation
Which benchmark tool is faster? That may sound like a weird question, but it opens some real concerns. Not just in choosing what hardware to run the client on, or how many clients are required, but to know when the results you are getting are nonsense. Understanding the load you want to generate versus what you need to measure is as important to benchmarking as the workload.
It is important to avoid saturating the server. Any benchmark that pushes throughput to its limit is meaningless. A real world (and overly simplified) comparison of this is in OLAP clusters, like those paired with Apache Spark, where without appropriate thresholds put onto the spark-cassandra-connector you can get a yo-yo effect on throughput as the cluster saturates, jams up, and then accepts writes again. With tuning and throughput thresholds put into place, higher throughput is sustainable over time. Responsiveness Under Load (RUL) benchmark is where we apply such throughput limits and observe responsiveness instead.
These problems extend into the client stress tool as well. Unlike the server that can block or load-shed at the defined throughput threshold, the client’s throughput of operations can be either limited or scheduled. This difference can be important, but explaining it goes beyond this blog post. For those interested I’d recommend reading this post on Fixing Coordinated Omission in Cassandra Stress.
$ cassandra-stress write -rate threads=4 fixed=50/s
nosqlbench has no scheduler per se, but deals with reducing coordinated omission via asynchronous requests and a non-fixed thread count. More information on nosqlbench’s timing terminology can be found here.
$ nb cql-iot cyclerate=50 async=256 threads=auto
Very few production clusters ever demonstrate constant throughput like this, so benchmarking bursts is a real thing. Currently only nosqlbench does this in-process.
$ nb cql-iot cyclerate=50,1.5 async=256 threads=auto
This specifies a rate threshold of 50 operations per second, with bursts of up to 50%. More information on bursts is available here
tlp-stress does not deal with Coordinated Omission. Its
--rate flag relies on google’s
RateLimiter and limits the throughput, but does not schedule.
Looking through the documentation for each of the tools it is easy to see that nosqlbench offers substantially more. But tlp-stress docs are elegant and easy for the beginner, though they are still missing information on how to implement your own workload (or profile as tlp-stress refers to them).
cassandra-stress is an advanced tool for very narrow applications against Cassandra. It is quickly a clumsy user-experience and often requires adventures into some awkward code to understand and get things working as expected.
tlp-stress was written as a replacement to cassandra-stress. Apart from not dealing with Coordinated Omission it succeeds in that goal in every aspect: good documentation, a rich command-line user-interface, and is an easy code to understand and contribute to.
nosqlbench takes the next step, aiming to be a YCSB replacement. It feels like a power-user’s tool and comes with the features and capacity to earn that title. Expect to see more and more workloads be made available for testing lots of different technologies in the NoSQL world.