מפתח תשובות · יחידה 3

איך מחשב מריץ תוכנית.

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

קטלוג הטעויות הנפוצות

מפתח תשובות 4

שיעור 1 מתוך 4 · כ־20 דקות

זיכרון וכתובות

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

לפתוח את השיעור

5 השלבים והתשובות שלהם

שלב 1 מתוך 5
לפתוח את השלב
שישה־עשר תאים
תרגול · בחרו
השאלה
אפיק הכתובות של השבב הוא ארבעה נתיבים, וכל נתיב נושא סיבית אחת. לכמה תאי זיכרון שונים אפשר לתת כתובת?

התשובה הנכונה
- נכונה $16$ ⁠
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0
המספר הראשון
28ברירת מחדל
המספר השני
14ברירת מחדל
שבב / טרנזיסטורים
רכיבים
האפשרויות
מוצגות בסדר אקראי.
- נכונה $16$ ⁠
- שגויה $4$ ⁠, תא לכל נתיב
  טעות נפוצה: Thinks each extra address line adds a fixed number of cells (four lines name 4 or 8 cells), instead of doubling them: 2⁴ = 16.
  משוב מהקטלוג
  כל נתיב נוסף באפיק הכתובות מכפיל את מספר הכתובות, ולא מוסיף להן. נתיב אחד נותן שתי כתובות, 0 ו־1; שני נתיבים נותנים ארבע, 00 עד 11; וארבעה נתיבים נותנים $2^4 = 16$ ⁠ כתובות, מ־0000 עד 1111. נתיב אחד לכל תא היה דורש שישה־עשר חוטים.
- שגויה $8$ ⁠, שניים לכל נתיב
  טעות נפוצה: Thinks each extra address line adds a fixed number of cells (four lines name 4 or 8 cells), instead of doubling them: 2⁴ = 16.
  משוב מהקטלוג
  כל נתיב נוסף באפיק הכתובות מכפיל את מספר הכתובות, ולא מוסיף להן. נתיב אחד נותן שתי כתובות, 0 ו־1; שני נתיבים נותנים ארבע, 00 עד 11; וארבעה נתיבים נותנים $2^4 = 16$ ⁠ כתובות, מ־0000 עד 1111. נתיב אחד לכל תא היה דורש שישה־עשר חוטים.
- שגויה $15$ ⁠
  טעות נפוצה: Forgets that counting starts at 0: takes the largest address, 15, as the number of cells, or tick 11 as the eleventh tick.
  משוב מהקטלוג
  במחשב סופרים מאפס. הכתובות הן 0 עד 15, ולכן יש שישה־עשר תאים, לא חמישה־עשר. באותו אופן הפעימה הראשונה היא פעימה 0, ולכן עד סוף פעימה 11 רצו שתים־עשרה פעימות. כשהמספור מתחיל באפס, הכמות היא המספר האחרון ועוד אחד.
משוב לתשובה נכונה
$2^4 = 16$ ⁠: כל נתיב יכול להיות 0 או 1, וכל נתיב נוסף מכפיל את מספר הצירופים. אלה בדיוק שישה־עשר התאים שבזיכרון, כתובות 0 עד 15.

רמז
כמה צירופים שונים יש לשתי סיביות? ולשלוש?

פתרון מלא
1. כל נתיב נושא סיבית אחת: 0 או 1.
2. לנתיב אחד שתי אפשרויות; לכל נתיב נוסף שתי אפשרויות לכל אחת מהקודמות, ולכן מספר הצירופים מוכפל.
3. ארבעה נתיבים: $2 \times 2 \times 2 \times 2 = 2^4 = 16$ ⁠ כתובות, מ־0000 עד 1111.
אם בחרתם $4$ ⁠ או $8$ ⁠, חיברתם במקום לכפול. אם בחרתם $15$ ⁠, זו הכתובת הגדולה ביותר, אבל הספירה מתחילה ב־0.
שלב 2 מתוך 5
לפתוח את השלב
בית אחד
תרגול · חשבו
השאלה
תא בזיכרון, כמו כל אוגר בשבב, הוא בית אחד: שמונה סיביות. מה המספר הגדול ביותר שבית אחד יכול להחזיק?

התשובה הנכונה
255 ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0
המספר הראשון
28ברירת מחדל
המספר השני
14ברירת מחדל
שבב / טרנזיסטורים
רכיבים
מתקבלת בטווח
± 0.01
ערך קבוע בשאלה
תשובות שגויות שהשאלה מזהה
- 256 ± 0.01
  טעות נפוצה: Takes the largest number n bits can hold to be 2ⁿ (256 for a byte) rather than 2ⁿ − 1 (255).
  משוב מהקטלוג
  שמונה סיביות נותנות $2^8 = 256$ ⁠ צירופים שונים, אבל אחד מהם הוא אפס, 00000000. לכן המספרים הם 0 עד 255, והגדול ביותר הוא $2^8 - 1 = 255$ ⁠, 11111111. כדי לכתוב 256 צריך סיבית תשיעית.
משוב לתשובה נכונה
11111111 הוא $128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255$ ⁠, שהם $2^8 - 1$ ⁠. בבית יש 256 ערכים שונים, 0 עד 255.

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

פתרון מלא
1. הדליקו את כל שמונה הסיביות: 11111111.
2. ערכי המקומות הם $1, 2, 4, \ldots, 128$ ⁠.
3. הסכום: $1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255$ ⁠, כלומר $2^8 - 1$ ⁠.
אם עניתם $256$ ⁠, ספרתם את מספר הערכים, $2^8$ ⁠, ולא את הגדול שבהם: אחד הערכים הוא אפס.
שלב 3 מתוך 5
לפתוח את השלב
בית הוא מספר
תרגול · חשבו
השאלה
הבית בכתובת 0 הוא 0001 1110. המכסה סגור. אם קוראים את הבית הזה כמספר ולא כהוראה, מהו?

התשובה הנכונה
30 ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0קבוע
המספר הראשון
28
המספר השני
14
שבב / טרנזיסטורים
שבבקבוע
מתקבלת בטווח
± 0.01
מחושבת מהסצנה בהגדרה של השלב
The byte in the instruction register after this tick (opcode in the high four bits)/nodes/cpu/outputs/instructionRegister
תשובות שגויות שהשאלה מזהה
- 14 ± 0.01
  טעות נפוצה: Reads a byte as two separate numbers, its high and low four bits, instead of one eight-bit number.
  משוב מהקטלוג
  כשקוראים בית כמספר, כל שמונה הסיביות הן מספר אחד. ערכי המקומות, מימין לשמאל, הם 1, 2, 4, 8, 16, 32, 64, 128. ב־0001 1110 דולקות הסיביות של 16, 8, 4 ו־2, ולכן הוא $16 + 8 + 4 + 2 = 30$ ⁠. החלוקה לשני חצאים, קוד פעולה וכתובת, נכונה רק כשקוראים את הבית כהוראה.
