memcaslap - Online nel cloud

PROGRAMMA:

NOME

memaslap - Documentazione libmemcached

SINOSSI

memaslap [opzioni]

--Aiuto

MEMCCHED_SERVER

DESCRIZIONE

meslap è uno strumento di generazione di carico e benchmark per server memcached. genera
carico di lavoro configurabile come thread, concorrenza, connessioni, runtime, sovrascrittura,
miss rate, dimensione chiave, dimensione valore, proporzione get/set, throughput previsto e così via.
Inoltre, verifica anche la verifica dei dati, la verifica del tempo di scadenza, UDP, binario
protocollo, test facebook, test di replica, multi-get e riconnessione, ecc.

Memaslap gestisce le connessioni di rete come memcached con libevent. Ogni thread di memaslap
è legato a un core della CPU, tutti i thread non comunicano tra loro e ci sono
diverse connessioni socket in ogni thread. Ogni connessione mantiene la distribuzione della dimensione della chiave,
distribuzione della dimensione del valore e distribuzione dei comandi da sola.

È possibile specificare i server tramite il memslap --server opzione o tramite la variabile d'ambiente
MEMCCHED_SERVER.

CARATTERISTICHE

Memslap è sviluppato per i seguenti scopi:

Gestisce le connessioni di rete con libevent in modo asincrono.

Imposta sia TCP che UDP per utilizzare l'IO non bloccante.

Migliora il parallelismo: prestazioni più elevate in ambienti multi-thread.

Migliora l'efficienza temporale: maggiore velocità di elaborazione.

Genera chiave e valore in modo più efficiente; distribuzione della dimensione della chiave e dimensione del valore
distribuzione sono configurabili.

Supporta i comandi get, multi-get e set; la distribuzione dei comandi è configurabile.

Supporta il tasso di errore controllabile e il tasso di sovrascrittura.

Supporta la verifica dei dati e della data di scadenza.

Supporta il dumping periodico delle informazioni statistiche.

Supporta migliaia di connessioni TCP.

Supporta il protocollo binario.

Supporta test facebook (impostato con TCP e multi-get con UDP) e test di replica.

DETTAGLI

Efficace implementazione of rete.
Per memaslap, sia TCP che UDP utilizzano I/O di rete non bloccanti. Tutti gli eventi della rete sono
gestito da libevent come memcached. Il modulo di rete di memaslap è simile a memcached.
Libevent può garantire che memaslap possa gestire la rete in modo molto efficiente.

Efficace implementazione of multi-thread ed concorrenza
Memslap ha l'implementazione simile di multi-thread a memcached. Memslap ne crea uno
o più thread autonomi; ogni thread è associato a un core della CPU se il sistema esegue il test
impostazione dell'affinità del core della CPU.

Inoltre, ogni thread ha un libevent per gestire gli eventi della rete; ogni filo
ha una o più gare autogestite; e ogni concorrenza ha uno o più socket
connessioni. Tutte le concorrenti non comunicano tra loro anche se lo sono
nello stesso filo.

Memslap può creare migliaia di connessioni socket e ogni concorrenza ha decine di
connessioni presa. Ogni concorrenza seleziona casualmente o in sequenza un socket
connessione dal suo pool di connessioni socket per l'esecuzione, quindi memaslap può garantire ogni concorrenza
gestisce una connessione socket in un dato momento. Gli utenti possono specificare il numero di
concorrenza e connessioni socket di ciascuna concorrenza in base alle loro attese
carico di lavoro.

Efficace implementazione of la generazione di chiave ed APPREZZIAMO
Al fine di migliorare l'efficienza temporale e spaziale, memaslap crea un casuale
tabella dei caratteri con 10 milioni di caratteri. Vengono generati tutti i suffissi di chiavi e valori
da questa tabella di caratteri casuali.

