memcaslap: en línea en la nube

PROGRAMA:

NOMBRE

memaslap - documentación libmemcached

SINOPSIS

memaslap [opciones]

--ayuda

MEMCACHED_SERVERS

DESCRIPCIÓN

memeslap es una herramienta de generación de carga y evaluación comparativa para servidores memcached. Genera
carga de trabajo configurable como subprocesos, simultaneidad, conexiones, tiempo de ejecución, sobrescritura,
tasa de errores, tamaño de clave, tamaño de valor, proporción de obtención / configuración, rendimiento esperado, etc.
Además, también prueba la verificación de datos, la verificación del tiempo de caducidad, UDP, binario
protocolo, prueba de facebook, prueba de replicación, obtención múltiple y reconexión, etc.

Memaslap gestiona conexiones de red como memcached con libevent. Cada hilo de memaslap
está vinculado con un núcleo de CPU, todos los subprocesos no se comunican entre sí, y hay
Varias conexiones de enchufe en cada hilo. Cada conexión mantiene la distribución del tamaño de la clave,
distribución del tamaño del valor y distribución del comando por sí misma.

Puede especificar servidores a través del bofetada --servidores opción o mediante la variable de entorno
MEMCACHED_SERVERS.

CATEGORIAS

Memslap está desarrollado para los siguientes propósitos:

Gestiona las conexiones de red con libevent de forma asincrónica.

Configure TCP y UDP para utilizar E / S sin bloqueo.

Mejora el paralelismo: mayor rendimiento en entornos de subprocesos múltiples.

Mejora la eficiencia del tiempo: mayor velocidad de procesamiento.

Genera clave y valor de manera más eficiente; distribución del tamaño de la clave y tamaño del valor
La distribución es configurable.

Admite comandos get, multi-get y set; la distribución de comandos es configurable.

Admite tasa de errores controlable y tasa de sobrescritura.

Admite datos y verificación de tiempo de vencimiento.

Soporta información estadística de dumping periódicamente.

Admite miles de conexiones TCP.

Soporta protocolo binario.

Admite prueba de Facebook (configurada con TCP y obtención múltiple con UDP) y prueba de replicación.

DETALLES

Eficaz implementación of red.
Para memaslap, tanto TCP como UDP utilizan E / S de red sin bloqueo. Todos los eventos de la red son
administrado por libevent como memcached. El módulo de red de memaslap es similar a memcached.
Libevent puede garantizar que memaslap pueda manejar la red de manera muy eficiente.

Eficaz implementación of múltiples hilos y concurrencia
Memslap tiene una implementación similar de múltiples subprocesos a memcached. Memslap crea uno
o hilos más autónomos; cada hilo está vinculado con un núcleo de CPU si el sistema prueba
establecer la afinidad del núcleo de la CPU.

Además, cada hilo tiene una liberación para gestionar los eventos de la red; cada hilo
tiene una o más concurrencias autónomas; y cada concurrencia tiene uno o más sockets
conexiones. Todas las concurrencias no se comunican entre sí a pesar de que son
en el mismo hilo.

Memslap puede crear miles de conexiones de socket, y cada concurrencia tiene decenas de
Conexiones de enchufe. Cada concurrencia selecciona aleatoria o secuencialmente un socket
conexión de su grupo de conexiones de socket para que se ejecute, por lo que memaslap puede garantizar cada concurrencia
maneja una conexión de socket en un momento dado. Los usuarios pueden especificar el número de
concurrencia y conexiones de socket de cada concurrencia de acuerdo con su
la carga de trabajo.

Eficaz implementación of la generación de clave y propuesta de
Para mejorar la eficiencia del tiempo y la eficiencia del espacio, memaslap crea un
tabla de caracteres con 10 millones de caracteres. Se generan todos los sufijos de claves y valores
de esta tabla de caracteres aleatorios.

