memcaslap - En ligne dans le Cloud

PROGRAMME:

Nom

memaslap - Documentation libmemcached

SYNOPSIS

memaslap [options]

--Aidez-moi

MEMCACHED_SERVERS

DESCRIPTION

memaslap est un outil de génération de charge et de référence pour les serveurs memcached. Il génère
charge de travail configurable telle que les threads, les accès concurrents, les connexions, le temps d'exécution, l'écrasement,
taux d'échec, taille de clé, taille de valeur, proportion get/set, débit attendu, etc.
En outre, il teste également la vérification des données, la vérification du délai d'expiration, UDP, binaire
protocole, test facebook, test de réplication, multi-get et reconnexion, etc.

Memaslap gère les connexions réseau comme memcached avec libevent. Chaque fil de memaslap
est lié à un cœur de processeur, tous les threads ne communiquent pas entre eux, et il y a
plusieurs connexions socket dans chaque thread. Chaque connexion conserve la distribution de la taille des clés,
distribution de taille de valeur et distribution de commande par elle-même.

Vous pouvez spécifier des serveurs via le gifle --les serveurs option ou via la variable d'environnement
MEMCACHED_SERVERS.

CARACTERISTIQUES

Memslap est développé aux fins suivantes :

Gère les connexions réseau avec libevent de manière asynchrone.

Configurez TCP et UDP pour utiliser des E/S non bloquantes.

Améliore le parallélisme : performances supérieures dans les environnements multi-threads.

Améliore l'efficacité du temps : vitesse de traitement plus rapide.

Génère la clé et la valeur plus efficacement ; distribution de la taille des clés et taille de la valeur
distribution sont configurables.

Prend en charge les commandes get, multi-get et set ; la distribution des commandes est configurable.

Prend en charge le taux d'échec et le taux d'écrasement contrôlables.

Prend en charge la vérification des données et de l'heure d'expiration.

Prend en charge le vidage périodique des informations statistiques.

Prend en charge des milliers de connexions TCP.

Prend en charge le protocole binaire.

Prend en charge le test facebook (défini avec TCP et multi-get avec UDP) et le test de réplication.

DÉTAILS

Efficace la mise en oeuvre of réseau.
Pour memaslap, TCP et UDP utilisent des E/S réseau non bloquantes. Tous les événements du réseau sont
géré par libevent comme memcached. Le module réseau de memaslap est similaire à memcached.
Libevent peut garantir que memaslap peut gérer le réseau très efficacement.

Efficace la mise en oeuvre of multi-threads ainsi que concurrence
Memslap a une implémentation similaire de multi-threads à memcached. Memslap en crée un
ou plusieurs threads autonomes ; chaque thread est lié à un cœur de processeur si le système teste
définir l'affinité du cœur du processeur.

De plus, chaque thread dispose d'un libevent pour gérer les événements du réseau ; chaque fil
a une ou plusieurs concurrences autonomes ; et chaque simultanéité a un ou plusieurs socket
Connexions. Toutes les simultanéités ne communiquent pas entre elles même si elles sont
dans le même fil.

Memslap peut créer des milliers de connexions socket, et chaque simultanéité a des dizaines de
connexions de prise. Chaque simultanéité sélectionne aléatoirement ou séquentiellement un socket
connexion à partir de son pool de connexions socket à exécuter, afin que memaslap puisse assurer chaque simultanéité
gère une connexion socket à un moment donné. Les utilisateurs peuvent spécifier le nombre de
connexions simultanées et socket de chaque simultanéité en fonction de leur
charge de travail.

Efficace la mise en oeuvre of générateur key ainsi que Plus-value
Afin d'améliorer l'efficacité du temps et l'efficacité de l'espace, memaslap crée un
table de caractères avec 10M caractères. Tous les suffixes des clés et des valeurs sont générés
de cette table de caractères aléatoires.

