memcaslap - Online di Cloud

PROGRAM:

NAMA

memaslap - Dokumentasi libmemcached

RINGKASAN

memaslap [opsi]

--membantu

MEMCACHED_SERVERS

DESKRIPSI

memaslap adalah alat pembangkit beban dan benchmark untuk server memcached. Ini menghasilkan
beban kerja yang dapat dikonfigurasi seperti utas, konkurensi, koneksi, waktu proses, menimpa,
miss rate, ukuran kunci, ukuran nilai, mendapatkan/menetapkan proporsi, throughput yang diharapkan, dan sebagainya.
Selain itu, juga menguji verifikasi data, verifikasi waktu kedaluwarsa, UDP, biner
protokol, uji facebook, uji replikasi, multi-get dan rekoneksi, dll.

Memaslap mengelola koneksi jaringan seperti memcached dengan libevent. Setiap utas memaslap
terikat dengan inti CPU, semua utas tidak berkomunikasi satu sama lain, dan ada
beberapa koneksi soket di setiap utas. Setiap koneksi menjaga distribusi ukuran kunci,
distribusi ukuran nilai, dan distribusi perintah dengan sendirinya.

Anda dapat menentukan server melalui menampar --server opsi atau melalui variabel lingkungan
MEMCACHED_SERVERS.

FITUR

Memslap dikembangkan untuk tujuan berikut:

Mengelola koneksi jaringan dengan libevent secara asinkron.

Setel TCP dan UDP untuk menggunakan IO non-pemblokiran.

Meningkatkan paralelisme: kinerja yang lebih tinggi di lingkungan multi-utas.

Meningkatkan efisiensi waktu: kecepatan pemrosesan lebih cepat.

Menghasilkan kunci dan nilai lebih efisien; distribusi ukuran kunci dan ukuran nilai
distribusi dapat dikonfigurasi.

Mendukung perintah get, multi-get, dan set; distribusi perintah dapat dikonfigurasi.

Mendukung tingkat kesalahan yang dapat dikontrol dan tingkat penimpaan.

Mendukung data dan verifikasi waktu kedaluwarsa.

Mendukung dumping informasi statistik secara berkala.

Mendukung ribuan koneksi TCP.

Mendukung protokol biner.

Mendukung uji facebook (diatur dengan TCP dan multi-get dengan UDP) dan uji replikasi.

RINCIAN

Efektif implementasi of jaringan.
Untuk memaslap, baik TCP maupun UDP menggunakan jaringan non-blocking IO. Semua acara jaringan adalah
dikelola oleh libevent sebagai memcached. Modul jaringan memaslap mirip dengan memcached.
Libevent dapat memastikan memaslap dapat menangani jaringan dengan sangat efisien.

Efektif implementasi of multi-utas dan konkurensi
Memslap memiliki implementasi multi-utas yang serupa dengan memcached. Memslap menciptakan satu
atau lebih utas yang diatur sendiri; setiap utas terikat dengan satu inti CPU jika sistem menguji
pengaturan afinitas inti CPU.

Selain itu, setiap utas memiliki libevent untuk mengelola peristiwa jaringan; setiap utas
memiliki satu atau lebih konkurensi yang diatur sendiri; dan setiap konkurensi memiliki satu atau lebih soket
koneksi. Semua konkurensi tidak berkomunikasi satu sama lain meskipun mereka
di utas yang sama.

Memslap dapat membuat ribuan koneksi soket, dan setiap konkurensi memiliki puluhan
koneksi soket. Setiap konkurensi secara acak atau berurutan memilih satu soket
koneksi dari kumpulan koneksi soketnya untuk dijalankan, sehingga memaslap dapat memastikan setiap konkurensi
menangani satu koneksi soket pada waktu tertentu. Pengguna dapat menentukan jumlah
koneksi konkurensi dan soket dari setiap konkurensi sesuai dengan yang diharapkan
beban kerja.

Efektif implementasi of menghasilkan kunci dan nilai
Untuk meningkatkan efisiensi waktu dan efisiensi ruang, memaslap membuat acak
tabel karakter dengan 10 juta karakter. Semua sufiks kunci dan nilai dihasilkan
dari tabel karakter acak ini.

