memcaslap - Online in de cloud

PROGRAMMA:

NAAM

memaslap - libmemcached Documentatie

KORTE INHOUD

memaslap [opties]

--help

MEMCACHED_SERVERS

PRODUCTBESCHRIJVING

memaslap is een tool voor het genereren van belasting en benchmark voor memcached-servers. Het genereert
configureerbare werklast zoals threads, concurrencies, verbindingen, runtime, overschrijven,
miss rate, key size, value size, get/set proportie, verwachte doorvoer, enzovoort.
Verder test het ook gegevensverificatie, vervaltijdverificatie, UDP, binair
protocol, facebook-test, replicatietest, multi-get en herverbinding, enz.

Memaslap beheert netwerkverbindingen zoals memcached met libevent. Elke draad van memaslap
is gebonden aan een CPU-kern, alle threads communiceren niet met elkaar, en er zijn
meerdere socket-aansluitingen in elke thread. Elke verbinding houdt de verdeling van de sleutelgrootte bij,
waardegrootteverdeling en opdrachtverdeling op zich.

U kunt servers opgeven via de memklap --servers optie of via de omgevingsvariabele
MEMCACHED_SERVERS.

KENMERKEN

Memslap is ontwikkeld voor de volgende doeleinden:

Beheert netwerkverbindingen met libevent asynchroon.

Stel zowel TCP als UDP in om niet-blokkerende IO te gebruiken.

Verbetert parallelliteit: hogere prestaties in omgevingen met meerdere threads.

Verbetert de tijdefficiëntie: snellere verwerkingssnelheid.

Genereert sleutel en waarde efficiënter; sleutelgrootteverdeling en waardegrootte
distributie zijn configureerbaar.

Ondersteunt get, multi-get en set-commando's; opdrachtdistributie is configureerbaar.

Ondersteunt controleerbare miss rate en overwrite rate.

Ondersteunt gegevens- en vervaltijdverificatie.

Ondersteunt het periodiek dumpen van statistische informatie.

Ondersteunt duizenden TCP-verbindingen.

Ondersteunt binair protocol.

Ondersteunt Facebook-test (ingesteld met TCP en multi-get met UDP) en replicatietest.

BIJZONDERHEDEN

effectief uitvoering of netwerk.
Voor memaslap gebruiken zowel TCP als UDP niet-blokkerende netwerk-IO. Alle netwerkevenementen zijn:
beheerd door libevent als memcached. De netwerkmodule van memaslap is vergelijkbaar met memcached.
Libevent kan ervoor zorgen dat memaslap het netwerk zeer efficiënt aankan.

effectief uitvoering of meerdere draden en samenloop
Memslap heeft dezelfde implementatie van multi-threads als memcached. Memslap maakt er een
of meer zelfbestuurde threads; elke thread is gebonden aan één CPU-kern als het systeem tests
affiniteit voor de CPU-kern instellen.

Bovendien heeft elke thread een libevent om de gebeurtenissen van het netwerk te beheren; elke draad
heeft een of meer zelfbesturende concurrencies; en elke gelijktijdigheid heeft een of meer sockets
verbindingen. Alle concurrencies communiceren niet met elkaar, ook al zijn ze dat wel
in hetzelfde draadje.

Memslap kan duizenden socketverbindingen maken en elke gelijktijdigheid heeft tientallen
stopcontact aansluitingen. Elke gelijktijdigheid selecteert willekeurig of opeenvolgend één socket
verbinding van de socketverbindingspool om uit te voeren, zodat memaslap elke gelijktijdigheid kan garanderen
verwerkt op elk moment één socketverbinding. Gebruikers kunnen het aantal
concurrency en socketverbindingen van elke concurrency volgens hun verwachte
werkdruk.

effectief uitvoering of het genereren van sleutel en waarde
Om de tijd- en ruimte-efficiëntie te verbeteren, maakt memaslap een willekeurige
karakters tabel met 10M karakters. Alle achtervoegsels van sleutels en waarden worden gegenereerd
uit deze tabel met willekeurige tekens.