Memslap usa el desplazamiento en la tabla de caracteres y la longitud de la cadena para identificar un
cuerda. Puede ahorrar mucha memoria. Cada clave contiene dos partes, un prefijo y un sufijo. El
El prefijo es un uint64_t, 8 bytes. Para verificar el conjunto de datos antes, memaslap necesita
asegúrese de que cada clave sea única, por lo que utiliza el prefijo para identificar una clave. El prefijo no puede
incluir caracteres ilegales, como 'r', 'n', '0' y ''. Y memaslap tiene un algoritmo
para asegurar eso.

Memslap no genera todos los objetos (pares clave-valor) al principio. Sólo
genera suficientes objetos para llenar la ventana de tareas (objetos por defecto de 10K) de cada
concurrencia. Cada objeto tiene la siguiente información básica, prefijo de clave, sufijo de clave
desplazamiento en la tabla de caracteres, longitud de la clave, desplazamiento de valor en la tabla de caracteres y valor
longitud.

En el proceso de trabajo, cada concurrencia selecciona secuencial o aleatoriamente un objeto del
ventana para realizar la operación de configuración u obtener la operación. Al mismo tiempo, cada concurrencia comienza
objetos fuera de su ventana y agrega un nuevo objeto en ella.

sencillos pero eficiente tarea programación
Memslap usa libevent para programar todas las concurrencias de subprocesos y cada concurrencia
programa las tareas en función de la ventana de tareas local. Memslap asume que si cada concurrencia
mantiene la misma distribución de claves, distribución de valor y distribución de comandos, desde
en el exterior, memaslap mantiene toda la distribución en su conjunto. Cada ventana de tarea incluye mucho
de objetos, cada objeto almacena su información básica, como la clave, el valor, el tiempo de caducidad y
pronto. En cualquier momento, todos los objetos de la ventana mantienen la misma clave y valor fijos
distribución. Si se sobrescribe un objeto, el valor del objeto se actualizará.
Memslap verifica los datos o el tiempo de caducidad de acuerdo con la información del objeto almacenada en el
ventana de tareas.

Libevent selecciona qué simultaneidad manejar en función de un evento de red específico. Entonces la
La concurrencia selecciona qué comando (obtener o establecer) operar según el comando
distribución. Si necesita expulsar un objeto antiguo y agregar un objeto nuevo, para mantener
la misma clave y distribución de valor, el nuevo objeto debe tener la misma longitud de clave y
longitud del valor.

Si el servidor memcached tiene dos capas de caché (memoria y SSD), ejecutar memaslap con diferentes
los tamaños de ventana pueden obtener diferentes tasas de pérdida de caché. Si memaslap agrega suficientes objetos en el
Windows al principio, y el caché de memcached no puede almacenar todos los objetos
inicializado, memaslap obtendrá algunos objetos de la segunda capa de caché. Causa
la primera capa de caché que se pierde. Entonces el usuario puede especificar el tamaño de la ventana para obtener el esperado
tasa de errores de la primera capa de caché.

Conveniente implementación of multi-servidores , UDP, TCP, obtención múltiple y binario protocolo
Debido a que cada subproceso se autogobierna, memaslap puede asignar diferentes subprocesos para manejar
diferentes servidores memcached. Esta es solo una de las formas en que memaslap prueba múltiples
servidores. La única limitación es que el número de servidores no puede ser mayor que el
Número de hilos. La otra forma de probar varios servidores es mediante la prueba de replicación. Cada
La concurrencia tiene una conexión de socket para cada servidor Memcached. Para la implementación,
memaslap puede establecer algunos objetos en un servidor memcached y obtener estos objetos del
otros servidores.

De forma predeterminada, Memslap solo obtiene. Si el usuario especifica la opción de obtención múltiple, memaslap
recopile suficientes comandos get y empaque y envíe los comandos juntos.

Memslap prueba tanto el protocolo ASCII como el protocolo binario, pero se ejecuta en ASCII.
protocolo por defecto. Memslap se ejecuta de forma predeterminada en el protocolo TCP, pero también prueba UDP.
Debido a que UDP no es confiable, pueden ocurrir paquetes caídos y paquetes fuera de servicio. Memslap
crea un búfer de memoria para manejar estos problemas. Memslap intenta leer toda la respuesta
datos de un comando del servidor y reordena los datos de respuesta. Si algunos paquetes obtienen
perdido, el mecanismo de tiempo de espera puede garantizar que los paquetes a medio hornear se desechen y
se enviará el siguiente comando.