Memslap utilise le décalage dans la table de caractères et la longueur de la chaîne pour identifier un
chaîne de caractères. Cela peut économiser beaucoup de mémoire. Chaque clé contient deux parties, un préfixe et un suffixe. Les
le préfixe est un uint64_t, 8 octets. Afin de vérifier l'ensemble de données avant, memaslap doit
assurez-vous que chaque clé est unique, il utilise donc le préfixe pour identifier une clé. Le préfixe ne peut
inclure des caractères illégaux, tels que 'r', 'n', '0' et ' '. Et memaslap a un algorithme
pour être sur de.

Memslap ne génère pas tous les objets (paires clé-valeur) au début. C'est seulement
génère suffisamment d'objets pour remplir la fenêtre de tâche (par défaut 10K objets) de chaque
concurrence. Chaque objet a les informations de base suivantes, le préfixe de clé, le suffixe de clé
décalage dans la table de caractères, longueur de clé, décalage de valeur dans la table de caractères et valeur
longueur.

Dans le processus de travail, chaque concurrence sélectionne de manière séquentielle ou aléatoire un objet dans le
fenêtre pour effectuer une opération de définition ou obtenir une opération. En même temps, chaque concurrence
objets hors de sa fenêtre et y ajoute un nouvel objet.

étapes mais incontournable tâche ordonnancement
Memslap utilise libevent pour planifier toutes les simultanéités de threads, et chaque simultanéité
planifie les tâches en fonction de la fenêtre de tâche locale. Memslap suppose que si chaque concurrence
conserve la même distribution de clé, distribution de valeur et distribution de commandes, de
à l'extérieur, memaslap conserve toute la distribution dans son ensemble. Chaque fenêtre de tâche comprend beaucoup
d'objets, chaque objet stocke ses informations de base, telles que la clé, la valeur, l'heure d'expiration et
bientôt. A tout moment, tous les objets de la fenêtre conservent la même clé et la même valeur fixes
Distribution. Si un objet est écrasé, la valeur de l'objet sera mise à jour.
Memslap vérifie les données ou le délai d'expiration en fonction des informations sur l'objet stockées dans le
fenêtre de tâche.

Libevent sélectionne la simultanéité à gérer en fonction d'un événement réseau spécifique. Puis le
la concurrence sélectionne la commande (get ou set) à exécuter en fonction de la commande
Distribution. S'il doit supprimer un ancien objet et ajouter un nouvel objet, afin de conserver
la même distribution de clé et de valeur, le nouvel objet doit avoir la même longueur de clé et
longueur de la valeur.

Si le serveur memcached a deux couches de cache (mémoire et SSD), exécutez memaslap avec différents
les tailles de fenêtre peuvent obtenir différents taux d'échec du cache. Si memaslap ajoute suffisamment d'objets dans le
windows au début, et le cache de memcached ne peut pas stocker tous les objets
initialisé, alors memaslap obtiendra des objets de la deuxième couche de cache. Cela implique
la première couche de cache à manquer. Ainsi, l'utilisateur peut spécifier la taille de la fenêtre pour obtenir le résultat attendu
taux d'échec de la première couche de cache.

Information la mise en oeuvre of multi-serveurs , UDP, TCP, multi-obtenir ainsi que binaire protocole
Parce que chaque thread est autogéré, memaslap peut affecter différents threads à gérer
différents serveurs memcached. Ce n'est qu'une des façons dont memaslap teste plusieurs
les serveurs. La seule limitation est que le nombre de serveurs ne peut pas être supérieur au
le nombre de fils. L'autre façon de tester plusieurs serveurs est le test de réplication. Chaque
la concurrence a une connexion socket à chaque serveur memcached. Pour la mise en oeuvre,
memaslap peut définir certains objets sur un serveur memcached et obtenir ces objets à partir du
autres serveurs.

Par défaut, Memslap n'obtient qu'une seule fois. Si l'utilisateur spécifie l'option multi-get, memaslap
collecter suffisamment de commandes get et emballer et envoyer les commandes ensemble.

