memcaslap - מקוון בענן

תָכְנִית:

שֵׁם

memaslap - תיעוד libmemcached

תַקצִיר

memaslap [אפשרויות]

- עזרה

MEMCACHED_SERVERS

תיאור

ממסlap הוא כלי ליצירת עומסים ו-benchmark עבור שרתי memcached. זה מייצר
עומס עבודה שניתן להגדרה כגון שרשורים, תרומות, חיבורים, זמן ריצה, החלפה,
שיעור החמצה, גודל מפתח, גודל ערך, פרופורציה קבל/קבע, תפוקה צפויה וכן הלאה.
יתר על כן, הוא גם בודק אימות נתונים, אימות בזמן תפוגה, UDP, בינארי
פרוטוקול, בדיקת פייסבוק, בדיקת שכפול, ריבוי גט וחיבור מחדש וכו'.

Memaslap מנהלת חיבורי רשת כמו memcached עם libevent. כל חוט של ממסלפ
קשור בליבת CPU, כל השרשורים לא מתקשרים זה עם זה, ויש
מספר חיבורי שקעים בכל חוט. כל חיבור שומר על חלוקת גודל מפתח,
התפלגות גודל ערך, והתפלגות פקודות בפני עצמה.

אתה יכול לציין שרתים דרך memslap --שרתים אפשרות או דרך משתנה הסביבה
MEMCACHED_SERVERS.

מאפיינים

Memslap פותחה למטרות הבאות:

מנהל חיבורי רשת עם libevent באופן אסינכרוני.

הגדר גם TCP וגם UDP לשימוש ב-IO לא חוסם.

משפר מקביליות: ביצועים גבוהים יותר בסביבות ריבוי חוטים.

משפר את יעילות הזמן: מהירות עיבוד מהירה יותר.

מייצר מפתח וערך בצורה יעילה יותר; חלוקת גודל מפתח וגודל ערך
ההפצה ניתנת להגדרה.

תומך בפקודות get, multi-get ו-set; הפצת פקודות ניתנת להגדרה.

תומך בקצב החמצה ובקצב החלפה הניתן לשליטה.

תומך בנתונים ובאימות בזמן תפוגה.

תומך בהטלת מידע סטטיסטי מעת לעת.

תומך באלפי חיבורי TCP.

תומך בפרוטוקול בינארי.

תומך בבדיקת פייסבוק (מוגדר עם TCP ו-multi-get עם UDP) ובבדיקת שכפול.

פרטים

אפקטיבי הפעלה of רשת.
עבור Memaslap, גם TCP וגם UDP משתמשים ב-IO של רשת לא חוסמת. כל אירועי הרשת הם
מנוהל על ידי libevent כ- memcached. מודול הרשת של memaslap דומה ל-memcached.
Libevent יכולה להבטיח ש-memaslap יכול להתמודד עם הרשת ביעילות רבה.

אפקטיבי הפעלה of ריבוי חוטים ו מקביליות
ל-Memslap יש יישום דומה של ריבוי חוטים ל-memcached. Memslap יוצר אחד
או יותר חוטים בשליטה עצמית; כל שרשור קשור בליבת מעבד אחת אם המערכת בודקת
הגדרת זיקה ליבת CPU.

בנוסף, לכל שרשור יש אפשרות לניהול אירועי הרשת; כל חוט
יש לו מטבע אחד או יותר בשליטה עצמית; ולכל מקביל יש שקע אחד או יותר
קשרים. כל המקרים לא מתקשרים זה עם זה למרות שהם כן
באותו שרשור.

Memslap יכולה ליצור אלפי חיבורי שקעים, ולכל מקביל יש עשרות
חיבורי שקעים. כל מקביל בוחר באקראי או ברצף שקע אחד
חיבור ממאגר החיבורים שלו להפעלה, כך ש-memaslap יכול להבטיח כל מקבילות
מטפל בחיבור שקע אחד בכל זמן נתון. משתמשים יכולים לציין את המספר של
במקביל וחיבורי שקעים של כל מקביל בהתאם לציפיות שלהם
עומס עבודה.

אפקטיבי הפעלה of יצירת מפתח ו ערך
על מנת לשפר את יעילות הזמן ויעילות החלל, Memaslap יוצר אקראי
טבלת תווים עם 10 מיליון תווים. נוצרות כל הסיומות של מפתחות וערכים
מטבלת התווים האקראיים הזו.