Memslap usa l'offset nella tabella dei caratteri e la lunghezza della stringa per identificare a
corda. Può risparmiare molta memoria. Ogni chiave contiene due parti, un prefisso e un suffisso. Il
prefisso è un uint64_t, 8 byte. Per verificare il set di dati prima, memaslap deve
assicurarsi che ogni chiave sia univoca, quindi utilizza il prefisso per identificare una chiave. Il prefisso non può
includere caratteri illegali, come 'r', 'n', '0' e ' '. E memaslap ha un algoritmo
per garantire che.

Memslap non genera tutti gli oggetti (coppie chiave-valore) all'inizio. Solo
genera oggetti sufficienti per riempire la finestra dell'attività (oggetti predefiniti 10K) di ciascuno
concorrenza. Ogni oggetto ha le seguenti informazioni di base, prefisso chiave, suffisso chiave
offset nella tabella dei caratteri, lunghezza della chiave, offset del valore nella tabella dei caratteri e valore
lunghezza.

Nel processo di lavoro, ogni concorrenza seleziona in modo sequenziale o casuale un oggetto dal
finestra per impostare l'operazione o ottenere l'operazione. Allo stesso tempo, ogni concorrenza calci
oggetti fuori dalla sua finestra e aggiunge un nuovo oggetto al suo interno.

Un'espansione ma utile compito programmazione
Memslap usa libevent per pianificare tutte le simultanee dei thread e ogni concorrenza
pianifica le attività in base alla finestra delle attività locali. Memslap presuppone che se ogni concorrenza
mantiene la stessa distribuzione delle chiavi, distribuzione del valore e distribuzione dei comandi, da
all'esterno, memaslap mantiene tutta la distribuzione nel suo insieme. Ogni finestra delle attività include molto
di oggetti, ogni oggetto memorizza le sue informazioni di base, come chiave, valore, tempo di scadenza e
presto. In qualsiasi momento, tutti gli oggetti nella finestra mantengono la stessa chiave e valore fissi
distribuzione. Se un oggetto viene sovrascritto, il valore dell'oggetto verrà aggiornato.
Memslap verifica i dati o il tempo di scadenza in base alle informazioni sull'oggetto memorizzate nel
finestra delle attività.

Libevent seleziona quale concorrenza gestire in base a un evento di rete specifico. Poi il
la concorrenza seleziona quale comando (get o set) operare in base al comando
distribuzione. Se ha bisogno di eliminare un vecchio oggetto e aggiungerne uno nuovo, per mantenerlo
la stessa distribuzione di chiave e valore, il nuovo oggetto deve avere la stessa lunghezza di chiave e
lunghezza del valore.

Se il server memcached ha due livelli di cache (memoria e SSD), eseguire memaslap con differenti
le dimensioni della finestra possono ottenere tassi di mancata memorizzazione della cache diversi. Se memaslap aggiunge abbastanza oggetti nel
windows all'inizio e la cache di memcached non può memorizzare tutti gli oggetti
inizializzato, quindi memaslap otterrà alcuni oggetti dal secondo livello di cache. Causa
il primo livello di cache da perdere. Quindi l'utente può specificare la dimensione della finestra per ottenere il previsto
miss rate del primo livello di cache.

Utile implementazione of multi-server , UDP, TCP, multi-ottenere ed binario protocollo
Poiché ogni thread è autogestito, memaslap può assegnare diversi thread da gestire
diversi server memcached. Questo è solo uno dei modi in cui memaslap esegue test multipli
server. L'unica limitazione è che il numero di server non può essere maggiore del
numero di fili. L'altro modo per testare più server è per il test di replica. Ogni
la concorrenza ha una connessione socket a ciascun server memcached. Per l'attuazione,
memaslap può impostare alcuni oggetti su un server memcached e ottenere questi oggetti dal
altri server.

Per impostazione predefinita, Memslap esegue una singola acquisizione. Se l'utente specifica l'opzione multi-get, memaslap lo farà
raccogli abbastanza comandi prendi e impacchetta e invia i comandi insieme.