Memslap teste à la fois le protocole ASCII et le protocole binaire, mais il s'exécute sur l'ASCII
protocole par défaut. Memslap fonctionne par défaut sur le protocole TCP, mais il teste également UDP.
Comme UDP n'est pas fiable, des packages abandonnés et des packages hors service peuvent se produire. memslap
crée une mémoire tampon pour gérer ces problèmes. Memslap essaie de lire toute la réponse
données d'une commande du serveur et réorganise les données de réponse. Si certains paquets obtiennent
perdu, le mécanisme de délai d'attente peut garantir que les paquets à moitié cuits seront jetés et
la prochaine commande sera envoyée.

UTILISATION

Voici quelques exemples d'utilisation :

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 config -t 2m

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

L'utilisateur doit spécifier au moins un serveur pour exécuter memaslap. Le reste des paramètres a
valeurs par défaut, comme indiqué ci-dessous :

Numéro de thread = 1 Concurrence = 16

Durée d'exécution = 600 secondes Fichier de configuration = NULL

Taille de la clé = 64 Taille de la valeur = 1024

Get/set = 9:1 Taille de la fenêtre = 10k

Nombre d'exécution = 0 Obtenir unique = vrai

Multi-get = false Nombre de sockets de chaque simultanéité = 1

Reconnexion = faux Vérification des données = faux

Vérification de l'heure d'expiration = faux Protocole ASCII = vrai

Protocole binaire = false Informations statistiques de vidage

périodiquement = faux

Proportion d'écrasement = 0% UDP = faux

TCP = vrai Débit limite = faux

Test Facebook = faux Test de réplication = faux

clés / KEY : Taille, Plus-value taille ainsi que commander distribution.
Toutes les distributions sont lues à partir du fichier de configuration spécifié par l'utilisateur avec
Option "—cfg_cmd". Si l'utilisateur ne spécifie pas de fichier de configuration, memaslap s'exécutera
avec la distribution par défaut (taille de la clé = 64, taille de la valeur = 1024, get/set = 9:1). Pour
informations sur la façon de modifier le fichier de configuration, reportez-vous au « Fichier de configuration »
.

La taille minimale de la clé est de 16 octets ; la taille maximale de la clé est de 250 octets. La précision de
la proportion est de 0.001. La proportion de distribution sera arrondie à 3 décimales.

La taille de valeur minimale est de 1 octet ; la taille de valeur maximale est de 1 M octets. La précision de
la proportion est de 0.001. La proportion de distribution sera arrondie à 3 décimales.
Actuellement, memaslap ne teste que les commandes set et get. Et il teste 100% set et 100% get.
Pour 100% get, il va prédéfinir certains objets sur le serveur.

Multi-thread ainsi que concurrence
La haute performance de memaslap bénéficie du programme spécial de filetage et
concurrence. Il est important d'en spécifier le bon nombre. Le nombre par défaut de
threads est 1 ; le nombre par défaut de simultanéité est 16. L'utilisateur peut utiliser "—threads" et
"--concurrency" pour spécifier ces variables.

Si le système teste la définition de l'affinité CPU et le nombre de threads spécifiés par l'utilisateur
est supérieur à 1, memaslap essaiera de lier chaque thread à un cœur de processeur différent. Donc si
vous souhaitez obtenir les meilleures performances memaslap, il est préférable de préciser le nombre de
thread égal au nombre de cœurs du processeur. Le nombre de threads spécifié par l'utilisateur peut
également être inférieur ou supérieur au nombre de cœurs de processeur. En raison de la limitation de
mise en œuvre, le nombre de simultanéités pourrait être le multiple du nombre de
threads.

1. Pour le système à 8 cœurs de processeur

Par exemple :

--threads=2 --concurrency=128

--threads=8 --concurrency=128

--threads=8 --concurrency=256

--threads=12 --concurrency=144

2. Pour le système à 16 cœurs de processeur

Par exemple :

--threads=8 --concurrency=128

--threads=16 --concurrency=256

--threads=16 --concurrency=512

--threads=24 --concurrency=288

