memcaslap - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

memaslap - libmemcached-Dokumentation

ZUSAMMENFASSUNG

memaslap [Optionen]

--help

MEMCACHED_SERVER

BESCHREIBUNG

memaslap ist ein Lastgenerierungs- und Benchmark-Tool für Memcached-Server. Es erzeugt
konfigurierbarer Workload wie Threads, Parallelitäten, Verbindungen, Laufzeit, Überschreiben,
Fehlerrate, Schlüsselgröße, Wertgröße, Get/Set-Verhältnis, erwarteter Durchsatz usw.
Darüber hinaus testet es auch Datenüberprüfung, Ablaufzeitüberprüfung, UDP, Binär
Protokoll, Facebook-Test, Replikationstest, Multi-Get und Reconnection usw.

Memaslap verwaltet Netzwerkverbindungen wie Memcached mit libevent. Jeder Thread von memaslap
ist an einen CPU-Kern gebunden, alle Threads kommunizieren nicht miteinander, und es gibt
mehrere Muffenverbindungen in jedem Gewinde. Jede Verbindung behält die Schlüsselgrößenverteilung bei,
Wertgrößenverteilung und Befehlsverteilung selbst.

Sie können Server über die Memslap --server Option oder über die Umgebungsvariable
MEMCACHED_SERVER.

MERKMALE

Memslap wurde für folgende Zwecke entwickelt:

Verwaltet Netzwerkverbindungen mit libevent asynchron.

Richten Sie sowohl TCP als auch UDP ein, um nicht blockierende E/A zu verwenden.

Verbessert die Parallelität: höhere Leistung in Multi-Thread-Umgebungen.

Verbessert die Zeiteffizienz: schnellere Verarbeitungsgeschwindigkeit.

Erzeugt Schlüssel und Wert effizienter; Schlüsselgrößenverteilung und Wertgröße
Verteilung sind konfigurierbar.

Unterstützt get-, multi-get- und set-Befehle; Befehlsverteilung ist konfigurierbar.

Unterstützt kontrollierbare Fehlerrate und Überschreibrate.

Unterstützt Daten- und Ablaufzeitüberprüfung.

Unterstützt regelmäßiges Dumping von Statistikinformationen.

Unterstützt Tausende von TCP-Verbindungen.

Unterstützt binäres Protokoll.

Unterstützt Facebook-Test (eingestellt mit TCP und Multi-Get mit UDP) und Replikationstest.

DETAILS

Effektiv Implementierung of Netzwerk.
Für Memaslap verwenden sowohl TCP als auch UDP nicht blockierende Netzwerk-E/A. Alle Netzwerkveranstaltungen sind
von libevent als Memcached verwaltet. Das Netzwerkmodul von memaslap ähnelt memcached.
Libevent kann sicherstellen, dass memaslap das Netzwerk sehr effizient handhaben kann.

Effektiv Implementierung of Multi-Thread und Parallelität
Memslap hat eine ähnliche Implementierung von Multi-Threads wie Memcached. Memslap erstellt einen
oder mehr selbstgesteuerte Fäden; jeder Thread ist an einen CPU-Kern gebunden, wenn das System testet
Einstellung der CPU-Kern-Affinität.

Außerdem verfügt jeder Thread über ein libevent, um die Ereignisse des Netzwerks zu verwalten; jeder Thread
hat eine oder mehrere selbstverwaltete Nebenläufigkeiten; und jede Parallelität hat einen oder mehrere Sockets
Verbindungen. Alle Nebenläufigkeiten kommunizieren nicht miteinander, obwohl sie es sind
im selben Thread.

Memslap kann Tausende von Socket-Verbindungen erstellen, und jede Parallelität hat Dutzende von
Steckdosenanschlüsse. Jede Parallelität wählt zufällig oder nacheinander einen Socket aus
Verbindung aus seinem Socket-Verbindungspool ausgeführt werden, sodass memaslap jede Parallelität sicherstellen kann
verarbeitet zu jedem Zeitpunkt eine Socket-Verbindung. Benutzer können die Anzahl der
Parallelität und Socket-Verbindungen jeder Parallelität entsprechend ihrer erwarteten
Arbeitsbelastung.

Effektiv Implementierung of Erzeugung Schlüssel und Wert
Um die Zeit- und Platzeffizienz zu verbessern, erstellt memaslap eine zufällige
Zeichentabelle mit 10 Millionen Zeichen. Alle Suffixe von Schlüsseln und Werten werden generiert
aus dieser zufälligen Zeichentabelle.