Memslap menggunakan offset dalam tabel karakter dan panjang string untuk mengidentifikasi a
rangkaian. Hal ini dapat menghemat banyak memori. Setiap kunci berisi dua bagian, awalan dan akhiran. NS
awalan adalah uint64_t, 8 byte. Untuk memverifikasi kumpulan data sebelumnya, memaslap perlu
memastikan setiap kunci unik, sehingga menggunakan awalan untuk mengidentifikasi kunci. Awalan tidak bisa
sertakan karakter ilegal, seperti 'r', 'n', '0' dan ' '. Dan memaslap memiliki algoritma
untuk memastikan bahwa.

Memslap tidak menghasilkan semua objek (pasangan nilai kunci) di awal. Itu hanya
menghasilkan objek yang cukup untuk mengisi jendela tugas (objek 10K default) masing-masing
konkurensi. Setiap objek memiliki informasi dasar berikut, awalan kunci, akhiran kunci
offset di tabel karakter, panjang kunci, nilai offset di tabel karakter, dan nilai
panjangnya.

Dalam proses kerja, setiap konkurensi secara berurutan atau acak memilih objek dari
jendela untuk melakukan operasi set atau mendapatkan operasi. Pada saat yang sama, setiap konkurensi dimulai
objek keluar dari jendelanya dan menambahkan objek baru ke dalamnya.

Sederhana tapi berguna tugas penjadwalan
Memslap menggunakan libevent untuk menjadwalkan semua konkurensi utas, dan setiap konkurensi
menjadwalkan tugas berdasarkan jendela tugas lokal. Memslap mengasumsikan bahwa jika setiap konkurensi
menjaga distribusi kunci yang sama, distribusi nilai dan distribusi perintah, dari
di luar, memaslap menyimpan semua distribusi secara keseluruhan. Setiap jendela tugas mencakup banyak hal
objek, setiap objek menyimpan informasi dasarnya, seperti kunci, nilai, waktu kedaluwarsa, dan
segera. Setiap saat, semua objek di jendela menyimpan kunci dan nilai yang sama dan tetap
distribusi. Jika suatu objek ditimpa, nilai objek akan diperbarui.
Memslap memverifikasi data atau waktu kedaluwarsa sesuai dengan informasi objek yang disimpan di
jendela tugas.

Libevent memilih konkurensi mana yang akan ditangani berdasarkan peristiwa jaringan tertentu. Kemudian
concurrency memilih perintah mana (dapatkan atau setel) untuk beroperasi berdasarkan perintah
distribusi. Jika perlu mengeluarkan objek lama dan menambahkan objek baru, untuk menjaga
kunci dan distribusi nilai yang sama, objek baru harus memiliki panjang kunci yang sama dan
panjang nilai.

Jika memcached server memiliki dua lapisan cache (memori dan SSD), menjalankan memaslap dengan berbeda
ukuran jendela bisa mendapatkan tingkat kehilangan cache yang berbeda. Jika memaslap menambahkan cukup banyak objek ke dalam
windows di awal, dan cache memcached tidak dapat menyimpan semua objek
diinisialisasi, kemudian memaslap akan mendapatkan beberapa objek dari lapisan cache kedua. Itu menyebabkan
lapisan cache pertama yang terlewatkan. Jadi pengguna dapat menentukan ukuran jendela untuk mendapatkan yang diharapkan
tingkat kesalahan lapisan cache pertama.

Berguna implementasi of multi-server , UDP, TCP, multi-dapatkan dan biner protokol
Karena setiap utas diatur sendiri, memaslap dapat menetapkan utas yang berbeda untuk ditangani
server memcache yang berbeda. Ini hanyalah salah satu cara memaslap menguji banyak
server. Satu-satunya batasan adalah jumlah server tidak boleh lebih besar dari
jumlah benang. Cara lain untuk menguji beberapa server adalah untuk uji replikasi. Setiap
concurrency memiliki satu koneksi soket ke setiap server memcached. Untuk pelaksanaannya,
memaslap dapat mengatur beberapa objek ke satu server memcached, dan mendapatkan objek ini dari
server lainnya.

