יסודות מעבד

ה-ארכיטקטורת von Neumann היא הבסיס לכל מחשב רב-שימושי:

• זיכרון אחד — זיכרון הגישה המיידי (IAS) — מאחסן גם הוראות תוכנה וגם נתונים (עקרון התוכנית הארוזה).
• מעבד (CPU) מוצא הוראות מהזיכרון ומבצע אותן אחת אחת.
• ההוראות מתבצעות ברצף, אלא אם כן שינוי בענף (branch) משנה את זרימת התוכנית.

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

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

יחידה אריתמטית ולוגית (ALU)

ה-ALU מבצעת פעולות אריתמטיות (חיבור, חיסור, …) ולוגיות (AND, OR, השוואות). היא לוקחת אופרנדים מ-רישומים ומחזירה תוצאות אל רישום.

יחידת בקרה (CU)

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

שעון המערכת

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

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

רישומים

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

• ונהל תוכנית (PC) — הכתובת של ההוראה הבאה.
• נהל כתובות זיכרון (MAR) — הכתובת שנקראת או נכתבת.
• נהל נתוני זיכרון (MDR) — הנתונים הנשלחים לזיכרון או מגיעים ממנו.
• נהל הוראה נוכחית (CIR) — ההוראה הנפענחת כרגע.
• צובר (ACC) — הערך שעליו עובדת כרגע ה-ALU.
• נהל מצבים — מחזיק דגלים (נשיאה, אפס, שלילי, גלישה) המשמשים לערמוזיות. כל דגל הוא ביט אחד, המוגדר או מבוטל על ידי ה-ALU לאחר פעולה: דגל האפס לאחר השוואה שהתאימה, דגל הנשיאה כאשר חיבור גרם לגלישה מהרישום, דגל השליליות כאשר התוצאה שלילית. ערמוזיה מותנית קוראת את הדגלים כדי להחליט אם לערום, ודגל הגלישה יכול לגרום להפרעה (interrupt).
• נהל אינדקס — הסטייה המוספת לכתובת באמצעות כתובת אינדקס; העלאת הערך שלו מאפשרת מעבר דרך מערך אלמנט אחד באחד.

השאלה "השלם את הטבלה המתארת את תפקודם של כל הרישומים" דורשת משפט מדויק אחד לכל רישום במונחים אלו: ה-PC מחזיק את כתובת ההוראה הבאה שיישאף; ה-MAR מחזיק את כתובת המקום שנקרא ממנו או נכתב אליו; ה-MDR מחזיק את הנתון או ההוראה שנשאופו מהמקום או עומדים להיכתב אליו; ה-CIR מחזיק את ההוראה הנפענחת והמבוצעת כרגע; ה-ACC מחזיק את תוצאת הפעולה האריתמטית או הלוגית האחרונה.

רישומים כלליים משמשים את המפתח עבור ערכים זמניים במהלך חישוב. הזזות נתונים בין רישומים לזיכרון נכתבות בסימון העברת רישומים — למשל MAR ← [PC] ("העתק תוכן ה-PC לתוך ה-MAR").

שלושה בוסים פנימיים (סדרות של חוטים מקבילים) מחברים את החלקים:

• בוס כתובות — מעביר את כתובת הזיכרון. חד-כיווני (CPU → זיכרון).
• בוס נתונים — מעביר את הנתונים. דו-כיווני.
• בוס בקרה — מעביר אותות בקרה (קריאה, כתיבה, הפסקה). דו-כיווני.

בוס כתובות בעל $n$ ביט יכול לגשת ל-$2^{n}$ מיקומי זיכרון. רוחב בוס הנתונים קובע כמה ביטים עוברים בכל גישה (לרוב זהו גודל המילה).

• מהירות שעון — יותר מחזוריים לשנייה.
• מספר ליבות — מעבד רב-ליבה מבצע מספר תהליכים בו-זמנית.
• גודל מילה — מעבד 64-ביט מטפל בבלוקים בגודל 64 ביט לכל מחזור ומסוגל לגשת לכמות זיכרון גדולה בהרבה מאשר מעבד 32-ביט.
• כמות RAM — יותר RAM מאפשר אחסון של יותר מתוך ערכת העבודה; כמות קטנה מדי מחייבת למערכת ההפעלה להשתמש ב-pageing (חילוף דף) לדיסק.
• גודל זיכרון Cache — יותר Cache מקצרת את זמן הגישה הממוצע לזיכרון.
• סוג אחסון משני — SSD טוען תוכניות הרבה מהר יותר מאשר HDD.
• רוחב ומהירות בוס — בוסים רחבים/מהירים מעבירים נתונים מהר יותר.

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

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

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

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

יציאה היא שקע פיזיקלי לחיבור מכשיר היקפי:

• USB (Universal Serial Bus) — רב-שימושי (מקלדי קלדים, כוננים, טלפונים).
• HDMI (High Definition Multimedia Interface) — וידאו ואודיו דיגיטליים למסך.
• VGA (Video Graphics Array) — יציאת וידאו אנלוגית ישנה למסך.
• Ethernet (RJ-45) — LAN חוטי. שקעי אודיו — אוזניות/מיקרופון.

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

"הסבר כיצד המחשב מתחבר למסך דרך HDMI": יציאת HDMI שולחת וידאו ואודיו כאות דיגיטלי אחד דרך כבל יחיד, ולכן אין צורך בהמרה לאנלוגי והתמונה אינה מתדרדרת; הכבל נושא רזולוציות HD והיציאה במסך עצמה פוענחת את האות. מכשיר USB הוא חיבור והפעלה (Plug-and-play): כאשר הוא מחובר, המחשב מזהה אותו, מזיהה אותו, מטעין או מתקין את הדרייבר הנדרש לו, ומספק לו חשמל, הכל ללא הצרכה מחדש.

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

משיכה

1. כתובת ה-PC מועתקת ל-MAR.
2. ה-PC מוגדל כדי להצביע על ההוראה הבאה.
3. אות קריאה עובר על נתיב הבקרה.
4. הזיכרון מניח את ההוראה על בוס הנתונים.
5. היא מועתקת ל-MDR, ולאחר מכן ל-CIR.

המבחן דורש שלבים אלו בסימוך העברת רשמים, כאשר [X] מייצג תוכן של רשם X ו-stereofon [[MAR]] מייצג תוכן של מיקום בזיכרון שכתובתו נמצאת ב-MAR:

MAR ← [PC]          the address of the next instruction goes to the MAR
PC  ← [PC] + 1      the PC now points to the following instruction
MDR ← [[MAR]]       the instruction at that address is read into the MDR
CIR ← [MDR]         the instruction is copied into the CIR for decoding

הסדר חשוב: ה-PC מתגבר מיד לאחר שהכתובת שלו הועתקה, כך שקפיצה שתתבצע מאוחר יותר עדיין תוכל לכתוב עליה. במהלך הביצוע אותו סימון מתאר כל הוראה; לדוגמה עבור LDD 200, יש MAR ← 200, MDR ← [[MAR]], ACC ← [MDR].

פיענוח

ה-CU מפענחת את ההוראה ב-CIR — איזה פעולה, ואילו ארגומנטים או כתובות.

ביצוע

ה-CU מבצעת אותה: פעולות אריתמטיות/לוגיות הולכות ל-ALU (התוצאה ל-ACC); טעינה/אחסון ממשיכים נתונים בין זיכרון לרשם; קפיצה משנה את ה-PC. לאחר מכן המחזור חוזר על עצמו.

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

טיפול באחד:

1. סיום ההוראה הנוכחת.
2. שמירת המצב (ה-PC והרשמים).
3. טעינת כתובת תוכנית שירות ההפרעות (ISR) לתוך ה-PC והרצתה.
4. ה-ISR מטפל באירוע.
5. שחזור המצב השמור והמשכה.

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

"הסבר כיצד הפרעה ממכשיר כניסה מזוהה ומטופלת במחזור F-E" היא תשובה בעלת 4 נקודות הנכללות בפריטים הבאים: המכשיר שולח אות הפרעה שמגדיר את דגל ההפרעה ב-רשומת ההפרעות; המעבד בודק את הרשומה זו בסוף כל מחזור fetch-execute, לאחר שההוראה הנוכחית סיימה ביצוע; אם הדגל מוגדר וההפרעה בעלת עדיפות גבוהה מהמשימה הנוכחית, התוכן של PC ושאר הרשומות נשמרים בשורה (stack); כתובת פרוגרמת השירות להפרעה נטענת ל-PC והפרוגרמה נערכת; כאשר היא מסתיימת, הערכים שנשמרו משוחזרים מהשורה והתוכנית המקוטעת ממשיכה מהנקודה בה עצרה.

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

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

אסמבלר דו-מעברי

אסמבלר דו-מעברי קורא את המקור פעמיים:

• מעבר 1 בונה טבלת סימנים: בכל פעם שתווית (כמו LOOP:) מופיעה, נרשום את כתובתה; אין עוד קוד.
• מעבר 2 מייצר קוד: תרגם כל הוראה, וכשאחת מתייחסת לתווית (כמו JMP LOOP), חפש את כתובתה בטבלת הסימנים.

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

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

        LDD  COUNT
LOOP:   DEC  ACC
        CMP  #0
        JPN  LOOP
        END
COUNT:  5