Memslap verwendet den Offset in der Zeichentabelle und die Länge des Strings, um a . zu identifizieren
Schnur. Es kann viel Speicher sparen. Jeder Schlüssel enthält zwei Teile, ein Präfix und ein Suffix. Die
Präfix ist ein uint64_t, 8 Byte. Um den Datensatz vorher zu verifizieren, muss memaslap
Stellen Sie sicher, dass jeder Schlüssel eindeutig ist, sodass er das Präfix verwendet, um einen Schlüssel zu identifizieren. Das Präfix kann nicht
enthalten unzulässige Zeichen wie 'r', 'n', '0' und ' '. Und memaslap hat einen Algorithmus
um sicherzustellen, dass.

Memslap generiert zu Beginn nicht alle Objekte (Schlüssel-Wert-Paare). Es nur
Generiert genug Objekte, um das Aufgabenfenster (Standard 10K Objekte) von jedem zu füllen
Gleichzeitigkeit. Jedes Objekt hat die folgenden grundlegenden Informationen, Schlüsselpräfix, Schlüsselsuffix
Offset in der Zeichentabelle, Schlüssellänge, Wertoffset in der Zeichentabelle und Wert
Länge.

Im Arbeitsprozess wählt jede Nebenläufigkeit sequentiell oder zufällig ein Objekt aus der
Fenster zum Ausführen von Set-Operationen oder Get-Operationen. Gleichzeitig tritt jede Parallelität auf
Objekte aus seinem Fenster und fügt ein neues Objekt hinzu.

Einfacher aber nützlich Auftrag Planung
Memslap verwendet libevent, um alle Parallelitäten von Threads und jede Parallelität zu planen
plant Aufgaben basierend auf dem lokalen Aufgabenfenster. Memslap geht davon aus, dass, wenn jede Parallelität
behält die gleiche Schlüsselverteilung, Wertverteilung und Befehlsverteilung bei, von
außen behält memaslap die gesamte Verteilung bei. Jedes Aufgabenfenster enthält eine Menge
von Objekten speichert jedes Objekt seine grundlegenden Informationen wie Schlüssel, Wert, Ablaufzeit und
demnächst. Alle Objekte im Fenster behalten jederzeit den gleichen und festen Schlüssel und Wert
Verteilung. Wird ein Objekt überschrieben, wird der Wert des Objekts aktualisiert.
Memslap überprüft die Daten oder die Ablaufzeit gemäß den in der Datei gespeicherten Objektinformationen
Aufgabenfenster.

Libevent wählt basierend auf einem bestimmten Netzwerkereignis aus, welche Parallelität verarbeitet werden soll. Dann ist die
Parallelität wählt basierend auf dem Befehl aus, welcher Befehl (get oder set) ausgeführt werden soll
Verteilung. Wenn es ein altes Objekt auswerfen und ein neues hinzufügen muss, um es zu behalten
gleiche Schlüssel- und Werteverteilung, das neue Objekt muss die gleiche Schlüssellänge haben und
Wert Länge.

Wenn der Memcached-Server über zwei Cache-Schichten (Speicher und SSD) verfügt, wird Memaslap mit unterschiedlichen ausgeführt
Fenstergrößen können unterschiedliche Cache-Miss-Raten erhalten. Wenn memaslap genügend Objekte in die
Fenster am Anfang, und der Cache von Memcached kann nicht alle Objekte speichern
initialisiert, dann holt memaslap einige Objekte aus der zweiten Cache-Schicht. Es verursacht
die erste Cache-Schicht, die übersehen wird. So kann der Benutzer die Fenstergröße angeben, um das erwartete zu erhalten
Fehltrefferrate der ersten Cache-Schicht.

Nützlich Implementierung of Multi-Server , UDP, TCP, Multi-Get und binär Protokoll
Da jeder Thread selbstverwaltet ist, kann memaslap verschiedene Threads zuweisen
verschiedene Memcached-Server. Dies ist nur eine der Möglichkeiten, wie memaslap mehrere Tests macht
Server. Die einzige Einschränkung besteht darin, dass die Anzahl der Server nicht größer sein darf als die
Anzahl der Themen. Die andere Möglichkeit zum Testen mehrerer Server ist der Replikationstest. Jeder
Nebenläufigkeit hat eine Socket-Verbindung zu jedem Memcached-Server. Für die Umsetzung,
memaslap kann einige Objekte auf einen Memcached-Server setzen und diese Objekte vom
andere Server.

