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

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

ניתן למצוא עבודת מעבדה בנושא זה כאן:
- מקורי: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- מקורי: github.com/remzi-arpacidusseau/ostep-code
- ההתאמה האישית שלי: github.com/bykvaadm/OS/tree/master/ostep

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

תפעול התוכנית

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

מודל חישוב פון נוימן

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

מערכת הפעלה

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

וירטואליזציה של מעבד

שקול את התוכנית הבאה:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

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

וירטואליזציה של זיכרון

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

קורא malloc()

שקול את התוכנית הבאה, אשר מקצה אזור זיכרון באמצעות השיחה malloc () (https://youtu.be/jnlKRnoT1m0):

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

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

עֲקֵבִיוּת

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

שקול את התוכנית הבאה:

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

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

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

מקור: www.habr.com