- 15 ± 0.01
  טעות נפוצה: Reads a byte as two separate numbers, its high and low four bits, instead of one eight-bit number.
  משוב מהקטלוג
  כשקוראים בית כמספר, כל שמונה הסיביות הן מספר אחד. ערכי המקומות, מימין לשמאל, הם 1, 2, 4, 8, 16, 32, 64, 128. ב־0001 1110 דולקות הסיביות של 16, 8, 4 ו־2, ולכן הוא $16 + 8 + 4 + 2 = 30$ ⁠. החלוקה לשני חצאים, קוד פעולה וכתובת, נכונה רק כשקוראים את הבית כהוראה.
משוב לתשובה נכונה
$16 + 8 + 4 + 2 = 30$ ⁠. אותו בית, כשהוא נוחת באוגר ההוראה, הוא LDA 14: השבב לא יודע מה הוא מה, רק איך משתמשים בו.

רמז
לסיבית החמישית מימין יש ערך מקום $16$ ⁠.

פתרון מלא
1. ערכי המקומות של שמונה הסיביות, משמאל לימין: $128, 64, 32, 16, 8, 4, 2, 1$ ⁠.
2. ב־0001 1110 דולקות הסיביות של $16$ ⁠, $8$ ⁠, $4$ ⁠ ו־ $2$ ⁠.
3. הסכום: $16 + 8 + 4 + 2 = 30$ ⁠.
אם עניתם $14$ ⁠, קראתם רק את ארבע הסיביות הימניות, הכתובת. אם עניתם $15$ ⁠, חיברתם את שני החצאים, $1 + 14$ ⁠: כמספר, שמונה הסיביות הן מספר אחד.
שלב 4 מתוך 5
לפתוח את השלב
קוד פעולה וכתובת
תרגול · בחרו
השאלה
בכתובת 3 שמור הבית 0101 1101. קוד הפעולה 0101 הוא STA, “שמור את A”. מה ההוראה עושה?

התשובה הנכונה
- נכונה כותבת את מה שבאוגר A לתא 13
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0
המספר הראשון
28ברירת מחדל
המספר השני
14ברירת מחדל
שבב / טרנזיסטורים
רכיבים
האפשרויות
מוצגות בסדר אקראי.
- נכונה כותבת את מה שבאוגר A לתא 13
- שגויה כותבת את מה שבאוגר A לתא 5
  משוב
  0101, החצי השמאלי, הוא קוד הפעולה. הכתובת היא החצי הימני, 1101.
- שגויה כותבת את המספר 13 לאוגר A
  טעות נפוצה: Confuses an address, the number that names a memory cell, with the value stored in that cell.
  משוב מהקטלוג
  כתובת היא השם של תא, כמו מספר של בית ברחוב; התוכן הוא מה שגר בו. בתא שכתובתו 14 שמור המספר 28. LDA 14 פירושו “טענו ל־A את מה שבתא 14”, כלומר 28, ולא את המספר 14 עצמו.
- שגויה טוענת לאוגר A את מה שבתא 13
  משוב
  טעינה לאוגר A היא קוד הפעולה 0001, LDA. STA הולכת לכיוון ההפוך: מהאוגר לזיכרון.
משוב לתשובה נכונה
1101 הוא $8 + 4 + 1 = 13$ ⁠, ולכן זו STA 13: הסכום שב־A נכתב לתא 13. זו ההוראה הרביעית של התוכנית.

פתרון מלא
1. החצי השמאלי, 0101, הוא קוד הפעולה: $4 + 1 = 5$ ⁠, STA.
2. החצי הימני, 1101, הוא הכתובת: $8 + 4 + 1 = 13$ ⁠.
3. ביחד: STA 13, כתבו את A לתא 13.
הכתובת בהוראה היא שם של תא, לא מספר שנכנס לאוגר.
שלב 5 מתוך 5
לפתוח את השלב
מעתיקים, לא מזיזים
תרגול · נבאו, ואז הסתכלו
השאלה
בתא 14 שמור 28. בפעימה 2 מתבצעת LDA 14. מה יישאר בתא 14 אחרי הפעימה?

התשובה הנכונה
- נכונה עדיין 28
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
1קבוע
המספר הראשון
28
המספר השני
14
שבב / טרנזיסטורים
רכיבים
הגדרות נוספות
Watch address/nodes/cpu/props/watchAddress = 14
האפשרויות
- נכונה עדיין 28
- שגויה 0: המספר עבר לאוגר A
  טעות נפוצה: Thinks loading a number into a register takes it out of memory, leaving the cell empty.
  משוב מהקטלוג
  טעינה מעתיקה. הזיכרון שולח על אפיק הנתונים את המתחים של הסיביות שבתא, והאוגר קולט אותם, אבל התא עצמו לא משתנה. אחרי LDA 14 המספר 28 נמצא גם באוגר A וגם בתא 14. רק כתיבה, STA, משנה תא בזיכרון.
- שגויה 14
  טעות נפוצה: Confuses an address, the number that names a memory cell, with the value stored in that cell.
  משוב מהקטלוג
  כתובת היא השם של תא, כמו מספר של בית ברחוב; התוכן הוא מה שגר בו. בתא שכתובתו 14 שמור המספר 28. LDA 14 פירושו “טענו ל־A את מה שבתא 14”, כלומר 28, ולא את המספר 14 עצמו.
אחרי נעילת הניבוי הסצנה משתנה
פעימת שעון
2קבוע
שבב / טרנזיסטורים
רכיבים
ואז הסצנה מראה: 28 · The byte in memory cell watchAddress after this tick/nodes/cpu/outputs/watched
ניבוי אף פעם לא נחשב כישלון: בכל מקרה הלומדים רואים את התוצאה ואת ההסבר.
משוב לתשובה נכונה
עדיין 28, ועכשיו גם באוגר A יש 28. טעינה מעתיקה: הזיכרון רק שולח את הסיביות שלו על אפיק הנתונים.

פתרון מלא
1. LDA 14 שולחת את הכתובת 14 לזיכרון ומדליקה את קו קריאת זיכרון.
2. הזיכרון שם על אפיק הנתונים את מה שבתא 14, 28, ואוגר A קולט אותו.
3. קריאה לא משנה את התא, ולכן בתא 14 נשאר 28.
רק STA, עם קו כתיבת זיכרון, משנה תא.

שיעור 2 מתוך 4 · כ־25 דקות

הבאה, פענוח, ביצוע

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

לפתוח את השיעור

5 השלבים והתשובות שלהם

שלב 1 מתוך 5
לפתוח את השלב
לולאה אחת
תרגול · בחרו
השאלה
בפעימת פענוח, מה קורה?

התשובה הנכונה
- נכונה יחידת הבקרה קוראת את קוד הפעולה ובוחרת אילו קווי בקרה להדליק; שום אוגר לא משתנה
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0
המספר הראשון
28ברירת מחדל
המספר השני
14ברירת מחדל
שבב / טרנזיסטורים
רכיבים
האפשרויות
מוצגות בסדר אקראי.
- נכונה יחידת הבקרה קוראת את קוד הפעולה ובוחרת אילו קווי בקרה להדליק; שום אוגר לא משתנה
- שגויה ה־ALU מחשבת את התשובה, ואוגר A קולט אותה
  משוב
  זה קורה בפעימת ביצוע. בפענוח רק מחליטים מה יקרה בביצוע.
