memcaslap - Online na nuvem

PROGRAMA:

NOME

memaslap - documentação libmemcached

SINOPSE

memaslap [opções]

--Socorro

MEMCACHED_SERVERS

DESCRIÇÃO

memaslap é uma ferramenta de geração de carga e benchmark para servidores memcached. Gera
carga de trabalho configurável, como threads, simultaneidades, conexões, tempo de execução, sobrescrever,
taxa de perda, tamanho da chave, tamanho do valor, obter / definir proporção, taxa de transferência esperada e assim por diante.
Além disso, ele também testa a verificação de dados, verificação de tempo de expiração, UDP, binário
protocolo, teste do Facebook, teste de replicação, multi-get e reconexão, etc.

Memaslap gerencia conexões de rede como memcached com libevent. Cada fio de memaslap
está vinculado a um núcleo de CPU, todos os threads não se comunicam entre si, e há
várias conexões de soquete em cada segmento. Cada conexão mantém a distribuição do tamanho da chave,
distribuição de tamanho de valor e distribuição de comando por si só.

Você pode especificar servidores por meio do tapa de memória --servidores opção ou através da variável de ambiente
MEMCACHED_SERVERS.

CARATERÍSTICAS

O Memslap foi desenvolvido para os seguintes fins:

Gerencia conexões de rede com libevent de forma assíncrona.

Configure TCP e UDP para usar IO sem bloqueio.

Melhora o paralelismo: maior desempenho em ambientes multi-thread.

Melhora a eficiência do tempo: velocidade de processamento mais rápida.

Gera chave e valor com mais eficiência; distribuição de tamanho de chave e tamanho de valor
distribuição são configuráveis.

Oferece suporte aos comandos get, multi-get e set; a distribuição do comando é configurável.

Suporta taxa de falha e taxa de substituição controláveis.

Suporta verificação de dados e tempo de validade.

Suporta despejar informações estatísticas periodicamente.

Suporta milhares de conexões TCP.

Suporta protocolo binário.

Suporta teste do Facebook (definido com TCP e multi-get com UDP) e teste de replicação.

DETALHES

Eficaz implementação of rede.
Para memaslap, o TCP e o UDP usam E / S de rede sem bloqueio. Todos os eventos da rede são
gerenciado por libevent como memcached. O módulo de rede do memaslap é semelhante ao memcached.
Libevent pode garantir que o memaslap consiga lidar com a rede de maneira muito eficiente.

Eficaz implementação of multithreads e simultaneidade
Memslap tem a implementação semelhante de multi-threads para memcached. Memslap cria um
ou mais threads autogeridos; cada thread é vinculado a um núcleo da CPU se o sistema testar
configuração da afinidade do núcleo da CPU.

Além disso, cada thread possui um libevent para gerenciar os eventos da rede; cada tópico
tem uma ou mais concorrentes autogerenciados; e cada simultaneidade tem um ou mais soquetes
conexões. Todas as simultaneidades não se comunicam entre si, embora sejam
no mesmo segmento.

Memslap pode criar milhares de conexões de soquete, e cada simultaneidade tem dezenas de
conexões de soquete. Cada simultaneidade seleciona aleatoriamente ou sequencialmente um soquete
conexão de seu pool de conexão de soquete para executar, para que memaslap possa garantir cada simultaneidade
lida com uma conexão de soquete a qualquer momento. Os usuários podem especificar o número de
simultaneidade e conexões de soquete de cada simultaneidade de acordo com o esperado
carga de trabalho.

Eficaz implementação of gerando chave e valor
A fim de melhorar a eficiência do tempo e do espaço, memaslap cria um
Tabela de caracteres com 10 milhões de caracteres. Todos os sufixos de chaves e valores são gerados
desta tabela de caracteres aleatórios.

Memslap usa o deslocamento na tabela de caracteres e o comprimento da string para identificar um
fragmento. Isso pode economizar muita memória. Cada chave contém duas partes, um prefixo e um sufixo. o
prefixo é um uint64_t, 8 bytes. A fim de verificar o conjunto de dados antes, memaslap precisa
certifique-se de que cada chave seja única, para que use o prefixo para identificar uma chave. O prefixo não pode
incluem caracteres ilegais, como 'r', 'n', '0' e ''. E memaslap tem um algoritmo
para garantir que.

