ApsaraDB for Redis:Performance white paper of ESSD-based instances

Overview

Tair ESSD-based instances are developed based on enhanced SSDs (ESSDs) and are compatible with core data structures and APIs of open source Redis. These instances can provide large-capacity, low-cost, and persistent database services. ESSD-based instances reduce costs and improve data reliability. In addition, ESSD-based instances reduce the amount of memory that is reserved for the forks of native Redis databases. ESSD-based instances are suitable for scenarios that store warm and cold data, and require compatibility with open source Redis, large capacity, and high access performance. For more information, see ESSD-based instances.

Test environment

Test tool

You can use open source YCSB to perform stress tests. YCSB is a Java tool that can be used to benchmark the performance of multiple types of databases. For more information about how to install and use YCSB, see YCSB.

In this test, the YCSB source code is modified to allow you to set the recordcount parameter to a LONG-typed value and test the string-related commands of Redis. To obtain the modified source code, download the YCSB source code package.

Workloads

• Data loading: performs 100% string set operations (write operations).
• Uniform-Read: runs Workload A that consists of 100% random string get operations (read operations). This tests read performance under harsh conditions.
• Zipfian-Read: uses Workload C that adopts Zipfian as the data distribution method to test read performance in scenarios in which most read requests are sent to access a small portion of data. Most read scenarios belong to these scenarios.
• Uniform-50%Read-50%Update: uses Workload A that consists of 50% string set operations (update operations) and 50% string get operations. This tests the performance of random updates.

For more information about workloads, see Core Workloads.

Test commands

The following script is used to test performance in scenarios where the data volume is larger than the memory size:

#! /bin/bash

ip=192.168.0.23
port=3100
timeout=30000
command_group=string
recordcount=640000000
run_operationcount=20000000
fieldcount=1
fieldlength=100
threads=32
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}

Test results

Scenarios in which the memory size is larger than the data volume

Scenarios in which the data volume is larger than the memory size