Secara default, Memslap tidak mendapatkan tunggal. Jika pengguna menentukan opsi multi-get, memaslap akan
mengumpulkan cukup mendapatkan perintah dan mengemas dan mengirim perintah bersama.

Memslap menguji protokol ASCII dan protokol biner, tetapi berjalan pada ASCII
protokol secara default. Memslap secara default berjalan pada protokol TCP, tetapi juga menguji UDP.
Karena UDP tidak dapat diandalkan, paket yang jatuh dan paket yang rusak dapat terjadi. tamparan
menciptakan buffer memori untuk menangani masalah ini. Memslap mencoba membaca semua tanggapan
data dari satu perintah dari server dan menyusun ulang data respons. Jika beberapa paket mendapatkan
hilang, mekanisme waktu tunggu tunggu dapat memastikan paket setengah matang akan dibuang dan
perintah berikutnya akan dikirim.

PENGGUNAAN

Di bawah ini adalah beberapa contoh penggunaan:

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

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

Pengguna harus menentukan setidaknya satu server untuk menjalankan memaslap. Parameter lainnya memiliki
nilai default, seperti yang ditunjukkan di bawah ini:

Nomor utas = 1 Konkurensi = 16

Waktu berjalan = 600 detik File konfigurasi = NULL

Ukuran kunci = 64 Ukuran nilai = 1024

Dapatkan/set = 9:1 Ukuran jendela = 10k

Jalankan nomor = 0 Single get = true

Multi-get = false Jumlah soket setiap konkurensi = 1

Hubungkan kembali = salah Verifikasi data = salah

Verifikasi waktu kedaluwarsa = protokol ASCII palsu = benar

Protokol biner = informasi statistik Dumping palsu

periodik = salah

Timpa proporsi = 0% UDP = false

TCP = benar Batas throughput = salah

Tes Facebook = salah Tes replikasi = salah

kunci ukuran, nilai ukuran dan Command distribusi.
Semua distribusi dibaca dari file konfigurasi yang ditentukan oleh pengguna dengan
opsi “—cfg_cmd”. Jika pengguna tidak menentukan file konfigurasi, memaslap akan dijalankan
dengan distribusi default (ukuran kunci = 64, ukuran nilai = 1024, get/set = 9:1). Untuk
informasi tentang cara mengedit file konfigurasi, lihat "File Konfigurasi"
bagian.

Ukuran kunci minimum adalah 16 byte; ukuran kunci maksimum adalah 250 byte. Ketepatan dari
proporsinya adalah 0.001. Proporsi distribusi akan dibulatkan menjadi 3 tempat desimal.

Ukuran nilai minimum adalah 1 byte; ukuran nilai maksimum adalah 1M byte. Ketepatan dari
proporsinya adalah 0.001. Proporsi distribusi akan dibulatkan menjadi 3 tempat desimal.
Saat ini, memaslap hanya tests set dan get command. Dan itu menguji 100% set dan 100% dapatkan.
Untuk mendapatkan 100%, itu akan mengatur beberapa objek ke server.

Multi-utas dan konkurensi
Performa tinggi memaslap diuntungkan dari jadwal khusus thread dan
konkurensi. Sangat penting untuk menentukan jumlah yang tepat dari mereka. Nomor default dari
benang adalah 1; jumlah default konkurensi adalah 16. Pengguna dapat menggunakan “—utas” dan
“--concurrency” untuk menentukan variabel-variabel ini.

Jika sistem menguji pengaturan afinitas CPU dan jumlah utas yang ditentukan oleh pengguna
lebih besar dari 1, memaslap akan mencoba mengikat setiap thread ke inti CPU yang berbeda. Jadi jika
anda ingin memaslap performa terbaik, lebih baik tentukan jumlah
thread sama dengan jumlah core CPU. Jumlah utas yang ditentukan oleh pengguna dapat
juga lebih kecil atau lebih besar dari jumlah core CPU. Karena keterbatasan
implementasi, jumlah konkurensi bisa menjadi kelipatan dari jumlah
utas.

1. Untuk sistem 8 core CPU

Sebagai contoh:

--utas=2 --konkurensi=128

--utas=8 --konkurensi=128

--utas=8 --konkurensi=256

--utas=12 --konkurensi=144

2. Untuk sistem 16 core CPU

Sebagai contoh:

--utas=8 --konkurensi=128

--utas=16 --konkurensi=256

--utas=16 --konkurensi=512

--utas=24 --konkurensi=288

Kinerja memaslap sangat baik, ketika digunakan untuk menguji kinerja server memcached.
Sebagian besar waktu, hambatan adalah jaringan atau server. Jika karena alasan tertentu pengguna
ingin membatasi kinerja memaslap, ada dua cara untuk melakukannya:

Kurangi jumlah utas dan konkurensi. Gunakan opsi “--tps” yang memaslap
menyediakan untuk membatasi throughput. Opsi ini memungkinkan pengguna untuk mendapatkan yang diharapkan
keluaran. Misalnya, asumsikan bahwa throughput maksimum adalah 50 kops/s untuk spesifik
konfigurasi, Anda dapat menentukan throughput yang sama dengan atau kurang dari throughput maksimum
menggunakan opsi “--tps”.

Jendela ukuran
Sebagian besar waktu, pengguna tidak perlu menentukan ukuran jendela. Jendela default
ukuran 10k Untuk Schooner Memcached, pengguna dapat menentukan ukuran jendela yang berbeda untuk mendapatkan
tingkat kehilangan cache yang berbeda berdasarkan kasus uji. Memslap menguji tingkat kesalahan cache antara
0% dan 100%. Jika Anda menggunakan utilitas ini untuk menguji kinerja Schooner Memcached, Anda
dapat menentukan ukuran jendela yang tepat untuk mendapatkan tingkat kesalahan cache yang diharapkan. Rumus untuk
menghitung ukuran jendela adalah sebagai berikut:

Asumsikan bahwa ukuran kunci adalah 128 byte, dan ukuran nilainya adalah 2048 byte, dan
konkurensi=128.

1. Cache kecil cache_size=1M, 100% cache miss (semua data didapat dari SSD). win_size = 10k

2.cache_size=4G

(1). tingkat kesalahan cache 0%

win_size = 8k

(2). tingkat kesalahan cache 5%

win_size = 11k

3.cache_size=16G

(1). tingkat kesalahan cache 0%

win_size = 32k

(2). tembolok rindu

menilai 5%

win_size = 46k

Rumus untuk menghitung ukuran jendela untuk cache miss rate 0%:

cache_size / konkurensi / (ukuran_kunci + ukuran_nilai) * 0.5

Rumus untuk menghitung ukuran jendela untuk cache miss rate 5%:

cache_size / konkurensi / (ukuran_kunci + ukuran_nilai) * 0.7

Verifikasi
Memslap menguji verifikasi data dan verifikasi waktu kedaluwarsa. Pengguna dapat menggunakan
"--verify=" atau "-v" untuk menentukan proporsi verifikasi data. Secara teori, itu menguji
verifikasi data 100%. Pengguna dapat menggunakan "--exp_verify=" atau "-e" untuk menentukan proporsi
verifikasi waktu kedaluwarsa. Secara teori, ini menguji 100% verifikasi waktu kedaluwarsa. Menentukan
opsi "--verbose" untuk mendapatkan informasi kesalahan yang lebih detail.

Contoh: --exp_verify=0.01 –verify=0.1 , artinya 1% objek diset dengan
waktu kedaluwarsa, 10% dari objek yang didapat akan diverifikasi. Jika benda-benda itu didapat,
memaslap akan memverifikasi waktu dan nilai kedaluwarsa.

multi-server dan multi-konfigurasi
Memslap menguji multi-server berdasarkan utas yang diatur sendiri. Ada batasan yang
jumlah server tidak boleh lebih besar dari jumlah utas. Memslap menugaskan satu
utas untuk menangani setidaknya satu server. Pengguna dapat menggunakan opsi "--servers=" atau "-s" untuk
tentukan multi-server.

Sebagai contoh:

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

Perintah di atas berarti ada 6 utas, dengan setiap utas memiliki 6 konkurensi
dan bahwa utas 0 dan 3 menangani server 0 (10.1.1.1); utas 1 dan 4 menangani server 1
(10.1.1.2); dan thread 2 dan 5 menangani server 2 (10.1.1.3).

Semua utas dan konkurensi dalam memaslap diatur sendiri.