Memslap não gera todos os objetos (pares de valores-chave) no início. É só
gera objetos suficientes para preencher a janela de tarefas (objetos padrão de 10K) de cada
simultaneidade. Cada objeto tem as seguintes informações básicas, prefixo de chave, sufixo de chave
deslocamento na tabela de caracteres, comprimento da chave, deslocamento de valor na tabela de caracteres e valor
comprimento.

No processo de trabalho, cada simultaneidade seleciona sequencialmente ou aleatoriamente um objeto do
janela para definir a operação ou obter a operação. Ao mesmo tempo, cada simultaneidade chuta
objetos fora de sua janela e adiciona um novo objeto a ele.

simples mas a útil tarefa agendamento
Memslap usa libevent para agendar todas as simultaneidades de threads, e cada simultaneidade
agenda tarefas com base na janela de tarefas locais. Memslap assume que se cada simultaneidade
mantém a mesma distribuição de chaves, distribuição de valores e distribuição de comandos, de
fora, memaslap mantém toda a distribuição como um todo. Cada janela de tarefa inclui muito
de objetos, cada objeto armazena suas informações básicas, como chave, valor, tempo de expiração e
em breve. A qualquer momento, todos os objetos na janela mantêm a mesma chave e valor fixo
distribuição. Se um objeto for sobrescrito, o valor do objeto será atualizado.
O Memslap verifica os dados ou o tempo de validade de acordo com as informações do objeto armazenadas no
janela de tarefas.

Libevent seleciona qual simultaneidade tratar com base em um evento de rede específico. Então o
simultaneidade seleciona qual comando (obter ou definir) operar com base no comando
distribuição. Se for necessário chutar um objeto antigo e adicionar um novo objeto, a fim de manter
a mesma distribuição de chave e valor, o novo objeto deve ter o mesmo comprimento de chave e
comprimento do valor.

Se o servidor memcached tiver duas camadas de cache (memória e SSD), executando memaslap com diferentes
tamanhos de janela podem obter diferentes taxas de perda de cache. Se memaslap adicionar objetos suficientes no
janelas no início, e o cache do memcached não pode armazenar todos os objetos
inicializado, então memaslap obterá alguns objetos da segunda camada de cache. Causa
a primeira camada de cache a perder. Assim, o usuário pode especificar o tamanho da janela para obter o esperado
taxa de perda da primeira camada de cache.

Útil implementação of multi-servidores , UDP, TCP, multi-obter e binário protocolo
Como cada thread é autogerido, memaslap pode atribuir diferentes threads para lidar
diferentes servidores memcached. Esta é apenas uma das maneiras pelas quais memaslap testa vários
servidores. A única limitação é que o número de servidores não pode ser maior que o
número de processos. A outra maneira de testar vários servidores é o teste de replicação. Cada
a simultaneidade tem uma conexão de soquete para cada servidor memcached. Para a implementação,
memaslap pode definir alguns objetos para um servidor memcached e obter esses objetos do
outros servidores.

Por padrão, Memslap tem um único get. Se o usuário especificar a opção multi-get, memaslap irá
colete o suficiente, obtenha comandos e empacote e envie os comandos juntos.

Memslap testa o protocolo ASCII e o protocolo binário, mas é executado no ASCII
protocolo por padrão. O Memslap, por padrão, é executado no protocolo TCP, mas também testa o UDP.
Como o UDP não é confiável, podem ocorrer pacotes descartados e pacotes fora de ordem. Memslap
cria um buffer de memória para lidar com esses problemas. Memslap tenta ler todas as respostas
dados de um comando do servidor e reordena os dados de resposta. Se alguns pacotes forem
perdido, o mecanismo de tempo limite de espera pode garantir que pacotes incompletos sejam descartados e
o próximo comando será enviado.

USO

Abaixo estão alguns exemplos de uso:

memaslap -s 127.0.0.1:11211 -S 5s

memaslap -s 127.0.0.1:11211 -t 2m -v 0.2 -e 0.05 -b

memaslap -s 127.0.0.1:11211 -F config -t 2m -w 40k -S 20s -o 0.2

memaslap -s 127.0.0.1:11211 -F configuração -t 2m -T 4 -c 128 -d 20 -P 40k

memaslap -s 127.0.0.1:11211 -F configuração -t 2m -d 50 -a -n 40

memaslap -s 127.0.0.1:11211,127.0.0.1:11212 -F configuração -t 2m

memaslap -s 127.0.0.1:11211,127.0.0.1:11212 -F configuração -t 2m -p 2

O usuário deve especificar pelo menos um servidor para executar o memaslap. O resto dos parâmetros têm
valores padrão, conforme mostrado abaixo:

Número do thread = 1 Concorrência = 16

Tempo de execução = 600 segundos Arquivo de configuração = NULL

Tamanho da chave = 64 Tamanho do valor = 1024

Obter / definir = 9: 1 Tamanho da janela = 10k

Executar número = 0 Single get = true

Multi-get = false Número de soquetes de cada simultaneidade = 1

Reconectar = falso Verificação de dados = falso

Verificação do tempo de expiração = falso protocolo ASCII = verdadeiro

Protocolo binário = informação estatística de despejo falsa

periodicamente = falso

Proporção de substituição = 0% UDP = falso

TCP = verdadeiro Limite de rendimento = falso

Teste do Facebook = falso Teste de replicação = falso

Chave tamanho, valor tamanho e comando distribuição.
Todas as distribuições são lidas do arquivo de configuração especificado pelo usuário com
Opção “—cfg_cmd”. Se o usuário não especificar um arquivo de configuração, memaslap será executado
com a distribuição padrão (tamanho da chave = 64, tamanho do valor = 1024, obter / definir = 9: 1). Para
informações sobre como editar o arquivo de configuração, consulte o “Arquivo de configuração”
seção.

O tamanho mínimo da chave é 16 bytes; o tamanho máximo da chave é 250 bytes. A precisão de
proporção é 0.001. A proporção da distribuição será arredondada para 3 casas decimais.

O tamanho mínimo do valor é 1 bytes; o tamanho máximo do valor é 1M bytes. A precisão de
proporção é 0.001. A proporção da distribuição será arredondada para 3 casas decimais.
Atualmente, memaslap apenas testa set e get comandos. E testa 100% definido e 100% obtido.
Para obter 100%, ele irá predefinir alguns objetos para o servidor.

Multi fio e simultaneidade
O alto desempenho do memaslap se beneficia da programação especial de rosca e
simultaneidade. É importante especificar o número adequado deles. O número padrão de
threads é 1; o número padrão de simultaneidade é 16. O usuário pode usar “—threads” e
“--Concurrency” para especificar essas variáveis.

Se o sistema testar a configuração da afinidade da CPU e o número de threads especificado pelo usuário
for maior que 1, memaslap tentará vincular cada thread a um núcleo de CPU diferente. Então se
você deseja obter o melhor desempenho de memaslap, é melhor especificar o número de
thread igual ao número de núcleos da CPU. O número de threads especificado pelo usuário pode
também ser menor ou maior que o número de núcleos da CPU. Por causa da limitação de
implementação, o número de simultaneidades pode ser o múltiplo do número de
tópicos.

1. Para sistema de 8 núcleos de CPU

Por exemplo:

--threads = 2 --concurrency = 128

--threads = 8 --concurrency = 128

--threads = 8 --concurrency = 256

--threads = 12 --concurrency = 144

2. Para sistema de 16 núcleos de CPU

Por exemplo:

--threads = 8 --concurrency = 128

--threads = 16 --concurrency = 256

--threads = 16 --concurrency = 512

--threads = 24 --concurrency = 288

O memaslap tem um desempenho muito bom, quando usado para testar o desempenho de servidores memcached.
Na maioria das vezes, o gargalo é a rede ou o servidor. Se por algum motivo o usuário
deseja limitar o desempenho de memaslap, existem duas maneiras de fazer isso:

Diminua o número de threads e simultaneidades. Use a opção “--tps” que memaslap
fornece para limitar o rendimento. Esta opção permite que o usuário obtenha o esperado
Taxa de transferência. Por exemplo, suponha que a taxa de transferência máxima seja de 50 kops / s para um determinado
configuração, você pode especificar a taxa de transferência igual ou menor que a taxa de transferência máxima
usando a opção “--tps”.

Janela tamanho
Na maioria das vezes, o usuário não precisa especificar o tamanho da janela. A janela padrão
o tamanho é 10k. Para Schooner Memcached, o usuário pode especificar diferentes tamanhos de janela para obter
diferentes taxas de perda de cache com base no caso de teste. Memslap testa taxa de perda de cache entre
0% e 100%. Se você usar este utilitário para testar o desempenho do Schooner Memcached, você
pode especificar um tamanho de janela adequado para obter a taxa de perda de cache esperada. A fórmula para
o cálculo do tamanho da janela é o seguinte:

Suponha que o tamanho da chave seja 128 bytes e o tamanho do valor seja 2048 bytes e
simultaneidade = 128.

1. Cache pequeno cache_size = 1M, 100% de perda de cache (todos os dados são obtidos do SSD). win_size = 10k

2. cache_size = 4G

(1). taxa de perda de cache 0%

win_size = 8k

(2). taxa de perda de cache 5%

win_size = 11k

3. cache_size = 16G

(1). taxa de perda de cache 0%

win_size = 32k

(2) falta de cache

taxa de 5%

win_size = 46k

A fórmula para calcular o tamanho da janela para taxa de falha de cache 0%:

cache_size / simultaneidade / (key_size + value_size) * 0.5

A fórmula para calcular o tamanho da janela para taxa de falha de cache 5%:

cache_size / simultaneidade / (key_size + value_size) * 0.7

Verificação
O Memslap testa tanto a verificação de dados quanto a verificação de tempo de expiração. O usuário pode usar
"--verify =" ou "-v" para especificar a proporção de verificação de dados. Em teoria, testa
100% de verificação de dados. O usuário pode usar "--exp_verify =" ou "-e" para especificar a proporção
de verificação de tempo de expiração. Em teoria, ele testa 100% de verificação do tempo de expiração. Especificamos
as opções "--verbose" para obter informações de erro mais detalhadas.

Por exemplo: --exp_verify = 0.01 –verify = 0.1, significa que 1% dos objetos definidos com
expire-time, 10% dos objetos obtidos serão verificados. Se os objetos forem obtidos,
memaslap verificará o tempo de expiração e o valor.

multi-servidores e multi-configuração
Memslap testa vários servidores com base em thread autogerida. Existe uma limitação que
o número de servidores não pode ser maior que o número de threads. Memslap atribui um
thread para lidar com um servidor, pelo menos. O usuário pode usar a opção "--servers =" ou "-s" para
especificar multi-servidores.

Por exemplo:

--servers=10.1.1.1:11211,10.1.1.2:11212,10.1.1.3:11213 --threads=6 --concurrency=36

O comando acima significa que existem 6 threads, com cada thread tendo 6 simultaneidades
e que os threads 0 e 3 lidam com o servidor 0 (10.1.1.1); threads 1 e 4 tratam do servidor 1
(10.1.1.2); e thread 2 e 5 tratam do servidor 2 (10.1.1.3).

Todos os threads e simultaneidades em memaslap são autogeridos.

E memaslap também. O usuário pode iniciar várias instâncias do memaslap. O usuário pode executar
memaslap em diferentes máquinas clientes para se comunicar com o mesmo servidor memcached no
mesmo. Recomenda-se que o usuário inicie diferentes memaslap em diferentes máquinas usando
a mesma configuração.

Execute com executar número modo or tempo modo
O memaslap padrão é executado com o modo de tempo. O tempo de execução padrão é 10 minutos. Se vezes
fora, memaslap sairá. Não especifique o modo numérico de execução e o modo de tempo ao mesmo
Tempo; apenas especifique um.