Memslap gebruikt de offset in de karaktertabel en de lengte van de string om a . te identificeren
snaar. Het kan veel geheugen besparen. Elke sleutel bestaat uit twee delen, een voorvoegsel en een achtervoegsel. De
voorvoegsel is een uint64_t, 8 bytes. Om de dataset eerder te verifiëren, moet memaslap:
zorg ervoor dat elke sleutel uniek is, dus het gebruikt het voorvoegsel om een ​​sleutel te identificeren. Het voorvoegsel kan niet
bevatten illegale tekens, zoals 'r', 'n', '0' en ' '. En memaslap heeft een algoritme
verzekeren dat.

Memslap genereert niet alle objecten (sleutel-waardeparen) aan het begin. het alleen
genereert voldoende objecten om het taakvenster (standaard 10K-objecten) van elk te vullen
gelijktijdigheid. Elk object heeft de volgende basisinformatie, sleutelvoorvoegsel, sleutelachtervoegsel:
offset in de tekentabel, sleutellengte, waardeverschuiving in de tekentabel en waarde
lengte.

In het werkproces selecteert elke gelijktijdigheid opeenvolgend of willekeurig een object uit de
venster om een ​​set-bewerking uit te voeren of een bewerking te krijgen. Tegelijkertijd begint elke gelijktijdigheid
objecten uit het venster en voegt er een nieuw object aan toe.

Eenvoudig maar nuttig taak scheduling
Memslap gebruikt libevent om alle concurrencies van threads en elke concurrency te plannen
plant taken op basis van het lokale taakvenster. Memslap gaat ervan uit dat als elke gelijktijdigheid
houdt dezelfde sleuteldistributie, waardedistributie en commandodistributie, van
buiten houdt memaslap de hele distributie bij. Elk taakvenster bevat veel
van objecten, slaat elk object zijn basisinformatie op, zoals sleutel, waarde, vervaltijd en
spoedig. Alle objecten in het venster behouden op elk moment dezelfde en vaste sleutel en waarde
verdeling. Als een object wordt overschreven, wordt de waarde van het object bijgewerkt.
Memslap verifieert de gegevens of vervaltijd volgens de objectinformatie die is opgeslagen in de
taak venster.

Libevent selecteert welke gelijktijdigheid moet worden afgehandeld op basis van een specifieke netwerkgebeurtenis. Dan de
gelijktijdigheid selecteert welke opdracht (get of set) moet worden uitgevoerd op basis van de opdracht
verdeling. Als het een oud object moet verwijderen en een nieuw object moet toevoegen om te behouden
dezelfde sleutel- en waardeverdeling, het nieuwe object moet dezelfde sleutellengte hebben en
waarde lengte.

Als de memcached-server twee cachelagen heeft (geheugen en SSD), draait memaslap met verschillende
venstergroottes kunnen verschillende cache-missers krijgen. Als memaslap genoeg objecten toevoegt aan de
vensters aan het begin, en de cache van memcached kan niet alle objecten opslaan
geïnitialiseerd, dan haalt memaslap enkele objecten uit de tweede cachelaag. Het veroorzaakt
de eerste cachelaag die je mist. Dus de gebruiker kan de venstergrootte specificeren om het verwachte te krijgen
mispercentage van de eerste cachelaag.

Nuttig uitvoering of meerdere servers , UDP, TCP, multi-krijg en binair protocol
Omdat elke thread autonoom is, kan memaslap verschillende threads toewijzen om te verwerken
verschillende memcached-servers. Dit is slechts een van de manieren waarop memaslap meerdere test
servers. De enige beperking is dat het aantal servers niet groter kan zijn dan de
aantal draden. De andere manier om meerdere servers te testen is voor replicatietest. Elk
concurrency heeft één socketverbinding met elke memcached-server. Voor de uitvoering is
memaslap kan sommige objecten op één geheugencacheserver zetten en deze objecten ophalen van de
andere servers.

Memslap doet standaard single get. Als de gebruiker de multi-get-optie specificeert, zal memaslap:
verzamel genoeg krijg commando's en pak en verzend de commando's samen.

Memslap test zowel het ASCII-protocol als het binaire protocol, maar het werkt op het ASCII
standaardprotocol. Memslap draait standaard op het TCP-protocol, maar het test ook UDP.
Omdat UDP onbetrouwbaar is, kunnen er pakketten vallen en pakketten die niet in orde zijn. Memslap
creëert een geheugenbuffer om deze problemen op te lossen. Memslap probeert alle reacties te lezen
gegevens van één opdracht van de server en herschikt de antwoordgegevens. Als sommige pakketten krijgen
verloren gaat, kan het wacht-time-outmechanisme ervoor zorgen dat halfgebakken pakketten worden weggegooid en
het volgende commando wordt verzonden.

