Download סיכום לסיכום

‫ארגון המחשב‬
‫מהדר ‪-‬‬
‫‪ 4‬שלבים למהדר – ‪pre processing → compiler → assembler → linker‬‬
‫(‪ )1‬המהדר מבצע פקודות ב‪ #‬והופך הכל לקובץ ‪ header‬יחיד‪.‬‬
‫(‪)2‬מתבצע תרגום של שפות עיליות לשפת אסמבלר (שפת מכונה‪ ,‬שונה בין מחשב למחשב)‪.‬‬
‫‪( Reduced Instruction Set Computer – RISC‬מספר מופחת של פעולות)‬
‫‪Complex Instruction Set Computer – CISC‬‬
‫סיביות ובתים –‬
‫*בית = ‪ 8‬ביטים ‪ -‬ניתן לייצג אותו עם ‪ 2‬תווים ב‪.Hex‬‬
‫*אין הבדל בין ‪ int‬ל ‪long int‬‬
‫סידור מילים –‬
‫‪ – Big Endian‬הבית הימני בכתובת הגבוהה‪( .‬מימין)‬
‫‪ – Little Endian‬הבית הימני בכתובת הנמוכה‪( .‬משמאל)‬
‫*‪ printf int‬אינו רגיש לסדר הבתים בזיכרון – כלומר מדפיס את המילה כראוי ללא קשר סידורה בזיכרון‪.‬‬
‫*מהדרים שונים מסדרים כתובות באופן שונה‪ ( .‬בקוד שמסתמך על כתובות יכול להיווצר בעיית ‪ porting‬בגלל פונקציות גיבוב (קיצור המילה שתתאים לאורך הזיכרון))‪.‬‬
‫פקודות מכונה –‬
‫‪ 4 – RISC‬בתים מספיקים לייצוג כל הפקודות‪ – CISC .‬גודל משתנה של פקודה‪.‬‬
‫*לכל פקודה קידוד מספרי‪ .‬מחשבים שונים משתמשים בשיטות קידוד שונות‪.‬‬
‫לוגיקה פסוקית –‬
‫𝑛‬
‫ ניתן לבנות ‪ 22‬שערים לוגיים מעל ‪ n‬משתנים‪.‬‬‫‪ AND‬ו ‪ OR‬קומוטטיבי ואסוציאטיבי‪.‬‬
‫השוואה בין אלגברה מתמטיקה לבוליאנית‪ 3,6,8( .‬לא ניתנים להשוואה)‬
‫עוד דוגמאות לא נכונות במעבר – ביטוי של ^ על ידי | & ‪-‬‬
‫חיבור במספרים בינאריים –‬
‫‪ – half adder‬מחבר שני ביטים ומעביר את השארית השמאלית הלאה‪.‬‬
‫‪ – full adder‬מקבל את השארית מהמחוברים מימינו ומעביר את השארית השמאלית הלאה‪.‬‬
‫השארית השמאלית ב‪(a&b) – HA‬‬
‫השארית השמאלית ב‪((a&b)|((a^b)&i) – FA‬‬
‫פעולת זיזה (‪)shifting‬‬
‫*בהזזה אריתמטית (‪ )signed‬משכפלים את הספרה השמאלית – על מנת לשמור על הסימן של המספר בשיטת המשלים ל‪.2‬‬
‫*מגבלה על גודל זיזה – אם ‪ 𝑛 > 32‬אז מזיזים ב )‪(𝑛%32‬‬
‫*זיזה שמאלה ב‪( 𝑥 ⋅ 2𝑦 - y‬אם אין גלישה ‪ /‬החלפת סימן)‬
‫*זיזה ימינה ב‪floor)𝑥 ∕ 2𝑦 ) - y‬‬
‫קידוד ‪– int‬‬
‫טווח ייצוג ב‪ 32‬סיביות –‬
‫מעברי בסיסים –‬
‫מספר ‪ K‬בבסיס ‪ 10‬לבסיס ‪.B‬‬
‫לוקחים את שארית החלוקה ב‪B‬‬‫על תוצאת החלוקה ב‪ B‬מהשלב‬
‫הקודם‪.‬‬
‫שיטת המשלים ל‪– two's complement – 2‬‬
‫*אם ‪ x‬חיובי ‪−𝑥 = ~𝑥 + 1 -‬‬
‫המספרים הקיצוניים בייצוג (‪)signed‬‬
‫‪Tmax = 2𝑤−1 − 1‬‬
‫‪Tmin = −2𝑤−1‬‬
‫*קבועים נחשבים כברירת מחדל בתור ‪.signed‬‬
‫* בביטויים מעורבים – ‪ signed‬מומרים להיות ‪.unsigned‬‬
‫*הרחבה ‪ – sign extension‬מכפילים את הסיבית המשמעותית (סיבית הסימן) וכך הערך המספרי והסימן נשארים זהים‪.‬‬
‫אריתמטיקה מודולרית‬
‫*בחיבור ‪ unsigned‬משתמשים באריתמטיקה מודולרית‬
‫ואם תוצאת החיבור יוצאת גדולה יותר מ 𝑤‪ 2‬אז עושים לתוצאה ‪:‬‬
‫(שזה כמו לחשב את שארית החלוקה)‬
‫*בחיבור ‪ – signed‬שני סוגי גלישות ‪:‬‬
‫𝑤‪𝑢 + 𝑣 − 2‬‬
‫צריך להמיר ל‪ unsigned‬ואז לבצע פעולות אריתמטיות ואז לבצע המרה בחזרה ל‪.signed‬‬
‫מסכות‬
‫שברים – ‪floating point‬‬
‫‪. 𝑏𝑖𝑎𝑠 = 2‬‬
‫גדלים של הייצוג – * מבצעים הטיה של האקספוננט למספר ‪ unsigned‬על ידי ‪− 1‬‬
‫קטגוריות של מספרים –‬
‫• אם כל המספר אפסים – התוצאה תהיה ‪ ±0‬בהתאם לסיבית הסימן‪.‬‬
‫• אם כל האקספוננט אפסים ו ‪–frac>0‬התוצאה מייצגת מספרים שנקראים ‪)0.frac( denormalized‬‬
‫• אם כל האקספוננט אחדים ו ‪ – frac>0‬התוצאה מייצגת ‪( . NaN‬למשל 𝑖)‬
‫• אם כל האקספוננט אחדים ו‪ – frac=0‬התוצאה מייצגת ∞‪ ±‬בהתאם לסיבית הסימן‪.‬‬
‫* פעולות חישוביות עם ‪ FP‬יותר איטיות מאשר עם שלמים‪.‬‬
‫*אסוציאטיביות אינה נשמרת‪( .‬יש אופטימיזציות שאינן מתבצעות)‪.‬‬
‫*‪ - double  int‬המרה מדויקת‪.‬‬
‫*‪ -float  int‬הייצוג משתנה – תלוי בגודל ה‪ frac‬ואז מתבצע עיגול‪.‬‬
‫נוסחת מעבר ‪( 𝐸 + 𝑏𝑖𝑎𝑠 = 𝑒𝑥𝑝 -‬כאשר‪ denorm :‬אזי – 𝑠𝑎𝑖𝑏 ‪)𝐸 = 1 −‬‬
‫‪" – E‬המשקל" לפני ההטיה‪.‬‬
‫‪|ⅇ|−1‬‬
‫שפת מכונה – אסמבלי‬
‫קבוצה מינימלית של סוגי נתונים (שלמים בגודל ‪ 1,2,4‬ערכים עם כתובות)‪ ,‬פעולות בסיסיות בלבד‪.‬‬
‫מחסנית – לכל פונקציה נעשית הקצאה של מסגרת חדשה במחסנית‪ .‬המסגרת מכילה – משתנים מקומיים‪ ,‬פרמטריים מקומיים‪ ,‬כתובת לחזרה‪. R8 → frame pointer( .‬‬
‫‪ R7 → stack pointer‬המקום האחרון שנכתב למחסנית)‪ ,‬כתיבה במחסנית מלמעלה למטה (כתובות יורדות)‪* .‬בכל תחילה וסוף של פונקציה יש לבצע פקודות‬
‫אדמיניסטרטיביות (תחילה – לשמור ‪ R8‬במחסנית‪ ,‬לעדכן לפי הצבעה של ‪ R7(.R7‬של הקוראת הופך ל ‪R8‬של הנקראת)‪ ,‬סוף – שחזור של ‪)R7, R8‬‬
‫‪ – Add‬פקודת חיבור‪ ,‬אין הבדל בין ‪ signed‬ל‪. unsigned‬‬
‫‪ – Move‬הזזת מידע‪ .‬אין אפשרות להעביר מזיכרון לזיכרון במעבר אחד‪.‬‬
‫שיטות מיעון –‬
‫• ‪ – )R( – Normal‬רגיסטר ‪ R‬מכיל כתובת בזיכרון‪.‬‬
‫• ‪ R – D(R) – Displacement‬מציין התחלה של כתובת‪ D ,‬מציין ‪offset‬‬
‫• מערכים ‪ R4 – (R4,R6,4) -‬כתובת לתחילת מערך‪ R6 ,‬מספר הקפיצות (מיקום)‪ 4 ,‬מציין את גודל הקפיצה (טיפוס)‬
‫‪ -Leal‬מעבירה כתובת של זיכרון במקום את תוכנו‪.‬‬
‫‪ – Flag registers‬רגיסטר ייעודי בין סיבית אחת‪ .‬מופעלים בעת חישוב פעולות אריתמטיות‪.‬‬
‫בפעולת ה‪ OF ,a-b<0 SF ,a==b ZF( compare‬אם יש גלישה ב‪ )signed‬וה ‪ ZF( test‬כאשר ‪ SF ,a==0‬כאשר ש‪ )a&b<0‬ניתן‬
‫לשנות את ערכי דגלים אלו‪ .‬ב‪ compare a,b‬בודקים ‪. b-a>0‬‬
‫פקודת ‪ switch‬עדיפה על ‪ if‬כאשר אין חורים בטווח ערכים‪ .‬אך גודל הטבלה יכול להיות לא פרופורציונלי למספר הכניסות‬
‫לטבלה‪ .‬ה‪ jump table‬מכיל לייבלים שממורים לכתובות‪ – jmp *.L57( ,R1,4) .‬מידע הנמצא במיקום ‪ R1‬בטבלה (בקפיצות‬
‫של ‪ 4‬כי כתובות)‪ .‬כאשר ה‪ switch‬דליל מיישם את הערכים בעץ בינארי ומבצע חיפוש לוגי (ממיין בזמן ההידור וחוסך זמן)‪.‬‬
‫‪ CISC‬מכילים רגיסטרים מיוחדים לתנאים‪ ,‬בעוד ש‪ RISC‬משתמשים ברגיסטרים כללים‪.‬‬
‫אופטימיזציה‬
‫אופטימיזציה לא תלוית מכונה‪-‬‬
‫• מהדרים מתרגמים מרובי אופטימיזציה – מיפוי יעיל של תכניות לשפת מכונה (הקצאת רגיסטרים‪ ,‬והקלות "זולות" לחישוב מקומיות ושמרניות)‪.‬‬
‫לא יכולים להשפיע על סיבוכיות אסימפטוטית‪ ,‬אלא בפקטור קבוע ‪( .‬לא ניתן לבצע שיפור על מרכיבים רבים בקוד מחשש של תוצאות לווי)‪.‬‬
‫**מגבלות של מהדרים – אסור לשנות סמנטיקה של תכנית – מונע ביצוע שינויים של מקרי קיצון מיוחדים‪( .‬התנהגות תכנית לא מובן למחשב רק למתכנת)‪.‬‬
‫רוב הניתוח מבוצע על ידי המהדר בתוך פרוצדורות ולא ביניהן (לא יעיל ומעשי לעבור על כל התכנית)‪ ,‬בדיקה ע"י פעפוע קבועים‪ inlining ,‬בקבצים‪ .‬מבוסס על מידע‬
‫סטטי (לא מזהה קלט בזמן ריצה)‪ ,‬חייב להיות שמרני!‪.‬‬
‫• הקטנה של מספר פעמים שקוד רץ‪ ,‬לדוגמה הוצאת קוד זהה מלולאה‪.‬‬
‫• החלפה של אופרטורים יקרים – להחליף כפל וחילוק בזיזה וחיבור‪.‬‬
‫• שימוש ברגיסטרים ‪ -‬שימוש ברגיסטרים הרבה יותר מהיר מגישה לזיכרון‪ .‬נותן עדיפות למשתנים זמניים (ניתן לקבוע אילו משתנים ייקח ע"י ‪)register‬‬
‫• צירוף ביטויים משותפים – בדר"כ לא מנצלים ידע אריתמטי‪.‬‬
‫מדידת ביצועים – חישוב זמן ריצה הנצרך על ידי קטע קוד מסוים‪ ,‬שימוש ב‪( profiler‬מספר הקריאות לפונקציה) (שלבים – הרץ תכנית לאיסוף סטטיסטיקות‪ ,‬הידור מחדש)‬
‫יתרונות ל‪ – profiling‬עוזר לזהות צווארי בקבוק בביצועים‪ ,‬שימוש בעיקר במערכת מרוכבת עם רכיבים רבים‪ .‬מגבלות – תלוי קלט‪ ,‬מנגנון חישוב זמן לא מאוד מדויק‪.‬‬
‫מדדי זמן – זמן אבסולוטי‪ :‬בדר"כ ננו‪-‬שניות (למשל ‪ ,) clock period=0.5ns – 2GHz‬ניתן למדוד זמן ע"י פונקציית ספריה (מזן מההתחלה עד לסוף‪ ,‬וזמן בתוך ה‪)CPU‬‬
‫‪ – CPE‬דרך נוחה למדוד ביצועים במקרה של רשמית נתונים‪.‬‬
‫חוסמי אופטימיזציה (‪ – )Memory aliasing‬שני מצביעים יצביעו לאותה כתובת‪.‬‬
‫אופטימיזציה תלוית מכונה –‬
‫שימוש במצביעים – מצביעים במקום גישות למערך‪( .‬מאפשר להפטר מהמונה)‪ .‬לא בהכרח עוזר‪ ,‬תלוי במבנה מעבד‪.‬‬
‫•‬
‫פרישת לולאה –חוסך תקורה של הלולאה‪ pipeline( .‬ל‪ – load‬עד ‪ . )3‬בלוק בסיסי יותר של פעולות (יותר חופש למהדר לבצע אופטימיזציה)‪.‬‬
‫•‬
‫הצנרה (‪ – )pipeline‬ניתן לבצע מספר רכיבים של פקודות שונות בו זמנית‪( .‬חלקים שונים של אותה פעולה מבוצעים ע"י רכיבים שונים)‪.‬‬
‫•‬
‫ביצוע מקבילי – לפרק את המכפלה הסדרתית לשתי מכפלות סדרתיות‪ .‬מגבלות – שימוש רב ברגיסטרים (‪ 6‬ל‪ 8 int‬ל‪ float‬ושיש חוסר מועבר לזיכרון ראשי)‪.‬‬
‫•‬
‫הסתעפויות – חוזים מצב של הסתעפות – חיזוי סטטי‪ ,‬דינמי (לא בהכרח נכון)‪( .‬הסתעפות בפונקציות וב‪)if‬‬
‫•‬
‫היררכית זיכרון‬
‫יחידת זיכרון בסיסית (תא) יכולה לאחסן סיבית אחת‪.‬‬
‫)‪ – Static RAM(SRAM‬אחסון סיבית בעזרת מעגל של ‪ 6‬טרנזיסטורים‪ ,‬מאחסן מידע באופן בלתי מוגבל‪ ,‬יחסית לא רגיש להפרעות חשמליות‪.‬‬
‫•‬
‫)‪ – Dynamic RAM (DRAM‬אחסון הסיביות בעזרת קבל וטרנזיסטור‪ ,‬יש "לחזק" מחדש את המידע כל ‪ 0.1‬שניות‪ ,‬רגיש להפרעות‪ ,‬איטי וזול יותר מה‪.SRAM‬‬
‫•‬
‫ה‪ SRAM‬וה‪ DRAM‬הם זיכרונות נדיפים – מאבדים מידע כשאין חשמל‪.‬‬
‫זיכרונות לא נדיפים נקראים )‪– Read-Only-Memory(ROM‬‬
‫‪Programmable ROM – PROM‬‬
‫•‬
‫‪Erasable programmable ROM – EPROM‬‬
‫•‬
‫‪Electrical erasable PROM – EEPROM‬‬
‫•‬
‫זיכרונות הבזק (‪ – )Flash memory‬דומה ל‪ EEPROM‬אבל מאפשר כתיבה‪/‬מחיקה של בלוקים קטנים‪.‬‬
‫•‬
‫‪ – Firmware‬מאחסנים תכנית ב‪ – ROM‬תכניות העולות בזמן עליית המחשב‪.‬‬
‫*ההיררכיה נובעת מהלוקאליות‪ -‬לתכניות שכתובות היטב יש לוקאליות (זמן–אותם משתנים בהפרשי זמן קטנים‪ ,‬מקום‪-‬מידע סמוך בזיכרון)‬
‫זיכרון מטמון‪ -‬זיכרון קטן ומהיר‪ ,‬משמש "מבוא" לזיכרון גדול ואיטי יותר‪( .‬כל ‪ K‬משמש זיכרון מטמון עבור הרמה ה‪ k+1‬בהיררכיה)‪.‬‬
‫‪ :write-through‬בעת קריאה של ערכים–מביא את הערכים מרמות נמוכות עד לרמות קרובות ל‪ K( CPU‬קטנים)– יוצר עותקים קרובים יותר על מנת ליצור גישה מהירה יותר‪.‬‬
‫בעת כתיבה של ערכים – משנה את ערכם ב‪ CPU‬ואז מעדכן עד למטה לדיסק (לערכי ‪ K‬גדולים יותר) כדי שהעדכון ישמר ולא יימחק (בגלל שאם נשמור רק במקומות עם ‪K‬‬
‫קטנים אז השינוי יכול להימחק)‪ :write-back .‬בעת כתיבת ערכי ם לא מעדכן ישר לרמות נמוכות (‪ K‬גדול)‪ ,‬אלא מחכה עד לרגע שבו נצטרך לדרוס אותם ורק אז יוצר עותק‬
‫שלהם ברמה נמוכה יותר‪.‬‬
‫בחירה של בלוק לפינוי –‬
‫• ‪ :Direct-map‬לפי שיוך ידוע מראש של בלוק ברמה ה‪ k+1‬לבלוק ברמה ה‪( .k‬אחד לאחד)‬
‫• ‪ :Associative map‬ללא מגבלה‪ .‬למשל לפי מדיניות ‪ – LRU‬מפנה את הבלוק שהשתמשו‬
‫• בו לפני הכי הרבה זמן‪( .‬הכל לכולם)‬
‫• משהו באמצע‪ 4-way-associative :‬בלוק ברמה ‪ k+1‬משויך לאחד מ‪ 4‬מקומות בבלוק ‪.k‬‬
‫גודל הבלוק משתנה בין רמות‪.‬‬
‫‪:Cache-misses‬‬
‫• ‪ – Cold miss‬זיכרון המטמון ריק‪.‬‬
‫• ‪ – Capacity miss‬זיכרון המטמון קטן מדי‪ ,‬התכנית זקוקה למידע זמין יותר מגודל זיכרון המטמון‪.‬‬
‫• ‪ )direct map( Conflict miss‬בזיכרון מיפוי ישיר הזיכרון ברמה ‪ K‬מגביל את המיקום של הבלוקים‬
‫מרמה ‪ k+1‬ולכן ייתכן שייווצר מצב שרמה ‪ K‬מספיקה לתכנית מסוימת אך תמיד יקראו אותם‬
‫בלוקים מ‪ k+1‬כי המיקום המיועד להם ברמה החדשה הוא זהה‪.‬‬
‫מדדים לביצועים של זיכרון מטמון –‬
‫• ‪ – Miss rate‬מספר הפעמים שהמידע שחופש לא נמצא ב‪ / cache‬מספר הפניות הכללי לזיכרון‪.‬‬
‫• ‪ – Hit time‬הזמן שלוקח להעביר שורה מה‪ cache‬למעבד (כולל הזמן לקבוע אם המידע נמצא שם)‪.‬‬
‫• ‪ – Miss penalty‬הזמן הנוסף כאשר המידע לא נמצא ב‪.cache‬‬
‫מערכות הפעלה‬
‫תהליך(‪ – )process‬תכנית שכרגע רצה‪.‬‬
‫לכל תהליך של מזהה שנקרא – ‪process ID – PID‬‬
‫אפשר להפעיל תהליך –‬
‫מתוך תהליך של מערכת הפעלה (‪ ,cmd‬דאבל קליק)‬
‫מתוך תהליך משתמש (קריאה ל‪ ,system‬קריאה ל‪) fork‬‬
‫תת‪-‬תהליך(‪( )thread‬חוט*)‬
‫אפשר להפעיל תת תהליך רק מתוך תהליך בזמן ריצה‪.‬‬
‫כל התתי תהליכים עובדים באותו מרחב כתובות וירטואלי‪( .‬ניתן לחלוק מידע על ידי משתנים גלובלים)‬
‫הזיכרון של כל התתי תהליכים מוגבלים בזיכרון של התהליך הראשי‪.‬‬
‫‪ – fork‬משכפל את הקוד בזיכרון ויוצר תת תהליך (נפרד לראשי) שמתבצע בו זמנית ובאותו מרחב וירטואלי‪.‬‬
‫*בתור משתמש אין שליטה על סדר התור בין התהליכים‪ – .‬הסדר הוא "שרירותי"‪ ,‬תלוי במערכת ההפעלה‪.‬‬
‫ריבוי תהליכים (‪)multitasking‬‬
‫החלף בין תהליכים מספיק מהר כדי שייראה כאילו רצות במקביל‪.‬‬
‫נעשה על ידי סירוג תהליכים (‪ – )interleaving‬מערכת ההפעלה מאפשרת זאת על ידי זמנון‬
‫(‪ ) CPU scheduling‬הוגן‪ .‬מתבצעת הגנה על ידי כך שתהליכים לא יכולים לשנות תהליכים אחרים‬
‫(מתבצע על ידי הפרדה לזיכרון וירטואלי ופיזי)‬
‫החלפת הקשר (‪ )context switch‬מריצה תהליך לקוונטה (‪ )Quantum‬של זמן‪.‬‬
‫עוצרת אותו ושומרת על מצבו ומכניסה את התהליך הבא בתור‪.‬‬
‫המידע שנשמר בהחלפת הקשר (נשמר במבנה נתונים שנקרא ‪– )Process Control Block‬‬
‫• הכתובת בזיכרון של הפקודה הבאה לביצוע (‪)Program Counter‬‬
‫• המצב של הרגיסטרים (‪)CPU registers‬‬
‫• אם יש קריאה של קובץ (‪)File access pointer‬‬
‫החלפת הקשר מתבצעת כאשר –‬
‫• המתנה לקלט‬
‫• כניסה למצב המתנה ‪( wait‬למשל על ידי סמפור)‬
‫• כניסה למצב השעיה‪ .‬למשל על ידי ‪sleep‬‬
‫*זמנון מסודר ‪ -‬מערכות הפעלה מודרניות מאלצות תהליכים לוותר על ה‪ CPU‬אם הם נשארים שם זמן רב‪.‬‬
‫קוצב קבוע (‪ – )fixed timer‬כל ‪ X‬יחידות זמן מחליפים תהליך‪.‬‬
‫קוצב משתנה (‪ – )variable timer‬מערכת ההפעלה קובעת אחרי כמה זמן מחליפים תהליך‪.‬‬
‫ביצוע החלפת התהליך –‬
‫ההחלפה נעשית על ידי רוטינה ייעודית–ניגשת למקום ידוע מראש בזיכרון ושולפת את הכתובת של התהליך‬
‫עם העדיפות הגבוהה ביותר‪.‬‬
‫למערכת ההפעלה יש טבלת תהליכים (‪ )PCB – Process Control Block‬שבה יש רשומה לכל תהליך (מזהה תהליך הוא ‪. )PID‬‬
‫*תור הממתינים לריצה – תור דו‪ -‬כיווני הממוין לפני העדיפות (מחושבת לפי ‪ ,base priority ,PCB‬ופקטורים נוספים)‪.‬‬
‫המיקום הראשון מוגדר בזיכרון וכך מערכת ההפעלה י ודעת לאן לגשת בשביל לקחת את התהליך עם העדיפות הגבוהה ביותר‪.‬‬
‫זמן שהייה במעבד (‪ )Quantum‬לא אחיד בין תהליכים שונים‪.‬‬
‫*הפונקציה המתארת את העדיפות של תהליך ‪ j‬לפי פרק הזמן ‪ i‬לא תהיה קבועה (שיניים)‪.‬‬
‫ניתן "להחליק" אותה על ידי פונקציה החלקה ‪: 𝑦𝑖 = 𝑎𝑥𝑖 + (1 − 𝑎)𝑦𝑖−1 :‬‬
‫כאשר ‪ a=0‬הגרף יהיה קו ישר מקביל לציר ‪ , x‬וכאשר ‪ a=1‬הפונקציה לא תשתנה מהמקור‪.‬‬
‫כל ערך בין ‪ 0‬ל‪ 1‬ייצור גרף "חלק" יותר ויאפשר לנו לקבל מגמתיות ברורה יותר (קו מגמה)‪.‬‬
‫בחירת מדיניות זמנון –‬
‫• ניצול מקסימלי‬
‫• מזעור תקורה (זמן שמנוצל על ידי משאבים אך לא תורם‬
‫באופן ישיר לביצוע המשימה – "זמן מבוזבז של החלפות הקשר")‬
‫• זמן תגובה מינימלי (לטבלת משתמשים אינטראקטיבית)‬
‫• הספק – מספר תהליכים שמסיימים בפרק זמן נתון‪.‬‬
‫אלגוריתמי זמנון‬
‫אופטימיזציה ללא כל הקלט מראש – ‪online algorithm‬‬
‫* ‪ – FIFO – )FCFS( First Come First Serve‬נותן עדיפות לתהליכים צורכי מעבד‪ ,‬העדיפות ניתנת למי ששולח הרבה ע בודות מוקדם‪ ,‬לא מספק רציפות מדומה‪.‬‬
‫*‪ – )SJF( Shortest Job First‬מוסדר או לא מוסדר‪ ,‬תהליך בעל יתרת זמן נמוכה ביותר ייכנס ראשון‪ ,‬דורש ניבוי של זמן ריצה של תהליך‪.‬‬
‫ יכול ליצור בעיות רבות עם תהליכים ארוכים‪ .‬פתרון ‪ :‬מדיניות ‪ , bypass and freeze‬הוותק מחושב ע"י‬‫כאשר ‪ K‬הוא קבוע שמעיד על החשיבות שהענקנו לזמן ההמתנה‪ .‬לוקחים את התהליך עם '‪ c‬הנמוך ביותר‪.‬‬
‫*אלגוריתם מוסדר – אלגוריתם שבו תהליך נכנס למעבד ולא מסיים את כל ריצתו בפעם אחת (נותן מקום לתהליך עם עדיפות גבוהה משלו‪ ,‬או הולך ל‪)IO‬‬
‫*‪ – )RR( Round Robin‬מחלקים את הזמן למרחבי זמן קבועים (‪ ,)Quantum‬כל התהליכים מאורגנים בתור מעגלי ‪ ,‬נכנסים לעיבוד לפי סדר הופעתם בתור‪ ,‬כל תור מקבל‬
‫לכל היותר ‪ Quantum‬בסיבוב‪.‬‬
‫תכונות – מוסדר‪ ,‬תלוי ב‪ ,Quantum‬עבור ‪ Quantum‬גדול שקול ל‪ q . FCFS‬קוונטה‪ n ,‬תהליכים לביצוע לפני תהליך נוכחי‪ nq ,‬זמן תגובה (עד התחלת התהליך)‪ ,‬נרצה‬
‫להקטין את הקוונטה מבלי להגדיל מדי את התקורה של החלפות ההקשר‪.‬‬
‫אם תהליך הוא קצר מהממוצע עדיף לו להיות ב‪.RR‬‬
‫*‪ n-1 – multilevel feedback‬תורי של ‪ FCFS‬ולמטה תור של ‪. RR‬‬
‫נותן עדיפות לתהליכים אטרקטיביים‪ Base-priority ,‬קובע כמה נמוך אפשר לרדת‪.‬‬
‫סנכרון בין תהליכים‬
‫תהליכים יכולים להתחרות על משאבים ביניהם (מ"ה מתזמנת ומגנה עליהם)‪ ,‬והם יכולים לשתף פעולה ולהתחלק במשאבים‬
‫(מ"ה מספקת אמצעים לחלוקה ולקשר‪ ,‬שיתוף הפעולה נעשה על ידי שיתוף זיכרון או תקשורת)‪.‬‬
‫דרישות בסיסיות מתהליכים למען שיתוף פעולה על ‪ data‬משותף –‬
‫• מניעת הדדיות (‪ – )mutual exclusion‬אם תהליך אחד מבצע את הקטע הקריטי‪ ,‬אף תהליך אחר לא מבצע אותו‪safety– .‬‬
‫• חוסר הרעבה – תהליך שרוצה להיכנס לקטע הקריטי בסופו של דבר נכנס אליו‪ .‬תכונה ‪liveness‬‬
‫דורש‪ ,‬בין היתר‪ ,‬שלא יהיה חבק (‪ :) deadlock‬מעגל של תהליכים בו כל אחד ממתין לשני‪.‬‬
‫הוגנות תהליכים (‪ – )process fairness‬אם תהליך רוצה ויכול להתקדם אינסוף פעמים‪ ,‬הוא מתקדם‪.‬‬
‫צריך להגן על קטעים קריטיים צריכים להיות סופיים‪ ,‬קטעים לא קריטיים לא דורשים הגנה ויכולים להיות אינסופיים‪.‬‬
‫האלגוריתם של פטרסון – אלגוריתם נכון אך סובל משתי בעיות עיקריות – קשה להרחיב ליותר משני‬
‫תהליכים‪ ,‬דורש לדעת מראש כמה תהליכים יש‪ .‬אלגוריתם המאפייה – ‪-‬יש בעיית גלישה עם מונה אינסופי ‪.‬‬
‫יכולה להיות בעיה של סירוג ואז שני תהליכים מקבלים את אותו מספר בתור‪ .‬פקודות אוטומטיות של המעבד –‬
‫פקודות מכונה – ‪exchange – XCHG compare and swap – CAS test and set – TAS‬‬
‫סמפורים‬
‫באמצעות ה‪ TAS‬ניתן למשש סמפורים – מנגנון לתאום בין תהליכים ובין תתי תהליכים‪ .‬מאפשר לכך שרק (תת) תהליך אחד יריץ אץ הקטע הקריטי של הקוד‪ .‬תור הממתינים מנוהל ב‪. FIFO‬‬
‫המנגנון מורכב מ – מונה‪ ,signal , wait ,‬פקודות נוספות לאתחול וכו'‪ .‬חוסך ‪ – busy wait‬מצב בו מתבצעות דגימות מרובות לבדיקת זמינות המעבד‪ .‬חוסך על ידי הכנסת תהליכים למצב ‪.sleep‬‬
‫!*כשיש יותר מסמפור אחד צריך להי זהר ממצב של חבק – מעגליות בין הסמפורים השונים תיצור חבק‪.‬‬
‫* כאשר רוצים לנהל מבנה זיכרון משותף בין תהליכים ניתן ליצור ‪ struct‬חדש שבנוסף למאפיינים הרגילים שומר סמפור עצמי שמאפשר בכל פעם רק לתהליך אחד לגשת לזיכרון של האובייקט‪.‬‬
‫ישנה טבלה של סמפורים ששומרת את ‪ -‬מצב הסמפור (בשימוש ‪ /‬לא)‪ ,‬המונה המשויך לסמפור‪ ,‬מצביעים לתור הממתינים של הסמפור‪.‬‬
‫פקודת ה‪ wait‬מורידה את ערך המונה באחד – אם ערך המונה שלילי התהליך נכנס למצב ‪ WAIT‬עד שיתאפשר לו להיכנס למעבד‪-( .‬מונה חיובי ‪ :‬מספר המשאבים הפנויים‪ .‬מונה שלילי ‪:‬‬
‫מספר ממתינים‪ ).‬מכניסה לרשומת התהליך את מזהה הסמפור‪.‬‬
‫פקודת ה‪ signal‬מעלה את המונה באחד‪ .‬אם לפני ההוספה המונה היה שלילי (תור הממתינים אינו ריק) מוציאה את הראשון בתור‪ ,‬ומכניסה אותו לתור ה‪( .ready‬יש גם ‪ signal_n‬שקולה לביצוע‬
‫‪ n signal‬פעמים אך יעיל יותר)‪ .‬פעולת ‪ s_create‬יוצאת סמפור ומאתחלת את ערך המונה‪ .‬המערכת קובעת את המספר המזהה של כל סמפור‪ .‬פעולת ‪ s_delete‬בודקת שהסמפור חוקי ואינו‬
‫משוחרר‪ .‬מעבירה את כל התהליכים בתור הממתינים לתור ה‪. ready‬מסמנת בטבלת הסמפורים שהסמפור משוחרר‪ .‬פעולת ‪ s_reset‬מעדכנת את המונה לערך חיובי (שקולה ל‪ delete‬ו‪create‬‬
‫אך יעילה יותר)‪ .‬מעבירה את כל התהליכים מתור הממתינים לתור ה‪( .ready‬לא ניתן לעדכן לערך שלילי – אמור לשקף את מספר התהליכים בתור הממתינים) ‪.‬‬
‫העברת הודעות בין תהליכים‬
‫מאפשר העברת מידע בין תהליכים‪ ,‬הפצת מידע ברשת מחשבים‪ ,‬תאום בין תהליכים‪.‬‬
‫אופני שליחת הודעה –‬
‫• מתהליך לתהליך – ‪Unicast‬‬
‫• מתהליך לקבוצה – ‪Multicast‬‬
‫• מתהליך לכולם – ‪Broadcast‬‬
‫• מתהליך לתיבת דואר – ‪Mailbox‬‬
‫אופנים לקבלת הודעות –‬
‫• מתהליך מסוים ‪one-to-one :‬‬
‫• מתהליך כלשהו ‪any-to-one :‬‬
‫• מתהליך כלשהו לקבוצה ‪any-to-any :‬‬
‫*אם תהליך שולח הודעה לתהליך אחר יש צורך לדעת את המציין של המקבל‪.‬‬
‫גישות סנכרון בין משלוח וקבלה‬
‫• גישה סינכרונית – השולח ממתין עד שהמקבל קורא את ההודעה‪.‬‬
‫המקבל ממתין עד למשלוח הודעה (עדיין לא נשלחה)‪.‬‬
‫• גישה אסינכרונית – השולח לא ממתין עד לקריאת ההודעה ע"י המקבל‪.‬‬
‫המקבל בודק אם קיימות עבורו הודעות וממשיך בתהליכו ללא המתנה‪.‬‬
‫גישות מעורבות ‪-‬‬
‫*שולח סינכרוני ומקבל אסינכרוני‪.‬‬
‫*שולח אסינכרוני ומקבל סינכרוני (שולח לא ממתין‪ ,‬מקבל ממתין – בשימוש רב)‬
‫בגרסה זו ניתן להעתיק את ההודעה ישירות ללא במתווכים‪.‬‬
‫תיבות דואר – אינה דורשת מהשולח לדעת מיהו התהליך המקבל אלא רק‬
‫להכיר את תיבת הדואר‪ .‬את ההודעה יקבל התהליך הראשון שיקרא מהתיבה‪.‬‬
‫באמצעות תיבת הדואר ניתן ליצור מספר תהליכי שירות המקבלים הודעות‪ ,‬שאינם‬
‫נדרשים לבחור את המקבל‪( .‬דוגמא – ניהול תור למדפסת)‬
‫שרתים – המשתמש רואה ביצוע סדרתי‪ .‬המערכת דואגת לביצוע נכון של פעולות‪.‬‬
‫זיכרון וירטואלי‬
‫יש הפרדה בין הכתובת הוו ירטואלית (שהתהליך מכיר) לבין הכתובת הפיזית בה המידע נשמר‪.‬‬
‫הקצאות זיכרון לוגי(בזמן הידור ‪-‬משתנים גלובאליים‪ ,‬או בזמן ריצה – ‪ ) new, malloc‬נעשות ברמת תהליך‬
‫(אין מודעות לתהליכים אחרים)‪.‬‬
‫* נדרש מנגנון תרגום בין וירטואלי לפיזי (טבלאות תרגום)‪ .‬תמיכה מבחינת החומרה ומערכת ההפעלה‪.‬‬
‫ה‪ MMU‬מפרש את הכתובת הווירטואלית לכתובת פיזית‪**( .‬טבלת דפים=טבלת תרגום)‬
‫*הפרדה זו עולה בזמן – גישה כפולה לזיכרון (לטבלת תרגום ולהבאת הערך)‬
‫* לכל תהליך טבלת דפים משלו – בזמן החלפת הקשר טבלת הדפים של התהליך עולה למקום מוגדר בזיכרון‪.‬‬
‫*עמוד (לוגי) מועתק למסגרת (פיזי) כאשר התוכן אינו משתנה – ה‪ offset‬של התוכן הפנימי של העמוד נשאר זהה‪.‬‬
‫*טבלת הדפים יכולה להכיל רשומות ריקות (חורים בזיכרון הווירטואלי) – ניתן לתקן על ידי היררכית של טבלאות דפים‪ * .‬מ"ה שומרת טבלת מסגרות בה מפרטת לכל‬
‫מסגרת האם מוקצית (למי) או פנויה‪.‬‬
‫אם המסגרת בדיסק ולא ב‪ – RAM‬נוצרת פסיקה ‪ page fault‬ומ"ה – מעבירה את התהליך למצב המתנה (בשל אריכות ההחלפה)‪ ,‬ואז מבצעת ‪ paging( swapping‬דפדוף‬
‫בין דפים) (‪ swap-out‬מוציא מסגרת מ‪ RAM‬לפי ‪ ,LRU‬ו‪ swap-in‬מכניס מסגרת חלופית ל‪ )RAM‬ומעדכנת ‪ ,valid-bit‬ולבסוף מחזירה את התהליך למצב ריצה‪( .‬בזמן הוצאת‬
‫המסגרת לדיסק‪ ,‬הזיכרון הפיזי אבד‪ ,‬והערכים שהיו ב‪ cache‬הופכים ל‪.)invalid‬‬
‫)‪ – Translation Lookaside Buffer (TLB‬משמש כזיכרון מטמון לתרגומים‪ .‬בגלל הגישה הכפולה לזיכרון נרצה לשמור את הכתובות בטבלת התרגום שבהן משתמשים הרבה‬
‫(לצמצום התקורה) ועל כן נחזיק ‪ cache‬שבו ישמרו הכתובות השימושיות יותר‪( .‬כאשר מתבצעת החלפת הקשר ה‪ TLB‬יימחק – בגלל שלכל תהליך טבלת תרגום שונה)‪.‬‬
‫* תקורה של זיכרון מדומה‪ .‬כאשר מביאים דפים מהדיסק מביאים‬
‫זמן גישה לזיכרון – מחושב ע"י–‬
‫מפנים מקום לפי ה‪ ,LRU‬מנסים לשמור על ‪ working set‬קטן‪.‬‬
‫מספר דפים שקרובים זה לזה‪,‬‬
‫יתרונות לזיכרון וירטואלי – מפשט את ניהול הזיכרון (תהליך לא יכול לכתוב על זיכרון של תהליך אחר)‪ ,‬משלב את הדיסק כהרחבה של הזיכרון הראשי (מהווה זיכרון מטמון‬
‫לדיסק – זמן גישה לדיסק גדול פי ‪ )1000‬עובד בשיטת ‪ .write-back‬כל תהליך יכול להשתמש במרחב כתובות רציפות של עד ‪( 4GB‬ב‪ 32‬סיביות)‪.‬‬
‫הקצאת זיכרון דינאמי‬
‫‪– Malloc‬בודקת האם נשאר בלוק בגודל הרצוי‪ ,‬אם אין מבקש דף חדש (מבקש מסגרת חדשה פנויה)‪ .‬הערך שנמצא בזיכרון שהוקנה לנו הוא שרירותי‪int *ip = (int*) .‬‬
‫))‪malloc(100*sizeof(int‬‬
‫‪ – Calloc‬כמו ‪ malloc‬רק שמאפס את ערכי הזיכרון לפני שמחזיר אותו לשימוש‪int *ip = (int*) calloc(100, sizeof(int)) .‬‬
‫‪ – Realloc‬מנסה להקנות זיכרון נוסף לזיכרון שכבר הוקנה‪ .‬אם קטן יותר משחרר חלק מהזיכרון (מאפשר להקצאות חדשות שם) ואם גדול יותר מחפש מקום ואם אין מקצה‬
‫זיכרון חדש ומעתיק את התוכן הקיים לשם‪*ip = realloc(void * ptr, new size) .‬‬
‫‪ – Heap‬כאשר מתבצעות הקצאות דינאמיות במהלך ריצה‪ ,‬הם נכתבות בתחתית הזיכרון‪ ,‬כאשר המחסנית נכתבת מלמעלה‪.‬‬
‫*‪ - stack overflow‬כאשר יש מצב בו מגיעים להתנגשות בין המיקום כתיבה של המחסנית לבין מיקום הכתיבה של ההקצאות הדינאמיות‪.‬‬
‫*‪ malloc‬מחזיקה רשימה מקושרת של השטחים הפנויים בזיכרון (שנקראת ‪ – memlist‬לכל מקום פנוי הרשימה מחזיקה את גדול השטח‪,‬‬
‫ומצביע לשטח הפנוי הבא‪.‬‬
‫*לא יופיעו ברשימה שני שטחים פנויים רצופים (יאוחדו לאחד)‪ .‬כתובות ואורכים הם בכפולות של ‪.8‬‬
‫שיטות הקצאה‬
‫• ‪ :First-fit‬השטח הפנוי המתאים הראשון שנמצא ברשימה‪.‬‬
‫• ‪ : Next-fit‬השטח הפנוי הבא (מתחילים את הסריקה מהמקום האחרון שהוקצה)‬
‫• ‪ :Best-fit‬השטח הפנוי הקטן ביותר האפשרי‪.‬‬
‫• ‪ :Worst-fit‬השטח הפנוי הגדול ביותר‪.‬‬
‫שחרור שטחי זיכרון – צריך לאחד אותו עם שטחים פנויים צמודים כדי ליצור את השטח הפנוי הגדול ביותר שניתן לקבל (אין ברשימה שני שטחים פנויים צמודים)‪.‬‬
‫שברור של הזיכרון (‪– )fragmentation‬‬
‫שברור פנימי – שטחי זיכרון מוקצים שאין בהם שימוש על ידי התהליך הנוכחי‪.‬‬
‫שברור חיצוני – שטחי זיכרון לא מוקצים‪ ,‬אך קטנים מידי להקצאה‪( .‬בדיסק יש בעיה דומה אך שם יש גם הקצאה לא רציפה)‪.‬‬
‫!* כך נוצרת בעיה שלא ניתן לבצע הקצאה גדולה למרות שסכום השטחים מספיק‪.‬‬
‫פתרונות ‪-‬‬
‫הידוק זיכרון (‪ – )compaction‬פתרון אפשרי לשברור חיצוני – פעם בכמה זמן או לפי דרישה ניתן "לאגד" את כל הזיכרון כך שיישאר יותר זיכרון רציף‪ .‬הידוק דורש עדכון‬
‫מצביעים לכתובות החדשות‪( .‬פתרון אפשרי ‪-‬אם ל‪ malloc‬אין זיכרון רציף להחזיר‪ ,‬מבצעים הידוק)‪.‬‬
‫** הידוק בדרכ מתייחס לזיכרון‪ ,‬אבל יכול להתייחס גם לדיסק‪.‬‬
‫איחוי (‪ – )defragmentation‬בדרכ מתייחס לפעולות על הדיסק‪ ,‬פעולה שמסדרת מחדש את 'שברי' הקבצים כדי שיהיו רציפים‪( .‬לא בהכרח יזיז קבצים שלמים על מנת‬
‫ליצור שטח פנוי גדול)‪.‬‬
‫*בקבצים‪ ,‬לא כמו ב‪ malloc‬אין חובת רציפות‪ ,‬ולכן דה‪ -‬פרגמנטציה נחוצה רק בשביל להאיץ את הסריקה שלהם‪.‬‬
‫‪ – Garbage collection‬איסוף של בלוקים מה‪ heap‬שהוקצו אך אינם בשימוש‪.‬‬
‫ניתן לדעת לאיזה בלוק קיים מצביע‪ .‬הנחות על המצביעים – ניתן לזהות אותם‪ ,‬מצביעים לתחילה של בלוק‪ ,‬לא מבצעים החבאה (המרה)‪.‬‬
‫• ‪ – Mark and sweep collection‬לא מזיז בלוקים‪ ,‬אלא אם מבצעים הידוק‪.‬‬
‫מסמנים את כל הבלוקים בסיבית סימון האם הם ישיגים או לא‪ ,‬ואז מבצעים מעבר על כל הבלוקים ומוחקים את אלה הלא ישיגים‪.‬‬
‫אלגוריתם שמרני – יכול להסתכל על מספר שלם ככתובת‪ ,‬אין פגיעה בנכונות רק ביעילות‪.‬‬
‫• ‪ – Reference counting‬לא מזיז בלוקים‪.‬‬
‫• ‪ – Copying collection‬מזיז בלוקים‪.‬‬
‫שגיאות אופייניות הקשורות לזיכרון‬
‫• ‪ – Dereferencing and bad pointers‬בעיה נפוצה בשימוש ב‪ scanf‬כאשר מכניסים ערך למשתנה במקום לכתובת של המשתנה‪.‬‬
‫• ‪ – Reading uninitialized memory‬הנחה שגויה שהזיכרון שהוקצה מה‪ heap‬מאותחל ל‪.0‬‬
‫• ‪ – Portability‬הקצאה לפי גודל לא נכון‪ malloc( .‬מקבל כפרמטר גם את הגודל של סוג הזיכרון )‬
‫השמה של קלט באורך לא מתאים‪ .‬קיימת פונקציה שבודקת את תקינות אורך הקלט‪fgets(char *str, int max_length, FILE *stream) .‬‬
‫• אריתמטיקה שגויה של מצביעים – לדוגמא לקדם את המצביע של ‪ int‬ב‪ 4‬במקום לאיבר הבא‪.‬‬
‫• ‪ – Referencing nonexistent variables‬לדוגמא משתנים מקומיים של פונקציה נעלמים בעת היציאה מהפונקציה‪.‬‬
‫• ‪ – Freeing blocks multiple times‬שחרור זיכרון יותר מפעם אחת‪.‬‬
‫• ‪ – Referencing freed blocks‬כאשר משתמשים במידע שנמצא בזיכרון ששוחרר‪.‬‬
‫• ‪ – Failing to free blocks‬שחרור חלקי של מבנה הנתונים‪.‬‬
‫גודל דף הוא ‪0x1000( 4KB‬‬
‫בתים)‬
‫זיכרון משותף – כאשר שני תהליכים ניגשים לכתובות שונות וירטואליות‪ ,‬אשר מתורגמות לאותה כתובת פיזית‪.‬‬
‫דפדוף – כאשר הכתובת הייעודית אינה ואלידית‪ ,‬ולוקחים אותה מהדיסק‪.‬‬
‫כינויים (‪ – )aliasing‬תהליך אחד כותב לכתובת פיזית מסוימת‪ ,‬ותהליך אחר קורא ממנה‪.‬‬
‫‪Exceptions & interrupts‬‬
‫‪ - Control flow‬מהדלקה לכיבוי ה‪ CPU‬מבצע במחזוריות – קריאה של פקודה‪ ,‬פירושה וביצועה‪.‬‬
‫‪– Exceptional Control flow‬‬
‫• ברמה נמוכה – חריגות‪ /‬פסיקות (שינוי סדר הפעולות כתגובה לאירוע כלשהו)‪ ,‬שינוי של חומרה עם תוכנה‪.‬‬
‫• הרמה גבוהה – החלפת הקשר‪ ,‬אותות (‪ , )signal‬פעולות נוספות‪.‬‬
‫חריגות – חריגה היא העברת השליטה למ"ה כתגובה לאירוע כלשהו‪.‬‬
‫וקטורים של פסיקות – לכל סוג אירוע יש מספר חריגה אופייני‪ ,‬מהווה אינדקס ל‪.jump table‬‬
‫כניסה לפי אינדקס שגיאה‪ :‬מצביעה על הפונקציה המיועדת להתמודד עם אותה שגיאה‪)handler( .‬‬
‫*חריגות אסינכרוניות – נגרם על ידי אירועים חיצוניים למעבד (כלומר יכול להגיע בכל זמן שהוא)‬
‫אחרי הפעלת הפונקציה המטפלת חוזרים לפקודה הבאה‪.‬‬
‫*חריגות סינכרוניות – נוצר כתוצאה מהפעלת פקודה ‪:‬‬
‫• מלכודות – מכוון‪ ,breakpoints ,‬לאחר הטיפול מחזירה שליטה לפקודה הבאה‪.‬‬
‫*דוגמה – פתיחת קובץ‪ ,‬המערכת חייבת למצוא או לקרוא לקובץ ולהגדיר קריאה‪/‬כתיבה‪.‬‬
‫• ‪ – Faults‬לא מכוון‪ ,‬אבל ייתכן שניתן לתיקון‪ ,page faults ,‬אם ניתן לתקן חוזרים לפקודה‪ ,‬אם לא מפסיקים את התכנית‪.‬‬
‫המעבד מאפשר למ"ה לתת הוראות " הזדמנות שנייה" לביצוע פעולות מסוימות‪.‬‬
‫*דוגמה – גישה לזיכרון (המשתמש כותב למקום בזיכרון אך הדף הרלוונטי נמצא בדיסק‪ .‬כאשר הוא מועלה לזיכרון זה בעצם "הזדמנות שנייה" לביצוע הפעולה‪ – ).‬הצלחנו‬
‫לתקן‬
‫*דוגמה – גישה לזיכרון – המשתמש כותב למקום לא חוקי בזיכרון‪ ,‬התהליך יוצא עם שגיאה‪ – .‬לא הצלחנו לתקן‪.‬‬
‫• ‪ – Aborts‬לא מכוון ולא ניתן לתיקון‪ , parity error,machine check ,‬מפסיק את התכנית‪.‬‬
‫*אחרי כל סיום ביצוע פקודה‪ ,‬נבדק האם יש חריגה ממתינה (חלק ממחזור הפקודה)‬
‫שני סוגי פסיקות – ‪ nonmaskable‬שמור עבור מאורעות דחופים כמו חריגות מזיכרון מסונכרנות‪ maskable ,‬ניתן לכיבוי ע"י המעבד למשל לפני ביצוע סידרת פקודות‬
‫קריטיות‪.‬‬
‫אותות –אירועי תוכנה‪ ,‬נשלחים על ידי תהליכים ומ"ה לתהליך אחר‪ .‬לכל אות יש מספר ייחודי (ללא אינפורמציה נוספת)‪.‬‬
‫טיפול באותות – לכל אות יש טיפול ברירת מחדל (לדוגמה ‪ -‬לסיים תהליך)‪ ,‬ניתן לשנות אותו על ידי ‪:‬‬
‫)‪ – Signal(sig, handler‬מודיע למ"ה שכעת סיגנל מסוג ‪ sig‬יפעיל פונקציית ‪ handler‬ובסיומה יחזור‬
‫לנקודה בה קרה האות‪.‬‬
‫אין תור של אותות – לכל סוג של אות יש סיבית שאורמת האם האות קרה או לא (גם אם מספר‬
‫תהליכים שלחו אותו)‪.‬‬
‫שגרת טיפול בפסיקה – קורה בזמן שהתהליך רץ אבל אינו בהכרח קשור לתהליך‪ .‬קוד הטיפול‬
‫בפסיקה שייך ל‪ kernel‬ולא לתהליך‪ .‬לא מתב צעת החלפת תהליכים כדי לטפל בפסיקות (קוד טיפול בפסיקה לא מתייחס לתהליך נוכחי אלא למבנה נתונים גלובליים של‬
‫מערכת)‬
‫מודל שרת‪-‬לקוח‬
‫מודל השכבות – פרוטוקול תקשורת מאפשר העברת נתונים ברשת‪ ,‬ופועל בשכבות שונות כאשר לכל שכבה תפקיד משלה‪.‬‬
‫כל שכבה מקבלת שירותים מהשכבה מתחתיה ‪,‬מספקת שירותים לשכבה מעליה ו"מדברת" עם השכבה ה מקבילה במחשב השני או מחשבי הביניים‪.‬‬
‫‪ – Data Link‬מעבירה חבילה מהתחנה לתחנה שכנה באותה רשת‪ .‬מטפלת בכל הפרטים הקשורים בחומרה ובמנשק‬
‫עם הרשת הפיזית‪ .‬תלוי חומרה של הרשת הפיזית‪.‬‬
‫‪ – Internet‬אחראית על ניתוב חבילות מתחנת המקור לתחנת היעד‪ .‬פרוטוקול בשם ‪ IP‬מנתב חבילות בין רשתות שונות‬
‫באמצעות ‪ .giveaway‬לא מבטיח שהחבילה תגיע ליעדה‪ .‬כל חבילה מנותבת ללא קשר לניתוב החבילות האחרות‪.‬‬
‫*תקשורת בין מחשבים‪.‬‬
‫כתובת ‪ – IP‬מספר ייחודי המזהה כל מנשק תקשורת המחובר לרשת‪ .‬כתובת בגודל ‪ 32‬סיביות (כיום ‪ 4 .)128‬מספרים‬
‫עשרוניים‪ .‬הניתוב מתבסס על ‪ IP‬של החבילה ועל טבלאות ניתוב מיוחדות הקיימות בכל ‪( router‬מחשב דרכו עוברות חבילות שלא למחשב עצמו)‪Ipconfig .‬‬
‫‪ – Transport‬מאפשרת תקשורת בין תהליכים‪ )Transport Connection Protocol( TCP .‬יוצר ‪ session‬בין שני תהליכים ומבטיח – סדר (החבילות יגיעו באותו סדר שנשלחו)‪,‬‬
‫אמינות (כל החבילות יגעו ליעדן – אם חבילה הלכה לאיבוד היא תשלח מחדש)‪.‬‬
‫‪ )User Datagram Protocol( UDP‬מעביר הודעה בודדת בין שני תהליכים‪ ,‬מבלי להבטיח סדר או אמינות‪.‬‬
‫‪ – Application‬מכילה פרוטוקולים של אפליקציות (‪ )http‬אשר משתמשות בפרוטוקולי ‪ transport‬לתקשורת עם מחשבים מרוחקים‪.‬‬
‫מודל שרת לקוח – ‪ – Socket.‬מנשק תכנות (‪ ) API‬לשליחת הודעות בין תהליכים על מחשבים שונים דרך האינטרנט‪ .‬לכל ‪ socket‬משויך – כתובת ‪ IP‬ו‪( port‬זיהוי התהליך‬
‫עשוי להריץ מספר תהליכים המתקשרים דרך ברשת‪port number( .‬‬
‫המתקבל – מחשב קצה‬
‫‪ 16‬סיביות)‬
‫פורטים שניתן להבדילם לפי מספר מזהה‪** .‬לאפליקציות פופולריות‬
‫**בשרת ישנם מספר‬
‫יש מספר פורט ידוע‪ .‬לשרת יש מספר פורט ידוע‪ ,‬בעוד שללקוח יש‬
‫מספר פורט זמני (‪ )65535 – 1024‬חלוקת עבודה – הרשת מעבירה את‬
‫ההודעה למחשב היעד ‪0‬על סמך כתובת ‪ )IP‬מערכת ההפעלה – מעבירה את המידע ל‪ socket‬על סמך פרוטוקול ומספר סוקט‪ .‬האפליקציה – קוראת‬
‫מידע מה‪ socket‬ומטפלת בו‪.‬‬
‫מבנה לקוח טיפוסי – הכנה לתקשורת (יצירת ‪ ,socket‬מציאת כתובת השרת ומספר פורט‪ ,‬אתחול תקשורת לשרת)‪ ,‬החלפת מידע עם השרת (כתוב‬
‫מידע ל‪ ,socket‬קרא מידע מה‪ ,socket‬טפל במידע למשל להציג דף)‪ ,‬סגור את ה‪.socket‬‬
‫שרתים אינם לקוחות – פאסיביים לתקשורת‪ ,‬שומעים מכמה לקוחות (תור)‪ ,‬יצירת ‪ socket‬לכל לקוח (בקשה מלקוח חדש ‪ socket ‬חדש‪ .‬מבנה‬
‫שרת טיפוסי‪ -‬הכנה לתקשורת (יצרית ‪ ,socket‬קשר כתובת עצמית ומספר פורט עם ה‪ .)socket‬המתן לשמוע מלקוח (ציין כמה יש בתור)‪ ,‬מקבל‬
‫בקשת התקשרות מלקוח ויוצר ‪ socket‬ייעוד‪ ,‬החלפת מידע עם הלקוח על ה‪ socket‬החדש (קורא מידע מה‪ ,socket‬מטפל בבקשה – למשל הבאת קובץ‪ ,‬כותב מידע ל‪socket‬‬
‫סוגר את ה‪ .socket‬טיפול בבקשות – טיפול סידרתי לא יעיל‪ ,‬יוצר המתנה בתור‪ .‬לכן השרת עובד על כמה בקשות במקביל – קצת על כל משימה‪ ,‬פירוק למשימות קטנות‪,‬‬
‫יצירת תהליך לטיפול‪ ,‬שימוש בתתי תהליכים‪ Berkley socket.‬ספריות סטנדרטיות לשליחת הודעות בין‬
‫מחשבים פונקציות מרכזיות – ‪ socket‬יוצר סוקט חדש‪.‬‬
‫‪ – connect‬צד לקוח‪ ,‬מקצה מס' פורט פנוי לסוקט‪.‬‬
‫‪ – Accept‬צד שרת‪ ,‬מקבל בקשת התחברות מלקוח‪ ,‬יוצר סוקט מתאים‪.‬‬
‫‪ – Close‬משחרר הקצאה לסוקט‬
‫‪ – recvfrom ,sendto ,recv ,Send‬מידע לסוקט וממנו‬