USO

A continuación se muestran algunos ejemplos 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 config -t 2m -T 4 -c 128 -d 20 -P 40k

memaslap -s 127.0.0.1:11211 -F config -t 2m -d 50 -a -n 40

memaslap -s 127.0.0.1:11211,127.0.0.1:11212 -F configuración -t 2m

memaslap -s 127.0.0.1:11211,127.0.0.1:11212 -F config -t 2m -p 2

El usuario debe especificar un servidor al menos para ejecutar memaslap. El resto de los parámetros tienen
valores predeterminados, como se muestra a continuación:

Número de hilo = 1 Simultaneidad = 16

Tiempo de ejecución = 600 segundos Archivo de configuración = NULL

Tamaño de la clave = 64 Tamaño del valor = 1024

Obtener / configurar = 9: 1 Tamaño de ventana = 10k

Ejecutar número = 0 Single get = true

Multi-get = false Número de sockets de cada concurrencia = 1

Reconectar = falso Verificación de datos = falso

Verificación de tiempo de expiración = falso protocolo ASCII = verdadero

Protocolo binario = información estadística de dumping falsa

periódicamente = falso

Proporción de sobrescritura = 0% UDP = falso

TCP = verdadero Límite de rendimiento = falso

Prueba de Facebook = falso Prueba de replicación = falso

Clave tamaño, propuesta de tamaño y comando distribución.
Todas las distribuciones se leen del archivo de configuración especificado por el usuario con
Opción “—cfg_cmd”. Si el usuario no especifica un archivo de configuración, memaslap se ejecutará
con la distribución predeterminada (tamaño de clave = 64, tamaño de valor = 1024, get / set = 9: 1). Para
información sobre cómo editar el archivo de configuración, consulte el "Archivo de configuración"
.

El tamaño mínimo de la clave es de 16 bytes; el tamaño máximo de la clave es 250 bytes. La precisión de
la proporción es 0.001. La proporción de distribución se redondeará a 3 decimales.

El tamaño mínimo del valor es 1 bytes; el tamaño máximo del valor es 1 M bytes. La precisión de
la proporción es 0.001. La proporción de distribución se redondeará a 3 decimales.
Actualmente, memaslap solo prueba los comandos set y get. Y prueba el 100% de fraguado y el 100% de obtención.
Para obtener el 100%, preestablecerá algunos objetos en el servidor.

Multihilo y concurrencia
El alto rendimiento de memaslap se beneficia del programa especial de hilo y
concurrencia. Es importante especificar el número adecuado de ellos. El número predeterminado de
subprocesos es 1; el número predeterminado de simultaneidad es 16. El usuario puede usar "—hilos" y
“--Concurrencia” para especificar estas variables.

Si el sistema prueba la configuración de la afinidad de la CPU y el número de subprocesos especificado por el usuario
es mayor que 1, memaslap intentará vincular cada hilo a un núcleo de CPU diferente. Así que si
desea obtener el mejor rendimiento memaslap, es mejor especificar el número de
hilo igual al número de núcleos de CPU. El número de subprocesos especificado por el usuario puede
también sea menor o mayor que el número de núcleos de CPU. Debido a la limitación de
implementación, el número de concurrencias podría ser el múltiplo del número de
roscas.

1. Para sistema de 8 núcleos de CPU

Por ejemplo:

--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 ejemplo:

--threads = 8 --concurrency = 128

--threads = 16 --concurrency = 256

--threads = 16 --concurrency = 512

--threads = 24 --concurrency = 288

Memaslap funciona muy bien cuando se utiliza para probar el rendimiento de los servidores memcached.
La mayoría de las veces, el cuello de botella es la red o el servidor. Si por alguna razón el usuario
quiere limitar el rendimiento de memaslap, hay dos formas de hacerlo:

Disminuya el número de subprocesos y simultaneidad. Utilice la opción "--tps" que memaslap
proporciona para limitar el rendimiento. Esta opción permite al usuario obtener el esperado
rendimiento. Por ejemplo, suponga que el rendimiento máximo es de 50 kops / s para un
configuración, puede especificar el rendimiento igual o menor que el rendimiento máximo
usando la opción "--tps".

Ventana tamaño
La mayoría de las veces, el usuario no necesita especificar el tamaño de la ventana. La ventana predeterminada
el tamaño es 10k. Para Schooner Memcached, el usuario puede especificar diferentes tamaños de ventana para obtener
diferentes tasas de pérdida de caché según el caso de prueba. Memslap prueba la tasa de errores de caché entre
0% y 100%. Si utiliza esta utilidad para probar el rendimiento de Schooner Memcached,
puede especificar un tamaño de ventana adecuado para obtener la tasa de errores de caché esperada. La fórmula para
el cálculo del tamaño de la ventana es el siguiente:

Suponga que el tamaño de la clave es de 128 bytes y el tamaño del valor es de 2048 bytes, y
concurrencia = 128.

1. Caché pequeño cache_size = 1M, 100% de falta de caché (todos los datos se obtienen de SSD). win_size = 10k

2. tamaño_caché = 4G

(1). tasa de fallos de caché 0%

win_size = 8k

(2). tasa de fallos de caché 5%

win_size = 11k

3. tamaño_caché = 16G

(1). tasa de fallos de caché 0%

win_size = 32k

(2). perdida de caché

tasa 5%

win_size = 46k

La fórmula para calcular el tamaño de la ventana para la tasa de errores de caché 0%:

tamaño_caché / concurrencia / (tamaño_clave + tamaño_valor) * 0.5

La fórmula para calcular el tamaño de la ventana para la tasa de errores de caché 5%:

tamaño_caché / concurrencia / (tamaño_clave + tamaño_valor) * 0.7

Verificación
Memslap prueba tanto la verificación de datos como la verificación del tiempo de vencimiento. El usuario puede utilizar
"--verify =" o "-v" para especificar la proporción de verificación de datos. En teoría, prueba
Verificación de datos al 100%. El usuario puede utilizar "--exp_verify =" o "-e" para especificar la proporción
de verificación de tiempo de vencimiento. En teoría, prueba la verificación del tiempo de vencimiento al 100%. Especificar
las opciones "--verbose" para obtener información de error más detallada.

Por ejemplo: --exp_verify = 0.01 –verify = 0.1, significa que el 1% de los objetos configurados con
expire-time, se verificará el 10% de los objetos obtenidos. Si se consiguen los objetos,
memaslap verificará el tiempo de vencimiento y el valor.

multi-servidores y multi-configuración
Memslap prueba varios servidores basados ​​en subprocesos autogobernados. Hay una limitación que
el número de servidores no puede ser mayor que el número de subprocesos. Memslap asigna uno
hilo para manejar un servidor al menos. El usuario puede utilizar la opción "--servers =" o "-s" para
especificar servidores múltiples.

Por ejemplo:

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

El comando anterior significa que hay 6 subprocesos, y cada subproceso tiene 6 concurrencias
y que los subprocesos 0 y 3 manejan el servidor 0 (10.1.1.1); los hilos 1 y 4 manejan el servidor 1
(10.1.1.2); y el hilo 2 y 5 manejan el servidor 2 (10.1.1.3).

Todos los hilos y concurrencias en memaslap son autónomos.

También lo es memaslap. El usuario puede iniciar varias instancias de memaslap. El usuario puede ejecutar
memaslap en diferentes máquinas cliente para comunicarse con el mismo servidor memcached en el
mismo. Se recomienda que el usuario inicie diferentes memaslap en diferentes máquinas usando
la misma configuración.

Ejecutar ejecutar número modo or equipo modo
El memaslap predeterminado se ejecuta con el modo de tiempo. El tiempo de ejecución predeterminado es de 10 minutos. Si es tiempo
out, memaslap saldrá. No especifique al mismo tiempo el modo numérico de ejecución y el modo de tiempo
hora; solo especifique uno en su lugar.