- שגויה ההוראה מגיעה מהזיכרון לאוגר ההוראה
  משוב
  זו הבאה, הפעימה שלפני הפענוח.
- שגויה מונה התוכנית עולה באחד
  טעות נפוצה: Thinks the program counter holds the address of the instruction being carried out, rather than the next one to fetch.
  משוב מהקטלוג
  מונה התוכנית מתקדם כבר בפעימת ההבאה: באותה פעימה שבה ההוראה נוחתת באוגר ההוראה, המונה עולה באחד. לכן בזמן הפענוח והביצוע הוא כבר מצביע על ההוראה הבאה. בזמן ש־LDB 15 מכתובת 1 מתבצעת, המונה מחזיק 2.
משוב לתשובה נכונה
פענוח הוא חיווט: ארבע הסיביות של קוד הפעולה נכנסות ליחידת הבקרה, והיא מדליקה קבוצה קבועה של קווים, למשל פלט ALU וקלט A בשביל ADD. הערכים באוגרים לא זזים.

פתרון מלא
1. הבאה: ההוראה נכנסת לאוגר ההוראה, והמונה עולה באחד.
2. פענוח: קוד הפעולה עובר ליחידת הבקרה, והיא בוחרת קווי בקרה. אף ערך לא נשמר.
3. ביצוע: הקווים פותחים מסלול אחד, ורכיב אחד קולט ערך.
קדמו את פעימת שעון בין 6 ל־7 ובדקו: באוגרים לא משתנה דבר.
שלב 2 מתוך 5
לפתוח את השלב
מונה התוכנית
תרגול · נבאו, ואז הסתכלו
השאלה
פעימה 2 ביצעה את LDA 14, שהגיעה מכתובת 0. בפעימה 3 המעבד מביא את ההוראה מכתובת 1. מה יהיה במונה התוכנית בסוף פעימה 3?

התשובה הנכונה
- נכונה 2
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
2קבוע
המספר הראשון
28ברירת מחדל
המספר השני
14ברירת מחדל
שבב / טרנזיסטורים
רכיבים
האפשרויות
- נכונה 2
- שגויה 1, הכתובת של ההוראה שהובאה
  טעות נפוצה: Thinks the program counter holds the address of the instruction being carried out, rather than the next one to fetch.
  משוב מהקטלוג
  מונה התוכנית מתקדם כבר בפעימת ההבאה: באותה פעימה שבה ההוראה נוחתת באוגר ההוראה, המונה עולה באחד. לכן בזמן הפענוח והביצוע הוא כבר מצביע על ההוראה הבאה. בזמן ש־LDB 15 מכתובת 1 מתבצעת, המונה מחזיק 2.
- שגויה 3, מספר הפעימה
  משוב
  המונה סופר הוראות בזיכרון, לא פעימות. הוא עולה באחד רק בפעימת הבאה, פעם אחת בכל שלוש פעימות.
אחרי נעילת הניבוי הסצנה משתנה
פעימת שעון
3קבוע
שבב / טרנזיסטורים
רכיבים
ואז הסצנה מראה: 2 · The program counter after this tick: the address of the next instruction to fetch/nodes/cpu/outputs/programCounter
ניבוי אף פעם לא נחשב כישלון: בכל מקרה הלומדים רואים את התוצאה ואת ההסבר.
משוב לתשובה נכונה
2. בפעימת ההבאה המונה שולח את 1 לזיכרון, ומיד עולה ל־2. בזמן ש־LDB 15 מתפענחת ומתבצעת, המונה כבר מצביע על ההוראה הבאה.

פתרון מלא
1. בתחילת פעימה 3 המונה מחזיק 1, הכתובת של ההוראה הבאה.
2. הבאה: הכתובת 1 יוצאת על אפיק הכתובות, והבית שבה, LDB 15, נוחת באוגר ההוראה.
3. באותה פעימה המונה עולה באחד: $1 + 1 = 2$ ⁠.
אם בחרתם 1, חשבתם שהמונה מחזיק את ההוראה שרצה עכשיו; הוא תמיד צעד אחד לפניה.
שלב 3 מתוך 5
לפתוח את השלב
שלוש פעימות להוראה
תרגול · הגיעו למטרה
השאלה
הזיזו את פעימת שעון אל הפעימה שבה יחידת הבקרה מפענחת את ADD, ההוראה שבכתובת 2, ולחצו על בדיקה.

המטרה
- 3 ± 0.01
  בתחילת השלב: 1
- 1 ± 0.01
  בתחילת השלב: 0
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0
המספר הראשון
28ברירת מחדל
המספר השני
14ברירת מחדל
שבב / טרנזיסטורים
רכיבים
נקרא מהסצנה בנקודה
The high four bits of the instruction register: 1 LDA, 2 LDB, 3 ADD, 4 SUB, 5 STA, 6 JMP, 7 JZ, 15 HLT/nodes/cpu/outputs/opcode
נקרא מהסצנה בנקודה
What this tick does: 0 fetch, 1 decode, 2 execute, 3 halted/nodes/cpu/outputs/phase
הגדרה אחת שמגיעה למטרה
פעימת שעון
7
המספר הראשון
0
המספר השני
0
משוב לתשובה נכונה
פעימה 7. ההוראה השלישית מתחילה בפעימה 6 בהבאה, ופעימה 7 היא הפענוח שלה. יחידת הבקרה מראה ADD ומדליקה פלט ALU וקלט A.

משוב לתשובה שגויה
עוד לא. מצאו את ההבאה של ADD ולכו פעימה אחת קדימה.

רמז
הוראה מכתובת $n$ ⁠ מתחילה בפעימה $3n$ ⁠.

פתרון מלא
1. כל הוראה תופסת שלוש פעימות, והראשונה מתחילה בפעימה 0.
2. ADD בכתובת 2 היא ההוראה השלישית, ולכן היא מתחילה בפעימה $2 \times 3 = 6$ ⁠.
3. ההבאה בפעימה 6, הפענוח בפעימה 7, הביצוע בפעימה 8.
בפעימה 6 ההוראה כבר באוגר ההוראה, אבל זו עוד ההבאה.
שלב 4 מתוך 5
לפתוח את השלב
לספור פעימות
תרגול · חשבו
השאלה
המעבד מתחיל מאיפוס בפעימה 0. ההוראה הרביעית, STA 13, כותבת את הסכום לתא 13. כמה פעימות שעון רצות, מהראשונה ועד זו שבה הסכום נכתב, כולל שתיהן?

התשובה הנכונה
12 ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0
המספר הראשון
28ברירת מחדל
המספר השני
14ברירת מחדל
שבב / טרנזיסטורים
רכיבים
מתקבלת בטווח
± 0.01
ערך קבוע בשאלה
תשובות שגויות שהשאלה מזהה
- 11 ± 0.01
  טעות נפוצה: Forgets that counting starts at 0: takes the largest address, 15, as the number of cells, or tick 11 as the eleventh tick.
  משוב מהקטלוג
  במחשב סופרים מאפס. הכתובות הן 0 עד 15, ולכן יש שישה־עשר תאים, לא חמישה־עשר. באותו אופן הפעימה הראשונה היא פעימה 0, ולכן עד סוף פעימה 11 רצו שתים־עשרה פעימות. כשהמספור מתחיל באפס, הכמות היא המספר האחרון ועוד אחד.