Por exemplo:

--time = 30s (significa que o teste será executado por 30 segundos.)

--execute_number = 100000 (significa que depois de executar 100000 comandos, o teste será encerrado.)

lixeira estatística INFORMAÇÕES periodicamente.
O usuário pode usar "--stat_freq =" ou "-S" para especificar a frequência.

Por exemplo:

--stat_freq = 20s

Memslap irá despejar as estatísticas dos comandos (obter e definir) na frequência de cada
Segundo 20.

Para obter mais informações sobre o formato das informações estatísticas de despejo, consulte “Formato de
Saída ”seção.

Obtenção múltipla
O usuário pode usar "--division =" ou "-d" para especificar a contagem de chaves multi-get. Memslap por
o padrão obtém apenas com TCP. O Memslap também testa a verificação de dados e o tempo de expiração
verificação para multi-get.

Memslap testa multi-get com TCP e UDP. Por causa da implementação diferente de
o protocolo ASCII e o protocolo binário, existem algumas diferenças entre os dois. Para
o protocolo ASCII, memaslap envia um “multi-get” para o servidor uma vez. Para o binário
protocolo, memaslap envia vários comandos get únicos juntos como "multi-get" para o
servidor.

UDP e TCP
Memslap testa UDP e TCP. Para TCP, memaslap não reconecta o servidor memcached
se as conexões de soquete forem perdidas. Se todas as conexões de soquete forem perdidas ou servidor memcached
travar, o memaslap será encerrado. Se o usuário especificar a opção “--reconnect” quando o soquete
as conexões forem perdidas, ele as reconectará.

O usuário pode usar “--udp” para habilitar o recurso UDP, mas o UDP vem com algumas limitações:

UDP não pode definir dados com mais de 1400 bytes.

UDP não é testado pelo protocolo binário porque o protocolo binário do memcached faz
não testa isso.

UDP não testa a reconexão.

Facebook teste
Defina os dados com TCP e obtenha-os com UDP. Especifique as seguintes opções:

"--facebook --division = 50"

Se você deseja criar milhares de conexões TCP, especifique o

opção "--conn_sock =".

Por exemplo: --facebook --division = 50 --conn_sock = 200

O comando acima significa que memaslap fará o teste do Facebook, cada simultaneidade tem 200
conexões TCP de soquete e um soquete UDP.

Memslap define objetos com o soquete TCP e multi-obtém 50 objetos uma vez com o UDP
tomada.

Se você especificar "--division = 50", o tamanho da chave deve ser inferior a 25 bytes porque o UDP
o tamanho do pacote é 1400 bytes.

réplica teste
Para teste de replicação, o usuário deve especificar pelo menos dois servidores memcached. O usuário pode
use a opção “—rep_write =” para habilitar o recurso.

Por exemplo:

--servers = 10.1.1.1: 11211,10.1.1.2: 11212 –rep_write = 2

O comando acima significa que existem 2 servidores memcached de replicação, memaslap irá definir
objetos para o servidor 0 e servidor 1, obter objetos que são definidos para o servidor 0 antes de
servidor 1, e também obter objetos que são definidos para o servidor 1 antes do servidor 0. Se o servidor 0
travar, o memaslap só obterá objetos do servidor 1. Se o servidor 0 voltar à vida
novamente, memaslap reconectará o servidor 0. Se o servidor 0 e o servidor 1 travarem, memaslap
vai sair.

suportes milhares of TCP conexões
Inicie o memaslap com "--conn_sock =" ou "-n" para habilitar este recurso. Certifique-se de que seu
sistema pode testar abrindo milhares de arquivos e criando milhares de sockets. Contudo,
este recurso não testa a reconexão se os soquetes forem desconectados.

Por exemplo:

--threads = 8 --concurrency = 128 --conn_sock = 128

O comando acima significa que memaslap inicia 8 threads, cada thread tem 16
simultaneidades, cada simultaneidade tem 128 conexões de soquete TCP, e o número total de
As conexões de soquete TCP são 128 * 128 = 16384.