Por ejemplo:

--time = 30s (significa que la prueba durará 30 segundos).

--execute_number = 100000 (Significa que después de ejecutar 100000 comandos, la prueba se cerrará).

vertedero estadística información periódicamente
El usuario puede utilizar "--stat_freq =" o "-S" para especificar la frecuencia.

Por ejemplo:

--stat_freq = 20 s

Memslap volcará las estadísticas de los comandos (get y set) con la frecuencia de cada
20 segundos.

Para obtener más información sobre el formato de la información estadística de vertido, consulte "Formato de
Salida ”sección.

Multi-obtener
El usuario puede usar "--division =" o "-d" para especificar el recuento de claves de obtención múltiple. Memslap por
por defecto hace single get con TCP. Memslap también prueba la verificación de datos y el tiempo de caducidad
verificación para multi-get.

Memslap realiza pruebas de obtención múltiple con TCP y UDP. Debido a la diferente implementación de
el protocolo ASCII y el protocolo binario, existen algunas diferencias entre los dos. Para
el protocolo ASCII, memaslap envía un "multi-get" al servidor una vez. Para el binario
protocolo, memaslap envía varios comandos get únicos juntos como "multi-get" al
servidor.

UDP y TCP
Memslap prueba tanto UDP como TCP. Para TCP, memaslap no vuelve a conectar el servidor memcached
si se pierden las conexiones del enchufe. Si todas las conexiones de socket se pierden o el servidor memcached
se bloquea, memaslap saldrá. Si el usuario especifica la opción "--reconnect" cuando el socket
las conexiones se pierden, las volverá a conectar.

El usuario puede usar "--udp" para habilitar la función UDP, pero UDP tiene algunas limitaciones:

UDP no puede configurar datos de más de 1400 bytes.

El protocolo binario no prueba UDP porque el protocolo binario de memcached no
no prueba eso.

UDP no prueba la reconexión.

Facebook test
Establezca datos con TCP y obtenga múltiples datos con UDP. Especifique las siguientes opciones:

"--facebook --division = 50"

Si desea crear miles de conexiones TCP, especifique el

Opción "--conn_sock =".

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

El comando anterior significa que memaslap hará la prueba de Facebook, cada concurrencia tiene 200
conexiones TCP de socket y un socket UDP.

Memslap establece objetos con el socket TCP y obtiene 50 objetos múltiples una vez con el UDP
enchufe.

Si especifica "--division = 50", el tamaño de la clave debe ser inferior a 25 bytes porque el UDP
el tamaño del paquete es de 1400 bytes.

Replicación test
Para la prueba de replicación, el usuario debe especificar al menos dos servidores memcached. El usuario puede
use la opción “—rep_write =” para habilitar la función.

Por ejemplo:

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

El comando anterior significa que hay 2 servidores memcached de replicación, memaslap establecerá
objetos tanto en el servidor 0 como en el servidor 1, obtenga los objetos que se establecieron en el servidor 0 antes de
servidor 1, y también obtener objetos que están configurados en el servidor 1 antes del servidor 0. Si el servidor 0
se bloquea, memaslap solo obtendrá objetos del servidor 1. Si el servidor 0 vuelve a la vida
de nuevo, memaslap volverá a conectar el servidor 0. Si tanto el servidor 0 como el servidor 1 fallan, memaslap
saldrá

soportes miles of TCP personales
Inicie memaslap con "--conn_sock =" o "-n" para habilitar esta función. Asegúrate de que tu
El sistema puede probar abriendo miles de archivos y creando miles de sockets. Sin embargo,
esta función no prueba la reconexión si los enchufes se desconectan.

Por ejemplo:

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

El comando anterior significa que memaslap inicia 8 hilos, cada hilo tiene 16
concurrencias, cada concurrencia tiene 128 conexiones de socket TCP, y el número total de
Las conexiones de socket TCP son 128 * 128 = 16384.