- 4 ± 0.01
  טעות נפוצה: Takes one clock tick to run one whole instruction, forgetting the separate fetch, decode and execute ticks.
  משוב מהקטלוג
  בשבב הזה כל הוראה לוקחת שלוש פעימות: הבאה, פענוח וביצוע. ארבע הוראות הן שתים־עשרה פעימות, ושעון של 1000 פעימות בשנייה מריץ רק כ־333 הוראות בשנייה. גם במעבדים אמיתיים הוראה אחת לוקחת בדרך כלל כמה פעימות, אף שהם מחפים הוראות זו על זו.
משוב לתשובה נכונה
ארבע הוראות כפול שלוש פעימות: $4 \times 3 = 12$ ⁠. הכתיבה קורה בפעימה 11, הפעימה השתים־עשרה, כי הספירה מתחילה ב־0.

רמז
כמה הוראות רצות עד הכתיבה, וכמה פעימות לוקחת כל אחת?

פתרון מלא
1. STA 13 היא ההוראה הרביעית: LDA, LDB, ADD, STA.
2. כל הוראה לוקחת שלוש פעימות: הבאה, פענוח, ביצוע.
3. $4 \times 3 = 12$ ⁠ פעימות: פעימות 0 עד 11.
אם עניתם $11$ ⁠, קראתם את מספר הפעימה האחרונה; כשמתחילים מ־0, יש אחת יותר. אם עניתם $4$ ⁠, ספרתם פעימה אחת להוראה.
שלב 5 מתוך 5
לפתוח את השלב
כמה הוראות עד עכשיו
תרגול · חשבו
השאלה
פעימת שעון עומדת על 9, והמכסה סגור. כמה הוראות הסתיימו לגמרי, כולל הביצוע שלהן, בסוף הפעימה הזאת?

התשובה הנכונה
3 ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
9קבוע
המספר הראשון
28ברירת מחדל
המספר השני
14ברירת מחדל
שבב / טרנזיסטורים
שבבקבוע
מתקבלת בטווח
± 0.01
מחושבת מהסצנה בהגדרה של השלב
Instructions executed once this tick ends (three ticks each; none after HLT)/nodes/cpu/outputs/instructions
תשובות שגויות שהשאלה מזהה
- 10 ± 0.01
  טעות נפוצה: Takes one clock tick to run one whole instruction, forgetting the separate fetch, decode and execute ticks.
  משוב מהקטלוג
  בשבב הזה כל הוראה לוקחת שלוש פעימות: הבאה, פענוח וביצוע. ארבע הוראות הן שתים־עשרה פעימות, ושעון של 1000 פעימות בשנייה מריץ רק כ־333 הוראות בשנייה. גם במעבדים אמיתיים הוראה אחת לוקחת בדרך כלל כמה פעימות, אף שהם מחפים הוראות זו על זו.
- 4 ± 0.01
  טעות נפוצה: Takes one clock tick to run one whole instruction, forgetting the separate fetch, decode and execute ticks.
  משוב
  ההוראה הרביעית רק הובאה בפעימה 9; הפענוח והביצוע שלה עוד לפניה.
משוב לתשובה נכונה
שלוש. פעימות 0 עד 8 הן שלוש הוראות שלמות, ופעימה 9 היא רק ההבאה של הרביעית, STA 13.

פתרון מלא
1. עד סוף פעימה 9 רצו $9 + 1 = 10$ ⁠ פעימות.
2. כל הוראה לוקחת שלוש: $10 = 3 \times 3 + 1$ ⁠.
3. שלוש הוראות הושלמו, והפעימה הנותרת היא הבאה של הרביעית.
אם עניתם $10$ ⁠, ספרתם פעימה אחת להוראה. אם עניתם $4$ ⁠, ספרתם גם את ההוראה שרק הובאה.

שיעור 3 מתוך 4 · כ־25 דקות

אוגרים וה־ALU

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

לפתוח את השיעור

6 השלבים והתשובות שלהם

שלב 1 מתוך 6
לפתוח את השלב
לחבר
תרגול · נבאו, ואז הסתכלו
השאלה
המספר הראשון הוא 100 והמספר השני 50, ושניהם כבר נטענו לאוגרים. מה יהיה באוגר A אחרי שה־ADD יתבצע, בפעימה 8?

התשובה הנכונה
150 ± 0.01
ניבוי מספרי נחשב נכון בטווח ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
5קבוע
המספר הראשון
100קבוע
המספר השני
50קבוע
שבב / טרנזיסטורים
רכיבים
אחרי נעילת הניבוי הסצנה משתנה
פעימת שעון
8קבוע
שבב / טרנזיסטורים
רכיבים
ואז הסצנה מראה: 150 · Register A after this tick/nodes/cpu/outputs/registerA
ניבוי אף פעם לא נחשב כישלון: בכל מקרה הלומדים רואים את התוצאה ואת ההסבר.
משוב לתשובה נכונה
150. ה־ALU מחברת את A ו־B, והסכום חוזר על אפיק הנתונים אל A, במקום המספר הראשון.

פתרון מלא
1. אחרי פעימה 5: A מחזיק 100, ו־B מחזיק 50.
2. בביצוע של ADD ה־ALU מחשבת $100 + 50 = 150$ ⁠.
3. קווי הבקרה פלט ALU וקלט A שולחים את התשובה ל־A, ולכן A מחזיק 150.
150 קטן מ־255, ולכן הוא נכנס בשמונה סיביות.
שלב 2 מתוך 6
לפתוח את השלב
שמונה סיביות מתגלגלות
תרגול · נבאו, ואז הסתכלו
השאלה
עכשיו המספר הראשון הוא 200 והמספר השני 100. מה יהיה באוגר A אחרי ה־ADD?

התשובה הנכונה
- נכונה 44
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
5קבוע
המספר הראשון
200קבוע
המספר השני
100קבוע
שבב / טרנזיסטורים
רכיבים
האפשרויות
- נכונה 44
- שגויה 300
  טעות נפוצה: Thinks an eight-bit register can hold any whole number, so 200 + 100 gives 300.
  משוב מהקטלוג
  לאוגר יש בדיוק שמונה סיביות, ולכן הוא מחזיק רק 0 עד 255. 300 צריך תשע סיביות, 1 0010 1100. הסיבית התשיעית לא נכנסת ל־A: היא נדלקת כדגל הנשא, ובאוגר נשארות שמונה הסיביות התחתונות, $300 - 256 = 44$ ⁠.
