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

Ambiente de teste

Item	Descrição
Região e zona	Todos os testes foram executados na Zona I de Hangzhou.
Arquitetura da instância	O teste utiliza a arquitetura padrão mestre-réplica. Para mais informações, consulte Arquitetura padrão.
Máquina virtual com a ferramenta de estresse implantada	Instância do Elastic Compute Service (ECS) do tipo ecs.g6e.13xlarge. Para mais detalhes, consulte Visão geral das famílias de instâncias.
Tipo de instância baseada em ESSD	tair.essd.standard.xlarge tair.essd.standard.2xlarge tair.essd.standard.4xlarge tair.essd.standard.8xlarge tair.essd.standard.13xlarge

O teste de desempenho avalia as instâncias baseadas em ESSD nos seguintes cenários:

Memória maior que o volume de dados: A maior parte dos dados é acessada diretamente da memória. Nesses casos, a proporção entre o tamanho da memória e o volume de dados é de aproximadamente 7:1.
Volume de dados maior que a memória: Apenas uma fração dos dados permanece em cache na memória, exigindo operações de leitura e escrita em disco para a maioria das solicitações. Nesse cenário, a proporção entre o tamanho da memória e o volume de dados é de aproximadamente 1:4.

Ferramenta de teste

Use o YCSB open source para executar testes de estresse. O YCSB é uma ferramenta Java para benchmarking de desempenho em diversos tipos de bancos de dados. Para saber como instale e usar o YCSB, consulte YCSB.

Neste teste, o código-fonte do YCSB foi modificado para permitir a definição do parâmetro recordcount como um valor do tipo LONG e testar comandos de string do Redis. Baixe o pacote de código-fonte do YCSB para obter o código-fonte modificado.

Cargas de trabalho

Carregamento de dados: Executa 100% de operações SET em strings (escrita).
Uniform-Read: Usa o Workload A, composto inteiramente por operações GET em strings aleatórias (leitura), para testar o desempenho de leitura sob condições rigorosas.
Zipfian-Read: Usa o Workload C, que segue uma distribuição Zipfian, para avaliar o desempenho de leitura quando a maioria das requisições acessa apenas uma pequena parcela dos dados. Esse comportamento é típico da maioria das aplicações de leitura.
Uniform-50%Read-50%Update: Baseia-se no Workload A e combina 50% de operações SET (atualização) com 50% de operações GET em strings, para medir o desempenho de atualizações aleatórias.

Para mais detalhes sobre as cargas de trabalho, consulte Core Workloads.

Comandos de teste

O script abaixo testa o desempenho em cenários em que o volume de dados supera o tamanho da memória:

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

Tabela 1. 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 de teste. Unidade: ms.
command_group	Tipo de dado a ser testado. Defina este parâmetro como String.
recordcount	Quantidade de dados preparada durante a fase de carregamento.
run_operationcount	Volume de dados envolvido na operação. Ao configurar este parâmetro, observe as seguintes regras: Se a memória for maior que o volume de dados, iguale este parâmetro ao valor de recordcount. Se o volume de dados superar a memória, defina este parâmetro como o valor de recordcount dividido por 32.
fieldcount	Número de campos. Defina este parâmetro como 1.
fieldlength	Comprimento de cada campo. Defina este parâmetro como 100.
threads	Número de threads do YCSB. Configure este parâmetro conforme o tipo da instância.

Resultados dos testes

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

Cenários em que a memória é maior que o volume de dados

内存大于数据场景的测试结果

Tipo de instância	Configuração do YCSB	Carga de trabalho	QPS	Latência média (µs)	Latência do percentil 99 (µs)
tair.essd.standard.xlarge	recordcount=20000000 run_operationcount=20000000 threads=32	Load	36.740	851	1.595
		Uniform-Read	103.890	294	907
		Zipfian-Read	106.357	288	865
		Uniform-50%Read-50%Update	46.610	Leitura: 530	Leitura: 1.108
		Uniform-50%Read-50%Update	46.610	Atualização: 795	Atualização: 1.684
