כדי להעריך את הביצועים של Google Cloud Hyperdisk, השתמשו ב-Flexible I/O tester (FIO) במקום בכלים אחרים להערכת ביצועי הדיסק, כמו dd.
כברירת מחדל, ב-dd נעשה שימוש בעומק תור קלט/פלט נמוך מאוד, ולכן קשה לוודא שהבנצ'מרק יוצר מספר מספיק של בייטים ופעולות קלט/פלט כדי לבדוק במדויק את ביצועי הדיסק.
בנוסף, מכשירים מיוחדים שמשמשים עם dd הם בדרך כלל איטיים מאוד ולא משקפים במדויק את ביצועי הדיסק. באופן כללי, אל תשתמשו בהתקנים מיוחדים כמו /dev/urandom, /dev/random ו-/dev/zero בבדיקות השוואתיות של ביצועי Hyperdisk.
כדי למדוד את ה-IOPS ואת קצב הנתונים של דיסק שנמצא בשימוש במכונה פועלת, צריך להשוות את מערכת הקבצים עם ההגדרות הרצויות. האפשרות הזו מאפשרת לבדוק עומס עבודה מציאותי בלי לאבד את התוכן של הדיסק הקיים. חשוב לזכור שכאשר מבצעים השוואה של מערכת הקבצים בדיסק קיים, יש הרבה גורמים ספציפיים לסביבת הפיתוח שיכולים להשפיע על תוצאות ההשוואה, וייתכן שלא תגיעו למגבלות הביצועים של הדיסק.
כדי למדוד את הביצועים הגולמיים של Hyperdisk, צריך להשוות ישירות את התקן הבלוקים. אתם יכולים להשתמש באפשרות הזו כדי להשוות בין הביצועים של הדיסק הגולמי לבין מגבלות הביצועים של Hyperdisk.
הפקודות הבאות פועלות במערכות ההפעלה Debian או Ubuntu עם מנהל החבילות apt.
בדיקת ביצועים של IOPS וקצב העברת נתונים של דיסק במכונה פועלת
אם אתם רוצים למדוד את ה-IOPS ואת קצב הנתונים של עומס עבודה מציאותי בדיסק פעיל במכונה וירטואלית פועלת, בלי לאבד את תוכן הדיסק, תוכלו להריץ את הבדיקה בספרייה חדשה במערכת הקבצים הקיימת.
הכנה לבדיקה
יחסי תלות של התקנות:
sudo apt update sudo apt install -y fioאם נפח ה-Hyperdisk עדיין לא פורמט, מפרמטים ומחברים את הדיסק.
בטרמינל, מציגים את רשימת הדיסקים שמחוברים ל-VM ומוצאים את הדיסק שרוצים לבדוק.
sudo lsblkהפלט של הפקודה הקודמת אמור להיראות כך:
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT nvme0n1 259:0 0 10G 0 disk ├─nvme0n1p1 259:1 0 9.9G 0 part / ├─nvme0n1p14 259:2 0 4M 0 part └─nvme0n1p15 259:3 0 106M 0 part /boot/efi nvme0n2 259:4 0 3.4T 0 disk
בדוגמה הזו אנחנו בודקים נפח של 3,500GiB ב-Hyperdisk Extreme עם שם המכשיר
nvme0n2.יוצרים ספרייה חדשה,
fiotest, בדיסק. בדוגמה הזו, הדיסק מותקן ב-/mnt/disks/mnt_dir:TEST_DIR=/mnt/disks/mnt_dir/fiotest sudo mkdir -p $TEST_DIRאם ה-VM משתמש בממשק הדיסק NVMe לחיבור של אמצעי האחסון ב-Hyperdisk (אם שם הדיסק הגולמי מתחיל בתחילית
nvme), מבצעים את השלבים הבאים כדי לקבל את מספר צומתי ה-NUMA שזמינים ל-VM.אסטרטגיית ההשוואה של דיסקי NVMe שונה במכונות וירטואליות עם צומת NUMA אחד ובמכונות וירטואליות עם יותר מצומת NUMA אחד. כשבודקים את הביצועים של Hyperdisk באמצעות ממשק הדיסק NVMe, מוקצים רק 256 גדלים של תור NVMe לכל תור. בגלל הגודל המוגבל של התורים ב-NVMe והתחרות הפוטנציאלית מצד דיסקים אחרים שמחוברים לאותו VM, בדיקות ההשוואה האלה משתמשות בשני תורים של דיסקי NVMe כדי לשמור על גודל תור מצטבר שיכול לטפל בעומק קלט/פלט של 256.
קבלת מספר צומתי ה-NUMA.
lscpu | grep -i 'numa node(s)' | awk '{print $NF}'אם למכונה הווירטואלית יש רק צומת NUMA אחד, צריך לקבל את מיפוי התור של CPU-to-NVMe. תצטרכו להשתמש במידע הזה בהמשך בשביל הפרמטר
--cpus-allowed.QUEUE_1_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 1p | tr -d " \t") QUEUE_2_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 2p | tr -d " \t")
בדיקת התפוקה בכתיבה
כדי לבדוק את קצב העברת הנתונים בכתיבה, מבצעים כתיבה רציפה עם כמה זרמים מקבילים (16+), באמצעות גודל בלוק קלט/פלט של 1MB ועומק קלט/פלט של 64 לפחות.
אם בנפח Hyperdisk משתמשים בממשק SCSI:
sudo fio --directory=$TEST_DIR \ --numjobs=16 --size=10G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --name=write_throughput
אם בנפח Hyperdisk משתמשים בממשק NVMe:
אם למכונה הווירטואלית יש רק צומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --directory=$TEST_DIR --numjobs=8 \ --size=10G --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --cpus_allowed_policy=split \ --group_reporting \ --name=write_throughput --cpus_allowed=$QUEUE_1_CPUS \ --name=write_throughput_2 --cpus_allowed=$QUEUE_2_CPUS
אם למכונה הווירטואלית יש יותר מצומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --directory=$TEST_DIR --numjobs=8 \ --size=10G --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --group_reporting \ --name=write_throughput --numa_cpu_nodes=0 \ --name=write_throughput_2 --numa_cpu_nodes=1
IOPS של כתיבת בדיקה
בודקים את IOPS של הכתיבה על ידי ביצוע כתיבה אקראית, באמצעות גודל בלוק קלט/פלט של 4KB ועומק קלט/פלט של 256 לפחות.
אם נפח ה-Hyperdisk מחובר באמצעות ממשק SCSI:
sudo fio --directory=$TEST_DIR \ --numjobs=16 --size=10G -time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --name=write_iops
אם בנפח Hyperdisk משתמשים בממשק NVMe:
אם למכונה הווירטואלית יש רק צומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --directory=$TEST_DIR --numjobs=8 \ --size=10G --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --cpus_allowed_policy=split \ --group_reporting \ --name=write_iops --cpus_allowed=$QUEUE_1_CPUS \ --name=write_iops_2 --cpus_allowed=$QUEUE_2_CPUS
אם למכונה הווירטואלית יש יותר מצומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --group_reporting \ --name=write_iops --numa_cpu_nodes=0 \ --name=write_iops_2 --numa_cpu_nodes=1
בדיקת קצב העברת הנתונים בקריאה
כדי לבדוק את קצב הקריאה, מבצעים קריאות רציפות עם כמה זרמים מקבילים (16+), באמצעות גודל בלוק קלט/פלט של 1MB ועומק קלט/פלט של 64 לפחות.
אם בנפח Hyperdisk משתמשים בממשק SCSI:
sudo fio --directory=$TEST_DIR \ --numjobs=16 --size=10G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --name=read_throughput
אם בנפח Hyperdisk משתמשים בממשק NVMe:
אם למכונה הווירטואלית יש רק צומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --cpus_allowed_policy=split \ --group_reporting \ --name=read_throughput --cpus_allowed=$QUEUE_1_CPUS \ --name=read_throughput_2 --cpus_allowed=$QUEUE_2_CPUS
אם למכונה הווירטואלית יש יותר מצומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --group_reporting \ --name=read_throughput --numa_cpu_nodes=0 \ --name=read_throughput_2 --numa_cpu_nodes=1
IOPS של קריאת בדיקה
בודקים את IOPS בקריאה על ידי ביצוע קריאות אקראיות, באמצעות גודל בלוק קלט/פלט של 4KB ועומק קלט/פלט של לפחות 256.
אם בנפח Hyperdisk משתמשים בממשק SCSI:
sudo fio --directory=$TEST_DIR \ --numjobs=16 --size=10G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --name=read_iops
אם בנפח Hyperdisk משתמשים בממשק NVMe:
אם למכונה הווירטואלית יש רק צומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --cpus_allowed_policy=split \ --group_reporting \ --name=read_iops --cpus_allowed=$QUEUE_1_CPUS \ --name=read_iops_2 --cpus_allowed=$QUEUE_2_CPUS
אם למכונה הווירטואלית יש יותר מצומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --group_reporting \ --name=read_iops --numa_cpu_nodes=0 \ --name=read_iops_2 --numa_cpu_nodes=1
הסרת המשאבים
מסירים את ספריות הבדיקה.
sudo rm $TEST_DIR/write* $TEST_DIR/read*
השוואה בין IOPS לבין קצב העברת הנתונים של Hyperdisk Extreme במכונות וירטואליות מסוג C3
Google Cloud Hyperdisk Extreme מציע ביצועים טובים יותר במכונות וירטואליות מסוג C3 עם 176 מעבדי vCPU. כדי להגיע למגבלות הביצועים הגבוהות יותר, צריך לצרף כמה אמצעי אחסון של Hyperdisk Extreme למכונה הווירטואלית.
כדי למדוד את מספר פעולות הקלט/פלט לשנייה (IOPS) או את קצב הנתונים של עומס עבודה מציאותי בדיסקים פעילים ב-VM מסוג C3 שפועל, בלי לאבד את התוכן של דיסקי הנתונים הקיימים, צריך להריץ את בדיקת הביצועים מול ספרייה חדשה במערכת הקבצים הקיימת ולצרף ל-VM נפחים חדשים של Hyperdisk Extreme בשביל משימות בדיקת הביצועים.
בדיסקים שמחוברים לממשק NVMe, מומלץ לפזר את עומס העבודה של הקלט/פלט בין כל התורים של NVMe שזמינים למכונה הווירטואלית. כך אפשר למקסם את הביצועים של נפח ה-Hyperdisk. במכונות וירטואליות מסוג C3 עם 176 יחידות vCPU, יש ארבעה צומתי NUMA שממופים ביחס של 1:1 לארבעה תורי NVMe. המיפוי הזה נלקח בחשבון בבדיקות ההשוואה לשוק בקטע הזה.
הכנה לבדיקה
מוסיפים דיסקים חדשים של Hyperdisk Extreme למכונה הווירטואלית, ונעזרים במגבלות הביצועים של Hyperdisk כדי להגדיר את הדיסק בהתאם לביצועים הרצויים.
מתחברים למכונה:
יחסי תלות של התקנות:
sudo apt update sudo apt install -y fioמציגים את רשימת הדיסקים שמחוברים ל-VM ומוצאים את הדיסק שרוצים לבדוק.
sudo lsblkהפלט של הפקודה הקודמת אמור להיראות כך:
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT nvme0n1 259:0 0 10G 0 disk ├─nvme0n1p1 259:1 0 9.9G 0 part / ├─nvme0n1p14 259:2 0 4M 0 part └─nvme0n1p15 259:3 0 106M 0 part /boot/efi nvme0n2 259:4 0 2.5T 0 disk nvme0n3 259:5 0 2.5T 0 disk nvme0n4 259:6 0 2.5T 0 disk
בדוגמה הזו אנחנו בודקים את הביצועים של Google Cloud Hyperdisk בשלושה נפחים של 2, 500GiB ב-Hyperdisk Extreme,עם מכשירים בשמות
nvme0n2,nvme0n3ו-nvme0n4.
בדיקת ביצועים של קצב העברת הנתונים של Hyperdisk Extreme ב-C3
בקטע הזה מוסבר איך לבצע השוואה לשוק של קצב העברת הנתונים בקריאה ובכתיבה של דיסקים מסוג Hyperdisk Extreme.
הכנה לבדיקה
לפני שמתחילים להשוות את הביצועים של דיסקים מסוג Hyperdisk Extreme שמחוברים למכונה וירטואלית מסוג C3 עם 176 מעבדי vCPU, צריך לבצע את השלבים הבאים.
יוצרים ספרייה חדשה,
fiotest, במערכת ההפעלה. בדוגמה הזו, תיקיית השורש היא/mnt/disks/mnt_dir:TEST_DIR=/mnt/disks/mnt_dir/fiotest sudo mkdir -p $TEST_DIRכדי להגיע לרמות הביצועים הגבוהות ביותר, המכונה הווירטואלית צריכה יותר מדיסק אחד. לכן, כדי לפשט את התהליך, כדאי להפעיל RAID 0 בכל נפחי ה-Hyperdisk המצורפים. כך קל יותר לפזר את הנתונים באופן שווה בין כמה אמצעי אחסון ב-Hyperdisk.
בדוגמה הזו, RAID 0 מבוצע בשלושה נפחי Hyperdisk Extreme שמחוברים למכונה הווירטואלית C3.
sudo mdadm --create /dev/md0 --level=0 --raid-devices=3 /dev/nvme0n2 /dev/nvme0n3 /dev/nvme0n4
מפרמטים ומחברים את אמצעי האחסון
/dev/md0של ה-RAID.
בדיקת התפוקה בכתיבה
כדי לבדוק את קצב העברת הנתונים בכתיבה, מבצעים כתיבה רציפה עם כמה זרמים מקבילים (לפחות 16), באמצעות גודל בלוק קלט/פלט של 1MiB ועומק קלט/פלט כולל של לפחות 32 לכל תור NVMe.
# Running this command causes data loss on the targeted file on the device. # We strongly recommend using a throwaway disk. sudo fio --name=global --group_reporting=1 --filesize=1024G \ --filename=$TEST_DIR/fiotestfile --numjobs=4 --size=64G \ --offset_increment=64G --time_based --runtime=5m \ --ramp_time=10s --ioengine=libaio --direct=1 --verify=0 \ --bs=1M --iodepth=8 --rw=write \ --name=write_throughput --numa_cpu_nodes=0 \ --name=write_throughput_1 --numa_cpu_nodes=1 \ --name=write_throughput_2 --numa_cpu_nodes=2 \ --name=write_throughput_3 --numa_cpu_nodes=3
בדיקת קצב העברת הנתונים בקריאה
כדי לבדוק את קצב הקריאה, מבצעים קריאות רציפות עם כמה זרמים מקבילים (לפחות 16), באמצעות גודל בלוק קלט/פלט של 1MiB ועומק קלט/פלט כולל של לפחות 32 לכל תור NVMe.
sudo fio --name=global --group_reporting=1 --filesize=1024G \ --filename=$TEST_DIR/fiotestfile --numjobs=4 --size=64G \ --offset_increment=64G --time_based --runtime=5m \ --ramp_time=10s --ioengine=libaio --direct=1 \ --verify=0 --bs=1M --iodepth=8 --rw=read \ --name=read_throughput --numa_cpu_nodes=0 \ --name=read_throughput_1 --numa_cpu_nodes=1 \ --name=read_throughput_2 --numa_cpu_nodes=2 \ --name=read_throughput_3 --numa_cpu_nodes=3
בדיקת ביצועים של IOPS ב-Hyperdisk Extreme ב-C3
כדי להשוות את הביצועים של פעולות קלט/פלט לשנייה (IOPS), מומלץ לבצע פעולות קלט/פלט קטנות במקביל ישירות לדיסקים גולמיים או מהם (ללא RAID).
IOPS של כתיבת בדיקה
כדי לבדוק את IOPS של הכתיבה, מבצעים כתיבה אקראית באמצעות גודל בלוק קלט/פלט של 4KiB ועומק קלט/פלט של לפחות 256, תוך שימוש ב-2 תורים לפחות של NVMe.
# Running this command causes data loss on the targeted device. # We strongly recommend using a throwaway disk. sudo fio --name=global --group_reporting=1 \ --directory=/ --bs=4K --direct=1 \ --filesize=512G --iodepth=256 \ --iodepth_batch_complete_max=256 --iodepth_batch_submit=256 \ --ioengine=libaio --numjobs=5 --ramp_time=10s \ --randrepeat=0 --runtime=5m --rw=randwrite \ --time_based=1 --verify=0 \ --name=write_iops_test --filename=/dev/nvme0n2 --numa_cpu_nodes=0 \ --name=write_iops_test_1 --filename=/dev/nvme0n3 --numa_cpu_nodes=1 \ --name=write_iops_test_2 --filename=/dev/nvme0n4 --numa_cpu_nodes=2
IOPS של קריאת בדיקה
בודקים את IOPS של הקריאה על ידי ביצוע קריאות אקראיות, באמצעות גודל בלוק קלט/פלט של 4 KiB ועומק קלט/פלט של לפחות 256, תוך שימוש ב-2 תורים לפחות של NVMe.
sudo fio --name=global --group_reporting=1 --directory=/ \ --bs=4K --direct=1 --filesize=512G --iodepth=256 \ --iodepth_batch_complete_max=256 --iodepth_batch_submit=256 \ --ioengine=libaio --numjobs=5 --ramp_time=10s \ --randrepeat=0 --runtime=5m --rw=randread \ --time_based=1 --verify=0 \ --name=read_iops_test --filename=/dev/nvme0n2 --numa_cpu_nodes=0 \ --name=read_iops_test_1 --filename=/dev/nvme0n3 --numa_cpu_nodes=1 \ --name=read_iops_test_2 --filename=/dev/nvme0n4 --numa_cpu_nodes=2
השוואת זמן האחזור של Hyperdisk Extreme ב-C3
בזמן בדיקת זמן האחזור של הקלט/פלט, המכונה הווירטואלית לא יכולה להגיע לרוחב הפס המקסימלי או ל-IOPS. אם כן, זמן האחזור שנצפה לא ישקף את זמן האחזור בפועל של קלט/פלט ב-Hyperdisk.
לדוגמה, אם ה-VM מגיע למגבלת ה-IOPS בעומק קלט/פלט של 30, והפקודה fio הכפילה את העומק, ה-IOPS הכולל נשאר זהה וזמן האחזור המדווח של הקלט/פלט מוכפל.
כדי לקבל זמני אחזור מציאותיים של קלט/פלט, מספיק לטרגט ישירות התקן דיסק גולמי אחד.
בדיקת זמן האחזור של הכתיבה
כדי לבדוק את זמן האחזור של הכתיבה, מבצעים כתיבה אקראית באמצעות גודל בלוק קלט/פלט של 4 KiB ועומק קלט/פלט של 4.
# Running this command causes data loss on the targeted device. # We strongly recommend using a throwaway disk. sudo fio --filename=/dev/nvme0n2 \ --filesize=512G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randwrite \ --iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \ --name=write_latency
בדיקת זמן האחזור של הקריאה
כדי לבדוק את זמן האחזור של הקריאה, מבצעים קריאות אקראיות באמצעות גודל בלוק קלט/פלט של 4 KiB ועומק קלט/פלט של 4.
sudo fio --filename=/dev/nvme0n2 \ --filesize=512G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randread \ --iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \ --name=read_latency
הסרת המשאבים
מסירים את קובצי הבדיקה.
sudo rm -rf $TEST_DIR/*מבטלים את הטעינה של אמצעי האחסון של ה-RAID ומפסיקים אותו.
sudo umount /dev/md0 sudo mdadm --stop /dev/md0מנתקים ומוחקים את אמצעי האחסון המצורפים של Hyperdisk. אפשר לעיין בפקודות
gcloud compute instances detach-diskו-gcloud compute disks delete.
השוואה בין הביצועים של Hyperdisk ללא שינויים
אם אתם רוצים למדוד את הביצועים של נפחי Hyperdisk בלבד, מחוץ לסביבת הפיתוח, אתם יכולים לבדוק את ביצועי הקריאה והכתיבה של מכשיר לאחסון ולאחזור בלוקים בדיסק ובמכונה וירטואלית חד-פעמיים.
הפקודות הבאות מבוססות על ההנחה שנפח של 3,500GiB ב-Hyperdisk Extreme מחובר למכונה הווירטואלית. גודל הדיסק הזה נדרש כדי להגיע למגבלות הקיבולת של מכונה וירטואלית עם 32 vCPU. אם גודל המכשיר שונה, צריך לשנות את הערך של הארגומנט --filesize בפקודות הבאות.
למידע נוסף על מגבלות הביצועים של סוגי מכונות וירטואליות, ראו תמיכה בסוגי מכונות.
הכנה לבדיקה
יחסי תלות של התקנות:
sudo apt-get update sudo apt-get install -y fioמשיגים את הנתיב לדיסק הגולמי. שומרים את הנתיב במשתנה. בדוגמה הבאה, הנתיב לדיסק הגולמי הוא
/dev/nvme0n2:TEST_DIR=/dev/nvme0n2ממלאים את הדיסק בנתונים שאינם אפס. לפעולות קריאה מבלוקים ריקים ב-Hyperdisk יש פרופיל זמן אחזור שונה מזה של בלוקים שמכילים נתונים. מומלץ למלא את הדיסק לפני שמריצים בדיקות השוואה של זמן האחזור בקריאה.
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --name=fill_disk \ --filename=$TEST_DIR --filesize=2500G \ --ioengine=libaio --direct=1 --verify=0 --randrepeat=0 \ --bs=128K --iodepth=64 --rw=randwrite \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64
אם ה-VM משתמש בממשק הדיסק NVMe לחיבור ה-Hyperdisk (אם שם הדיסק הגולמי מתחיל בתחילית
nvme), בצעו את השלבים הבאים כדי לקבל את מספר צומתי ה-NUMA שזמינים ל-VM.אסטרטגיית ההשוואה של דיסקי NVMe שונה במכונות וירטואליות עם צומת NUMA אחד ובמכונות וירטואליות עם יותר מצומת NUMA אחד. כשבודקים את הביצועים של Hyperdisk באמצעות ממשק הדיסק NVMe, מוקצים רק 256 גדלים של תור NVMe לכל תור. בגלל הגודל המוגבל של התורים ב-NVMe והתחרות הפוטנציאלית על משאבים עם דיסקים אחרים שמחוברים לאותו VM, בדיקות ההשוואה האלה משתמשות בשני תורים של דיסקים ב-NVMe כדי לשמור על גודל תור מצטבר שיכול להתמודד עם iodepth של 256.
קבלת מספר צומתי ה-NUMA.
lscpu | grep -i 'numa node(s)' | awk '{print $NF}'אם למכונה הווירטואלית יש רק צומת NUMA אחד, צריך לקבל את מיפוי התור של CPU-to-NVMe. תצטרכו להשתמש במידע הזה בהמשך בשביל הפרמטר
--cpus-allowed.QUEUE_1_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 1p | tr -d " \t") QUEUE_2_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 2p | tr -d " \t")
בדיקת התפוקה בכתיבה
כדי לבדוק את קצב העברת הנתונים בכתיבה, מבצעים כתיבה רציפה עם כמה זרמים מקבילים (16+), באמצעות 1MB כגודל הקלט/פלט ועם עומק קלט/פלט של 64 או יותר.
אם ה-Hyperdisk מחובר באמצעות ממשק SCSI:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR \ --numjobs=16 --size=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --offset_increment=20G \ --name=write_throughput
אם בנפח Hyperdisk משתמשים בממשק NVMe:
אם למכונה הווירטואלית יש רק צומת NUMA אחד, משתמשים בפקודה הבאה:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --cpus_allowed_policy=split \ --offset_increment=20G --group_reporting \ --name=write_throughput --cpus_allowed=$QUEUE_1_CPUS \ --name=write_throughput_2 --cpus_allowed=$QUEUE_2_CPUS
אם למכונה הווירטואלית יש יותר מצומת NUMA אחד, משתמשים בפקודה הבאה:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --offset_increment=20G --group_reporting \ --name=write_throughput --numa_cpu_nodes=0 \ --name=write_throughput_2 --numa_cpu_nodes=1
IOPS של כתיבת בדיקה
כדי להשיג את מספר פעולות הקלט/פלט לשנייה המקסימלי של Hyperdisk, צריך לשמור על תור קלט/פלט עמוק. לדוגמה, אם זמן האחזור של הכתיבה הוא אלפית השנייה, המכונה הווירטואלית יכולה להגיע לכל היותר ל-1,000 IOPS לכל פעולת קלט/פלט בתהליך. כדי להגיע ל-15,000 IOPS בכתיבה, המכונה הווירטואלית צריכה לשמור על לפחות 15 פעולות קלט/פלט בתהליך. אם הדיסק וה-VM יכולים להגיע ל-30,000 פעולות כתיבה של קלט/פלט לשנייה, מספר פעולות הקלט/פלט שמתבצעות בו-זמנית צריך להיות לפחות 30. אם גודל הקלט/פלט גדול מ-4KB, יכול להיות שהמכונה הווירטואלית תגיע למגבלת רוחב הפס לפני שתגיע למגבלת ה-IOPS.
בודקים את IOPS של הכתיבה על ידי ביצוע כתיבה אקראית, באמצעות גודל בלוק קלט/פלט של 4KB ועומק קלט/פלט של 256 לפחות.
אם נפח ה-Hyperdisk Extreme מחובר באמצעות ממשק SCSI:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR \ --numjobs=16 --size=500G -time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --name=write_iops
אם נפח ה-Hyperdisk Extreme מחובר באמצעות ממשק NVMe:
אם למכונה הווירטואלית יש רק צומת NUMA אחד, משתמשים בפקודה הבאה:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --cpus_allowed_policy=split \ --group_reporting \ --name=write_write_iops --cpus_allowed=$QUEUE_1_CPUS \ --name=write_write_iops_2 --cpus_allowed=$QUEUE_2_CPUS
אם למכונה הווירטואלית יש יותר מצומת NUMA אחד, משתמשים בפקודה הבאה:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --group_reporting \ --name=write_iops --numa_cpu_nodes=0 \ --name=write_iops_2 --numa_cpu_nodes=1
בדיקת זמן האחזור של הכתיבה
בזמן בדיקת זמן האחזור של הקלט/פלט, ה-VM לא יכול להגיע לרוחב הפס המקסימלי או ל-IOPS, אחרת זמן האחזור שנצפה לא ישקף את זמן האחזור בפועל של הקלט/פלט של Hyperdisk. לדוגמה, אם מגיעים למגבלת ה-IOPS בעומק קלט/פלט של 30, והפקודה fio מכפילה את העומק, ה-IOPS הכולל נשאר ללא שינוי וזמן האחזור המדווח של הקלט/פלט מוכפל.
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR \ --filesize=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randwrite \ --iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \ --name=write_latency
בדיקת רוחב הפס של הקריאה
כדי לבדוק את רוחב הפס של הקריאה, מבצעים קריאות סדרתיות עם כמה סטרימינג מקבילים (16+), באמצעות גודל קלט/פלט של 1MB ועומק קלט/פלט של לפחות 64.
אם נפח Hyperdisk Extreme מחובר באמצעות ממשק SCSI:
sudo fio --filename=$TEST_DIR \ --numjobs=16 --size=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --offset_increment=20G --name=read_bandwidth
אם נפח ה-Hyperdisk Extreme מחובר באמצעות ממשק NVMe:
אם למכונה הווירטואלית יש רק צומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --cpus_allowed_policy=split \ --offset_increment=20G --group_reporting \ --name=read_bandwidth --cpus_allowed=$QUEUE_1_CPUS \ --name=read_bandwidth_2 --cpus_allowed=$QUEUE_2_CPUS
אם למכונה הווירטואלית יש יותר מצומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --offset_increment=20G --group_reporting \ --name=read_bandwidth --numa_cpu_nodes=0 \ --name=read_bandwidth_2 --numa_cpu_nodes=1
IOPS של קריאת בדיקה
כדי להגיע למספר המקסימלי של IOPS ב-Hyperdisk, צריך לשמור על תור עמוק של פעולות קלט/פלט.
לדוגמה, אם גודל הקלט/פלט גדול מ-4KB, יכול להיות שהמכונה הווירטואלית תגיע למגבלת רוחב הפס לפני שתגיע למגבלת ה-IOPS. כדי להגיע למספר המקסימלי של IOPS בקריאה שזמינות לסוג מכונה, צריך לציין --iodepth=256 לבדיקה הזו.
אם נפח Hyperdisk Extreme מחובר באמצעות ממשק SCSI:
sudo fio --filename=$TEST_DIR \ --numjobs=16 --size=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --name=read_iops
אם נפח ה-Hyperdisk Extreme מחובר באמצעות ממשק NVMe:
אם למכונה הווירטואלית יש רק צומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --cpus_allowed_policy=split \ --group_reporting \ --name=read_iops --cpus_allowed=$QUEUE_1_CPUS \ --name=read_iops_2 --cpus_allowed=$QUEUE_2_CPUS
אם למכונה הווירטואלית יש יותר מצומת NUMA אחד, משתמשים בפקודה הבאה:
sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --group_reporting \ --name=read_iops --numa_cpu_nodes=0 \ --name=read_iops_2 --numa_cpu_nodes=1
בדיקת זמן האחזור של הקריאה
חשוב למלא את הדיסק בנתונים כדי לקבל מדידת זמן אחזור מציאותית. חשוב שה-VM לא יגיע למגבלות ה-IOPS או קצב הנתונים במהלך הבדיקה, כי אחרי שנפח ה-Hyperdisk מגיע למגבלת הרוויה שלו, הוא דוחה פעולות קלט/פלט נכנסות. הדחייה הזו באה לידי ביטוי כעלייה מלאכותית בזמן האחזור של הקלט/פלט.
sudo fio --filename=$TEST_DIR \ --filesize=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randread \ --iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \ --name=read_latency
הסרת המשאבים
אם השתמשתם בדיסק ובמכונה וירטואלית חד-פעמיים, כמו שהמלצנו, אחרי שתסיימו את בדיקות ההשוואה תוכלו:
- מנתקים ומוחקים את הדיסק.
- מוחקים את המכונה הווירטואלית.