- שגויה 255, הגדול ביותר שנכנס
  טעות נפוצה: Thinks a sum too big for eight bits stops at the largest value, 255, instead of wrapping round past zero.
  משוב מהקטלוג
  המסכם לא יודע שיש תקרה: הוא מחבר סיבית אחר סיבית, והנשא מהסיבית העליונה פשוט לא נכנס לאוגר. לכן הסכום מתגלגל מעבר לאפס, כמו מד מרחק במכונית ישנה: 255 + 1 נותן 0, ו־250 + 10 נותן $260 - 256 = 4$ ⁠. דגל הנשא מסמן שזה קרה.
- שגויה 0, כי החישוב נכשל
  משוב
  שום דבר לא נכשל: המסכם תמיד מוציא שמונה סיביות. הוא פשוט מאבד את התשיעית.
אחרי נעילת הניבוי הסצנה משתנה
פעימת שעון
8קבוע
שבב / טרנזיסטורים
רכיבים
ואז הסצנה מראה: 44 · Register A after this tick/nodes/cpu/outputs/registerA
ניבוי אף פעם לא נחשב כישלון: בכל מקרה הלומדים רואים את התוצאה ואת ההסבר.
משוב לתשובה נכונה
44, ודגל הנשא דולק. $200 + 100 = 300$ ⁠, שהם 1 0010 1100: תשע סיביות. A שומר רק את שמונה התחתונות, $300 - 256 = 44$ ⁠.

פתרון מלא
1. הסכום האמיתי: $200 + 100 = 300$ ⁠.
2. בשמונה סיביות יש מקום רק עד 255; 300 צריך סיבית תשיעית, ששווה 256.
3. הסיבית התשיעית יוצאת לדגל הנשא, ובאוגר נשאר $300 - 256 = 44$ ⁠.
הסכום לא נתקע ב־255: הוא מתגלגל מעבר לאפס.
שלב 3 מתוך 6
לפתוח את השלב
לחשב את הגלישה
תרגול · חשבו
השאלה
המספר הראשון הוא 250 והמספר השני 10. המכסה סגור, ופעימת שעון עומדת על 8, הביצוע של ADD. מה יש באוגר A?

התשובה הנכונה
4 ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
8קבוע
המספר הראשון
250קבוע
המספר השני
10קבוע
שבב / טרנזיסטורים
שבבקבוע
מתקבלת בטווח
± 0.01
מחושבת מהסצנה בהגדרה של השלב
Register A after this tick/nodes/cpu/outputs/registerA
תשובות שגויות שהשאלה מזהה
- 260 ± 0.01
  טעות נפוצה: Thinks an eight-bit register can hold any whole number, so 200 + 100 gives 300.
  משוב מהקטלוג
  לאוגר יש בדיוק שמונה סיביות, ולכן הוא מחזיק רק 0 עד 255. 300 צריך תשע סיביות, 1 0010 1100. הסיבית התשיעית לא נכנסת ל־A: היא נדלקת כדגל הנשא, ובאוגר נשארות שמונה הסיביות התחתונות, $300 - 256 = 44$ ⁠.
- 255 ± 0.01
  טעות נפוצה: Thinks a sum too big for eight bits stops at the largest value, 255, instead of wrapping round past zero.
  משוב מהקטלוג
  המסכם לא יודע שיש תקרה: הוא מחבר סיבית אחר סיבית, והנשא מהסיבית העליונה פשוט לא נכנס לאוגר. לכן הסכום מתגלגל מעבר לאפס, כמו מד מרחק במכונית ישנה: 255 + 1 נותן 0, ו־250 + 10 נותן $260 - 256 = 4$ ⁠. דגל הנשא מסמן שזה קרה.
משוב לתשובה נכונה
$250 + 10 = 260$ ⁠, ובשמונה סיביות $260 - 256 = 4$ ⁠. דגל הנשא דולק ומסמן את ה־256 שלא נכנס.

רמז
כמה מעל 255 הסכום?

פתרון מלא
1. הסכום האמיתי: $250 + 10 = 260$ ⁠.
2. $260$ ⁠ גדול מ־255, ולכן הסיבית התשיעית, ששווה 256, נשמטת.
3. באוגר A נשאר $260 - 256 = 4$ ⁠.
אם עניתם $260$ ⁠, שכחתם שלאוגר יש רק שמונה סיביות. אם עניתם $255$ ⁠, עצרתם בתקרה; המסכם מתגלגל מעבר לה.
שלב 4 מתוך 6
לפתוח את השלב
לחסר
תרגול · נבאו, ואז הסתכלו
השאלה
בזיכרון נטענה תוכנית אחרת: בכתובת 2 יש עכשיו SUB, שמחסרת את B מ־A. המספר הראשון הוא 90 והמספר השני 25. מה יהיה ב־A אחרי פעימה 8?

התשובה הנכונה
65 ± 0.01
ניבוי מספרי נחשב נכון בטווח ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
5קבוע
המספר הראשון
90קבוע
המספר השני
25קבוע
שבב / טרנזיסטורים
רכיבים
הגדרות נוספות
Memory/nodes/cpu/props/memory = [30,47,64,93,100,0,0,0,0,0,0,0,0,0,9,4]
אחרי נעילת הניבוי הסצנה משתנה
פעימת שעון
8קבוע
שבב / טרנזיסטורים
רכיבים
ואז הסצנה מראה: 65 · Register A after this tick/nodes/cpu/outputs/registerA
ניבוי אף פעם לא נחשב כישלון: בכל מקרה הלומדים רואים את התוצאה ואת ההסבר.
משוב לתשובה נכונה
65. ה־ALU מחסרת בעזרת אותו מסכם: היא הופכת את הסיביות של B, מוסיפה 1 ומחברת. כך $90 + (256 - 25) = 321$ ⁠, ובשמונה סיביות $321 - 256 = 65$ ⁠.

פתרון מלא
1. A מחזיק 90, ו־B מחזיק 25.
2. SUB מחשבת $A - B = 90 - 25 = 65$ ⁠.
3. התשובה חוזרת ל־A.
בתוך ה־ALU זה חיבור: $90 + (256 - 25) = 321$ ⁠, והסיבית התשיעית נשמטת. לכן דגל הנשא דולק כאן, וזה מסמן שלא היה צורך “ללוות”.
שלב 5 מתוך 6
לפתוח את השלב
מתחת לאפס
תרגול · חשבו
השאלה
אותה תוכנית חיסור. המספר הראשון הוא 5 והמספר השני 8. המכסה סגור, ופעימת שעון עומדת על 8. מה יש באוגר A?

התשובה הנכונה
253 ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
8קבוע
המספר הראשון
5קבוע
המספר השני
8קבוע
שבב / טרנזיסטורים
שבבקבוע
הגדרות נוספות
Memory/nodes/cpu/props/memory = [30,47,64,93,100,0,0,0,0,0,0,0,0,0,9,4]
מתקבלת בטווח
± 0.01
מחושבת מהסצנה בהגדרה של השלב
Register A after this tick/nodes/cpu/outputs/registerA
תשובות שגויות שהשאלה מזהה
- -3 ± 0.01
  טעות נפוצה: Expects a register to store a negative result with a minus sign, as −3.
  משוב מהקטלוג
  באוגר יש רק שמונה סיביות, ואין בו מקום לסימן מינוס. כשמחסרים מספר גדול ממספר קטן, החשבון מתגלגל לאחור מעבר לאפס: $5 - 8$ ⁠ נותן $256 - 3 = 253$ ⁠, 1111 1101. מחשבים מפרשים תבנית כזו כ־−3 כשמחליטים שהסיבית העליונה היא סימן (שיטת המשלים ל־2), אבל בשבב עצמו נשאר 253.