מעבר 1 קורא כל שורה, סופר את הכתובת שת occupies, ומרשם כל תווית בטבלת הסימנים: LOOP = 101 (שורת הDEC) וCOUNT = 105 (שורת הנתונים). אין קוד המיוצר. מעבר 2 קורא את התוכנית שוב ותרגם כל שורה לכידור מכונה, תוך החלפת כל מונונימיק ב-אופקוד וחלפת כל כתובת סמלית במספר מטבלת הסימנים: LDD COUNT הופך לאופקוד עבור LDD עם אופרנד 105, וJPN LOOP הופך לאופקוד עבור JPN עם אופרנד 101. הקפיצה חזרה לLOOP יכלה להיות פותרת במעבר אחד, אך קפיצה קדימית לתווית שלא נראתה עד כן לא הייתה אפשרית, ולכן האסמבלר מבצע שניים.

דוגמה לערכת הוראות

Cambridge משתמש בערכת הוראות קטנה וגנרית, מודפסת בטבלת ההפניה בדף הבחן, עם רשמה אחת רב-שימושית, האקumulátor (ACC), ורשמת אינדקס (IX). אופרנד הכתוב #n הוא מספר עשרוני, Bn מספר בינארי ו&n מספר הלודקסימלי; <address> הוא מספר מיקום או תווית.

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

המצב הכתובתי (או מצבי הכתובות) מסביר כיצד מעבד ה-CPU מזהה את הארגומנט:

• היפוע מיידי — האופרנד הוא הערך בתוך ההוראה. LDM #10 מטעין 10.
• היפוע ישיר — ההוראה מכילה כתובת; האופרנד הוא הערך ששם. LDD 200.
• היפוע עקיף — ההוראה מכילה כתובת שמכילה כתובת אחרת, שהיא הנתון. LDI 200.
• היפוע אינדקסי — הכתובת האפקטיבית היא address + index register; משמש למטריצות. LDX 100 עם רשמת IR = 5 קורא את הכתובת 105.

(היפוע יחסי מספק את הכתובת כסטייה מה-PC — משמש לקפיצות.)

דוגמה מפורטת. הזיכרון מכיל: מיקום 200 = 250, מיקום 250 = 99, מיקום 105 = 7. רישום האינדקס מכיל 5. מה יש במצבור האקumulat after each of LDM #200, LDD 200, LDI 200 and LDX 100? Follow how far each mode has to look. LDM #200 is immediate - the operand is the number written in the instruction, so the accumulator holds 200. LDD 200 is direct - go to location 200 and take what is there: 250. LDI 200 is indirect - location 200 holds 250, which is another address, so go on to location 250: 99. LDX 100 is indexed - add the index register to the address, $100 + 5 = 105$, and read location 105: 7. Count the hops to keep them apart: immediate 0, direct 1, indirect 2, indexed 1 (once the index has been added).

כדי לבצע מעקב: בנה טבלה עם עמודות עבור PC, ACC, רשמת אינדקס, כל משתנה וכל סימן. עבור על ההוראות עדכנות את הטבלה לאחר כל אחת; עקוב אחר ветки כאשר הן משנות את ה-PC; עצור בEND. דפוס נפוץ הוא לולאה על מטריצה באמצעות היפוע אינדקסי.

דוגמה פותרת. עקוב אחר התוכנית הבאה. הכתובת 200 מכילה 5 והכתובת 201 מכילה 0.

100   LDD  200
101   CMP  #0
102   JPE  108
103   OUT
104   DEC  ACC
105   STO  200
106   LDD  201
107   JMP  100
108   END

כתוב שורה אחת לכל הוראה שבוצעה, ומלא רק את העמודות ששתנו:

וכך הלאה, עד שLDD 200 מטעין 0, ההשוואה מגדירה את סימן השוויון, JPE 108 נלקח והתוכנית נגמרת. שלושה דברים שהבוחן בודק: CMP אינו משנה רשמה, אלא רק סימן; קפיצה שלא נלקחה עדיין נחשבת כבוצעה; וOUT מציג אות, ולכן הוא מופיע בעמודת התפוקה, לא בעמודת ה-ACC. "צין את ההשפעה של שינוי LDD 10 לLDM #10": ה-ACC היה מכיל את המספר 10 במקום תכולת הכתובת 10.

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

