Livre blanc sur les performances des instances basées sur SSD - Tair (Redis® OSS-Compatible)

Environnement de test

Élément

Description

Région et zone

Hangzhou Zone J

Architecture de l'instance

Architecture standard maître-réplica. Pour plus de détails, consultez Standard architecture.

Hôte de test de charge

Instance Elastic Compute Service (ECS) de type ecs.c9i.8xlarge. Pour plus de détails, consultez Overview of instance families.

Types d'instances testés

tair.localssd.c1m8.xlarge, tair.localssd.c1m8.2xlarge, tair.localssd.c1m8.with.proxy.xlarge (3 shards), tair.localssd.c1m8.with.proxy.2xlarge (3 shards)

Le test couvre deux scénarios représentant les extrémités opposées du spectre d'utilisation de la mémoire :

Mémoire supérieure au volume de données : La majeure partie des données tient en mémoire. Le rapport mémoire/données est d'environ 7:1. Ce scénario représente un modèle d'accès dominé par la mémoire.
Volume de données supérieur à la mémoire : Seule une partie des données est mise en cache en mémoire et la plupart des requêtes de lecture/écriture nécessitent des E/S disque. Le rapport mémoire/données est d'environ 1:4. Ce scénario représente un modèle d'accès dominé par le SSD.

Outil de test

Le test utilise YCSB, un framework open source de test de performance de bases de données basé sur Java.

Le code source de YCSB a été modifié pour prendre en charge un paramètre recordcount de type LONG et pour tester les commandes string de Redis. Pour consulter le code source modifié, rendez-vous sur YCSB source code.

Script de test

Le script suivant exécute les tests de performance pour le scénario où le volume de données est supérieur à la mémoire :

#!/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}

Paramètres

Paramètre

Description

ip

Adresse IP de l'instance Tair

port

Port de service de l'instance Tair

timeout

Délai d'expiration de la commande. Unité : ms

command_group

Type de données à tester. Définissez la valeur sur string

recordcount

Nombre d'enregistrements chargés lors de la phase de chargement des données

run_operationcount

Nombre d'opérations pendant la phase d'exécution. Dans les deux scénarios, définissez cette valeur identique à celle de recordcount.

fieldcount

Nombre de champs par enregistrement. Définissez la valeur sur 1

fieldlength

Longueur de chaque champ en octets. Définissez la valeur sur 100

threads

Nombre de threads clients YCSB. Varie selon le type d'instance.

Métriques de test

Métrique

Description

QPS

Nombre d'opérations de lecture et d'écriture traitées par seconde

Latence moyenne

Latence moyenne des opérations de lecture ou d'écriture. Unité : µs

Latence du 99e centile

Latence la plus élevée pour les 99 % d'opérations les plus rapides. Unité : µs. Par exemple, une valeur de 500 µs signifie que 99 % des opérations se terminent en moins de 500 µs.

Résultats des tests

Taille de la mémoire supérieure au volume de données

Le rapport mémoire/données est d'environ 7:1. La plupart des requêtes sont servies depuis la mémoire.

Type d'instance	Configuration YCSB	Charge de travail	QPS	Latence moyenne (µs)	Latence du 99e centile (µ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

Volume de données supérieur à la taille de la mémoire

Le rapport mémoire/données est d'environ 1:4. La plupart des requêtes nécessitent des E/S disque, ce qui entraîne une latence plus élevée que dans le scénario précédent dominé par la mémoire.

Type d'instance	Configuration YCSB	Charge de travail	QPS	Latence moyenne (µs)	Latence du 99e centile (µ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

Références

ESSD/SSD-based instances