Standardmäßig führt Memslap Single Get aus. Wenn der Benutzer die Multi-Get-Option angibt, wird memaslap
Sammeln Sie genug Get-Befehle und packen und senden Sie die Befehle zusammen.

Memslap testet sowohl das ASCII-Protokoll als auch das Binärprotokoll, läuft aber auf ASCII
Protokoll standardmäßig. Memslap läuft standardmäßig auf dem TCP-Protokoll, testet aber auch UDP.
Da UDP unzuverlässig ist, kann es zu verworfenen Paketen und Paketen außerhalb der Reihenfolge kommen. Memslap
erstellt einen Speicherpuffer, um diese Probleme zu behandeln. Memslap versucht alle Antworten zu lesen
Daten eines Befehls vom Server und ordnet die Antwortdaten neu. Wenn einige Pakete erhalten
verloren, kann der Wartezeit-Timeout-Mechanismus sicherstellen, dass unfertige Pakete verworfen werden und
der nächste Befehl wird gesendet.

ANWENDUNG

Nachfolgend finden Sie einige Anwendungsbeispiele:

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

Der Benutzer muss mindestens einen Server angeben, um memaslap auszuführen. Die restlichen Parameter haben
Standardwerte, wie unten gezeigt:

Thread-Nummer = 1 Parallelität = 16

Laufzeit = 600 Sekunden Konfigurationsdatei = NULL

Schlüsselgröße = 64 Wertgröße = 1024

Get/Set = 9:1 Fenstergröße = 10k

Nummer ausführen = 0 Single get = true

Multi-get = false Anzahl der Sockets jeder Parallelität = 1

Reconnect = false Datenüberprüfung = false

Ablaufzeitüberprüfung = falsch ASCII-Protokoll = wahr

Binäres Protokoll = falsche Dumping-Statistikinformationen

periodisch = falsch

Überschreibanteil = 0% UDP = false

TCP = true Limit-Durchsatz = false

Facebook-Test = falsch Replikationstest = falsch

Wesentliche Größe, Wert Größe und Befehl Verteilung.
Alle Distributionen werden aus der vom Benutzer angegebenen Konfigurationsdatei gelesen mit
„—cfg_cmd“-Option. Wenn der Benutzer keine Konfigurationsdatei angibt, wird memaslap ausgeführt
mit der Standardverteilung (Schlüsselgröße = 64, Wertgröße = 1024, Get/Set = 9:1). Zum
Informationen zum Bearbeiten der Konfigurationsdatei finden Sie in der „Konfigurationsdatei“
.

Die Mindestschlüsselgröße beträgt 16 Byte; die maximale Schlüsselgröße beträgt 250 Byte. Die Präzision von
Anteil beträgt 0.001. Der Ausschüttungsanteil wird auf 3 Stellen nach dem Komma gerundet.

Die minimale Wertgröße beträgt 1 Byte; die maximale Wertgröße beträgt 1 MByte. Die Präzision von
Anteil beträgt 0.001. Der Ausschüttungsanteil wird auf 3 Stellen nach dem Komma gerundet.
Derzeit testet memaslap nur set- und get-Befehle. Und es testet 100% Set und 100% Get.
Für 100% Get werden einige Objekte auf dem Server voreingestellt.

Multi Thread und Parallelität
Die hohe Performance von memaslap profitiert von der speziellen Einteilung von Threads und
Gleichzeitigkeit. Es ist wichtig, die richtige Anzahl von ihnen anzugeben. Die Standardanzahl von
Fäden ist 1; die Standardanzahl der Parallelität ist 16. Der Benutzer kann „—threads“ und . verwenden
„--concurrency“, um diese Variablen anzugeben.

Wenn das System die Einstellung der CPU-Affinität und die vom Benutzer angegebene Anzahl von Threads testet
größer als 1 ist, versucht memaslap, jeden Thread an einen anderen CPU-Kern zu binden. Also wenn
Wenn Sie die beste Memaslap-Leistung erzielen möchten, ist es besser, die Anzahl der anzugeben
Thread gleich der Anzahl der CPU-Kerne. Die vom Benutzer angegebene Anzahl von Threads kann
auch kleiner oder größer als die Anzahl der CPU-Kerne sein. Wegen der Beschränkung von
Implementierung kann die Anzahl der Nebenläufigkeiten das Vielfache der Anzahl der
Threads.

1. Für System mit 8 CPU-Kernen

Beispielsweise:

--threads=2 --concurrency=128

