io_uring בלינוקס מול קלט/פלט בחלונות: השוואה טכנית

מצב הקלט/פלט האסינכרוני

שרתים בעלי ביצועים גבוהים, בסיסי נתונים ומנועי אחסון ניצבים כולם בפני אותו צוואר בקבוק: כיצד לבצע כמויות אדירות של קלט/פלט בלי לטבוע בתקורת קריאות מערכת. לינוקס וחלונות נקטו גישות שונות באופן יסודי לבעיה הזו, והפער התרחב משמעותית מאז שלינוקס 5.1 הציגה את io_uring ב-2019.

מהו io_uring?

io_uring הוא ממשק של ליבת לינוקס לקלט/פלט אסינכרוני הבנוי סביב שני מאגרי טבעת נטולי נעילות המשותפים בין מרחב המשתמש לליבה: תור הגשה (SQ) ותור השלמה (CQ). היישום דוחף בקשות קלט/פלט אל ה-SQ, והליבה מוסרת תוצאות אל ה-CQ — הכול ללא קריאות מערכת במסלול החם.

תכונות מרכזיות:

הגשה ללא העתקה — בקשות נכתבות ישירות לזיכרון משותף. אין צורך במעטפת syscall לכל פעולה לאחר שהטבעות מוקמו.
קיבוץ — קריאת io_uring_enter() בודדת יכולה להגיש מאות פעולות ולקצור השלמות באותה עת.
מצב סקירה (polled) — עבור עומסי NVMe בעלי השהיה נמוכה במיוחד, הליבה יכולה לסקור בלולאה עסוקה אחר השלמות, ולבטל לחלוטין את תקורת הפסיקות.
מאגרים ומתארי קבצים רשומים — רישום מוקדם של משאבים מסיר חיפושים חוזרים בליבה, וחוסך מיקרו-שניות לכל פעולה.
פעולות מקושרות — שרשראות של פעולות קלט/פלט תלויות יכולות להיות מוגשות כיחידה אחת, ומבוצעות ברצף בידי הליבה.
טבעות בגודל קבוע שהוקצו מראש — אין הקצאות במסלול החם.

מנגנוני קלט/פלט אסינכרוני בחלונות

חלונות מציעה כמה מנגנוני קלט/פלט אסינכרוניים חופפים, כל אחד מתקופה אחרת:

פורטי השלמת קלט/פלט (IOCP)

IOCP, שהוצג ב-Windows NT 3.5 (1994), הוא מנגנון הקלט/פלט האסינכרוני הראשי בעל הביצועים הגבוהים בחלונות. יישום יוצר פורט השלמה, משייך אליו מתארי קבצים, מנפיק פעולות קלט/פלט חופפות (overlapped), ושולף השלמות מהפורט.

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

קלט/פלט חופף (Overlapped I/O)

היסוד שמתחת ל-IOCP. כל קריאת קלט/פלט מקבלת מבנה OVERLAPPED ומסתיימת באופן אסינכרוני. הודעת ההשלמה מגיעה דרך IOCP, אובייקטי אירוע, או המתנה הניתנת להתראה (APC). תקורת קריאת המערכת לכל פעולה נותרת.

קלט/פלט רשום (RIO)

RIO, שהוצג ב-Windows 8 / Server 2012, הוא ניסיונה של מיקרוסופט ליצור מסלול קלט/פלט רשתי בעל ביצועים גבוהים יותר. הוא רושם מראש מאגרים ומשתמש בתורי הגשה/השלמה — דומה רעיונית ל-io_uring, אך מוגבל לשקעי רשת בלבד. RIO מעולם לא זכה לאימוץ נרחב ובקושי נמצא בשימוש מחוץ ליישומי מסחר פיננסי מיוחדים.

השוואה ראש בראש

תקורת קריאות מערכת

