Performance whitepaper of SSD-based instances - Tair (Redis® OSS-Compatible)

This document covers the test environment, tooling, methodology, and results for a performance benchmark of Tair (Enterprise Edition) SSD-based instances.

Test environment

Item	Description
Region and zone	Hangzhou Zone J
Instance architecture	Standard master-replica architecture. For details, see Standard architecture.
Stress testing host	Elastic Compute Service (ECS) instance of the `ecs.c9i.8xlarge` type. For details, see Overview of instance families.
Instance types tested	`tair.localssd.c1m8.xlarge`, `tair.localssd.c1m8.2xlarge`, `tair.localssd.c1m8.with.proxy.xlarge (3 shards)`, `tair.localssd.c1m8.with.proxy.2xlarge (3 shards)`

The benchmark covers two scenarios that represent opposite ends of the memory utilization spectrum:

Memory larger than data volume: Most data fits in memory. Memory-to-data ratio is approximately 7:1. This represents an in-memory-dominant access pattern.
Data volume larger than memory: Only a portion of data is cached in memory, and most read/write requests require disk I/O. Memory-to-data ratio is approximately 1:4. This represents an SSD-dominant access pattern.

Test tool

The benchmark uses YCSB, an open-source Java-based database benchmarking framework.

The YCSB source code is modified to support a LONG-typed recordcount parameter and to test Redis string commands. For the modified source code, see YCSB source code.

Test script

The following script runs performance tests for the data-volume-larger-than-memory scenario:

#!/bin/bash

ip=192.168.0.23
port=3100
timeout=30000
command_group=string
recordcount=640000000
run_operationcount=640000000
fieldcount=1
fieldlength=100
threads=64
load_sleep_time=600
run_sleep_time=60

echo "##################################### $command_group  ############################################"

# Load
./bin/ycsb load redis -s -P workloads/workloada \
  -p "redis.host=${ip}" -p "redis.port=${port}" \
  -p "recordcount=${recordcount}" -p "operationcount=${recordcount}" \
  -p "redis.timeout=${timeout}" -p "redis.command_group=${command_group}" \
  -p "fieldcount=${fieldcount}" -p "fieldlength=${fieldlength}" \
  -threads ${threads}
sleep ${load_sleep_time}

# Uniform-Read
./bin/ycsb run redis -s -P workloads/workloadc \
  -p "redis.host=${ip}" -p "redis.port=${port}" \
  -p "recordcount=${recordcount}" -p "operationcount=${run_operationcount}" \
  -p "redis.timeout=${timeout}" -p "redis.command_group=${command_group}" \
  -p "fieldcount=${fieldcount}" -p "fieldlength=${fieldlength}" \
  -p "requestdistribution=uniform" -threads ${threads}
sleep ${run_sleep_time}

# Zipfian-Read
./bin/ycsb run redis -s -P workloads/workloadc \
  -p "redis.host=${ip}" -p "redis.port=${port}" \
  -p "recordcount=${recordcount}" -p "operationcount=${run_operationcount}" \
  -p "redis.timeout=${timeout}" -p "redis.command_group=${command_group}" \
  -p "fieldcount=${fieldcount}" -p "fieldlength=${fieldlength}" \
  -p "requestdistribution=zipfian" -threads ${threads}
sleep ${run_sleep_time}

# Uniform-50%Read-50%Update
./bin/ycsb run redis -s -P workloads/workloada \
  -p "redis.host=${ip}" -p "redis.port=${port}" \
  -p "recordcount=${recordcount}" -p "operationcount=${run_operationcount}" \
  -p "redis.timeout=${timeout}" -p "redis.command_group=${command_group}" \
  -p "fieldcount=${fieldcount}" -p "fieldlength=${fieldlength}" \
  -p "requestdistribution=uniform" -threads ${threads}

Parameters

Parameter	Description
`ip`	IP address of the Tair instance
`port`	Service port of the Tair instance
`timeout`	Command timeout. Unit: ms
`command_group`	Data type to test. Set to `string`
`recordcount`	Number of records loaded during the data loading phase
`run_operationcount`	Number of operations during the run phase. In both scenarios, set this to the same value as `recordcount`.
`fieldcount`	Number of fields per record. Set to `1`
`fieldlength`	Length of each field in bytes. Set to `100`
`threads`	Number of YCSB client threads. Varies by instance type.

Test metrics

Metric	Description
QPS	Number of read and write operations processed per second
Average latency	Average latency of read or write operations. Unit: µs
99th percentile latency	Highest latency for the fastest 99% of operations. Unit: µs. For example, a value of 500 µs means 99% of operations complete within 500 µs.

