memcaslap - Online în cloud

PROGRAM:

NUME

memaslap - documentație libmemcached

REZUMAT

memaslap [opțiuni]

--Ajutor

MEMCACHED_SERVERS

DESCRIERE

memaslap este un instrument de generare a încărcăturii și de referință pentru serverele memcache. Ea generează
sarcină de lucru configurabilă, cum ar fi fire de execuție, concurențe, conexiuni, timp de rulare, suprascriere,
rata de ratare, dimensiunea cheii, dimensiunea valorii, proporția obține/setează, debitul așteptat și așa mai departe.
În plus, testează și verificarea datelor, verificarea timpului de expirare, UDP, binar
protocol, test facebook, test de replicare, multi-get și reconectare etc.

Memaslap gestionează conexiunile de rețea, cum ar fi memcached cu libevent. Fiecare fir de memaslap
este legat cu un nucleu CPU, toate firele de execuție nu comunică între ele și există
mai multe prize în fiecare filet. Fiecare conexiune păstrează distribuția dimensiunii cheii,
distribuția mărimii valorii și distribuția comenzilor în sine.

Puteți specifica servere prin intermediul memslap --servere opțiune sau prin variabila de mediu
MEMCACHED_SERVERS.

CARACTERISTICI

Memslap este dezvoltat pentru următoarele scopuri:

Gestionează conexiunile de rețea cu libevent în mod asincron.

Setați atât TCP, cât și UDP pentru a utiliza IO non-blocante.

Îmbunătățește paralelismul: performanță mai mare în medii cu mai multe fire.

Îmbunătățește eficiența timpului: viteză mai rapidă de procesare.

Generează cheie și valoare mai eficient; distribuția dimensiunii cheii și dimensiunea valorii
distribuția sunt configurabile.

Suportă comenzi get, multi-get și set; distribuția comenzilor este configurabilă.

Acceptă rata de ratare controlabilă și rata de suprascriere.

Acceptă datele și verificarea timpului de expirare.

Acceptă descărcarea periodică a informațiilor statistice.

Suportă mii de conexiuni TCP.

Suporta protocolul binar.

Suportă testul Facebook (setat cu TCP și multi-get cu UDP) și testul de replicare.

DETALII

Eficace implementarea of rețea.
Pentru memaslap, atât TCP, cât și UDP folosesc IO de rețea care nu blochează. Toate evenimentele din rețea sunt
gestionat de libevent ca memcache. Modulul de rețea al memaslap este similar cu memcached.
Libevent se poate asigura că memaslap poate gestiona rețeaua foarte eficient.

Eficace implementarea of cu mai multe fire și concurență
Memslap are o implementare similară a multi-thread-urilor cu memcached. Memslap creează unul
sau mai multe fire auto-guvernate; fiecare fir este legat cu un nucleu CPU dacă sistemul este testat
setarea afinității nucleului procesorului.

În plus, fiecare thread are un libevent pentru a gestiona evenimentele din rețea; fiecare fir
are una sau mai multe concurențe autonome; și fiecare concurență are una sau mai multe prize
conexiuni. Toate concurențele nu comunică între ele, deși sunt
in acelasi fir.

Memslap poate crea mii de conexiuni socket și fiecare concurență are zeci de
conexiuni prize. Fiecare concurență selectează aleatoriu sau secvenţial un soclu
conexiunea din pool-ul său de conexiuni la socket să ruleze, astfel încât memaslap poate asigura fiecare concurență
se ocupă de o conexiune priză la un moment dat. Utilizatorii pot specifica numărul de
concurența și conexiunile socket ale fiecărei concurențe conform așteptărilor lor
volumul de muncă.

Eficace implementarea of generator cheie și valoare
Pentru a îmbunătăți eficiența timpului și eficiența spațiului, memaslap creează o aleatorie
tabel de caractere cu 10 milioane de caractere. Sunt generate toate sufixele cheilor și valorilor
din acest tabel cu caractere aleatorii.

