0.2 המחשב הרצאה

המחשב

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

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

1. המעבד, CPU (central processing unit)- המעבד הוא "המוח" של המחשב. הוא החלק שאחראי לבצע את ההוראות שמוגדרות בזכרון. תפקידו הוא לבצע את הקוד שניתן לו שלב אחר שלב.

2. הזכרון, RAM (random access memory)- שומר מידע שהמעבד צריך לשם ביצוע ההוראות:

   1. את הקוד עצמו(סדרת ההוראות שהמעבד יריץ)
   2. מידע כללי שהמעבד שומר כדי לבצע פעולות ( לדוגמה, משתנים).

3. רכיבי הקלט/פלט, IO (input output)- רכיבים אלו מאפשרים תקשורת בין המשתמש למחשב. המעבד יכול לקרוא מידע ממכשירי קלט(כמו מקלדת או עכבר) ולכתוב מידע למכשירי פלט(כמו מסך)

סוגי הוראות שהמעבד יודע לבצע

1. חישובים מתמטיים ולוגיים: חיבור, חיסור, השוואות וכו'
2. התממשקות עם הRAM: קריאה וכתיבה של מידע מ\אל הRAM
3. התממשקות עם הIO (קלט פלט): שליפה או הצגה של מידע אל מול המשתמש
   

אוגרים(Registers)

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

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

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

הזכרון

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

סגמנטים

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

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

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

אוגר "מצביע ההוראה"

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

סוגי ההוראות

נגדיר סוגי הוראות שהמעבד שלנו יודע לבצע.
- הוראת חיבור: הוראת ADD, יודעת לחשב את סכום הערך שנמצא באוגר מספר 1 ואוגר מספר 2, ולכתוב את התשובה באוגר מספר 3.
- הוראת חיסור: הוראת SUB, יודעת לחשב את הפרש הערך שנמצא באוגר מספר 1 ואוגר מספר 2 ולכתוב את התשובה באוגר מספר 3
- הוראות העברה: הוראת MOV, יודעת להעביר מידע מאוגר לאוגר, או ערך לאוגר.
- הוראת קיראה: הוראת LDR, יודעת לקרוא מידע מכתובת מוגדרת בRAM לתוך אוגר מוגדר.
- הוראת כתיבה: הוראת WRT, יודעת לכתוב מידע מאוגר מוגדר לכתובת בRAM.
- הוראת קלט: הוראת IN, יודעת לקרוא מידע ממכשיר הקלט לאוגר מספר 1.
- הוראת פלט: הוראת OUT, יודעת לכתוב מידע מאוגר מספר 1 למכשיר הפלט.

דוגמאות

נכתוב תוכנה למחשב שבנינו!
- נשים באוגר הקוד את המספר 1, כדי שהתוכנה תתחיל להריץ את ההוראות מכתובת מספר 1 בזכרון.
- נשים באוגר המשתנים (הDATA) את המספר 6, כדי לסמן מאיפה מתחילים לשמור משתנים בRAM!
שימו לב, זה אומר שיהיו לנו רק 5 הוראות שונות שנוכל לשים בסגמנט הקוד שלנו.
- נכתוב את ההוראות הבאות בRAM:

MOV 7 -> אוגר מס 1
MOV 5 -> אוגר מס 2
ADD 
MOV אוגר מס 1 <- אוגר מס 3
OUT

ונריץ את המעבד!