suportes binário protocolo
Inicie o memaslap com as opções "--binary" ou "-B" para habilitar este recurso. Ele testa todos os
recursos acima, exceto UDP, porque o memcached 1.3.3 mais recente não implementa binário
Protocolo UDP.

Por exemplo:

--binário

Como memcached 1.3.3 não implementa o protocolo UDP binário, memaslap não testa UDP.
Além disso, o memcached 1.3.3 não testa multi-get. Se você especificar "--division = 50"
opção, ele apenas envia 50 comandos get juntos como “mulit-get” para o servidor.

CONFIGURAÇÃO ARQUIVO

Esta seção descreve o formato do arquivo de configuração. Por padrão quando não
arquivo de configuração é especificado memaslap lê o padrão localizado em ~ / .memaslap.cnf.

Abaixo está um exemplo de arquivo de configuração:

-------------------------------------------------- -------------------------
#comments devem começar com '#'
#chave
#start_len end_len proporção
#
# intervalo de comprimento da chave de start_len a end_len
#start_len deve ser igual ou maior que 16
#end_len deve ser igual ou menor que 250
#start_len deve ser igual ou maior que end_len
#memaslap irá gerar chaves de acordo com o intervalo de chaves
# proporção: indica as chaves geradas a partir de contas de um intervalo para o total
chaves geradas
#
# example1: intervalo de chave 16 ~ 100 contas para 80%
# intervalo de chaves 101 ~ 200 contas para 10%
# intervalo de chaves 201 ~ 250 contas para 10%
# total deve ser 1 (0.8 + 0.1 + 0.1 = 1)
#
# 16 100 0.8
# 101 200 0.1
# 201 249 0.1
#
# example2: todas as chaves têm 128 bytes
#
# 128 128 1
chave
128 128 1
#valor
#start_len end_len proporção
#
#value length range from start_len a end_len
#start_len deve ser igual ou maior que 1
#end_len deve ser igual ou menor que 1M
#start_len deve ser igual ou maior que end_len
#memaslap irá gerar valores de acordo com a faixa de valores
# proporção: indica os valores gerados a partir de contas de um intervalo para o
valores totais gerados
#
# example1: intervalo de valores 1 ~ 1000 contas para 80%
# intervalo de valores 1001 ~ 10000 contas para 10%
# intervalo de valores 10001 ~ 100000 contas para 10%
# total deve ser 1 (0.8 + 0.1 + 0.1 = 1)
#
# 1 1000 0.8
# 1001 10000 0.1
# 10001 100000 0.1
#
# exemplo2: todos os comprimentos de valor são 128 bytes
#
# 128 128 1
valor
2048 2048 1
#cmd
#cmd_type cmd_proporção
#
#currently memaslap only testss get e set command.
#
#cmd_type
#conjunto 0
#pegue 1
#
#example: definir contas de comando para 50%
# obter contas de comando para 50%
# total deve ser 1 (0.5 + 0.5 = 1)
#
#cmd
# 0 0.5
# 1 0.5
cmd
0 0.1
1.0 0.9

FORMATO OF SAÍDA

No início, memaslap exibe algumas informações de configuração da seguinte maneira:

servidores: 127.0.0.1:11211

contagem de tópicos: 1

simultaneidade: 16

tempo de execução: 20s

tamanho das janelas: 10k

definir proporção: set_prop = 0.10

obter proporção: get_prop = 0.90

Onde
servidores: "servidores"
Os servidores usados ​​por memaslap.

contagem de tópicos
O número de threads com as quais memaslap é executado.

simultaneidade
O número de simultaneidades com as quais o memaslap é executado.

tempo de execução
Quanto tempo para executar o memaslap.

tamanho das janelas
O tamanho da janela de tarefas de cada simultaneidade.

definir proporção
A proporção do comando definido.

obter proporção
A proporção de obter o comando.