soportes binario protocolo
Inicie memaslap con las opciones "--binary" o "-B" para habilitar esta función. Prueba todos los
características anteriores excepto UDP, porque el último Memcached 1.3.3 no implementa binario
Protocolo UDP.

Por ejemplo:

--binario

Dado que memcached 1.3.3 no implementa el protocolo UDP binario, memaslap no prueba UDP.
Además, memcached 1.3.3 no prueba multi-get. Si especifica "--division = 50"
opción, solo envía 50 comandos get juntos como "mulit-get" al servidor.

CONFIGURACIÓN ARCHIVO

Esta sección describe el formato del archivo de configuración. Por defecto cuando no
se especifica el archivo de configuración memaslap lee el predeterminado ubicado en ~ / .memaslap.cnf.

A continuación se muestra un archivo de configuración de muestra:

-------------------------------------------------- -------------------------
#comentarios deben comenzar con '#'
#llave
#start_len end_len proporción
#
# rango de longitud de clave desde start_len hasta end_len
#start_len debe ser igual o superior a 16
#end_len debe ser igual o menor que 250
#start_len debe ser igual o mayor que end_len
#memaslap generará claves de acuerdo con el rango de claves
#proporción: indica las claves generadas a partir de un rango de cuentas para el total
claves generadas
#
# example1: el rango de claves 16 ~ 100 representa el 80%
# el rango de teclas 101 ~ 200 representa el 10%
# el rango de teclas 201 ~ 250 representa el 10%
# total debe ser 1 (0.8 + 0.1 + 0.1 = 1)
#
# 16 100 0.8
# 101 200 0.1
# 201 249 0.1
#
# example2: la longitud de todas las claves es de 128 bytes
#
# 128 128 1
clave
128 128 1
#valor
#start_len end_len proporción
#
#valor rango de longitud desde start_len hasta end_len
#start_len debe ser igual o superior a 1
#end_len debe ser igual o menor que 1 M
#start_len debe ser igual o mayor que end_len
#memaslap generará valores de acuerdo con el rango de valores
#proporción: indica los valores generados a partir de un rango de cuentas para el
valores totales generados
#
# ejemplo1: el rango de valores 1 ~ 1000 representa el 80%
# rango de valores 1001 ~ 10000 representa el 10%
# rango de valores 10001 ~ 100000 representa el 10%
# total debe ser 1 (0.8 + 0.1 + 0.1 = 1)
#
# 1 1000 0.8
# 1001 10000 0.1
# 10001 100000 0.1
#
# ejemplo2: todas las longitudes de los valores son 128 bytes
#
# 128 128 1
propuesta de
2048 2048 1
#cmd
#cmd_type cmd_proporción
#
#actualmente memaslap solo prueba el comando get y set.
#
#cmd_tipo
#conjunto 0
#obtener 1
#
#ejemplo: establecer cuentas de comando al 50%
# obtener cuentas de comando al 50%
# total debe ser 1 (0.5 + 0.5 = 1)
#
#cmd
N.º 0 0.5
N.º 1 0.5
cmd
0 0.1
1.0 0.9

FORMATO OF SALIDA

Al principio, memaslap muestra información de configuración de la siguiente manera:

servidores: 127.0.0.1:11211

número de hilos: 1

concurrencia: 16

tiempo de ejecución: 20 s

tamaño de las ventanas: 10k

proporción establecida: set_prop = 0.10

obtener proporción: get_prop = 0.90

Dónde
servidores: "servidores"
Los servidores utilizados por memaslap.

recuento de hilos
El número de subprocesos con los que se ejecuta memaslap.

concurrencia
El número de concurrencias con las que se ejecuta memaslap.

tiempo de ejecución
Cuánto tiempo debe ejecutarse memaslap.

tamaño de las ventanas
El tamaño de la ventana de tareas de cada simultaneidad.

establecer proporción
La proporción de comando establecido.

obtener proporción
La proporción de obtener el mando.

