This topic presents benchmark results for the Orca feature in PolarDB for MySQL Enterprise Edition 8.0.2. Orca is a persistent database built on PolarDB for MySQL that is fully compatible with the Redis protocol. When you enable the Orca feature, you can access data through a Redis protocol endpoint without deploying a separate Redis service.
The benchmarks measure throughput (QPS) and latency across different value sizes, concurrency levels, and network modes to help you evaluate Orca's performance characteristics for your workload.
Test environment
| Component | Configuration |
|---|---|
| PolarDB cluster | Cluster Edition, MySQL 8.0.2 database engine version, polar.mysql.x4.2xlarge node specifications (16 cores, 64 GB), PSL5 storage type |
| Blink Tree index acceleration | Enabled (loose_innodb_polar_blink_tree=ON) to improve query performance |
| ECS client instance | ecs.c8i.16xlarge (64 cores, 128 GB) |
| Network | ECS instance and PolarDB cluster in the same region and virtual private cloud (VPC), connected through an Orca private endpoint |
The ECS instance connects through an Orca private endpoint to ensure high access performance and efficient, secure data transmission within the VPC.
Test tool
All tests use memtier_benchmark, a multi-threaded stress testing tool from Redis Labs.
Test scenarios
The tests evaluate Orca performance under two concurrency levels (128 and 512 concurrent connections) using two network mechanisms:
Ping-pong mode: The client sends one request and waits for the response before sending the next request. This mode reflects typical interactive workloads.
Pipeline mode: The client sends multiple requests without waiting for individual responses, using a pipeline depth of 32 (
--pipeline=32). This mode maximizes throughput for batch-oriented workloads.
Each concurrency level is tested with four value sizes: 128 bytes, 1 KB, 4 KB, and 16 KB.
Test parameters
128 concurrent connections
| Value size | Threads | Connections per thread | Total connections | Operations per connection | Key range | Total data volume |
|---|---|---|---|---|---|---|
| 128 bytes | 32 | 4 | 128 | 2,000,000 | [1, 128,000,000] | Approx. 30 GB |
| 1 KB | 32 | 4 | 128 | 2,000,000 | [1, 128,000,000] | Approx. 40 GB |
| 4 KB | 32 | 4 | 128 | 200,000 | [1, 12,800,000] | Approx. 60 GB |
| 16 KB | 32 | 4 | 128 | 200,000 | [1, 12,800,000] | Approx. 750 GB |
512 concurrent connections
| Value size | Threads | Connections per thread | Total connections | Operations per connection | Key range | Total data volume |
|---|---|---|---|---|---|---|
| 128 bytes | 32 | 16 | 512 | 2,000,000 | [1, 512,000,000] | Approx. 150 GB |
| 1 KB | 32 | 16 | 512 | 2,000,000 | [1, 512,000,000] | Approx. 175 GB |
| 4 KB | 32 | 16 | 512 | 200,000 | [1, 51,200,000] | Approx. 250 GB |
| 16 KB | 32 | 16 | 512 | 200,000 | [1, 51,200,000] | Approx. 1.5 TB |
Parameter descriptions
| Field | Description |
|---|---|
| Value size | The size of the data value used in each test. The tested sizes are 128 bytes, 1 KB, 4 KB, and 16 KB. |
| Threads | The number of threads used in each test scenario. All scenarios use 32 threads. |
| Connections per thread | The number of client connections created by each thread. 4 connections for 128-concurrency scenarios; 16 connections for 512-concurrency scenarios. |
| Total connections | The total number of concurrent connections (threads multiplied by connections per thread). |
| Operations per connection | The number of write and read operations run per connection. |
| Key range | The range of randomly generated keys for write and read operations. |
| Total data volume | The total data volume, calculated from the value size, operations count, and connections count. |
Test metrics
| Metric | Description |
|---|---|
| QPS | The number of read and write operations per second (operations/sec). Higher values indicate greater throughput capacity. |
| Avg Latency | The average latency of read and write operations, in milliseconds (ms). Lower values indicate faster response times. |
| p99 Latency | The latency below which 99% of operations fall, in milliseconds (ms). Lower values indicate more stable performance under load. |
Test results
Troubleshooting authentication errors
If you encounter either of the following authentication errors during execution:
"error: authentication failed [-ERR wrong number of arguments for 'auth'/'hello' command.]""error: authentication failed [-WRONGPASS invalid username-password pair or user is disabled.]"Replace"-a $password"with the"-a username:password"format, whereusernameis your username andpasswordis your password. For details, see the official memtier_benchmark documentation.
128 concurrency results
Ping-pong mode (128 concurrency)
| Value size | Workload | QPS | Avg Latency (ms) | p99 Latency (ms) |
|---|---|---|---|---|
| 128 bytes | Write-only | 115,179.72 | 1.09 | 3.12 |
| 128 bytes | Read-only | 302,828.59 | 0.41 | 1.46 |
| 128 bytes | Read/write | 200,585.95 | 0.63 | 2.14 |
| 1 KB | Write-only | 91,244.76 | 1.40 | 6.46 |
| 1 KB | Read-only | 310,197.23 | 0.41 | 1.46 |
| 1 KB | Read/write | 142,757.04 | 0.89 | 4.67 |
| 4 KB | Write-only | 49,899.54 | 2.55 | 18.30 |
| 4 KB | Read-only | 275,966.23 | 0.46 | 1.44 |
| 4 KB | Read/write | 86,027.86 | 1.48 | 14.40 |
| 16 KB | Write-only | 6,225.02 | 20.82 | 84.99 |
| 16 KB | Read-only | 166,434.33 | 0.78 | 1.44 |
| 16 KB | Read/write | 12,868.24 | 10.03 | 70.14 |
Pipeline mode (128 concurrency)
| Value size | Workload | QPS | Avg Latency (ms) | p99 Latency (ms) |
|---|---|---|---|---|
| 128 bytes | Write-only | 306,757.45 | 13.35 | 62.46 |
| 128 bytes | Read-only | 1,598,605.28 | 2.54 | 13.82 |
| 128 bytes | Read/write | 272,943.49 | 15.00 | 58.62 |
| 1 KB | Write-only | 195,675.57 | 21.03 | 232.45 |
| 1 KB | Read-only | 981,181.21 | 4.17 | 39.94 |
| 1 KB | Read/write | 191,592.63 | 21.46 | 129.02 |
| 4 KB | Write-only | 69,978.37 | 58.80 | 352.25 |
| 4 KB | Read-only | 497,229.35 | 8.22 | 68.61 |
| 4 KB | Read/write | 97,213.70 | 42.25 | 352.25 |
| 16 KB | Write-only | 6,542.18 | 627.00 | 2,981.89 |
| 16 KB | Read-only | 215,512.81 | 19.09 | 45.57 |
| 16 KB | Read/write | 12,600.41 | 325.68 | 1,581.06 |
512 concurrency results
Ping-pong mode (512 concurrency)
| Value size | Workload | QPS | Avg Latency (ms) | p99 Latency (ms) |
|---|---|---|---|---|
| 128 bytes | Write-only | 85,516.58 | 5.98 | 60.16 |
| 128 bytes | Read-only | 320,063.10 | 1.60 | 14.72 |
| 128 bytes | Read/write | 208,489.07 | 2.46 | 22.53 |
| 1 KB | Write-only | 95,896.76 | 5.36 | 36.86 |
| 1 KB | Read-only | 498,535.49 | 1.04 | 5.02 |
| 1 KB | Read/write | 187,732.88 | 2.75 | 19.20 |
| 4 KB | Write-only | 38,969.61 | 13.17 | 111.61 |
| 4 KB | Read-only | 408,631.46 | 1.28 | 4.67 |
| 4 KB | Read/write | 78,955.68 | 6.50 | 71.68 |
| 16 KB | Write-only | 6,439.60 | 79.68 | 245.76 |
| 16 KB | Read-only | 211,629.97 | 2.44 | 15.17 |
| 16 KB | Read/write | 12,453.06 | 41.15 | 216.06 |
Pipeline mode (512 concurrency)
| Value size | Workload | QPS | Avg Latency (ms) | p99 Latency (ms) |
|---|---|---|---|---|
| 128 bytes | Write-only | 116,795.27 | 140.16 | 2,834.43 |
| 128 bytes | Read-only | 323,316.82 | 50.77 | 436.22 |
| 128 bytes | Read/write | 205,215.89 | 79.93 | 2,719.74 |
| 1 KB | Write-only | 149,738.66 | 109.44 | 1,024.00 |
| 1 KB | Read-only | 929,717.39 | 17.73 | 137.22 |
| 1 KB | Read/write | 208,624.31 | 78.35 | 1,277.95 |
| 4 KB | Write-only | 48,330.42 | 339.82 | 3,948.54 |
| 4 KB | Read-only | 494,936.80 | 33.53 | 243.71 |
| 4 KB | Read/write | 83,907.15 | 195.16 | 3,112.96 |
| 16 KB | Write-only | 6,586.62 | 2,503.77 | 40,894.46 |
| 16 KB | Read-only | 208,420.70 | 79.56 | 708.61 |
| 16 KB | Read/write | 13,054.47 | 1,260.14 | 15,269.89 |
Test commands
This section provides the complete memtier_benchmark commands for every test scenario. Replace the following placeholders with your actual values:
$host: The Orca private endpoint hostname$port: The Orca private endpoint port$password: Your authentication credentials (useusername:passwordformat)
The commands follow a consistent pattern. The key differences across scenarios are the -c flag (connections per thread), -d flag (data size in bytes), --key-maximum flag (key range upper bound), -n flag (operations per connection), and --ratio flag (write:read ratio). Pipeline mode commands include the --pipeline=32 flag.
128 concurrency commands
128 bytes
Ping-pong write-only (128 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Ping-pong read-only (128 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Ping-pong read/write (128 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1Pipeline write-only (128 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Pipeline read-only (128 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Pipeline read/write (128 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=128000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1
1 KB
Ping-pong write-only (128 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=1:0Ping-pong read-only (128 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=0:1Ping-pong read/write (128 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=1:1Pipeline write-only (128 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=1:0Pipeline read-only (128 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=0:1Pipeline read/write (128 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=12800000 --key-minimum=1 --key-prefix=key_ --ratio=1:1
4 KB
Ping-pong write-only (128 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Ping-pong read-only (128 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Ping-pong read/write (128 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1Pipeline write-only (128 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Pipeline read-only (128 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Pipeline read/write (128 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1
16 KB
Ping-pong write-only (128 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Ping-pong read-only (128 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Ping-pong read/write (128 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1Pipeline write-only (128 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Pipeline read-only (128 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Pipeline read/write (128 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 4 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=12800000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1
512 concurrency commands
128 bytes
Ping-pong write-only (512 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Ping-pong read-only (512 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Ping-pong read/write (512 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1Pipeline write-only (512 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Pipeline read-only (512 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Pipeline read/write (512 concurrency, 128-byte value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 2000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=512000000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1
1 KB
Ping-pong write-only (512 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Ping-pong read-only (512 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Ping-pong read/write (512 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1Pipeline write-only (512 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Pipeline read-only (512 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Pipeline read/write (512 concurrency, 1 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 1024 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1
4 KB
Ping-pong write-only (512 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Ping-pong read-only (512 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Ping-pong read/write (512 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1Pipeline write-only (512 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Pipeline read-only (512 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Pipeline read/write (512 concurrency, 4 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 4096 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1
16 KB
Ping-pong write-only (512 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Ping-pong read-only (512 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Ping-pong read/write (512 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1Pipeline write-only (512 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:0Pipeline read-only (512 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=0:1Pipeline read/write (512 concurrency, 16 KB value):
memtier_benchmark -s $host -p $port -a $password -c 16 -t 32 --pipeline=32 -n 200000 --random-data --randomize --distinct-client-seed -d 16384 --key-maximum=51200000 --key-minimum=1 --key-prefix= --key-pattern=R:R --ratio=1:1
Conclusion
The benchmark results demonstrate the following performance characteristics of the PolarDB Orca feature:
Data durability through distributed storage: The PolarDB Orca feature leverages the distributed storage architecture and three-replica redundancy mechanism of PolarDB for MySQL to prevent data loss.
Higher throughput in pipeline mode: In pipeline scenarios, the PolarDB Orca feature significantly improves system throughput using extensive aggregation optimizations. Pipeline mode is best suited for batch-oriented workloads where maximizing throughput is more important than minimizing per-request latency. You can select the pipeline mode as needed.
Read performance scales well: Across all value sizes and concurrency levels, read-only workloads consistently achieve the highest QPS and lowest latency, reflecting Orca's optimized read path.
Value size impacts write performance: Write throughput decreases as value size increases, which is expected due to the larger data volume that must be persisted. For example, at 128 concurrency in ping-pong mode, write-only QPS drops from 115,179.72 (128 bytes) to 6,225.02 (16 KB).