כדי להשוות את הביצועים של 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) וקצב העברת הנתונים (throughput) של דיסק במכונה פעילה
אם רוצים למדוד את ה-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
בדוגמה הזו, אנחנו בודקים נפח אחסון של Hyperdisk Extreme בגודל 3,500GiB עם שם המכשיר
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 ל-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 ומעלה), באמצעות גודל בלוק של קלט/פלט של 1 MB ועומק קלט/פלט של 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:
אם למכונת ה-VM יש רק צומת 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
אם למכונת ה-VM יש יותר מצומת 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 של כתיבה
כדי לבדוק את קצב הקלט/פלט של פעולות כתיבה, מבצעים פעולות כתיבה אקראיות באמצעות גודל בלוק קלט/פלט של 4 KB ועומק קלט/פלט של 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:
אם למכונת ה-VM יש רק צומת 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
אם למכונת ה-VM יש יותר מצומת 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 ומעלה), באמצעות גודל בלוק של קלט/פלט של 1 MB ועומק קלט/פלט של 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:
אם למכונת ה-VM יש רק צומת 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
אם למכונת ה-VM יש יותר מצומת 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
כדי לבדוק את קצב הקלט/פלט של פעולות קריאה, מבצעים קריאות אקראיות, באמצעות גודל בלוק קלט/פלט של 4 KB ועומק קלט/פלט של לפחות 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:
אם למכונת ה-VM יש רק צומת 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
אם למכונת ה-VM יש יותר מצומת 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 ושל קצב העברת נתונים (throughput) ב-Hyperdisk Extreme במכונות וירטואליות מסוג C3
Google Cloud Hyperdisk Extreme מציע ביצועים טובים יותר במכונות וירטואליות מסוג C3 עם 176 מעבדים וירטואליים. כדי להגיע למגבלות הביצועים הגבוהות יותר, צריך לצרף כמה נפחי אחסון של Hyperdisk Extreme למכונה הווירטואלית.
כדי למדוד את קצב הקלט/פלט (IOPS) או את קצב העברת הנתונים (throughput) עבור עומס עבודה ריאלי בדיסקים פעילים במכונה וירטואלית (VM) מסוג C3 שפועלת, בלי לאבד את התוכן של דיסקי הנתונים הקיימים, צריך לבצע השוואה לביצועים של ספרייה חדשה במערכת הקבצים הקיימת ולצרף נפחי אחסון חדשים מסוג Hyperdisk Extreme למכונה הווירטואלית לצורך משימות ההשוואה לביצועים.
לדיסקים שמצורפים באמצעות ממשק NVMe, מומלץ לפזר את עומס העבודה של קלט/פלט על פני כל תורי ה-NVMe שזמינים למכונה הווירטואלית. כך אפשר למקסם את הביצועים של נפח ה-Hyperdisk. במכונות וירטואליות מסוג C3 עם 176 vCPU, יש ארבעה צמתי NUMA שממופים אחד לאחד לארבעה תורי 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 בשלושה נפחי Hyperdisk Extreme של 2,500 GiB עם מכשירים בשמות
nvme0n2,nvme0n3ו-nvme0n4.
ביצועי העברת הנתונים של Hyperdisk Extreme ב-C3
בקטע הזה מוסבר איך להשוות את קצב העברת הנתונים לקריאה ולכתיבה בדיסקים של Hyperdisk Extreme.
הכנה לבדיקה
לפני שמתחילים בהשוואת הביצועים של דיסקים מסוג Hyperdisk Extreme שמצורפים למכונה וירטואלית מסוג C3 עם 176 מעבדים וירטואליים, צריך לבצע את השלבים הבאים.
יוצרים מדריך חדש,
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
מפרמטים ומפעילים את נפח ה-RAID
/dev/md0.
בדיקת קצב העברת הנתונים לכתיבה
בודקים את קצב העברת הנתונים לכתיבה על ידי ביצוע כתיבות רציפות עם כמה זרמים מקבילים (לפחות 16), באמצעות גודל בלוק של קלט/פלט של 1 MiB ועומק כולל של קלט/פלט של לפחות 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), באמצעות גודל בלוק קלט/פלט של 1 MiB ועומק כולל של קלט/פלט של לפחות 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 של פעולות כתיבה, מבצעים פעולות כתיבה אקראיות באמצעות גודל בלוק של קלט/פלט של 4 KiB ועומק קלט/פלט של 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/*מבטלים את ה-unmount ומפסיקים את נפח ה-RAID.
sudo umount /dev/md0 sudo mdadm --stop /dev/md0מנתקים ומוחקים את נפחי ה-Hyperdisk המצורפים. אפשר לעיין בפקודות
gcloud compute instances detach-diskו-gcloud compute disks delete.
השוואת ביצועים של Hyperdisk גולמי
אם רוצים למדוד את הביצועים של נפחי Hyperdisk בלבד, מחוץ לסביבת הפיתוח, אפשר לבדוק את ביצועי הקריאה והכתיבה של מכשיר בלוקים בדיסק ובמכונה וירטואלית זמניים.
הפקודות הבאות מניחות שנפח Hyperdisk Extreme של 3,500 GiB מצורף למכונה הווירטואלית. גודל הדיסק הזה נדרש כדי להשיג את מגבלות התפוקה של מכונת ה-VM עם 32 ליבות וירטואליות. אם גודל המכשיר שונה, צריך לשנות את הערך של הארגומנט --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
אם המכונה הווירטואלית משתמשת בממשק הדיסק NVMe לצירוף Hyperdisk (אם שם הדיסק הגולמי מתחיל ב-
nvme), צריך לבצע את השלבים הבאים כדי לקבל את מספר צמתי ה-NUMA שזמינים למכונה הווירטואלית.אסטרטגיית ההשוואה לביצועים של דיסקים מסוג NVMe שונה במכונות וירטואליות עם צומת NUMA אחד בלבד ובמכונות וירטואליות עם יותר מצומת NUMA אחד. כשבודקים את הביצועים של Hyperdisk באמצעות ממשק הדיסק NVMe, מוקצים רק 256 גדלים של תור NVMe לכל תור. בגלל הגדלים המוגבלים של תורי NVMe שזמינים וההתנגשות הפוטנציאלית שמגיעה מהדיסקים האחרים שמצורפים לאותה מכונה וירטואלית, בדיקות ההשוואה האלה משתמשות בשני תורי דיסקים של NVMe כדי לשמור על גודל תור מצטבר שיכול לטפל ב-iodepth של 256.
קבלת מספר צמתי ה-NUMA.
lscpu | grep -i 'numa node(s)' | awk '{print $NF}'אם למכונה הווירטואלית יש רק צומת NUMA אחד, צריך לקבל את המיפוי של התור מ-CPU ל-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 ומעלה), משתמשים ב-1 MB כגודל הקלט/פלט ובעומק קלט/פלט של 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:
אם למכונת ה-VM יש רק צומת 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
אם למכונת ה-VM יש יותר מצומת 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 של כתיבה
כדי להשיג את ערכי ה-IOPS המקסימליים של Hyperdisk, צריך לשמור על תור עמוק של פעולות קלט/פלט. לדוגמה, אם זמן האחזור של פעולת הכתיבה הוא אלפית השנייה, המכונה הווירטואלית יכולה להשיג לכל היותר 1,000 פעולות קלט/פלט בשנייה לכל פעולת קלט/פלט בתהליך. כדי להשיג 15,000 פעולות קלט/פלט של כתיבה בשנייה, המכונה הווירטואלית צריכה לבצע לפחות 15 פעולות קלט/פלט בזמן נתון. אם הדיסק והמכונה הווירטואלית יכולים להגיע ל-30,000 פעולות קלט/פלט בשנייה (IOPS) של כתיבה, מספר פעולות הקלט/פלט בתהליך חייב להיות לפחות 30. אם גודל הקלט/פלט גדול מ-4 KB, יכול להיות שהמכונה הווירטואלית תגיע למגבלת רוחב הפס לפני שהיא תגיע למגבלת ה-IOPS.
כדי לבדוק את קצב הקלט/פלט של פעולות כתיבה, מבצעים פעולות כתיבה אקראיות באמצעות גודל בלוק קלט/פלט של 4 KB ועומק קלט/פלט של 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:
אם למכונת ה-VM יש רק צומת 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
אם למכונת ה-VM יש יותר מצומת 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
בדיקת זמן האחזור של פעולות כתיבה
במהלך בדיקת זמן האחזור של קלט/פלט, המכונה הווירטואלית לא יכולה להגיע לרוחב הפס המקסימלי או למספר הפעולות המקסימלי של קלט/פלט לשנייה (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 ומעלה), באמצעות גודל קלט/פלט של 1 MB ועומק קלט/פלט של 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:
אם למכונת ה-VM יש רק צומת 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
אם למכונת ה-VM יש יותר מצומת 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, צריך לשמור על תור עמוק של פעולות קלט/פלט.
לדוגמה, אם גודל הקלט/פלט גדול מ-4 KB, יכול להיות שהמכונה הווירטואלית תגיע למגבלת רוחב הפס לפני שהיא תגיע למגבלת ה-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:
אם למכונת ה-VM יש רק צומת 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
אם למכונת ה-VM יש יותר מצומת 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
בדיקת זמן האחזור של הקריאה
חשוב למלא את הדיסק בנתונים כדי לקבל מדידה מציאותית של זמן האחזור. חשוב שהמכונה הווירטואלית לא תגיע למגבלות של 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
הסרת המשאבים
אם השתמשתם בדיסק ובמכונה וירטואלית זמניים כמומלץ, אחרי שתסיימו את בדיקות הביצועים תוכלו:
- מנתקים ומוחקים את הדיסק.
- מוחקים את ה-VM.