מבוא למערכות הפעלה

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

ניתן למצוא עבודת מעבדה בנושא זה כאן:

• מְקוֹרִי: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• מְקוֹרִי: github.com/remzi-arpacidusseau/ostep-code
• ההתאמה האישית שלי: github.com/bykvaadm/OS/tree/master/ostep

חלקים אחרים:

• חלק 1: מבוא

אתה יכול גם לבדוק את הערוץ שלי בכתובת מִברָק =)

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

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

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

הפשטה: תהליך

ההפשטה של ​​תוכנית פועלת שמבוצעת על ידי מערכת ההפעלה היא מה שאנו מכנים תהליך. כפי שהוזכר קודם לכן, תהליך הוא פשוט תוכנית פועלת, בכל פרק זמן מיידי. תוכנית שבאמצעותה נוכל לקבל מידע סיכום ממשאבי מערכת שונים שתוכנית זו ניגשת אליהם או משפיעה עליהם במהלך ביצועה.
כדי להבין את מרכיבי התהליך, עליך להבין את מצבי המערכת: מה התוכנית יכולה לקרוא או לשנות במהלך פעולתה. בכל זמן נתון, עליך להבין אילו אלמנטים במערכת חשובים לביצוע התוכנית.
אחד המרכיבים הברורים של המערכת קובעים שהתהליך כולל הוא память. ההוראות ממוקמות בזיכרון. הנתונים שהתוכנית קוראת או כותבת נמצאים גם הם בזיכרון. לפיכך, הזיכרון שתהליך יכול לטפל בו (נקרא מרחב כתובת) הוא חלק מהתהליך.
גם חלק ממצב המערכת הם אוגרים. הוראות רבות מכוונות לשינוי ערכם של רגיסטרים או קריאת ערכם, וכך הופכים גם רגיסטרים לחלק חשוב בתפעול התהליך.
יש לציין שמצב המכונה נוצר גם מכמה אוגרים מיוחדים. לדוגמה, IP - מצביע הוראות - מצביע להוראה שהתוכנית מבצעת כעת. יש גם מצביע מחסנית וקשורים אליו מצביע מסגרת, המשמשים לניהול: פרמטרי פונקציה, משתנים מקומיים וכתובות החזרה.
לבסוף, תוכניות ניגשות לרוב ל-ROM (זיכרון לקריאה בלבד). מידע "I/O" (קלט/פלט) זה צריך לכלול רשימה של קבצים שנפתחים כעת בתהליך.

תהליך API

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

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

יצירת תהליך: פרטים

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

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

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

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

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

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

מצב תהליך

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

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

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

מבנה נתונים

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

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

בנוסף למצבים מוכנים, חסומים, פועלים, יש כמה מדינות אחרות. לפעמים, בזמן היצירה, תהליך עשוי להיות במצב INIT. לבסוף, ניתן להציב תהליך במצב FINAL כאשר הוא כבר הושלם, אך המידע שלו עדיין לא נוקה. במערכות UNIX נקרא מצב זה תהליך זומבים. מצב זה שימושי למקרים שבהם תהליך הורה רוצה לדעת את קוד ההחזרה של ילד, למשל, בדרך כלל 0 מסמן הצלחה ו-1 שגיאה, אך מתכנתים יכולים להנפיק קודי פלט נוספים כדי לאותת על בעיות שונות. כאשר תהליך האב מסתיים, הוא מבצע קריאת מערכת סופית, כגון wait(), כדי להמתין עד שתהליך הילד יסתיים ולאותת למערכת ההפעלה שהיא יכולה לנקות את כל הנתונים הקשורים לתהליך שהופסק.

נקודות מפתח בהרצאה:

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

מקור: www.habr.com