Memslap משתמשת בהיסט בטבלת התווים ובאורך המחרוזת כדי לזהות א
חוּט. זה יכול לחסוך הרבה זיכרון. כל מפתח מכיל שני חלקים, קידומת וסיומת. ה
הקידומת היא uint64_t, 8 בתים. על מנת לאמת את מערך הנתונים לפני, יש צורך ב-memaslap
ודא שכל מפתח הוא ייחודי, ולכן הוא משתמש בקידומת כדי לזהות מפתח. הקידומת לא יכולה
כולל תווים לא חוקיים, כגון 'r', 'n', '0' ו- ' '. ול-memaslap יש אלגוריתם
להבטיח ש.

Memslap לא יוצר את כל האובייקטים (צמדי מפתח-ערך) בהתחלה. זה בלבד
יוצר מספיק אובייקטים כדי למלא את חלון המשימות (ברירת מחדל של 10K אובייקטים) של כל אחד
במקביל. לכל אובייקט יש את המידע הבסיסי הבא, קידומת מפתח, סיומת מפתח
היסט בטבלת התווים, אורך מפתח, היסט ערך בטבלת התווים וערך
אורך.

בתהליך העבודה, כל מקביל בוחרת ברצף או באקראי אובייקט מתוך
חלון כדי לעשות את פעולת הגדר או לקבל פעולה. במקביל, כל מקביל בועט
אובייקטים מחוץ לחלון שלו ומוסיף אובייקט חדש לתוכו.

פָּשׁוּט אבל מועיל משימה תזמון
Memslap משתמשת ב-libevent כדי לתזמן את כל המקרים של שרשורים, וכל מקביל
מתזמן משימות על סמך חלון המשימות המקומי. Memslap מניח שאם כל במקביל
שומר על אותה הפצת מפתחות, הפצת ערכים והפצת פקודות, מ
בחוץ, Memaslap שומר על כל ההפצה כמכלול. כל חלון משימות כולל הרבה
של אובייקטים, כל אובייקט מאחסן את המידע הבסיסי שלו, כגון מפתח, ערך, זמן תפוגה ו
בקרוב. בכל עת, כל האובייקטים בחלון שומרים על אותו מפתח וערך קבועים
הפצה. אם אובייקט מוחלף, ערך האובייקט יעודכן.
Memslap מאמת את הנתונים או זמן התפוגה בהתאם למידע האובייקט המאוחסן ב-
חלון משימות.

Libevent בוחר באיזו מקבילות לטפל בהתבסס על אירוע רשת ספציפי. אז ה
concurrency בוחר איזו פקודה (get או set) לפעול על סמך הפקודה
הפצה. אם הוא צריך לבעוט חפץ ישן ולהוסיף חפץ חדש, כדי לשמור
אותה התפלגות מפתח וערך, האובייקט החדש חייב להיות בעל אותו אורך מפתח ו
אורך ערך.

אם לשרת memcached יש שתי שכבות מטמון (זיכרון ו-SSD), הפעלת memaslap עם שונה
גדלי חלונות יכולים לקבל שיעורי החמצה שונים של מטמון. אם memaslap מוסיף מספיק אובייקטים לתוך
חלונות בהתחלה, והמטמון של memcached אינו יכול לאחסן את כל האובייקטים
אתחול, אז memaslap יקבל כמה אובייקטים משכבת ​​המטמון השנייה. זה גורם
שכבת המטמון הראשונה להחמיץ. אז המשתמש יכול לציין את גודל החלון כדי לקבל את הצפוי
שיעור החמצה של שכבת המטמון הראשונה.

מוֹעִיל הפעלה of ריבוי שרתים , UDP, TCP, ריבוי קבלים ו בינרי פרוטוקול
מכיוון שכל שרשור הוא בשליטה עצמית, Memaslap יכול להקצות חוטים שונים לטיפול
שרתים מסוג memcach שונים. זו רק אחת מהדרכים שבהן בדיקות ממסלפ מרובות
שרתים. המגבלה היחידה היא שמספר השרתים לא יכול להיות גדול מ-
מספר חוטים. הדרך השנייה לבדוק מספר שרתים היא בדיקת שכפול. כל אחד
במקביל יש חיבור שקע אחד לכל שרת שמור ב-memcached. לצורך היישום,
memaslap יכול להגדיר אובייקטים מסוימים לשרת memcached אחד, ולקבל אובייקטים אלה מה-
שרתים אחרים.

כברירת מחדל, Memslap עושה קבל יחיד. אם המשתמש מציין אפשרות ריבוי גט, Memaslap יעשה זאת
אספו מספיק קבל פקודות וארוז ושלח את הפקודות ביחד.