Le memaslap fonctionne très bien lorsqu'il est utilisé pour tester les performances des serveurs memcached.
La plupart du temps, le goulot d'étranglement est le réseau ou le serveur. Si, pour une raison quelconque, l'utilisateur
veut limiter les performances de memaslap, il y a deux manières de le faire :

Diminuez le nombre de threads et de simultanéités. Utilisez l'option "--tps" qui memaslap
permet de limiter le débit. Cette option permet à l'utilisateur d'obtenir le
débit. Par exemple, supposons que le débit maximum est de 50 kops/s pour un
configuration, vous pouvez spécifier le débit égal ou inférieur au débit maximal
en utilisant l'option "--tps".

Vitrine taille
La plupart du temps, l'utilisateur n'a pas besoin de spécifier la taille de la fenêtre. La fenêtre par défaut
la taille est de 10k. Pour Schooner Memcached, l'utilisateur peut spécifier différentes tailles de fenêtre pour obtenir
différents taux d'échec de cache en fonction du cas de test. Memslap teste le taux d'échec du cache entre
0% et 100%. Si vous utilisez cet utilitaire pour tester les performances de Schooner Memcached, vous
peut spécifier une taille de fenêtre appropriée pour obtenir le taux d'échec de cache attendu. La formule pour
le calcul de la taille de la fenêtre est le suivant :

Supposons que la taille de la clé est de 128 octets et que la taille de la valeur est de 2048 octets, et
simultanéité=128.

1. Petit cache cache_size = 1M, 100 % d'échec de cache (toutes les données proviennent du SSD). win_size=10k

2. taille_cache=4G

(1). taux d'échec de cache 0%

win_size=8k

(2). taux d'échec de cache 5%

win_size=11k

3. taille_cache=16G

(1). taux d'échec de cache 0%

win_size=32k

(2). cache manque

taux 5%

win_size=46k

La formule de calcul de la taille de la fenêtre pour le taux d'échec du cache 0% :

cache_size / concurrence / (key_size + value_size) * 0.5

La formule de calcul de la taille de la fenêtre pour le taux d'échec du cache 5% :

cache_size / concurrence / (key_size + value_size) * 0.7

Vérification
Memslap teste à la fois la vérification des données et la vérification du délai d'expiration. L'utilisateur peut utiliser
"--verify=" ou "-v" pour spécifier la proportion de vérification des données. En théorie, il teste
Vérification des données à 100 %. L'utilisateur peut utiliser "--exp_verify=" ou "-e" pour spécifier la proportion
de vérification du délai d'expiration. En théorie, il teste une vérification à 100 % du délai d'expiration. Spécifier
les options "--verbose" pour obtenir des informations d'erreur plus détaillées.

Par exemple : --exp_verify=0.01 –verify=0.1 , cela signifie que 1% des objets définis avec
délai d'expiration, 10% des objets obtenus seront vérifiés. Si les objets sont récupérés,
memaslap vérifiera l'heure d'expiration et la valeur.

multi-serveurs ainsi que multi-configuration
Memslap teste les multi-serveurs basés sur des threads auto-gouvernés. Il y a une limite qui
le nombre de serveurs ne peut pas être supérieur au nombre de threads. Memslap en attribue un
thread pour gérer au moins un serveur. L'utilisateur peut utiliser l'option "--servers=" ou "-s" pour
spécifier multi-serveurs.

Par exemple :

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

La commande ci-dessus signifie qu'il y a 6 threads, chaque thread ayant 6 simultanéités
et que les threads 0 et 3 gèrent le serveur 0 (10.1.1.1) ; les threads 1 et 4 gèrent le serveur 1
(10.1.1.2) ; et les threads 2 et 5 gèrent le serveur 2 (10.1.1.3).

Tous les threads et les concurrences dans memaslap sont autogérés.

Memaslap aussi. L'utilisateur peut démarrer plusieurs instances de memaslap. L'utilisateur peut exécuter
memaslap sur différentes machines clientes pour communiquer avec le même serveur memcached au
même. Il est recommandé à l'utilisateur de démarrer différents memaslap sur différentes machines en utilisant
la même configuration.