כאן io_uring מנצח באופן מובהק. IOCP דורש קריאת מערכת אחת לכל פעולת קלט/פלט שמונפקת ואחת לכל השלמה שנשלפת. io_uring יכול להגיש ולקצור אלפי פעולות בלי שום קריאת מערכת בעזרת מצב סקירה מבוסס זיכרון משותף, או לכל היותר קריאת io_uring_enter() אחת עבור אצווה מלאה. בעומסים עם מיליוני פעולות קלט/פלט קטנות בשנייה, ההבדל הזה לבדו יכול להביא לתפוקה גבוהה ב-30-50%.

כלליות

io_uring תומך כמעט בכל פעולת קלט/פלט שהליבה מציעה: read, write, fsync, poll, accept, connect, send, recv, openat, close, statx, rename, unlink, mkdir, ורבות נוספות. הוא הפך למעשה לממשק כללי של קריאות מערכת אסינכרוניות.

IOCP מיועד בעיקר לקלט/פלט של קבצים ושקעים. RIO מוגבל לשקעים בלבד. לחלונות אין מקבילה ליכולתו של io_uring לבצע פעולות שרירותיות של מערכת קבצים באופן אסינכרוני דרך ממשק אחיד.

ניהול מאגרים

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

IOCP דורש נעיצת דפים עבור כל פעולה חופפת. RIO רושם מראש מאגרים אך רק עבור קלט/פלט רשתי. אין מקבילה לקבוצות המאגרים המסופקות של io_uring עבור קלט/פלט של קבצים בחלונות.

עקיפת ליבה וסקירה

מצב SQPOLL של io_uring יוצר תהליכון ליבה שסוקר ברציפות את תור ההגשה, כלומר היישום אינו נכנס לליבה כלל במצב יציב. בשילוב עם מצב סקירה של NVMe, זה משיג השהיות קרובות לעקיפת ליבה בסגנון SPDK בלי לוותר על בטיחות הקלט/פלט המתווך בידי הליבה.

לחלונות אין מקבילה. הדבר הקרוב ביותר הוא מסגרת דרייברים במרחב המשתמש (UMDF) או דרייבר ליבה מותאם, ששניהם מורכבים בהרבה לפיתוח ולפריסה.

פעולות מקושרות ותלויות

io_uring תומך בשרשור פעולות: לקרוא קובץ, ואז לכתוב לשקע, ואז fsync — הכול מוגש כשרשרת מקושרת אחת. הליבה מבצעת אותן בסדר בלי לחזור למרחב המשתמש בין הצעדים.

ל-IOCP אין מקבילה. כל פעולה תלויה חייבת להיות מוגשת ממרחב המשתמש לאחר שהקודמת הושלמה, מה שמוסיף הלוך ושוב לכל חוליה בשרשרת.

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

ל-IOCP 30 שנות שימוש בייצור. הוא מובן היטב, מתועד היטב, ומשולב עמוקות באקוסיסטם של חלונות (‎.NET, Win32, Winsock). כמעט כל יישום שרת בחלונות משתמש בו. כלי הניפוי והפרופיילינג (ETW, xperf, WPA) בשלים.

io_uring צעיר יותר (2019) ועבר כמה סבבים של הקשחת אבטחה. גרסאות ליבה מוקדמות סבלו מ-CVE-ים הקשורים ל-io_uring, וכמה הפצות (בייחוד ליבות הייצור של גוגל וגרסאות מוקדמות של פרופילי ה-seccomp של Docker) השביתו אותו לחלוטין למשך תקופה. ה-API התייצב במידה ניכרת מאז לינוקס 5.15+, ופרויקטים מרכזיים (PostgreSQL, RocksDB, NGINX, Tokio, liburing) משתמשים בו כיום בייצור.

יתרונות io_uring על פני הקלט/פלט של חלונות

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

יתרונות הקלט/פלט של חלונות על פני io_uring