La salida de estadísticas dinámicas es algo como esto:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Obtener estadísticas
Tipo Tiempo (s) Ops TPS (ops / s) Neto (M / s) Get_miss Min (us) Max (us)
Promedio (EE. UU.) Std_dev Geo_dist
Periodo 5 345826 69165 65.3 0 27 2198
95.43 177.29
Global 20 1257935 62896 71.8 0 26 3791
117.79 192.60

Establecer estadísticas
Tipo Tiempo (s) Ops TPS (ops / s) Neto (M / s) Get_miss Min (us) Max (us)
Promedio (EE. UU.) Std_dev Geo_dist
Periodo 5 38425 7685 7.3 0 42 628
88.05 220.21
Global 20 139780 6989 8.0 0 37 3790
117.93 224.83

Estadísticas totales
Tipo Tiempo (s) Ops TPS (ops / s) Neto (M / s) Get_miss Min (us) Max (us)
Promedio (EE. UU.) Std_dev Geo_dist
Periodo 5 384252 76850 72.5 0 27 2198
94.72 181.18
Global 20 1397720 69886 79.7 0 26 3791
117.93 195.60
-------------------------------------------------- -------------------------------------------------- -----------------------------

Dónde
Obtener estadísticas
Información estadística del comando get

Establecer estadísticas
Información estadística del comando set

Estadísticas totales
Información estadística del comando get y set

periodo
Resultado dentro de un período

Buscar
Resultados acumulados

ops
Operaciones totales

TPS
Rendimiento, operaciones / segundo

Red
La tasa de red

obtener_miss
Cuantos objetos no se pueden conseguir

Min
El tiempo mínimo de respuesta

Max
El tiempo máximo de respuesta

Avg:
El tiempo medio de respuesta

std_dev
Desviación estándar del tiempo de respuesta

Dist_geo
Distribución geométrica basada en la función exponencial natural

Al final, memaslap generará algo como esto:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Obtener estadísticas (1257956 eventos)
Mín .: 26
Max: 3791
Promedio: 224
Geografía: 192.60
Estándar: 116.23
Dist Log2:
4: 0 10 84490 215345
8: 484890 459823 12543 824
12: 31

Establecer estadísticas (139782 eventos)
Mín .: 37
Max: 3790
Promedio: 253
Geografía: 224.84
Estándar: 116.83
Dist Log2:
4: 0 0 4200 16988
8: 50784 65574 2064 167
12: 5

Estadísticas totales (1397738 eventos)
Mín .: 26
Max: 3791
Promedio: 227
Geografía: 195.60
Estándar: 116.60
Dist Log2:
4: 0 10 88690 232333
8: 535674 525397 14607 991
12: 36

cmd_get: 1257969
conjunto_cmd: 139785
get_misses: 0
Verificar_misses: 0
verificar_fallido: 0
caducado_obtener: 0
inexpired_unget: 0
bytes_escritos: 242516030
leer_bytes: 1003702556
objeto_bytes: 152086080
paquete_desorden: 0
caída_paquete: 0
udp_tiempo de espera: 0

Tiempo de ejecución: 20.0 s Operaciones: 1397754 TPS: 69817 Tasa_neta: 59.4 M / s
-------------------------------------------------- -------------------------------------------------- -----------------------------

Dónde
Obtener estadísticas
Obtenga estadísticas de tiempo de respuesta

Establecer estadísticas
Establecer estadísticas de tiempo de respuesta

Estadísticas totales
Ambos obtienen y establecen estadísticas de tiempo de respuesta

Min
El tiempo de respuesta mínimo y acumulado

Max
El tiempo de respuesta acumulado y máximo.

Promedio
El tiempo de respuesta acumulado y promedio.

Horas
Desviación estándar del tiempo de respuesta

Dist Log2
Distribución geométrica basada en el logaritmo 2

cmd_get
Total de comandos terminados

conjunto_cmd
Comandos de conjunto total realizados

get_misses
¿Cuántos objetos no se pueden obtener del servidor?

verificar_misses
Cuántos objetos necesitan verificar pero no pueden obtenerlos

verificar_fallido
Cuantos objetos con valor insistente

expirado_get
Cuántos objetos están caducados pero los obtenemos

