Redis Benchmarks, often simply referred to as redis-benchmark, is a command-line tool that allows you to measure the performance of your Redis server.
Important Topics for Redis Benchmark
It is a part of the Redis distribution, so you don’t need to install it separately. Redis Benchmarks are incredibly valuable for assessing how well your Redis server can handle various workloads, concurrent connections, and different types of operations.
Syntax of Redis Benchmarks
Syntax:
redis-benchmark [options]
Note: Here, [options] represent various configuration options and parameters that allow you to customize the benchmarking process to suit your specific testing needs.
Redis Benchmarking Commands
Redis Benchmarks support several options and commands to tailor your performance tests. Here are some of the most commonly used ones:
Hostname command
Specifies the hostname or IP address of the Redis server to connect. The default is 127.0.0.1.
Syntax:
-h, –host <hostname>
Example:
Connect to a Redis server running on 192.162.4.100
redis-benchmark -h 192.162.4.100
This option allows you to specify the hostname or IP address of the Redis server to which you want to connect. By default, it is set to 127.0.0.1, which means it will connect to a Redis server running on the local machine. You can change this to the hostname or IP address of your Redis server if it’s on a remote machine.
Port command
Specifies the port number of the Redis server.
Syntax:
-p, –port <port>
Example:
Connect to a Redis server running on port 6380
redis-benchmark -p 6380
This option to specify the port number of the Redis server. The default Redis port is 6379. If your Redis server is running on a different port, you can provide that port number using this option.
Client Number command
Sets the number of parallel client connections to use for the benchmark.
Syntax:
-c, –clients <num>
Example:
Simulate 500 clients making requests concurrently
redis-benchmark -c 500
It determines the number of parallel client connections that Redis Benchmark will use to simulate the workload. Increasing the number of clients can help you test how well Redis handles concurrent requests.
Requests command
Determines the total number of requests to send during the benchmark.
Syntax:
-n, –requests <num>:
Example:
Each client sends 50,000 requests.
redis-benchmark -n 50000
This option sets the total number of requests that each client connection will send during the benchmark. It represents the workload you want to simulate.
Threads command
Specifies the number of threads to use for running the benchmark.
Syntax:
-t, –threads <num>
The -t option specifies the number of threads to use for running the benchmark.
Note: Redis Benchmark supports multi-threaded benchmarking, which can help you saturate your CPU cores effectively. This is particularly useful for high-performance servers with multiple CPU cores.
Example:
Run the benchmark using 4 threads
redis-benchmark -t 4
Data Size command
Sets the size of the payload for SET and GET operations.
Syntax:
-d, –data-size <num>:
With this option, you can set the size of the payload data for SET and GET operations. The default is 2 bytes.
Example:
d 512 would set the payload size to 512 bytes.
-d, –data-size 512
Random Benchmarking Data command
Redis Benchmark will randomize the payload data for SET and GET operations. This is useful for testing scenarios where the data is not predictable or uniform.
Syntax:
-r, –random-data:
Example: Use a 256-byte payload for SET and GET operations
redis-benchmark -d 256
Key Benchmark command:
It helps for simulating real-world scenarios where keys follow a specific structure.
Syntax:
-k, –key-pattern <pattern>
The -k option allows you to specify a key pattern for benchmarking. For instance, -k “user:%u:profile” uses %u as a placeholder for unique values in keys.
Example:
Simulate keys in the format “user:580097:profile”:
redis-benchmark -k “user:%u:profile”
Pipeline command:
Enables pipelining of commands, allowing multiple commands to be sent in a single network request.
Syntax:
-o, –pipeline <num>
Enabling pipelining with this option allows you to send multiple commands in a single network request. It can significantly improve Redis’s throughput by reducing the overhead of individual command execution.
Example:
-o 1 means each client will send one command at a time, while -o 10 means each client will send ten commands in a single request.
-o, –pipeline 1
Request command:
Syntax:
redis-benchmark -n <num>
Example:
redis-benchmark -n 50000
Note: Ensure the total number of requests doesn’t overload the server or take too long to complete.
Example:
Use pipelining with a pipeline size of 5
redis-benchmark -o 5
Note: The -o option is used to specify the number of outstanding (in-flight) requests that should be kept open at a time during the benchmarking process.
Num-Clients command:
The total number of requests.
Syntax:
redis-benchmark -n <num>
Note: Ensure the total number of requests doesn’t overload the server or take too long to complete.
Example:
To benchmark the redis for processing 1000 commands
redis-benchmark -n 1000
Redis Benchmarking Examples
Let’s explore some practical examples of how to use Redis Benchmarks:
Basic Benchmark
To perform a basic benchmark with 50 clients sending 100,000 requests each, use the following command:
Syntax:
redis-benchmark -c 50 -n 100000
This command will assess the Redis server’s performance under the specified load.
Benchmark with Custom Payload Size
You can test Redis’s performance with a custom payload size (e.g., 512 bytes) using the -d option.
Syntax:
redis-benchmark -c 10 -n 10000 -d 512
It measure how Redis handles larger data payloads.
Benchmark with Pipelining
To enable pipelining with 100 clients and 1,000 requests, use the -o option.
Syntax:
redis-benchmark -c 100 -n 1000 -o 1
Pipelining can significantly improve Redis’s throughput by batching multiple commands in a single request.
Benchmark with Key Pattern
You can simulate a workload where keys follow a specific pattern using the -k option.
Example
redis-benchmark -c 20 -n 50000 -k “user:%u:profile”
Note: Here, %u will be replaced with unique values for each key.
Pitfalls and Misconceptions of Redis Benchmarking
- Overloading the Server: Benchmarking with an excessively high number of clients or requests can artificially degrade performance. Ensure your benchmarks are realistic.
- Network Overheads: Redis Benchmarking measures not only Redis but also network performance. Latency can be influenced by network conditions.
- Cold Cache vs. Warm Cache: Redis Benchmarking doesn’t account for cache warming. Real-world performance may vary when Redis starts with an empty cache.
- Hardware Variability: Benchmark results can differ significantly based on hardware, CPU, RAM, and disk speed. Ensure consistent hardware for meaningful comparisons.
- Single Operation Benchmark: Redis Benchmarking often focuses on single operations (e.g., SET and GET). Real-world applications involve complex operations.
Factors Impacting Redis Performance
- Data Size: Larger data payloads can impact Redis performance, as they require more memory and bandwidth.
- CPU and Memory: Redis is CPU-bound for most workloads. Ensure sufficient CPU cores and memory for your Redis server.
- Persistence: Enabling disk persistence options (e.g., RDB snapshots or AOF logs) can affect Redis performance.
- Data Structures: The choice of Redis data structures (e.g., Sets, Sorted Sets, Hashes) impacts performance based on the operations you perform
- Eviction Policies: Redis eviction policies (e.g., LRU, LFU) affect cache efficiency and performance under memory pressure.
- Concurrency: Concurrent access to Redis can lead to contention. Use connection pooling and pipeline commands effectively.
- Network Latency: Network latency between clients and the Redis server can be a significant factor, especially in distributed setups.
- Key Design: Efficient key design, including proper sharding, can prevent hot keys and improve Redis performance.
Interpreting Redis Benchmark Results
After running a benchmark, Redis Benchmarks will provide you with a summary of the results. Key metrics to focus on include:
- Requests per second (RPS): This indicates the number of operations Redis can handle in a second. Higher RPS values are generally better.
- Latency: Redis Benchmarks provide latency percentiles (e.g., 50%, 95%, 99%) to show the response times of various percentiles of requests. Lower latency values are preferable, indicating quicker response times.
- Throughput: Measured in operations per second, throughput is a measure of Redis’s processing capacity under the specified workload.
- Connection errors: This helps identify if the Redis server is struggling to handle the specified number of clients.
Conclusion:
Redis Benchmarks are an indispensable tool for assessing the performance of your Redis server under different conditions and workloads. By understanding the syntax, available commands, and interpreting the benchmark results, you can optimize your Redis deployment for your specific use cases. Accurate performance evaluation ensures that Redis continues to serve as a high-performance, low-latency data store for your applications.