Memslap testa sia il protocollo ASCII che il protocollo binario, ma funziona su ASCII
protocollo per impostazione predefinita. Memslap per impostazione predefinita viene eseguito sul protocollo TCP, ma verifica anche UDP.
Poiché UDP è inaffidabile, possono verificarsi pacchetti persi e pacchetti fuori servizio. Memslap
crea un buffer di memoria per gestire questi problemi. Memslap prova a leggere tutta la risposta
dati di un comando dal server e riordina i dati di risposta. Se alcuni pacchetti ottengono
perso, il meccanismo di timeout di attesa può garantire che i pacchetti cotti a metà vengano scartati e
verrà inviato il comando successivo.

USO

Di seguito sono riportati alcuni esempi di utilizzo:

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'utente deve specificare almeno un server per eseguire memaslap. Il resto dei parametri ha
valori predefiniti, come mostrato di seguito:

Numero thread = 1 Concorrenza = 16

Tempo di esecuzione = 600 secondi File di configurazione = NULL

Dimensione chiave = 64 Dimensione valore = 1024

Ottieni/imposta = 9:1 Dimensione finestra = 10k

Esegui numero = 0 Singolo get = vero

Multi-get = false Numero di socket di ogni concorrenza = 1

Riconnetti = falso Verifica dati = falso

Verifica scadenza = falso protocollo ASCII = vero

Protocollo binario = false Informazioni statistiche di dumping

periodicamente = falso

Sovrascrivi proporzione = 0% UDP = falso

TCP = vero Limite throughput = falso

Test di Facebook = falso Test di replica = falso

Le dimensione, APPREZZIAMO Taglia ed command distribuzione.
Tutte le distribuzioni vengono lette dal file di configurazione specificato dall'utente con
Opzione “—cfg_cmd”. Se l'utente non specifica un file di configurazione, verrà eseguito memaslap
con la distribuzione predefinita (dimensione chiave = 64, dimensione valore = 1024, get/set = 9:1). Per
informazioni su come modificare il file di configurazione, fare riferimento al “File di configurazione”
.

La dimensione minima della chiave è 16 byte; la dimensione massima della chiave è 250 byte. La precisione di
la proporzione è 0.001. La proporzione di distribuzione sarà arrotondata alla terza cifra decimale.

La dimensione minima del valore è 1 byte; la dimensione massima del valore è 1M byte. La precisione di
la proporzione è 0.001. La proporzione di distribuzione sarà arrotondata alla terza cifra decimale.
Attualmente, memaslap verifica solo l'impostazione e l'acquisizione dei comandi. E verifica il 100% di set e il 100% di get.
Per ottenere il 100%, preimposta alcuni oggetti sul server.

Multi thread ed concorrenza
Le elevate prestazioni di memaslap beneficiano dello speciale programma di thread e
concorrenza. È importante specificare il numero corretto di essi. Il numero predefinito di
thread è 1; il numero predefinito di simultaneità è 16. L'utente può utilizzare "—thread" e
“--concurrency” per specificare queste variabili.

Se il sistema verifica l'impostazione dell'affinità della CPU e il numero di thread specificati dall'utente
è maggiore di 1, memaslap tenterà di associare ciascun thread a un diverso core della CPU. Quindi se
vuoi ottenere le migliori prestazioni memaslap, è meglio specificare il numero di
thread uguale al numero di core della CPU. Il numero di thread specificato dall'utente può
anche essere minore o maggiore del numero di core della CPU. A causa della limitazione di
implementazione, il numero di concorrenti potrebbe essere il multiplo del numero di
thread.

1. Per sistema a 8 core della CPU

Per esempio:

--thread=2 --concurrency=128

--thread=8 --concurrency=128

--thread=8 --concurrency=256

--thread=12 --concurrency=144

2. Per sistema a 16 core della CPU

Per esempio:

--thread=8 --concurrency=128

--thread=16 --concurrency=256

--thread=16 --concurrency=512

--thread=24 --concurrency=288