Test results

Memory size larger than data volume

Memory-to-data ratio is approximately 7:1. Most requests are served from memory.

Instance type	YCSB configuration	Workload	QPS	Average latency (µs)	99th percentile latency (µs)
`tair.localssd.c1m8.xlarge`	recordcount=20,000,000 run_operationcount=20,000,000 threads=64 fieldlength=100	Load	41,960	1,522	5,523
		Uniform-Read	110,867	574	2,515
		Zipfian-Read	116,309	547	2,429
		Uniform-50%Read-50%Update	53,116	Read: 1,094	Read: 4,025
		Uniform-50%Read-50%Update	53,116	Update: 1,310	Update: 4,655
`tair.localssd.c1m8.2xlarge`	recordcount=40,000,000 run_operationcount=40,000,000 threads=128 fieldlength=100	Load	64,378	1,985	6,091
		Uniform-Read	205,584	620	2,279
		Zipfian-Read	211,290	603	2,217
		Uniform-50%Read-50%Update	80,796	Read: 1,406	Read: 4,631
		Uniform-50%Read-50%Update	80,796	Update: 1,756	Update: 5,495
`tair.localssd.c1m8.with.proxy.xlarge (3 shards)`	recordcount=60,000,000 run_operationcount=60,000,000 threads=192 fieldlength=100	Load	110,169	1,737	11,279
		Uniform-Read	233,028	820	4,675
		Zipfian-Read	235,489	811	4,655
		Uniform-50%Read-50%Update	122,866	Read: 1,480	Read: 10,311
		Uniform-50%Read-50%Update	122,866	Update: 1,635	Update: 10,735
`tair.localssd.c1m8.with.proxy.2xlarge (3 shards)`	recordcount=120,000,000 run_operationcount=120,000,000 threads=384 fieldlength=100	Load	180,502	2,122	10,727
		Uniform-Read	429,252	891	3,293
		Zipfian-Read	438,533	872	3,365
		Uniform-50%Read-50%Update	231,044	Read: 1,541	Read: 8,663
		Uniform-50%Read-50%Update	231,044	Update: 1,772	Update: 9,151

Data volume larger than memory size

Memory-to-data ratio is approximately 1:4. Most requests require disk I/O, so latency is higher than in the memory-dominant scenario above.

Instance type	YCSB configuration	Workload	QPS	Average latency (µs)	99th percentile latency (µs)
`tair.localssd.c1m8.xlarge`	recordcount=640,000,000 run_operationcount=640,000,000 threads=64 fieldlength=100	Load	32,596	1,961	8,135
		Uniform-Read	50,227	1,272	3,753
		Zipfian-Read	71,804	889	2,947
		Uniform-50%Read-50%Update	27,063	Read: 2,306	Read: 8,199
		Uniform-50%Read-50%Update	27,063	Update: 2,416	Update: 8,535
`tair.localssd.c1m8.2xlarge`	recordcount=1,280,000,000 run_operationcount=1,280,000,000 threads=128 fieldlength=100	Load	50,608	2,526	9,071
		Uniform-Read	78,931	1,619	4,371
		Zipfian-Read	113,338	1,127	3,347
		Uniform-50%Read-50%Update	47,564	Read: 2,598	Read: 8,471
		Uniform-50%Read-50%Update	47,564	Update: 2,778	Update: 8,959
`tair.localssd.c1m8.with.proxy.xlarge (3 shards)`	recordcount=1,920,000,000 run_operationcount=1,920,000,000 threads=192 fieldlength=100	Load	88,483	2,167	16,383
		Uniform-Read	119,177	1,609	8,775
		Zipfian-Read	156,079	1,228	7,663
		Uniform-50%Read-50%Update	70,402	Read: 2,670	Read: 19,295
		Uniform-50%Read-50%Update	70,402	Update: 2,777	Update: 19,535
`tair.localssd.c1m8.with.proxy.2xlarge (3 shards)`	recordcount=3,840,000,000 run_operationcount=3,840,000,000 threads=384 fieldlength=100	Load	147,757	2,596	16,559
		Uniform-Read	217,186	1,766	7,087
		Zipfian-Read	282,698	1,356	6,131
		Uniform-50%Read-50%Update	135,495	Read: 2,766	Read: 18,591
		Uniform-50%Read-50%Update	135,495	Update: 2,895	Update: 18,815

References

ESSD/SSD-based instances