Memslap בודק גם את פרוטוקול ASCII וגם את הפרוטוקול הבינארי, אך הוא פועל על ה-ASCII
פרוטוקול כברירת מחדל. Memslap כברירת מחדל פועלת על פרוטוקול TCP, אך היא גם בודקת UDP.
מכיוון ש-UDP אינו אמין, עלולות להופיע חבילות שנשמטו וחבילות לא בהזמנה. ממסלאפ
יוצר מאגר זיכרון לטיפול בבעיות אלו. ממסלאפ מנסה לקרוא את כל התגובה
נתונים של פקודה אחת מהשרת ומסדר מחדש את נתוני התגובה. אם כמה חבילות לקבל
אבדו, מנגנון פסק זמן ההמתנה יכול להבטיח חבילות חצי אפויות יושלכו ו
הפקודה הבאה תישלח.

נוהג

להלן כמה דוגמאות לשימוש:

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

המשתמש חייב לציין שרת אחד לפחות כדי להפעיל Memaslap. לשאר הפרמטרים יש
ערכי ברירת מחדל, כפי שמוצג להלן:

מספר חוט = 1 במקביל = 16

זמן ריצה = 600 שניות קובץ תצורה = NULL

גודל מפתח = 64 גודל ערך = 1024

קבל/קבע = 9:1 גודל חלון = 10k

מספר ביצוע = 0 קבל בודד = נכון

Multi-get = false מספר שקעים של כל מקביל = 1

התחבר מחדש = שקר אימות נתונים = שקר

אימות בזמן תפוגה = פרוטוקול ASCII שקר = נכון

פרוטוקול בינארי = false השלכת מידע סטטיסטי

מעת לעת = שקר

פרופורציית החלפה = 0% UDP = שקר

TCP = true Limit flowput = false

מבחן פייסבוק = שקר מבחן רפליקציה = שקר

מפתח גודל, ערך גודל ו הפקודה הפצה.
כל ההפצות נקראות מקובץ התצורה שצוין על ידי המשתמש עם
אפשרות "—cfg_cmd". אם המשתמש לא מציין קובץ תצורה, Memaslap יפעל
עם התפלגות ברירת המחדל (גודל מפתח = 64, גודל ערך = 1024, get/set = 9:1). ל
מידע על אופן עריכת קובץ התצורה, עיין ב"קובץ תצורה"
סָעִיף.

גודל המפתח המינימלי הוא 16 בתים; גודל המפתח המרבי הוא 250 בתים. הדיוק של
הפרופורציה היא 0.001. שיעור ההתפלגות יעוגל ל-3 מקומות עשרוניים.

גודל הערך המינימלי הוא 1 בתים; גודל הערך המרבי הוא 1M בתים. הדיוק של
הפרופורציה היא 0.001. שיעור ההתפלגות יעוגל ל-3 מקומות עשרוניים.
נכון לעכשיו, רק בדיקות Memaslap מוגדרות ומקבלות פקודות. וזה בוחן 100% סט ו-100% מקבל.
עבור 100% get, זה יגדיר מראש כמה אובייקטים לשרת.

רב חוטים ו מקביליות
הביצועים הגבוהים של Memaslap נהנים מלוח הזמנים המיוחד של חוט ו
במקביל. חשוב לציין את המספר המתאים שלהם. מספר ברירת המחדל של
חוטים הוא 1; מספר ברירת המחדל של במקביל הוא 16. המשתמש יכול להשתמש ב-"-threads" ו
"--מקבילות" כדי לציין משתנים אלה.

אם המערכת בודקת את הגדרת זיקת המעבד ואת מספר השרשורים שצוין על ידי המשתמש
גדול מ-1, Memaslap ינסה לקשור כל חוט לליבת CPU אחרת. אז אם
אתה רוצה לקבל את הביצועים הטובים ביותר Memaslap, עדיף לציין את המספר של
חוט שווה למספר ליבות המעבד. מספר השרשורים שצוין על ידי המשתמש יכול
גם להיות קטן או גדול ממספר ליבות המעבד. בגלל המגבלה של
יישום, מספר המקרים יכול להיות הכפולה של המספר של
חוטים.

1. למערכת 8 ליבות מעבד

לדוגמה:

--threads=2 --concurrency=128

--threads=8 --concurrency=128

--threads=8 --concurrency=256

--threads=12 --concurrency=144

2. למערכת 16 ליבות מעבד

לדוגמה:

--threads=8 --concurrency=128

--threads=16 --concurrency=256

--threads=16 --concurrency=512