GEBRUIK

Hieronder staan ​​enkele gebruiksvoorbeelden:

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 configuratie -t 2m -w 40k -S 20s -o 0.2

memaslap -s 127.0.0.1:11211 -F configuratie -t 2m -T 4 -c 128 -d 20 -P 40k

memaslap -s 127.0.0.1:11211 -F configuratie -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

De gebruiker moet minimaal één server specificeren om memaslap uit te voeren. De rest van de parameters hebben
standaardwaarden, zoals hieronder weergegeven:

Draadnummer = 1 Gelijktijdigheid = 16

Runtime = 600 seconden Configuratiebestand = NULL

Sleutelgrootte = 64 Waardegrootte = 1024

Ophalen/instellen = 9:1 Venstergrootte = 10k

Nummer uitvoeren = 0 Enkele get = waar

Multi-get = false Aantal sockets van elke gelijktijdigheid = 1

Opnieuw verbinden = onwaar Gegevensverificatie = onwaar

Vervaltijdverificatie = onwaar ASCII-protocol = waar

Binair protocol = fout Statistiekgegevens dumpen

periodiek = false

Overschrijfaandeel = 0% UDP = onwaar

TCP = waar Beperkt doorvoer = onwaar

Facebook-test = onwaar Replicatietest = onwaar

sleutel grootte, waarde grootte en commando distributie.
Alle distributies worden gelezen uit het configuratiebestand dat door de gebruiker is opgegeven met
“—cfg_cmd” optie. Als de gebruiker geen configuratiebestand opgeeft, wordt memaslap uitgevoerd
met de standaardverdeling (sleutelgrootte = 64, waardegrootte = 1024, get/set = 9:1). Voor
informatie over het bewerken van het configuratiebestand, raadpleeg het "Configuratiebestand"
pagina.

De minimale sleutelgrootte is 16 bytes; de maximale sleutelgrootte is 250 bytes. De precisie van
aandeel is 0.001. Het verdelingspercentage wordt afgerond op 3 decimalen.

De minimale waarde is 1 bytes; de maximale waarde is 1M bytes. De precisie van
aandeel is 0.001. Het verdelingspercentage wordt afgerond op 3 decimalen.
Momenteel test memaslap alleen de commando's die worden ingesteld en opgehaald. En het test 100% set en 100% get.
Voor 100% get, zal het een aantal objecten vooraf instellen op de server.

Meerdradig en samenloop
De hoge prestaties van memaslap profiteren van het speciale schema van draad en
gelijktijdigheid. Het is belangrijk om het juiste aantal ervan op te geven. Het standaard aantal
draden is 1; het standaard aantal gelijktijdigheid is 16. De gebruiker kan “—threads” en . gebruiken
"--concurrency" om deze variabelen te specificeren.

Als het systeem de CPU-affiniteit en het aantal threads dat door de gebruiker is opgegeven, test:
groter is dan 1, zal memaslap proberen elke thread aan een andere CPU-kern te binden. Dus indien
u de beste prestatie memaslap wilt krijgen, is het beter om het aantal op te geven
thread gelijk aan het aantal CPU-kernen. Het aantal threads gespecificeerd door de gebruiker kan
ook kleiner of groter zijn dan het aantal CPU-kernen. Vanwege de beperking van
implementatie, kan het aantal concurrencies het veelvoud zijn van het aantal
threads.

1. Voor 8 CPU-kernensysteem:

Bijvoorbeeld:

--threads=2 --gelijktijdigheid=128

--threads=8 --gelijktijdigheid=128

--threads=8 --gelijktijdigheid=256

--threads=12 --gelijktijdigheid=144

2. Voor 16 CPU-kernensysteem:

Bijvoorbeeld:

--threads=8 --gelijktijdigheid=128

--threads=16 --gelijktijdigheid=256

--threads=16 --gelijktijdigheid=512

--threads=24 --gelijktijdigheid=288