Il memaslap funziona molto bene, quando viene utilizzato per testare le prestazioni dei server memcached.
Il più delle volte, il collo di bottiglia è la rete o il server. Se per qualche motivo l'utente
vuole limitare le prestazioni di memaslap, ci sono due modi per farlo:

Diminuire il numero di thread e simultanee. Usa l'opzione "--tps" che memaslap
prevede di limitare il throughput. Questa opzione consente all'utente di ottenere il previsto
portata. Ad esempio, supponiamo che il throughput massimo sia di 50 kops/s per uno specifico
configurazione, è possibile specificare il throughput uguale o inferiore al throughput massimo
utilizzando l'opzione "--tps".

Finestra Taglia
La maggior parte delle volte, l'utente non ha bisogno di specificare la dimensione della finestra. La finestra predefinita
la dimensione è 10k. Per Schooner Memcached, l'utente può specificare diverse dimensioni della finestra da ottenere
tassi di cache miss diversi in base al test case. Memslap verifica il tasso di perdita della cache tra
0% e 100%. Se usi questa utility per testare le prestazioni di Schooner Memcached,
può specificare una dimensione della finestra adeguata per ottenere il tasso di mancato riconoscimento della cache previsto. La formula per
il calcolo delle dimensioni della finestra è il seguente:

Supponiamo che la dimensione della chiave sia 128 byte e che la dimensione del valore sia 2048 byte e
concorrenza=128.

1. Cache piccola cache_size=1M, 100% cache miss (tutti i dati ottengono da SSD). win_size=10k

2. dimensione_cache=4G

(1). tasso di mancato salvataggio della cache 0%

dimensione_vincita=8k

(2). tasso di mancato salvataggio della cache 5%

dimensione_vincita=11k

3. dimensione_cache=16G

(1). tasso di mancato salvataggio della cache 0%

dimensione_vincita=32k

(2). manca la cache

tasso 5%

dimensione_vincita=46k

La formula per il calcolo della dimensione della finestra per il tasso di mancata ricezione della cache 0%:

cache_size / concorrenza / (key_size + value_size) * 0.5

La formula per il calcolo della dimensione della finestra per il tasso di mancata ricezione della cache 5%:

cache_size / concorrenza / (key_size + value_size) * 0.7

Convalida
Memslap verifica sia la verifica dei dati che la verifica del tempo di scadenza. L'utente può utilizzare
"--verify=" o "-v" per specificare la percentuale di verifica dei dati. In teoria, si verifica
Verifica dei dati al 100%. L'utente può usare "--exp_verify=" o "-e" per specificare la proporzione
di verifica della scadenza. In teoria, testa la verifica del tempo di scadenza al 100%. Specificare
le opzioni "--verbose" per ottenere informazioni più dettagliate sull'errore.

Ad esempio: --exp_verify=0.01 –verify=0.1 , significa che l'1% degli oggetti impostati con
scadenza, verrà verificato il 10% degli oggetti ottenuti. Se gli oggetti vengono ottenuti,
memaslap verificherà l'ora di scadenza e il valore.

multi-server ed multi-configurazione
Memslap testa i multi-server basati su thread autogestiti. C'è una limitazione che
il numero di server non può essere maggiore del numero di thread. Memslap ne assegna uno
thread per gestire almeno un server. L'utente può utilizzare l'opzione "--servers=" o "-s" per
specificare più server.

Per esempio:

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

Il comando sopra significa che ci sono 6 thread, con ogni thread con 6 concorrenti
e che i thread 0 e 3 gestiscono il server 0 (10.1.1.1); i thread 1 e 4 gestiscono il server 1
(10.1.1.2) e i thread 2 e 5 gestiscono il server 2 (10.1.1.3).

Tutti i thread e le concorrenze in memaslap sono autogestiti.

Così è memaslap. L'utente può avviare diverse istanze di memaslap. L'utente può eseguire
memaslap su diverse macchine client per comunicare con lo stesso server memcached al
stesso. Si consiglia all'utente di avviare diversi memaslap su macchine diverse utilizzando
la stessa configurazione.