Memslap folosește offset-ul din tabelul de caractere și lungimea șirului pentru a identifica a
şir. Poate economisi multă memorie. Fiecare cheie conține două părți, un prefix și un sufix. The
prefixul este un uint64_t, 8 octeți. Pentru a verifica setul de date înainte, memaslap trebuie
asigurați-vă că fiecare cheie este unică, așa că folosește prefixul pentru a identifica o cheie. Prefixul nu poate
include caractere ilegale, cum ar fi „r”, „n”, „0” și „”. Și memaslap are un algoritm
a se asigura ca.

Memslap nu generează toate obiectele (perechile cheie-valoare) la început. Doar
generează suficiente obiecte pentru a umple fereastra de activitate (implicit 10K obiecte) pentru fiecare
concurență. Fiecare obiect are următoarele informații de bază, prefix cheie, sufix cheie
offset în tabelul de caractere, lungimea cheii, offset-ul valorii în tabelul de caractere și valoare
lungime.

În procesul de lucru, fiecare concurență selectează secvenţial sau aleatoriu un obiect din
fereastra pentru a efectua operația de setare sau pentru a obține operațiunea. În același timp, fiecare concurență începe
obiecte din fereastra sa și adaugă obiecte noi în ea.

simplu dar util sarcină programare
Memslap folosește libevent pentru a programa toate concurența firelor și fiecare concurență
programează sarcini în funcție de fereastra locală de activități. Memslap presupune că dacă fiecare concurență
păstrează aceeași distribuție a cheilor, distribuția valorii și distribuția comenzilor, de la
în afară, memaslap păstrează toată distribuția ca întreg. Fiecare fereastră de activitate include o mulțime
de obiecte, fiecare obiect stochează informațiile sale de bază, cum ar fi cheia, valoarea, timpul de expirare și
curând. În orice moment, toate obiectele din fereastră păstrează aceeași cheie și valoare fixă
distributie. Dacă un obiect este suprascris, valoarea obiectului va fi actualizată.
Memslap verifică datele sau timpul de expirare în funcție de informațiile despre obiect stocate în
fereastra sarcinii.

Libevent selectează ce concurență să gestioneze pe baza unui anumit eveniment de rețea. Apoi
concurența selectează ce comandă (get sau set) să opereze pe baza comenzii
distributie. Dacă trebuie să dea afară un obiect vechi și să adauge un nou obiect, pentru a păstra
aceeași cheie și aceeași distribuție a valorii, noul obiect trebuie să aibă aceeași lungime a cheii și
lungimea valorii.

Dacă serverul memcached are două straturi de cache (memorie și SSD), rulează memaslap cu diferite
Dimensiunile ferestrelor pot obține rate diferite de pierdere a memoriei cache. Dacă memaslap adaugă suficiente obiecte în
windows la început, iar memoria cache a memcached nu poate stoca toate obiectele
initializat, apoi memaslap va primi unele obiecte din al doilea strat de cache. Cauzează
primul strat de cache pierdut. Deci, utilizatorul poate specifica dimensiunea ferestrei pentru a obține valoarea așteptată
rata de pierderi a primului strat de cache.

util implementarea of multi-servere , UDP, TCP, multi-get și binar protocol
Deoarece fiecare thread este auto-guvernat, memaslap poate atribui fire diferite de gestionat
diferite servere memcache. Acesta este doar unul dintre modalitățile prin care memaslap testează multiple
servere. Singura limitare este că numărul de servere nu poate fi mai mare decât
numărul de fire. Cealaltă modalitate de a testa mai multe servere este testul de replicare. Fiecare
concurența are o conexiune socket la fiecare server memcached. Pentru implementare,
memaslap poate seta unele obiecte pe un server memcache și poate obține aceste obiecte de la
alte servere.

În mod implicit, Memslap primește un singur. Dacă utilizatorul specifică opțiunea multi-get, memaslap va face
strângeți suficiente comenzi get și împachetați și trimiteți comenzile împreună.

