Performance whitepaper of SSD-based instances - Tair (Redis® OSS-Compatible): Central de Documentação do Alibaba Cloud

Ambiente de teste

Item	Descrição
Região e zona	Hangzhou Zone J
Arquitetura da instância	Arquitetura mestre-réplica padrão. Para obter detalhes, consulte Arquitetura padrão.
Host de teste de carga	Instância do Elastic Compute Service (ECS) do tipo `ecs.c9i.8xlarge`. Para obter detalhes, consulte Visão geral das famílias de instâncias.
Tipos de instância testados	`tair.localssd.c1m8.xlarge`, `tair.localssd.c1m8.2xlarge`, `tair.localssd.c1m8.with.proxy.xlarge (3 shards)`, `tair.localssd.c1m8.with.proxy.2xlarge (3 shards)`

O benchmark abrange dois cenários que representam extremos opostos no espectro de utilização de memória:

Memória maior que o volume de dados: A maior parte dos dados cabe na memória. A proporção entre memória e dados é de aproximadamente 7:1. Esse cenário representa um padrão de acesso com predominância de memória.
Volume de dados maior que a memória: Apenas uma parcela dos dados permanece em cache na memória; a maioria das solicitações de leitura e gravação exige E/S de disco. A proporção entre memória e dados é de aproximadamente 1:4. Esse cenário representa um padrão de acesso com predominância de SSD.

Ferramenta de teste

O benchmark utiliza o YCSB, um framework de benchmark de banco de dados open source baseado em Java.

O código-fonte do YCSB foi modificado para oferecer suporte ao parâmetro recordcount do tipo LONG e testar comandos de string do Redis. Para acessar o código-fonte modificado, consulte Código-fonte do YCSB.

Script de teste

O script a seguir executa testes de desempenho para o cenário em que o volume de dados supera a memória:

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

Parâmetros

Parâmetro	Descrição
`ip`	Endereço IP da instância Tair
`port`	Porta de serviço da instância Tair
`timeout`	Tempo limite do comando. Unidade: ms
`command_group`	Tipo de dado a ser testado. Defina como `string`
`recordcount`	Quantidade de registros carregados durante a fase de carga de dados
`run_operationcount`	Quantidade de operações durante a fase de execução. Em ambos os cenários, defina este valor igual ao `recordcount`.
`fieldcount`	Número de campos por registro. Defina como `1`
`fieldlength`	Tamanho de cada campo em bytes. Defina como `100`
`threads`	Número de threads do cliente YCSB. Varia conforme o tipo de instância.

Métricas de teste

Métrica	Descrição
QPS	Quantidade de operações de leitura e gravação processadas por segundo
Latência média	Latência média das operações de leitura ou gravação. Unidade: µs
Latência do percentil 99	Maior latência observada entre os 99% de operações mais rápidas. Unidade: µs. Por exemplo, um valor de 500 µs indica que 99% das operações foram concluídas em até 500 µs.

Resultados dos testes

Memória maior que o volume de dados

A proporção entre memória e dados é de aproximadamente 7:1. A memória atende diretamente à maioria das solicitações.

Tipo de instância	Configuração do YCSB	Carga de trabalho	QPS	Latência média (µs)	Latência do percentil 99 (µs)
`tair.localssd.c1m8.xlarge`	recordcount=20.000.000 run_operationcount=20.000.000 threads=64 fieldlength=100	Load	42.275	1.511	4.987
		Uniform-Read	104.303	611	2.163
		Zipfian-Read	105.217	605	2.259
		Uniform-50%Read-50%Update	52.267	Read: 1.114	Read: 4.191
		Uniform-50%Read-50%Update	52.267	Update: 1.329	Update: 4.827
`tair.localssd.c1m8.2xlarge`	recordcount=40.000.000 run_operationcount=40.000.000 threads=128 fieldlength=100	Load	64.104	1.993	5.951
		Uniform-Read	174.533	730	2.049
		Zipfian-Read	177.612	718	2.033
		Uniform-50%Read-50%Update	75.762	Read: 1.509	Read: 4.667
		Uniform-50%Read-50%Update	75.762	Update: 1.864	Update: 5.479
`tair.localssd.c1m8.with.proxy.xlarge (3 shards)`	recordcount=60.000.000 run_operationcount=60.000.000 threads=192 fieldlength=100	Load	116.107	1.647	9.983
		Uniform-Read	225.613	847	3.687
		Zipfian-Read	234.014	816	3.279
		Uniform-50%Read-50%Update	138.884	Read: 1.321	Read: 8.131
		Uniform-50%Read-50%Update	138.884	Update: 1.435	Update: 8.479
`tair.localssd.c1m8.with.proxy.2xlarge (3 shards)`	recordcount=120.000.000 run_operationcount=120.000.000 threads=384 fieldlength=100	Load	170.447	2.246	11.935
		Uniform-Read	323.136	1.184	4.005
		Zipfian-Read	330.023	1.159	3.951
		Uniform-50%Read-50%Update	207.350	Read: 1.759	Read: 9.031
		Uniform-50%Read-50%Update	207.350	Update: 1.934	Update: 9.439

Volume de dados maior que a memória

A proporção entre memória e dados é de aproximadamente 1:4. Como a maioria das solicitações exige E/S de disco, a latência supera a do cenário anterior com predominância de memória.

Tipo de instância	Configuração do YCSB	Carga de trabalho	QPS	Latência média (µs)	Latência do percentil 99 (µs)
`tair.localssd.c1m8.xlarge`	recordcount=640.000.000 run_operationcount=640.000.000 threads=64 fieldlength=100	Load	33.198	1.925	7.699
		Uniform-Read	48.243	1.324	3.659
		Zipfian-Read	66.635	958	3.003
		Uniform-50%Read-50%Update	28.779	Read: 2.169	Read: 7.531
		Uniform-50%Read-50%Update	28.779	Update: 2.272	Update: 7.851
`tair.localssd.c1m8.2xlarge`	recordcount=1.280.000.000 run_operationcount=1.280.000.000 threads=128 fieldlength=100	Load	48.605	2.631	8.463
		Uniform-Read	83.687	1.527	3.889
		Zipfian-Read	113.742	1.123	3.351
		Uniform-50%Read-50%Update	46.606	Read: 2.652	Read: 8.815
		Uniform-50%Read-50%Update	46.606	Update: 2.835	Update: 9.367
`tair.localssd.c1m8.with.proxy.xlarge (3 shards)`	recordcount=1.920.000.000 run_operationcount=1.920.000.000 threads=192 fieldlength=100	Load	89.421	2.144	15.351
		Uniform-Read	115.967	1.653	9.311
		Zipfian-Read	155.686	1.231	6.359
		Uniform-50%Read-50%Update	72.890	Read: 2.585	Read: 16.479
		Uniform-50%Read-50%Update	72.890	Update: 2.676	Update: 16.719
`tair.localssd.c1m8.with.proxy.2xlarge (3 shards)`	recordcount=3.840.000.000 run_operationcount=3.840.000.000 threads=384 fieldlength=100	Load	137.521	2.789	16.591
		Uniform-Read	185.273	2.070	8.575
		Zipfian-Read	238.099	1.610	6.203
		Uniform-50%Read-50%Update	128.080	Read: 2.930	Read: 15.535
		Uniform-50%Read-50%Update	128.080	Update: 3.060	Update: 15.807

Gráfico de comparação de desempenho

Referências

Instâncias baseadas em ESSD/SSD