מה יקרה?
1. המעבד ידאג שאוגר מצביע ההוראה יהיה 1, כמו שמוגדר לו באוגר הקוד.
2. המעבד יריץ את ההוראה שנמצאת בכתובת מספר 1 בRAM, בדיוק כמו שאוגר מבציע ההוראה אמר לו.
3. על פי ההוראה שהגדרנו שנמצאת בתחילת הRAM, המעבד יקח את המספר 7 וישים אותו באוגר מספר 1.
4. המעבד יוסיף +1 לאוגר מצביע ההוראה, כך שהוא עכשיו מצביע על כתובת מספר 2.
5. המעבד יריץ את כתובת מספר 2 בRAM, ששם מוגדר לו לקחת את המספר 5 ולשים אותה באוגר מספר 2.
6. המעבד יוסיף 1+ לאוגר מצביע ההוראה, כך שעכשיו יצביע על כתובת מספר 3.
7. המעבד יריץ את שורה 3, שבה כתוב לו לבצע את פעולת ADD. שמחברת את אוגר מספר 1 ואוגר מספר 2 (יוצא 7+5 שזה 12) ושומרת את התוצאה באוגר מספר 3
8. המעבד יעביר את הערך באוגר מספר 3 לאוגר מספר 1, כך שעכשיו אוגר מספר 1 יכיל את הערך 12.
9. המעבד יבצע את פעולת OUT, שלוקחת את הערך באוגר מספר 1 (13) ושמה אותו במכשיר הפלט.
10. המעבד ימשיך להריץ כל שורה בRAM עד שאוגר מצביע ההוראה יגיע לערך 6, שהוא תחילת סגמנט הDATA (לאן שאוגר המשתנים מצביע). אז המעבד יפסיק לרוץ.
המספר 13 יהיה בפלט.

MOV 10 -> אוגר 1
MOV 20 -> אוגר 2
MOV אוגר 1 -> אוגר 3
OUT אוגר 3

הסבר:
1. מעבירים את המספר 10 לאוגר מספר 1.
2. מעבירים את המספר 20 לאוגר מספר 2.
3. מעבירים את התוכן של אוגר 1 (שבו עכשיו יש 10) לאוגר 3.
4. מוציאים לפלט את הערך שבאוגר 3 — כלומר 10.

MOV 4 -> אוגר 1
MOV 6 -> אוגר 2
ADD                 ; מחבר את אוגר 1 ואוגר 2, ושומר באוגר 3
WRT אוגר 3 -> RAM[10] ; שומר את התוצאה בכתובת 10 בזכרון RAM

הסבר:
1. שומרים את המספר 4 באוגר 1.
2. שומרים את המספר 6 באוגר 2.
3. מבצעים חיבור בין שני האוגרים, והתוצאה (10) נשמרת באוגר 3.
4. כותבים את הערך של אוגר 3 לכתובת מספר 10 בזכרון ה-RAM.

LDR RAM[10] -> אוגר 1
OUT אוגר 1

הסבר:
1. קוראים את הערך שמאוחסן בזכרון בכתובת 10 ומעבירים אותו לאוגר 1.
2. מציגים את הערך שבאוגר 1 בפלט.

IN -> אוגר 1       
OUT

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

MOV 15 -> אוגר 1
MOV 7 -> אוגר 2
SUB
OUT אוגר 3

הסבר:
1. שומרים את המספר 15 באוגר 1.
2. שומרים את המספר 7 באוגר 2.
3. מבצעים חיסור: 15 - 7 = 8, ושמים את התוצאה באוגר 3.
4. מציגים את הערך 8 בפלט.

מחזור הוראה (Fetch-Decode-Execute Cycle)

כל פעולה של המעבד מתבצעת במחזור בן 3 שלבים:

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

2. פעולת הDecode – המעבד "מפענח" את ההוראה כדי להבין איזה פעולה עליו לבצע.

3. פעולת הExecute – המעבד מבצע את הפעולה על פי ההוראה.

לאחר כל מחזור, אוגר הIP (מצביע ההוראה) מתעדכן כדי להצביע על ההוראה הבאה.

סיכום

המעבד היא מכונה טיפשה.
- יש לו סט הוראות מוגדרות, (למשל במעבד שלנו יש mov, add, sub, in, out, ldr, wrt)
- יש לו סט אוגרים כלליים מוגדרים שהוא משתמש בהם כדי לבצע את ההוראות.
- יש לו סט אוגרים מיוחדים שעוזרים לו לפעול- אוגרי סגמנטים, ואוגר הIP (instruction pointer) ועוד.
- הוא יכול להשתמש בRAM כדי לשמור מידע, כדי לשמור קוד ועוד.
- הוא יכולה להשתמש ברכיבי הקלט/פלט כדי ליצור אינטרציה עם המשתמש
- פקודות המעבד מבוצעות במחזורים קבועים: Fetch → Decode → Execute.