--threads=8 --concurrency=128

--threads=8 --concurrency=256

--threads=12 --concurrency=144

2. Für System mit 16 CPU-Kernen

Beispielsweise:

--threads=8 --concurrency=128

--threads=16 --concurrency=256

--threads=16 --concurrency=512

--threads=24 --concurrency=288

Der Memaslap schneidet sehr gut ab, wenn er zum Testen der Leistung von Memcached-Servern verwendet wird.
Der Flaschenhals ist meistens das Netzwerk oder der Server. Wenn der Benutzer aus irgendeinem Grund
die Leistung von memaslap einschränken möchte, gibt es dazu zwei Möglichkeiten:

Verringern Sie die Anzahl der Threads und Parallelitäten. Verwenden Sie die Option "--tps", die memaslap
bietet die Möglichkeit, den Durchsatz zu begrenzen. Diese Option ermöglicht es dem Benutzer, das erwartete
Durchsatz. Angenommen, der maximale Durchsatz beträgt 50 kops/s für ein bestimmtes
Konfiguration können Sie den Durchsatz gleich oder kleiner als der maximale Durchsatz festlegen
mit der Option "--tps".

Window Größe
In den meisten Fällen muss der Benutzer die Fenstergröße nicht angeben. Das Standardfenster
Größe ist 10k. Für Schooner Memcached kann der Benutzer verschiedene Fenstergrößen angeben, um zu erhalten
unterschiedliche Cache-Miss-Raten basierend auf dem Testfall. Memslap testet Cache-Missrate zwischen
0% und 100%. Wenn Sie dieses Dienstprogramm verwenden, um die Leistung von Schooner Memcached zu testen,
kann eine geeignete Fenstergröße angeben, um die erwartete Cache-Fehltrefferrate zu erhalten. Die Formel für
Die Berechnung der Fenstergröße ist wie folgt:

Angenommen, die Schlüsselgröße beträgt 128 Byte und die Wertgröße beträgt 2048 Byte, und
Gleichzeitigkeit=128.

1. Small Cache cache_size=1M, 100 % Cache-Miss (alle Daten kommen von SSD). win_size=10k

2. Cachegröße=4G

(1). Cache-Missrate 0%

win_size=8k

(2). Cache-Missrate 5%

win_size=11k

3. Cachegröße=16G

(1). Cache-Missrate 0%

win_size=32k

(2). Cache-Miss

bewerte 5%

win_size=46k

Die Formel zur Berechnung der Fenstergröße für die Cache-Miss-Rate 0 %:

Cache_Größe / Parallelität / (Schlüssel_Größe + Wert_Größe) * 0.5

Die Formel zur Berechnung der Fenstergröße für die Cache-Miss-Rate 5 %:

Cache_Größe / Parallelität / (Schlüssel_Größe + Wert_Größe) * 0.7

Verification
Memslap testet sowohl die Datenüberprüfung als auch die Überprüfung der Ablaufzeit. Der Benutzer kann verwenden
"--verify=" oder "-v", um den Anteil der Datenüberprüfung anzugeben. Theoretisch testet es
100% Datenüberprüfung. Der Benutzer kann "--exp_verify=" oder "-e" verwenden, um den Anteil anzugeben
der Ablaufzeitüberprüfung. Theoretisch wird eine 100%ige Verifizierung der Ablaufzeit getestet. Angeben
die Optionen "--verbose", um detailliertere Fehlerinformationen zu erhalten.

Zum Beispiel: --exp_verify=0.01 –verify=0.1 , das bedeutet, dass 1% der Objekte mit
Ablaufzeit werden 10 % der erhaltenen Objekte verifiziert. Wenn die Objekte geholt werden,
memaslap überprüft die Ablaufzeit und den Wert.

Multi-Server und Multi-Konfiguration
Memslap testet Multiserver basierend auf selbstverwalteten Threads. Es gibt eine Einschränkung, dass
die Anzahl der Server darf nicht größer sein als die Anzahl der Threads. Memslap weist einen zu
Thread, um mindestens einen Server zu behandeln. Der Benutzer kann die Option "--servers=" oder "-s" verwenden, um
Geben Sie mehrere Server an.

Beispielsweise:

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

Der obige Befehl bedeutet, dass es 6 Threads gibt, wobei jeder Thread 6 Parallelen hat
und dass Threads 0 und 3 Server 0 handhaben (10.1.1.1); Threads 1 und 4 behandeln Server 1
(10.1.1.2); und Thread 2 und 5 behandeln Server 2 (10.1.1.3).