Memslap testează atât protocolul ASCII, cât și protocolul binar, dar rulează pe ASCII
protocol implicit. Memslap rulează implicit pe protocolul TCP, dar testează și UDP.
Deoarece UDP nu este de încredere, pot apărea pachete abandonate și pachete necomandate. Memslap
creează un buffer de memorie pentru a gestiona aceste probleme. Memslap încearcă să citească tot răspunsul
datele unei comenzi de pe server și reordonează datele de răspuns. Dacă unele pachete primesc
pierdut, mecanismul de timeout de așteptare poate asigura că pachetele semicoapte vor fi aruncate și
următoarea comandă va fi trimisă.

UTILIZARE

Mai jos sunt câteva exemple de utilizare:

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

Utilizatorul trebuie să specifice cel puțin un server pentru a rula memaslap. Restul parametrilor au
valori implicite, după cum se arată mai jos:

Număr fir = 1 Concurență = 16

Timp de rulare = 600 de secunde Fișier de configurare = NULL

Dimensiunea cheii = 64 Dimensiunea valorii = 1024

Get/set = 9:1 Dimensiunea ferestrei = 10k

Executare număr = 0 Single get = true

Multi-get = fals Numărul de prize ale fiecărei concurențe = 1

Reconectare = fals Verificarea datelor = fals

Verificarea timpului de expirare = fals Protocol ASCII = adevărat

Protocol binar = informații statistice de Dumping false

periodic = fals

Proporția de suprascriere = 0% UDP = fals

TCP = adevărat Limitarea debitului = fals

Test Facebook = fals Test de replicare = fals

Cheie mărimea, valoare mărimea și comandă distribuție.
Toate distribuțiile sunt citite din fișierul de configurare specificat de utilizator cu
Opțiunea „—cfg_cmd”. Dacă utilizatorul nu specifică un fișier de configurare, memaslap va rula
cu distribuția implicită (dimensiunea cheii = 64, dimensiunea valorii = 1024, get/set = 9:1). Pentru
informații despre cum să editați fișierul de configurare, consultați „Fișierul de configurare”
secţiune.

Dimensiunea minimă a cheii este de 16 octeți; dimensiunea maximă a cheii este de 250 de octeți. Precizia de
proporția este 0.001. Proporția de distribuție va fi rotunjită la 3 zecimale.

Dimensiunea minimă a valorii este de 1 octeți; dimensiunea maximă a valorii este de 1M de octeți. Precizia de
proporția este 0.001. Proporția de distribuție va fi rotunjită la 3 zecimale.
În prezent, memaslap testează doar setarea și obținerea comenzilor. Și testează 100% setat și 100% obține.
Pentru 100% get, va preseta unele obiecte pe server.

Multi-threaded și concurență
Performanța ridicată a memaslap beneficiază de programul special de fir și
concurență. Este important să specificați numărul corect al acestora. Numărul implicit de
fire este 1; numărul implicit de concurență este 16. Utilizatorul poate folosi „—threads” și
„--concurrency” pentru a specifica aceste variabile.

Dacă sistemul testează setarea afinității CPU și a numărului de fire specificate de utilizator
este mai mare decât 1, memaslap va încerca să lege fiecare fir la un nucleu diferit al procesorului. Astfel, dacă
doriți să obțineți cea mai bună performanță memaslap, este mai bine să specificați numărul de
fir egal cu numărul de nuclee CPU. Numărul de fire specificat de utilizator poate
de asemenea, să fie mai mic sau mai mare decât numărul de nuclee CPU. Din cauza limitării de
implementare, numărul de concurențe ar putea fi multiplu al numărului de
fire.

1. Pentru sistem cu 8 nuclee CPU

De exemplu:

--threads=2 --concurrency=128

--threads=8 --concurrency=128

--threads=8 --concurrency=256

--threads=12 --concurrency=144

2. Pentru sistem cu 16 nuclee CPU