--threads=24 --concurrency=288

ה-memaslap מתפקד טוב מאוד, כאשר משתמשים בו כדי לבדוק את הביצועים של שרתי memcached.
רוב הזמן, צוואר הבקבוק הוא הרשת או השרת. אם מסיבה כלשהי המשתמש
רוצה להגביל את הביצועים של Memaslap, ישנן שתי דרכים לעשות זאת:

הפחת את מספר השרשורים והמקיפות. השתמש באפשרות "--tps" כי ה-memaslap
מספק כדי להגביל את התפוקה. אפשרות זו מאפשרת למשתמש לקבל את המצופה
תפוקה. לדוגמה, נניח שהתפוקה המקסימלית היא 50 קופות לשנייה עבור ספציפי
תצורה, אתה יכול לציין את התפוקה השווה או קטנה מהתפוקה המקסימלית
באמצעות אפשרות "--tps".

חלון גודל
לרוב, המשתמש אינו צריך לציין את גודל החלון. חלון ברירת המחדל
הגודל הוא 10k. עבור Schooner Memcached, המשתמש יכול לציין גדלים שונים של חלונות לקבל
שיעורי החמצה שונים של מטמון בהתבסס על מקרה הבדיקה. Memslap בודקת שיעור החמצה במטמון בין
0% ו-100%. אם אתה משתמש בכלי זה כדי לבדוק את הביצועים של Schooner Memcached, אתה
יכול לציין גודל חלון מתאים כדי לקבל את שיעור ההחמצה הצפוי של המטמון. הנוסחה עבור
חישוב גודל החלון הוא כדלקמן:

נניח שגודל המפתח הוא 128 בתים, וגודל הערך הוא 2048 בתים, ו
במקביל=128.

1. מטמון קטן cache_size=1M, החמצת 100% מטמון (כל הנתונים מגיעים מ-SSD). win_size=10k

2. cache_size=4G

(1). שיעור החמצת מטמון 0%

win_size=8k

(2). שיעור החמצת מטמון 5%

win_size=11k

3. cache_size=16G

(1). שיעור החמצת מטמון 0%

win_size=32k

(2). פספוס מטמון

שיעור 5%

win_size=46k

הנוסחה לחישוב גודל החלון עבור שיעור החמצה של מטמון 0%:

cache_size / concurrency / (מפתח_גודל + ערך_גודל) * 0.5

הנוסחה לחישוב גודל החלון עבור שיעור החמצה של מטמון 5%:

cache_size / concurrency / (מפתח_גודל + ערך_גודל) * 0.7

אימות
Memslap בודק גם אימות נתונים וגם אימות בזמן תפוגה. המשתמש יכול להשתמש
"--verify=" או "-v" כדי לציין את השיעור של אימות הנתונים. בתיאוריה, זה בוחן
100% אימות נתונים. המשתמש יכול להשתמש ב---exp_verify=" או "-e" כדי לציין את הפרופורציה
של אימות זמן תפוגה. בתיאוריה, הוא בודק אימות של 100% בזמן תפוגה. לפרט
אפשרויות "--verbose" כדי לקבל מידע מפורט יותר על שגיאות.

לדוגמה: --exp_verify=0.01 –verify=0.1 , זה אומר ש-1% מהאובייקטים המוגדרים עם
זמן תפוגה, 10% מהאובייקטים שהתקבלו יאומתו. אם החפצים יתקבלו,
memaslap יאמת את זמן התפוגה והערך.

ריבוי שרתים ו רב תצורה
Memslap בודקת ריבוי שרתים על בסיס שרשור בשליטה עצמית. יש מגבלה לזה
מספר השרתים לא יכול להיות גדול ממספר השרשורים. Memslap מקצה אחד
שרשור כדי לטפל בשרת אחד לפחות. המשתמש יכול להשתמש באפשרות "--servers=" או "-s" כדי
ציין ריבוי שרתים.

לדוגמה:

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

הפקודה לעיל פירושה שיש 6 פתילים, כאשר לכל פתיל יש 6 תווים במקביל
וכי שרשורים 0 ו-3 מטפלים בשרת 0 (10.1.1.1); שרשורים 1 ו-4 מטפלים בשרת 1
(10.1.1.2); וחוט 2 ו-5 מטפלים בשרת 2 (10.1.1.3).

כל השרשורים והמקבילים בממסלפ הם בשליטה עצמית.