Alle Threads und Nebenläufigkeiten in Memaslap sind selbstverwaltet.

So ist Memaslap. Der Benutzer kann mehrere memaslap-Instanzen starten. Der Benutzer kann ausführen
memaslap auf verschiedenen Client-Rechnern, um mit demselben Memcached-Server zu kommunizieren
gleich. Es wird empfohlen, dass der Benutzer verschiedene Memaslaps auf verschiedenen Computern mit . startet
die gleiche Konfiguration.

Führen Sie mit ausführen Anzahl Modus or Zeit Modus
Der Standard-Memaslap wird im Zeitmodus ausgeführt. Die Standardlaufzeit beträgt 10 Minuten. Wenn es mal
aus, memaslap wird beendet. Geben Sie nicht gleichzeitig den Ausführungsnummernmodus und den Zeitmodus an
Zeit; Geben Sie stattdessen einfach einen an.

Beispielsweise:

--time=30s (Das bedeutet, dass der Test 30 Sekunden dauert.)

--execute_number=100000 (Dies bedeutet, dass der Test nach dem Ausführen von 100000 Befehlen beendet wird.)

Dump Statistik Information regelmäßig.
Der Benutzer kann mit "--stat_freq=" oder "-S" die Häufigkeit angeben.

Beispielsweise:

--stat_freq=20s

Memslap gibt die Statistiken der Befehle (get und set) in der Häufigkeit von jedem aus
20 Sekunden.

Weitere Informationen zum Format der Dumping-Statistikinformationen finden Sie unter „Format von
Ausgabe“.

Multi-Get
Der Benutzer kann "--division=" oder "-d" verwenden, um die Anzahl der Multiget-Schlüssel anzugeben. Memslap von
default macht single get mit TCP. Memslap testet auch die Datenüberprüfung und die Ablaufzeit
Verifizierung für Multi-Get.

Memslap testet Multi-Get sowohl mit TCP als auch mit UDP. Aufgrund der unterschiedlichen Implementierung von
dem ASCII-Protokoll und dem Binärprotokoll gibt es einige Unterschiede zwischen den beiden. Zum
Beim ASCII-Protokoll sendet memaslap einmal ein „multi-get“ an den Server. Für die binäre
Protokoll sendet memaslap mehrere einzelne get-Befehle zusammen als „multi-get“ an das
Server.

UDP und TCP
Memslap testet sowohl UDP als auch TCP. Bei TCP verbindet memaslap den Memcached-Server nicht erneut
wenn Socket-Verbindungen verloren gehen. Wenn alle Socket-Verbindungen verloren gehen oder ein Memcached-Server vorliegt
abstürzt, wird memaslap beendet. Wenn der Benutzer die Option „--reconnect“ angibt, wenn Socket
Verbindungen verloren gehen, werden sie wieder verbunden.

Der Benutzer kann „--udp“ verwenden, um die UDP-Funktion zu aktivieren, aber UDP hat einige Einschränkungen:

UDP kann keine Daten mit mehr als 1400 Byte festlegen.

UDP wird nicht vom Binärprotokoll getestet, da das Binärprotokoll von Memcached dies tut
testet das nicht.

UDP testet keine erneute Verbindung.

Facebook Test
Setzen Sie Daten mit TCP und multi-get mit UDP. Geben Sie die folgenden Optionen an:

"--facebook --division=50"

Wenn Sie Tausende von TCP-Verbindungen erstellen möchten, geben Sie die

"--conn_sock="-Option.

Zum Beispiel: --facebook --division=50 --conn_sock=200

Der obige Befehl bedeutet, dass memaslap einen Facebook-Test durchführt, jede Parallelität hat 200
Socket TCP-Verbindungen und ein UDP-Socket.

Memslap setzt Objekte mit dem TCP-Socket und erhält einmal 50 Objekte mit dem UDP
Steckdose.

Wenn Sie "--division=50" angeben, muss die Schlüsselgröße weniger als 25 Byte betragen, da die UDP
Paketgröße beträgt 1400 Byte.

Replikation Test
Für den Replikationstest muss der Benutzer mindestens zwei Memcached-Server angeben. Der Benutzer kann
Verwenden Sie die Option „—rep_write=“, um die Funktion zu aktivieren.

Beispielsweise:

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