- 3 ± 0.01
  טעות נפוצה: Expects a register to store a negative result with a minus sign, as −3.
  משוב
  SUB מחשבת תמיד $A - B$ ⁠, כאן $5 - 8$ ⁠, ולא את ההפרש החיובי.
משוב לתשובה נכונה
253, 1111 1101. $5 - 8$ ⁠ יורד שלושה צעדים מתחת לאפס ומתגלגל לאחור: $256 - 3 = 253$ ⁠.

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

פתרון מלא
1. החשבון הרגיל: $5 - 8 = -3$ ⁠.
2. באוגר אין סימן מינוס, ושמונה סיביות מתגלגלות כמו מד מרחק: צעד אחד מתחת ל־0 הוא 255.
3. שלושה צעדים מתחת לאפס: $256 - 3 = 253$ ⁠.
אם עניתם $-3$ ⁠, ציפיתם לסימן מינוס באוגר. אם עניתם $3$ ⁠, חיסרתם את הקטן מהגדול; SUB תמיד מחשבת $A - B$ ⁠.
שלב 6 מתוך 6
לפתוח את השלב
דגל האפס
תרגול · נבאו, ואז הסתכלו
השאלה
בתוכנית החיסור, המספר הראשון והמספר השני שניהם 37. מה יקרה כשה־SUB יתבצע?

התשובה הנכונה
- נכונה A יחזיק 0, ודגל האפס יידלק
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
5קבוע
המספר הראשון
37קבוע
המספר השני
37קבוע
שבב / טרנזיסטורים
רכיבים
הגדרות נוספות
Memory/nodes/cpu/props/memory = [30,47,64,93,100,0,0,0,0,0,0,0,0,0,9,4]
האפשרויות
- נכונה A יחזיק 0, ודגל האפס יידלק
- שגויה A יחזיק 0, ושום דגל לא יידלק
  משוב
  דגל האפס נדלק בדיוק כשהתשובה של ה־ALU היא 0. בשבילו הוא קיים: כדי שהוראה אחרת תוכל לשאול עליו.
- שגויה A יחזיק 74
  משוב
  $37 + 37 = 74$ ⁠ הוא חיבור. כאן בכתובת 2 יש SUB.
אחרי נעילת הניבוי הסצנה משתנה
פעימת שעון
8קבוע
שבב / טרנזיסטורים
רכיבים
ואז הסצנה מראה: 1 · 1 when the last ADD or SUB gave 0, else 0/nodes/cpu/outputs/zeroFlag
ניבוי אף פעם לא נחשב כישלון: בכל מקרה הלומדים רואים את התוצאה ואת ההסבר.
משוב לתשובה נכונה
$37 - 37 = 0$ ⁠: A מחזיק 0, ודגל האפס דולק. בשיעור הבא הוראת קפיצה תשתמש בדגל הזה כדי להחליט אם לצאת מלולאה.

פתרון מלא
1. SUB מחשבת $A - B = 37 - 37 = 0$ ⁠.
2. A קולט את 0.
3. כל ADD או SUB גם מעדכנת את הדגלים: התשובה 0, ולכן דגל האפס נדלק.

שיעור 4 מתוך 4 · כ־30 דקות

קפיצות, לולאות ומהירות שעון

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

לפתוח את השיעור

7 השלבים והתשובות שלהם

שלב 1 מתוך 7
לפתוח את השלב
תוכנית עם לולאה
תרגול · נבאו, ואז הסתכלו
השאלה
בכתובת 9 שמורה JMP 0. בפעימה 27 היא הובאה, ומונה התוכנית עלה ל־10. מה יהיה במונה אחרי הביצוע שלה, בפעימה 29?

התשובה הנכונה
0 ± 0.01
ניבוי מספרי נחשב נכון בטווח ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
27קבוע
סבבים
4
מהירות השעון
1000 Hz
שבב / טרנזיסטורים
רכיבים
אחרי נעילת הניבוי הסצנה משתנה
פעימת שעון
29קבוע
שבב / טרנזיסטורים
רכיבים
ואז הסצנה מראה: 0 · The program counter after this tick: the address of the next instruction to fetch/nodes/cpu/outputs/programCounter
ניבוי אף פעם לא נחשב כישלון: בכל מקרה הלומדים רואים את התוצאה ואת ההסבר.
משוב לתשובה נכונה
0. קפיצה לא עושה חשבון: היא כותבת את הכתובת שבהוראה ישר לתוך מונה התוכנית. ההבאה הבאה, בפעימה 30, מביאה שוב את LDA 13 מראש התוכנית.

פתרון מלא
1. אחרי ההבאה בפעימה 27 המונה מחזיק 10.
2. בביצוע של JMP 0 הכתובת 0 עוברת מאוגר ההוראה אל המונה, במקום 10.
3. לכן אחרי פעימה 29 המונה מחזיק 0, והסבב הבא מתחיל.
שלב 2 מתוך 7
לפתוח את השלב
קפיצה מותנית
תרגול · בחרו
השאלה
בכתובת 8 שמורה JZ 10, “קפוץ ל־10 אם אפס”. מתי היא קופצת?

התשובה הנכונה
- נכונה כשדגל האפס דולק: ה־SUB האחרונה הורידה את מספר הסבבים שנותרו לאפס
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
26
סבבים
4
מהירות השעון
1000 Hz
שבב / טרנזיסטורים
רכיבים
האפשרויות
מוצגות בסדר אקראי.
- נכונה כשדגל האפס דולק: ה־SUB האחרונה הורידה את מספר הסבבים שנותרו לאפס
- שגויה תמיד, כמו JMP
  משוב
  אז התוכנית הייתה מדלגת ל־HLT כבר בסבב הראשון. JZ היא קפיצה מותנית.
- שגויה כשבתא 10 יש 0
  טעות נפוצה: Confuses an address, the number that names a memory cell, with the value stored in that cell.
  משוב מהקטלוג
  כתובת היא השם של תא, כמו מספר של בית ברחוב; התוכן הוא מה שגר בו. בתא שכתובתו 14 שמור המספר 28. LDA 14 פירושו “טענו ל־A את מה שבתא 14”, כלומר 28, ולא את המספר 14 עצמו.
- שגויה אף פעם: JMP 0 שאחריה תמיד מחזירה למעלה
  טעות נפוצה: Reads a program top to bottom once, as if a jump back did not make the same instructions run again.
  משוב מהקטלוג
  קפיצה מחזירה את מונה התוכנית לכתובת מוקדמת, והמעבד פשוט ממשיך להביא משם: אותן הוראות רצות שוב, סבב אחר סבב, עד שקפיצה מותנית יוצאת מהלולאה. בתוכנית הכפל כל סבב מוסיף את המספר לסכום פעם אחת, ולכן ארבעה סבבים של 6 נותנים 24, לא 6.