כך גם ממסלאפ. המשתמש יכול להפעיל מספר מופעי Memaslap. המשתמש יכול לרוץ
memaslap על מחשבי לקוח שונים כדי לתקשר עם אותו שרת memcached ב-
אותו. מומלץ שהמשתמש יתחיל memaslap שונה במכונות שונות באמצעות
אותה תצורה.

הפעלה עם לבצע מספר מצב or זמן מצב
ה-Memaslap המוגדר כברירת מחדל פועל עם מצב זמן. ברירת המחדל של זמן הריצה היא 10 דקות. אם זה פעמים
החוצה, Memaslap ייצא. אל תציין גם את מצב מספר הביצוע וגם את מצב הזמן בו זמנית
זְמַן; פשוט ציין אחד במקום.

לדוגמה:

--time=30s (זה אומר שהבדיקה תימשך 30 שניות.)

--execute_number=100000 (זה אומר שאחרי הפעלת 100000 פקודות, הבדיקה תצא.)

להשליך נתון מידע מעת לעת.
המשתמש יכול להשתמש ב---stat_freq=" או "-S" כדי לציין את התדירות.

לדוגמה:

--stat_freq=20s

Memslap תשליך את הסטטיסטיקה של הפקודות (get and set) בתדירות של כל
20 שניות.

למידע נוסף על הפורמט של השלכת מידע סטטיסטי, עיין ב"פורמט של
קטע פלט.

ריבוי גט
המשתמש יכול להשתמש ב---division=" או "-d" כדי לציין מספר מפתחות של ריבוי קבלים. Memslap על ידי
ברירת המחדל עושה קבל יחיד עם TCP. Memslap גם בודקת את אימות הנתונים ואת זמן התפוגה
אימות עבור ריבוי גט.

Memslap בודקת ריבוי גט גם עם TCP וגם עם UDP. בגלל היישום השונה של
פרוטוקול ASCII והפרוטוקול הבינארי, ישנם כמה הבדלים בין השניים. ל
פרוטוקול ASCII, memaslap שולח "מולטי-גט" אחד לשרת פעם אחת. עבור הבינארי
פרוטוקול, memaslap שולח מספר פקודות קבל בודדות יחד כ"רב-קבל" ל-
שרת.

UDP ו TCP
Memslap בודק גם UDP וגם TCP. עבור TCP, memaslap לא מחבר מחדש את השרת ה-memcached
אם חיבורי השקע אבדו. אם כל חיבורי השקע אבדו או השרת שמור במטמון
קורס, memaslap ייצא. אם המשתמש מציין את האפשרות "--התחבר מחדש" בעת השקע
חיבורים אבדו, זה יחבר אותם מחדש.

המשתמש יכול להשתמש ב---udp כדי להפעיל את תכונת UDP, אך ל-UDP יש כמה מגבלות:

UDP לא יכול להגדיר נתונים של יותר מ-1400 בתים.

UDP לא נבדק על ידי הפרוטוקול הבינארי מכיוון שהפרוטוקול הבינארי של memcached כן
לא בודק את זה.

UDP לא בודק חיבור מחדש.

פייסבוק מבחן
הגדר נתונים עם TCP ו-multi-get עם UDP. ציין את האפשרויות הבאות:

"--facebook --division=50"

אם ברצונך ליצור אלפי חיבורי TCP, ציין את

אפשרות "--conn_sock=".

לדוגמה: --facebook --division=50 --conn_sock=200

הפקודה לעיל פירושה ש-memaslap יבצע בדיקת פייסבוק, לכל צד יש 200
שקע TCP ושקע UDP אחד.

Memslap מגדיר אובייקטים עם שקע TCP, ומקבל 50 אובייקטים פעם אחת עם UDP
שקע.

אם תציין "--division=50", גודל המפתח חייב להיות פחות מ-25 בתים מכיוון שה-UDP
גודל החבילה הוא 1400 בתים.

שכפול מבחן
לבדיקת שכפול, המשתמש חייב לציין לפחות שני שרתים מאוחסנים בזיכרון זיכרון. המשתמש יכול
השתמש באפשרות "—rep_write=" כדי להפעיל תכונה.

לדוגמה:

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

הפקודה לעיל פירושה שיש 2 שרתי שכפול מאוחסני memcached, memaslap יקבע
אובייקטים גם לשרת 0 וגם לשרת 1, מקבלים אובייקטים שמוגדרים לשרת 0 לפני מ
שרת 1, וגם לקבל אובייקטים שמוגדרים לשרת 1 לפני משרת 0. אם שרת 0
קורס, memaslap יקבל רק אובייקטים משרת 1. אם שרת 0 יחזור לחיים
שוב, Memaslap יחבר מחדש את שרת 0. אם גם שרת 0 וגם שרת 1 קורסים, Memaslap
ייצא.