inexpired_unget
¿Cuántos objetos no han caducado pero no podemos obtenerlos?

bytes_escritos
Total de bytes escritos

leer_bytes
Total de bytes leídos

objeto_bytes
Bytes totales del objeto

desorden_paquete
¿Cuántos paquetes UDP son desorden?

paquete_drop
Cuántos paquetes UDP se pierden

udp_tiempo de espera
Cuántas veces se agota el tiempo de espera de UDP

Tiempo de ejecución
Tiempo de ejecución total

ops
Operaciones totales

TPS
Rendimiento, operaciones / segundo

Tasa neta
La tasa promedio de red

CAMPUS

-s, --servers =
Enumere uno o más servidores para conectarse. El recuento de servidores debe ser menor que el recuento de subprocesos.
por ejemplo: --servers = localhost: 1234, localhost: 11211

-T, --threads =
Número de subprocesos para iniciar, mejor igual al número de CPU. Por defecto 8.

-C, --concurrencia =
Número de simultaneidad a simular con carga. Por defecto 128.

-norte, --conn_sock =
Número de socks TCP por concurrencia. Predeterminado 1.

-X, --execute_number =
Número de operaciones (obtener y establecer) a ejecutar para la prueba dada. Por defecto 1000000.

-t, --time =
Cuánto tiempo debe ejecutarse la prueba, sufijo: s-segundos, m-minutos, h-horas, d-días, por ejemplo:
--tiempo = 2h.

-F, --cfg_cmd =
Cargue el archivo de configuración para obtener la lista de distribución de comandos, claves y valores.

-w, --win_size =
Tamaño de la ventana de tareas de cada simultaneidad, sufijo: K, M, por ejemplo: --win_size = 10k. Defecto
10k.

-X, --fixed_size =
Longitud fija de valor.

-v, --verify =
La proporción de verificación de fecha, por ejemplo: --verify = 0.01

-D, --division =
Número de claves para obtener varias veces una vez. Predeterminado 1, significa obtención única.

-S, --stat_freq =
Frecuencia de información estadística sobre dumping. sufijo: s-segundos, m-minutos, por ejemplo:
--resp_freq = 10 segundos.

-mi, --exp_verify =
La proporción de objetos con tiempo de caducidad, por ejemplo: --exp_verify = 0.01. No predeterminado
objeto con tiempo de expiración

-Oh, --overwrite =
La proporción de objetos necesita sobrescribir, por ejemplo: --overwrite = 0.01. Por defecto nunca
sobrescribir objeto.

-R, --reconectar
Vuelva a conectar las pruebas, cuando se cierre la conexión se volverá a conectar.

-U, --udp
Pruebas UDP, memaslap predeterminado usa TCP, el puerto TCP y el puerto UDP del servidor deben ser iguales.

-a, --Facebook
Ya sea que habilite la función de prueba de Facebook, configurado con TCP y multi-get con UDP.

-B, --binario
Si habilita el protocolo binario. Por defecto con protocolo ASCII.

-PAG, --tps =
Rendimiento esperado, sufijo: K, por ejemplo: --tps = 10k.

-pag, --rep_write =
Los primeros servidores n pueden escribir datos, por ejemplo: --rep_write = 2.

-b, --verboso
Si genera información detallada cuando falla la verificación.

-h, --ayuda
Muestre este mensaje y luego salga.

-V, --versión
Muestre la versión de la aplicación y luego salga.

EJEMPLOS

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 config -t 2m -T 4 -c 128 -d 20 -P 40k

memaslap -s 127.0.0.1:11211 -F config -t 2m -d 50 -a -n 40

memaslap -s 127.0.0.1:11211,127.0.0.1:11212 -F configuración -t 2m

memaslap -s 127.0.0.1:11211,127.0.0.1:11212 -F config -t 2m -p 2

INICIO

Para obtener más información, consulte: http://libmemcached.org/

AUTORES

Mingqiang Zhuang[email protected]> (Tecnología de la goleta) Brian Aker, <-
[email protected]>

Utilice memcaslap en línea utilizando los servicios de onworks.net