Begitu juga dengan memaslap. Pengguna dapat memulai beberapa instance memaslap. Pengguna dapat menjalankan
memaslap pada mesin klien yang berbeda untuk berkomunikasi dengan server memcached yang sama di
sama. Disarankan agar pengguna memulai memaslap yang berbeda pada mesin yang berbeda menggunakan
konfigurasi yang sama.

Run dengan menjalankan jumlah mode or waktu mode
Secara default memaslap berjalan dengan mode waktu. Waktu berjalan default adalah 10 menit. Jika kali
keluar, memaslap akan keluar. Jangan tentukan mode nomor eksekusi dan mode waktu secara bersamaan
waktu; cukup tentukan satu saja.

Sebagai contoh:

--time=30s (Ini berarti tes akan berjalan 30 detik.)

--execute_number=100000 (Artinya setelah menjalankan 100000 perintah, tes akan keluar.)

Membuang statistik informasi secara berkala.
Pengguna dapat menggunakan "--stat_freq=" atau "-S" untuk menentukan frekuensi.

Sebagai contoh:

--stat_freq=20 detik

Memslap akan membuang statistik perintah (dapatkan dan setel) pada frekuensi setiap
20 detik.

Untuk informasi lebih lanjut tentang format informasi statistik dumping, lihat “Format”
bagian keluaran”.

Multi-dapatkan
Pengguna dapat menggunakan "--division=" atau "-d" untuk menentukan jumlah kunci multi-get. Memslap oleh
default tidak mendapatkan tunggal dengan TCP. Memslap juga menguji verifikasi data dan waktu kedaluwarsa
verifikasi untuk multi-get.

Memslap menguji multi-get dengan TCP dan UDP. Karena implementasi yang berbeda dari
protokol ASCII dan protokol biner, ada beberapa perbedaan antara keduanya. Untuk
protokol ASCII, memaslap mengirimkan satu "multi-get" ke server sekali. Untuk biner
protokol, memaslap mengirimkan beberapa perintah get tunggal bersama-sama sebagai "multi-get" ke
Server.

UDP dan TCP
Memslap menguji UDP dan TCP. Untuk TCP, memaslap tidak menghubungkan kembali server memcached
jika koneksi soket hilang. Jika semua koneksi soket hilang atau server memcache
crash, memaslap akan keluar. Jika pengguna menentukan opsi "--sambungkan kembali" saat soket
koneksi terputus, itu akan menyambungkannya kembali.

Pengguna dapat menggunakan “--udp” untuk mengaktifkan fitur UDP, tetapi UDP memiliki beberapa batasan:

UDP tidak dapat mengatur data lebih dari 1400 byte.

UDP tidak diuji oleh protokol biner karena protokol biner memcached tidak
tidak menguji itu.

UDP tidak menguji koneksi ulang.

Facebook uji
Atur data dengan TCP dan multi-get dengan UDP. Tentukan opsi berikut:

"--facebook --division=50"

Jika Anda ingin membuat ribuan koneksi TCP, tentukan:

"--conn_sock=" pilihan.

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

Perintah di atas berarti memaslap akan melakukan tes facebook, setiap konkurensi memiliki 200
soket koneksi TCP dan satu soket UDP.

Memslap menyetel objek dengan soket TCP, dan multi-mendapatkan 50 objek sekali dengan UDP
stopkontak.

Jika Anda menentukan "--division=50", ukuran kunci harus kurang dari 25 byte karena UDP
ukuran paket adalah 1400 byte.

sahutan uji
Untuk uji replikasi, pengguna harus menentukan setidaknya dua server memcached. Pengguna dapat
gunakan opsi “—rep_write=" untuk mengaktifkan fitur.

Sebagai contoh:

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

Perintah di atas berarti ada 2 server memcached replikasi, memaslap akan disetel
objek ke server 0 dan server 1, dapatkan objek yang disetel ke server 0 sebelumnya dari
server 1, dan juga mendapatkan objek yang disetel ke server 1 sebelumnya dari server 0. Jika server 0
crash, memaslap hanya akan mendapatkan objek dari server 1. Jika server 0 hidup kembali
lagi, memaslap akan menyambungkan kembali server 0. Jika server 0 dan server 1 crash, memaslap
akan keluar.