De exemplu:

--threads=8 --concurrency=128

--threads=16 --concurrency=256

--threads=16 --concurrency=512

--threads=24 --concurrency=288

Memaslap funcționează foarte bine, atunci când este folosit pentru a testa performanța serverelor memcached.
De cele mai multe ori, blocajul este rețeaua sau serverul. Dacă dintr-un motiv oarecare utilizatorul
dorește să limiteze performanța memaslap, există două moduri de a face acest lucru:

Reduceți numărul de fire și concurențe. Utilizați opțiunea „--tps” care memaslap
prevede limitarea debitului. Această opțiune permite utilizatorului să obțină ceea ce s-a așteptat
debitului. De exemplu, să presupunem că debitul maxim este de 50 kops/s pentru un anumit
configurație, puteți specifica debitul egal sau mai mic decât debitul maxim
folosind opțiunea „--tps”.

Fereastră mărimea
De cele mai multe ori, utilizatorul nu trebuie să specifice dimensiunea ferestrei. Fereastra implicită
dimensiunea este de 10k. Pentru Schooner Memcached, utilizatorul poate specifica diferite dimensiuni de fereastră pentru a obține
rate diferite de pierdere a memoriei cache pe baza cazului de testare. Memslap testess cache rata ratate între
0% și 100%. Dacă utilizați acest utilitar pentru a testa performanța Schooner Memcached, vă
poate specifica o dimensiune adecvată a ferestrei pentru a obține rata de pierdere așteptată a memoriei cache. Formula pentru
calcularea dimensiunii ferestrei este după cum urmează:

Să presupunem că dimensiunea cheii este de 128 de octeți, iar dimensiunea valorii este de 2048 de octeți și
concurenta=128.

1. Cache mică cache_size=1M, pierdere 100% cache (toate datele sunt obținute de pe SSD). win_size=10k

2. cache_size=4G

(1). rata de pierdere a memoriei cache 0%

win_size=8k

(2). rata de pierdere a memoriei cache 5%

win_size=11k

3. cache_size=16G

(1). rata de pierdere a memoriei cache 0%

win_size=32k

(2). cache miss

rata 5%

win_size=46k

Formula pentru calcularea dimensiunii ferestrei pentru rata de pierdere a memoriei cache 0%:

cache_size / concurență / (key_size + value_size) * 0.5

Formula pentru calcularea dimensiunii ferestrei pentru rata de pierdere a memoriei cache 5%:

cache_size / concurență / (key_size + value_size) * 0.7

Verificare
Testele Memslap testează atât verificarea datelor, cât și verificarea timpului de expirare. Utilizatorul poate folosi
„--verify=" sau „-v” pentru a specifica proporția de verificare a datelor. În teorie, se testează
Verificare 100% a datelor. Utilizatorul poate folosi „--exp_verify=" sau „-e” pentru a specifica proporția
de verificare a timpului de expirare. În teorie, testează verificarea 100% a timpului de expirare. Specifica
opțiunile „--verbose” pentru a obține informații mai detaliate despre erori.

De exemplu: --exp_verify=0.01 –verify=0.1 , înseamnă că 1% din obiectele setate cu
timp de expirare, 10% din obiectele obținute vor fi verificate. Dacă obiectele sunt primite,
memaslap va verifica timpul și valoarea de expirare.

multi-servere și multi-config
Memslap testează mai multe servere bazate pe fir auto-guvernat. Există o limitare care
numărul de servere nu poate fi mai mare decât numărul de fire. Memslap atribuie unul
thread pentru a gestiona cel puțin un server. Utilizatorul poate folosi opțiunea „--servers=" sau „-s” pentru
specificați mai multe servere.

De exemplu:

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

Comanda de mai sus înseamnă că există 6 fire, fiecare thread având 6 concurențe
și că firele de execuție 0 și 3 gestionează serverul 0 (10.1.1.1); firele 1 și 4 gestionează serverul 1
(10.1.1.2); iar firele 2 și 5 mâner serverul 2 (10.1.1.3).