תומך אלפים of TCP חיבורים
התחל את ה-Memaslap עם "--conn_sock=" או "-n" כדי להפעיל תכונה זו. ודא כי שלך
המערכת יכולה לבדוק פתיחת אלפי קבצים ויצירת אלפי שקעים. למרות זאת,
תכונה זו אינה בודקת חיבור מחדש אם שקעים מתנתקים.

לדוגמה:

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

הפקודה לעיל פירושה ש-memaslap מפעיל 8 שרשורים, לכל שרשור יש 16
במקביל, לכל מקביל יש 128 חיבורי שקע TCP, והמספר הכולל של
חיבורי שקע TCP הם 128 * 128 = 16384.

תומך בינרי פרוטוקול
התחל את ה-Memaslap עם אפשרויות "--binary" או "-B" כדי לאפשר תכונה זו. זה בודק את כל
תכונות לעיל מלבד UDP, מכיוון שה-memcached 1.3.3 האחרון אינו מיישם בינארי
פרוטוקול UDP.

לדוגמה:

--בינארי

מכיוון ש-memcached 1.3.3 אינו מיישם פרוטוקול UDP בינארי, memaslap לא בודק את UDP.
בנוסף, memcached 1.3.3 אינו בודק ריבוי גט. אם תציין "--division=50"
אפשרות, זה פשוט שולח 50 פקודות גט ביחד כ-"mulit-get" לשרת.

תְצוּרָה קובץ

סעיף זה מתאר את הפורמט של קובץ התצורה. כברירת מחדל כאשר לא
קובץ התצורה צוין memaslap קורא את ברירת המחדל שנמצאת ב ~/.memaslap.cnf.

להלן קובץ תצורה לדוגמה:

-------------------------------------------------- -------------------------
#תגובות צריכות להתחיל ב-'#'
#מַפְתֵחַ
#start_len end_len פרופורציה
#
טווח אורך #key מ-start_len ל-end_len
#start_len חייב להיות שווה ל-16 או גדול מ-XNUMX
#end_len חייב להיות שווה או קטן מ-250
#start_len חייב להיות שווה או גדול מ-end_len
#memaslap יפיק מפתחות בהתאם לטווח המפתחות
#פרופורציה: מציין מפתחות שנוצרו מחשבונות טווח אחד עבור הסכום הכולל
מפתחות שנוצרו
#
#example1: טווח מפתח 16~100 מהווה 80%
# טווח מפתח 101~200 מהווה 10%
# טווח מפתח 201~250 מהווה 10%
# סך הכל צריך להיות 1 (0.8+0.1+0.1 = 1)
#
# 16 100 0.8
# 101 200 0.1
# 201 249 0.1
#
#example2: כל המפתחות הם 128 בתים
#
# 128 128 1
מפתח
128 128 1
#ערך
#start_len end_len פרופורציה
#
#value טווח אורך מ-start_len ל-end_len
#start_len חייב להיות שווה ל-1 או גדול מ-XNUMX
#end_len חייב להיות שווה ל-1 מיליון או פחות
#start_len חייב להיות שווה או גדול מ-end_len
#memaslap יפיק ערכים בהתאם לטווח הערכים
#פרופורציה: מציין ערכים שנוצרו מחשבונות טווח אחד עבור
סך כל הערכים שנוצרו
#
#example1: טווח ערכים 1~1000 מהווה 80%
# טווח ערכים 1001~10000 מהווה 10%
# טווח ערכים 10001~100000 מהווה 10%
# סך הכל צריך להיות 1 (0.8+0.1+0.1 = 1)
#
# 1 1000 0.8
# 1001 10000 0.1
# 10001 100000 0.1
#
#example2: כל אורך הערכים הוא 128 בתים
#
# 128 128 1
ערך
2048 2048 1
#cmd
#cmd_type cmd_proportion
#
#currently memaslap רק בדיקות מקבלות ומגיבות פקודה.
#
#cmd_type
#סט 0
#קבל 1
#
#example: הגדרת הפקודה מהווה 50%
# קבל חשבונות פקודה עבור 50%
מספר סה"כ צריך להיות 1 (0.5+0.5 = 1)
#
# cmd
# 0 0.5
# 1 0.5
cmd
0 0.1
1.0 0.9

פורמט OF תפוקה

בהתחלה, Memaslap מציג מידע על תצורה באופן הבא:

שרתים: 127.0.0.1:11211

ספירת שרשורים: 1

במקביל: 16

זמן ריצה: 20 שניות

גודל חלונות: 10k

קבע פרופורציה: set_prop=0.10

קבל פרופורציה: get_prop=0.90

איפה
שרתים: "שרתים"
השרתים שבהם משתמשים Memaslap.

חוטים נחשבים
מספר החוטים ש-memaslap פועל איתם.

מקביליות
מספר המקבילות ש-memaslap פועל איתם.

זמן ריצה
כמה זמן להריץ ממסלפ.

גודל חלונות
גודל חלון המשימות של כל מקביל.

לקבוע פרופורציה
הפרופורציה של הפקודה הגדר.

לקבל פרופורציה
הפרופורציה של get command.

הפלט של סטטיסטיקה דינמית הוא בערך כך:

------------------------------------------------------ ------------------------------------------------------ -----------------------------
קבל סטטיסטיקה
סוג זמן/ים פעולות TPS(אופס/s) נטו (M/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
תקופה 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

הגדר סטטיסטיקה
סוג זמן/ים פעולות TPS(אופס/s) נטו (M/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
תקופה 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

סטטיסטיקה כוללת
סוג זמן/ים פעולות TPS(אופס/s) נטו (M/s) Get_miss Min(us) Max(us)
Avg(us) Std_dev Geo_dist
תקופה 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
------------------------------------------------------ ------------------------------------------------------ -----------------------------

איפה
קבל סטטיסטיקה
מידע סטטיסטי של get command

הגדר סטטיסטיקה
מידע סטטיסטי של פקודת סט

סטטיסטיקה כוללת
מידע סטטיסטי של פקודת get וגם של set

תְקוּפָה
תוצאה בתוך תקופה

גלוֹבָּלִי
תוצאות מצטברות

Ops
סה"כ פעולות

תב"ע
תפוקה, פעולות/שנייה

נֶטוֹ
קצב הרשת

קבל_פספס
כמה חפצים לא ניתן להשיג

דקות
זמן תגובה מינימלי

מקס
זמן התגובה המקסימלי

ממוצע:
זמן התגובה הממוצע

Std_dev
סטיית תקן של זמן תגובה

Geo_dist
התפלגות גיאומטרית המבוססת על פונקציה אקספוננציאלית טבעית

בסוף, memaslap יוציא משהו כמו זה:

------------------------------------------------------ ------------------------------------------------------ -----------------------------
קבל סטטיסטיקה (1257956 אירועים)
דקה: 26
מקסימום: 3791
ממוצע: 224
גיאוגרפי: 192.60
סטד: 116.23
ריחוק יומן2:
4: 0 10 84490 215345
8: 484890 459823 12543 824
12: 31

סטטיסטיקות (139782 אירועים)
דקה: 37
מקסימום: 3790
ממוצע: 253
גיאוגרפי: 224.84
סטד: 116.83
ריחוק יומן2:
4: 0 0 4200 16988
8: 50784 65574 2064 167
12: 5

סה"כ סטטיסטיקות (1397738 אירועים)
דקה: 26
מקסימום: 3791
ממוצע: 227
גיאוגרפי: 195.60
סטד: 116.60
ריחוק יומן2:
4: 0 10 88690 232333
8: 535674 525397 14607 991
12: 36

cmd_get: 1257969
cmd_set: 139785
get_misses: 0
verify_misses: 0
verify_failed: 0
expired_get: 0
unexpired_unget: 0
written_bytes: 242516030
read_bytes: 1003702556
object_bytes: 152086080
packet_disorder: 0
packet_drop: 0
udp_timeout: 0

זמן ריצה: 20.0 שניות הפעלה: 1397754 TPS: 69817 קצב נטו: 59.4M/s
------------------------------------------------------ ------------------------------------------------------ -----------------------------

איפה
קבל סטטיסטיקה
קבל סטטיסטיקות של זמן תגובה

הגדר סטטיסטיקה
הגדר סטטיסטיקה של זמן תגובה

סטטיסטיקה כוללת
גם לקבל וגם להגדיר סטטיסטיקה של זמן תגובה

דקות
זמן התגובה המצטבר והמינימלי

מקס
זמן התגובה המצטבר והמקסימלי

ממוצע
זמן התגובה המצטבר והממוצע

Std
סטיית תקן של זמן תגובה

Log2 Dist
התפלגות גיאומטרית מבוססת על לוגריתם 2

cmd_get
סך הכל ביצוע פקודות

cmd_set
סך כל הפקודות שנעשו

לקבל_החמצות
כמה אובייקטים לא ניתן לקבל מהשרת

verify_misses
כמה אובייקטים צריכים לאמת אבל לא יכולים להשיג אותם

לאמת_נכשל
כמה חפצים עם ערך מתעקש

expired_get
כמה חפצים פג תוקף אבל אנחנו מקבלים אותם

unexpired_unget
כמה חפצים לא פג תוקף אבל אנחנו לא יכולים להשיג אותם

כתובים_בייט
סך הכל בתים כתובים

read_bytes
סה"כ קריאה בתים

object_bytes
סך בתים של אובייקט

packet_disorder
כמה חבילות UDP הן הפרעות

packet_drop
כמה חבילות UDP אבדו

udp_timeout
כמה פעמים קורה פסק זמן של UDP

זמן ריצה
זמן ריצה כולל

Ops
סה"כ פעולות

תב"ע
תפוקה, פעולות/שנייה

שיעור_נטו
הקצב הממוצע של הרשת

אפשרויות

-ס, --שרתים=
רשום שרת אחד או יותר לחיבור. ספירת השרתים חייבת להיות קטנה מספירת השרשורים.
למשל: --servers=localhost:1234,localhost:11211

-T, --חוטים=
מספר השרשורים להפעלה, שווה יותר למספרי המעבד. ברירת מחדל 8.

-ג, --מקבילות=
מספר המקבילות לדמות עם עומס. ברירת מחדל 128.

-נ, --conn_sock=
מספר גרבי TCP בכל מקביל. ברירת מחדל 1.

-איקס, --execute_number=
מספר הפעולות (קבל והגדר) לביצוע עבור הבדיקה הנתונה. ברירת מחדל 1000000.

-ט, --זמן=
כמה זמן הבדיקה אמורה לרוץ, סיומת: s-שניות, m-דקות, h-hours, d-days, למשל:
--זמן=2 שעות.

-ו, --cfg_cmd=
טען את קובץ התצורה כדי לקבל רשימת תפוצה של פקודות, מפתח וערכים.

-וו, --win_size=
גודל חלון המשימות של כל מקביל, סיומת: K, M למשל: --win_size=10k. בְּרִירַת מֶחדָל
10 ק"ג.

-איקס, --fixed_size=
אורך קבוע של ערך.

-ב, --אמת=
השיעור של אימות התאריך, למשל: --verify=0.01

-ד, --חלוקה=
מספר המפתחות לריבוי קבל פעם אחת. ברירת מחדל 1, פירושה קבל יחיד.

-S, --stat_freq=
תדירות השלכת מידע סטטיסטי. סיומת: s-שניות, m-דקות, למשל:
--resp_freq=10s.

, --exp_verify=
השיעור של אובייקטים עם זמן תפוגה, למשל: --exp_verify=0.01. ברירת מחדל מספר
אובייקט עם זמן תפוגה

-או, --דרוס=
שיעור האובייקטים שצריך להחליף, למשל: --overwrite=0.01. ברירת מחדל אף פעם
להחליף אובייקט.

-R, --להתחבר מחדש
בדיקות חיבור מחדש, כאשר החיבור ייסגר הוא יתחבר מחדש.

-U, --udp
בדיקות UDP, ברירת המחדל של memaslap משתמש ב-TCP, יציאת TCP ויציאת UDP של השרת חייבות להיות זהות.

-a, --פייסבוק
בין אם היא מאפשרת תכונת בדיקת פייסבוק, מוגדרת עם TCP ו-multi-get עם UDP.

-B, --בינארי
האם זה מאפשר פרוטוקול בינארי. ברירת מחדל עם פרוטוקול ASCII.

-פ, --tps=
תפוקה צפויה, סיומת: K, למשל: --tps=10k.

-פ, --rep_write=
השרתים ה-n הראשונים יכולים לכתוב נתונים, למשל: --rep_write=2.

-b, --מִלוּלִי
האם הוא מוציא מידע מפורט כאשר האימות נכשל.

-h, - עזרה
הצג הודעה זו ולאחר מכן צא.

-V, --גִרְסָה
הצג את גרסת היישום ולאחר מכן צא.

דוגמאות

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

עמוד הבית

למידע נוסף אנא בדוק: http://libmemcached.org/

מחברים

Mingqiang Zhuang[מוגן בדוא"ל]> (Schooner Technolgy) בריאן אקר, <-
[מוגן בדוא"ל]>

השתמש ב-memcaslap באינטרנט באמצעות שירותי onworks.net