Mendukung ribuan of TCP koneksi
Mulai memaslap dengan "--conn_sock=" atau "-n" untuk mengaktifkan fitur ini. Pastikan bahwa Anda
sistem dapat menguji pembukaan ribuan file dan membuat ribuan soket. Namun,
fitur ini tidak menguji koneksi ulang jika soket terputus.

Sebagai contoh:

--benang=8 --konkurensi=128 --konn_sock=128

Perintah di atas berarti memaslap memulai 8 utas, setiap utas memiliki 16
konkurensi, setiap konkurensi memiliki 128 koneksi soket TCP, dan jumlah total
Koneksi soket TCP adalah 128 * 128 = 16384.

Mendukung biner protokol
Mulai memaslap dengan opsi "--binary" atau "-B" untuk mengaktifkan fitur ini. Ini menguji semua
fitur di atas kecuali UDP, karena memcached 1.3.3 terbaru tidak mengimplementasikan biner
protokol UDP.

Sebagai contoh:

--biner

Karena memcached 1.3.3 tidak mengimplementasikan protokol UDP biner, memaslap tidak menguji UDP.
Selain itu, memcached 1.3.3 tidak menguji multi-get. Jika Anda menentukan "--division=50"
opsi, itu hanya mengirim 50 perintah get bersama sebagai "mulit-get" ke server.

KONFIGURASI FILE

Bagian ini menjelaskan format file konfigurasi. Secara default saat tidak ada
file konfigurasi ditentukan memaslap membaca yang default terletak di ~/.memaslap.cnf.

Di bawah ini adalah contoh file konfigurasi:

-------------------------------------------------- -------------------------
#komentar harus dimulai dengan '#'
#kunci
#start_len proporsi akhir_len
#
#rentang panjang kunci dari start_len hingga end_len
#start_len harus sama dengan atau lebih besar dari 16
#end_len harus sama dengan atau kurang dari 250
#start_len harus sama dengan atau lebih besar dari end_len
#memaslap akan menghasilkan kunci sesuai dengan rentang kunci
#proporsi: menunjukkan kunci yang dihasilkan dari satu akun rentang untuk total
kunci yang dihasilkan
#
#example1: rentang kunci 16~100 menyumbang 80%
# rentang kunci 101~200 akun untuk 10%
# rentang kunci 201~250 akun untuk 10%
# total harus 1 (0.8+0.1+0.1 = 1)
#
#16 100 0.8
#101 200 0.1
#201 249 0.1
#
#example2: semua panjang kunci adalah 128 byte
#
#128 128 1
kunci
128 128 1
#nilai
#start_len proporsi akhir_len
#
#rentang panjang nilai dari start_len hingga end_len
#start_len harus sama dengan atau lebih besar dari 1
#end_len harus sama dengan atau kurang dari 1M
#start_len harus sama dengan atau lebih besar dari end_len
#memaslap akan menghasilkan nilai sesuai dengan rentang nilai
#proporsi: menunjukkan nilai yang dihasilkan dari satu akun rentang untuk
total nilai yang dihasilkan
#
#example1: rentang nilai 1~1000 menyumbang 80%
# rentang nilai 1001~10000 menyumbang 10%
# rentang nilai 10001~100000 menyumbang 10%
# total harus 1 (0.8+0.1+0.1 = 1)
#
#1 1000 0.8
#1001 10000 0.1
#10001 100000 0.1
#
#example2: semua panjang nilai adalah 128 byte
#
#128 128 1
nilai
2048 2048 1
#cmd
#cmd_type cmd_proporsi
#
#saat ini hanya memaslap tes get dan set perintah.
#
#cmd_type
#atur 0
#dapatkan 1
#
#contoh: setel akun perintah untuk 50%
# dapatkan akun perintah untuk 50%
# total harus 1 (0.5+0.5 = 1)
#
#cmd
#0 0.5
#1 0.5
cmd
0 0.1
1.0 0.9

FORMAT OF KELUARAN

Pada awalnya, memaslap menampilkan beberapa informasi konfigurasi sebagai berikut:

server: 127.0.0.1:11211

jumlah utas: 1

konkurensi: 16