Courir avec exécuter nombre mode or fiable mode
Le memaslap par défaut s'exécute avec le mode temporel. La durée d'exécution par défaut est de 10 minutes. S'il est temps
out, memaslap sortira. Ne spécifiez pas à la fois le mode numéro d'exécution et le mode temporel en même temps
temps; spécifiez-en un à la place.

Par exemple :

--time=30s (Cela signifie que le test s'exécutera 30 secondes.)

--execute_number=100000 (Cela signifie qu'après avoir exécuté 100000 commandes, le test se terminera.)

Déverser statistique d'information périodiquement.
L'utilisateur peut utiliser "--stat_freq=" ou "-S" pour spécifier la fréquence.

Par exemple :

--stat_freq=20s

Memslap videra les statistiques des commandes (get et set) à la fréquence de chaque
20 secondes.

Pour plus d'informations sur le format de vidage des informations statistiques, reportez-vous à « Format de
rubrique "Sortie".

Multi-obtenir
L'utilisateur peut utiliser "--division=" ou "-d" pour spécifier le nombre de clés multi-get. Memslap par
par défaut n'obtient qu'un seul avec TCP. Memslap teste également la vérification des données et le délai d'expiration
vérification pour multi-get.

Memslap teste le multi-get avec TCP et UDP. En raison de la mise en œuvre différente de
le protocole ASCII et le protocole binaire, il existe quelques différences entre les deux. Pour
le protocole ASCII, memaslap envoie une fois un « multi-get » au serveur. Pour le binaire
protocole, memaslap envoie plusieurs commandes get simples ensemble en tant que « multi-get » au
serveur.

UDP ainsi que TCP
Memslap teste à la fois UDP et TCP. Pour TCP, memaslap ne reconnecte pas le serveur memcached
si les connexions socket sont perdues. Si toutes les connexions socket sont perdues ou serveur memcached
se bloque, memaslap va se fermer. Si l'utilisateur spécifie l'option "--reconnect" lorsque socket
les connexions sont perdues, il les reconnectera.

L'utilisateur peut utiliser "--udp" pour activer la fonctionnalité UDP, mais UDP comporte certaines limitations :

UDP ne peut pas définir de données de plus de 1400 octets.

UDP n'est pas testé par le protocole binaire car le protocole binaire de memcached le fait
teste pas ça.

UDP ne teste pas la reconnexion.

Facebook tester
Définissez les données avec TCP et multi-get avec UDP. Spécifiez les options suivantes :

"--facebook --division=50"

Si vous souhaitez créer des milliers de connexions TCP, spécifiez le

"--conn_sock=" option.

Par exemple : --facebook --division=50 --conn_sock=200

La commande ci-dessus signifie que memaslap fera un test facebook, chaque simultanéité a 200
socket TCP et un socket UDP.

Memslap définit des objets avec le socket TCP et obtient 50 objets une fois avec l'UDP
prise.

Si vous spécifiez "--division=50", la taille de la clé doit être inférieure à 25 octets car l'UDP
la taille du paquet est de 1400 octets.

réplication tester
Pour le test de réplication, l'utilisateur doit spécifier au moins deux serveurs memcached. L'utilisateur peut
utilisez l'option "—rep_write=" pour activer la fonctionnalité.

Par exemple :

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

La commande ci-dessus signifie qu'il y a 2 serveurs de réplication memcached, memaslap définira
objets à la fois sur le serveur 0 et le serveur 1, obtenez les objets qui sont définis sur le serveur 0 avant de
serveur 1, et obtenir également des objets qui sont définis sur le serveur 1 avant du serveur 0. Si le serveur 0
plante, memaslap n'obtiendra que les objets du serveur 1. Si le serveur 0 revient à la vie
encore une fois, memaslap reconnectera le serveur 0. Si le serveur 0 et le serveur 1 plantent, memaslap
va sortir.

Les soutiens milliers of TCP liens
Démarrez memaslap avec "--conn_sock=" ou "-n" pour activer cette fonctionnalité. Assurez-vous que votre
le système peut tester l'ouverture de milliers de fichiers et la création de milliers de sockets. Cependant,
cette fonctionnalité ne teste pas la reconnexion si les sockets se déconnectent.

Par exemple :

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

La commande ci-dessus signifie que memaslap démarre 8 threads, chaque thread en a 16
simultanées, chaque simultanéité a 128 connexions socket TCP, et le nombre total de
Les connexions de socket TCP sont 128 * 128 = 16384.

Les soutiens binaire protocole
Démarrez memaslap avec les options "--binary" ou "-B" pour activer cette fonctionnalité. Il teste tous les
ci-dessus, sauf UDP, car le dernier memcached 1.3.3 n'implémente pas le binaire
Protocole UDP.

Par exemple :

--binaire

Puisque memcached 1.3.3 n'implémente pas le protocole UDP binaire, memaslap ne teste pas UDP.
De plus, memcached 1.3.3 ne teste pas le multi-get. Si vous spécifiez "--division=50"
option, il envoie simplement 50 commandes get ensemble en tant que « mulit-get » au serveur.

CONFIGURATION DOSSIER

Cette section décrit le format du fichier de configuration. Par défaut quand non
le fichier de configuration est spécifié memaslap lit celui par défaut situé à ~/.memaslap.cnf.

Voici un exemple de fichier de configuration :

-------------------------------------------------- -------------------------
Les #commentaires doivent commencer par '#'
#clé
#start_len end_len proportion
#
#key longueur plage de start_len à end_len
#start_len doit être égal ou supérieur à 16
#end_len doit être égal ou inférieur à 250
#start_len doit être égal ou supérieur à end_len
#memaslap générera des clés en fonction de la plage de clés
#proportion : indique les clés générées à partir d'une plage de comptes pour le total
clés générées
#
#exemple1 : la plage de clés 16~100 représente 80 %
# plage de clés 101 à 200 comptes pour 10 %
# plage de clés 201 à 250 comptes pour 10 %
# total doit être 1 (0.8+0.1+0.1 = 1)
#
# 16 100 0.8
# 101 200 0.1
# 201 249 0.1
#
#exemple2 : la longueur de toutes les clés est de 128 octets
#
# 128 128 1
key
+128 (128)1
#valeur
#start_len end_len proportion
#
#valeur plage de longueur de start_len à end_len
#start_len doit être égal ou supérieur à 1
#end_len doit être égal ou inférieur à 1M
#start_len doit être égal ou supérieur à end_len
#memaslap générera des valeurs en fonction de la plage de valeurs
#proportion : indique les valeurs générées à partir d'une plage de comptes pour le
valeurs totales générées
#
#exemple1 : la plage de valeurs 1~1000 représente 80 %
# plage de valeurs 1001 ~ 10000 représente 10 %
# plage de valeurs 10001 ~ 100000 représente 10 %
# total doit être 1 (0.8+0.1+0.1 = 1)
#
# 1 1000 0.8
# 1001 10000 0.1
# 10001 100000 0.1
#
#example2 : toutes les longueurs de valeur sont de 128 octets
#
# 128 128 1
Plus-value
+2048 (2048)1
#cmd
#cmd_type cmd_proportion
#
#actuellement memaslap teste uniquement la commande get et set.
#
#cmd_type
#set 0
#obtenir 1
#
#exemple : définir les comptes de commande pour 50 %
# obtenir des comptes de commande pour 50 %
# total doit être 1 (0.5+0.5 = 1)
#
#cmd
# 0 0.5
# 1 0.5
cmd
+0 (0.1)XNUMX XNUMX
+1.0 (0.9)XNUMX XNUMX

Format OF SORTIE

Au début, memaslap affiche quelques informations de configuration comme suit :

serveurs : 127.0.0.1:11211

nombre de threads : 1

simultanéité : 16

temps d'exécution: 20s

taille des fenêtres: 10k

définir la proportion : set_prop=0.10

obtenir la proportion : get_prop=0.90

Où
serveurs : "serveurs"
Les serveurs utilisés par memaslap.

les fils comptent
Le nombre de threads avec lesquels memaslap s'exécute.

concurrence
Le nombre de simultanéités avec lesquelles memaslap s'exécute.

temps d'exécution
Combien de temps pour exécuter memaslap.

taille des fenêtres
La taille de la fenêtre de tâche de chaque concurrence.

définir les proportions
La proportion de la commande définie.

obtenir des proportions
La proportion de la commande get.

La sortie des statistiques dynamiques ressemble à ceci :

-------------------------------------------------- -------------------------------------------------- -----------------------------
Obtenez des statistiques
Type Heure(s) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
Période 5 345826 69165 65.3 0 27 2198 203
+95.43 (177.29)XNUMX XNUMX
Monde 20 1257935 62896 71.8 0 26 3791 224
+117.79 (192.60)XNUMX XNUMX

Définir les statistiques
Type Heure(s) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
Période 5 38425 7685 7.3 0 42 628 240
+88.05 (220.21)XNUMX XNUMX
Monde 20 139780 6989 8.0 0 37 3790 253
+117.93 (224.83)XNUMX XNUMX

Statistiques totales
Type Heure(s) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
Période 5 384252 76850 72.5 0 27 2198 207
+94.72 (181.18)XNUMX XNUMX
Monde 20 1397720 69886 79.7 0 26 3791 227
+117.93 (195.60)XNUMX XNUMX
-------------------------------------------------- -------------------------------------------------- -----------------------------

Où
Obtenez des statistiques
Informations statistiques de la commande get

Définir les statistiques
Informations statistiques de la commande set

Statistiques totales
Informations statistiques sur les commandes get et set

Période
Résultat dans un délai

Global
Résultats cumulés

Ops
Total des opérations

TPS
Débit, opérations/seconde

Net
Le taux de réseau

Get_miss
Combien d'objets ne peuvent pas être obtenus

Min
Le temps de réponse minimum

Max
Le temps de réponse maximal

Moy
Le temps de réponse moyen

Std_dev
Écart type du temps de réponse

Géo_dist
Distribution géométrique basée sur la fonction exponentielle naturelle

À la fin, memaslap affichera quelque chose comme ceci :

-------------------------------------------------- -------------------------------------------------- -----------------------------
Obtenir des statistiques (1257956 événements)
Min: 26
Max: 3791
Moyenne : 224
Géo : 192.60
Std: xnumx
Log2 Dist :
4: 0 10 84490 215345
8: 484890 459823 12543 824
12: 31

Statistiques d'ensemble (139782 événements)
Min: 37
Max: 3790
Moyenne : 253
Géo : 224.84
Std: xnumx
Log2 Dist :
4: 0 0 4200 16988
8: 50784 65574 2064 167
12: 5

Statistiques totales (1397738 événements)
Min: 26
Max: 3791
Moyenne : 227
Géo : 195.60
Std: xnumx
Log2 Dist :
4: 0 10 88690 232333
8: 535674 525397 14607 991
12: 36

cmd_get : 1257969
cmd_set : 139785
get_misses : 0
verify_misses : 0
verify_failed : 0
expiré_get : 0
unexpired_unget : 0
octets_écrits : 242516030
read_bytes : 1003702556
object_bytes : 152086080
paquet_disorder : 0
paquet_drop : 0
udp_timeout : 0

Temps d'exécution : 20.0 s Ops : 1397754 TPS : 69817 Net_rate : 59.4 M/s
-------------------------------------------------- -------------------------------------------------- -----------------------------

Où
Obtenez des statistiques
Obtenez des statistiques de temps de réponse

Définir les statistiques
Définir des statistiques de temps de réponse

Statistiques totales
Obtenir et définir des statistiques de temps de réponse

Min
Le temps de réponse cumulé et minimum

Max
Le temps de réponse cumulé et maximum

Moy
Le temps de réponse cumulé et moyen

Std
Écart type du temps de réponse

Log2 Dist
Distribution géométrique basée sur le logarithme 2

cmd_get
Total obtenir des commandes effectuées

cmd_set
Nombre total de commandes définies

get_misses
Combien d'objets ne peuvent pas être obtenus du serveur

vérifier_manquer
Combien d'objets doivent être vérifiés mais ne peuvent pas les obtenir

vérifier_failed
Combien d'objets à valeur insistante

expiré_get
Combien d'objets ont expiré mais nous les obtenons

non expiré_unget
Combien d'objets n'ont pas expiré mais nous ne pouvons pas les obtenir

octets_écrits
Nombre total d'octets écrits

lecture_octets
Nombre total d'octets lus

octets_objet
Nombre total d'octets d'objet

désordre_paquet
Combien de paquets UDP sont en désordre

paquet_drop
Combien de packages UDP sont perdus

udp_timeout
Combien de fois le délai d'expiration UDP se produit

le temps d'exécution
Durée totale d'exécution

Ops
Total des opérations

TPS
Débit, opérations/seconde

Taux_net
Le taux moyen du réseau

OPTIONS

-Oui, --serveurs=
Répertoriez un ou plusieurs serveurs à connecter. Le nombre de serveurs doit être inférieur au nombre de threads.
par exemple : --servers=localhost:1234,localhost:11211

-T, --threads=
Nombre de threads à démarrer, mieux égal aux nombres de CPU. Par défaut 8.

-c, --concurrence=
Nombre de simultanéités à simuler avec charge. Par défaut 128.

-n, --conn_sock=
Nombre de chaussettes TCP par simultanéité. Par défaut 1.

-X, --execute_number=
Nombre d'opérations (get et set) à exécuter pour le test donné. Par défaut 1000000.

-t, --heure=
Durée d'exécution du test, suffixe : s-secondes, m-minutes, h-heures, jours-j, par exemple :
--temps=2h.

-F, --cfg_cmd=
Chargez le fichier de configuration pour obtenir la liste de distribution des commandes, des clés et des valeurs.

-w, --win_size=
Taille de la fenêtre de tâche de chaque concurrence, suffixe : K, M ex : --win_size=10k. Défaut
10k.

-X, --fixed_size=
Longueur fixe de la valeur.

-dans, --vérifier=
La proportion de vérification de la date, par exemple : --verify=0.01

-ré, --division=
Nombre de clés à obtenir une seule fois. Par défaut 1, signifie un seul obtention.

-S, --stat_freq=
Fréquence de vidage des informations statistiques. suffixe : s-secondes, m-minutes, par exemple :
--resp_freq=10s.

-e, --exp_verify=
La proportion d'objets avec un délai d'expiration, par exemple : --exp_verify=0.01. Par défaut non
objet avec délai d'expiration

-o, --écraser=
La proportion d'objets à écraser, par exemple : --overwrite=0.01. Par défaut jamais
écraser l'objet.

-R, --reconnecter
Reconnectez les tests, lorsque la connexion est fermée, elle sera reconnectée.

-U, --udp
Tests UDP, memaslap par défaut utilise TCP, le port TCP et le port UDP du serveur doivent être identiques.

-a, --Facebook
Qu'il active la fonction de test Facebook, défini avec TCP et multi-get avec UDP.

-B, --binaire
S'il active le protocole binaire. Par défaut avec le protocole ASCII.

-P, --tps=
Débit attendu, suffixe : K, par exemple : --tps=10k.

-p, --rep_write=
Les premiers nièmes serveurs peuvent écrire des données, par exemple : --rep_write=2.

-b, --verbeux
S'il produit des informations détaillées lorsque la vérification échoue.

-h, --Aidez-moi
Affichez ce message puis quittez.

-V, --version
Affichez la version de l'application puis quittez.

EXEMPLES

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 config -t 2m

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

ACCUEIL

Pour plus d'informations, veuillez consulter : http://libmemcached.org/

AUTEURS

Mingqiang Zhuang[email protected]> (Technologie des goélettes) Brian Aker, <‐
[email protected]>

Utiliser memcaslap en ligne en utilisant les services onworks.net