Toate firele și concurențele din memaslap sunt autoguvernate.

La fel și memaslap. Utilizatorul poate porni mai multe instanțe memaslap. Utilizatorul poate rula
memaslap pe diferite mașini client pentru a comunica cu același server memcached la
la fel. Se recomandă ca utilizatorul să înceapă diferite memaslap pe diferite mașini folosind
aceeași configurație.

Alerga cu a executa număr mod or timp mod
Memaslap implicit rulează cu modul de timp. Timpul de rulare implicit este de 10 minute. Dacă ori
afară, memaslap va ieși. Nu specificați atât modul de execuție numeric, cât și modul de timp în același timp
timp; trebuie doar să specificați unul.

De exemplu:

--time=30s (Înseamnă că testul va rula 30 de secunde.)

--execute_number=100000 (Înseamnă că după rularea a 100000 de comenzi, testul va ieși.)

Benă statistic informații periodic.
Utilizatorul poate folosi „--stat_freq=" sau „-S” pentru a specifica frecvența.

De exemplu:

--stat_freq=20s

Memslap va arunca statisticile comenzilor (get și set) la frecvența fiecăreia
20 secunde.

Pentru mai multe informații despre formatul informațiilor statistice de dumping, consultați „Format de
secțiunea Ieșire”.

Multi-get
Utilizatorul poate folosi „--division=" sau „-d” pentru a specifica numărul de chei multi-get. Memslap de
implicit se obține o singură dată cu TCP. Memslap testează, de asemenea, verificarea datelor și timpul de expirare
verificare pentru multi-get.

Testele Memslap sunt multi-get atât cu TCP, cât și cu UDP. Din cauza implementării diferite a
protocolul ASCII și protocolul binar, există unele diferențe între cele două. Pentru
protocolul ASCII, memaslap trimite un „multi-get” la server o dată. Pentru binar
protocol, memaslap trimite mai multe comenzi unice get împreună ca „multi-get” către
Server.

UDP și TCP
Memslap testează atât UDP, cât și TCP. Pentru TCP, memaslap nu reconecta serverul memcache
dacă se pierd conexiunile prize. Dacă toate conexiunile socket sunt pierdute sau serverul memcached
se blochează, memaslap va ieși. Dacă utilizatorul specifică opțiunea „--reconnect” la priză
conexiunile sunt pierdute, le va reconecta.

Utilizatorul poate folosi „--udp” pentru a activa caracteristica UDP, dar UDP vine cu unele limitări:

UDP nu poate seta date mai mari de 1400 de octeți.

UDP nu este testat de protocolul binar deoarece protocolul binar al memcached o face
nu testeaza asta.

UDP nu testează reconectarea.

Facebook test
Setați date cu TCP și multi-get cu UDP. Specificați următoarele opțiuni:

„--facebook --division=50”

Dacă doriți să creați mii de conexiuni TCP, specificați

Opțiunea „--conn_sock=".

De exemplu: --facebook --division=50 --conn_sock=200

Comanda de mai sus înseamnă că memaslap va face testul Facebook, fiecare concurență are 200
socket conexiuni TCP și un socket UDP.

Memslap setează obiecte cu socket-ul TCP și primește mai multe 50 de obiecte o dată cu UDP
priză.

Dacă specificați „--division=50”, dimensiunea cheii trebuie să fie mai mică de 25 de octeți, deoarece UDP
dimensiunea pachetului este de 1400 de octeți.

Replicarea test
Pentru testul de replicare, utilizatorul trebuie să specifice cel puțin două servere memcache. Utilizatorul poate
utilizați opțiunea „—rep_write=" pentru a activa funcția.

De exemplu:

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

