גרעין (מערכות הפעלה)

הגרעין מתווך את חומרת המחשב ליישומי התוכנה.

במערכת מחשב, הגרעין (באנגלית: kernel) הוא רכיב מרכזי של מערכת ההפעלה (התוכנה שמנהלת את המחשב) אשר שולט ברכיבי החומרה במערכת ומתווך אותם לתוכניות שרצות על המחשב. הגרעין מנהל את משאבי המערכת הפיזיים (המעבד, הזיכרון, וההתקנים) והווירטואלים (לדוגמא טבלת התהליכים שמכילה את כל מופעי התוכניות שרצות באותו רגע על המחשב) כך שתהליכים שונים יכולים להשתמש באותו משאב מבלי להפריע זה לזה. הגרעין מספק שכבה של אבסטרקציה שמפשטת משמעותית את פעולת התכנות (כתיבה של תוכניות) ע״י הצגת ממשק שמאפשר למתכנתים להשתמש במשאבי המחשב בצורה נוחה (למשל באמצעות מערכת קבצים במקום ע״י פעולות נמוכות-רמה להפעלת התקני אחסון). תוכניות משתמשות בשרותי הגרעין באמצעות קריאות מערכת.

המשימות של מערכות הפעלה מבוצעות באופן שונה על ידי גרעינים שונים, בהתאם לעיצוב ולמימוש שלהן. בעוד שגרעינים מונוליטים (monolithic kernels) מריצים את כל הקוד של מערכת ההפעלה באותו מרחב כתובות על מנת לשפר את ביצועי המערכת, מיקרו-גרעינים (microkernels) מריצים את מרבית שירותי מערכת ההפעלה במרחב המשתמש כשרתים, במטרה לשפר את האמינות והתחזוקתיות של מערכת ההפעלה. קיים מגוון של אפשרויות בין שתי הדוגמאות הקיצוניות האלה.

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

תפקידיו הבסיסיים של הגרעין

תפקידו העקרי של הגרעין הוא לנהל את משאבי המחשב ולאפשר לתוכניות אחרות לרוץ ולהשתמש במשאבים אלה. בדרך כלל בין משאבי המחשב נכללים:

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

הגורמים העיקריים הדרושים לניהול משאבים הם הגדרה של מרחב כתובות (execution domain) ומנגנון הגנה שמשמש לתיווך הגישה אל המשאבים בתוך הדומיין. בדרך כלל גרעינים מספקים גם אמצעים לסנכרון ולתקשורת בין תהליכים. גרעין יכול לממש רכיבים אלה בעצמו, או שהוא יכול להסתמך על תהליכים מסוימים שהוא מריץ על מנת לספק שירותים אלה עבור תהליכים אחרים, אם כי במקרה כזה על הגרעין לספק אמצעי כלשהו לתקשורת בין תהליכים על מנת לאפשר לתהליכים לגשת לשירותים שהם מספקים זה לזה. ולבסוף, על הגרעין לספק לתוכניות הרצות אמצעי להגיש בקשות לקבלת שירותים אלה.

ניהול תהליכים

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

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