waktu berjalan: 20s

ukuran jendela: 10k

atur proporsi: set_prop=0.10

dapatkan proporsi: get_prop=0.90

Dimana
server: "server"
Server yang digunakan dengan memaslap.

jumlah utas
Jumlah thread yang memaslap berjalan dengan.

konkurensi
Jumlah konkurensi berjalan dengan memaslap.

waktu berjalan
Berapa lama untuk menjalankan memaslap.

ukuran jendela
Ukuran jendela tugas setiap konkurensi.

tetapkan proporsi
Proporsi perintah yang ditetapkan.

dapatkan proporsi
Proporsi perintah get.

Output dari statistik dinamis adalah seperti ini:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Dapatkan Statistik
Ketik Waktu Operasi TPS(ops/s) Net(M/s) Get_miss Min(us) Maks(us)
Rata-rata(kami) Std_dev Geo_dist
Periode 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

Tetapkan Statistik
Ketik Waktu Operasi TPS(ops/s) Net(M/s) Get_miss Min(us) Maks(us)
Rata-rata(kami) Std_dev Geo_dist
Periode 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

Statistik Total
Ketik Waktu Operasi TPS(ops/s) Net(M/s) Get_miss Min(us) Maks(us)
Rata-rata(kami) Std_dev Geo_dist
Periode 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
-------------------------------------------------- -------------------------------------------------- -----------------------------

Dimana
Dapatkan Statistik
Informasi statistik dari perintah get

Tetapkan Statistik
Informasi statistik dari perintah yang ditetapkan

Statistik Total
Informasi statistik dari perintah get dan set

Periode
Hasil dalam satu periode

Aksi
Akumulasi hasil

Ops
Total operasi

TPS
Throughput, operasi/detik

Bersih
Tingkat jaringan

Dapatkan_miss
Berapa banyak objek yang tidak bisa didapat

Min
Waktu respons minimum

max
Waktu respons maksimum

Rata-rata:
Waktu respons rata-rata

Std_dev
Standar deviasi waktu respons

Geo_disst
Distribusi geometrik berdasarkan fungsi eksponensial alami

Pada akhirnya, memaslap akan menampilkan sesuatu seperti ini:

-------------------------------------------------- -------------------------------------------------- -----------------------------
Dapatkan Statistik (1257956 acara)
Minimal: 26
Maks: 3791
Rata-rata: 224
Geografis: 192.60
Std: 116.23
Jarak Log2:
4: 0 10 84490 215345
8: 484890 459823 12543 824
12: 31

Tetapkan Statistik (139782 peristiwa)
Minimal: 37
Maks: 3790
Rata-rata: 253
Geografis: 224.84
Std: 116.83
Jarak Log2:
4: 0 0 4200 16988
8: 50784 65574 2064 167
12: 5

Statistik Total (1397738 peristiwa)
Minimal: 26
Maks: 3791
Rata-rata: 227
Geografis: 195.60
Std: 116.60
Jarak Log2:
4: 0 10 88690 232333
8: 535674 525397 14607 991
12: 36

cmd_dapatkan: 1257969
cmd_set: 139785
dapatkan_misses: 0
verifikasi_misses: 0
verifikasi_gagal: 0
kadaluwarsa_dapatkan: 0
belum kedaluwarsa_unget: 0
write_bytes: 242516030
baca_byte: 1003702556
objek_byte: 152086080
paket_gangguan: 0
paket_drop: 0
udp_timeout: 0

Waktu berjalan: 20.0s Operasi: 1397754 TPS: 69817 Net_rate: 59.4M/s
-------------------------------------------------- -------------------------------------------------- -----------------------------

Dimana
Dapatkan Statistik
Dapatkan statistik waktu respons

Tetapkan Statistik
Tetapkan statistik waktu respons

Statistik Total
Keduanya mendapatkan dan mengatur statistik waktu respons

Min
Akumulasi dan waktu respons minimum

max
Akumulasi dan waktu respons maksimum

Avg
Akumulasi dan waktu respons rata-rata

jam
Standar deviasi waktu respons

Jarak Log2
Distribusi geometrik berdasarkan logaritma 2

cmd_dapatkan
Selesaikan perintah total