עשרות שנים של יציבות — ה-API של IOCP קפוא כבר 30 שנה. אין שינויים שוברים מפתיעים.
שילוב עם מאגר תהליכונים — ויסות המקביליות המובנה של IOCP מקשה על כתיבת שרת שקורס תחת עומס.
תיעוד וכלים עדיפים — תיעוד ה-IOCP של מיקרוסופט, מעקב ETW וניתוח WPA מלוטשים.
ללא חבלי לידה של אבטחה — משטח התקיפה של IOCP הוקשח לאורך שלושה עשורים, בעוד io_uring עדיין צובר תיקוני CVE.
RIO לשימוש נישתי — עבור עומסי רשת טהורים, RIO מציע חלק מיתרונות io_uring ללא המורכבות.
תמיכה רחבה יותר בשפות — קלט/פלט אסינכרוני ב-C#/‎.NET בנוי ישירות על IOCP, ומנגיש קלט/פלט בעל ביצועים גבוהים ללא ניהול ידני של מאגרי טבעת.

חסרונות io_uring

מורכבות — ה-API עוצמתי אך גדול. שימוש נכון מחייב הבנה של סמנטיקת מאגרי טבעת, סדר זיכרון, ודגלי רשומות תור הגשה (SQE). ספריות כמו liburing מסייעות, אך ההפשטה מורכבת מטבעה יותר מ"קריאה ל-ReadFile עם OVERLAPPED".
רקורד אבטחה — io_uring היה מקור חוזר לפרצות של הסלמת הרשאות. משטח התקיפה הגדול בליבה הוא דאגה מתמשכת.
רגישות לגרסת ליבה — תכונות ותיקונים משתנים משמעותית בין גרסאות ליבה. יישום המכוון ל-io_uring חייב או לדרוש ליבה עדכנית או לממש מסלולי נסיגה.
קושי בניפוי — מעקב אחר קלט/פלט דרך מאגרי טבעת בזיכרון משותף קשה יותר ממעקב אחר קריאות מערכת. strace הרגיל אינו לוכד פעולות io_uring כברירת מחדל.

חסרונות הקלט/פלט של חלונות

תקורת קריאת מערכת לכל פעולה — המגבלה הארכיטקטונית היסודית. שום אופטימיזציה לא יכולה להשתוות למסלול נטול קריאות מערכת.
משטח API מפוצל — IOCP, RIO, קלט/פלט חופף ו-APC הם מנגנונים נפרדים עם סמנטיקות שונות, מה שמוביל לבלבול ולבאגים.
אין פעולות מטא-נתונים אסינכרוניות אמיתיות — פעולות כמו rename, delete ו-stat הן סינכרוניות בחלונות. יישומים הזקוקים לפעולות מטא-נתונים אסינכרוניות חייבים להשתמש במאגרי תהליכונים, מה שמחטיא את המטרה.
קיפאון RIO — ה-API של מיקרוסופט הדומה ביותר ל-io_uring זכה לפיתוח מינימלי מאז הצגתו ונשאר מוגבל לרשת בלבד.
קוד סגור — בלתי אפשרי לבקר, לנפות ברמת הליבה, או לתרום תיקונים ללא מעורבות מיקרוסופט.

השורה התחתונה

io_uring מייצג קפיצת דור בעיצוב ממשקי קלט/פלט. הוא מטפל בחוסר היעילות היסודי שפגע בכל מודלי הקלט/פלט האסינכרוני הקודמים — קריאת המערכת לכל פעולה — ומחליף אותה בתקשורת בזיכרון משותף המסוגלת להשיג מיליוני IOPS בתקורת מעבד מינימלית.

IOCP של חלונות נותר כשיר ומנוסה בשדה, אך הארכיטקטורה שלו מראה סימני זקנה. מיקרוסופט לא שחררה ממשק קלט/פלט מודרני דומה, ו-RIO היה חצי צעד שמעולם לא מימש את הפוטנציאל שלו.

עבור מערכות חדשות בעלות ביצועים גבוהים — בסיסי נתונים, מנועי אחסון, פרוקסים, מערכות העברת הודעות — io_uring על לינוקס הוא המנצח הטכני הברור. הפרש הביצועים אינו שולי; הוא ארכיטקטוני. יישומים שקודם לכן נזקקו למסגרות עקיפת ליבה כמו DPDK או SPDK יכולים כעת להשיג ביצועים דומים דרך io_uring תוך שהם נשארים במסלול הקלט/פלט הסטנדרטי של הליבה.

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