Correre con eseguire numero modo or tempo modo
Il memaslap predefinito viene eseguito con la modalità ora. Il tempo di esecuzione predefinito è 10 minuti. Se è tempo
out, memaslap uscirà. Non specificare contemporaneamente la modalità di esecuzione del numero e la modalità di tempo
tempo; basta specificarne uno invece.

Per esempio:

--time=30s (significa che il test verrà eseguito per 30 secondi.)

--execute_number=100000 (Significa che dopo aver eseguito 100000 comandi, il test verrà terminato.)

Scaricare statistica informazioni periodicamente.
L'utente può utilizzare "--stat_freq=" o "-S" per specificare la frequenza.

Per esempio:

--stat_freq=20s

Memslap scaricherà le statistiche dei comandi (get e set) alla frequenza di ogni
20 secondi.

Per ulteriori informazioni sul formato delle informazioni statistiche di dumping, fare riferimento a “Formato di
sezione Uscita”.

Multi-ottenere
L'utente può utilizzare "--division=" o "-d" per specificare il numero di chiavi multi-get. Memslap di
l'impostazione predefinita ottiene singolo con TCP. Memslap testa anche la verifica dei dati e il tempo di scadenza
verifica per multi-get.

Memslap verifica il multi-get sia con TCP che con UDP. A causa della diversa implementazione di
il protocollo ASCII e il protocollo binario, ci sono alcune differenze tra i due. Per
il protocollo ASCII, memaslap invia un "multi-get" al server una volta. Per il binario
protocollo, memaslap invia diversi comandi get singoli insieme come "multi-get" al
server.

UDP ed TCP
Memslap testa sia UDP che TCP. Per TCP, memaslap non riconnette il server memcached
se le connessioni socket vengono perse. Se tutte le connessioni socket vengono perse o il server memcached
si blocca, memaslap uscirà. Se l'utente specifica l'opzione "--reconnect" quando socket
le connessioni sono perse, le riconnetterà.

L'utente può utilizzare "--udp" per abilitare la funzione UDP, ma UDP presenta alcune limitazioni:

UDP non può impostare dati più di 1400 byte.

UDP non viene testato dal protocollo binario perché il protocollo binario di memcached lo fa
non lo prova.

UDP non verifica la riconnessione.

Facebook test
Imposta i dati con TCP e multi-get con UDP. Specificare le seguenti opzioni:

"--facebook --division=50"

Se vuoi creare migliaia di connessioni TCP, specifica il

"--conn_sock=" opzione.

Ad esempio: --facebook --division=50 --conn_sock=200

Il comando sopra significa che memaslap eseguirà il test di Facebook, ogni concorrenza ha 200
connessioni TCP socket e un socket UDP.

Memslap imposta gli oggetti con il socket TCP e multi-ottiene 50 oggetti una volta con l'UDP
zoccolo.

Se specifichi "--division=50", la dimensione della chiave deve essere inferiore a 25 byte perché l'UDP
la dimensione del pacchetto è 1400 byte.

replicazione test
Per il test di replica, l'utente deve specificare almeno due server memcached. L'utente può
utilizzare l'opzione "—rep_write=" per abilitare la funzione.

Per esempio:

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

Il comando sopra significa che ci sono 2 server di replica memcached, memaslap verrà impostato
oggetti sia al server 0 che al server 1, ottieni oggetti che sono impostati sul server 0 prima da
server 1 e ottiene anche oggetti che sono impostati sul server 1 prima dal server 0. Se il server 0
si blocca, memaslap otterrà solo oggetti dal server 1. Se il server 0 torna in vita
di nuovo, memaslap riconnetterà il server 0. Se sia il server 0 che il server 1 si bloccano, memaslap
uscirà.