cmd_set
Perintah set total selesai

dapatkan_misses
Berapa banyak objek yang tidak bisa didapat dari server

verifikasi_misses
Berapa banyak objek yang perlu diverifikasi tetapi tidak bisa mendapatkannya

verifikasi_gagal
Berapa banyak objek dengan nilai ngotot

kedaluwarsa_get
Berapa banyak objek yang kedaluwarsa tetapi kami mendapatkannya

belum kedaluwarsa_unget
Berapa banyak objek yang belum kedaluwarsa tetapi kita tidak bisa mendapatkannya

tertulis_byte
Total byte tertulis

baca_bytes
Total byte yang dibaca

objek_byte
Total byte objek

paket_gangguan
Berapa banyak paket UDP yang tidak teratur?

paket_drop
Berapa banyak paket UDP yang hilang?

udp_timeout
Berapa kali waktu habis UDP terjadi?

Jalankan waktu
Total waktu berjalan

Ops
Total operasi

TPS
Throughput, operasi/detik

Tarif_bersih
Tingkat rata-rata jaringan

PILIHAN

-S, --server=
Daftar satu atau lebih server untuk terhubung. Jumlah server harus kurang dari jumlah thread.
misalnya: --servers=localhost:1234,localhost:11211

-T, --benang=
Jumlah utas untuk memulai, lebih baik sama dengan nomor CPU. Standar 8.

-C, --konkurensi=
Jumlah konkurensi untuk disimulasikan dengan beban. Standar 128.

-N, --sambungan_kaus kaki=
Jumlah kaus kaki TCP per konkurensi. Standar 1.

-X, --execute_number=
Jumlah operasi (dapatkan dan setel) yang akan dijalankan untuk pengujian yang diberikan. Standar 1000000.

-T, --waktu=
Berapa lama tes dijalankan, akhiran: s-detik, m-menit, h-jam, d-hari misalnya:
--waktu=2j.

-F, --cfg_cmd=
Muat file konfigurasi untuk mendapatkan daftar distribusi perintah, kunci, dan nilai.

-w, --menang_ukuran=
Ukuran jendela tugas setiap konkurensi, akhiran: K, M mis: --win_size=10k. Bawaan
10k

-X, --ukuran_tetap=
Panjang nilai tetap.

-di, --verifikasi=
Proporsi verifikasi tanggal, misalnya: --verify=0.01

-D, --divisi=
Jumlah kunci untuk multi-get sekali. Default 1, berarti single get.

-S, --stat_freq=
Frekuensi dumping informasi statistik. akhiran: s-detik, m-menit, misalnya:
--resp_freq=10 detik.

-e, --exp_verifikasi=
Proporsi objek dengan waktu kedaluwarsa, misalnya: --exp_verify=0.01. No default
objek dengan waktu kedaluwarsa

-Hai, --timpa=
Proporsi objek yang perlu ditimpa, misalnya: --overwrite=0.01. default tidak pernah
menimpa objek.

-R, --sambungkan kembali
Menghubungkan kembali tes, ketika koneksi ditutup akan disambungkan kembali.

-U, --udp
Tes UDP, memaslap default menggunakan TCP, port TCP dan port UDP server harus sama.

-a, --facebook
Apakah itu mengaktifkan fitur uji facebook, set dengan TCP dan multi-get dengan UDP.

-B, --biner
Apakah itu memungkinkan protokol biner. Default dengan protokol ASCII.

-P, --tps=
Throughput yang diharapkan, akhiran: K, misalnya: --tps=10k.

-P, --rep_write=
Server ke-n pertama dapat menulis data, misalnya: --rep_write=2.

-b, --bertele-tele
Apakah itu mengeluarkan informasi terperinci saat verifikasi gagal.

-h, --membantu
Tampilkan pesan ini lalu keluar.

-V, --Versi: kapan
Tampilkan versi aplikasi lalu keluar.

CONTOH

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

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

HOME

Untuk mengetahui informasi lebih lanjut silahkan cek: http://libmemcached.org/

PENULIS

Mingqiang Zhuang[email dilindungi]> (Teknologi Sekunar) Brian Aker, <-
[email dilindungi]>

Gunakan memcaslap online menggunakan layanan onworks.net