Comanda de mai sus înseamnă că există 2 servere de replicare memcached, memaslap se va seta
obiecte atât la serverul 0, cât și la serverul 1, obțineți obiectele care sunt setate la serverul 0 înainte de la
serverul 1 și, de asemenea, obțineți obiecte care sunt setate la serverul 1 înainte de la serverul 0. Dacă serverul 0
se blochează, memaslap va primi doar obiecte de la serverul 1. Dacă serverul 0 revine la viață
din nou, memaslap va reconecta serverul 0. Dacă atât serverul 0, cât și serverul 1 se blochează, memaslap
va ieși.

Sprijină mii of TCP Conexiuni
Începeți memaslap cu „--conn_sock=" sau „-n” pentru a activa această funcție. Asigurați-vă că dvs
sistemul poate testa deschiderea a mii de fișiere și crearea a mii de socket-uri. In orice caz,
această caracteristică nu testează reconectarea dacă prizele se deconectează.

De exemplu:

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

Comanda de mai sus înseamnă că memaslap pornește 8 fire, fiecare thread are 16
concurențe, fiecare concurență are 128 de conexiuni socket TCP și numărul total de
Conexiunile socket TCP sunt 128 * 128 = 16384.

Sprijină binar protocol
Începeți memaslap cu opțiunile „--binary” sau „-B” pentru a activa această funcție. Testează toate
caracteristicile de mai sus, cu excepția UDP, deoarece cel mai recent memcached 1.3.3 nu implementează binar
Protocolul UDP.

De exemplu:

--binar

Deoarece memcached 1.3.3 nu implementează protocolul binar UDP, memaslap nu testează UDP.
În plus, memcached 1.3.3 nu testează multi-get. Dacă specificați „--division=50”
opțiunea, trimite doar 50 de comenzi get împreună ca „mulit-get” către server.

CONFIGURARE FILE

Această secțiune descrie formatul fișierului de configurare. Implicit când nu
Fișierul de configurare este specificat memaslap citește cel implicit situat la ~/.memaslap.cnf.

Mai jos este un exemplu de fișier de configurare:

-------------------------------------------------- -------------------------
#comentariile ar trebui să înceapă cu „#”
#cheie
#start_len end_len proporție
#
interval de lungime #key de la start_len la end_len
#start_len trebuie să fie egal sau mai mare decât 16
#end_len trebuie să fie egal sau mai mic de 250
#start_len trebuie să fie egal sau mai mare decât end_len
#memaslap va genera chei în funcție de intervalul de chei
#proporție: indică cheile generate dintr-un interval de conturi pentru total
cheile generate
#
#example1: intervalul de chei 16~100 reprezintă 80%
# intervalul de taste 101~200 reprezintă 10%
# intervalul de taste 201~250 reprezintă 10%
# total ar trebui să fie 1 (0.8+0.1+0.1 = 1)
#
# 16 100 0.8
# 101 200 0.1
# 201 249 0.1
#
#example2: lungimea tuturor cheilor este de 128 de octeți
#
# 128 128 1
cheie
128 128 1
#valoare
#start_len end_len proporție
#
#value interval de lungime de la start_len la end_len
#start_len trebuie să fie egal sau mai mare decât 1
#end_len trebuie să fie egal sau mai mic de 1M
#start_len trebuie să fie egal sau mai mare decât end_len
#memaslap va genera valori în funcție de intervalul de valori
#proporție: indică valorile generate dintr-un interval de conturi pentru
valorile totale generate
#
#example1: intervalul de valori 1~1000 reprezintă 80%
# intervalul de valori 1001~10000 reprezintă 10%
# intervalul de valori 10001~100000 reprezintă 10%
# total ar trebui să fie 1 (0.8+0.1+0.1 = 1)
#
# 1 1000 0.8
# 1001 10000 0.1
# 10001 100000 0.1
#
#example2: toată lungimea valorii este de 128 de octeți
#
# 128 128 1
valoare
2048 2048 1
#cmd
#cmd_type cmd_proportion
#
#currently memaslap only testss get and set command.
#
#cmd_type
#set 0
#obține 1
#
#exemplu: setați conturile de comandă pentru 50%
# obțineți conturi de comandă pentru 50%
# total ar trebui să fie 1 (0.5+0.5 = 1)
#
# cmd
# 0 0.5
# 1 0.5
cmd
0 0.1
1.0 0.9