Der obige Befehl bedeutet, dass es 2 Replikations-Memcached-Server gibt, memaslap wird gesetzt
Objekte sowohl auf Server 0 als auch auf Server 1, holt Objekte, die auf Server 0 gesetzt wurden, bevor von
Server 1 und holt auch Objekte, die zuvor auf Server 1 gesetzt wurden, von Server 0. Wenn Server 0
abstürzt, holt memaslap nur Objekte von Server 1. Wenn Server 0 wieder zum Leben erwacht
wieder verbindet memaslap Server 0. Wenn sowohl Server 0 als auch Server 1 abstürzen, memaslap
wird aussteigen.

Unterstützt Tausende of TCP Verbindungen
Starten Sie memaslap mit "--conn_sock=" oder "-n", um diese Funktion zu aktivieren. Stellen Sie sicher, dass Ihr
Das System kann das Öffnen von Tausenden von Dateien und das Erstellen Tausender von Sockets testen. Jedoch,
Diese Funktion testet keine erneute Verbindung, wenn die Sockets getrennt werden.

Beispielsweise:

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

Der obige Befehl bedeutet, dass memaslap 8 Threads startet, jeder Thread hat 16
Nebenläufigkeiten, jede Nebenläufigkeit hat 128 TCP-Socket-Verbindungen und die Gesamtzahl der
TCP-Socket-Verbindungen sind 128 * 128 = 16384.

Unterstützt binär Protokoll
Starten Sie memaslap mit den Optionen "--binary" oder "-B", um diese Funktion zu aktivieren. Es testet alle
obige Funktionen außer UDP, da die neueste Memcached-Version 1.3.3 keine Binärdateien implementiert
UDP-Protokoll.

Beispielsweise:

--binär

Da memcached 1.3.3 kein binäres UDP-Protokoll implementiert, testet memaslap kein UDP.
Außerdem testet Memcached 1.3.3 kein Multi-Get. Wenn Sie "--division=50" angeben
Option sendet es nur 50 get-Befehle zusammen als "mulit-get" an den Server.

CONFIGURATION FILE

In diesem Abschnitt wird das Format der Konfigurationsdatei beschrieben. Standardmäßig, wenn nein
Konfigurationsdatei ist angegeben memaslap liest die Standarddatei unter ~/.memaslap.cnf.

Unten ist eine Beispielkonfigurationsdatei:

-------------------------------------------------- -------------------------
#Kommentare sollten mit '#' beginnen
#Schlüssel
#start_len end_len Anteil
#
#Schlüssellängenbereich von start_len bis end_len
#start_len muss gleich oder größer als 16 . sein
#end_len muss kleiner oder gleich 250 . sein
#start_len muss gleich oder größer als end_len sein
#memaslap generiert Schlüssel entsprechend dem Schlüsselbereich
#proportion: gibt Schlüssel an, die aus einem Bereichskonten für die Summe generiert wurden
generierte Schlüssel
#
#example1: Schlüsselbereich 16~100 macht 80% aus
# Schlüsselbereich 101~200 macht 10% aus
# Schlüsselbereich 201~250 macht 10% aus
# insgesamt sollte 1 sein (0.8+0.1+0.1 = 1)
#
Nr. 16 100 0.8
Nr. 101 200 0.1
Nr. 201 249 0.1
#
#example2: Alle Schlüssellängen sind 128 Bytes
#
Nr. 128 128 1
Schlüssel
128 128 1
#Wert
#start_len end_len Anteil
#
#Wertlängenbereich von start_len bis end_len
#start_len muss gleich oder größer als 1 . sein
#end_len muss kleiner oder gleich 1 M sein
#start_len muss gleich oder größer als end_len sein
#memaslap generiert Werte entsprechend dem Wertebereich
#proportion: gibt Werte an, die aus einem Bereichskonten für die . generiert wurden
gesamt generierte Werte
#
#example1: Wertebereich 1~1000 macht 80% aus
# Wertebereich 1001~10000 macht 10 % aus
# Wertebereich 10001~100000 macht 10 % aus
# insgesamt sollte 1 sein (0.8+0.1+0.1 = 1)
#
Nr. 1 1000 0.8
Nr. 1001 10000 0.1
Nr. 10001 100000 0.1
#
#example2: alle Wertelängen sind 128 Byte
#
Nr. 128 128 1
Wert
2048 2048 1
#cmd
#cmd_type cmd_proportion
#
#Derzeit testet memaslap nur die Befehle get und set.
#
#cmd_type
#setze 0
#bekomme 1
#
#Beispiel: set-Befehl macht 50 % aus
# Get-Befehl macht 50% aus
# insgesamt sollte 1 sein (0.5+0.5 = 1)
#
#cmd
# 0 0.5
# 1 0.5
cmd
0 0.1
1.0 0.9