De memaslap presteert erg goed wanneer deze wordt gebruikt om de prestaties van memcached-servers te testen.
Meestal is de bottleneck het netwerk of de server. Als om de een of andere reden de gebruiker
de prestaties van memaslap wil beperken, zijn er twee manieren om dit te doen:

Verminder het aantal threads en concurrencies. Gebruik de optie "--tps" die memaslap
biedt om de doorvoer te beperken. Met deze optie kan de gebruiker de verwachte
doorvoer. Neem bijvoorbeeld aan dat de maximale doorvoer 50 kops/s is voor een specifieke
configuratie, kunt u de doorvoer opgeven die gelijk is aan of kleiner is dan de maximale doorvoer
met de optie "--tps".

venster grootte
Meestal hoeft de gebruiker de venstergrootte niet op te geven. Het standaardvenster
maat is 10k. Voor Schooner Memcached kan de gebruiker verschillende venstergroottes specificeren om te krijgen
verschillende cache-missers op basis van de testcase. Memslap testss cache miss rate tussen
0% en 100%. Als u dit hulpprogramma gebruikt om de prestaties van Schooner Memcached te testen, kunt u:
kan een juiste venstergrootte specificeren om het verwachte aantal cachemissers te krijgen. De formule voor
het berekenen van de venstergrootte is als volgt:

Neem aan dat de sleutelgrootte 128 bytes is en dat de waarde 2048 bytes is, en
gelijktijdigheid=128.

1. Kleine cache cache_size=1M, 100% cachemisser (alle gegevens komen van SSD). win_size=10k

2. cache_grootte=4G

(1). cache mispercentage 0%

win_size=8k

(2). cache mispercentage 5%

win_size=11k

3. cache_grootte=16G

(1). cache mispercentage 0%

win_size=32k

(2). cache missen

tarief 5%

win_size=46k

De formule voor het berekenen van de venstergrootte voor cache-missers 0%:

cache_size / gelijktijdigheid / (key_size + value_size) * 0.5

De formule voor het berekenen van de venstergrootte voor cache-missers 5%:

cache_size / gelijktijdigheid / (key_size + value_size) * 0.7

Verificatie
Memslap test zowel gegevensverificatie als vervaltijdverificatie. De gebruiker kan gebruiken:
"--verify=" of "-v" om het aandeel van gegevensverificatie op te geven. In theorie test het
100% gegevensverificatie. De gebruiker kan "--exp_verify=" of "-e" gebruiken om de verhouding te specificeren
van vervaltijdverificatie. In theorie test het 100% vervaltijdverificatie. Specificeer
de "--uitgebreide" opties om meer gedetailleerde foutinformatie te krijgen.

Bijvoorbeeld: --exp_verify=0.01 –verify=0.1 , dit betekent dat 1% van de objecten die zijn ingesteld met
vervaltijd, wordt 10% van de verkregen objecten geverifieerd. Als de objecten zijn verkregen,
memaslap zal de vervaltijd en waarde verifiëren.

meerdere servers en multi-configuratie
Memslap test multi-servers op basis van zelfbeheerde thread. Er is een beperking dat
het aantal servers kan niet groter zijn dan het aantal threads. Memslap wijst er een toe
thread om op zijn minst één server af te handelen. De gebruiker kan de optie "--servers=" of "-s" gebruiken om
specificeer meerdere servers.

Bijvoorbeeld:

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

Het bovenstaande commando betekent dat er 6 threads zijn, waarbij elke thread 6 concurrencies heeft
en dat threads 0 en 3 server 0 afhandelen (10.1.1.1); threads 1 en 4 behandelen server 1
(10.1.1.2); en thread 2 en 5 behandelen server 2 (10.1.1.3).

Alle threads en concurrencies in memaslap zijn autonoom.

Zo ook memaslap. De gebruiker kan meerdere memaslap-instanties opstarten. De gebruiker kan uitvoeren
memaslap op verschillende clientcomputers om te communiceren met dezelfde memcached-server op de
dezelfde. Het wordt aanbevolen dat de gebruiker verschillende memaslap op verschillende machines start met:
dezelfde configuratie.

