Transcript אלגוריתם מס` 3

Principles of Structure of
Operating Systems
‫עקרונות מבנה מערכות הפעלה‬
‫זימון תהליכים‬-CPU ‫תזמון‬
‫רעיון כללי‬
‫המטרה של ‪ multiprogramming‬היא להחזיק‬
‫מספר תהליכים רצים במשך כל הזמן‪ ,‬בכדי לנצל‬
‫את ה‪ CPU-‬באופן מקסימאלי‪ .‬במערכות‬
‫‪( uni-processor‬מעבד אחד)‬
‫רק תהליך אחד יכול לרוץ‪ .‬יתר התהליכים יצטרכו‬
‫להמתין עד שה‪ CPU-‬יתפנה‪.‬‬
‫רעיון כללי‪ -‬המשך‬
‫• הרעיון של ‪ multiprogramming‬ביסודו פשוט‪ .‬תהליך רץ עד שהוא‬
‫צריך להמתין‪ .‬ההמתנה היא בדרך כלל לסיום של בקשות ‪.I/O‬‬
‫במצב כזה במערכת מחשב פשוטה‪ ,‬ה‪ CPU-‬יעבור למצב של ‪idle‬‬
‫(סרק)‪ .‬כל זמן ההמתנה הזה מבוזבז – כי אפשר היה לנצל את‬
‫המעבד בזמן זה לביצוע מטלות אחרות‪.‬‬
‫• ב‪ multiprogramming-‬אנחנו מנסים להשתמש בזמן הזה בצורה‬
‫מועילה‪ .‬מספר תהליכים נשמרים בזיכרון באותו זמן‪ ,‬וכאשר תהליך‬
‫אחד נמצא במצב המתנה‪ ,‬מערכת ההפעלה לוקחת את ה‪CPU-‬‬
‫מהתהליך ונותנת אותו לתהליך אחר‪.‬‬
‫• תזמון הנו אחד מהפעולות העיקריות של מערכת ההפעלה‪ .‬כמעט‬
‫כל משאבי המחשב מתוזמנים לפני שימוש‪.‬‬
‫מושגים‬
‫‪ )1‬מעגל ה"התפרצויות" של המעבד ‪CPU-I/O Burst Cycle -‬‬
‫ריצת תהליך מורכבת ממעגל של ריצה ב‪ CPU-‬והמתנה ל‪ ,I/O-‬כאשר כל הזמן‬
‫התהליך עובר בין השניים‪ .‬כמו כן‪ ,‬התהליך מתחיל ב‪ CPU-‬ומסתיים בו‪.‬‬
‫תוכנית המבוססת בעיקר על ‪ I/O‬סביר שיהיו לה פרצי (‪ CPU )burst‬קצרים‪,‬‬
‫ואילו תוכנית המבוססת על ‪ CPU‬תכיל פרצים ארוכים‪ .‬הצלחת מתזמן ה‪-‬‬
‫‪ CPU‬תלויה למעשה בריצת התהליך‪.‬‬
‫‪ )2‬מתזמן המעבד ‪CPU Scheduler -‬‬
‫ברגע שה‪ CPU-‬נכנס למצב של סרק‪ ,‬מערכת ההפעלה חייבת לבחור תהליך‬
‫מתוך ה‪ ready queue-‬ולתת לו לרוץ על ה‪ .CPU-‬החלטות המתזמן עשויות‬
‫לקרות באחד מארבעת הנסיבות הבאות‪:‬‬
‫א‪ .‬כאשר תהליך עובר ממצב ריצה למצב המתנה‪.‬‬
‫ב‪ .‬כאשר תהליך עובר ממצב ריצה למצב ‪.ready‬‬
‫ג‪ .‬כאשר תהליך עובר ממצב המתנה למצב ‪.ready‬‬
‫ד‪ .‬כאשר תהליך מסתיים‪.‬‬
‫מושגים‪ -‬המשך‬
‫• במקרים ‪ 1,4‬אין אפשרות בחירה‪ .‬התהליך מסתיים מיוזמתו‪,‬‬
‫ותהליך חדש חייב להיבחר מתוך התור‪ .‬מקרים מסוג זה נקראים‬
‫‪( non-preemptive‬מדיניות ללא‪-‬הפקעה)‪ .‬המשמעות היא שברגע‬
‫שה‪ CPU-‬הוקצה לתהליך‪ ,‬התהליך שומר על ה‪ CPU-‬עד שהוא‬
‫משחרר אותו‪ ,‬ולא ייתכן מצב שמערכת ההפעלה תפריע לו באמצע‪,‬‬
‫או תעצור אותו ותיתן עדיפות לתהליך אחר‪ .‬זוהי מערכת שאדישה‬
‫לשינויים‪ .‬תהליך בעל עדיפות גבוהה יותר לא יכול להפריע לתהליך‬
‫שכבר רץ‪.‬‬
‫• עבור מקרים ‪ 2‬ו‪ 3-‬קיימת אפשרות בחירה‪ .‬מקרים אלו נקראים‬
‫‪( preemptive‬מדיניות עם הפקעה) – קיימת עדיפות לתהליך‪.‬‬
‫מערכת מסוג זה אינה אדישה לשינויים‪ ,‬והיא בודקת כל הזמן את‬
‫מצבי התהליכים ועשויה להפסיק תהליך אחד עבור תהליך בעל‬
‫עדיפות גבוהה יותר‪ .‬תזמון מסוג זה גורם לעלויות – זמן‬
‫ה‪ .context switch-‬בעיה נוספת במערכת מסוג זה היא הסנכרון‪.‬‬
‫מושגים‪ -‬המשך‬
‫‪ )3‬המשגר ‪Dispatcher -‬‬
‫‪ module‬זה מעביר את הבקרה של ה‪ CPU-‬לתהליך שנבחר ע"י‬
‫•‬
‫ה‪ .short-term scheduler-‬פעולה זו כוללת‪:‬‬
‫א‪.Switching context .‬‬
‫ב‪ .‬מעבר ל‪.user mode-‬‬
‫ג‪ .‬קפיצה למקום הנכון בתוכנית המשתמש במטרה להתחיל‬
‫להריץ אותה‪.‬‬
‫‪ module‬זה צריך להיות מהיר ככל האפשר‪ ,‬שכן הוא נקרא בכל‬
‫•‬
‫פעם שמחליפים תהליך‪ .‬הזמן שלוקח ל‪ dispatcher-‬להפסיק את‬
‫התהליך הרץ ולהתחיל בהרצת תהליך חדש נקרא ‪dispatch‬‬
‫‪latency‬‬
‫קריטריונים לתזמון ‪Scheduling -‬‬
‫‪Criteria‬‬
‫כאשר אנו מחליטים באיזה אלגוריתם להשתמש במצב מסוים‪ ,‬יש לקחת בחשבון את‬
‫המאפיינים של כל אלגוריתם‪ .‬הקריטריונים בהם משתמשים להשוואות אלגוריתמים‬
‫של מתזמני ‪ CPU‬הם‪:‬‬
‫‪ .1‬ניצול ‪ – CPU‬נרצה לוודא שה‪ CPU-‬עסוק כל הזמן‪ .‬ניצול ה‪ CPU-‬יכול לנוע‬
‫מ‪ 0-‬אחוז ל‪ 100-‬אחוז‪ .‬במערכת אמיתית הטווח צריך להיות בין ‪ 40‬אחוז ל‪-‬‬
‫‪ 90‬אחוז‪.‬‬
‫‪ .2‬תפוקה – יעילות הרצת תהליכים חופפים‪ .‬אחת הדרכים לבדוק את עבודת‬
‫האלגוריתם היא מספר התהליכים שסיימו ביחידת זמן אחת‪.‬‬
‫‪ .3‬זמן סבב – מנקודת מבט של תהליך ספציפי‪ ,‬הקריטריון החשוב הוא כמה‬
‫זמן לוקח להריץ את התהליך‪ .‬המרווח בין הזמן שהתהליך ביקש לרוץ לבין‬
‫הזמן שהתהליך יסתיים נקרא זמן סבב‪ .‬זמן זה הוא סכום משך הזמנים‬
‫שהתהליך בזבז בהמתנה לזיכרון‪ ,‬המתנה בתור ‪ ,ready‬ריצה ב‪CPU-‬‬
‫והפעלת ‪(.I/O‬מדידה מהרגע שנכנס ל ‪)memory queue‬‬
‫קריטריונים לתזמון ‪Scheduling Criteria -‬‬
‫המשך‬
‫‪ .4‬זמן המתנה – האלגוריתם אינו משפיע על הזמן בו תהליך רץ או‬
‫משתמש ב‪ ,I/O-‬אלא רק על הזמן שתהליך מעביר בהמתנה בתור‬
‫ה‪ .ready-‬זמן ההמתנה הוא סכום משך הזמנים הכולל שהתהליך‬
‫העביר בתור ה‪(.ready-‬כשזמן ההמתנה אינסופי אז יש הרעבה)‬
‫‪ .5‬זמן תגובה – במערכת אינטראקטיבית‪ ,‬זמן הסבב אינו יכול להיות‬
‫קריטריון מתאים‪ ,‬משום שלעיתים קרובות‪ ,‬תהליך יכול לספק חלק‬
‫מהפלט די מהר‪ ,‬ולהמשיך בחישובים אחרים בזמן שחלק מהפלט‬
‫כבר מוצג למשתמש‪ .‬לכן אמת מידה נוספת היא הזמן שלוקח מרגע‬
‫הבקשה ועד לתגובה הראשונה‪ .‬זמן התגובה הנו משך הזמן שלוקח‬
‫להתחיל להגיב‪ ,‬אבל לא כולל את זמן התגובה עצמו‪.‬‬
‫קובע את מידת ההגינות של המערכת – זמן תגובה דומה לכל‬
‫התהליכים זה ממתי שנכנס ל ‪ ready queue‬ועד שקיבל ‪ cpu‬ועבר‬
‫ל ‪.running‬‬
‫המטרה‬
‫המטרה היא להביא את ניצול ה‪ CPU-‬ואת‬
‫התפוקה למצב מקסימאלי‪ ,‬ולמזער כמה שיותר‬
‫את זמן הסבב‪ ,‬זמן ההמתנה וזמן התגובה‪ .‬ברוב‬
‫המקרים מנסים לייעל את הממוצע של כל‬
‫הקריטריונים‪ ,‬אך קיימים מצבים בהם רצוי לייעל‬
‫את ערכי המקסימום או המינימום ולא את‬
‫הממוצע‪ .‬לדוגמא‪ ,‬כאשר רוצים להבטיח שכל‬
‫המשתמשים יקבלו שירות טוב‪ ,‬נרצה להקטין את‬
‫זמן התגובה המקסימאלי‪.‬‬
‫אלגוריתמים שונים לתזמון ‪Scheduling -‬‬
‫‪Algorithms‬‬
‫קיימים מס' אלגוריתמים שמנסים להשיג את‬
‫המטרה ‪.‬‬
‫בחלק זה נציג חלק מהאלגוריתמים הקיימים ונעריך‬
‫את היתרונות והחסרונות של כל אחד מהם ‪.‬‬
‫אלגוריתם מס ‪ :1‬ראשון בא‪ ,‬ראשון ישורת ‪-‬‬
‫‪FCFS - First Come, First Served‬‬
‫באלגוריתם זה ה ‪ Scheduler‬יכניס לעבודה ב‪ CPU‬את‬
‫התהליך הראשון שהיגיע ל ‪. ready queue‬‬
‫התהליכים מסודרים בתור לפי סדר הגעתם ומוכנסים‬
‫לעבודה לפי סדר זה‪.‬‬
‫מימוש האלגוריתם‬
‫ברגע שתהליך נכנס ל‪ ,ready queue-‬ה‪ PCB-‬שלו‬
‫מקושר לזנב התור‪ .‬כאשר ה‪ CPU-‬פנוי‪ ,‬הוא מוקצה‬
‫לתהליך שנמצא בראש התור (התהליכים יתבצעו לפי‬
‫סדר ההגעה שלהם)‪.‬‬
‫אלגוריתם מס ‪ :1‬ראשון בא‪ ,‬ראשון ישורת ‪-‬‬
‫‪FCFS - First Come, First Served‬‬
‫יתרונות האלגוריתם ‪:‬‬
‫א‪ .‬פשוט מאוד למימוש ‪.‬‬
‫ב‪ .‬שומר על עיקרון ההגינות‪.‬‬
‫חסרון האלגוריתם ‪:‬‬
‫זמן ההמתנה הממוצע במקרה זה הוא לרוב‬
‫ארוך‪ ,‬והוא תלוי בזמן ההגעה של התהליכים‬
‫אלגוריתם מס ‪ :1‬ראשון בא‪ ,‬ראשון ישורת ‪-‬‬
‫‪FCFS - First Come, First Served‬‬
‫דוגמא לזמן המתנה ממוצע‬
‫נניח כי מגיעים שלושה תהליכים ל‪ready queue -‬‬
‫‪Burst time‬‬
‫זמן סיום התהליך‬
‫‪Process‬‬
‫‪24‬‬
‫‪p1‬‬
‫‪3‬‬
‫‪p2‬‬
‫‪3‬‬
‫‪p3‬‬
‫המשך הדוגמא‬
‫אם התהליכים הגיעו על פי הסדר ‪:‬‬
‫‪ P1‬ראשון ‪ P2 ,‬שני ‪ P3 ,‬שלישי ‪,‬‬
‫נקבל את המצב הבא‪:‬‬
‫ זמן ההמתנה של ‪ P1‬יהיה ‪( 0‬משום שהוא‬‫התחיל מיד)‬
‫ זמן ההמתנה של ‪ P2‬יהיה ‪24‬‬‫זמן ההמתנה של ‪ P3‬יהיה ‪.27‬‬‫זמן ההמתנה הממוצע הינו‪:‬‬
‫‪(0+24+27)/3=17‬‬
‫המשך הדוגמא‬
‫אם התהליכים הגיעו על פי הסדר ‪:‬‬
‫‪ P2‬ראשון ‪ P3 ,‬שני ‪ P1 ,‬שלישי ‪,‬‬
‫נקבל את המצב הבא‪:‬‬
‫ זמן ההמתנה של ‪ P2‬יהיה ‪( 0‬משום שהוא‬‫התחיל מיד)‬
‫ זמן ההמתנה של ‪ P3‬יהיה‪3‬‬‫זמן ההמתנה של ‪ P1‬יהיה ‪.6‬‬‫זמן ההמתנה הממוצע הינו‪:‬‬
‫‪(0+3+6)/3=3‬‬
‫הסבר‬
‫לפי הדוגמא אנו רואים שזמן ההמתנה הממוצע תלוי בסדר‬
‫הגעת התהליכים ‪.‬‬
‫ככול שבראש התור יש תהליכים ארוכים יותר זמן ההמתנה‬
‫הממוצע עולה‪.‬‬
‫מצב ‪(convoy effect‬אפקט השיירה)‬
‫מצב כאשר כל התהליכים ממתינים לתהליך אחד ארוך‬
‫שיסיים עם ה‪.CPU-‬‬
‫אלגוריתם זה בעיקר בעייתי במערכות ‪ ,time-sharing‬בהן‬
‫חשוב שכל משתמש יקבל את ה‪ CPU-‬המשותף במרווח‬
‫רגיל‪.‬‬
‫אלגוריתם מס' ‪: 2‬הקצר ביותר ראשון ‪SJF -‬‬
‫‪- Shortest Job First‬‬
‫• ראינו בדוגמא כי ככול שבתחילת התור יש תהליכים‬
‫קצרים יותר זמן ההמתנה הממוצע קטן‪.‬‬
‫• אלגוריתם זה מקשר לכל תהליך את אורך פרץ ה‪CPU-‬‬
‫(‪ )CPU Burst‬הבא שלו‪ .‬ברגע שה‪ CPU-‬נגיש‪ ,‬הוא‬
‫מוקצה לתהליך בעל פרץ ה‪ CPU-‬הבא הקצר ביותר‪ .‬אם‬
‫לשני תהליכים יש את אותו אורך פרץ ‪ ,CPU‬יעשה שימוש‬
‫באלגוריתם ‪ FCFS‬לבחירת התהליך הראשון‪ .‬נשים לב‬
‫שהאלגוריתם לא מתייחס לזמן הכולל הנדרש לתהליך על‬
‫ה‪ ,CPU-‬אלא רק לפרץ ה‪ CPU-‬הבא‪.‬‬
‫אלגוריתם מס' ‪: 2‬הקצר ביותר ראשון ‪SJF -‬‬
‫‪- Shortest Job First‬‬
‫• יתרון האלגוריתם ‪:‬‬
‫קיצור זמן ההמתנה הממוצע למינימום‪.‬‬
‫דוגמא לזמן המתנה ממוצע‬
‫נניח כי מגיעים ארבע תהליכים ל‪ ready queue -‬לפי הסדר‬
‫הבא‬
‫‪Burst time‬‬
‫‪Process‬‬
‫‪6‬‬
‫‪p1‬‬
‫‪8‬‬
‫‪p2‬‬
‫‪7‬‬
‫‪p3‬‬
‫‪3‬‬
‫‪p4‬‬
‫המשך הדוגמא‬
‫• תזמון התהליכים ע"י שימוש באלגוריתם זה בסדר הבא‪:‬‬
‫ ‪ P4‬ראשון ‪ -‬זמן ההמתנה שלו הוא ‪0‬‬‫ ‪ P1‬שני – זמן ההמתנה שלו הוא ‪3‬‬‫ ‪ P3‬שלישי ‪ -‬זמן ההמתנה שלו הוא ‪9‬‬‫ ‪ P2‬רביעי ‪ -‬זמן ההמתנה שלו הוא ‪16‬‬‫זמן ההמתנה הממוצע יהיה‬
‫‪(0+3+9+16)/4=7‬‬
‫אלגוריתם מס' ‪: 2‬הקצר ביותר ראשון ‪SJF -‬‬
‫‪- Shortest Job First‬‬
‫חיסרון האלגוריתם ‪:‬‬
‫תתכן הרעבה עבור התהליך בעל ‪Burst time‬‬
‫הארוך ביותר‪.‬‬
‫סיכום ‪:‬‬
‫אלגוריתם זה מבטיח ממוצע זמן המתנה אופטימאלי (בין‬
‫אלגוריתמים ה ‪)non-preemptive -‬‬
‫אלגוריתם מס' ‪ – 3‬זמן הריצה הקצר ביותר‬
‫)‪Shortest Remaining Time (SRT‬‬
‫• ראינו שבמערכות ‪ non-preemptive‬אלגוריתם‬
‫‪ SJF‬הוא היעיל ביותר אך‪ ,‬אם המערכת שלו‬
‫מאפשרת ‪ preemptive‬אם ניתן ליעל אותו ?‬
‫• אלגוריתם ‪ SRT‬מייעל את האלגורית ‪ SJF‬במערכות‬
‫‪.preemptive‬‬
‫אלגוריתם מס' ‪ – 3‬זמן הריצה הקצר ביותר‬
‫)‪Shortest Remaining Time (SRT‬‬
‫הסבר עיקרון האלגוריתם‪:‬‬
‫אלגוריתם זה בודק עבור כל תהליך חדש המגיע‬
‫לתור האם זמן ‪ Burst Time‬שלו קטן מהזמן‬
‫שנשאר לתהליך שרץ כעט עד לסיומו‬
‫(‪ ,)Remaining Time‬אם כן‪ ,‬יופסק התהליך הרץ‬
‫עכשיו וה‪ CPU-‬יימסר לתהליך שהיגיע ‪.‬‬
‫אלגוריתם מס' ‪ – 3‬זמן הריצה הקצר ביותר‬
‫)‪Shortest Remaining Time (SRT‬‬
‫דוגמא לפעולת האלגוריתם‬
‫נניח שמגיעים התהליכים האים לפי הסדר הבא ‪:‬‬
‫‪Burst‬‬
‫‪Arrival‬‬
‫‪8‬‬
‫‪0‬‬
‫‪Proces‬‬
‫‪s‬‬
‫‪p1‬‬
‫‪4‬‬
‫‪1‬‬
‫‪p2‬‬
‫‪9‬‬
‫‪2‬‬
‫‪p3‬‬
‫‪5‬‬
‫‪3‬‬
‫‪p4‬‬
‫התהליכים ירוצו בסדר הבא‪.P1, P2, P4, P1, P3 :‬‬
‫אלגוריתם מס' ‪ – 3‬זמן הריצה הקצר ביותר‬
‫)‪Shortest Remaining Time (SRT‬‬
‫כי ‪:‬‬
‫‪ P1‬יתחיל לרוץ בזמן ‪ 0‬מכיוון שהוא היחיד בתור‪.‬‬
‫ברגע ש‪ P2-‬מגיע ל‪ P1-‬נשאר פרץ ‪ CPU‬בגודל ‪,7‬‬
‫ולכן ‪ P2‬יתחיל לרוץ במקומו‪.‬‬
‫כאשר ‪ P3‬ו‪ P4-‬מגיעים פרץ הזמן שלהם גדול יותר מפרץ הזמן‬
‫שנותר ל‪ P2-‬ולכן אף אחד מהם לא גורם ל‪ P2-‬לעצור‪.‬‬
‫זמן ההמתנה של ‪ P2‬הוא אפס‪ ,‬זמן ההמתנה של ‪ P4‬הוא ‪( 2‬משום‬
‫שהוא מתחיל ביחידת הזמן ‪ ,5‬אבל הוא הגיע בזמן ‪ ,)3‬זמן‬
‫ההמתנה של ‪ P3‬הוא ‪ 15‬וזמן ההמתנה של ‪ P1‬הוא ‪.9‬‬
‫זמן ההמתנה הממוצע יהיה‬
‫‪(0+2+9+15)/4=6.5‬‬
‫אלגוריתם מס' ‪ – 3‬זמן הריצה הקצר ביותר‬
‫)‪Shortest Remaining Time (SRT‬‬
‫‪ SRT‬בהשוואה ל ‪SJF‬‬
‫אם באותה מערכת היינו עובדים עפ"י אלגוריתם ‪ , sjf‬התהליכים ירוצו בסדר הבא‪:‬‬
‫‪P1, P2, P4, P3‬‬
‫ זמן ההמתנה של ‪ – P1‬הוא ‪. 0‬‬‫ זמן ההמתנה של ‪ – P2‬הוא ‪( 7‬תהליך זה‬‫היגיע בזמן ‪ 1‬ולכן ‪) 8-1‬‬
‫ זמן ההמתנה של ‪ - P4‬הוא ‪ ( 9‬תהליך זה היגע‬‫בזמן ‪ , 3‬לכן ‪) 8+4-3‬‬
‫ זמן ההמתנה של ‪ – P3‬הוא ‪ ( 15‬תהליך זה הגיע בזמן ‪, 2‬‬‫לכן ‪) 8+4+5-2‬‬
‫זמן ההמתנה הממוצע יהיה‬
‫‪(0+7+9+15)/4=7.75‬‬
‫אלגוריתם מס' ‪ – 3‬זמן הריצה הקצר ביותר‬
‫)‪Shortest Remaining Time (SRT‬‬
‫בעיתיות האלגוריתם ‪:‬‬
‫• אלגוריתם זה מניח שתי הנחות‪:‬‬
‫‪ .1‬זמני ההחלפה בין התהליכים הם מהירים‪ ,‬ואינם‬
‫משפיעים על זמני ההמתנה‪.‬‬
‫‪ .2‬זמני הריצה בין ההחלפות הם ארוכים‪ ,‬כלומר‬
‫לא ייתכן מצב שבו רק מחליפים כל הזמן‪.‬‬
‫• לאור הנחות אלו ניתן לראות כי אלגוריתם זה אינו‬
‫ישים‪ ,‬והוא מתאר שיטה תיאורטית בלבד‪.‬‬
‫אלגוריתם מס' ‪- 4‬תזמון ע"פ עדיפות ‪-‬‬
‫‪Priority Scheduling‬‬
‫הסבר עיקרון האלגוריתם‪:‬‬
‫אלגוריתם זה נותן לכל תהליך עדיפות‪ ,‬וה‪CPU-‬‬
‫מוקצה לתהליך בעל העדיפות הגבוהה ביותר‪.‬‬
‫העדיפות נקבעת העדיפות נקבעת פעם אחת‪,‬‬
‫בכניסה אל המערכת‪ .‬אם לשני תהליכים יש את‬
‫אותה עדיפות‪ ,‬יעשה שימוש באלגוריתם ‪FCFS‬‬
‫לבחירת התהליך הראשון‪.‬‬
‫אלגוריתם מס' ‪- 4‬תזמון ע"פ עדיפות ‪-‬‬
‫‪Priority Scheduling‬‬
‫דוגמא לפעולת האלגוריתם ‪:‬‬
‫נניח שמגיעים התהליכים הבאים ‪ ,‬לכל תהליך עדיפות‬
‫(מס' נמוך עדיפות גבוהה )‬
‫‪Priority‬‬
‫‪3‬‬
‫‪Burst‬‬
‫‪10‬‬
‫‪Process‬‬
‫‪p1‬‬
‫‪1‬‬
‫‪3‬‬
‫‪4‬‬
‫‪2‬‬
‫‪1‬‬
‫‪2‬‬
‫‪1‬‬
‫‪5‬‬
‫‪p2‬‬
‫‪p3‬‬
‫‪p4‬‬
‫‪p5‬‬
‫התהליכים ירוצו בסדר הבא‪.P2, P5, P1, P3, P4 :‬‬
‫אלגוריתם מס' ‪- 4‬תזמון ע"פ עדיפות ‪-‬‬
‫‪Priority Scheduling‬‬
‫קביעת עדיפות‬
‫קיימות שני דרכים להגדיר עדיפות‪:‬‬
‫‪)1‬עדיפויות סטטיות‪ :‬קבועות לאורך כל ריצת התהליך‬
‫– למשל‪ :‬חשיבות בארגון‪ ,‬מחיר ששולם עבור השרות‬
‫– ב‪:UNIX-‬‬
‫• עדיפות ל‪kernel -‬‬
‫• פקודת ‪ nice‬להורדת עדיפות‬
‫‪) 2‬עדיפויות דינאמיות‪ :‬עפ"י צריכת משאבים‬
‫– עדיפות למי שצורך מעט ‪(I/O bound) CPU‬‬
‫אלגוריתם מס' ‪- 4‬תזמון ע"פ עדיפות ‪-‬‬
‫‪Priority Scheduling‬‬
‫חסרונות האלגוריתם ‪:‬‬
‫אחת הבעיות באלגוריתם מסוג זה היא הרעבה – מצב‬
‫שבו תהליך שמוכן לרוץ אינו מקבל את ה‪( CPU-‬מערכת‬
‫לא מסוגלת לזהות הרעבה)‪ .‬תהליך שנמצא במצב של‬
‫המתנה נחשב לחסום – ‪.Blocked‬‬
‫אלגוריתם עדיפויות עשוי לגרום לתהליכים בעלי עדיפות‬
‫נמוכה לחכות לנצח‪ .‬במקרה של מערכות הנטענות‬
‫בכבדות‪ ,‬תהליכים בעלי עדיפות גבוהה עשויים למנוע‬
‫מתהליכים בעלי עדיפות נמוכה גישה ל‪.CPU-‬‬
‫אלגוריתם מס' ‪- 4‬תזמון ע"פ עדיפות ‪-‬‬
‫‪Priority Scheduling‬‬
‫מנגנון הזדקנות כפיתרון להרעבה עקב עדיפות‬
‫כדי לפתור את בעיית הרעבת תהליך נפתח מנגנון הזדקנות‬
‫‪Aging‬‬
‫במנגנון זה מגדילים את העדיפות של התהליך ככל‬
‫שזמן ההמתנה שלו גדל‪.‬‬
‫ז"א הגדלה הדרגתית של עדיפות של תהליכים‬
‫הממתינים זמן רב‬
‫אלגוריתם מס' ‪ - 5‬תזמון סרט נע –‬
‫‪Round-Robin Scheduling‬‬
‫אלגוריתם זה עוצב במיוחד למערכת ‪ .time-sharing‬האלגוריתם דומה‬
‫לאלגוריתם ‪ ,FCFS‬אלא שהפעם ייתכן והתהליכים יוחלפו ביניהם תוך‬
‫כדי ריצה ‪.‬‬
‫עיקרון פעולת האלגוריתם‪:‬‬
‫מוגדרת יחידת זמן קטנה‪ ,‬הנקראת ‪.time quantum‬‬
‫מתייחסים אל תור ה‪ ready-‬כאל תור מעגלי‪.‬‬
‫מתזמן ה‪ CPU-‬עובר על התור ומקצה את ה‪ CPU-‬בכל פעם לתהליך‬
‫אחר לזמן של ‪.time quantum‬‬
‫בעת מימוש האלגוריתם‪ ,‬שומרים את תור ה‪ ready-‬בתור ‪.FIFO‬‬
‫תהליך חדש מתווסף תמיד לסוף התור‪.‬‬
‫מתזמן ה‪ CPU-‬בוחר בכל פעם את התהליך הראשון בתור‪ ,‬מגדיר‬
‫‪ timer interrupt‬שיופעל אחרי ‪ time quantum‬אחד‪ ,‬ומפעיל את‬
‫התהליך‪.‬‬
‫אלגוריתם מס' ‪ - 5‬תזמון סרט נע –‬
‫‪Round-Robin Scheduling‬‬
‫עיקרון פעולת האלגוריתם ‪-‬המשך‬
‫יכולים לקרות שני מקרים‪:‬‬
‫• התהליך עשוי להזדקק לפרץ ‪ CPU‬הקטן מ‪time -‬‬
‫‪ .quantum‬במקרה כזה התהליך עצמו ישחרר את ה‪-‬‬
‫‪ ,CPU‬והמתזמן ימשיך לתהליך הבא בתור‪.‬‬
‫• אם פרץ ה‪ CPU-‬לו זקוק התהליך גדול מ‪time -‬‬
‫‪ quantum‬אחד‪ ,‬ה‪ timer-‬יגרום ל‪Context .interrupt-‬‬
‫‪ switch‬יופעל‪ ,‬התהליך יועבר לסוף התור‪ ,‬והמתזמן‬
‫ייבחר את התהליך הנמצא בראש התור‪.‬‬
– ‫ תזמון סרט נע‬- 5 '‫אלגוריתם מס‬
Round-Robin Scheduling
: ‫דוגמא‬
0 ‫ כל התהליכים מגיעים בזמן‬,Q=4
p1
0
p2
4
Process
Burst time
p1
p2
p3
24
3
5
p3
7
p1
11
15
p3
p1
16
p1
20
p1
24
p1
28
p1
32
34
‫אלגוריתם מס' ‪ - 5‬תזמון סרט נע –‬
‫‪Round-Robin Scheduling‬‬
‫דוגמא ‪-‬המשך ‪:‬‬
‫חישוב זמן ההמתנה הממוצע ‪:‬‬
‫ זמן ההמתנה של ‪ – P1‬הוא ‪. 8‬‬‫ זמן ההמתנה של ‪ – P2‬הוא ‪4‬‬‫ זמן ההמתנה של ‪ - P3‬הוא ‪11‬‬‫זמן ההמתנה הממוצע יהיה‬
‫‪(8+4+11)/3=7.66‬‬
‫אלגוריתם מס' ‪ - 5‬תזמון סרט נע –‬
‫‪Round-Robin Scheduling‬‬
‫• יתרונות האלגוריתם ‪:‬‬
‫‪ .1‬שנפתרים מהר מתהליכים קצרים‪.‬‬
‫‪ .2‬אין הרעבה ‪.‬‬
‫‪ .3‬זמן תגובה מהיר ‪.‬‬
‫חסרונות האלגוריתם ‪:‬‬
‫‪.1‬הבעיה היא בעיקר בתהליכים שגדולים במעט מה‪time -‬‬
‫‪ ,quantum‬ואז עצירת התהליך לקרת סיומו מיותרת‪.‬‬
‫‪ .2‬זמן המתנה ממוצע גבוה (כי לא רגיש למאפיינים של התהליכים)‬
‫‪ .3‬מניח שכל התהליכים חשובים באותה מידה‬
‫‪ .4‬בצועים מושפעים מגודל ה‪: quantum -‬‬
‫– ‪ context switch‬חייב להיות קטן ביחס ל‪quantum -‬‬
‫– ‪ quantum‬ארוך פוגע ב‪response time-‬‬
‫אלגוריתם מס' ‪ - 5‬תזמון סרט נע –‬
‫‪Round-Robin Scheduling‬‬
‫הביצועים של האלגוריתם תלויים בצורה משמעותית בגודל ה‪:time quantum-‬‬
‫– אם ה‪ time quantum-‬מאוד גדול (מספר אינסופי)‪ ,‬נקבל אלגוריתם שמתנהג כמו‬
‫אלגוריתם ‪ .FCFS‬כלומר‪ ,‬זמן תגובה ארוך‪.‬‬
‫– אם ה‪ time quantum-‬הוא מאוד קטן‪ ,‬מתקבלת תפוקה נמוכה‪ ,‬משום שמערכת ההפעלה‬
‫עסוקה ב‪ ,context switching-‬מצב שבו ה‪ CPU-‬נמצא במצב סרק‪.‬‬
‫לכן‪ ,‬נרצה שה‪ time quantum-‬יהיה גדול תוך כדי התחשבות בזמן ה‪context -‬‬
‫‪ .switch‬אם זמן ה‪ context switch-‬הוא בערך ‪ 10‬אחוז מזמן ה‪,time quantum-‬‬
‫אזי עשר אחוז מהזמן ה‪ CPU-‬יבזבז על ‪.context switch‬‬
‫•‬
‫אחד מחוקי האצבע לבחירת גודל ה‪ time quantum-‬דורש בחירת ‪ quantum‬גדול‬
‫מספיק‪ ,‬כך שלפחות ‪ 80‬אחוז מפרצי ה‪ CPU-‬הדרושים יהיו קטנים ממנו (כלומר כ‪80-‬‬
‫אחוז מהתהליכים יכלו לרוץ מבלי שייאלצו להפסיק את פעולתם באמצע בגלל שה‪-‬‬
‫‪ quantum‬שלהם הסתיימה)‪.‬‬
‫‪ 100msec‬נחשב ל‪ quantum-‬סביר (ב‪)Unix -‬‬
‫אלגוריתם מס' ‪-6‬תזמון מרובה תורים‬
‫עם רמות ‪Multilevel Queue -‬‬
‫• קבוצה נוספת של אלגוריתמים לתזמון נוצרה עבור‬
‫מצבים בהם ניתן לחלק בקלות את התהליכים‬
‫לקבוצות‪ .‬לדוגמא‪ ,‬חלוקה מוכרת נעשתה בין‬
‫‪ foreground process‬לבין ‪background‬‬
‫‪ .process‬לשתי הקבוצות הנ"ל יש זמני תגובה‬
‫שונים‪ ,‬דרישות שונות וייתכן ויזדקקו למתזמנים‬
‫שונים‪ .‬בנוסף‪ foreground process ,‬עשויים‬
‫לקבל עדיפות על ‪.background process‬‬
‫אלגוריתם מס' ‪-6‬תזמון מרובה תורים‬
‫עם רמות ‪Multilevel Queue -‬‬
‫עיקרון פעולת האלגוריתם‬
‫אלגוריתם ‪ multilevel queue-scheduling‬מחלק את תור ה‪-‬‬
‫‪ ready‬למספר תורים נפרדים‪ .‬התהליכים מוקצים באופן קבוע‬
‫לאחד התורים‪ ,‬בד"כ על פי תכונות התהליך (לדוגמא גודל זיכרון‪,‬‬
‫עדיפות או סוג התהליך)‪ .‬לכל תור יש אלגוריתם תזמון משלו‪.‬‬
‫בנוסף קיים מתזמן בין התורים עצמם‪ .‬ברוב המקרים מתזמן זה‬
‫ממומש ע"י אלגוריתם ‪ preemptive‬של עדיפויות קבועות‪ .‬תור בעל‬
‫עדיפות נמוכה לא יתחיל לרוץ לפני שכל התורים שבעדיפות גבוהה‬
‫משלו יהיו ריקים‪ .‬אפשרות נוספת היא לחלק "פרוסות" זמן ( ‪time‬‬
‫‪ )slice‬בין התורים‪ .‬כל תור מקבל זמן ‪ CPU‬מוקצב אותו הוא מחלק‬
‫(עפ"י אלגוריתם התזמון בו עובד) בין כל התהליכים בתור‪.‬‬
‫אלגוריתם מס' ‪-6‬תזמון מרובה תורים‬
‫עם רמות ‪Multilevel Queue -‬‬
‫• דוגמת תורים במערכת מרובת תורים‬
‫אלגוריתם מס' ‪-6‬תזמון מרובה תורים‬
‫עם רמות ‪Multilevel Queue -‬‬
‫• יתרון ‪:‬‬
‫ניצול ה‪.CPU-‬‬
‫חיסרון ‪:‬‬
‫שתיתכן הרעבה‪ ,‬משום שאם התורים בעלי‬
‫העדיפות הגבוהה יותר לא מתרוקנים‪ ,‬לא נגיע‬
‫לתורים בעלי העדיפות הנמוכה‬
‫אלגוריתם מס' ‪-7‬תזמון מרובה תורים עם‬
‫מעבר ע"פ מאפייני פרץ ‪Multilevel -‬‬
‫‪Feedback Queue‬‬
‫• באלגוריתם ‪ multilevel queue‬תהליכים מוקצים‬
‫באופן קבוע לאחד התורים‪ .‬התהליכים לא עוברים‬
‫בין התורים‪ .‬הדבר מתאים למקרים כמו תורים‬
‫נפרדים ל‪ foreground process-‬ו‪background -‬‬
‫‪ ,process‬שכן התהליכים לא משנים את סוג‬
‫הריצה שלהם (ברקע או לא)‪.‬‬
‫אלגוריתם מס' ‪-7‬תזמון מרובה תורים עם‬
‫מעבר ע"פ מאפייני פרץ ‪Multilevel -‬‬
‫‪Feedback Queue‬‬
‫• עיקרון פעולת האלגוריתם‬
‫אלגוריתם ‪ Multilevel feedback queue‬מאפשר‬
‫לתהליכים לעבור בין התורים‪.‬‬
‫מפרידים את תהליכים עפ"י מאפייני פרץ ה‪ CPU-‬שלהם‪.‬‬
‫אם תהליך דורש זמן רב של ‪ ,CPU‬הוא יעבור לתור בעל‬
‫עדיפות נמוכה יותר‪.‬‬
‫שיטה זו משאירה תהליכים מונחי ‪ I/O‬ותהליכים‬
‫אינטראקטיביים בתורים בעלי עדיפות גבוהה‪ .‬באופן‬
‫דומה‪ ,‬תהליך שממתין יותר מידי זמן בתור בעל עדיפות‬
‫נמוכה יעבור לתור בעל עדיפות גבוהה‪.‬‬
‫שיטה זו של ‪ aging‬מונעת הרעבה‪.‬‬
‫אלגוריתם מס' ‪-7‬תזמון מרובה תורים עם‬
‫מעבר ע"פ מאפייני פרץ ‪Multilevel -‬‬
‫‪Feedback Queue‬‬
‫אלגוריתם זה מוגדר עפ"י הפרמטרים הבאים‪:‬‬
‫• מספר התורים‪.‬‬
‫• אלגוריתם התזמון עבור כל תור‪.‬‬
‫• השיטה על פיה מעלים תהליך לתור בעל עדיפות‬
‫גבוהה‪ /‬מורידים תהליך לתור בעל עדיפות נמוכה‪.‬‬
‫• השיטה על פיה קובעים לאיזה תור ייכנס תהליך‬
‫ברגע שהוא צריך שירות‪.‬‬
‫אלגוריתם מס' ‪-7‬תזמון מרובה תורים עם‬
‫מעבר ע"פ מאפייני פרץ ‪Multilevel -‬‬
‫‪Feedback Queue‬‬
‫• מבנה עקרוני של התורים באלגוריתם זה ‪:‬‬
‫‪– high priority-1 quantum‬‬
‫–‬
‫‪level 2 got 2 quanta‬‬
‫‪– level 3 got 3 quanta‬‬
‫‪– etc.‬‬
‫ככל שהתור גבוה יותר אז הוא בעדיפות גבוהה יותר => כלומר מקבל זמן ‪ cpu‬גדול‬
‫יותר‬