FORMAT OF REZULTATE

La început, memaslap afișează câteva informații de configurare, după cum urmează:

servere: 127.0.0.1:11211

Numar fire: 1

concurență: 16

timp de rulare: 20s

Dimensiunea ferestrelor: 10k

set proporție: set_prop=0.10

obțineți proporția: get_prop=0.90

Unde
servere: "servere"
Serverele folosite de memaslap.

firele numără
Numărul de fire cu care rulează memaslap.

concurență
Numărul de concurențe cu care rulează memaslap.

timpul de rulare
Cât timp să ruleze memaslap.

dimensiunea ferestrelor
Dimensiunea ferestrei de activitate a fiecărei concurențe.

proporție stabilită
Proporția de comandă setată.

obține proporție
Proporția de a obține comanda.

Rezultatul statisticilor dinamice este cam așa:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Obțineți statistici
Tip Timp(e) Ops TPS(ops/s) Net(L/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
Perioada 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

Setează Statistici
Tip Timp(e) Ops TPS(ops/s) Net(L/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
Perioada 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

Statistici totale
Tip Timp(e) Ops TPS(ops/s) Net(L/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
Perioada 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
-------------------------------------------------- -------------------------------------------------- -----------------------------

Unde
Obțineți statistici
Informații statistice pentru comanda get

Setează Statistici
Informații statistice ale comenzii set

Statistici totale
Informații statistice atât pentru comanda get, cât și pentru set

Perioadă
Rezultat într-o perioadă

Caritate
Rezultate acumulate

Ops
Total operațiuni

TPS
Debit, operații/secundă

Net
Rata rețelei

Get_miss
Câte obiecte nu pot fi obținute

Min
Timpul minim de răspuns

max
Timpul maxim de răspuns

Medie:
Timpul mediu de răspuns

Std_dev
Abaterea standard a timpului de răspuns

Geo_dist
Distribuție geometrică bazată pe funcție exponențială naturală

La sfârșit, memaslap va scoate ceva de genul acesta:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Obțineți statistici (1257956 evenimente)
Min: 26
Max: 3791
Medie: 224
Geo: 192.60
Std: 116.23
Log2 Dist:
4: 0 10 84490 215345
8: 484890 459823 12543 824
12: 31

Set statistici (139782 evenimente)
Min: 37
Max: 3790
Medie: 253
Geo: 224.84
Std: 116.83
Log2 Dist:
4: 0 0 4200 16988
8: 50784 65574 2064 167
12: 5

Statistici totale (1397738 evenimente)
Min: 26
Max: 3791
Medie: 227
Geo: 195.60
Std: 116.60
Log2 Dist:
4: 0 10 88690 232333
8: 535674 525397 14607 991
12: 36

cmd_get: 1257969
cmd_set: 139785
get_misses: 0
verific_misses: 0
verify_failed: 0
expired_get: 0
unexpired_unget: 0
bytes_scriși: 242516030
read_bytes: 1003702556
object_bytes: 152086080
packet_disorder: 0
packet_drop: 0
udp_timeout: 0

Timp de rulare: 20.0s Ops: 1397754 TPS: 69817 Net_rate: 59.4M/s
-------------------------------------------------- -------------------------------------------------- -----------------------------

Unde
Obțineți statistici
Obțineți statistici despre timpul de răspuns

Setează Statistici
Setați statistici privind timpul de răspuns

Statistici totale
Ambele obțin și stabilesc statistici privind timpul de răspuns

Min
Timpul de răspuns acumulat și minim

max
Timpul de răspuns acumulat și maxim

Medie
Timpul de răspuns acumulat și mediu

Std
Abaterea standard a timpului de răspuns

Log2 Dist
Distribuția geometrică bazată pe logaritmul 2

cmd_get
Total obține comenzi efectuate

cmd_set
Total set comenzi efectuate

get_misses
Câte obiecte nu pot fi obținute de pe server

verify_misses
Câte obiecte trebuie verificate, dar nu le pot obține

verify_failed
Câte obiecte cu valoare insistentă

expired_get
Câte obiecte au expirat dar le primim

unexpired_unget
Câte obiecte sunt neexpirate, dar nu le putem obține

octeți_scriși
Total octeți scrisi

read_bytes
Total octeți citiți

obiect_octeți
Total octeți obiect

dezordine_pachet
Câte pachete UDP sunt dezordine

packet_drop
Câte pachete UDP sunt pierdute

udp_timeout
De câte ori se întâmplă timpul de expirare UDP

Timpul de rulare
Timp total de rulare

Ops
Total operațiuni

TPS
Debit, operații/secundă

Cota netă
Rata medie a rețelei

OPŢIUNI

-da, --servere=
Listați unul sau mai multe servere de conectat. Numărul de servere trebuie să fie mai mic decât numărul de fire.
de exemplu: --servers=localhost:1234,localhost:11211

-T, --fire=
Numărul de fire de execuție pentru pornire, mai bine egal cu numerele CPU. Implicit 8.

-c, --concurență=
Numărul de concurență de simulat cu încărcare. Implicit 128.

-n, --conn_sock=
Numărul de șosete TCP per concurență. Implicit 1.

-X, --execute_number=
Numărul de operații (get și set) de executat pentru testul dat. Implicit 1000000.

-t, --timp=
Cât timp va rula testul, sufix: s-secunde, m-minute, h-ore, d-zile, de exemplu:
--timp=2h.

-F, --cfg_cmd=
Încărcați fișierul de configurare pentru a obține lista de distribuție a comenzilor, cheii și valorii.

-w, --win_size=
Dimensiunea ferestrei de activitate a fiecărei concurențe, sufix: K, M de ex.: --win_size=10k. Mod implicit
10k

-X, --fixed_size=
Lungime fixă ​​a valorii.

-v, --verify=
Proporția verificării datei, de exemplu: --verify=0.01

-d, --diviziune=
Numărul de chei pentru a obține mai multe o dată. Implicit 1, înseamnă o singură obținere.

-S, --stat_freq=
Frecvența informațiilor statistice privind dumpingul. sufix: s-secunde, m-minute, de exemplu:
--resp_freq=10s.

-e, --exp_verify=
Proporția obiectelor cu timp de expirare, de exemplu: --exp_verify=0.01. Implicit nr
obiect cu termen de expirare

-o, --overwrite=
Proporția de obiecte necesită suprascriere, de exemplu: --overwrite=0.01. Implicit niciodată
suprascrie obiectul.

-R, --reconectați
Testele de reconectare, când conexiunea este închisă, aceasta va fi reconectată.

-U, --udp
Testele UDP, memaslap implicit folosește TCP, portul TCP și portul UDP al serverului trebuie să fie același.

-a, --Facebook
Fie că activează funcția de testare Facebook, setată cu TCP și multi-get cu UDP.

-B, --binar
Dacă activează protocolul binar. Implicit cu protocolul ASCII.

-P, --tps=
Debit așteptat, sufix: K, de exemplu: --tps=10k.

-p, --rep_write=
Primul al n-lea server poate scrie date, de exemplu: --rep_write=2.

-b, --verbos
Dacă emite informații detaliate atunci când verificarea eșuează.

-h, --Ajutor
Afișați acest mesaj și apoi ieșiți.

-V, --versiune
Afișați versiunea aplicației și apoi ieșiți.

EXEMPLE

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

ACASA

Pentru a afla mai multe informații vă rugăm să verificați: http://libmemcached.org/

AUTORI

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

Utilizați memcaslap online folosind serviciile onworks.net