תוכרעמ Documents/__Saul_Coval... · (NFS) תורזובמ םיצבק תוכרעמ 12.11 mount תועצמאב םיכירדמ תבכרה 12.12 (תוסנתה תועש 5 + תוינויע

______________________________________________________________________________ - http://www.coval.net אסור לשכפול © כל הזכויות שמורות - מערכות מחשבים ® שאול קובל : עריכה

המכללה לטכנאים והנדסאים

להנדסת תוכנה ההמחלק

מערכות הפעלה

עזר יוחומר, בסיסי ריסאסול קורס מיםסיכו, סיכומי פרקי הלימוד, םתוכניות לימודי

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

.אתרי אינטרנטחוברות ופרסומים מ, שאול קובל

©SAUL COVAL – שאול קובל®

בלבד שאול קובל עבור השיעורים של המרצה Ver. 3.11 – 01/2010: מהדורה

11:01:01 - 2010דצמבר 07שלישי יום :עדכון - solaris_basics: קובץ

75מתוך 2עמוד הודעה על זכויות יוצרים – מערכות הפעלהב: קורס ' ת ב"פ :מכללת עמל_____________________________________________________________________________

______________________________________________________________________________ - http://www.coval.net לשכפולאסור © כל הזכויות שמורות - מערכות מחשבים ® שאול קובל : עריכה

מבוא למערכות הפעלה והעתקי שקפים אוסף מאמרי עזר

א"תשע כסלו' ל שלישי יום - 2010 דצמבר 07

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

. תודה מיוחדת לסטודנטים שאפשרו לי להשתמש בעבודתם

: סימן מסחריייחסות רק לתרגום לעברית ועריכה טכנית של אוסף המאמרים הזכויות השמורות עבור שאול קובל מת

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

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

. החוקיים . ש ליידי דיוויס"ע 'ב והופתח תק ,עמלרשת שיכפול וחלוקה לתלמידים באחריות של מכללת , הדפסה

Introduction to Operational Systems

An Assist Articles and Slides Collection December 7, 2010

Special Arrangement and Hebrew translations from technical pages of computer web sites, teacher curses, and manufacturers hand books, for Students of Amal

network of vocational schools College, Petah Tikva Beth Lady Davis. Special gratitude to my students who permit me to use their works

No part of this collection may be used or reproduced in any form by any means, or stored in a database or retrieval system. This collection is given to the students as is, without warranty of any kind, either expressed or implied, respecting the contents of this assist collection. Trademarks:

Trademarks and registered trademarks of products mentioned in this assist articles collection are held by the companies producing them. Use of a term in this collection should not be regarded as affecting the validity of any trademark, service mark or internet web site. All screen captures, internet web sites photographs in this collection are the property of the software manufacturers and web sites owners. Mention of any products in this collection in no way constitutes an endorsement by Saul Coval. Saul Coval privileges are only for the Hebrew Translation and Special Arrangements for the students use at college. Printing, reproduction and students distribution is the responsibility of AMAL College, Petach Tikva Beth.

75מתוך 3עמוד תוכנית לימודים – מערכות הפעלה: סקור ' ת ב"פ :מכללת עמל____________________________________________________________________________


Solaris -ו מבוא למערכת ההפעלה: תוכנית לימודים )שעות עיוניות 6(מבוא . 1

?מהי מערכת הפעלה 1.1 ,מערכת הפעלה, תכנית יישום, חמרה: סכמת מלבנים לתיאור עקרונות של מערכת מחשב המכילה 1.2

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

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

הגנה ואבטחה, הקצאת משאבים, גילוי שגיאות, בתקשורת מערכת אצווה מרובת תכניות , מערכת אצווה: התפתחות של מערכות הפעלה –היסטוריה 1.6

)multiprogramming Batched system( , מערכות לשיתוף זמנים)Time sharing( , מערכת .מערכות זמן אמת, מערכות מבוזרות, מערכות מקבילות, )personal-computer system(למחשב אישי

)שעות עיוניות 6(מבנים במערכת המחשב . 2 פ במחשב/פעילות ק 2.1 ופעילותן) Interrupts(פסיקות 2.2 )מכונה וירטואליות/ IOערוצי (מבנים של קלט ופלט 2.3 יםמבנים של אחסון נתונ 2.4 מנגנוני הגנת חמרה 2.5

)שעות התנסות 24+ שעות עיוניות Solaris 10 )72הכרת מערכת . 3 ?Unixמהי מערכת 3.1 Unixההיסטוריה של 3.2 מבנה גרעין מערכת ההפעלה 3.3 משתמשים וססמאות 3.4 כניסה ויציאה מן המערכת 3.5 )date, cal, who, echo(קודות ופקודות פשוטות מבנה פ 3.6 מבנה מערכת הקבצים 3.7 )…cd, pwd, ls, mv, cp, rm, link(פקודות לטיפול בקבצים ומדריכים 3.8 )ACLs (Access control lists" קינפוג" 3.9

הרשאות גישה, בעלות על קבצים ומדריכים: אבטחת מידע בקבצים 3.10 )vi/emacs – TBD(שימוש בעורך 3.11 scripts: Unix Shellשימוש ב 3.12 )pipes" (צינורות"הפניות ו 3.13 ניהול תהליכים 3.14 networking-מבוא ל 3.153.16 Power tools Solaris 10התקנת מערכת 3.173.18 Shell scripts