O resultado das estatísticas dinâmicas é mais ou menos assim:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Obtenha estatísticas
Digite Tempo (s) Ops TPS (ops / s) Net (M / s) Get_miss Min (us) Max (us)
Avg (us) Std_dev Geo_dist
Período 5 345826 69165 65.3 0 27 2198 203
95.43 177.29
Global 20 1257935 62896 71.8 0 26 3791 224
117.79 192.60

Definir estatísticas
Digite Tempo (s) Ops TPS (ops / s) Net (M / s) Get_miss Min (us) Max (us)
Avg (us) Std_dev Geo_dist
Período 5 38425 7685 7.3 0 42 628 240
88.05 220.21
Global 20 139780 6989 8.0 0 37 3790 253
117.93 224.83

Estatísticas Totais
Digite Tempo (s) Ops TPS (ops / s) Net (M / s) Get_miss Min (us) Max (us)
Avg (us) Std_dev Geo_dist
Período 5 384252 76850 72.5 0 27 2198 207
94.72 181.18
Global 20 1397720 69886 79.7 0 26 3791 227
117.93 195.60
-------------------------------------------------- -------------------------------------------------- -----------------------------

Onde
Obtenha estatísticas
Informações estatísticas do comando get

Definir estatísticas
Informações estatísticas do comando set

Estatísticas Totais
Informações estatísticas dos comandos get e set

de Payback
Resultado dentro de um período

Global
Resultados acumulados

Ops
Operações totais

TPS
Taxa de transferência, operações / segundo

Líquido
A taxa da rede

Get_miss
Quantos objetos não podem ser obtidos

min
O tempo mínimo de resposta

Max
O tempo máximo de resposta

Média:
O tempo médio de resposta

Desv_padrão
Desvio padrão do tempo de resposta

geo_dist
Distribuição geométrica baseada na função exponencial natural

No final, memaslap produzirá algo assim:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Obter estatísticas (1257956 eventos)
Mín: 26
Máx: 3791
Média: 224
Geo: 192.60
Std: 116.23
Dist Log2:
4: 0 10 84490 215345
8: 484890 459823 12543 824
12: 31

Definir estatísticas (139782 eventos)
Mín: 37
Máx: 3790
Média: 253
Geo: 224.84
Std: 116.83
Dist Log2:
4: 0 0 4200 16988
8: 50784 65574 2064 167
12: 5

Estatísticas totais (1397738 eventos)
Mín: 26
Máx: 3791
Média: 227
Geo: 195.60
Std: 116.60
Dist Log2:
4: 0 10 88690 232333
8: 535674 525397 14607 991
12: 36

cmd_get: 1257969
cmd_set: 139785
get_misses: 0
verificar_missos: 0
verificar_failed: 0
expirado_get: 0
não expirado: 0
write_bytes: 242516030
bytes de leitura: 1003702556
objeto_bytes: 152086080
pacote_disorder: 0
pacote_drop: 0
udp_timeout: 0

Tempo de execução: 20.0s Ops: 1397754 TPS: 69817 Net_rate: 59.4M / s
-------------------------------------------------- -------------------------------------------------- -----------------------------

Onde
Obtenha estatísticas
Obtenha estatísticas de tempo de resposta

Definir estatísticas
Definir estatísticas de tempo de resposta

Estatísticas Totais
Ambos obtêm e definem estatísticas de tempo de resposta

min
O tempo de resposta acumulado e mínimo

Max
O tempo de resposta acumulado e máximo

Média
O tempo de resposta acumulado e médio

Std
Desvio padrão do tempo de resposta

Dist. Log2
Distribuição geométrica baseada no logaritmo 2

cmd_get
Comandos de execução total

cmd_set
Total de comandos definidos feitos

get_misses
Quantos objetos não podem ser obtidos do servidor

verificar_missos
Quantos objetos precisam ser verificados, mas não podem obtê-los

verificar_failed
Quantos objetos com valor insistente

expirado_get
Quantos objetos expiraram, mas nós os obtemos

não expirado
Quantos objetos não expiraram, mas não podemos obtê-los

write_bytes
Total de bytes gravados

leitura_bytes
Total de bytes lidos