משוב לתשובה נכונה
JZ בודקת את דגל האפס, שנקבע ב־SUB של הסבב. כל עוד נותרו סבבים, הדגל כבוי, והמעבד ממשיך ל־JMP 0. כשהמספר מגיע ל־0 הדגל נדלק, והקפיצה ל־10 יוצאת מהלולאה אל HLT.

פתרון מלא
1. בכתובות 4 עד 7 התוכנית טוענת את מספר הסבבים, מחסרת 1 ושומרת אותו.
2. ה־SUB מדליקה את דגל האפס רק כשהתשובה 0.
3. JZ 10 קופצת רק כשהדגל דולק; אחרת המונה ממשיך כרגיל ל־9.
הכתובת 10 שבהוראה היא לאן לקפוץ, לא תא שבודקים.
שלב 3 מתוך 7
לפתוח את השלב
לכפול בעזרת חיבור
תרגול · חשבו
השאלה
המספר שכופלים הוא עכשיו 6, וסבבים עומד על 4. המכסה סגור, והתוכנית כבר עצרה. מה יש בתא 13?

התשובה הנכונה
24 ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
239קבוע
סבבים
4קבוע
מהירות השעון
1000 Hz
שבב / טרנזיסטורים
שבבקבוע
הגדרות נוספות
Cell14/nodes/cpu/props/cell14 = 6
מתקבלת בטווח
± 0.01
מחושבת מהסצנה בהגדרה של השלב
The byte in memory cell watchAddress after this tick/nodes/cpu/outputs/watched
תשובות שגויות שהשאלה מזהה
- 6 ± 0.01
  טעות נפוצה: Reads a program top to bottom once, as if a jump back did not make the same instructions run again.
  משוב מהקטלוג
  קפיצה מחזירה את מונה התוכנית לכתובת מוקדמת, והמעבד פשוט ממשיך להביא משם: אותן הוראות רצות שוב, סבב אחר סבב, עד שקפיצה מותנית יוצאת מהלולאה. בתוכנית הכפל כל סבב מוסיף את המספר לסכום פעם אחת, ולכן ארבעה סבבים של 6 נותנים 24, לא 6.
- 10 ± 0.01
  טעות נפוצה: Reads a program top to bottom once, as if a jump back did not make the same instructions run again.
  משוב
  $6 + 4$ ⁠ מחבר את שני המספרים. הלולאה מוסיפה את 6 שוב ושוב, פעם בכל סבב.
משוב לתשובה נכונה
24. בכל סבב התוכנית מוסיפה 6 לתא 13: 6, 12, 18, 24. כך מעבד שיודע רק לחבר כופל: $6 \times 4$ ⁠ הוא ארבע פעמים 6.

רמז
כמה מוסיף כל סבב לתא 13, וכמה סבבים יש?

פתרון מלא
1. בתחילה בתא 13 יש 0.
2. כל סבב, בכתובות 0 עד 3, טוען את התא, מוסיף 6 ושומר בחזרה.
3. הלולאה רצה ארבעה סבבים, ולכן $0 + 6 + 6 + 6 + 6 = 24$ ⁠.
אם עניתם $6$ ⁠, קראתם את התוכנית פעם אחת מלמעלה למטה; JMP 0 מחזירה אותה להתחלה עוד שלוש פעמים.
שלב 4 מתוך 7
לפתוח את השלב
לספור הוראות
תרגול · חשבו
השאלה
סבבים עומד על 3. בתוכנית אחת־עשרה הוראות, בכתובות 0 עד 10. כמה הוראות המעבד מבצע מהאיפוס ועד שהוא עוצר, כולל ה־HLT?

התשובה הנכונה
30 ± 0.01
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
239קבוע
סבבים
3קבוע
מהירות השעון
1000 Hz
שבב / טרנזיסטורים
שבבקבוע
מתקבלת בטווח
± 0.01
מחושבת מהסצנה בהגדרה של השלב
Instructions executed once this tick ends (three ticks each; none after HLT)/nodes/cpu/outputs/instructions
תשובות שגויות שהשאלה מזהה
- 11 ± 0.01
  טעות נפוצה: Reads a program top to bottom once, as if a jump back did not make the same instructions run again.
  משוב מהקטלוג
  קפיצה מחזירה את מונה התוכנית לכתובת מוקדמת, והמעבד פשוט ממשיך להביא משם: אותן הוראות רצות שוב, סבב אחר סבב, עד שקפיצה מותנית יוצאת מהלולאה. בתוכנית הכפל כל סבב מוסיף את המספר לסכום פעם אחת, ולכן ארבעה סבבים של 6 נותנים 24, לא 6.
- 33 ± 0.01
  טעות נפוצה: Reads a program top to bottom once, as if a jump back did not make the same instructions run again.
  משוב
  HLT רצה רק פעם אחת, בסוף, ובכל סבב חוץ מהאחרון רצות עשר הוראות.
משוב לתשובה נכונה
30. כל סבב מבצע את עשר ההוראות שבכתובות 0 עד 9, חוץ מהאחרון, שקופץ מ־JZ ישר ל־HLT: $10 + 10 + 9 + 1 = 30$ ⁠.

רמז
כמה הוראות רצות בסבב אחד, ומה שונה בסבב האחרון?

פתרון מלא
1. סבב רגיל: עשר הוראות, כתובות 0 עד 9, כולל JMP 0.
2. בסבב האחרון JZ 10 קופצת, ולכן JMP 0 לא רצה: תשע הוראות, ואז HLT.
3. שלושה סבבים: $10 + 10 + 9 + 1 = 30$ ⁠, כלומר עשר הוראות לכל סבב.
אם עניתם $11$ ⁠, ספרתם את ההוראות שבזיכרון, כאילו כל אחת רצה פעם אחת. אם עניתם $33$ ⁠, ספרתם את כל אחת־עשרה ההוראות בכל סבב.
שלב 5 מתוך 7
לפתוח את השלב
מפעימות לשניות
תרגול · חשבו
השאלה
סבבים עומד על 4, ומהירות השעון היא 1000 Hz: אלף פעימות בשנייה. כמה זמן לוקחת התוכנית כולה, מהאיפוס עד שה־HLT מתבצעת?

התשובה הנכונה
0.12 s ± 1%
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0
סבבים
4קבוע
מהירות השעון
1000 Hzקבוע
שבב / טרנזיסטורים
רכיבים
מתקבלת בטווח
± 1%
מחושבת מהסצנה בהגדרה של השלב
How long the whole program takes at clockHz: ticksToHalt / clockHz/nodes/cpu/outputs/timeToHalt
כל יחידה של אותו גודל מתקבלת; התשובה מומרת לפני הבדיקה.
תשובות שגויות שהשאלה מזהה
- 0.04 s ± 1%
  טעות נפוצה: Takes the clock rate as the number of instructions run per second, forgetting that an instruction takes several ticks.
  משוב מהקטלוג
  מהירות השעון סופרת פעימות בשנייה, לא הוראות. כאן כל הוראה לוקחת שלוש פעימות, ולכן הזמן הוא מספר הפעימות חלקי מהירות השעון: 40 הוראות הן 120 פעימות, ובשעון של 1000 Hz הן לוקחות 0.12 s, לא 0.04 s.