• הזזה שמאלה ב-1 (LSL #1) — הביטים זזים שמאלה, 0 נכנס מימין; עבור מספר ללא סימן זה × 2.
• הזזה ימינה ב-1 (LSR #1) — הביתים נעים ימינה, 0 נכנס משמאל; עבור מספר ללא סימן זהו מספר שלם ÷ 2.

הזזה ב-$n$ מקומות כופלת או מחלקת ב-$2^{n}$. דוגמה: 00001011 (11) LSL #1 → 00010110 (22).

ביתים שנזזו החוצה מהקצה אובדים, ולכן הכפל נכון רק כל עוד הם היו אפסים. הוספת LSL #2 למספר שלם בשנייה-משלים 11001010 נותנת 00101000: שני ה-1s שנפלו משמאל אבדו, ביט הסימן השתנה, והתוצאה אינה ארבע פעמים המקורית יותר.

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

"הראה את תוצאת ההזזה האריתמטית הימינה ב-3 מקומות על 10011110": העתק ביט הסימן לכל מקום ריק, 11110011. אותה הזזה על 01011100 נותנת 00001011. הזזה מעגלית שמאלית ב-1 על 10000110 נותנת 00001101: ה-1 המוביל מופיע שוב מימין.

ההפרש בין שתי ההזזות הימניות הוא ביט אחד. לקחת 11110000, שהוא 240 קריאה ללא סימן ו-$-16$ קריאה עם סימן. LSR #1 מכניס 0 ונותן 01111000 $= 120$, שהוא המחצית הנכונה של 240. ASR #1 מעתיק את ביט הסימן במקום זאת ונותן 11111000 $= -8$, שהוא המחצית הנכונה של $-16$. אף אחד מהם אינו שגוי — כל אחד מחלק בערך תחת קריאה אחת.

עיבוד ביטים לניטור/בקרה

התקנים embedded משתמשים לעיתים קרובות ב-ביט אחד של רגיסטר לכל אות (למשל bit $n$ = LED $n$). השימוש ב-מסכה — עיבוד ביטי במסכה — מאפשר לך:

• להגדיר bit $n$: R = R OR מסכה עם bit $n$ מוגדר.
• לנטרל bit $n$: R = R AND מסכה עם bit $n$ נטרל ושאר הגדרות.
• להפוך bit $n$: R = R XOR מסכה עם bit $n$ מוגדר.
• לבדוק bit $n$: R AND המסכה, ולאחר מכן לבדוק אם התוצאה אינה אפס.

עיבוד ביטים מהיר, משתמש בזיכרון מעט, ומאפשר לבייט אחד להחזיק עד 8 מצבי ON/OFF.

בסט ההוראות במבחן אלו הם AND, OR ו-XOR עם מסכה כתובה כארגומנט עשרוני, בינארי או הדקסিমלי. עם ACC שמחזיק 10101100:

"כתוב את ההוראה שמגדירה את הביט המינימלי ל-1 ומשאירה את שאר הביטים ללא שינוי": OR #1 או OR B00000001. כדי לאפס ביט השתמש בAND עם מסכה שיש בה 0 במיקום זה ו-1s במקומות האחרים; לבדיקת ביט, השתמש בAND עם מסכה שיש בה 1 רק במיקום זה, ולאחר מכן השווא את התוצאה לאפס. במכשיר ניטור, ביט אחד של רגיסטר לכל חיישן מאפשר לרגיסטר אחד AND לבדוק האם חיישן מסוים דולק, ורגיסטר אחד OR מדליק את ביט הבקרה של מערך ללא פגיעה באחרים.

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

• להבין את מחזור המשיכה והביצוע במונחי העברת רשמים (PC, MAR, MDR, CIR, ACC) ולזהות מה מעלה את PC.
• לציין את תפקידו של כל רשם; ערוץ הכתובות הוא חד-כיווני, ערוץ הנתונים הוא דו-כיווני.
• להבחין בין מצבי הכתובת (מיידית, ישירה, לא ישירה, אינדקסית) — שאלה נפוצה.
• להסביר כיצד מהירות שעון, מספר ליבות, גודל קאש ואורך מילה משפיעים על ביצועים.
• עבור הזזה בינארית, לציין אם מדובר בהזזה לוגית או אריתמטית; הזזה שמאלה כופלת ב-2, הזזה ימינה מחלקת ב-2.

טעויות נפוצות

• לומר שה-PC מכיל את ההוראה הנוכחית, או שה-MDR מכיל כתובת. ה-PC מכיל את כתובת ההוראה הבאה; ה-MDR מכיל נתונים או הוראה, לעולם לא כתובת.
• להשאיר את ההגבהה של PC מחוץ למשיכה, או לשים אותה לאחר הביצוע. זה קורה ברגע שהכתובת הועברה ל-MAR.
• לקרוא LDD 10 כ"טעינה 10". LDD 10 טוען את תוכן הכתובת 10; LDM #10 טוען את המספר 10.
• לשים ערך בעמודת ה-ACC עבור CMP או OUT. השוואה מגדירה סימן בלבד; פלט יוצא לעמודת הפלט.
• לומר שהפרעת טיפול "מיידי". המעבד מסתיים את ההוראה הנוכחית ובוחן הפרעות בסוף המחזור.
• שימוש בהזזה ימנית לוגית על מספר שלילי בשלימה לשניים. רק הזזה אריתמטית שומרת על סימן המספר.