גרעינים התומכים בריבוי משימות מסוגלים ליצור אשליה עבור המשתמש כאילו מספר התהליכים שרצים בו זמנית על גבי המחשב הוא גדול יותר מהמספר המקסימלי של תהליכים שהמחשב פיזית יכול להריץ בו זמנית. בדרך כלל מספר התהליכים שמערכת יכולה להריץ בו זמנית שווה למספר המעבדים שמותקנים במחשב (עם זאת, המצב יכול להיות שונה אם המעבדים תומכים בריבוי תהליכונים בו-זמנית (simultaneous multithreading).

במערכת המבוססת על ריבוי משימות מוסדר (preemptive multitasking), הגרעין יתן לכל תוכנית פרוסת זמן ותבצע מיתוג (switch) מתהליך לתהליך במהירות כזאת עד שהדבר יראה למשתמש כאילו תהליכים אלה מורצים בו זמנית. הגרעין משתמש באלגוריתמי תזמון על מנת לקבוע מה יהיה התהליך הבא שירוץ וכמה זמן יוקצה לו. האלגוריתם הנבחר יכול לאפשר לחלק מהתהליכים להיות בעלי קדימות גבוהה יותר מזו של אחרים. הגרעין בדרך כלל גם מספק לתהליכים אלה אמצעי כלשהו להתקשר; דבר זה ידוע בתור תקשורת בין תהליכים (IPC), והשיטות העיקריות לצורך כך הן זיכרון משותף, העברת מסרים והפעלת פרוצדורות מרחוק (ראו: מחשוב מקבילי).

מערכות אחרות (בייחוד על גבי מחשבים קטנים ופחות עוצמתיים) יכולות להיות מבוססות על ריבוי משימות שיתופי (cooperative multitasking), שבו כל תהליך מורשה לרוץ ללא פסיקות ("ללא הפרעה"), עד שהוא מגיש בקשה שאומרת לגרעין שהוא יכול לבצע מיתוג לתהליך אחר. בקשות כאלה נקראות yielding (ויתור), בדרך כלל הן מתרחשות בתגובה לבקשות לתקשורת בין תהליכים, או כאשר מחכים לאירוע שיתרחש. גרסאות ישנות יותר של Windows ו-Mac OS השתמשו בריבוי משימות שיתופי, אבל שתיהן עברו לעבוד בשיטת ריבוי משימות מוסדר ככל שגדלה עוצמת המחשבים שעבורם תוכננו.

מערכת ההפעלה עשויה לתמוך גם בריבוי עיבודים (multiprocessing), בארכיטקטורת ריבוי עיבודים סימטרי (Symmetric multiprocessing) או גישה לא אחידה לזיכרון (Non-Uniform Memory Access). במקרה זה, תוכניות ותהליכונים שונים יכולים לרוץ על מעבדים שונים. הגרעין עבור מערכת כזאת צריך להיות מתוכנן כך שיוכל בו זמנית להריץ בבטחה שני חלקים שונים של הקוד שלו. בדרך כלל המשמעות של כך היא שיש לספק מנגנוני סנכרון (כדוגמת spinlock) על מנת להבטיח שלא יקרה מצב בו שני מעבדים מנסים לשנות את אותם הנתונים באותו זמן.

ניהול זיכרון

לגרעין יש גישה מלאה לזיכרון המערכת ותפקידה לאפשר לתהליכים לגשת לזיכרון זה בצורה בטוחה בהתאם לדרישותיהם. בדרך כלל השלב הראשון לצורך כך הוא מיעון וירטואלי (virtual addressing), המושג בדרך כלל באמצעות דפדוף או סגמנטציה. מיעון וירטואלי מאפשר לגרעין לגרום לכתובת פיזית בזיכרון להופיע בתור כתובת שונה, הכתובת הווירטואלית. מרחבי כתובות וירטואליים עשויים להיות שונים עבור תהליכים שונים; הזיכרון אליו ניגש תהליך אחד בכתובת (וירטואלית) מסוימת עשוי להיות זיכרון שונה מהזיכרון שאליו ניגש תהליך אחר באותה הכתובת. זה מאפשר לכל תוכנית להתנהג כאילו היא התוכנית היחידה (חוץ מהגרעין) שרצה, ובכך מונעת מתוכניות להפיל אחת את השנייה.

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

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

ניהול התקנים

כדי לעשות פעילות מועילה כלשהי, לתהליכים צריכה להיות גישה לציוד ההיקפי (peripherals) שמחובר למחשב. ציוד היקפי זה נשלט על ידי הגרעין באמצעות מנהלי התקנים (device drivers). מנהל התקנים (דרייבר) הוא תוכנת מחשב המאפשרת למערכת ההפעלה ליצור אינטראקציה עם התקן חומרה כלשהו. מנהל ההתקנים מספק למערכת ההפעלה מידע כיצד לשלוט על יחידת חומרה מסוימת ואיך לתקשר איתה. לדרייבר חשיבות מכרעת עבור תוכנית יישומים. המטרה בתכנון מנהל התקנים היא ליצור אבסטרקציה על ידי תרגום קריאות של פונקציות (function/programming calls) היוצאות ממערכת ההפעלה, לקריאות הספציפיות עבור התקן מסוים. עקרונית, התקן אמור לעבוד באופן תקין עם מנהל ההתקנים המתאים עבורו. בדרך כלל מהנדסים כותבים את הקוד עבור מנהלי התקנים. הם פועלים על: כרטיסי מסך, כרטיסי קול, מדפסות, סורקים, מודמים, כרטיסי רשת, ועוד.

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

על הגרעין להחזיק ברשימה של כל ההתקנים הזמינים. רשימה זו יכולה להיות ידועה מראש (למשל במערכת משובצת מחשב שבה הגרעין יכתב מחדש אם החומרה תשתנה); יכולה להיות מוגדרת על ידי המשתמש (טיפוסי למחשבים אישיים ישנים ובמערכות שלא מיועדות לשימוש אישי); או שהיא מזוהה על ידי מערכת ההפעלה בזמן ריצה – הכנס-הפעל (plug and play). במערכת הכנס-הפעל, מנהל ההתקנים תחילה מבצע סריקה על אפיקי חומרה שונים, כגון PCI ו-USB על מנת לזהות התקנים מותקנים, ואז מחפש אחר הדרייברים המתאימים.

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

קריאות מערכת

קריאת מערכת (system call) היא מנגנון המשמש תוכניות לצורך בקשת שירות ממערכת ההפעלה. הן משתמשות בהוראות בשפת מכונה אשר גורמות למעבד לשנות מצב. דוגמה לכך יכולה להיות מעבר בין המצבים supervisor mode ל-protected mode. כאן מערכת ההפעלה מבצעת פעולות כמו גישה להתקני חומרה או ליחידת ניהול הזיכרון (MMU). בדרך כלל מערכת ההפעלה מספקת ספרייה שיושבת בינה לבין התוכניות הרגילות. בדרך כלל זוהי ספרייה בשפת C כמו glibc או Windows API. הספרייה מטפלת בפרטים ברמה הנמוכה (low level) של העברת מידע אל הגרעין ומעבר למצב משגוח (supervisor mode). קריאות מערכת נפוצות הן: close, open, read, write.

כדי לעשות פעילות מועילה כלשהי, על התהליך להיות מסוגל לגשת לשירותים שמספק הגרעין. דבר זה ממומש באופן שונה על ידי כל גרעין, אבל רובן מספקות ספרייה – C standard library, או ממשק תכנות יישומים (API), שבתורם קוראים לפונקציות של הגרעין.

סוגי גרעין

גרעין מונוליטי

בגרעין מונוליטי (monolithic kernel) כל שירותי מערכת ההפעלה רצים ביחד עם התהליכון הראשי של הגרעין, ולכן הם גם שוכנים באותו האזור בזיכרון. שיטה זו מאפשרת גישה עשירה ורבת עוצמה לחומרה. חלק מהמפתחים, כמו קן תומפסון, המפתח של UNIX, טוענים כי "קל יותר לממש גרעין מונוליטי" לעומת מיקרו-גרעינים (microkernels). החסרונות העיקריים של גרעינים מונוליטים הם התלויות שבין רכיבי המערכת – באג במנהל התקנים עלול לגרום לקריסת המערכת כולה, וכמו כן גרעינים גדולים עשויים להפוך לקשים מאוד לתחזוקה.

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

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

מרבית העבודה בגרעין מונוליטי מבוצעת דרך קריאות מערכת. אלו הם ממשקים הנשמרים בדרך כלל במבנה טבלאי, ואשר ניגשים לתת מערכת כלשהי בתוך הגרעין, כמו ביצוע פעולות על דיסק למשל. בעיקרו של דבר, קריאות מתבצעות בתוך תוכניות ועותק בדוק של הבקשה מועבר דרך קריאת מערכת. מכאן שהמסלול הוא לא ארוך בכלל. ניתן להפוך את הגרעין המונוליטי של לינוקס לקטן במיוחד לא רק בזכות היכולת שלו לטעון דינאמית מודולים, אלא גם בגלל הקלות לבצע בו התאמות אישיות. למעשה, קיימות כמה גרסאות קטנות דיין שיכולות להיכנס ביחד עם מספר גדול של יישומים ותוכניות אחרות לתוך נפח של כ-2MB ועדיין לספק מערכת הפעלה פונקציונלית לכל דבר (אחת ממערכות ההפעלה הפופולריות מהסוג היא OpenWRT, הפצה פופולרית לנתבים). היכולת הזאת למזעור של הגרעין שלה, הובילה גם לצמיחה המהירה בשימוש בלינוקס במערכות משובצות מחשב (מעגלים ממוחשבים המובנים לתוך מוצרים אחרים).

גרעינים מהסוג הזה מורכבים מהפונקציות הבסיסיות של מערכת ההפעלה וממנהלי התקנים עם היכולת לטעון מודולים בזמן ריצה. הם מספקים הפשטות עשירות ורבות עוצמה של החומרה שמתחת. כמו כן הגרעינים מספקים סט קטן של הפשטות פשוטות ומשתמשים באפליקציות שנקראות שרתים (servers) על מנת לספק עוד פונקציונליות. גישה זו מגדירה ממשק וירטואלי גבוה (high-level) מעל החומרה, ביחד עם קבוצה של קריאות מערכת שממשות שירותי מערכת הפעלה כגון ניהול תהליכים, מקביליות וניהול זיכרון, אשר מתבצעים במצב משגוח (supervisor mode). בעיצוב זה ישנם כמה פגמים ומגבלות:

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

מיקרו-גרעין

מיקרו-גרעין (microkernel, µK) הוא מונח המתאר גישה לתכנון מערכות הפעלה, בה הפונקציונליות של המערכת מועברת החוצה מה"גרעין" המסורתי, אל קבוצה של "שרתים" אשר מתקשרים דרך גרעין "מינימלי", ובכך משאירה כמה שניתן פחות ב"מרחב המערכת" וכמה שיותר ב"מרחב המשתמש". מיקרו-גרעין אשר מתוכנן עבור פלטפורמה או מכשיר ספציפי, תמיד יכיל אך ורק את הדרוש לה על מנת לפעול. תפישת המיקרו-גרעין כוללת הגדרה של אבסטרקציה פשוטה של החומרה, ביחד עם קבוצה של פרימיטיבים או קריאות מערכת כדי לממש שירותי מערכת הפעלה מינימליים כגון ניהול זיכרון, ריבוי משימות ותקשורת בין תהליכים. שירותים אחרים, כולל אלו שבדרך כלל מסופקים על ידי הגרעין, כמו רישות (networking), ממומשים בתוכניות שרצות במרחב המשתמש, המכונות שרתים. מיקרו-גרעינים הם פשוטים יותר לתחזוקה לעומת גרעינים מונוליטים, אבל המספר הגדול של קריאות מערכת והחלפות הקשר עלול להאט את המערכת מכיוון שהן בדרך כלל דורשות יותר משאבים לעומת קריאות פשוטות של פונקציות.

רק החלקים שבאמת חייבים לעבוד במצב עם הרשאות מלאות (privileged mode) נמצאים במרחב הגרעין: תקשורת בין תהליכים (IPC), המתזמן הבסיסי או פרימיטיבים של תזמון, ניהול זיכרון בסיסי, פרימיטיבים בסיסיים לקלט/פלט. במקרה זה חלקים קריטיים רבים רצים במרחב המשתמש: המתזמן המלא, ניהול זיכרון, מערכות קבצים ומחסניות רשת. מיקרו-גרעינים הומצאו בתגובה לעיצוב ה"מונוליטי" של גרעינים, שבו כל הפונקציונליות של המערכת הוכנסה לתוך תוכנה סטטית אחת, אשר רצה במצב "מערכת" מיוחד של המעבד. במיקרו-גרעין מתבצעות רק המשימות הבסיסיות ביותר, כמו היכולת לגשת לחלק מרכיבי החומרה (לא בהכרח אל כולם), ניהול זיכרון, וניהול העברת מסרים בין תהליכים. מהיתרונות של מיקרו-גרעינים:

בדרך כלל התחזוקה פשוטה יותר.
ניתן לבחון תיקונים חדשים ביחידה נפרדת, ולאחר מכן להכניס אותם במקום יחידה קודמת במערכת שכבר נמצאת בייצור (production).
זמן פיתוח מהיר יותר.
במערכות הפעלה רבות יש קוד גרעין מודולרי שאפשר להוריד ולטעון ללא צורך באתחול הגרעין.
עמידות גבוהה יותר בתקלות (שרידות; persistence). ניתן להריץ יותר מיחידה אחת ובמקביל, ואם אחת משתבשת, להפעיל את השנייה.

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

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

שירותים אחרים המסופקים על ידי הגרעין, כמו עבודה ברשת (networking), ממומשים בתוכניות למרחב המשתמש, המכונות שרתים (servers). השרתים מאפשרים לשנות את מערכת ההפעלה פשוט על ידי הפעלה ועצירה של תוכניות. לדוגמה, מכונה אשר אינה תומכת בעבודה ברשת, לא מפעילה את שרת ה-networking. מיקרו-גרעינים בדרך כלל מציגים ביצועים נחותים ביחס לעיצובים המסורתיים בגלל התקורה של המעברים אל ומחוץ לגרעין על מנת להעביר נתונים בין התוכניות והשרתים השונים. בעיה זו טופלה בגרסאות חדשות יותר של הגרעין. עם זאת קיימים חסרונות נוספים במיקרו-גרעינים:

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

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

הגישה של מיקרו-גרעינים הייתה נפוצה מאוד בחוגי האקדמיה בשנות השמונים והתשעים של המאה העשרים^[^{דרוש מקור]}, בשנים שבהן תוכננו רבות ממערכות ההפעלה שמשתמשים בהן היום. כתוצאה מכך הן מערכת ההפעלה Windows NT (שממנה נוצרו כל הגרסאות השולחניות המודרניות של מערכת חלונות) והן מערכת Mac OS X שנמצאת במחשבי מקינטוש מודרניים, תוכננו במקור כמערכות מיקרו-גרעין^[^{דרוש מקור]}. אולם בהמשך נזנחה הגישה הזו ובשתי המערכות הללו יש בפועל גרעין היברידי, שמשלב את שתי הגישות^[^{דרוש מקור: נקודה שנויה במחלוקת, בפרט לגבי OSX, שם המצב מסובך קצת יותר]}.

דוגמאות למערכות הפעלה שבנויות מעל מיקרו-גרעין:

QNX – משמשת בעיקר במערכות מבוזרות, אך גם בכמה טלפוני בלקברי.‏
HURD – הייתה אמורה להיות מערכת ההפעלה של פרויקט גנו. בפועל ירשה גנו/לינוקס את מקומה. המערכת עדיין בפיתוח אולם אין לה כמעט שימוש. במערכת HURD משתמשים במיקרו-גרעין Mach שמספק רק מיפוי כתובות והעברת הודעות.
מיניקס.

גרעין היברידי

גרעינים היברידיים משמשים כיום במרבית מערכות ההפעלה המסחריות, כשהבולטת ביותר היא משפחת חלונות NT על גרסאותיה: NT 3.x,‏ NT 4,‏ 2000,‏ XP,‏ ויסטה, 7, 8, 10 ו-11. גם מערכת ההפעלה של אפל, macOS (לשעבר Mac OS X) משתמשת בגרעין היברידי בשם XNU שמבוסס על קוד משולב מהמיקרו-גרעין Mach ומהגרעין המונוליטי של FreeBSD.

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

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

בין היתרונות של גרעינים היברידיים:

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

ראו גם

קישורים חיצוניים

מדיה וקבצים בנושא גרעין בוויקישיתוף