supporti migliaia of TCP connessioni
Avvia memaslap con "--conn_sock=" o "-n" per abilitare questa funzione. Assicurati che il tuo
il sistema può testare l'apertura di migliaia di file e la creazione di migliaia di socket. Però,
questa funzione non verifica la riconnessione se i socket si disconnettono.

Per esempio:

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

Il comando precedente significa che memaslap avvia 8 thread, ogni thread ha 16
concorrenti, ogni concorrenza ha 128 connessioni socket TCP e il numero totale di
Le connessioni socket TCP sono 128 * 128 = 16384.

supporti binario protocollo
Avvia memaslap con le opzioni "--binary" o "-B" per abilitare questa funzione. Mette alla prova tutti i
sopra le funzionalità tranne UDP, perché l'ultimo memcached 1.3.3 non implementa il binario
protocollo UDP.

Per esempio:

--binario

Poiché memcached 1.3.3 non implementa il protocollo UDP binario, memaslap non verifica UDP.
Inoltre, memcached 1.3.3 non verifica multi-get. Se specifichi "--division=50"
opzione, invia solo 50 comandi get insieme come "multi-get" al server.

CONFIGURAZIONE RISORSE

Questa sezione descrive il formato del file di configurazione. Per impostazione predefinita quando no
viene specificato il file di configurazione memaslap legge quello predefinito situato in ~/.memaslap.cnf.

Di seguito è riportato un file di configurazione di esempio:

-------------------------------------------------- -------------------------
I #commenti devono iniziare con '#'
#chiave
#start_len end_len proporzione
#
#intervallo di lunghezza della chiave da start_len a end_len
#start_len deve essere uguale o maggiore di 16
#end_len deve essere uguale o inferiore a 250
#start_len deve essere uguale o maggiore di end_len
#memaslap genererà chiavi in ​​base all'intervallo di chiavi
#proporzione: indica le chiavi generate da un intervallo conti per il totale
chiavi generate
#
#example1: l'intervallo di chiavi 16~100 rappresenta l'80%
# intervallo di chiavi 101~200 rappresenta il 10%
# intervallo di chiavi 201~250 rappresenta il 10%
# totale deve essere 1 (0.8+0.1+0.1 = 1)
#
#16 100 0.8
#101 200 0.1
#201 249 0.1
#
#esempio2: tutte le chiavi sono lunghe 128 byte
#
#128 128 1
chiave
128 128 1
#valore
#start_len end_len proporzione
#
#value intervallo di lunghezza da start_len a end_len
#start_len deve essere uguale o maggiore di 1
#end_len deve essere uguale o inferiore a 1M
#start_len deve essere uguale o maggiore di end_len
#memaslap genererà valori in base all'intervallo di valori
#proporzione: indica i valori generati da un intervallo conti per il
valori totali generati
#
#example1: l'intervallo di valori 1~1000 rappresenta l'80%
# intervallo di valori 1001~10000 rappresenta il 10%
# intervallo di valori 10001~100000 rappresenta il 10%
# totale deve essere 1 (0.8+0.1+0.1 = 1)
#
#1 1000 0.8
#1001 10000 0.1
#10001 100000 0.1
#
#example2: tutta la lunghezza del valore è 128 byte
#
#128 128 1
APPREZZIAMO
2048 2048 1
#cmd
#cmd_type cmd_proporzione
#
#currently memaslap solo i test ottengono e impostano il comando.
#
#cmd_tipo
#imposta 0
#ottenere 1
#
#esempio: imposta gli account di comando per il 50%
# ottieni account di comando per il 50%
# totale deve essere 1 (0.5+0.5 = 1)
#
#cmd
# 0 0.5
# 1 0.5
cmd
0/0.1
1.0/0.9

FORMATO OF USCITA

All'inizio, memaslap mostra alcune informazioni di configurazione come segue:

server: 127.0.0.1:11211

conteggio dei fili: 1

concorrenza: 16

tempo di esecuzione: 20s

dimensioni finestre: 10k

imposta proporzione: set_prop=0.10