משוב לתשובה נכונה
$40$ ⁠ הוראות כפול $3$ ⁠ פעימות הן $120$ ⁠ פעימות, ו־ $\dfrac{120}{1000} = 0.12$ ⁠: כלומר 0.12 s, או 120 ms.

רמז
כמה פעימות לוקחת התוכנית? חלקו במספר הפעימות בשנייה.

פתרון מלא
1. ארבעה סבבים של עשר הוראות: $40$ ⁠ הוראות, כולל ה־HLT.
2. כל הוראה שלוש פעימות: $40 \times 3 = 120$ ⁠ פעימות.
3. הזמן הוא הפעימות חלקי מהירות השעון: $t = \dfrac{120}{1000\ \mathrm{Hz}} = 0.12\ \mathrm{s}$ ⁠.
אם עניתם 0.04 s, חילקתם הוראות ולא פעימות במהירות השעון.
שלב 6 מתוך 7
לפתוח את השלב
שעון מהיר יותר
תרגול · הגיעו למטרה
השאלה
סבבים קבוע על 4, כך שהתוכנית לוקחת 120 פעימות. שנו את מהירות השעון עד שהתוכנית כולה לוקחת 0.03 s, ולחצו על בדיקה.

המטרה
- 0.03 s ± 0.0005 s
  בתחילת השלב: 0.12 s
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0קבוע
סבבים
4קבוע
מהירות השעון
1000 Hz
שבב / טרנזיסטורים
רכיבים
נקרא מהסצנה בנקודה
How long the whole program takes at clockHz: ticksToHalt / clockHz/nodes/cpu/outputs/timeToHalt
הגדרה אחת שמגיעה למטרה
מהירות השעון
4000 Hz
משוב לתשובה נכונה
4000 Hz: $\dfrac{120}{4000} = 0.03$ ⁠. שעון מהיר פי ארבעה מריץ את אותן 120 פעימות ברבע מהזמן. התוכנית לא השתנתה, רק הקצב.

משוב לתשובה שגויה
עוד לא. חלקו את 120 הפעימות ב־0.03 s.

רמז
פי כמה צריך לקצר את הזמן?

פתרון מלא
1. הזמן: $t = \dfrac{N}{f}$ ⁠, כש־ $N$ ⁠ מספר הפעימות, ולכן $f = \dfrac{N}{t}$ ⁠.
2. הצבה: $f = \dfrac{120}{0.03} = 4000\ \mathrm{Hz}$ ⁠.
3. קבעו את מהירות השעון על 4000 Hz.
ב־1000 Hz התוכנית לוקחת 0.12 s: פי ארבעה יותר זמן.
שלב 7 מתוך 7
לפתוח את השלב
מעבדים אמיתיים
תרגול · בחרו
השאלה
למעבד אמיתי יש שעון של 3 GHz: שלושה מיליארד פעימות בשנייה. אילו כל הוראה בו הייתה לוקחת שלוש פעימות, כמו בשבב שלנו, כמה הוראות היה מבצע בשנייה?

התשובה הנכונה
- נכונה מיליארד
הגדרות, אפשרויות ומשוב
הסצנה בשלב הזה
פעימת שעון
0
סבבים
4
מהירות השעון
1000 Hz
שבב / טרנזיסטורים
רכיבים
האפשרויות
מוצגות בסדר אקראי.
- נכונה מיליארד
- שגויה שלושה מיליארד
  טעות נפוצה: Takes the clock rate as the number of instructions run per second, forgetting that an instruction takes several ticks.
  משוב מהקטלוג
  מהירות השעון סופרת פעימות בשנייה, לא הוראות. כאן כל הוראה לוקחת שלוש פעימות, ולכן הזמן הוא מספר הפעימות חלקי מהירות השעון: 40 הוראות הן 120 פעימות, ובשעון של 1000 Hz הן לוקחות 0.12 s, לא 0.04 s.
- שגויה תשעה מיליארד
  משוב
  שלוש פעימות להוראה פירושן פחות הוראות מפעימות, לא יותר: מחלקים בשלוש, לא כופלים.
משוב לתשובה נכונה
$\dfrac{3 \times 10^9}{3} = 10^9$ ⁠: מיליארד הוראות בשנייה. מעבדים אמיתיים מגיעים ליותר, כי הם מחפים הוראות ומריצים כמה בבת אחת, אבל השעון עדיין סופר פעימות, לא הוראות.

פתרון מלא
1. 3 GHz הם $3 \times 10^9$ ⁠ פעימות בשנייה.
2. כל הוראה לוקחת שלוש פעימות.
3. הוראות בשנייה: $\dfrac{3 \times 10^9}{3} = 10^9$ ⁠, מיליארד.
אם בחרתם שלושה מיליארד, הנחתם שכל פעימה מסיימת הוראה.

בכל היחידה · 13 טעויות נפוצות

קטלוג הטעויות הנפוצות

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

תוכן העניינים

זיכרון וכתובות

שישה־עשר תאים

השאלה

התשובה הנכונה

הסצנה בשלב הזה

האפשרויות

רמז

פתרון מלא

בית אחד

השאלה

התשובה הנכונה

הסצנה בשלב הזה

תשובות שגויות שהשאלה מזהה

רמז

פתרון מלא

בית הוא מספר

השאלה

התשובה הנכונה

הסצנה בשלב הזה

תשובות שגויות שהשאלה מזהה

רמז

פתרון מלא

קוד פעולה וכתובת

השאלה

התשובה הנכונה

הסצנה בשלב הזה

האפשרויות

פתרון מלא

מעתיקים, לא מזיזים

השאלה

התשובה הנכונה

הסצנה בשלב הזה

האפשרויות

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

פתרון מלא

הבאה, פענוח, ביצוע

לולאה אחת

השאלה

התשובה הנכונה

הסצנה בשלב הזה

האפשרויות

פתרון מלא

מונה התוכנית

השאלה

התשובה הנכונה

הסצנה בשלב הזה

האפשרויות

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

פתרון מלא

שלוש פעימות להוראה

השאלה

המטרה

הסצנה בשלב הזה

הגדרה אחת שמגיעה למטרה

רמז

פתרון מלא

לספור פעימות

השאלה

התשובה הנכונה

הסצנה בשלב הזה

תשובות שגויות שהשאלה מזהה

רמז

פתרון מלא

כמה הוראות עד עכשיו

השאלה

התשובה הנכונה

הסצנה בשלב הזה

תשובות שגויות שהשאלה מזהה

פתרון מלא

אוגרים וה־ALU

לחבר

השאלה

התשובה הנכונה

הסצנה בשלב הזה

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

פתרון מלא

שמונה סיביות מתגלגלות

השאלה

התשובה הנכונה

הסצנה בשלב הזה