lopen Met uitvoeren aantal mode or niet de tijd of mode
De standaard memaslap werkt met de tijdmodus. De standaard looptijd is 10 minuten. Als het keer is
uit, wordt memaslap afgesloten. Geef niet tegelijkertijd zowel de uitvoeringsnummermodus als de tijdmodus op
tijd; specificeer er gewoon een in plaats daarvan.

Bijvoorbeeld:

--time=30s (Dit betekent dat de test 30 seconden duurt.)

--execute_number=100000 (Dit betekent dat na het uitvoeren van 100000 commando's, de test wordt afgesloten.)

Storten statistisch informatie periodiek.
De gebruiker kan "--stat_freq=" of "-S" gebruiken om de frequentie op te geven.

Bijvoorbeeld:

--stat_freq=20s

Memslap dumpt de statistieken van de commando's (ophalen en instellen) met de frequentie van elke
20 seconden.

Voor meer informatie over het formaat van dumpingstatistieken, zie “Formaat van
Uitgang” sectie.

Multi-krijg
De gebruiker kan "--division=" of "-d" gebruiken om het aantal sleutels voor meerdere ophalen op te geven. Memslap door
standaard doet single get met TCP. Memslap test ook gegevensverificatie en vervaltijd
verificatie voor multi-get.

Memslap test multi-get met zowel TCP als UDP. Door de verschillende uitvoering van
het ASCII-protocol en het binaire protocol, zijn er enkele verschillen tussen de twee. Voor
het ASCII-protocol, memaslap stuurt één keer één "multi-get" naar de server. voor de binaire
protocol, memaslap stuurt verschillende enkele get-commando's samen als "multi-get" naar de
server.

UDP en TCP
Memslap test zowel UDP als TCP. Voor TCP maakt memaslap geen verbinding met de memcached-server
als stopcontactverbindingen verloren gaan. Als alle socketverbindingen zijn verbroken of de server in het geheugen is opgeslagen
crasht, wordt memaslap afgesloten. Als de gebruiker de optie "--reconnect" specificeert wanneer socket
verbindingen verloren gaan, zal het ze opnieuw verbinden.

De gebruiker kan "--udp" gebruiken om de UDP-functie in te schakelen, maar UDP heeft enkele beperkingen:

UDP kan geen gegevens meer dan 1400 bytes instellen.

UDP wordt niet getest door het binaire protocol omdat het binaire protocol van memcached dat wel doet
test dat niet.

UDP test geen herverbinding.

Facebook proef
Stel gegevens in met TCP en multi-get met UDP. Geef de volgende opties op:

"--facebook --division=50"

Als u duizenden TCP-verbindingen wilt maken, specificeert u de

"--conn_sock=" optie.

Bijvoorbeeld: --facebook --division=50 --conn_sock=200

Het bovenstaande commando betekent dat memaslap een Facebook-test zal doen, elke gelijktijdigheid heeft 200
socket TCP-verbindingen en één UDP-socket.

Memslap stelt objecten in met de TCP-socket en multi-krijgt 50 objecten eenmaal met de UDP
stopcontact.

Als u "--division=50" opgeeft, moet de sleutelgrootte kleiner zijn dan 25 bytes omdat de UDP
pakketgrootte is 1400 bytes.

kopiëren proef
Voor de replicatietest moet de gebruiker ten minste twee memcached-servers specificeren. De gebruiker kan
gebruik de optie "—rep_write=" om de functie in te schakelen.

Bijvoorbeeld:

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

De bovenstaande opdracht betekent dat er 2 replicatie-memcached-servers zijn, memaslap wordt ingesteld
objecten naar zowel server 0 als server 1, haal objecten op die eerder op server 0 zijn ingesteld van
server 1, en haal ook objecten op die eerder op server 1 zijn ingesteld van server 0. Als server 0
crasht, krijgt memaslap alleen objecten van server 1. Als server 0 weer tot leven komt
nogmaals, memaslap maakt opnieuw verbinding met server 0. Als zowel server 0 als server 1 crashen, memaslap
zal afsluiten.

steunen duizenden kosten of TCP verbindingen
Start memaslap met "--conn_sock=" of "-n" om deze functie in te schakelen. Zorg ervoor dat uw
systeem kan testen duizenden bestanden openen en duizenden sockets maken. Echter,
deze functie test het opnieuw verbinden niet als stopcontacten worden losgekoppeld.

Bijvoorbeeld:

--threads=8 --gelijktijdigheid=128 --conn_sock=128

Het bovenstaande commando betekent dat memaslap 8 threads start, elke thread heeft 16
concurrencies, elke concurrency heeft 128 TCP-socketverbindingen en het totale aantal
TCP-socketverbindingen zijn 128 * 128 = 16384.

steunen binair protocol
Start memaslap met "--binary" of "-B" opties om deze functie in te schakelen. Het test alle
bovenstaande functies behalve UDP, omdat de nieuwste memcached 1.3.3 geen binair implementeert
UDP-protocol.

Bijvoorbeeld:

--binair

Aangezien memcached 1.3.3 geen binair UDP-protocol implementeert, test memaslap UDP niet.
Bovendien test memcached 1.3.3 geen multi-get. Als u "--division=50" opgeeft
optie, het stuurt gewoon 50 get-commando's samen als "mulit-get" naar de server.

CONFIGURATIE FILE

In dit gedeelte wordt de indeling van het configuratiebestand beschreven. Standaard wanneer nee
configuratiebestand is opgegeven memaslap leest het standaardbestand dat zich bevindt op ~/.memaslap.cnf.

Hieronder vindt u een voorbeeldconfiguratiebestand:

-------------------------------------------------- -------------------------
#commentaar moet beginnen met '#'
#toets
#start_len end_len proportie
#
#sleutellengtebereik van start_len tot end_len
#start_len moet gelijk zijn aan of groter zijn dan 16
#end_len moet gelijk zijn aan of kleiner zijn dan 250
#start_len moet gelijk zijn aan of groter zijn dan end_len
#memaslap genereert sleutels volgens het sleutelbereik
#proportion: geeft sleutels aan die zijn gegenereerd op basis van één bereikaccounts voor het totaal
gegenereerde sleutels
#
#voorbeeld1: sleutelbereik 16~100 is goed voor 80%
# sleutelbereik 101~200 is goed voor 10%
# sleutelbereik 201~250 is goed voor 10%
# totaal moet 1 zijn (0.8+0.1+0.1 = 1)
#
# 16 100 0.8
# 101 200 0.1
# 201 249 0.1
#
#voorbeeld2: alle sleutels zijn 128 bytes lang
#
# 128 128 1
sleutel
128 128 1
#waarde
#start_len end_len proportie
#
#waarde lengtebereik van start_len tot end_len
#start_len moet gelijk zijn aan of groter zijn dan 1
#end_len moet gelijk zijn aan of kleiner zijn dan 1M
#start_len moet gelijk zijn aan of groter zijn dan end_len
#memaslap genereert waarden volgens het waardebereik
#proportion: geeft waarden aan die zijn gegenereerd op basis van één bereikaccounts voor de
totaal gegenereerde waarden
#
#voorbeeld1: waardebereik 1~1000 is goed voor 80%
# waardebereik 1001~10000 is goed voor 10%
# waardebereik 10001~100000 is goed voor 10%
# totaal moet 1 zijn (0.8+0.1+0.1 = 1)
#
# 1 1000 0.8
# 1001 10000 0.1
# 10001 100000 0.1
#
#voorbeeld2: alle waarden zijn 128 bytes
#
# 128 128 1
waarde
2048 2048 1
#cmd
#cmd_type cmd_proportie
#
#momenteel memaslap alleen testss opdracht ophalen en instellen.
#
#cmd_type
#stel 0 in
#haal 1
#
#voorbeeld: stel opdrachtaccounts in voor 50%
# get command is goed voor 50%
# totaal moet 1 zijn (0.5+0.5 = 1)
#
#cmd
# 0
# 1
cmd
0 0.1
1.0 0.9

FORMAT OF OUTPUT

In het begin geeft memaslap als volgt enige configuratie-informatie weer:

servers: 127.0.0.1:11211

aantal threads: 1

gelijktijdigheid: 16

looptijd: 20s

venstergrootte: 10k

stel verhouding in: set_prop=0.10

krijg proportie: get_prop=0.90

Waar
servers: "servers"
De servers die worden gebruikt door memaslap.

threads tellen
Het aantal threads waarmee memaslap wordt uitgevoerd.

samenloop
Het aantal concurrencies waar memaslap mee loopt.

runtime
Hoe lang memaslap draaien.

venstergrootte
De grootte van het taakvenster van elke gelijktijdigheid.

proportie instellen
Het aandeel van het ingestelde commando.

proportie krijgen
De proportie van het commando 'krijgen'.

De output van dynamische statistieken is ongeveer als volgt:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Statistieken ophalen
Type Tijd(en) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Gem(us) Std_dev Geo_dist
Periode 5 345826 69165 65.3 0 27 2198 203
95.43 177.29
Wereldwijd 20 1257935 62896 71.8 0 26 3791 224
117.79 192.60

Statistieken instellen
Type Tijd(en) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Gem(us) Std_dev Geo_dist
Periode 5 38425 7685 7.3 0 42 628 240
88.05 220.21
Wereldwijd 20 139780 6989 8.0 0 37 3790 253
117.93 224.83

Totale statistieken
Type Tijd(en) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Gem(us) Std_dev Geo_dist
Periode 5 384252 76850 72.5 0 27 2198 207
94.72 181.18
Wereldwijd 20 1397720 69886 79.7 0 26 3791 227
117.93 195.60
-------------------------------------------------- -------------------------------------------------- -----------------------------

Waar
Statistieken ophalen
Statistieken informatie van opdracht ophalen

Statistieken instellen
Statistieken informatie van set commando

Totale statistieken
Statistiekinformatie van zowel de opdracht Get als Set

Periode
Resultaat binnen een periode

Globaal
Geaccumuleerde resultaten

Ops
Totaal aantal bewerkingen

TPS
Doorvoer, bewerkingen/seconde

Netto
De snelheid van netwerk

Ontvang_miss
Hoeveel objecten kunnen niet worden verkregen

min
De minimale reactietijd

Max
De maximale reactietijd

Gem:
De gemiddelde reactietijd

Std_dev
Standaarddeviatie van responstijd

Geo_afst
Geometrische verdeling op basis van natuurlijke exponentiële functie

Aan het einde zal memaslap zoiets als dit weergeven:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Statistieken ophalen (1257956 evenementen)
Min: 26
Max: 3791
Gem: 224
Geo: 192.60
Standaard: 116.23
Log2 Afst:
4: 0 10 84490 215345
8: 484890 459823 12543 824
12: 31

Statistieken instellen (139782 gebeurtenissen)
Min: 37
Max: 3790
Gem: 253
Geo: 224.84
Standaard: 116.83
Log2 Afst:
4: 0 0 4200 16988
8: 50784 65574 2064 167
12: 5

Totaal statistieken (1397738 evenementen)
Min: 26
Max: 3791
Gem: 227
Geo: 195.60
Standaard: 116.60
Log2 Afst:
4: 0 10 88690 232333
8: 535674 525397 14607 991
12: 36

cmd_get: 1257969
cmd_set: 139785
get_misses: 0
verifiëren_missers: 0
verifiëren_failed: 0
verlopen_get: 0
niet-verlopen_unget: 0
geschreven_bytes: 242516030
lees_bytes: 1003702556
object_bytes: 152086080
pakket_stoornis: 0
pakket_drop: 0
udp_timeout: 0

Looptijd: 20.0s Ops: 1397754 TPS: 69817 Netto_rate: 59.4M/s
-------------------------------------------------- -------------------------------------------------- -----------------------------

Waar
Statistieken ophalen
Statistieken van de responstijd ophalen

Statistieken instellen
Statistieken van responstijd instellen

Totale statistieken
Beide statistieken van de responstijd ophalen en instellen

min
De geaccumuleerde en minimale responstijd

Max
De geaccumuleerde en maximale responstijd

Gem
De geaccumuleerde en gemiddelde responstijd

Std
Standaarddeviatie van responstijd

Log2 Verst
Geometrische verdeling op basis van logaritme 2

cmd_get
Totaal aantal opdrachten gedaan

cmd_set
Totaal aantal ingestelde commando's gedaan

krijg_missen
Hoeveel objecten kunnen niet van de server worden opgehaald

verifiëren_missers
Hoeveel objecten moeten worden geverifieerd, maar kunnen ze niet krijgen

verifiëren_failed
Hoeveel objecten met aanhoudende waarde

verlopen_get
Hoeveel objecten zijn verlopen, maar we krijgen ze

unexpired_unget
Hoeveel objecten zijn niet verlopen, maar we kunnen ze niet krijgen

geschreven_bytes
Totaal geschreven bytes

lees_bytes
Totaal aantal gelezen bytes

object_bytes
Totaal aantal objectbytes

pakket_stoornis
Hoeveel UDP-pakketten zijn wanorde?

pakket_drop
Hoeveel UDP-pakketten gaan verloren

udp_time-out
Hoe vaak gebeurt er een UDP-time-out

Looptijd
Totale looptijd

Ops
Totaal aantal bewerkingen

TPS
Doorvoer, bewerkingen/seconde

Nettotarief
De gemiddelde netwerksnelheid

OPTIES

-Ja, --servers=
Maak een lijst van een of meer servers om verbinding mee te maken. Het aantal servers moet kleiner zijn dan het aantal threads.
bijvoorbeeld: --servers=localhost:1234,localhost:11211

-T, --draden=
Aantal threads om op te starten, beter gelijk aan CPU-nummers. Standaard 8.

-C, --gelijktijdigheid=
Aantal gelijktijdigheid dat moet worden gesimuleerd met belasting. Standaard 128.

-N, --conn_sok=
Aantal TCP-sokken per gelijktijdigheid. Standaard 1.

-X, --execute_nummer=
Aantal bewerkingen (get en set) om uit te voeren voor de gegeven test. Standaard 1000000.

-T, --tijd=
Hoe lang de test moet worden uitgevoerd, achtervoegsel: s-seconden, m-minuten, h-uren, d-dagen bijv.:
--tijd=2u.

-F, --cfg_cmd=
Laad het configuratiebestand om de opdracht-, sleutel- en waardedistributielijst te krijgen.

-w, --win_grootte=
Taakvenstergrootte van elke gelijktijdigheid, achtervoegsel: K, M, bijvoorbeeld: --win_size=10k. Standaard
10k.

-X, --vaste_grootte=
Vaste lengte van waarde.

-in, --verifieer=
Het aandeel van datumverificatie, bijvoorbeeld: --verify=0.01

-NS, --divisie=
Aantal sleutels om een ​​keer te multi-krijgen. Standaard 1, betekent enkele get.

-S, --stat_freq=
Frequentie van statistische informatie over dumpen. achtervoegsel: s-seconden, m-minuten, bijv.:
--resp_freq=10s.

-e, --exp_verify=
Het aandeel objecten met een vervaltijd, bijvoorbeeld: --exp_verify=0.01. Standaard nr
object met vervaltijd

-O, --overschrijven=
Het aantal objecten dat moet worden overschreven, bijvoorbeeld: --overwrite=0.01. standaard nooit
object overschrijven.

-R, --opnieuw verbinden
Tests opnieuw verbinden, wanneer de verbinding wordt verbroken, wordt deze opnieuw verbonden.

-U, --udp
UDP-tests, standaard memaslap gebruikt TCP, de TCP-poort en de UDP-poort van de server moeten hetzelfde zijn.

-a, --facebook
Of het nu de Facebook-testfunctie inschakelt, ingesteld met TCP en multi-get met UDP.

-B, --binair
Of het binair protocol inschakelt. Standaard met ASCII-protocol.

-P, --tps=
Verwachte doorvoer, achtervoegsel: K, bijv.: --tps=10k.

-P, --rep_write=
De eerste n-de servers kunnen gegevens schrijven, bijvoorbeeld: --rep_write=2.

-b, --uitgebreid
Of het gedetailleerde informatie geeft wanneer de verificatie mislukt.

-h, --help
Geef dit bericht weer en sluit af.

-V, --versie
Geef de versie van de applicatie weer en sluit af.

Voorbeelden

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 configuratie -t 2m -w 40k -S 20s -o 0.2

memaslap -s 127.0.0.1:11211 -F configuratie -t 2m -T 4 -c 128 -d 20 -P 40k

memaslap -s 127.0.0.1:11211 -F configuratie -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

Kijk voor meer informatie op: http://libmemcached.org/

AUTEURS

Mingqiang Zhuang[e-mail beveiligd]> (Schooner-technologie) Brian Aker, <‐
[e-mail beveiligd]>

Gebruik memcaslap online met onworks.net-services