ottieni proporzione: get_prop=0.90

Dove
server: "server"
I server utilizzati da memaslap.

i thread contano
Il numero di thread con cui viene eseguito memaslap.

concorrenza
Il numero di simultanee con cui viene eseguito memaslap.

tempo di esecuzione
Per quanto tempo eseguire memaslap.

dimensione delle finestre
La dimensione della finestra dell'attività di ogni concorrenza.

impostare la proporzione
La proporzione del comando impostato.

ottenere proporzione
La proporzione di comando get.

L'output delle statistiche dinamiche è qualcosa del genere:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Ottieni statistiche
Tipo Tempo(i) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
Periodo 5 345826 69165 65.3 0 27 2198 203
95.43/177.29
Globale 20 1257935 62896 71.8 0 26 3791 224
117.79/192.60

Imposta statistiche
Tipo Tempo(i) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
Periodo 5 38425 7685 7.3 0 42 628 240
88.05/220.21
Globale 20 139780 6989 8.0 0 37 3790 253
117.93/224.83

Statistiche totali
Tipo Tempo(i) Ops TPS(ops/s) Net(M/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
Periodo 5 384252 76850 72.5 0 27 2198 207
94.72/181.18
Globale 20 1397720 69886 79.7 0 26 3791 227
117.93/195.60
-------------------------------------------------- -------------------------------------------------- -----------------------------

Dove
Ottieni statistiche
Informazioni statistiche del comando get

Imposta statistiche
Informazioni statistiche del comando set

Statistiche totali
Informazioni statistiche di entrambi i comandi get e set

Periodo
Risultato entro un periodo

globali
Risultati accumulati

Ops
Operazioni totali

TPS
Throughput, operazioni/secondo

Rete
Il tasso di rete

Get_miss
Quanti oggetti non possono essere ottenuti

Min
Il tempo di risposta minimo

Max
Il tempo di risposta massimo

avg:
Il tempo medio di risposta

Std_dev
Deviazione standard del tempo di risposta

Geo_dist
Distribuzione geometrica basata sulla funzione esponenziale naturale

Alla fine, memaslap produrrà qualcosa del genere:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Ottieni statistiche (1257956 eventi)
Min: 26
Max: 3791
Media: 224
Geo: 192.60
Std: 116.23
Log2 Dist:
4: 0 10 84490
8: 484890 459823 12543
12: 31

Imposta statistiche (139782 eventi)
Min: 37
Max: 3790
Media: 253
Geo: 224.84
Std: 116.83
Log2 Dist:
4: 0 0 4200
8: 50784 65574 2064
12: 5

Statistiche totali (1397738 eventi)
Min: 26
Max: 3791
Media: 227
Geo: 195.60
Std: 116.60
Log2 Dist:
4: 0 10 88690
8: 535674 525397 14607
12: 36

cmd_get: 1257969
cmd_set: 139785
get_miss: 0
verifica_miss: 0
verifica_fallita: 0
scaduto_get: 0
unexpired_unget: 0
write_bytes: 242516030
read_bytes: 1003702556
byte_oggetto: 152086080
pacchetto_disordine: 0
pacchetto_drop: 0
udp_timeout: 0

Tempo di esecuzione: 20.0s Ops: 1397754 TPS: 69817 Net_rate: 59.4 M/s
-------------------------------------------------- -------------------------------------------------- -----------------------------

Dove
Ottieni statistiche
Ottieni statistiche sui tempi di risposta

Imposta statistiche
Imposta le statistiche del tempo di risposta

Statistiche totali
Entrambi ottengono e impostano le statistiche del tempo di risposta

Min
Il tempo di risposta accumulato e minimo

Max
Il tempo di risposta accumulato e massimo

Avg
Il tempo di risposta accumulato e medio

Std
Deviazione standard del tempo di risposta

Log2 Dist
Distribuzione geometrica basata sul logaritmo 2

cmd_get
Totale comandi da eseguire

set_cmd
Comandi impostati totali eseguiti

get_miss
Quanti oggetti non possono essere ottenuti dal server

verifica_manca
Quanti oggetti devono essere verificati ma non è possibile ottenerli

verifica_fallita
Quanti oggetti con valore insistente

scaduto_get
Quanti oggetti sono scaduti ma li riceviamo

non scaduto_unget
Quanti oggetti non sono scaduti ma non riusciamo a ottenerli

byte_scritti
Byte scritti totali

read_bytes
Byte letti totali

byte_oggetto
Byte totali dell'oggetto

pacchetto_disordine
Quanti pacchetti UDP sono disordine

pacchetto_drop
Quanti pacchetti UDP vengono persi

udp_timeout
Quante volte si verifica il timeout UDP

Tempo di esecuzione
Tempo di esecuzione totale

Ops
Operazioni totali

TPS
Throughput, operazioni/secondo

Tasso netto
Il tasso medio di rete

VERSIONI

-S, --server=
Elenca uno o più server da connettere. Il conteggio dei server deve essere inferiore al conteggio dei thread.
ad esempio: --servers=localhost:1234,localhost:11211

-T, --thread=
Numero di thread all'avvio, meglio uguale ai numeri di CPU. Predefinito 8.

-C, --concorrenza=
Numero di simultaneità da simulare con il carico. predefinito 128.

-N, --conn_calza=
Numero di calze TCP per concorrenza. Predefinito 1.

-X, --execute_number=
Numero di operazioni (get e set) da eseguire per il test specificato. Valore predefinito 1000000.

-T, --tempo=
Per quanto tempo deve essere eseguito il test, suffisso: s-secondi, m-minuti, h-ore, d-giorni es:
--tempo=2h.

-F, --cfg_cmd=
Carica il file di configurazione per ottenere l'elenco di distribuzione di comandi, chiavi e valori.

-w, --win_dimensione=
Dimensione della finestra dell'attività di ogni concorrenza, suffisso: K, M es: --win_size=10k. Predefinito
10k.

-X, --dimensione_fissa=
Lunghezza fissa del valore.

-in, --verifica=
La proporzione della verifica della data, ad esempio: --verify=0.01

-D, --divisione=
Numero di chiavi per ottenere il multiplo una volta. Predefinito 1, significa get singolo.

-S, --freq_stat=
Frequenza delle informazioni statistiche di dumping. suffisso: s-secondi, m-minuti, es:
--resp_freq=10s.

-e, --exp_verify=
La proporzione di oggetti con tempo di scadenza, ad esempio: --exp_verify=0.01. No predefinito
oggetto con scadenza

-oh, --sovrascrivi=
La proporzione di oggetti deve essere sovrascritta, ad esempio: --overwrite=0.01. Predefinito mai
sovrascrivere l'oggetto.

-R, --riconnetti
Riconnetti i test, quando la connessione viene chiusa verrà ricollegata.

-U, --udp
Test UDP, memaslap predefinito utilizza TCP, la porta TCP e la porta UDP del server devono essere uguali.

-a, --Facebook
Se abilita la funzione di test di Facebook, imposta con TCP e multi-get con UDP.

-B, --binario
Se abilita il protocollo binario. Predefinito con protocollo ASCII.

-P, --tps=
Throughput previsto, suffisso: K, ad esempio: --tps=10k.

-P, --rep_scrivi=
Il primo ennesimo server può scrivere dati, ad esempio: --rep_write=2.

-b, --verboso
Se emette informazioni dettagliate quando la verifica fallisce.

-h, --Aiuto
Visualizza questo messaggio e poi esci.

-V, --versione
Visualizza la versione dell'applicazione e poi esci.

ESEMPI

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

HOMEPAGE

Per saperne di più, controlla: http://libmemcached.org/

AUTORI

Mingqiang Zhuang[email protected]> (Tecnologia della goletta) Brian Aker, <‐
[email protected]>

Usa memcaslap online utilizzando i servizi onworks.net