FORMAT OF AUSGABE

Zu Beginn zeigt memaslap einige Konfigurationsinformationen wie folgt an:

Server: 127.0.0.1:11211

Thread-Anzahl: 1

Gleichzeitigkeit: 16

Laufzeit: 20s

Fenstergröße: 10k

Proportion einstellen: set_prop=0.10

Anteil erhalten: get_prop=0.90

Wo
Server: "Server"
Die von memaslap verwendeten Server.

Threads zählen
Die Anzahl der Threads, mit denen Memaslap ausgeführt wird.

Parallelität
Die Anzahl der Parallelitäten, mit denen Memaslap ausgeführt wird.

Laufzeit
Wie lange memaslap laufen soll.

Fenstergröße
Die Aufgabenfenstergröße jeder Parallelität.

Proportion einstellen
Der Anteil des Set-Befehls.

Anteil bekommen
Der Anteil des Get-Befehls.

Die Ausgabe dynamischer Statistiken sieht in etwa so aus:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Statistiken abrufen
Typ Zeit(en) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Durchschn. (us) Std_dev Geo_dist
Zeitraum 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

Statistik einstellen
Typ Zeit(en) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Durchschn. (us) Std_dev Geo_dist
Zeitraum 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

Gesamtstatistik
Typ Zeit(en) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Durchschn. (us) Std_dev Geo_dist
Zeitraum 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
-------------------------------------------------- -------------------------------------------------- -----------------------------

Wo
Statistiken abrufen
Statistikinformationen des Get-Befehls

Statistik einstellen
Statistikinformationen des Set-Befehls

Gesamtstatistik
Statistikinformationen des Befehls get und set

Zeitraum
Ergebnis innerhalb eines Zeitraums

Global
Kumulierte Ergebnisse

Ops
Gesamtbetrieb

TPS
Durchsatz, Operationen/Sekunde

Netto-
Die Rate des Netzwerks

Get_miss
Wie viele Objekte können nicht erhalten werden?

Min.
Die minimale Reaktionszeit

Max
Die maximale Reaktionszeit

Durchschnitt:
Die durchschnittliche Reaktionszeit

Std_dev
Standardabweichung der Reaktionszeit

Geo_dist
Geometrische Verteilung basierend auf natürlicher Exponentialfunktion

Am Ende wird memaslap etwa so ausgeben:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Statistiken abrufen (1257956 Ereignisse)
Min: 26
Max: 3791
Durchschn.: 224
Geo: 192.60
Std: 116.23
Log2 Distanz:
4: 0 10 84490 215345
8: 484890 459823 12543 824
12: 31

Statistik einstellen (139782 Ereignisse)
Min: 37
Max: 3790
Durchschn.: 253
Geo: 224.84
Std: 116.83
Log2 Distanz:
4: 0 0 4200 16988
8: 50784 65574 2064 167
12: 5

Gesamtstatistik (1397738 Ereignisse)
Min: 26
Max: 3791
Durchschn.: 227
Geo: 195.60
Std: 116.60
Log2 Distanz:
4: 0 10 88690 232333
8: 535674 525397 14607 991
12: 36

cmd_get: 1257969
cmd_set: 139785
get_misses: 0
verifiziere_misses: 0
verifizieren_fehlgeschlagen: 0
abgelaufen_get: 0
unexpired_unget: 0
geschriebene_bytes: 242516030
read_bytes: 1003702556
Objektbytes: 152086080
Paketstörung: 0
Paket_Drop: 0
udp_timeout: 0

Laufzeit: 20.0s Ops: 1397754 TPS: 69817 Net_rate: 59.4M/s
-------------------------------------------------- -------------------------------------------------- -----------------------------

Wo
Statistiken abrufen
Statistiken zur Reaktionszeit abrufen

Statistik einstellen
Statistik der Reaktionszeit einstellen

Gesamtstatistik
Sowohl Statistiken zur Reaktionszeit abrufen als auch festlegen

Min.
Die kumulierte und minimale Reaktionszeit

Max
Die kumulierte und maximale Reaktionszeit

Durchschn.
Die kumulierte und durchschnittliche Reaktionszeit

Std
Standardabweichung der Reaktionszeit

Log2 Dist
Geometrische Verteilung basierend auf Logarithmus 2

cmd_get
Gesamte Get-Befehle erledigt