objeto_bytes
Bytes totais do objeto

pacote_disorder
Quantos pacotes UDP são desordenados

pacote_drop
Quantos pacotes UDP foram perdidos

udp_timeout
Quantas vezes o tempo limite UDP ocorre

Tempo de execução
Tempo total de execução

Ops
Operações totais

TPS
Taxa de transferência, operações / segundo

Taxa_líquida
A taxa média da rede

OPÇÕES

-sim, --servers =
Liste um ou mais servidores para conectar. A contagem de servidores deve ser menor que a contagem de threads.
por exemplo: --servers = localhost: 1234, localhost: 11211

-T, --threads =
Número de threads a serem inicializados, melhor igual aos números da CPU. Padrão 8.

-c, --concurrency =
Número de simultaneidade para simular com carga. Padrão 128.

-n, --conn_sock =
Número de socks TCP por simultaneidade. Padrão 1.

-x, --execute_number =
Número de operações (obter e definir) a serem executadas para o teste fornecido. 1000000 padrão.

-t, --time =
Por quanto tempo o teste deve ser executado, sufixo: s-segundos, m-minutos, h-horas, d-dias, por exemplo:
--time = 2h.

-F, --cfg_cmd =
Carregue o arquivo de configuração para obter a lista de distribuição de comandos, chaves e valores.

-C, --win_size =
Tamanho da janela de tarefas de cada simultaneidade, sufixo: K, M por exemplo: --win_size = 10k. Predefinição
10k.

-X, --fixed_size =
Comprimento fixo do valor.

-dentro, --verify =
A proporção de verificação de data, por exemplo: --verify = 0.01

-d, --division =
Número de chaves para obter uma única vez. Padrão 1, significa obtenção única.

-S, --stat_freq =
Frequência de despejo de informações estatísticas. sufixo: s-segundos, m-minutos, por exemplo:
--resp_freq = 10s.

-e --exp_verify =
A proporção de objetos com tempo de expiração, por exemplo: --exp_verify = 0.01. Padrão não
objeto com tempo de expiração

-ó, --overwrite =
A proporção de objetos precisa ser sobrescrita, por exemplo: - sobrescrever = 0.01. Padrão nunca
sobrescrever o objeto.

-R, --reconectar
Testes de reconexão, quando a conexão for fechada, ela será reconectada.

-U, --udp
Os testes UDP, o memaslap padrão usa TCP, a porta TCP e a porta UDP do servidor devem ser iguais.

-a, --Facebook
Se habilita o recurso de teste do Facebook, defina com TCP e obtenha com UDP.

-B, --binário
Se habilita o protocolo binário. Padrão com protocolo ASCII.

-P, --tps =
Taxa de transferência esperada, sufixo: K, por exemplo: --tps = 10k.

-p, --rep_write =
O primeiro enésimo servidor pode gravar dados, por exemplo: --rep_write = 2.

-b, --verbose
Se ele fornece informações detalhadas quando a verificação falha.

-h, --Socorro
Exiba esta mensagem e saia.

-V, --versão
Exiba a versão do aplicativo e saia.

EXEMPLOS

memaslap -s 127.0.0.1:11211 -S 5s

memaslap -s 127.0.0.1:11211 -t 2m -v 0.2 -e 0.05 -b

memaslap -s 127.0.0.1:11211 -F config -t 2m -w 40k -S 20s -o 0.2

memaslap -s 127.0.0.1:11211 -F configuração -t 2m -T 4 -c 128 -d 20 -P 40k

memaslap -s 127.0.0.1:11211 -F configuração -t 2m -d 50 -a -n 40

memaslap -s 127.0.0.1:11211,127.0.0.1:11212 -F configuração -t 2m

memaslap -s 127.0.0.1:11211,127.0.0.1:11212 -F configuração -t 2m -p 2

EMPRESA

Para obter mais informações, verifique: http://libmemcached.org/

AUTORES

Mingqiang Zhuang[email protegido]> (Tecnologia da Escuna) Brian Aker, <-
[email protegido]>

Use memcaslap online usando serviços onworks.net