מערכות הפעלה

)שעות התנסות 5+ ניות שעות עיו 15(תהליכים . 4

מאפייני התהליך 4.1 .הסתיים, פעיל, ממתין, מוכן –מצבי תהליך 4.2 אופציונליים של תהליך/שדות חובה – process control block` ז"ת` - PCB: מזהה של תהליך 4.3 )Context Switch(החלפת משימות 4.4 Unix – fork()יצירת תהליכים ב 4.5 תורי מצבים 4.6 )Threads(תהליכונים 4.7



5.םיכילהת ןומיז ) 12תוינויע תועש + 5תוסנתה תועש ( התפישה הבסיסית של זימון תהליכים 5.1 )Unixלדוגמה מערכת הפעלה (ם "יע- אמות מידה לתזמון ה 5.2 FCFSזימון בשיטת 5.3 SJF בשיטות CPU-זימון ה 5.4 Round Robinזימון שוויוני 5.5 SRTFזימון לפי הזמן הקצר ביותר לסיום 5.6 הערכת זמן ריצה וזימון לפי עדיפויות 5.7 Unixריבוי תורים ודוגמאות לזימון ב 5.8

)שעות עיוניות Threads) (4(תהליכונים . 6 ?ומדוע הם נחוצים Threadsמהם 6.1 ההבדלים בין תהליך לתהליכון 6.2 תהליכוני משתמש לעומת תהליכוני מערכת 6.3 השוואת ביצועים 6.4

)שעות התנסות 4+ שעות עיוניות 12(תיאום בין תהליכים . 7 דוגמאות לבעיות תיאום 7.1 הגדרת קטע קריטי 7.2 מנעולים והדרכים למימושם 7.3 ני תיאום נוספיםמנגנו 7.4 )Dead Lock(בעיית הקיפאון 7.5 .זיהוי קיפאון ושיטות להימנעות מקיפאון ולטיפול בו 7.6

)שעות עיוניות 2(פסיקות . 8 סוגי פסיקות 8.1 טיפול בפסיקות 8.2 קלט באמצעות פסיקות: דוגמה 8.3

)שעות התנסות 2+ שעות עיוניות 4(ניהול זיכרון . 9 מטרות ניהול הזיכרון 9.1 מנגנונים לחיסכון בזיכרון ראשי 9.2 ).Unixלדוגמה מערכת הפעלה (מרחבי כתובות לוגיים ופיזיים 9.3 )רציפה- רציפה ולא(הקצאות זיכרון 9.49.5 Paging שלבי-שלבי ורב-חד השימוש באזורי זיכרון משותפים 9.6 Segmentationפתרון באמצעות 9.7 )שעות התנסות 15+ שעות עיוניות 15(הזיכרון בפועל . 10

מבנה הזיכרון 10.1 ?הזיכרון הווירטואלי מהו 10.2 דפדוף לפי דרישה 10.3 Page Fault -מנגנון ה 10.410.5 Page Replacement FIFOהחלפת דפים לפי 10.6 האופטימליהאלגוריתם 10.7 LRUאלגוריתם 10.8 אלגוריתמים של מנייה 10.9

הקצאת מסגרות קבועה ויחסית 10.10 זיכרון) Thrashing(דשדוש 10.11 סגמנטציה לפי דרישה 10.12

.Unixנושאים אלו יודגמו באמצעות מערכת הפעלה ·

)שעות התנסות 5+ שעות עיוניות 15(מערכת הקבצים . 11 מבנה מערכת הקבצים 11.1 תכונות של קבצים 11.2



צורות של ארגון נתונים 11.3 צורות של גישה לנתונים 11.4 שיקולים לבחירת הצורות 11.5 ציקלי-גרף א, עץ מכוון, רמות: מבנה מדריכים 11.6 סוגי קישורים 11.7

)שעות התנסות 5+ שעות עיוניות 24(מימוש מערכת הקבצים . 12 Unixמבנה מערכת הקבצים ומדריכים ב 12.1 היררכית האחסון 12.2 מבנה הדיסק 12.3 הקצאה רציפה: מיפוי קבצים 12.4 משורשרת, רציפה- הקצאה לא 12.512.6 File Allocation Table (FAT( אינדקס: מיפוי קבצים 12.7 Unix-מבנה מערכת הקבצים ב 12.8 קיבוץ, רשימה מקושרת, bitmap: הדיסק הפנויים ניהול שטחי 12.9

אמינות 12.10 )NFS(מערכות קבצים מבוזרות 12.11 mountהרכבת מדריכים באמצעות 12.12

)שעות התנסות 5+ שעות עיוניות 24(מערכת האחסון המשני . 13 הדיסק, מבנה יחידת האחסון 13.1 )IDE, SCSI(שיטות לתזמון פעילות הדיסק 13.2 ).Unixלדוגמה מערכת הפעלה ( Disk Management -ניהול דיסק 13.3 ).Unixלדוגמה מערכת הפעלה (ביצוע חלוקה של הדיסק 13.4

)שעות התנסות 2+ שעות עיוניות 7(רשתות ותקשורת . 14 המבנה הכללי של הרשת 14.1 ) Topology(שיטות קישור פיזיות 14.2 )LAN, WAN(תות כלליים סוגי רש 14.3 מנגנון השמות והכתובות 14.4 מניעת התנגשות מסרים ברשת 14.5 ISOשל OSIמודל התקשורת 14.6 IPפרוטוקול –תקשורת אינטרנט 14.7 socket-מושג ה, Unix-מימוש תקשורת ב 14.8

ביבליוגרפיה :ספרות עזרו ספרי לימוד

1 .A. Tanenbaum, Modern operating systems, 2nd edition. Prentice-Hall, Englewood Cliffs,

New Jersey, 2001 . 2 .W. Stallings, Operating systems, internals and design principles, Prentice-Hall, Englewood

Cliffs, New Jersey, 2000 . 3 .A. Silberschatz, P. Galvin and G. Gagne, Operating system concepts, John Wiley and Sons,

New York, 2001 . עריכה ב ריסאמבוסס על עבודות הגמר של מרצים למערכות הפעלה בקורס סול - סיכום קורס סולריס בסיסי. 4

.חיים צדוק' מרשל מקצועיתה :של המרצה שאול קובל ומתוך האתר האינטרנט שלו" מערכות הפעלה"חוברות ומצגות הקורס . 5

http://www.coval.net/www/downs.html

75מתוך 6עמוד חומר לימוד – מערכות הפעלה: קורס ' ת ב"פ :מכללת עמל____________________________________________________________________________

____________________________________________________________________________ http://www.coval.net- אסור לשכפול © כל הזכויות שמורות - מערכות מחשבים ® שאול קובל : עריכה

חומר לימוד מתוך סיכומי הרצאות של סטודנטים ומאתרי אינטרנט

הקדמה – 1פרק הגדרה -מערכת הפעלה

ם לבין היא אוסף של תוכניות שנועדה לנהל הקשר בין חומרת המחשב או רשת מחשבי – ?מהי מערכת הפעלהקובעת את סדר מערבת הפעלה . ומייצרת סביבת עבודה בה יכול המשתמש להריץ תוכניות .המשתמש ותכניותיו

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

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

:תפקידי מערכת ההפעלה

משנוחות למשת. יעילות.

:רכיבים 4-מערכת המחשב מורכבת מ

.רכיבי חומרה -1תוך ניצול יעיל של מערכת המחשב ומספקת סביבת , התוכנה והנתונים, מנווטת את החומרה –מערכת הפעלה -2

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

פוצרות את בקשות החישוב של המשתמשים כאשר יכולים להיות מספר משתמשים המנצלים את –אפליקציות -3 .המחשב לצרכים שונים

.נקודת הקצה שמפעילה את המערכת. לאו דווקא אדם. המשתמש –תחנת קצה -4

:הגדרות שונות למערכת ההפעלהResource Allocator – הקצאת משאבים.

Control Program – שליטה בתוכניות הרצות ובפעולות ה-I/O. Kernel – תוכנית אחת שרצה כל הזמן על המחשב בגרעין –גרעין.

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

Kernel mode אוmonitor mode – ערכת ההפעלה עובדת והמשתמש לא יכול לבצע דברמצב בו מ. User Mode – ה-CPU נמצא במצב שבוprocess -והמערכת לא יכולה לגשת , ים שהתקבלו מהמשתמש רצים

.לחומרה

מספר הגדרות חשובות

Program – אפליקציה היא מקרה פרטי של (תוכניות שנמצאת בדיסקprogram.( היא אוסף של הוראות ).הפנימי של המחשב במלאו או בחלקו.(ההוראות באות ברצף והן מאוחסנות בזיכרון .ידי המחשבהמוכרות על

Job = Process – כאשר תוכנית שנמצאת על הדיסק נכנסת לריצה היא הופכת ל-Process. הדברים מכלול . המוכנים לעיבוד, היא תוכנית יישום או מספר תוכניות יישום בצירוף הנתונים הדרושים עבורם

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

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

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



Computer Resources –אשר עומדים לרשות המחשב כדי שיוכל , הם כל ההתקנים במערכת המחשב, משאבי מחשבזיכרון ,זיכרון פנימי , מעבד: השייכים למערכת מחשב,דוגמאות להתקנים ). 'הרצת תוכניות וכד(לבצע את מטרותיו

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

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

entrant code .(תוכנית הבנויה מקבוצת הוראות המכילה ערכים שאינם משתנים במהלך ביצוע הקוד. Data - הנתונים הם ייצוג המציאות כפי שהיא באה לידי ביטוי במחשב .הם עובדות גולמיות בלתי מעובדות, נתונים.

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

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

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

CPU מעבד אחד בלבד/במקרה של ליבה( מתחלק בין כל התוכניות(. Multiprocessing – מקרה פרטי שלmultiprogramming – הדבר מאפשר . מערכת עם מספר מעבדים

.לתוכניות לרוץ במקבילMultitasking – מערכות שלsharing-Time .בנוסף . המחשב יודע לחלק את הזמן בין התהליכים בצורה מהיר מאוד

זהו מקרה פרטי של . לעבוד עם מספר משתמשים במקבילהדבר מאפשר . הוא יודע לחלק כל תהליך למשימותmultiprogramming.

Computerized Information System - מערכת המנהלת ומעבדת נתונים בעזרת יאה, מערכת מידע ממוחשבתואוסף של תוכניות המבצעות את , מערכות המידע מכילות אוסף נתונים המאוחסנים ביחידות אחסון חיצוניות. מחשב

מידע ממוחשבות הוא זמן התגובה של . מחשב אחד המאפיינים החשובים של מערכותזה . העיבוד ומפיקות את המידע :מבחינים בשלוש צורות עיבוד נתונים המערכת עיבוד אצווה = Batch Processing עיבוד מקוון = On Line Processing עיבוד בזמן אמת = Real Time Processing

Simple Batch Systems .ברצף, מערכת הצוברת את האירועים ומעבדת את כולם במכלול אחד - Batch Processing -מערכות אצווה

אירוע צבירה טפסים ניקוב עיבוד מידע

נתונים

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

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

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

.לאורך זמן) מכוונת או לא(תוכניות .סרק – Idleהיה במצב CPU-במשך זמן זה ה. זמן רבטעינת תוכנית לזיכרון לקחה , בעבר

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

.הקומפיילר לזיכרון

Automatic job sequencing – מערכת ההפעלה הבסיסית הראשונה אשר העבירה בצורה אוטומטית את הבקרה ).לא המתין לתוכנית שתחזור לפעולה CPU-וכך כאשר תוכנית עצרה ה(ממשימה אחת לשנייה



Resident Monitor – כאשר המחשב מופעל השליטה נמצאת אצל ה. נוצרה תוכנית קטנה שישבה תמיד בזיכרון -monitor .ה -monitor כאשר המשימה מסתיימת הבקרה חוזרת ל. מעביר את הבקרה למשימה הראשונה-monitor

. נתב את הבקרה למשימה הבאהאשר יודע ל

Control Cards איזה תוכנית , התעוררה הבעיה כיצד ידע המוניטור מה סוג המשימה הבא Resident Monitor-בעקבות יצירת ה .כיצד להבדיל בין משימות וכיצד להבדיל בין תוכניות לנתונים, להריץ בכל שלב

Resident -כרטיסים מיוחדים אשר אמרו ל – Control Cards-הפתרון היה שימוש בMonitor וכן , על כל כרטיס היה שם של משימה או פקודה לביצוע. איזה תוכנית להריץ

).נתון או תוכנית(תווים מיוחדים אשר ציינו מה סוג המידע על הכרטיס :Resident Monitor-בנוסף הכיל ה

1- Control Card interpreter - מפרש שתפקידו היה לקרוא וליישם את הפקודות שעל הכרטיסים. 2- Loader – טוען תוכניות לזיכרון. 3- Device drivers – מזהה תכונות ומאפיינים של כל התקןI/O.

Off-line operation מאוד איטית הטעינת הכרטיסים היית. לא יכלו לעבוד במקביל CPU-וה I/O-שהתקני ההבעיה החדשה שנוצרה היא

.והאטה את הביצועיםהמידע מהכרטיסים הועבר לטייפ : החליפו את קוראי הכרטיסים בטייפים מגנטים. Off-line operationהפתרון היה

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

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

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

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

.בו מאוחסנים נתונים למקום בו נמצאות הפקודות

Spooling Simultaneous Peripheral Operation On Line )SPOOL.(

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

.עובד על תהליכים אחרים CPU-ובינתיים ה, תפוס שמים את המידע על הדיסק CPU-כלומר כאשר ה

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

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

:מבצעת ההפעלה קוראת את המשימה הבאה לתוך שטח אחסון בדיסק)job queue.( מדפיסה פלט של משימה קודמת מהדיסק למדפסת.

Job Pool – מבנה נתונים המאפשר למערכת ההפעלה לבחור בכל שלב איזה משימה תרוץ בפעם הבאה.

Multiprogramming Batch Systems .תמיד יבצע עבודה CPU-המטרה שלנו היא שה. CPU-אחד יכול לרוץ ב processק בכל שלב ר

ברגע . לאחד מהם CPU-ומערכת ההפעלה דואגת בכל שלב לתת את ה, ים- processבזיכרון נשמרים מספר קריאה של – System Callלצורך כך הוא יבצע . I/Oמסוים מתחיל לרוץ הוא עשוי להזדקק להתקן process-ש

process במצב כזה ה. למערכת ההפעלה-CPU מפסיק לעבוד על ה-process , ומערכת ההפעלה פונה אל רכיבי



.עובד עליו CPU-אחר וה process-מעבירה מערכת ההפעלה את הפיקוח ל, בינתיים. החומרה הרלוונטייםמופסק ומערכת CPU-שנמצא ב process-ה. למערכת ההפעלה interruptהוא שולח , מסיים I/O-כאשר רכיב ה

.CPU-ים יקבל את ה- process-כעת לא ידוע מי מה. ההפעלה מטפלת במידע שהוחזר

:multiprogrammingדרישות ממערכת ההפעלה לצורך ניהול זיכרון כך שיוקצה מקום למספר משימות. CPU scheduling – בחירה מי מבין המשימות תרוץ כעת. הקצאת משאבים.

כותסוגים שונים של מער

1( Time-Sharing systems .עובד על מספר משימות הנמצאות בזיכרון CPU-ה

כאשר מערכת ההפעלה מסיימת הרצת משימה אחת . בין המשתמש למערכת on-lineמערכות בהן קיימת תקשורת .היא מקבלת את הפקודה הבאה מהמשתמש ולא מהכרטיס קורא

.שה לקוד ולנתוניםלצורך גי on-lineיש לספק למשתמש מערכת קבצים .למשתמש נעשה דרך מערכת ההפעלה processהמעבר בין

2( Personal-Computer systems .מחשב המיועד למשתמש אחד

3( Parallel Systems . מערכות שמשתמשות במספר מעבדים

.שעון ועוד, bus, זיכרון: המעבדים משתמשים במשאבים משותפים כגון :יתרונות

חלוקת העבודה בין מספר מעבדים –מהירות עבודה. במקום להפעיל מספר עמדות מחשב למספר משתמשים מחברים את כולם לאותו מחשב –יתרון כלכלי. יעילות ה-CPU )הפסקת מעבד אחד אינה גורמת להפסקת עבודת המערכת). אין הרעבה. :multiprocessingסוגי

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

Asymmetric multiprocessing - שיטתSlave-Master . ישנו מעבד ראשי שמקצה משימות למספר מעבדיםכי עלול , לרוב ישנו מעבד שתפקידו לקרוא ולאחסן את הקלט. ק לולכל מעבד יש את המשימות שמוקצות ר. משניים

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

.slaveי היותם מעבדי "שמספר מיקרו מעבדים מבצעים פונקציות מערכת ההפעלה ע4( Distributed systems

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

.גודל המעבדים אינו אחיד. מהיר או קווי תקשורת מהירים busי "ע :ם במערכות מבוזרותסיבות לשימושי

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

5( Real Time Systems - ות לבקרת זמן אמת מערכ)Real Time Processing( אותו כאשר מגיע זרם הנתונים יש לעבד. לרוב משתמשים במערכות אלו כאשר ישנו זמן מוגבל לביצוע פעולה

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

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

.ט"מערכת בקרה של מזל, מערכת טייס, להנחיית טילים



מבנה מערכות מחשב – 2פרק )Solaris(אריס לבציור דוגמה של מערכת סו :עם החומרה process-ר הכיצד מדב

Process

מערכת הפעלה

Device driver – תוכנה

Controller ) לכל רכיב ישcontroller(

Device

Computer system operation במטרה לאפשר גישה , busי "המחוברים ביניהם ע) device controller(ומספר בקרים CPUמערכת המחשב מכילה

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

)memory controller (שתפקידו לסנכרן את הגישה לזיכרון. )אוסף של תאי זיכרון עזר= buffer( .מקומי bufferלכל בקר יש

.ים השונים- buffer-מנתב מידע בין הזיכרון לבין ה CPU-התוכנית זו מאתחלת את כל . רוץשת) bootstrap program(הוא זקוק לתוכנית התחלתית , כדי שמחשב יתחיל לרוץ

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

Interrupt י שליחת "ע, יכול לקרות בכל שלב מחומרהsignal ל-CPU ,ויכול להיות מסוגים שונים .Interrupt .System Callי הוראה מיוחדת הנקראת "מהתוכנה מתבצע ע

, חלוקה באפס, I/Oשל פעולת השלמה, לדוגמא – interrupt-קיימים סוגים שונים של אירועים העשויים לגרום לשאחראית service interruptכזה קיימת interruptלכל . לשירותי מערכת ההפעלהגישה שגויה לזיכרון ובקשות

.interrupt-לטפל במקום קבוע זה מכיל ברוב . הוא מפסיק את פעולתו ומיד עובר לרוץ במקום קבוע, Interruptמקבל CPU-כאשר ה

CPU-ה, ובסיום, מתחילה לרוץ interrupt-ות של הרוטינת השיר. service routineהמקרים כתובות התחלה של . מחדש את הפעולה שהופסקה

Common functions of Interrupts - ניהול מערכת הפסיקות

:אבל קיימות מספר פונקציות משותפות, )פסיקות( ים- interrupt-כל מחשב מעצב לעצמו מנגנון טיפול ב, במהירות interrupt-מכיוון שיש לטפל ב. המתאימה service routine-חייב להעביר את הבקרה ל Interrupt-ה

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

. ים- interruptאותם בסיום פעולת . מערכת ההפעלה שומרת על כתובת החזרה וכן את מצב הרגיסטרים במערכת interruptכאשר מפעילים

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

Interrupt י תיעדוף לפי חשיבות ההתקן ממנו מגיע ה"וזאת ע-interrupt. .שיתעוררו במערכת כלומר היא מחכה לאירועים –) interrupt )Interrupt drivenמערכת ההפעלה היא מונחת

Trap – Interrupt י בקשה מפורשת של תוכנית משתמש לבצע שירות של "המתעורר כתוצאה משגיאת מערכת או ע . מערכת הפעלה



:Interrupt-תהליך הטיפול ב .החומרה מעבירה את הבקרה למערכת ההפעלה

.program counter-י שמירת ערכי הרגיסטרים וה"ע CPU-ירת מצב השמ :שהתקבל בעזרת שתי שיטות interrupt-קביעת סוג ה

polling – שואלים מי מההתקנים ביקש את ה. תשאול-CPU. ).היתרון בשיטה זו היא שלא מבזבזים זמן לשאול מי צריך( Vectored interrupt system-בעזרת ה

.interrupt-מציאת סגמנט הקוד המתאים לביצוע ה

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

.pollingזאת באמצעות

)Solaris(מנגנון הפסיקות בסולאריס ושתיארנמממשת את המנגנון , )Intel )x86מנגנון הפסיקות הינו תלוי בחומרה עבור פלטפורמה , בסולאריס, כללית

.SUNשל חברת SPARCאותו מנגנון עבור מעבד . Intelולארכיטקטורה PC-ומתאימה את עצמה לחומרת ה

כללי -פסיקות :נבחין בין שלושה סוגי פסיקות

.דיסק, מדפסת, מקלדת, שעון: דוגמאות. וניתסינכר- פסיקה אי: )hardware( חומרה – 1 .רמות שרות של פסיקות) system call(קריאת מערכת : דוגמאות. פסיקה סינכרונית ):software(תוכנה – 2 .נפילת מתח, page fault, 0 -חלוקה ב: דוגמאות. פסיקה סינכרוני: חריג – 3

פסיקות חומרה .הן אמצעי המאפשר להתקנים חיצוניים לקבל ולתת שירותים למעבד) hardware interrupt(פסיקות חומרה

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

). poolingלמשל (בדיקות חוזרות ונשנות

מנגנון בסיסי לטיפול בפסיקות .אותו היא בוחנת לאחר כל פקודת מכונה) interrupt request line( קו פסיקותלחומרת המעבד יש

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

.מבצעת את החישוב הנדרש לטיפול בפסיקה) ISR = interrupt service routine(שגרת הטיפול בפסיקות



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

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

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

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

.כתגובה הדרושה עם פריווילגיות של מערכת הפעלה

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

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

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

).מוחזר בדיוק למצב בו הופסק

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

).ISR = interrupt service routine(בכל פסיקה מטפלות 1024 הבתים הראשונים בזיכרון מוקדשים לווקטור הפסיקות. עבור ) סיביות 32(בתים 4כל כניסה בווקטור הפסיקות הינה בתsegment:offset. יפול בפסיקה מספר הכתובת לטN 4נמצאת בארבעת הבתים שמתחילים בכתובת*N.

לכן היא משתמשת ) MMX( 586-אולם מבנה וקטור הפסיקות שונה ב, 8086תוכננה לארכיטקטורה UNIX: הערה .הישן של ווקטור הפסיקות Intelבמודל

)סדר תהליכים(מנגנון הפסיקות .הוא שולח סימןכאשר התקן חיצוני רוצה להתקשר עם המעבד -1 )מורם IFבמידה ודגל הפסיקות (את קו הפסיקות בין כל שתי פקודות מכונה המעבד בודק -2 .המעבד מכבה את דגל הפסיקות ומבקש מההתקן אות זיהוי -3 ).250לבין Nמספר בין (ההתקן מחזיר בקו הנתנים את סוג הפסיקה -4נדחפים על ) cs:ip(כן כתובת הפקודה הבאה לביצוע ו) שלפני כיבוי דגל הפסיקות(הנוכחי flags-ערך רגיסטר ה -5

.המחסנית ).cs:ip(לתוך רגיסטר הפקודות N*4 כרוןיהמעבד טוען את תוכן תא ז -6 ).פקודות לטיפול בפסיקה( cs:ipהמעבד ממשיך לבצע פקודות החל מהכתובת -7 .iretהמכונה י פקודת"בגמר ביצוע הקוד לטיפול בפסיקה חוזר לפקודה שעמד לבצע לפני הפסיקה ע -8 ).cs:ip-בנוסף ל( flagsשכן היא צריכה לשחזר גם את retשונה מפקודת החזרה הרגילה iretפקודה -9

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

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

. int Nי פקודת המכונה "תוכנה מתבצעת ע פסיקת

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

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



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

mapinit : קוד פסיקהcontrol-break הקוד של שאר הפסיקות נקרא רק לאחר . מחליף את קוד הפסיקה הקודם .הקריאה לקוד הפסיקה המקורי

בסיוםUNIX וקטור הפסיקות למצבו כפי שהיה לפני העלאת מתבצע שחוזרUNIX )כדי ש-MSDOS תוכל ).לחזור לעבוד

Revectoring -ביצוע ה

:intcomובשגרת אסמבלר sys_impנעשה בשימוש ברשומות מערך וקטור הפסיקות מצביע על פקודתcall intcom הנמצאת בתוך הרשומה. כאשר מתבצעת פסיקה המעבד קופץ לפקודהcall intcom ומשם קופץ ל- intcom עצמה. intcom י "פקת עמבצעת את הקריאה לקוד הפסיקה המקורי ולפסיקה החליפית המסוUNIX.

Solaris -פקודות ב .Intelהפקודה גם עובדת במערכת עם מעבד . מציגה סטטיסטיקה של הפסיקות, )10החל מסולאריס ( intrstatפקודת

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

.הפסיקה של המעבד

:דוגמה ראשונהexample# intrstat

%tim cpu0 device

0.0 166 ata#0 0.0 0 ata#1 0.0 6 audioi810#0 0.7 281 i8042#0 0.0 6 iprb#0 0.0 6 uhci#1 0.0 6 uhci#2

tim – 100%שלעולם לא יהיה (כ "חוזי זמן עיבוד מסהא.(

Cpu0 – (סוג של תהליכים ). מספר נומרי(מעבד ראשוןthreads.( .עדכונים מופיעים פעם בשנייה ומתחדשים כל העת -

:דוגמה שנייה

# intrstat 1 5 )של המעבד ID(מספר מעבד = 1 .שניות לפני שתצא והצג סטטיסטיקה 5בצע = 5

):ך פלט מהניסיונות שלנומס( לדוגמה

tim cpu0 device% :שנייה 1לאחר 0.0 8 Ehci#0 0.0 8 Ehci#0 0.0 8 uhci#3 0.0 11837 uhci#3 0.0 12400 uhci#0

tim cpu0 device% :שנייה 2לאחר 0.0 10 Ehci#0



0.0 10 uhci#2 0.0 10 Ehci#0 0.0 16225 uhci#2 0.0 16344 uhci#3 0.0 3 uhci#0

tim cpu0 device% :שנייה 3לאחר 0.0 0 ata#1 0.0 10 ehci#0 0.0 10 uhci#1 0.0 10 Ehci#3 0.0 16225 uhci#0 0.0 17140 vfe#0

tim cpu0 device% :שנייה 4לאחר 0.2 10 Ehci#0 0.0 10 uhci#3 0.4 10 Ehci#0 0.0 141 uhci#1 0.0 16344 uhci#3 0.0 3 uhci#0

tim cpu0 Device% :שנייה 5לאחר 0.0 8 Ehci#0 0.0 8 Ehci#0 0.0 8 uhci#3 0.0 11837 vfe#0 0.0 12400 uhci#0

.Sunתוצרת חברת sparcרצה רק על מעבד – trapstat: פקודה שנייה

."not implemented on i86pc": ייתן את הפלט הבא PCניסיון הפעלה של

tureI/O Struc בודק את תוכנם , בתגובה, הבקר. טוען את הרגיסטרים המתאימים לתוך הבקר CPU-ה, I/Oכדי להתחיל פעולת

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

I/O-והבקרה תחזור למשתמש רק כאשר רכיב ה waitתהליך המשתמש עובר למצב של – סינכרוני -המקרה הפשוט . יסיים

:פעולת ההמתנה עשויה להתבצע בשני דרכים .במידה וקיים – waitמנגנון

I/O-שהוא למעשה ההודעה של רכיב ה, נוסף Interruptקבל הלולאה תמשיך לעבוד כל עוד לא מת –לולאה אינסופית .על סיום פעולתו

מתקדם בעבודה עם process-ה. תושלם I/O-העברת הבקרה לתוכנית המשתמש בלי לחכות שפעולת ה – סינכרוני-א . פעולות שהוא יכול לבצע בלי המידע שחסר לו

במקרה ואין תוכנית . שהסתיים I/O-שתאפשר לתוכנית המשתמש להמתין ל system call-במקרה כזה יש צורך בצריך , בנוסף. עדיין יש צורך במנגנון המתנה, או מערכת ההפעלה לא עושה שום דבר אחר/אחרת שצריכה לרוץ וכל כניסה – s tableDevice statuלצורך כך שומרת מערכת ההפעלה . רבות באותו זמן I/Oלעקוב אחרי בקשות

interrupt I/Oכאשר מתעורר . נשמרות בטבלה deviceהבקשות עבור כל . ומידע עבורו deviceבטבלה מציינת לצורך כך דואגת המערכת גם לנהל . מערכת ההפעלה בודקת מי ההתקן שגרם לכך ומעדכנת את הסטטוס שלו בטבלה

.deviceתור בקשות עבור כל .ממשיך לעבוד על דברים אחרים CPU-עובד ה I/O-בזמן שה. היתרון בשיטה זו היא היעילות



I/O Devices – פלט/התקני קלט Block Devices -מקטעי אחסון •

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

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

עוד התקנים • .דרך הזיכרון ממופותתצוגות , שעונים

בקרי התקנים Interface Components -רכיבי תאום •

Mechanical: םמכני .Bus –אפיק לוח מודפס מחבר ל ~ .כבל מחובר להתקן ~

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

Software: .של ההתקנים מתקשרים למערכת הפעלה) דריורים(מנהלי התקנים ~ .רים עם ההתניםמנהלים של רמה נמוכה מתקש ~ .CPU-אותות פסיקות של ה ~

מטרה • ).serial bit-stream into bytes or words(מעמירים סדרות טוריות של סיביות לבתים או מילים .תיקון שגיאות

Direct Memory Access (DMA) Structure יעביר את I/Oשל רכיב device controller-ה. ולהפך התקני חומרהדע מהזיכרון אל דואג להעביר מי DMA-ה

.CPU-המידע ישירות לזיכרון ולא יעבור דרך הנוגע DMA-ברגע שה. ים אחרים בזמן שהמידע עובר- processלעבוד בינתיים על CPU-המטרה היא לאפשר ל

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

).CPU-ל .ל"הוא רכיב חומרה האחראי לניהול הפעולות הנ DMA (Direct Memory Access)בקר



.Chip set -חלק מה, רכיב מתוכנת – קרבהוא מודיע לו לאיזה כתובת הוא מבקש , ההתקן מבקש מהמעבד גישה ישירה לזיכרון, הבקר יושב בין המעבד לזיכרון

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

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

Storage Structure Main Memory – הזיכרון היחיד איתו ה. המקום שבו תוכניות רצות. זיכרון ראשי-UCP יכול לעבוד בצורה ישירה . ).יכול לעבוד רק עליו CPU-וזוהי הסיבה שה, CPU-כמו ה(זהו זיכרון חשמלי :סוגים 2-זיכרון זה מתחלק ל

ROM - Read Only Memory – מכיל מידע הדרוש למערכת ההפעלה על מנת לעלות את . זמין לקריאה בלבד .מידע צרוב. לא נמחק כאשר המחשב נכבה. המחשב

RAM - Read Access Memory – נמחק עם כיבוי המחשב, זיכרון חשמלי. Secondary Storage – זיכרון מכני. הרחבות של הזיכרון הראשי המספקות יכולת אחסון מאוד גבוהה. זיכרון משני .

.interruptגישה אליו נעשית בעזרת Magnetic disks.

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

. בנוי ממספר סקטורים Trackכאשר כל . ים- Track-מ 4לרוב (ים באותו רדיוס נקראים צילינדר - Track-כל ה

Track -אוסף הצילינדרים מרכיב את הדיסק). ים בצילינדר. .הפלטות בדיסק כל הזמן מסתובבות

Disk device – עצמוהדיסק. Device driver – התוכניות שנמצאות במערכת ההפעלה

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

בלוק היא היחידה הקטנה ביותר אותה מערכת . בלוק . ההפעלה כותבת וקוראת ).4K= בלוק Windows(נייה כאשר גודל הבלוק משתנה ממערכת הפעלה אחת לש, הבלוקים נמדדים בבתים

? מה משפיע על מהירות המחשב

Transfer Rate – מעבר של מידע בין הדיסק למחשב. Positioning time – בנוי מ. יםבסקטור המתא, במקום הנכון) כותב/הראש קורא(זמן מיקום הזרוע -

Seek time – הזמן שלוקח להזיז את זרוע הדיסק לצילינדר הנכון. Rotational latency – סיבוב של הדיסק(הזמן שלוקח לסקטור המבוקש להיות מסובב עד לראש הקורא.(

Storage Hierarchy ההיררכיה מלמטה למעלה

.שמירת כמויות עצומות של מידע. שים לגיבוי בעיקרמשמ –טייפ .מהיר יותר –דיסק אופטי ).הוא לרוב דיסק מגנטי .H.D(דיסק מגנטי

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



Hardware Protection :עלה מספקת מספר הגנות על משאבים קריטיים במערכתמערכת ההפ

Mode operation-Dual – בשל השימוש במשאבי מערכת משותפים של מערכת ההפעלה . הגנה על מערכת ההפעלהי מצבי לצורך כך למערכת ההפעלה יש שנ. יש להבטיח שטעות בתוכנית אחת לא תגרור לטעויות בתוכניות אחרות

:עבודה• User Mode – רקuser יכול לרוץ. • Monitor mode – רק מערכת ההפעלה יכולה לרוץ. זה 0- ו user mode –זה 1כאשר , המציין מהו המצב הנוכחי – mode bit - ישנו ביט המתווסף לחומרת המחשב •

monitor mode.

.למערכת system callרוצה לגשת לחומרה הוא מעביר userכאשר . כל הזמן מתבצע מעבר בין המצביםI/O protection – כל פעולות ה-I/O גישה ל. מוגנות-I/O יש למנוע מהמשתמש לקבל . עוברת דרך מערכת ההפעלה

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

process מוקצה שטח בזיכרון וזהו השטח היחיד שה-process גישה לכתובת לא חוקית תגרור . יכול לגשת אליו .שגיאה

:יסטריםכאשר תוכניות רוצה לרוץ בזיכרון היא עובדת מול שני רג Base register – מציין עבור התוכנית מאיזה מקום היא תטען. Limit register – מכיל את הגודל המקסימלי של הזיכרון שמוקצה לתוכנית.

.התוכנית יכולה לרוץ רק בגבולות הכתובות של הרגיסטר :?כיצד מתבצע התהליך

.מקבל כתובת לפענוח CPU-הניסיון של – Trapיישלח . שגיאה –אם כן ). base +limit(-או גדולה מ base-בודק האם הכתובת קטנה מה CPU-ה

process לגשת למקום בזיכרון שלא מוקצה לו . .תתאפשר גישה לזיכרון –אחרת

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

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

process -ים להשתלט על ה-CPU )ין סופיתלדוגמא בלולאה א.( process-אם מערכת ההפעלה רואה ש. processאשר מודד שמן לכל Timerיש CPU-ל? כיצד מתבצעת ההגנה

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

General System Architecture - סיכום

במטרה , אילצו ליצור פיתוחים חדשים של הארכיטקטורה time sharing–ו multiprogramming-עקרונות ה .I/Oלאפשר למערכת ההפעלה לשלוט על המערכת ובייחוד על התקני

.interruptאן trapי "אשר מתעוררת ע system callנקראת I/Oבקשה של תוכנית משתמש לביצועי מערכת ההפעלה ניגשת לרוטינה המתאימה . מהמשתמש system callמערכת ההפעלה מקבלת : תיאור התהליךת מחזיר א, בזמן המתאים, מחזיר את המידע חזרה למערכת ההפעלה והיא I/O-ה. המתאים I/O-ומגישה בקשה ל .המידע למשתמש



מבנה מערכת ההפעלה – 3פרק

Systems Components התהליך מקבל . I/Oקבצים והתקני , זיכרון, CPUזמן : תהליך שרץ במחשב זקוק למספר משאבים – ניהול תהליכים

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

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

.יצירה ומחיקה של תהליכים .השעיה או הפעלה מחדש של תהליכים

.סנכרון ותקשורת בין התהליכים –מנגנון תזמון בין תהליכים :מערכת ההפעלה אחראית על – ניהול הזיכרון הראשי

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

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

:ההפעלה אחראית על .ניהול השטח הפנוי

.הקצאות .תזמון הדיסק

: מערכות אלו בנויות מ – I/Oניהול מערכות Buffer caching system.

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

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

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

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

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

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

. משאבי מערכת :גישה למשאבים משותפים מאפשרת

.האצת חישובים .הגדלת זמינות הנתונים

.הגברת האמינותCommand Interpreter System – קות חלק ממערכות ההפעלה מחזי. ממשק בין המשתמש למערכת ההפעלה

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



System Service-Operating השירותים שונים ממערכת . מערכת ההפעלה מייצרת סביבה להרצת תוכניות ומספק שירותים שונים לתוכניות אלו

:כ"והם בדר, הפעלה אחת לשנייה .טעינת תוכנית לזיכרון הראשי והרצתה –הרצת תוכניות

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

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

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

.מעקב סטטיסטי אחר המשתמשים במשאבי המערכת –חשבונאות .הגנות והרשאות

System Calls מספקת ממשק בין תוכניות רצות לבין מערכת System Call. פנייה ישירה למערכת ההפעלה לביצוע עבודה מסוימת

.לרוב בקשות אלו הן בשפת אסמבלי. ההפעלה :System Call- שיטות להעברת פרמטרים בין מערכת ההפעלה ל 3קיימות

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

.התוכנית תאחסן נתונים במחסנית ומערכת ההפעלה תשלוף אותם משם: שימשו במחסנית

:System Callקטגוריות של 5ישנן Process Control – בקרה על תהליכים .System calls אפשרות טעינת תהליך: הקשורים לשליטה על תהליכים ,

.fork, exec, wait: לדוגמא. שחרור משאבים ועוד, תנההמ, יצירת, הרצת תהליךFile manipulation – סגירה וחיפוש, פתיחה, מחיקה, יצירה: עבודה עם קבצים וספריות.

Device manipulation – ניהול ההתקנים. תחזוקת המידע

תקשורת

System Programs והן מאפשרות , תוכניות אלו מגיעות עם מערכת ההפעלה). lsלדוגמא (שורת הפקודה תוכניות שירות שניתן להפעיל מ

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

.user mode-מתאפשר עבודה עם משאבי המערכת כאשר מדובר ב .system callהתוכניות עצמן הן למעשה אוסף של

System Structure MS-DOS – כאשר כל שכבה יכולה לגשת לכל , שכבות 4יש : חסרת מבנה מאורגן. מבנה פשוט של מערכת הפעלה

הכל יותר פשוט כי אין צורך . תוכניות בודדות מאפשרת להריץ. השכבות האחרות ולכן אין כאן היררכיה של שכבות .לטפל בהגנות

UNIX – הגרעין מחולק ל. מבנה מערכת ההפעלה מורכב מגרעין ותוכניות מערכת-device drivers וממשקיהם . system callsוניהול מערכת קבצים בתיווך CPUתזמון , ניהול זיכרון: הגרעין מספר. שהורחבו בהמשך



.חומרה> - גרעין > - user: בותחלוקה לשלוש שכ

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

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

כאשר נמצאת שגיאה באחת הרמות השגיאה נובעת מהרמה הנוכחית היות והרמות . debugging, מודולריות: יתרונות .התחתונות נבדקו והן תקינות

. מצריך תכנון זהיר )1 :חסרונותכל שכבה . ר את המידע בין השכבותכאשר יש להעבי, על מנת לבצע פעולה יש לרדת בשכבות )2

.ל"עלולה לשנות את המידע הנ

3.19שקף User

פלט/מעבר מידע בין רכיבי קלט ים לצורך טיפול בבקשות- device-מערכת ההפעלה משתמש ב

ניהול זיכרון CPUתזמון חומרה

Virtual Machines ניתן להריץ בכל סוג javaלדוגמא תוכניות . במקום אחר הרעיון במערכות אלו הוא שניתן להפעיל תוכניות שיושבות

.ולא חשוב לו על איזה מערכת הפעלה הוא רץ, הוא זה שמריץ את התוכנית Interpreter-ה. של מערכת הפעלה

Process C

Process B

Process A

Kernel Kernel Kernel Virtual Machine

Hardware

.פעלה כחלק אחדמתייחסים לחומרה ולמערכת הה . multi processמערכת ההפעלה יוצרת אשליה של

System Design And Implementation :כאשר מתכננים מערכת הפעלה יש לבצע

.אמינה ועוד, נוחה, קלה ללמידה ולשימוש – user-הגדרת המטרות מצד ה .גמישה ועוד, נהאמי, יעילה, נקייה מטעויות, ללא שגיאות – system-הגדרת המטרות מצד ה

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

כיון ניתן לכתוב בשפות עיליות או בשילוב שפת מכונה ). אסמבלי(כ בשפת מכונה "מימשו מערכת ההפעלה נעשה בדר . ושפה עילית

מערכת ההפעלה



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

System Generation יש לספק למערכת , לכן. כ מערכת הפעלה מתוכננת לרוץ על מספר פלטפורמות ובמספר מחשבים ומספר אתרים"בדר

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

Booting – לרוב מערכות המחשב יש פיסות זיכרון המאוחסנות ב. הודעה לחומרת המחשב להעלות את הגרעין -ROM תהליך זה נקרא . עיןהיודעות לאתר את הגרbootstrap program.



תהליכים – 4פרק

Process Concept Job = Process – תוכנית בזמן ריצה.

Process כולל בתוכו: Program counter.

.מחסניתData section.

: processמצבי New – ברגע שה-process נוצר.

Running – ה-process בזמן נתון רק . מריץ פקודותprocess אחד יכול להימצא במצב זה. Waiting – ה-process ממתין ל-event ) לרובI/O .(ממצב זה לא ניתן לעבור לריצה.

Ready – ה-process ממתין לקבל את ה-CPU .מוכן לעבודה. Terminated – ה-process הסתיים.

ברגע שמגיע תורו של התהליך הוא .readyומיד הוא עובר למצב של , Newהוא process-המצב הראשוני של ה :כעת יכול לקרוא אחד מהמקרים הבאים. runningעובר למצב של .readyהתהליך יחזור למצב של –התקבלה פסיקה .waitingהתהליך יעבור למצב – I/Oמסוים או פעולת event-התהליך זקוק ל

.terminatedיעבור למצב –התהליך מסתיים .ברגע שהמידע שהוא המתין לו חזר readyליך יחזור להיות התה waitingמשלב של

Process Control Block - PCB :PCB-בין היתר כולל ה. המכיל מידע המשויך לתהליך מסוים, PCBי "כל תהליך מיוצג במערכת ההפעלה ע

.מצב התהליךProgram Counter – י התהליך"צע עכתובת הפעולה הבאה שצריכה להתב.

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

CPU scheduling information – תזמוןמצביע לתור התזמונים ופרמטרים נוספים של , עדיפות התהליך. .טבלת הדפים ועוד, limit register-ו base register-כולל בין היתר ערך ה –מידע על ניהול זיכרון

Accounting information – בכמהCPU מספרי תהליכים ועוד, גבולות זמנים, הוא משתמש. .וחיםרשימת קבצים פת, רשימת התקנים בהם משתמש התהליך – I/Oמצב

Process Scheduling

terminatednew

ready

waiting

running

admitted interruptexit

scheduler dispatch

I/O or event waitI/O or event completion

terminatednew

ready

waiting

running

admitted interruptexit

scheduler dispatch

I/O or event waitI/O or event completion



תהליכים . תור זה מכיל את כל התהליכים במערכת. job queue-הוא נכנס לתוך ה, ברגע שתהליך נכנס למערכתרשימה זו . ready queueשנמצאים בזיכרון הראשי ומוכנים לריצה או ממתינים לריצה נשמרים ברשימה הנקראת

הראשון והאחרון ברשימה PCB-ראש הרשימה יכיל מצביעים ל. תנשמרת לרוב במבנה נתונים של רשימה מקושר ).הבא אחריו PCB-יכיל בנוסף מצביע ל PCBכל (

).או סיבה אחרת interrupt(תהליך חוזר לתור בגלל החלטה של מערכת ההפעלה **

:סיכום התורים הקיימים במערכתJob queue – תור שלsproces -ים שרוצים להיכנס לריצה.

eReady queu – התור של הזיכרון .Process -מכאן התהליכים נכנסים לזיכרון והם . ים שיקבלו הרשאה לריצה .זמינים לריצה

I/O waiting queue – ברגע שמתקבל פעולת ה. תהליכים שמחכים-I/O וזר לתור של הדרושה התהליך חready.

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

Long term scheduler – נקרא גםjob scheduler . המתזמן של התורjob queue .תהליכים יעבור מחליט אילוגישה בטווחים של שניות או אפילו . מקור השם הוא בכך שהדגימות בתור זה נעשות בדחיפות נמוכה. readyלמצב .דקות

.שולט בכמות התהליכים שאני מוכנה להריץ במקבילShort term scheduler – נקרא גםCPU scheduler . המתזמן של התורeady queuer . מחליט מי מהתהליכים

.מידע יוצא ונכנס מהזיכרון מצורה מהירה מאוד. הדגימות מאוד מהירות. CPU-יקבל את ה .ההבדל העיקרי בין שני המתזמנים הוא תדירות הגישה עליהם

Ready queue

I/O waitingQueue(s)

CPU

Job queue

enter

I/O

end

**

Long term Short term

Ready queue

I/O waitingQueue(s)

CPU

Job queue

enter

I/O

end

**

Ready queue

I/O waitingQueue(s)

CPU

Job queue

enter

I/O

endReady queue

I/O waitingQueue(s)

CPU

Job queue

enter

I/O

end

**

Long term Short term



ם מוגדרים רוב התהליכי, באופן כללי. את התהליכים long term scheduler-חשוב מאוד לשים לב לצורה בה בוחר ה :CPU boundאו I/O bound-כ

I/O bound process – תהליך שכל הזמן זקוק ל-I/O . תהליך מסוג זה נמצא הרבה במצבwaiting. CPU bound process – תהליך שצריך כל הזמן פעולותCPU.

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

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

.בדיסק שיהיה מיועד לכך partitionאחרת ניצור ,)מהיר יותר וגישה מהירה יותר, דיסק שמיועד לכך( swap disk-ל swap-inברגע שמתפנה מעט מקום מבצעים . מעבירים את כל התהליך החוצה – swap-outפעולת ההוצאה נקראת

.ready queue-והתהליך חוזר ל

Context switch . של התהליך החדש וטעינת המצב, לתהליך אחר דורשת שמירת המצב הקיים של התהליך הישן CPU-החלפת ה

?מה קורה בתהליך זה. context switchפעולה זו נקראת שם לוגי ולא – File/process control block(לכל תהליך יש מספר טבלאות ששומרות את סביבת העבודה שלו

. כאשר תהליך נסגר טבלאות אלו נשמרות במערכת ההפעלה). ספציפי למערכת הפעלהואז מערכת ) monitor mode(הוא מחזיר את הבקרה למערכת ההפעלה . user mode-תהליך שמופעל כרגע נמצא ב

.ההפעלה טוענת את הטבלאות ומחזיר את הבקרה למשתמש .המערכת לא עובדת בזמן תהליך זה – overheadפעולה זו היא

Operation On Processes

יצירת תהליך )1 .המתאים system call-תוך כדי שימוש ב, הליך אב יכול ליצור מספר תהליכי בןת

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

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

.תהליך בן יכול לקבל פרמטרים מהאב :כאשר אב יוצר תהליכי בן

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

:קימות שתי אפשרויות לגבי מרחב הכתובות של התהליך החדש

.תהליך הילד הוא שיכפול של האב . קיימת תוכנית הנטענת אל תהליך הבן

סיום תהליך )2 exit-תוך שימוש ב, לה להפסיק אותוהוא שולח בקשה למערכת ההפע, כאשר תהליך מסיים את הפקודה האחרונה שלו

system call .בעזרת (התהליך עשוי להחזיר נתון לתהליך האב שלו , בנקודה זוwait system call .( כל משאבי . י מערכת ההפעלה"משוחררים ע) ועוד I/O buffers, קבצים פתוחים(התהליך

, ברוב המקרים). abortלדוגמא (המתאים system call-ר תוך שימוש בתהליך עשוי לגרום להפסקתו של תהליך אחsystem call אחרת משתמשים היו יכולים להרוג (י תהליך האב של התהליך שמופסק "מסוג זה עשוי להיקרא רק ע

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



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

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

).הבנים וגם הבנים שלהם מסתיימים

Cooperating Processes :סוגי תהליכים 2קיימים

Independent process – הכוונה היא שהם לא . תהליכים לא תלויים ולכן הם לא מושפעים מתהליכים אחרים .ועוד I/Oגעים באותו לא נו, נמצאים באותו מקום בזיכרון

Cooperating process – לדוגמא קובץ משתוף. תהליך המושפע במריצה של תהליך אחר. תהליכים שיתופיים . ).bufferלמשל (אפשרות אחרית שהיא שהמידע המשותף יהיה בזיכרון . I/Oי "האזור המשותף מנוהל ע

:מתי יש צורך בשיתוף תהליכים .שיתוף מידע

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

.נוחות

איך תהליכים מדברים ביניהםMessage passing – כלומר התהליכים . קורא מאותו אזור' כותב לתוך אזור במערכת ההפעלה ותהליך ב' תהליך אהוא דוגמא Unix-ב| - שימוש ב. א עובר ישירות ביניהם אלא דרך מערכת ההפעלהאבל הוא ל, מעבירים ביניהם מידע

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

).שנמצא במקום ששניהם הגדירו(אחראים לבד על המידע

צרכן-בעיית היצרן :אפשרויות 2קיימות . י תהליך היצרן"תהליך הצרכן צורך מידע שמיוצר ע: יות בין תהליכיםדוגמא לשיתופ

Unbounded buffer – היצרן ממשיך לייצר מידע. מאגר לא מוגבל. Bounded buffer – כאשר הוא מתמלא היצרן צריך להמתין שהצרכן ירוקן אותו. מאגר מוגבל.

.אלגוריתם – 4.14/15שקף

Threads Thread =lightweight process – היחידה הקטנה ביותר שיכולה לרוץ ולהשתמש ב-CPU .מכילה:

Program counter. Register set. Stack space.

:ים והם חולקים יחד- threadבכל תהליך יש מספר Code section. Data section.

Operating system resources. כלומר (אחד נחסם thread-בזמן ש. Context switch-נה מעורבת בתהליך ולכן אין כאן צורך במערכת ההפעלה אי

.שיטה זו יעילה יותר ובעלת ביצועים טובים. אחר באותה משימה יכול לרוץ thread, )הוא מחכה ולא רץ כרגע



IPC -Process Communication -Inter . receive- ו sendהפעולות הבסיסיות הם . הודעות שיטה נוספת עבור תהליכים לדבר ביניהם בעזרת

ביניהם והם מחליפים הודעות בעזרת הפקודות communication linkכאשר שני תהליכים רוצים לדבר נוצר :סוגי תקשורת 2קיימים . הבסיסיות

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

.סטריתהליכים יכולים לתקשר . לכל תיבה יש מספר ייחודי. שליחת ההודעות נעשית לתוך תיבות דואר – תקשורת עקיפה

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

?מה קורה כאשר תהליך אחד שולח הודעה ושני תהליכים אחרי מנסים לקבל –בעיה בשיטה זו ; receiveכול לבצע פעולת בכל שלב רק תהליך אחד י) 2; לאפשר קשר רק בין שני תהליכים) 1: פתרונות אפשריים

.והשולח יקבל הודעה מי קיבל את המידע, המערכת תבחר את המקבל בצורה אקראית) 3

Buffering :ניתן לממש בדרכים הבאות. עבודה עם תור של הודעות

Zero capacity – כלומר אין בעצם . הודעות 0מקסימוםbuffer השולח חייב לחכות למקבל לפני . ששומר הודעות .שהוא שולח

Bounded capacity – מקסימוםn כאשר התור מלא השולח צריך לחכות שהתרו יתרוקן. הודעות בתור. Unbounded capacity – השולח אך פעם לא צריך לחכות. התור אינסופי.



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

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

.שהתהליך השני הסתיים :פתרונות אפשריים – הודעות אבודות

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

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

.במקרה זה מערכת ההפעלה תשלח את ההודעה בשנית. לזיהוי התקלה checksum, parityשימוש – ויותהודעות שג



CPUתזמון – 5פרק

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

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

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

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

CPU-I/O Burst Cycle , כמו כן. כאשר כל הזמן התהליך עובר בין השניים, I/O-והמתנה ל CPU-ריצת תהליך מורכבת ממעגל של ריצה ב

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

CPU Scheduler ולתת לו לרוץ על ready queue-מערכת ההפעלה חייבת לבחור תהליך מתוך ה, נכנס למצב של סרק CPU-ברגע שה

.FIFOתור זה אינו בהכרח תור . CPU-ה :החלטות המתזמן עשויות לקרות באחד מארבעת הנסיבות הבאות

.כאשר תהליך עובר ממצב ריצה למצב המתנה .readyכאשר תהליך עובר ממצב ריצה למצב

.readyכאשר תהליך עובר ממצב המתנה למצב .כאשר תהליך מסתיים

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

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

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

זמן –תזמון מסוג זה גורם לעלויות . אחד עבור תהליך בעל עדיפות גבוהה יותר . בעיה נוספת במערכת מסוג זה היא הסנכרון. context switch-ה



Dispatcher module יר את הבקרה של הזה מעב-CPU י ה"לתהליך שנבחר ע-short-term scheduler .פעולה זו כוללת:

Switching context. .user mode-מעבר ל

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

.dispatch latencyלהפסיק את התהליך הרץ ולהתחיל בהרצת תהליך חדש נקר

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

:הם CPUהקריטריונים בהם משתמשים להשוואות אלגוריתמים של מתזמני במערכת . אחוז 100-אחוז ל 0- יכול לנוע מ CPU-ניצול ה. עסוק כל הזמן CPU-נרצה לוודא שה – CPUניצול

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

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

.I/Oוהפעלת CPU-ריצה ב, readyהמתנה בתור , הזמנים שהתהליך בזבז בהמתנה לזיכרוןאלא רק על הזמן שתהליך מעביר , I/O-יך רץ או משתמש בהאלגוריתם אינו משפיע על הזמן בו תהל – זמן המתנה

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

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

.לא כולל את זמן התגובה עצמו

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

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



Scheduling Algorithms

1( FCFS - First Come, First Served הדרך הפשוטה ביותר לממש אלגוריתם זה היא בעזרת תור . מוקצה ראשון לתהליך הראשון שביקש אותו CPU-ה

FIFO .ברגע שתהליך נכנס ל-ready queue ,ה-PCB כאשר ה. שלו מקושר לזנב התור-CPU הוא מוקצה , פנוי .לתהליך שנמצא בראש התור

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

24 P1 3 P2 3 P3

:נקבל את המצב הבא, P1, P2, P3: על פי הסדר הבאאם התהליכים הגיעו

. 27יהיה P3וזמן ההמתנה של , 24יהיה P2זמן ההמתנה של , )משום שהוא התחיל מיד( 0יהיה P1זמן ההמתנה של . 17=3/(0+24+27)זמן ההמתנה הממוצע שמתקבל הינו

3=3/(0+3+6)וצע שהיה מתקבל הוא זמן הממ, P2, P3, P1: אם התהליכים היו מגיעים בסדר הבא, לעומת זאת ).6הוא P1ובזמן ההמתנה של 3הוא P3זמן ההמתנה של , לא ממתין P2כאשר (

כאשר כל התהליכים ממתינים לתהליך אחד ארוך שיסיים עם convoy effectעשוי להיווצר מצב של . CPU-ה

התהליך מחזיק בו עד לרגע שבו הוא משחרר , מוקצה לתהליך CPU-ברגע שה. non-preemptiveאלגוריתם זה הוא .אותו

המשותף במרווח CPU-בהם חשוב שכל משתמש יקבל את ה, time-sharingאלגוריתם זה בעיקר בעייתי במערכות .רגיל

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

2( SJF - Shortest Job First הוא מוקצה , נגיש CPU-ברגע שה. הבא שלו) CPU )CPU Burst-אלגוריתם זה מקשר לכל תהליך את אורך פרץ ה

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

CPU ,אלא רק לפרץ ה-CPU הבא.

.מינימלי זהו אלגוריתם אופטימלי הנתון זמן המתנה :נסתכל על הדוגמא הבא

Burst timeProcess6 P1 8 P2 7 P3 3 P4

זמן , לא ימתין P4: זמני ההמתנה יהיה. P4, P1, P3, P2: שימוש באלגוריתם זה יתזמן את התהליכים בסדר הבאזמן ההמתנה הממוצע יהיה . 16יהיה P2וזמן ההמתנה של 9יהיה P3זמן ההמתנה של , 3יהיה P1ההמתנה של

).10.25של היה נותן זמן המתנה FCFS-בעוד שאלגוריתם ה( 7=4/(3+16+9+0)-nonהדוגמא שהוצגה לעיל הציגה אלגוריתם . preemptiveאו non-preemptiveאלגוריתם זה יכול להיות

preemptive .אפשרות הבחירה מתעוררת כאשר מגיע תהליך חדש לתור ה-ready התהליך . בזמן שתהליך אחד רץיאפשר לתהליך preemptiveאלגוריתם . קצר יותר מזה שנשאר לתהליך שרץ CPUהחדש יכול להיות עם פרץ

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

Shortest remaining time first (SRTF).



:לדוגמאBurst TimeArrival TimeProcess

8 0 P1 4 1 P2 9 2 P3 5 3 P4

. P1, P2, P4, P1, P3: התהליכים ירוצו בסדר הבא SRTFבאלגוריתם

P1 ברגע ש. מכיוון שהוא היחיד בתור 0יתחיל לרוץ בזמן-P2 ל מגיע-P1 נשאר פרץCPU ולכן , 7בגודלP2 יתחילולכן אף אחד מהם לא P2-מגיעים פרץ הזמן שלהם גדול יותר מפרץ הזמן שנותר ל P4-ו P3כאשר . לרוץ במקומו

, 5משום שהוא מתחיל ביחידת הזמן ( 2הוא P4זמן ההמתנה של , הוא אפס P2זמן ההמתנה של . לעצור P2-גורם ל .9הוא P1וזמן ההמתנה של 15הוא P3זמן ההמתנה של , )3אבל הוא הגיע בזמן

.7.75היה non-preemptive SJFזמן ההמתנה הממוצע באלגוריתם . 6.5זמן ההמתנה הממוצע המתקבל הוא :אלגוריתם זה מניח שני הנחות

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

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

3( Priority Scheduling אם לשני תהליכים יש . מוקצה לתהליך בעל העדיפות הגבוהה ביותר CPU-וה, יפותאלגוריתם זה נותן לכל תהליך עד

.לבחירת התהליך הראשון FCFSיעשה שימוש באלגוריתם , את אותה עדיפות CPU-בעל פרץ ה. הבא CPU-בו העדיפות נקבעת על פי פרץ זמן ה, הינו אלגוריתם עדיפות פשוט SJFאלגוריתם

.הגבוה ביותר הינו בעל העדיפות הנמוכה ביותר ולהפך . non-preemptiveאו preemptiveאלגוריתם זה עשוי להיות

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

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

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

.ו גדלשיטה בה מגדילים את העדיפות של התהליך ככל שזמן ההמתנה של – Agingהפתרון לבעיית ההרעבה הוא

4( Round-Robin Scheduling אלא שהפעם ייתכן , FCFSהאלגוריתם דומה לאלגוריתם . time-sharingאלגוריתם זה עוצב במיוחד למערכת

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

quantum . -מתזמן ה. תהליך חדש מתווסף תמיד לסוף התור. FIFOבתור ready- שומרים את תור ה, בעת מימוש האלגוריתם

CPU מגדיר , ראשון בתורבוחר בכל פעם את התהליך הtimer interrupt שיופעל אחריtime quantum אחד , :כעת יכולים לקרות שני מקרים. ומפעיל את התהליך

, CPU- במקרה כזה התהליך עצמו ישחרר את ה. time quantum-הקטן מ CPUהתהליך עשוי להזדקק לפרץ .ורוהמתזמן ימשיך לתהליך הבא בת

interrupt .Context switch-יגרום ל timer-ה, אחד time quantum-לו זקוק התהליך גדול מ CPU-אם פרץ ה .והמתזמן ייבחר את התהליך הנמצא בראש התור, התהליך יועבר לסוף התור, יופעל

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

.ואז עצירת התהליך לקרת סיומו מיותרת, time quantum-מה . כ ארוך"זמן ההמתנה הממוצע הינו בדר



מזמן n/1אזי כל תהליך יקבל , qהוא time quantum- וה ready-תהליכים בתור ה nבמצב שבו יש יחידות זמן עד לפעם הבאה בו n-1)*q(-כל תהליך יחכה לא יותר מ. אחיד לומר זמן תגובהכ. qבכפולות של CPU-ה

.CPU-יקבל את ה :time quantum-הביצועים של האלגוריתם תלויים בצורה משמעותית בגודל ה

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

משום שמערכת ההפעלה , מתקבלת תפוקה נמוכה. לעומת מעבד אמיתי n/1התהליכים יש מעבד משלו שרץ בקצב של .נמצא במצב סרק CPU-מצב שבו ה, context switching-עסוקה ב

context switch-אם זמן ה. context switch-יהיה גדול תוך כדי התחשבות בזמן ה time quantum-נרצה שה, לכן .context switchיבזבז על CPU-אזי עשר אחוז מהזמן ה, time quantum-ה אחוז מזמן 10הוא בערך

אחוז 80כך שלפחות , גדול מספיק quantumדורש בחירת time quantum-אחד מחוקי האצבע לבחירת גודל היאלצו להפסיק את אחוז מהתהליכים יכלו לרוץ מבלי שי 80- כלומר כ(הדרושים יהיו קטנים ממנו CPU-מפרצי ה

).שלהם הסתיימה quantum-פעולתם באמצע בגלל שה .בשיטה זו לא תיתכן הרעבה

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

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

background process. התהליכים מוקצים . למספר תורים נפרדים ready-מחלק את תור ה multilevel queue-schedulingאלגוריתם

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

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

י "עפ(מוקצב אותו הוא מחלק CPUכל תור מקבל זמן . בין התורים) time slice(זמן " פרוסות"נוספת היא לחלק .כל התהליכים בתורבין ) אלגוריתם התזמון בו עובד

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

.לתורים בעלי העדיפות הנמוכה

6( Multilevel Feedback Queue . התהליכים לא עוברים בים התורים. תהליכים מוקצים באופן קבוע לאחד התורים multilevel queueאלגוריתם ב

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

הרעיון הוא להפריד . מאפשר לתהליכים לעבור בין התורים Multilevel feedback queueאלגוריתם , לעומת זאתהוא יעבור לתור בעל עדיפות נמוכה , CPUאם תהליך דורש זמן רב של . שלהם CPU-י מאפייני פרץ ה"תהליכים עפ

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

:י הפרמטרים הבאים"אלגוריתם זה מוגדר עפ, באופן כללי .מספר התורים .מון עבור כל תוראלגוריתם התז

.על פיה מעלים תהליך לתור בעל עדיפות גבוהה שיטהה .השיטה על פיה מורידים תהליך לתור בעל עדיפות נמוכה

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



סנכרון תהליכים – 6פרק

Background לחלוקתהליכים אלו יכולים ישירות . של תהליכים אחרים במערכת תהליכים שיתופיים הם תהליכים המושפעים מריצה

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

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

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

:קוד היצרן יהיה מעתהrepeat … produce an item in nextp … while counter = n do no-op; buffer[in] := nextp; in := (in + 1) mod n; counter := counter + 1 until false;

:יהיה מעתה צרכןקוד

repeat while counter = 0 do no-op; nextp := buffer[in]; out := (out + 1) mod n; counter := counter - 1 … consume the item in nextc until false;

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

counter := counter + 1 ו - counter := counter - 1 .לא יודעים מה יתרחש , מכיוון שהרוטינות רצות במקביל .עלולים להיות שגויים counter-ולכן ערכי ה, קודם

Section Problem-The Critical בו התהליך עשוי לשנות critical sectionמנט קוד הנקרא לכל תהליך יש סג. תהליכים nנסתכל על מערכת המכילה

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

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

.remainder sectionיתר הקוד ייקרא . הקטע הקריטי יבוא מיד אחרי קטע הכניסה. nentry sectioנקרא



:הדרישות הבאות 3פתרון לבעיית הקטע הקריטי חייב לספק את Mutual Exclusion – אם תהליךPi אזי כל יתר התהליכים לא יוכלו לרוץ בקטע הקריטי ,נמצא בקטע הקריטי שלו

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

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

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

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

:אשר המבנה שלו אופייני Piונתאר תהליך , נגדיר אך ורק את המשתנים בהם נשתמש למטרת סנכרוןrepeat entry section critical section exit section remainder section until false;

פתרונות לשני תהליכים .נתסכל תחילה על אלגוריתם המתאימים לשני תהליכים בכל שלב

1אלגוריתם

.רשאי להיכנס לקטע הקריטי Piך תהלי turn=iכאשר . turnנאפשר לתהליכים לחלוק משתנה משותף אחד בשם repeat while turn i do no-op; critical section turn := j; remainder section until false;

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

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



2אלגוריתם

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

var flag: array [0..1] of boolean; קוד התהליך . מוכן להיכנס לקטע הקריטי Piמציין כי התהליך false .flag[i] = true-נאתחל את כל איברי המערך ל

:כך יראהrepeat flag[i] := true; while flag[j] do no-op; critical section flag[i] := false; remainder section until false;

. בכדי לציין שהוא מוכן להיכנס לקטע הקריטי שלו, flag[i]-ב trueמציב תחילה את הערך Piבאלגוריתם זה התהליך

ורק אז , ייצא מהקטע הקריטי Pj-ממתין עד ש Piאזי , אם כן. מעוניין בקטע הקריטי או לא Pjיך בודק האם כעת התהלומאפשר לתהליך אחר , false-ל flag[i]הוא מעדכן את הערך , מסיים Piכאשר . יכנס לקטע הקריטי שלו Piהתהליך

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

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

3אלגוריתם

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

var flag: array [0..1] of boolean; turn: 0..1;

:יהיה Piמבנה התהליך . 1או 0יקבל turn-ו, false-נאתחל את איברי המערך ל, בתחילהrepeat flag[i] := true; turn := j; while (flag[j] and turn=j) do no-op; critical section flag[i] := false; remainder section until false;

ולאחר מכן מצהיר שזה תורו של , true-ל flag[i] מעדכן תחילה את הערך Piתהליך , כדי להיכנס לקטע הקריטי

בערך jושל iיקבל את הערך של turn, אם שני התהליכים ינסו להיכנס לקטע הקריטי באותו זמן. התהליך השניבסופו של דבר . ההשמה האחרת אומנם תתרחש אבל היא מיד תידרס; ל תהיה תקפה"רק אחת מההשמות הנ. באותו זמן .יחליט מי מהתהליכים רשאי להיכנס לקטע הקריטי turnערכיו של

.הדרישות 3נראה כעת כי פתרון זה מספק את Mutual exclusion – נשים לב כי תהליךPi יכול להיכנס לקטע הקריטי שלו רק אםflag[j]=false ) כלומר תהליך

j לא רוצה להיכנס לקטע הקריטי ( אוturn=i ) כלומר תורו שלi אם שני תהליכים היו , כמו כן). יטילהיכנס לקטע הקרניתן לראות כי , על פני שני הבחנות אלו. flag[i]=flag[j]=trueאזי , יכולים לרוץ בו זמנית בקטע הקריטי שלהם

, לכן. jאו iיהיה או turnמשום שהערך של , שלהם בהצלחה בו זמנית while-התהליכים לא יכלו לעבור את הוראת ה, turn=jואילו התהליך השני יהיה חייב לבצע , בהצלחה while-יצליח לעבור את הוראת ה, Pjנניח , אחד התהליכים

.יסיים Pjעד שהתהליך while-ולכן להמתין בתוך לולאת ה



Progress +Bounded-waiting – תהליך לא יוכל להיכנס לקטע הקריטי שלו רק אם הוא נתקע בלולאת ה-while .גם אם , אזי התהליך יוכל להיכנס לקטע הקריטי , )turn=jכלומר (לא מוכן Pjאם . turn=jוגם flag[j]=trueכלומר

-ל flag[j]הוא יאפס את , יוצא מהקטע הקריטי שלו Pj-ברגע ש, אבל. יחכה Piאזי , אם התהליך מוכן, זה לא תורוfalse ,אם כעת . וכך התהליך הראשון יוכל להיכנס לקטע הקריטיPj הרי , מעוניין בקטע הקריטייחליט שוב שהוא

הוא turnלא שינה את הערך של Pi-מכיוון ש, כך. turn=iאבל הוא גם יצטרך לעדכן , flag[j]=trueשהוא יעדכן כלומר הושגה (לקטע הקריטי Pjוכן הוא חיכה רק לכניסה אחת של , )כלומר יש התקדמות(ייכנס לקטע הקריטי bounded waiting.(

Bakery Algorithm . תהליכים nאלגוריתם זה פותר את בעיית הקטע הקריטי עבור

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

יקבל אישור Piאזי , j-קטן מ I-ו, קיבלו את אותו מספר Pj-ו Piאם , כלומר. בעל השם הקטן ביותר יקבל אישור . ראשון

:מבני הנתונים המשותפים יהיוvar choosing: array [0..n-1] of boolean; number: array [0..n-1] of integer;

:לצורך הנוחות נגדיר את הסימונים הבאים. בהתאמה 0-ול false-ל מאותחלים ל"הנ מבני הנתונים, בתחילה

(a,b) < (c,d) if a < c or if a = c and b < d max(a0, …, an-1) is a number, k such that k>= ai for i = 0, … n-1.



:יהיה Piמבנה התהליך repeat choosing[i] := true; number[i] := max(number[0], number[1], …, number[n-1]) + 1; choosing[i] := false; for j := 0 to n – 1 do begin while choosing[j] do no-op; while number[j] 0 and (number[j] , j) < (number[i] , i) do no-op; end; critical section number [i] := 0; remainder section until false;

) שונה( Pkותהליך , בנמצא בקטע הקריטי שלו Piיש להראות תחילה כי אם תהליך , כדי להוכיח שהאלגוריתם נכוןהוכחה של זה לא , מסיבה מאוד נחמדה. (number[k] , k) < (number[i] , i)אזי , בחר לעצמו מספר השונה מאפס

...אבל נניח שהצלחנו להוכיח??? מופיעה בספר Pkותהליך , נמצא בקטע הקריטי שלו Piנניח שתהליך . מסופקת mutual exclusion-ות שדרישת הניתן להרא, כעת

:המצב יהיה) j=Iכאשר (השנייה while- יגיע להוראת ה Pkכאשר . מנסה להיכנס לקטע הקריטי שלוnumber[i] 0 (number[i] , i) < (number[k] , k)

.יעזוב את הקטע הקריטי שלו Pi-לולאה עד שולכן הוא יישאר ב

Synchronization Hardware ברגע שמשתנה interruptאם לא נרשה לקבל , בעיית הקטע הקריטי יכולה להיפתר בקלות במערכת עם מעבד אחד

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

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

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

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

. מאוד



:באופן הבא Test-and-Setנגדיר את ההוראה function Test-and-Set (var target: boolean): boolean: begin Test-and-Set := target; target := true; end;

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

.הן ירוצו אחד אחרי השנייה בסדר כלשהו, יופעלו Test-and-Setאם שני הוראות , לכן. ים- interruptי "להפרעה עי הצהרת משתנה בוליאני בשם "ע mutual exclusionאזי ניתן לממש , Test-and-Setאם המכונה תומכת בהוראה

lock חל לאשר יאות-false .קוד התהליך יראה בצורה הבאה: repeat while Test-and-Set(lock) do no-op; critical section lock := false; remainder section until false;

Semaphores Semaphore s הוא משתנה מסוגinteger ,ניתן לגשת אליו רק דרך שתי פעולות , מאותחל אשר פרט לשלב בו הוא

:ההגדרה הקלאסית של פקודות אלו היא. signal-ו wait: אטומיותwait(S): while S <= 0 do no-op; S := S – 1; signal(S): S := S – 1;

כאשר , כלומר. באופן שאינו ניתן לחלוקהחייב להתבצע signal-ו wait- בהוראות ה semaphore-עדכון ערכו של ה

, בנוסף. semaphoreאת אותו זמנית- בואף תהליך אחר לא יכול לעדכן , semaphore- תהליך אחד מעדכן את ערך הנראה . חייבים גם כן לרוץ ללא הפרעות, S := S – 1ולאחר מכן העדכון S<=0הבדיקה האם , wait(S)במקרה של

יתן להשתמש איך תחילה נראה כיצד נ, כיצד ניתן לממש פעולות אלו .semaphores-ב



Processes n for Section Critical :Example התהליכים חולקים n. תהליכים nכדי להתמודד עם בעיית הקטע הקריטי עבור semaphores -ניתן להשתמש ב

semaphores בשםmutex כל תהליך מאורגן בצורה הבאה. 1-המאותחל ל: repeat wait(mutex); critical section signal(mutex); remainder section until false;

Semaphore Implementation כאשר תהליך רוצה להיכנס לקטע . busy waiting-שהגדרנו עד כה הוא השימוש ב while-אחד החסרונות בלולאות ה

ללולאה זו יוצרת בעיה במערכות . entry code-הקריטי והוא צריך להמתין הוא מבצע לולאה בתור הmultiprogramming ,בהם מעבד אחד מתחלק בין מספר תהליכים .Busy waiting מבזבז משאבים של

.בצורה יעילה יותר CPU-בזמן שתהליכים אחרים היו יכולים להשתמש ב, CPU-הכאשר תהליך מריץ את הוראת . signal-ו waitנעדכן את הגדרת ההוראות busy waitingכדי להתגבר על הצורך של

במקום להשתמש , אבל. הוא יהיה חייב לחכות, שלילי semaphore-ומגלה שערך ה wait-ההמקושר waiting-פעולת החסימה ממקמת את התהליך בתור ה. את עצמו) block(התהליך יחסום , busy waiting-ב .waiting-וסטטוס התהליך הופך ל, semaphore-ל

, wakeupהתהליך יותחל מחדש בעזרת הוראת . signalם יותחל מחדש כאשר תהליך אחד יריץ הוראת תהליך שחסו .ready-וכך ממוקם התהליך שוב בתור ה, ready-ל waiting-אשר משנה את סטטוס התהליך מ

:בתור רשומה semaphore -נגדיר את ה, תחת הגדרות אלו semaphoreכדי לממש type semaphore = record value: integer; L: list of process; end;

הוא מתווסף לרשימת semaphore -כאשר תהליך חייב לחכות ל. יש ערך מספרי ורשימת תהליכים semaphoreלכל .ומעירה אותו, מסירה תהליך אחד מרשימת התהליכים הממתינים signalהוראת . התהליכים :יוגדרו כעת כך semaphore -הוראות ה

wait(S): S.value := S.value – 1; if S.value < 0 then begin add this process to S.L; block; end;



signal(S): S.value := S.value + 1; if S.value <= 0 then begin remove a process P from S.L; wakeup(P); end;

שתי הוראות אלו מסופקות . מחדשת את רימת התהליך שנחסם wakeupראת הו. משהה את התהליך blockהוראת

.בסיסיות system call-י מערכת ההפעלה כ"ע

Deadlocks and Starvation אם תור ממתינים עשוי לגרום למצב שבו שני תהליכים או יותר ממתינים לנצח לאירוע semaphoreמימוש של

).deadlocked(במצב כזה התהליכים נמצאים בקיפאון . נמצא גם כן בתורי אחד התהליכים ש"שעשוי להתרחש רק ע, Q-ו S, ים-semaphoreשניהם ניגשים לשני , P1-ו P0, תהליכים 2כדי להדגים זאת נסתכל על מערכת המכילה

.1המכילים את הערך P1 P0

wait(Q); wait(S); wait(S); wait(Q);

. .

. .

. . signal(Q);signal(S); signal(S); signal(Q);

חייב P1 -בעוד ש, signal(Q)יריץ P1-חייב לחכות עד ש wait(Q) .P0את P1 -ו, wait(S)מריץ את P0 -נניח ש

.התהליכים במצב קיפאון, לא יכולות לרוץ signal-מכיוון ששתי פעולות ה. signal(S)יריץ P0-לחכות עד שי תהליך אחד "פאון כאשר כל תהליך בקבוצה מחכה לאירוע שצריך להתרחש ענאמר שקבוצה של תהליכים נמצאת בקי

.semaphoreמצב שבו תהליך מחכה לנצח בתוך –בעיה נוספת הקשורה לקיפאון היא הרעבה . בקבוצה

Binary Semaphores משום שהערך המספרי שלה יכול , counting semaphoreשתוארה עד עכשיו מוכרת בשם semaphore-תבנית ה

יכול לפשט Binary semaphore. 1או 0טווח הערכים הוא Binary semaphore-ב. לא מוגבללתחום להגיע לטווח countingנראה כעת כיצד ניתן לממש . תלוי בארכיטקטורת החומרה, counting semaphoreאת המימוש של

semaphore בעזרתbinary semaphore.



נגדיר את מבנה binary semaphoreכדי לממש זאת במונחים של . counting semaphore-בתור ה Sנגדיר את :הנתונים הבא

var S1: binary-semaphore; S2: binary-semaphore; C: integer;

.counting semaphore S-יקבל את הערך הראשוני של ה Cוערך המסר S1=1 ,S2=0 בתחילה :תמומש בצורה הבאה wait-הוראת ה

wait(S1); C := C – 1; If C < 0 then begin signal(S1); wait(S2); end signal(S1):

:תמומש בצורה הבא signal-הוראת ה

wait(S1); C := C + 1; If C <= 0 then signal(S2); else signal(S1);



SynchronizationClassical Problems Of .semaphores-אשר הפתרון שלהם הוא שימוש ב, נציג כעת מספר בעיות שונות של סנכרון

Bounded-Buffer Problem . בעיית היצרן צרכן

:ים- semaphore 3נגדיר . כל אחד מסוגל להחזיק פריט אחד, n buffersנניח שקיימים mutex – מספקmutual exclusion לגישה ל-buffer, 1-ומאותחל ל. empty – לוקח בחשבון את ה-buffer-מאותחל לערך . ים הריקיםn.

full – לוקח בחשבון את ה-buffer-0-מאותחל ל. ים המלאים.

:קוד היצרן יהיה מעתהrepeat … produce an item in nextp … wait(empty); wait(mutex); … add nextp to buffer … signal(mutex); signal(full); until false;

:יהיה מעתה צרכןקוד

repeat wait(full); wait(mutex); … remove an item from buffer to nextc … signal(mutex); signal(empty); … consume the item in nextc … until false;

Readers-Writers Problem אם ניתן עדיפות . העבודה תהייה מהירה יותר, אם ניתן עדיפות לקרואים. ם בעיהקוראים וכותבים יחדיו יוצרי

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

.קוראים

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

.אבל אם יש כותבים נוספים בתור נכניס אותם קודם, נכניס אותו



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

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

.הכותבים חייבים לחכות שהאור יכבה על מנת להיכנס .בחוברת 94עמוד 6.30אלגוריתם בשקף

Dining-Philosophers Problem כל , על מנת לאכול. צלחות יש מקל אכילה אחד 2בין כל . שולחן עגולפילוסופים יושבים סביב 5: תיאור הבעיה

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

.הפילוסוף האחר

1פתרון פתרון זה עלול ליצור . לימינו ולשמאלו waitכל פילוסוף שרוצה לאכול יבצע . semaphores 5נחזיק מערך של

.עבור תפיסת שתי מקלות semaphoreנוסיף –פתרון . כל אחד תופס מקל ימני ומחכה לנצח לשמאלי –הרעבה

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

.בחוברת 95עמוד 6.32שקף



Deadlocks – 7פרק

System Model , המשאבים מתחלקים למספר סוגים. המתחלקים בין מספר תהליכים, המערכת מורכבת ממספר סופי של משאבים

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

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

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

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

Request – את " לרכוש"הרי שהתהליך המבקש יאלץ להמתין עד שיוכל , אם לא ניתן לבצע את הבקשה באופן מיידי .המשאב

Use – התהליך יכול לפעול על המשאב. Release – התהליך משחרר את המשאב.

.system callי "בקשה ושחרור משאב נעשים ע

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

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

CPU קובץ(או משאב לוגי ) ועוד ,semaphores ו-monitors .( ייתכן כמובן . כלומר תהליך אחד יבצע הילוך לאחור –עשוי להיות בעזרת עקיבה לאחור פתרון של מצב קיפאון

.שנזדקק לפעולת עקיבה לאחור ביותר מתהליך אחד

.במצב קיפאון נשים לב שתיתכן הרעבה

Deadlock Characterization " קשורה"תהליכים אף פעם לא מסתיימים ומערכת המשאבים , במצב של קיפאון. לא ניתן להימנע ממצב של קיפאון

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

usionMutual excl – בכל פעם רק תהליך אחד יכול , כלומר. לפחות משאב אחד מוחזק באופן שלא ניתן לחלוק בו .הוא יאלץ להמתין עד שהמשאב יתפנה, ל"כאשר תהליך אחד יבקש את המשאב הנ. להשתמש במשאבHold and Wait – י "והוא ממתין למשאבים נוספים שכרגע מוחזקים ע, משאב אחדקיים תהליך שמחזיק לפחות .תהליכים אחרים

No preemption – לא ייתכן . ברגע שהתהליך סיים את משימתו, י התהליך עצמו"שחרור המשאבים נעשה אך ורק ע .לתהליך את המשאב" לוקחים"מצב בו

Circular wait – קיימת קבוצת}n, ..., P1, P0{P 0כאשר , של תהליכים שממתינים למשאביםP ממתין למשאב .P0י "ממתין לתהליך שתפוס ע Pnכאשר , וכך הלאה P2י "ממתין למשאב שתפוס ע P1 ,P1י "שתפוס ע

)system resource allocation graph(גרף הקצאת משאבים .בצורה הרבה יותר מדויקת צבי קיפאוןבעזרת גרף הקצאת משאבים ניתן לתאר מ

המייצגת את Rוכן מהקבוצה , המייצגת את כל התהליכים שרצים במערכת Pיהיו מורכבים מהקבוצה קדקודי הגרף .כל משאבי המערכת

תהליך תהליך ים -4instanceמשאב בעל •• ים -4instanceמשאב בעל •• •• ••



:סימון הקדקודים

: קשתות הגרף .Rjביקש את המשאב Piמציינת כי התהליך Rjלמשאב Piקשת מתהליך

.של המשאב instanceמציינת כי התהליך מחזיק באותו Piלתהליך Rjספציפי במשאב instance-קשת מ .deadlockבשני הדוגמאות אין מצב של . 7.9- ו 7.8דוגמאות בשקפים

כללים חשובים

.deadlockאזי בוודאות לא ייווצר מצב של ) 7.8כדוגמת הגרף בשקף (אם הגרף לא כולל מעגלים :מעגל בגרף אזי ייתכנו שני מקריםאם יש

.deadlockאזי בוודאות ייווצר מצב של , אחד מכל משאב instanceאם קיים רק מראה 7.9הדוגמא בשקף . deadlockאזי קיים סיכוי גבוה שלא ייווצר , ים לכל משאב- instanceאם קיימים מספר

- כך שברגע ש. ים של משאבים- instanceתופסים הסיבה היא שבנוסף למעגל קיימים תהליכים אחרים ש. מקרה כזהp2 הרי שיתפנה ) שכן הוא לא זקוק לאף משאב נוסף(יסתייםinstance של משאבR1 ותהליךp1 יוכל לקבל אותו ,

.וכך למעשה נשבר המעגל

Methods for Handling Deadlocks :קיימות שלוש דרכים שונות לטפל בבעיית קיפאון

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

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

או ) מניעה(= deadlock-prevention- המערכת יכולה להשתמש או בשיטת ה deadlockבכדי למנוע תופעה של ראה (הדרושים לקיפאון שיטת המניעה דואגת שלפחות אחד מהתנאים). הימנעות(= deadlock-avoidance-בשיטת ה

Deadlock Characterization שיטת הימנעות דורשת שמערכת ההפעלה תדע מראש מהם . לא התקיים) 44' עמאב או לא ניתן יהיה להחליט בכל בקשה האם התהליך יקבל את המש, בעזרת מידע זה. המשאבים הדרושים לכל תהליך

).גם אם המשאב פנוי(

Deadlock Prevention :נבטיח שלפחות אחד מתנאי הקיפאון לא התקיימו

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

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

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

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

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

.רגע :ישנם שתי חסרונות לשיטה זו

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

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

No preemption – כדי להבטיח שתנאי זה לא . תנאי זה היה נחוץ כדי להבטיח שמשאב שכבר הוקצה לא יילקחאך אותו ,בזמן שהוא מחזיק כבר במספר משאבים, אם תהליך מסוים מבקש משאב: נשתמש בשיטה הבאה, יקרה



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

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

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

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

.משאבים הם צריכים

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

Deadlock Avoidance בעזרת המידע לגבי כל . י דרישת מידע נוסף על המשאבים שהתהליכים עומדים לבקש"ע, השיטה השנייה היא הימנעות

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

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

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

.בעוד ששיטת המניעה פוגעת בוודאות במערכת, אבל לא פוגעת בה, שיטה זו מעטה את המערכת

Safe State – מצב בטוח. הינו מצב שבו המערכת יכול להקצות משאבים לתהליכים בסדר מסוים ועדיין להימנע ממצב של קיפאון מצב בטוח

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

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

עובדות

.כת במצב בטוח אין קיפאוןאם המער .אם המערכת לא במצב בטוח ייתכן מצב של קיפאון

.הימנעות מבטיחה שהמערכת לא תיכנס למצב לא בטוח

אלגוריתם הבנקאי .ים לכל משאב- instanceאלגוריתם זה מתאים למצב שבו יש מספר

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

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

.את מספר המשאבים m-את מספר התהליכים וב n-נסמן ב

:מבני הנתונים בהם משתמש האלגוריתםAvailable – ווקטור באורךm המצביע על מספר ה-instance -ים הפנויים עבור כל משאב .]=kAvailable[j מציין .ים פנויים- k instanceיש Rjכי למשאב



Max – מטריצה בגודלnXm המציינת את הכמות המקסימלית שלinstance -ים ממשאב מסוים הדרושים לתהליך .Max[i,j]=k מציין כי תהליךPi עשוי לבקשk instance - ים של המשאבRj. Allocation - מטריצה בגודלnXm המציינת את הכמות ה-nstancei - ים ממשאב מסוים המוקצים ברגע נתון

.Rjים של המשאב - k instance-מחזיק בשלב זה ב Piמציין כי תהליך Allocation[i,j]=k. לתהליךNeed - מטריצה בגודלnXm המציינת את הכמות ה-instance -ים שחסרים לתהליך ממשאב מסוים .Need[i,j]=k

.Rjים של המשאב - k instanceזקוק לעוד Piמציין כי תהליך

Need[i,j] = Max[i,j] - Allocation[i,j]

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

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



תיאור אלגוריתם לקביעה האם המערכת במצב בטוח או לאווקטור זה יציין עבור על תהליך האם הוא סיים ( false-אשר יאותחל ל, nבאורך Finishווקטור : נגדיר שני ווקטורים

.availableאשר יכיל את הווקטור mבאורך workווקטור , )או לא :המקיים iנמצא

Finish[i] = false Need[i,j] <= Work[j]

.4נעבור לשלב iאם לא קיים כזה Work[i] = Work[i] + Allocation[i,j]

Finish[i] = true .2חזרה לשב

. אזי המערכת במצב בטוח i ,Finish[i]= trueאם לכל

Piעבור תהליך Request-Resourceתיאור אלגוריתם

k-מציין כל התהליך זקוק ל Requesti[j] = k. כך שיכיל את כל הבקשות של התהליך Requestiנגדיר את הווקטור instance - ים של משאבRj .ך יש לבצעי התהלי"ברגע שמתקבלת בקשה למשאב ע:

שהתהליך עבר את כמות המשאבים , אחרת יש להציג הודעת שגיאה. 2יש להמשיך לשלב Requesti < Neediאם .אותה הוא טען שהוא צריך

.משום שהמשאבים אינם זמינים, אחרת התהליך ימתין. 3יש להמשיך לשלב Requesti < Availableאם :העדכונים הבאים י"המערכת תקצה כביכול את המשאבים לתהליך ע

Available = Available - Requesti Allocationi = Allocationi + Requesti Needi = Needi - Requesti

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

.resource-allocation-ויעודכן המצב הקודם של ה, התהליך ימתין

.מציג דוגמא של האלגוריתם 7.22שקף .האלגוריתם מחפש למעשה מסלול בטוח

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

.זה משום שהוא מעט את הביצועים



ניהול זיכרון – 8פרק

Background בכדי להריץ את התוכנית יש להביא תחילה את . תוכנית נמצאת בדיסק בתור קובץ בינארי הניתן להרצה, ברוב המקרים

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

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

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

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

המחשב יקשר . כתובות בתוכנית המקור הם לרוב כתובות סימבוליות. הכתובות יכולות להופיע בדרכים שונות, האלו)bind (ל לכתובות "את הכתובות הנrelocatable ) ה). בתים מתחילת המודול 14לדוגמא-linkage editor או ה -

loader (כל קישור כזה ). 74014לדוגמא (כתובות מוחלטות יהפוך כתובות אלו לbinding ( הוא מיפוי של מרחב .זיכרון אחד לאחר

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

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

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

. הריצה

Dynamic Loading במצב זה לא טוענים רוטינה לזיכרון עד . הוא תפוקה טובה יותר ממרחב הזיכרון dynamic loading-מטרת השימוש בהתוכנית הראשית נטענת לזיכרון . relocatableכל הרוטינות נשמרות בדיסק בפורמט כתובות . שלא קוראים להבמידה . לה האם כבר טענו את הרוטינה או לאכאשר יש צורך לקרוא לרוטינה נוספת בודקים תחי. ומתחילה לרוץ

טוען את הרוטינה הדרושה לזיכרון ומעדכן את relocatable linking loader-ה, ועדין לא טענו את הרוטינה לזיכרון .טבלת הכתובות של התוכנית כך שתתאים לשינויים שנעשו

יתרונות .רוטינות שלא בשימוש לא נטענות לעולם

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

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

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

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

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

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



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

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

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

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

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

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

Logical Versus Physical Address Space ומוגבלת 0-כתובת לוגית מתחילה ב. virtual addressמכונה גם . CPU-י ה"כתובת שנוצרת ע – כתובת לוגית

.232-1הכתובות המקסימלי יהיה ' ביט מס 32מכיוון שכתובת היא בגודל . 232-1-ב .מוגבלת באורך הזיכרון הקיים. כתובות ממשית בזיכרון – כתובת פיזית

אוסף כל הכתובות הפיזיות המתאימות . י התוכנית נקראות מרחב כתובות לוגי"ל הכתובות הלוגיות שנוצרת עאוסף כ . לכתובות לוגיות אלו נקראות מרחב כתובות פיזי

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

Memory Management Unit - MMU MMU הינו רכיב חומרה אשר מבצע את מיפוי הכתובות הלוגיות לכתובות פיזיות .

למעשה ). בחוברת 134עמוד 8.3איור ( relocation register-הוא להשתמש ב MMUאחת הדרכים לממש י "מוסיפים את ערך הרגיסטר לכל כתובת המיוצר ע. relocation registerבשם החדש base register-מתייחסים ל

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

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

עד (R+0)-וכתובות פיזיות בתחום מ, maxעד 0-ת בתחום מכתובות לוגיו: למעשה יש לנו שני סוגי כתובות)max+R.(

Swapping באופן זמני את התהליך מחוץ לזיכרון ) swapped(ניתן להוציא , אבל. תהליך צריך להיות בזיכרון כדי לרוץ

נניח שיש לי , לדוגמא). בחוברת 136עמוד 8.10שקף (ריצה ולהביא אותו בחזרה לזיכרון להמשך, backing store-לברגע שיחידת הזמן שהוקצתה ). 31ראה עמוד ( round-robinשעובדת בעזרת מתזמן multiprogrammingסביבת

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

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

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



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

.יהיה להעביר את התהליך למקום חדשגדול מספיר להכיל את כל מופעי הזיכרון . יהיה דיסק מהיר ברוב המקרים זה. backing storeדורש swap-תהליך ה

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

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

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

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

Contiguous Allocation – הקצאה רציפה

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

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

Single-Partition Allocation יש צורך להגן על הקוד , ותוכניות משתמש רצות באזור זיכרון גבוה, באזור זיכרון נמוךאם מערכת ההפעלה יושבת

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

ממפה באופן דינאמי את MMU-רכיב ה. Limit register-תהייה קטנה יותר מה כל כתובת לוגית, שני רגיסטרים אלו 135בעמוד 8.6איור (הכתובת הממופה נשלחת לזיכרון . relocation register-י הוספת ערך ה"הכתובת הלוגית ע

).בחוברת . context switch-טוען את שני הרגיסטרים כחלק מתהליך ה dispatcher-ה, בוחר תהליך CPU-כאשר מתזמן ה



Multiple-Partition Allocation ולכן עלינו להתחשב בבעיה של הקצאת זיכרון נגיש למגוון , בזיכרון מצויים מספר תהליכי משתמש בו זמנית

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

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

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

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

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

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

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

. תהליך שדרוש כמות זיכרון קטנה יותר

blemAllocation Pro-Dynamic Storage

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

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

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

First Fit – הקצאת ה-hole לת החיפוש יכול להתחיל מתחי. הראשון ברשימה אשר גדול מספיק בשביל התהליך .הרשימה או מהנקודה האחרונה שבה עצרנו

Best Fit – הקצאת ה-hole יש לעבור על כל הרשימה. הקטן ביותר אשר גדול מספיק בשביל התהליך. Worst Fit – הקצאת ה-hole שוב יש לעבור על כל הרשימה. הגדול ביותר ברשימה.

First-fit ו-best-fit דיפות על פני עworst-fit מבחינת מהירות ואחסון.

Fragmentation מכיוון שהתהליכים נטענים ). fragmentation(יוצר בעיות שיברור ) hole-שימוש ב(האלגוריתם שתואר לעיל

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

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

holeהדרוש לעקוב אחר overhead-ה. בתים 2בגדול holeנקבל , אם נקצה בלוק בגודל הבקשה. בתים 18,462-לים קטנים מאוד כחלק מהבקשה - holeלכן הגישה היא להקצות . עצמו hole-זה הוא לרוב גדול יותר באופן ממשי מה

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

המטרה היא לערבב את תוכן . Compactionנקראת FragmentationExternal-אחת הדרכים לפתור את בעיית ה ).בחוברת 142עמוד 8.10איור (הזיכרון ולמקם את כל הזיכרון הפנוי בבלוק אחד גדול

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

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



Paging וכך , הוא לאפשר לתהליך לעבוד עם מרחב כתובות לוגי לא רציף External Fragmentation-ת הפתרון נוסף לבעיי

י שימוש "שיטה אחת למימוש פתרון זה נעשית ע. התהליך מוקצה לתהליך זיכרון פיזי היכן שהוא פנוי . paging-ב

הזיכרון הלוגי מחולק גם הוא לבלוקים באותו גודל . framesקראים הזיכרון הפיזי מחולק לבלוקים בגודל קבוע הנ . backing storage-כאשר תהליך אמור לרוץ הדפים שלו נטענים מתוך ה. pagesהנקראים

.עצמו מחולק גם כן לבלוקים באותו גודל backing storage-ה :גת באיור הבאמוצ paging- החומרה הדרושה לתמיכה ב

מספר העמוד משמש . page offset (d)-ו page number (p): מחולקת לשני חלקים CPU-י ה"כל כתובת שנוצרת עכתובת הבסיס . אשר מכילה את כתובת הבסיס של כל דף בזיכרון הפיזי) page table(כאינדקס לטבלת הדפים

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

תלוי בארכיטקטורת , מגה בית 16-בתים ל 512בין , 2ברוב המקרים מדבר בחזקה של . י החומרה"גודל הדף נקבע ע .המחשב

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

-במידה והזיכרון הדרוש אינו נופל בגבולות ה. ים מוקצים כיחידה-internal fragmentation .Frameעשויים לקבל page ,הרי ש -frame לתהליך שזקוק ל, במקרה הגרוע. א לחלוטיןהאחרון שמוקצה עשוי להיות לא מל-n דפים ועוד

. שלם frameשל כמעט internal fragmentationוכתוצאה מכך יתקבל , דפים (n+1)יוקצו , בית אחד )גודל כתובת4k * ( (4 )(גודל דף / גודל התוכנית : (גודל טבלת הדפים הינו

מימוש טבלת הדפיםהמכיל מצביע page table base register (PTBR)נשמר רגיסטר PCB-ב. יטבלת הדפים נשמרת בזיכרון הראש

.המכיל את גודל טבלת הדפים page table length register (PTLR)וכן רגיסטר , לטבלת הדפיםגישה אחת לטבלת הדפים וגישה אחת (משום שדרושות שתי גישות לזיכרון , בעיה בשיטה זו היא זמן הגישה לזיכרוןה

או associative registerהנקרא , cache- הפתרון לבעיה זו הוא שימוש ב). לנתון עצמוtranslation look-aside buffers (TLBS) .הרגיסטרים מכילים . נבנה אוסף של רגיסטרים בזיכרון מהיר במיוחד

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

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

Physical memory

CPU p d

Logical address

p d

Physical address

f

Page table

p

Physical memory

CPU p d

Logical address

p d

Physical address

f

Page table

p



Two-Level Page-Table Scheme בצורה הדפים עצמה גדולה בסביבה כזו טבלת. רוב מערכות המחשב המודרניות תומכות במרחב כתובות גדול מאוד

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

שבה הטבלה עצמה ) בחוברת 148עמוד 8.23שקף ( two level page table-דרך אחת ליישם זאת היא שיטת ה. ביטים המכילים את היסט העמוד 12- ביטים שיכילו את מספר העמוד ו 20-מורכבת מ כתובת לוגית. מורכבת מדפים

ביטים שיכילו את 10: הביטים של מספר העמוד לשני חלקים 20נחלק את , מכיוון שהפכנו את טבלת הדפים לעמודים .ביטים שיכילו את ההיסט 10-מספר העמוד ו

.כניסה מצביע על חלק מטבלת הדפיםכל . כניסות kכלומר קיבלנו דף שמכיל

Inverted Page Table אחת הבעיות . עד כה הצגנו מצב שבו לכל תהליך יש טבלת דפים המכילה כניסה אחת לכל דף שהתהליך משתמש

inverted-משתמשים ב כדי לפתור בעיה זו. בשיטה זו היא ייווצרות של טבלאות בעלות כמות גדולה מאוד של כניסותpage table . בטבלה זו יש כניסה אחת בלבד לכלframe כל כניסה מורכבת מכתובת וירטואלית של העמוד . בזיכרון

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

.בחוברת 150עמוד 8.28שקף :שיטה זו מתבססת על מספר הנחות

.כל התוכניות נמצאות בזיכרון הוירטואלי .לא כל תוכנית יכולה לקבל את כל הזיכרון הוירטואלי

.החיפוש בטבלה יעיל. ניהול הכניסות מאוד יעיל

Shared Pages . היא היכולת לשתף קוד שכיח paging-אחד היתרונות בשימוש ב

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

.קוד משותף חייב להופיע באותן כתובות לוגיות בכל התהליכים שמשתמשים בו .בחוברת 151ד בעמו 8.30שקף



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

.שהמשתמש רואה את הזיכרון לבין איך שהזיכרון באמת בנוי פיזיתSegmentation מרחב הכתובת הלוגי הינו אוסף של . תומכת בשיטת זוהיא שיטת ניהול זיכרון ה

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

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

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

מציין את אורך limit-וסגמנט ה, סגמנט הבסיס מכיל את הכתובת הפיזית בזיכרון בה מתחיל הסגמנט. limitוסגמנט .הסגמנט

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

טים בגלל שמספר הסגמנ, בנוסף. המצביע לטבלת הסגמנטים STBR segment table base register)(כך שומרים המציין את מספר הסגמנטים , STLR segment table length register)(-נעשה שימוש ב, של התוכנית גדול

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

Segmentation With Paging קיימת אפשרות לשלב את השניים במטרה . יש את היתרונות והחסרונות שלהם segmentation-וגם ל paging-גם ל

:שילוב זה מוצג בשתי ארכיטקטורות שונות. לשפר את שניהםי חלוקת "וזמן החיפוש ע external fragmentation-מערכות אלו פותרות את בעיית ה – MULTICSכת מער

.בחוברת 155עמוד 8.38שקף . וגודל הסגמנטים הוא כפולות של דפים, כל הזיכרון מחולק לדפים. הסגמנטים לדפים . לכל סגמנט יש טבלת דפים מפוצלת – Intel 386מעבדי



רטואליזיכרון וי – 9פרק

Background ומה שנמצא בזיכרון אינו , זיכרון וירטואלי הוא טכניקה המאפשרת הרצת תהליכים שאינם נמצאים בשלמותם בזיכרון

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

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

.משום שהם תופסות פחות מקום, יותר תוכניות יוכלו לרוץ בו זמנית .כל שהתוכניות ירוצו מהר יותר, כנית משתמשיהיה דרוש לטעינה והחלפה של כל תו I/Oפחות

.זיכרון וירטואלי הוא הפרדה בין זיכרון לוגי לזיכרון פיזי

:ניתן ליישם זיכרון וירטואלי בשני דרכיםDemand paging.

Demand segmentation )לא נלמד בקורס כי למרצה כבר לא היה כוח.(

Demand Paging תהליכים ). בחוברת 162עמוד 9.2איור ( swappingהכוללת pagingדומה למערכת demand pagingמערכת

lazy-בנוסף לכך נשתמש ב. אותו לזיכרון) swap(כאשר נרצה להריץ תהליך נכניס . נשמרים בזיכרון המשניswapper .Lazy swapper מתייחסים כעת מכיוון שאנו. לעולם לא יכניס לזיכרון תהליך אלא אם כן יש בו צורך

מופעל Swapper. מבחינה טכניתאינו נכון swapולכן המונח , ולא מרחב כתובות רציף, לתהליך כעל סידרה של דפיםבהקשר של pagerנשתמש במונח , ולכן. עוסק בדפים עצמאיים של תהליך pager- בעוד ש, על תהליכים שלמיםdemand paging.

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

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

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

. או מכילה את כתובת הדף בדיסק invalid-הכניסה עצמה מסומנת כ invalid-הערך ה

Page Fault זה הוא תוצאה מניסיון Trap. למערכת ההפעלה page fault trapגורמת לשליחת invalid-גישה לדף המסומן כ

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

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

.פנוי frameנמצא .החדש frame-נתזמן פעולת דיסק אשר תקרא את הדף המתאים אל ה

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

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



e ReplacementPag . שלא נמצא כרגע בשימוש ונשחרר אותו frameנחפש , פנוי frameגישת החלפת הדפים אומרת שבמידה ואין שום

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

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

.כתוב לדיסק את הדף שהוצאת ועדכן את הטבלאות .הפנוי ושנה את הטבלאות בהתאם frame-קרא את הדף הרצי ל

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

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

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

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

1( First In First Out (FIFO) Algorithm ים לא תקטין את -frame-נשים לב שהגדלת מספר ה. הראשון שנכנס לזיכרון יהיה גם הראשון שישוחרר frame-ה

.מספר ההחלפות .בחוברת 169עמוד 9.11דוגמא בשקף

2( Optimal Algorithm דבר (כלומר נדע מראש מתי נזדקק לכל דף . מה הולך לקרותבאלגוריתם זה קיימת הנחה שאנחנו יודעים מראש

.במקרה כזה נוציא תמיד מהזיכרון את הדף שלא יהיה בשימוש הכי הרבה זמן). שכמובן לא קורה במציאות



3( Least Recently Used (LRU) Algorithm :ה בשני דרכיםניתן לממש אלגוריתם ז. נוציא מהזיכרון את הדף שלא היה בשימוש הכי הרבה זמן

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

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

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

4( LRU Approximation Algorithm אולם רוב המערכות מספקות עזרה . LRUמעט מאוד מערכות הפעלה מספקות חומרה התומכת בהחלפת דפים בעזרת

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

.אין אפשרות לדעת את סדר השימוש בדפים

אלגוריתם ההזדמנות השנייה או אלגוריתם השעוןנחליף 0במידה והביט הוא . שלו bit-אשר דף נבחר נבדוק את הכ. FIFOהאלגוריתם הבסיסי לאלגוריתם זה הוא

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

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

5( Counting Algorithm :את מספר הפניות לכל דף קיימים שני אלגוריתמים נוספים המשתמשים במונה הסופר

Least Frequently Used (LFU) – הסיבה לבחירה זו . אלגוריתם זה דורש שהדף בעל המונה הנמוך ביותר יוחלףהחיסרון של האלגוריתם הוא מצב . היא שדף שכבר השתמשנו בו הרבה פעמים יהיה בעל מונה הגישות הגבוה ביותר

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

.0ולא 1כאשר רק בדף שנגענו נכניס , נבצע הזזה ימינה במונה של כל דף ודף, פעם שניגשים לדףMFU – אלגוריתם זה . אלא שהפעם נוציא מהזיכרון את הדף בעל המונה הגובה ביותר, אלגוריתם יעבוד באותה שיטה

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



Allocation of Frames במקרה כזה יש יותר מתהליך . multiprogrammingררת כאשר יש דרישה לדפדף תוך כדי שילוב עם הבעיה מתעו .ים נקצה לכל תהליך-frameוהשאלה היא כמה , אחד בזיכרון

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

יש לזכור שברגע . instruction-set architecture-י ה"מספר מינימלי זה מוגדר ע. ים שחייבים להקצות-frameשל ים כך - fameמספיק עלינו להחזיק, כתוצאה מכך. ההוראה תאותחל מחדש, תוך כדי הוראה page-faultשמתרחש

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

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

:קיימות שתי שיטות הקצאה עיקריותFixed allocation – כל תהליך מקבל מספר קבוע של . הקצאה שווהFrame -ים.

Priority allocation – בה כל תהליך מקבל , קיימת הקצאה לפי פרופורציה. הקצאה על פי עדיפותframe - ים ביחסים על פי -Frameאלא שהפעם מקצים לתהליך , ל פי עדיפות עובדת באותה שיטההקצאה ע. מתאים לגודל שלו

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

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

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

במידה וניצולת . CPU-מערכה ההפעלה עוקבת אחר הניצולת של ה. ביצוע רבותיוצר בעיות Trashingהתוצאה של

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

תהליכים אלו זקוקים . וכתוצאה לוקח דפים מתהליכים אחרים, page faultהוא מתחיל לייצר . הוא זקוק לדפים נוספים pageל שיצרו "כל התהליכים הנ. ולוקחים דפים מתהליכים אחרים, גם כן page fault-ולכן גורמים ל, גם כן לדפים

fault משתמשים ברכיב ה-paging התהליכים , מכיוון שכל התהליכים זקוקים לרכיב. ס דפיםבכדי להוציא ולהכני CPU-מתזמן ה. יורדת CPU-וניצולת ה, מתרוקן ready-תור ה. waiting-ועוברים לתור ה ready-יוצאים מתור ה

...ומכניס תהליך נוספים CPU- רואה את הירידה בניצלות ה

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



Working-Set Model מספר זה נקרא קבוצת . נגדיר לכל תהליך את מספר הדפים המקסימלי שנשמור עבורו בזיכרון Trashingכדי למנוע

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

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

.לתהליך שלם swap outלבצע גדול מהזיכרון יש

Page Fault Frequency Scheme .בחוברת 179עמוד 9.25שקף

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

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

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

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

ומתקבל מצב שבו קוראים את הדפים , כלומר בכל פעם קוראים איבר מדף. השיטה השנייה בוחרת לרוץ לפי עמודותk2 מיםפע.



ניהול מערכת הקבצים – 10פרק

File Concept ) גודל ועוד, מיקום, סוג, שם(כל המידע על הקובץ . כ מייצגת תוכניות או מידע"הקובץ הינו יחידת אחסון לוגית שבדר

.אשר נשמר על הדיסק directory structure-נשמר ב

FCB – File Control Block – מתווספת שורה עבור הקובץ ב כאשר פותחים קובץ -FCB שמציינת באיזהdevice כאשר לא . ל"פעולת סגירת קובץ מוחקת את השורה הנ. מה השינויים שנעשו בו ועוד, מי משתמש בו, הקובץ נמצא

.מתמלא ובשלב מסוים לא נוכל לפתוח יותר קבצים FCB-מבצעים סגירה מסודרת של קבצים ה ).אחד לשני process-מ CPU-החלפה של ה( Context Switchעוזר לנו במצב של FCB-ה

.סוגי קבצים – 10.6שקף

Access Method . קיים מצביע למיקום הנוכחי שמשתנה בכל פעולות הקריאה והכתיבה - גישה סדרתית

ן לבצע קריאה וכתיבה מהירה ניצ. הקובץ מורכב מיחידות לוגיות בגודל קבוע – Random Accessגישה ישירה או .ללא סדר

Directory Structure .שכל אחד מהם מכיל מידע על קובץ מסוים, ים- nodeספרייה מכילה אוסף של

:קיימות מספר רמות של חלוקה לספריותלא ניתן לתת שמות זהים – namingבעיית : חסרונות. ישנה ספרייה אחת לא המשתמשים – )10.12שקף (רמה אחת

).לא ניתן לאחד קבצים מאותו נושא תחת אותה ספרייה( groupingבעיית , קבצים של משתמשים שוניםלחיפוש יעיל יותר , naming-נפתרה בעיית ה: יתרונות. ספרייה נפרדת לכל משתמש – )10.13שקף (רמות 2 .אין קבצים משותפים, groupingבעיית : חסרונות). משתמש מחפש רק תחת הספרייה שלו(

. ניתן לפנות לקבצים בשם יחסי או מוחלט. grouping-נפתרת בעיית ה. אין הגבלת רמות – )10.14שקף (עץ ספריות .ים- Linkלא ניתן לבצע

. ים לקובץ- linkי יצירת "ניתן לתת מספר שמות לאותו קובץ וזאת ע .גמיש יותר מעץ – )10.17שקף (גרף אציקלי .ים- linkחק קובץ רק כאשר אין אליו נמ? מתי ניתן למחוק קובץ: חסרונות

Protection אורך : חסרון. ספרייה יש רשימת מורשים/לכל קובץ. מבוסס על שם משתמש: קבוצות/רשימות גישה: גישה אחת

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

םארגון קבצי – 11פרק

System Structure-File כל בלוק מכיל סקטור אחד או . I/O-במטרה לשפר את יעילות ה, העברת מידע בין הזיכרון לדיסק נעשית בבלוקים

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

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

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



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

:מערכת הקבצים מחולקת לוגית למספר שכבות )application programs(תוכניות יישום

)Logical fils system – LFS(מערכת הקבצים הלוגית ים לצורך טיפול בבקשות- device-מערכת ההפעלה משתמש ב

)file organization module – FOM(מודל ארגון הקבצים )basic file system – BFS(מערכצ הקבצים הבסיסים

I/O control )devices(התקנים

.ים חדשים לרמות הגבוהות- featureים של רמות נמוכות יותר ומייצרת -feature-כל רמה משתמשת ב

I/O control – מורכבת מ-device drivers ו-interrupt handler להעברת מידע בין הזיכרון למערכת הדיסקים .Device driver ואילו הפלט שלו נתון ברמה נמוכה , הקלט שלו מורכב מפקודות בשפה גבוהה. ול להיחשב כמתרגםיכ

. בהם משתמש הבקר החומרה, הוראות חומרה מדויקת –Basic file system – רמה פיזית(מוציא פקודות להתקנים לקרוא ולכתוב בלוקים.(

organization module-File – לתרגמה לרמה הפיזית עבור המכיר גם רמה לוגית ויכול-BFS .נעזר גם ב-free space manager כדי למצוא מקומות ריקים בדיסק .

Logical file system – משתמש ב-directory structure כדי לספק ל-FOM בהינתן שם , את המידע לו הוא זקוק .אחרי גם להגן על הקבצים. קובץ



: תהלך יצירת קובץ חדשמעדכן אותו , המתאים לזיכרון directory-ל קורא את ה"הנ. LFS-קוראת ל יישוםתוכנית ה, חדש כדי ליצור קובץ

באחרות . מתייחסות לספרייה כמו אל קובץ) Unixלדוגמא (מערכות הפעלה מסוימות . ורושם אותו חזרה לדיסק .נפרדים לקבצים וספריות system callsקיימים

את directory structure- כשקובץ נפתח מחפשים ב. I/Oבצע עליו פעולות קובץ צריך להיות פתוח בכדי שנוכל לכשקובץ מאותר . כדי להאיץ את המהירות cache-מועברים ל directory structure-חלקים מה. הרשומה שלו

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

.file control blockבמערכות אחרות הוא מכונה . NT :file handle-וב Unix file descriptor-האינדקס מכונה ב .שבדיסק directory structure-כשקובץ נסגר המידע לגביו מועתק מהטבלה ל

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

.מהדיסק

Allocation Methods

Contiguous Allocation – הקצאה רציפה )1 .הנתונים נשמרים בבלוקים עוקבים. לכל קובץ מקצים מספר בלוקים. הקבצים מוקצים ברצף בדיסק

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

:יתרונות השיטה

.פשוט ביותר למימוש ומהיר מאוד :חסרונות השיטה

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

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

איך מוצאים שטח בדיסק

Best Fit – מציאת החלל הקטן ביותר שיכול להתאים לגודל הקובץ. Worst Fit – ל משמעותי בקובץנשתמש בשטח זה כאשר נצפה לגידו. מציאת החלל הגדול ביותר בדיסק.

First Fit – מציאת החלל הראשון בדיסק שיכול להתאים.

Linked Allocation –הקצאה משורשרת )2כל בלוק מצביע לבלוק . כאשר הבלוקים אינם יושבים בצורה רציפה בדיסק, כל קובץ הוא רשימה מקושרת של בלוקים

).בתים ככתובת לבלוק הבא 4אזי הבלוק מכיל , בתים 4בהנחה שכל כתובת היא (הבא .מחזיק את הבלוק הראשון והאחרון של הקובץ directory-ה

:יתרונות השיטה

.הגדלת הקובץ לא דורשת הזזות .אין חללים בדיסק :חסרונות השיטה

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

.כאשר בלוק אחד הולך לאיבוד מאבדים את כל הקובץ .Internal fragmentationבבלוק האחרון עלול להיות



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

.שלא בשימוש

:FAT – File Allocation Table –מחזיקים את שרשרת המצביעים בנפרד –שיפור של השיטה . תכיל את כתובת הבלוק הבא בתור והכניסה, לכל בלוק בדיסק תהייה כניסה בטבלה. הטבלה מחזיקה צילום של הדיסק

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

3( Indexed Allocation בתים 4כאשר כל , בתים 4הבלוק הראשון מחולק לקבוצות של . אינדקסים שאומרים לי איפה נמצא הקובץמחזיקים

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

).4MB )K*4Kבמקרה זה הוא .8MBוכעת נקבל קובץ של , הכתובת האחרונה בבלוק הראשון תצביע לבלוק אינדקסים נוסף –פתרון

בלוקים K-כלומר מפנה ל, בלוקים שכל אחד מהם הוא בלוק אינדקסים K-הבלוק הראשון מפנה ל –פתרון נוסף .4Gגודל מקסימלי . אחרים

:יתרונות השיטה ).FATכאשר הדבר לא היה ניתן בהקצאה משורשרת כאשר אין לי (כה בגישה ישירה תמי

חסרון השיטה .בזבזני עבור קבצים קטנים

.ים- seekעדיין הרבה

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

קבוצת הכתובות הראשונה בבלוק מפנות לבלוק אחד בלבד המצביע ישירות . inode-שימוש ב –) 11.13שקף ( .הגישה אליו מיידית 40kאם הקובץ הוא עד ). direct block(לנתונים

.כאשר בלוק זה מצביע ישירות לנתונים, והיא מצביעה לבלוק הפניות נוסף single indirect-הכניסה הבאה מיועדת לוהיא מצביע לבלוק הפניות נוסף בו כל כניסה מצביעה לבנוק הפניות ורק double indirectהכניסה הבאה נקראת .4Gמתאים לקובץ בגודל . משם מגיעים לנתונים

:יתרונות .יעיל גם בקבצים קטנים

.ניתן להגדיל את הקבצים בלי בעיה

:חסרונות .הרבה תנועות ראש בקבצים גדולים

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

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

External Fragmentation - חללים בדיסק בין הקבצים שהם קטנים מידי לקבצים חדשים. Internal Fragmentation - חללים שנמצאים בבלוק האחרון שהוקצה לקובץ.

Defrag – "מעבירים את כל הבלוקים ברצף אחד אחרי השני. החללים שנוצרו בדיסק" ביטול.



?במה נבחר, רתאח. אקראית עדיף להשתמש בהקצאה רציפה או משורשרת עם אינדקסים/אם ידוע שהגישה לקובץ תהיה ישירה

.נשתמש בהקצאה משורשרת

Space Management-Free :כיצד נמצא מקומות פנויים בדיסק

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

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

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

.איטי –לא יעיל : חסרון .חסכון במקום: יתרון

Grouping ) 11.14שקף( – בלוק ראשון מצביע עלn בלוקים פנויים ובנוסף על בלוק האינדקסים הבא) הבנוי באותה .אבל אין קשר למיקום הפיזי, מחזיקים את הבלוקים בקבוצות). הצור

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

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

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

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

Efficiency and Performance :היעילות תלויה ב. או המעבד הם צוואר הבקבוקלא תמיד הזיכרון

.סוג ההקצאה בדיסק .directory-שמחוזק בכל כניסה ב date-טיפוס ה

:שיטת לשיפור הביצועים

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

.ולכן מהירות הגישה גבוהה בהרבה, זהו רכיב חשמליFree behind & Read ahead – 19- ו 18אם כך רוב הסיכויים שנזדקק גם לבלוק . 17נניח כי יש לי צורך בבלוק ,

.אש בלוקיםבדומה רצוי לשחרר מר. כלומר הכנה מראש. ולכן רצוי לקרוא בלוקים עוקבים ולא רק בלוק אחדRAM disk – )virtual disk (דיסק שנמצא ב-RAM )כותבים וקוראים לשטח כאילו זה הדיסק). זיכרון ראשי .

.לא אמין. היום שימוש זה כבר לא נפוץ. מהירות –יתרון . כאשר החשמל נופל הכל הולך לאיבוד: חיסרוןDisk Track buffer – מטמון בבקר הדיסק המשמש לקראתtrack החל מהסקטור בו נמצאים(בבת אחת שלם .(

.חסכון בזמן רוטציה ובזמן העברה

Recovery - אמינות

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



).כי עליו עבדנו(ברוב המקרים הזיכרון יותר מעודכן Consistency checker – ב(בדיסק השוואה בין המידע בזיכרון לבין המידע-unix י הפקודה "נעשה עfsck.(

.והתקנים פיזיים אחרים system programs-י שימשו ב"ע –גיבויים

Loggingאמינות באמצעות במקרה של נפילה ניתן לדעת מה : יתרון. שבו נכתבים כל העדכונים לפני שהם מבוצעים בדיסק logמחזיקים קובץ

.ר הכתיבותהכפלת מספ :חסרון. נשמר לדיסק ומה לא



I/Oמערכות – 12פרק

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

I/O Hardware

מושגי יסודPort – device התקשורת של ה. י שליחת אותות דרך כבל או אפילו דרך האוויר"מתקשר עם המחשב ע-device עם

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

Controller – המפעיל אלקטרוניקהאוסף שלport ,bus אוdevice.

:לפנות בשני דרכים ניתן deviceלכל .ישירות I/Oפקודות .הרגיסטרים של הבקר ממופים לתוך מרחב הכתובות של המעבד – memory mapped I/O-שימוש ב

Polling .CPU-בכל שלב בודקים מי צריך את ה –תשאול

-ל ready bit-ומשנה את ה, )command registerדרך (ואז שולח פקוד , 0-יהיה ב busy bit-מחכה עד שה host-ה . ובודק את הפקודה busy bit-הבקר מעדכן את ה. 1

.כל הזמן מתבצעת בדיקה –שיטה לא טובה משום שהדיסק כל הזמן עובד . Pollingממתין נקרא host-השלב שבו ה

פסיקות interrupt handler-ה. בקשת פסיקה אסינכרוני דרך קו מיוחד, interruptשולח CPU-שיטה בה התקן שצריך את ה

.מקבל את הפסיקה :השיטה מתבססת על

.קיימים התקנים בעלי עדיפות גבוהה יותר –עדיפויות unmakable – מצב שבו לא יכולות להתקבל פסיקות.

.exceptions-שימושי ל

.interruptמעגל – 12.5שקף



)דיסק(מבנה הזיכרון המשני – 13פרק

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

.כותב הם בין הצילינדרים/פעולות הראש קורא

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

:זמן הגישה מושפע משני גורמים. ביותרSeek Time – כותב על הצילינדר המתאים/הזמן שלוקח לזרוע הדיסק להזיז את הראש קורא.

Rotational latency – כותב/זמן סיבוב הדיסק עד שהסקטור המבוקש נמצא מול הראש קורא. Disk bandwidth – מספר הבתים שעובדים לחלק לזמן שעבר מרגע שביקשנו את המידע = רוחב הפס של הדיסק

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

שיטות שונות לקריאות מידע מדיסקFirst come First Sarved - FCFS - ) גמא בספר י הדו"עפ. הולכים לפי הסדר. קבלת מידע סדרתית) 13.5שקף

.כותב/תזוזות צילינדרים של הראש קורא 640נקבל rstShortest Seek Time Fi - SSTF – ) אלא מחפשים את הבקשות , אין התייחסות לסדר הבקשה) 713.6/שקף seek timeכאשר המיון יעשה לפי , ממיינים את הרשימה והולכים לפי הרשימה הממוינת. מינימלי seek timeאם

.תזוזות 236י הדוגמא בספר מתקבלות "עפ. מינימלי : חסרונות

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

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

.במקרה זה עשויה הרעבה. לצילינדרים קרוביםSCAN ) בכל פעם . זרוע הדיסק נעה מהנקודה בה היא נמצאת לכיוון ההתחלה ומשם אל הסוף –) 913.8/שקף

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

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

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

.היא שלא נקרא את המידע לפי הסדר כאשר ייתכן והמידע הדרוש מצוי בין צילינדרים , 199ועד הצילינדר 0-הראש נע מהצילינדר ה

50-100. SCAN-C ) שיפור השיטה –) 1113.10/שקףSCAM : וכאשר , מהמיקום הנוכחי אל הצילינדר האחרוןהראש נע

כלומר מבצעים קריאה מצילינדר רק . ומשם שוב הולכים לסוף, 0-מוזזים את הראש ישירות לצילינדר ה, מגיעים אליו . כאשר מתקדמים קדימה

LOOK – שיטה זו דומה ל-SCAN , א המינימלי בדיסקול(אלא שהתנועה היא בין הצילינדר הימני ביותר המבוקש ( .SCANשל השיטה 3פתרון חסרון . לבין השמאלי ביותר

KLOO-C – ) בדומה –) 13.13שקף–SCAN-C :קריאה רק כאשר מתקדמים קדימה .



?במה נבחר .תלוי בכמות ובסוג הדרישות

SSTF היא השכיחה ביותר.

Disk Management 13.15שקף

tSpace Managemen-Swap הפתרון הוא . לעיתים קורה שכמות הזיכרון לא מספיקה לי. כאשר עובדים במערכת עובדים תמיד מול הזיכרון והדיסק

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

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

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

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

:יתרון .הרבה דיסקים קטנים וזולים במקום דיסק אחד גדול ויקר

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

RAID רבות שיפרו את RAIDשיטות , בנוסף. Redundant array of inexpensive disksכ "ארגון מסוג זה נקרא בדר

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

RAID level 0 – מערך של דיסקים)disk stripping.( level 1 RAID – נקרא גםmirroring אןshadowing . כל מידע נכתב גם לעותק. עותקים מכל דבר 2תמיד יהיו .

.במקרה של נפילה תמיד ניתן לשחר מהעותק .אמינות גבוהה

.פעולת כתיבה לוקחת זמן כפול, מספר כפול של דיסקים: חסרונותlevel 2 RAID – memory style error correcting code .שימוש בקוד המתקן שגיאות ברמת הבתים. .פחות דיסקים מהגישה הקודמת, מאוד אמין: יתרונותlevel 3 RAID – interleaved parity-Byte . קיים דיסקparity כל בית בדיסק מיועד . יחיד המתקן שגיאה אחת

הכתיבה מחשבים את הזוגיות של הבתים הנמצאים בכל הדיסקים באותה בזמן ). כל בית לדיסק(לכל יתר הדיסקים ברגע שדיסק אחד הלך או בלוק אחד הלך ניתן לשחזור . הזוגיות באותה כתובת בדיסק הנוסף bitוכותבים את , הכתובת .parity bit-י ה"אותו עפ .כתיבה דורשת גישה לכל הדיסקים: חסרונותlevel 4 RAID – ed parityinterleav-Block .בכל כתיבה מחשבים בלוק . הפעם מקצים בלוק לכל דיסק ולא ביתparity ולא ביט בודד.

level 5 RAID – interleaved distributed parity-Block .בלוק ה-parity נשמר בכל הדיסקים ולא בדיסק בודד.



אינדקס

A

Aging 30 c job sequencingAutomati 8

B

backing store 51 Bakery Algorithm 36

Best Fit 52 ,63 Binary semaphore 40 Bounded Waiting 34

Burst time 29

C

Circular wait 45 ,46 LOO-C 69

Common functions of Interrupts 12 Compaction 53

Compile time 49 context switch 23 ,27 ,31 ,51

text SwitchCon 61 Contiguous Allocation 51 ,63

Control Card interpreter 8 Control Cards 8 convoy effect 29

Cooperating process 24 Counting Algorithm 58 counting semaphore 40 CPU bound process 23

CPU Scheduler 27 I/O Burst Cycle-CPU 27 critical section 33 ,34, 35 ,37 ,38 ,39

SCAN-C 69

D

Deadlock Avoidance 46 Deadlock Characterization 44 ,45

Deadlock Prevention 46 avoidance-deadlock 45 prevention-deadlock 45

device controller 12 ,14 Device status table 13

Direct Memory Access 14 Disk Reliability 69

gdisk strippin 69 dispatch latency 28

dispatcher 28 ,51 Dispatcher 28

DMA 14 Mode operation-Dual 15

Dynamic Linking 49 Dynamic Loading 49

Allocation Problem-Dynamic Storage 52

E

entry section 33 Execution time 49

External Fragmentation 52 ,53

F

FCB 61 FCFS 29 ,30 ,31 ,68

First Fit 52 ,63 Fragmentation 52 ,63 ,65

frames 53

H

Hold and Wait 44 ,46 Hole 52

I

I/O bound process 23 I/O waiting queue 22

Independent process 24 input queue 49

Internal Fragmentation 52 ,63 Interrupt 12 ,13 ,21

Interrupt Vector 12 leInverted Page Tab 54

J

Job Pool 9 Job queue 22

L

limit register 22 ,51 Load time 49

Long term scheduler 22 LOOK 69

LRU Approximation Algorithm 58

M

Memory Management Unit 50 MMU 50 ,51

Multilevel Feedback Queue 32 Multilevel Queue 31

Partition Allocation-Multiple 52



iprocessingMult 7 Multiprogramming 7

Multitasking 7 Mutual exclusion 44 ,46 Mutual Exclusion 34

mutually exclusive 33

N

No preemption 44 ,46 preemptive-non 27 ,29 ,30

O

line operation-Off 8 System Service-Operating 18

overlays 50 Overlays 50

P

Page Fault 56 ,06 Page Replacement Algorithms 57

page table base register 54 page table length register 54

pages 53 Paging 53 ,56

PCB 21 ,22 ,29 ,54 ,56 polling 13

Positioning time 14 preemptive 27 ,30 ,32

Priority Scheduling 30 based scheduling-priority 51

Progress 34 BRPT 54

PTLR 54

Q

quantum 31

R

RAID 69 Ready queue 22

redundancy 69 relocation register 50 ,51 remainder section 33 Resident Monitor 8

roll out, roll in 51 Rotational latency 14 Robin Scheduling-Round 31

S

Safe State 47 SCAN 68

Seek time 14 segment table 55

segment table base register 55 segment table length register 55

Segmentation 55 Segmentation With Paging 55

Semaphores 38 Shared Pages 54

Short term scheduler 22 Shortest Seek Time Fi 68

term scheduler-short 28 Partition Allocation-Single 51

SJF 29 ,30 olingSpo 9

SRTF 30 SSTF 68 STBR 55 STLR 55

stub 49 swap in 51

swap out 51 ,60 Swapping 23 ,51

system call 13 ,15 ,16 ,19 ,23 ,24 ,44 System Calls 18

System Programs 19

T

Thrashing 59 Thread 25

Throughput 28 TLBS 54

Transfer Rate 14 ersaside buff-translation look 54

Trap 13 ,15 Turnaround 28

Table Scheme-Level Page-Two 54

U

user mode 15 ,19 ,23 ,28

W

Worst Fit 52 ,63

א

48, 47 אלגוריתם הבנקאיאלגוריתם ההזדמנות השנייה או אלגוריתם השעון

58

ה

63, 51 הקצאה רציפה 68, 46, 44, 32, 31, 30, 29, 10 הרעבה

ז



30, 92, 28 זמן המתנה 31, 28 זמן תגובה

כ

55, 54, 53, 51, 50 כתובת לוגית 50 כתובת פיזית

מ

14 מה משפיע על מהירות המחשב 45 מניעה

47 מצב בטוח

ק

48, 47, 46, 45, 44 קיפאון

ת

Interrupt 13-תהליך הטיפול ב

73עמוד סיכום נושאים ללימוד עצמי – מערכות הפעלה: קורס ' ת ב"פ :מכללת עמל 75מתוך

__________________________________________________________________________________


תוכן עניינים

6 הקדמה – 1פרק 6 הגדרה -מערכת הפעלה

6 מספר הגדרות חשובות

Simple Batch Systems 7

Multiprogramming Batch Systems 8 9 סוגים שונים של מערכות

10 מבנה מערכות מחשב – 2פרק Computer system operation 10

I/O Structure 14

Storage Structure 16

Storage Hierarchy 16

Hardware Protection 17

General System Architecture - 17 סיכום

18 מבנה מערכת ההפעלה – 3פרק Systems Components 18

Operating-System Service 19

System Calls 19

System Programs 19

System Structure 19

Virtual Machines 20

System Design And Implementation 20

System Generation 21

22 תהליכים – 4פרק Process Concept 22

Process Scheduling 22

Operation On Processes 24

Cooperating Processes 25

Threads 25

Inter-Process Communication - IPC 26

CPU 28תזמון – 5פרק Basic Concepts 28

Scheduling Criteria 29

Scheduling Algorithms 30


__________________________________________________________________________________


33 סנכרון תהליכים – 6פרק Background 33

The Critical-Section Problem 33

Synchronization Hardware 37

Semaphores 38

Classical Problems Of Synchronization 42

Deadlocks 44 – 7פרק System Model 44

Deadlock Characterization 44

Methods for Handling Deadlocks 45

Deadlock Prevention 45

Deadlock Avoidance 46

49 ניהול זיכרון – 8פרק Background 49

Logical Versus Physical Address Space 50

Swapping 50

Contiguous Allocation – 51 הקצאה רציפה

Paging 53

Segmentation 55

Segmentation With Paging 55

56 זיכרון וירטואלי – 9פרק Background 56

Demand Paging 56

Page Replacement 57

Page Replacement Algorithms 57

Allocation of Frames 59

Thrashing 59

Other Consideration 60

61 ניהול מערכת הקבצים – 10פרק File Concept 61

Access Method 61

Directory Structure 61

Protection 61

61 ארגון קבצים – 11פרק File-System Structure 61

Allocation Methods 63


__________________________________________________________________________________


Free-Space Management 65

Directory Implementation 65

Efficiency and Performance 65

Recovery - 65 אמינות

I/O 67ות מערכ – 12פרק I/O Hardware 67

68 )דיסק(מבנה הזיכרון המשני – 13פרק Disk Structure 68

Disk Scheduling 68

Disk Management 69

Swap-Space Management 69

Disk Reliability 69