tair.essd.standard.2xlarge	recordcount=40000000 run_operationcount=40000000 threads=50	Load	54.670	911	1.528
		Uniform-Read	150.796	314	995
		Zipfian-Read	151.110	314	977
		Uniform-50%Read-50%Update	69.137	Leitura: 537	Leitura: 948
		Uniform-50%Read-50%Update	69.137	Atualização: 878	Atualização: 1.479
air.essd.standard.4xlarge	recordcount=80000000 run_operationcount=80000000 threads=100	Load	90.703	1.099	1.697
		Uniform-Read	285.833	339	1.196
		Zipfian-Read	288.750	335	1.162
		Uniform-50%Read-50%Update	110.316	Leitura: 757	Leitura: 1.114
		Uniform-50%Read-50%Update	110.316	Atualização: 1.041	Atualização: 1.536
tair.essd.standard.8xlarge	recordcount=160000000 run_operationcount=160000000 threads=120	Load	117.581	1.011	1.692
		Uniform-Read	477.099	242	784
		Zipfian-Read	494.550	234	727
		Uniform-50%Read-50%Update	196.245	Leitura: 519	Leitura: 829
		Uniform-50%Read-50%Update	196.245	Atualização: 691	Atualização: 1.096
tair.essd.standard.13xlarge	recordcount=240000000 run_operationcount=240000000 threads=160	Load	126.366	1.249	2.281
		Uniform-Read	673.183	231	637
		Zipfian-Read	691.383	230	652
		Uniform-50%Read-50%Update	197.803	Leitura: 678	Leitura: 940
		Uniform-50%Read-50%Update	197.803	Atualização: 935	Atualização: 1.925

Cenários em que o volume de dados é maior que a 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.essd.standard.xlarge	recordcount=640000000 run_operationcount=20000000 threads=32	Load	25.561	1.245	3.497
		Uniform-Read	25.727	1.239	2.042
		Zipfian-Read	47.559	667	1.217
		Uniform-50%Read-50%Update	19.731	Leitura: 1.576	Leitura: 6.383
		Uniform-50%Read-50%Update	19.731	Atualização: 1.639	Atualização: 6.487
tair.essd.standard.2xlarge	recordcount=1280000000 run_operationcount=40000000 threads=50	Load	42.287	1.179	3.465
		Uniform-Read	35.794	1.394	1.880
		Zipfian-Read	77.759	637	1.219
		Uniform-50%Read-50%Update	28.656	Leitura: 1.716	Leitura: 8.863
		Uniform-50%Read-50%Update	28.656	Atualização: 1.761	Atualização: 8.951
air.essd.standard.4xlarge	recordcount=2560000000 run_operationcount=80000000 threads=100	Load	65.923	1.514	6.615
		Uniform-Read	44.753	2.232	7.903
		Zipfian-Read	120.337	826	1.382
		Uniform-50%Read-50%Update	38.470	Leitura: 2.577	Leitura: 8.535
		Uniform-50%Read-50%Update	38.470	Atualização: 2.617	Atualização: 8.583
tair.essd.standard.8xlarge	recordcount=5120000000 run_operationcount=160000000 threads=120	Load	89.231	1.340	9.575
		Uniform-Read	51.175	2.343	2.955
		Zipfian-Read	131.317	911	1.573
		Uniform-50%Read-50%Update	38.930	Leitura: 3.063	Leitura: 8.695
		Uniform-50%Read-50%Update	38.930	Atualização: 3.097	Atualização: 8.735
tair.essd.standard.13xlarge	recordcount=7680000000 run_operationcount=240000000 threads=160	Load	92.163	1.733	9.879
		Uniform-Read	51.267	3.510	16.623
		Zipfian-Read	138.522	1.152	2.131
		Uniform-50%Read-50%Update	39.584	Leitura: 4.022	Leitura: 12.159
		Uniform-50%Read-50%Update	39.584	Atualização: 4.057	Atualização: 12.239