This document describes the Orca performance test results for PolarDB for MySQL Enterprise Edition 8.0.2.
Test environment
The ECS instance and the PolarDB for MySQL cluster must be in the same region and virtual private cloud (VPC).
PolarDB for MySQL cluster configuration:
Cluster specifications: Cluster Edition, MySQL 8.0.2 database engine version,
polar.mysql.x4.2xlarge(16 cores and 64 GB) node specifications, and PSL5 storage type.Parameter settings: The Blink-tree index acceleration feature (
loose_innodb_polar_blink_tree=ON) is enabled to improve query performance.
ECS instance configuration: One
ecs.c8i.16xlargeinstance (64 cores, 128 GB) connects through an Orca private endpoint to ensure high access performance and efficient, secure data transmission within the VPC.
Test tool
This test uses memtier_benchmark, a multi-threaded stress testing tool from Redis Labs.
Performance testing
Test scenarios
This section describes the performance of the Orca feature in two scenarios: one with 128 concurrent connections and the other with 512 concurrent connections. The tests use both Ping-Pong and Pipeline network mechanisms.
Concurrency | Value size | Threads | Connections per thread | Total connections | Operations per connection | Key range | Total data volume |
128 concurrency | 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 concurrency | 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 |
The following table describes the parameters.
Field | Description |
Concurrency | The total number of connections used in the test. The test includes scenarios with 128 and 512 concurrent connections. |
Value size | The size of the data value used in the 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. In the 128-concurrency scenario, 4 connections are created. In the 512-concurrency scenario, 16 connections are created. |
Total connections | The total number of concurrent connections, which is the number of threads multiplied by the number of connections per thread. |
Operations per connection | The number of write and read operations executed per connection. |
Key range | The range of randomly generated keys for write and read operations. |
Total data volume | The total data volume calculated based on the value size, number of operations, and number of connections. |
Test metrics
Metric | Description |
QPS | The number of read and write operations executed per second, in operations/sec. Note QPS is a key metric that measures the throughput capacity of a system. A higher value indicates a stronger processing capability. |
Avg Latency | The average latency of read and write operations, in milliseconds (ms). Note Avg Latency reflects the average response speed of a system. A lower value indicates a better user experience. |
p99 Latency | The latency below which 99% of operations fall, in milliseconds (ms). Note p99 Latency is an important metric that measures the performance stability of a system. A lower value indicates more stable performance under high loads. |
Test results
128 concurrency
If you encounter 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.]"
To resolve this, correct the authentication parameter as specified in the official memtier_benchmark documentation. Replace "-a $password" with the "-a username:password" format. Replace username with your username and password with your password.
128-byte test commands
Ping-Pong write-only test with 128 concurrent connections and a 128 byte value size.
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 test with 128 concurrent connections and a 128 byte value size.
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 test with 128 concurrent connections and a 128 byte value size.
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 test with 128 concurrent connections and a 128 byte value size.
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 test with 128 concurrent connections and a 128 byte value size.
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 test with 128 concurrent connections and a 128 byte value size.
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 test commands
Ping-Pong write-only test with 128 concurrent connections and a 1 KB value size.
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 test with 128 concurrent connections and a 1 KB value size.
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 test with 128 concurrent connections and a 1 KB value size.
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 test with 128 concurrent connections and a 1 KB value size.
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 test with 128 concurrent connections and a 1 KB value size.
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 test with 128 concurrent connections and a 1 KB value size.
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 test commands
Ping-Pong write-only test with 128 concurrent connections and a 4 KB value size.
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 test with 128 concurrent connections and a 4 KB value size.
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 test with 128 concurrent connections and a 4 KB value size.
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 test with 128 concurrent connections and a 4 KB value size.
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 test with 128 concurrent connections and a 4 KB value size.
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 test with 128 concurrent connections and a 4 KB value size.
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 test commands
Ping-Pong write-only test with 128 concurrent connections and a 16 KB value size.
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 test with 128 concurrent connections and a 16 KB value size.
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 test with 128 concurrent connections and a 16 KB value size.
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 test with 128 concurrent connections and a 16 KB value size.
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 test with 128 concurrent connections and a 16 KB value size.
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 test with 128 concurrent connections and a 16 KB value size.
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
The following table compares the performance results.
Test scenario | QPS | Avg Latency (ms) | p99 Latency (ms) |
Ping-Pong write-only test (128 concurrency, 128 bytes) | 115,179.72 | 1.09 | 3.12 |
Ping-Pong read-only test (128 concurrency, 128 bytes) | 302,828.59 | 0.41 | 1.46 |
Ping-Pong read/write test (128 concurrency, 128 bytes) | 200,585.95 | 0.63 | 2.14 |
Pipeline write-only test (128 concurrency, 128 bytes) | 306,757.45 | 13.35 | 62.46 |
Pipeline read-only test (128 concurrency, 128 bytes) | 1,598,605.28 | 2.54 | 13.82 |
Pipeline read/write test (128 concurrency, 128 bytes) | 272,943.49 | 15.00 | 58.62 |
Ping-Pong write-only test (128 concurrency, 1 KB) | 91,244.76 | 1.40 | 6.46 |
Ping-Pong read-only test (128 concurrency, 1 KB) | 310,197.23 | 0.41 | 1.46 |
Ping-Pong read/write test (128 concurrency, 1 KB) | 142,757.04 | 0.89 | 4.67 |
Pipeline write-only test (128 concurrency, 1 KB) | 195,675.57 | 21.03 | 232.45 |
Pipeline read-only test (128 concurrency, 1 KB) | 981,181.21 | 4.17 | 39.94 |
Pipeline read/write test (128 concurrency, 1 KB) | 191,592.63 | 21.46 | 129.02 |
Ping-Pong write-only test (128 concurrency, 4 KB) | 49,899.54 | 2.55 | 18.30 |
Ping-Pong read-only test (128 concurrency, 4 KB) | 275,966.23 | 0.46 | 1.44 |
Ping-Pong read/write test (128 concurrency, 4 KB) | 86,027.86 | 1.48 | 14.40 |
Pipeline write-only test (128 concurrency, 4 KB) | 69,978.37 | 58.80 | 352.25 |
Pipeline read-only test (128 concurrency, 4 KB) | 497,229.35 | 8.22 | 68.61 |
Pipeline read/write test (128 concurrency, 4 KB) | 97,213.70 | 42.25 | 352.25 |
Ping-Pong write-only test (128 concurrency, 16 KB) | 6,225.02 | 20.82 | 84.99 |
Ping-Pong read-only test (128 concurrency, 16 KB) | 166,434.33 | 0.78 | 1.44 |
Ping-Pong read/write test (128 concurrency, 16 KB) | 12,868.24 | 10.03 | 70.14 |
Pipeline write-only test (128 concurrency, 16 KB) | 6,542.18 | 627.00 | 2,981.89 |
Pipeline read-only test (128 concurrency, 16 KB) | 215,512.81 | 19.09 | 45.57 |
Pipeline read/write test (128 concurrency, 16 KB) | 12,600.41 | 325.68 | 1,581.06 |
512 concurrency
If you encounter 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.]"
To resolve this, correct the authentication parameter as specified in the official memtier_benchmark documentation. Replace "-a $password" with the "-a username:password" format. Replace username with your username and password with your password.
128-byte test commands
Ping-Pong write-only test with 512 concurrent connections and a 128 byte value size.
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 test with 512 concurrent connections and a 128 byte value size.
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 test with 512 concurrent connections and a 128 byte value size.
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 test with 512 concurrent connections and a 128 byte value size.
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 test with 512 concurrent connections and a 128 byte value size.
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 test with 512 concurrent connections and a 128 byte value size.
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 test commands
Ping-Pong write-only test with 512 concurrent connections and a 1 KB value size.
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 test with 512 concurrent connections and a 1 KB value size.
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 test with 512 concurrent connections and a 1 KB value size.
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 test with 512 concurrent connections and a 1 KB value size.
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 test with 512 concurrent connections and a 1 KB value size.
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 test with 512 concurrent connections and a 1 KB value size.
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 test commands
Ping-Pong write-only test with 512 concurrent connections and a 4 KB value size.
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 test with 512 concurrent connections and a 4 KB value size.
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 test with 512 concurrent connections and a 4 KB value size.
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 test with 512 concurrent connections and a 4 KB value size.
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 test with 512 concurrent connections and a 4 KB value size.
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 test with 512 concurrent connections and a 4 KB value size.
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 test commands
Ping-Pong write-only test with 512 concurrent connections and a 16 KB value size.
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 test with 512 concurrent connections and a 16 KB value size.
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 test with 512 concurrent connections and a 16 KB value size.
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 test with 512 concurrent connections and a 16 KB value size.
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 test with 512 concurrent connections and a 16 KB value size.
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 test with 512 concurrent connections and a 16 KB value size.
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
The following table compares the performance results.
Test scenario | QPS | Avg Latency (ms) | p99 Latency (ms) |
Ping-Pong write-only test (512 concurrency, 128 bytes) | 85,516.58 | 5.98 | 60.16 |
Ping-Pong read-only test (512 concurrency, 128 bytes) | 320,063.10 | 1.60 | 14.72 |
Ping-Pong read/write test (512 concurrency, 128 bytes) | 208,489.07 | 2.46 | 22.53 |
Pipeline write-only test (512 concurrency, 128 bytes) | 116,795.27 | 140.16 | 2,834.43 |
Pipeline read-only test (512 concurrency, 128 bytes) | 323,316.82 | 50.77 | 436.22 |
Pipeline read/write test (512 concurrency, 128 bytes) | 205,215.89 | 79.93 | 2,719.74 |
Ping-Pong write-only test (512 concurrency, 1 KB) | 95,896.76 | 5.36 | 36.86 |
Ping-Pong read-only test (512 concurrency, 1 KB) | 498,535.49 | 1.04 | 5.02 |
Ping-Pong read/write test (512 concurrency, 1 KB) | 187,732.88 | 2.75 | 19.20 |
Pipeline write-only test (512 concurrency, 1 KB) | 149,738.66 | 109.44 | 1,024.00 |
Pipeline read-only test (512 concurrency, 1 KB) | 929,717.39 | 17.73 | 137.22 |
Pipeline read/write test (512 concurrency, 1 KB) | 208,624.31 | 78.35 | 1,277.95 |
Ping-Pong write-only test (512 concurrency, 4 KB) | 38,969.61 | 13.17 | 111.61 |
Ping-Pong read-only test (512 concurrency, 4 KB) | 408,631.46 | 1.28 | 4.67 |
Ping-Pong read/write test (512 concurrency, 4 KB) | 78,955.68 | 6.50 | 71.68 |
Pipeline write-only test (512 concurrency, 4 KB) | 48,330.42 | 339.82 | 3,948.54 |
Pipeline read-only test (512 concurrency, 4 KB) | 494,936.80 | 33.53 | 243.71 |
Pipeline read/write test (512 concurrency, 4 KB) | 83,907.15 | 195.16 | 3,112.96 |
Ping-Pong write-only test (512 concurrency, 16 KB) | 6,439.60 | 79.68 | 245.76 |
Ping-Pong read-only test (512 concurrency, 16 KB) | 211,629.97 | 2.44 | 15.17 |
Ping-Pong read/write test (512 concurrency, 16 KB) | 12,453.06 | 41.15 | 216.06 |
Pipeline write-only test (512 concurrency, 16 KB) | 6,586.62 | 2,503.77 | 40,894.46 |
Pipeline read-only test (512 concurrency, 16 KB) | 208,420.70 | 79.56 | 708.61 |
Pipeline read/write test (512 concurrency, 16 KB) | 13,054.47 | 1,260.14 | 15,269.89 |
Conclusion
The PolarDB Orca feature leverages the distributed storage architecture and three-replica redundancy mechanism of PolarDB for MySQL to prevent data loss.
In Pipeline scenarios, the PolarDB Orca feature significantly improves system throughput using extensive aggregation optimizations. You can select the Pipeline mode as needed.