cmd_set
Gesamtsatzbefehle erledigt

get_misses
Wie viele Objekte können nicht vom Server abgerufen werden?

verifiziere_misses
Wie viele Objekte müssen überprüft werden, können sie aber nicht abrufen?

Verify_Failed
Wie viele Objekte mit beharrlichem Wert

abgelaufen_get
Wie viele Objekte sind abgelaufen, aber wir bekommen sie

nicht abgelaufen_unget
Wie viele Objekte sind nicht abgelaufen, aber wir können sie nicht bekommen

geschriebene_bytes
Insgesamt geschriebene Bytes

read_bytes
Gesamtzahl gelesener Bytes

Objekt_Bytes
Gesamtobjektbytes

Paketstörung
Wie viele UDP-Pakete sind Unordnung

paket_drop
Wie viele UDP-Pakete gehen verloren

udp_timeout
Wie oft UDP-Zeitüberschreitungen auftreten

Brenndauer
Gesamtlaufzeit

Ops
Gesamtbetrieb

TPS
Durchsatz, Operationen/Sekunde

Nettopreis
Die durchschnittliche Netzwerkrate

OPTIONAL

-S, --servers=
Listen Sie einen oder mehrere Server auf, um eine Verbindung herzustellen. Die Anzahl der Server muss kleiner sein als die Anzahl der Threads.
zB: --servers=localhost:1234,localhost:11211

-T, --threads=
Anzahl der zu startenden Threads, besser gleich den CPU-Nummern. Vorgabe 8.

-C, --concurrency=
Anzahl der Parallelität, die mit Last simuliert werden soll. Standard 128.

-nicht, --conn_sock=
Anzahl der TCP-Socks pro Parallelität. Standard 1.

-X, --execute_number=
Anzahl der Operationen (get und set), die für den gegebenen Test ausgeführt werden sollen. Standard 1000000.

-T, --time=
Wie lange der Test laufen soll, Suffix: s-Sekunden, m-Minuten, h-Stunden, d-Tage zB:
--Zeit=2h.

-F, --cfg_cmd=
Laden Sie die Konfigurationsdatei, um die Befehls-, Schlüssel- und Wertverteilerliste zu erhalten.

-w, --win_size=
Aufgabenfenstergröße jeder Parallelität, Suffix: K, M zB: --win_size=10k. Standard
10k.

-X, --fixed_size=
Feste Länge des Wertes.

-in, --verify=
Der Anteil der Datumsüberprüfung, zB: --verify=0.01

-D, --teilung=
Anzahl der Schlüssel, die einmal mehrfach abgerufen werden sollen. Standardwert 1, bedeutet einzelnes Get.

-S, --stat_freq=
Häufigkeit des Dumpings von statistischen Informationen. Suffix: s-Sekunden, m-Minuten, zB:
--resp_freq=10s.

-e, --exp_verify=
Der Anteil der Objekte mit Ablaufzeit, zB: --exp_verify=0.01. Standard-Nr
Objekt mit Ablaufzeit

-Ö, --overwrite=
Der Anteil der Objekte muss überschrieben werden, zB: --overwrite=0.01. Standard nie
Objekt überschreiben.

-R, --wiederverbinden
Reconnect-Tests, wenn die Verbindung geschlossen wird, wird sie erneut verbunden.

-U, --udp
UDP-Tests, Standard-Memaslap verwendet TCP, TCP-Port und UDP-Port des Servers müssen gleich sein.

-a, --Facebook
Ob es Facebook-Testfunktion aktiviert, mit TCP eingestellt und mit UDP multiget.

-B, --binär
Ob es das Binärprotokoll aktiviert. Standard mit ASCII-Protokoll.

-P, --tps=
Erwarteter Durchsatz, Suffix: K, zB: --tps=10k.

-P, --rep_write=
Der erste n-te Server kann Daten schreiben, zB: --rep_write=2.

-b, - ausführlich
Gibt an, ob detaillierte Informationen ausgegeben werden, wenn die Überprüfung fehlschlägt.

-h, --help
Diese Meldung anzeigen und dann beenden.

-V, --Version
Zeigen Sie die Version der Anwendung an und beenden Sie sie dann.

Beispiele:

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

HOME

Weitere Informationen finden Sie unter: http://libmemcached.org/

AUTOREN

Mingqiang Zhuang[E-Mail geschützt] > (Schoner-Technologie) Brian Aker, <‐
[E-Mail geschützt] >

Verwenden Sie memcaslap online mit den onworks.net-Diensten