‫פתרונות‬

‫תרגיל חובה מספר ‪ 5‬בארכיטקטורה ‪ 2022‬ב מועד הגשה ‪8.5.2022 :‬‬

‫( לתרגיל זה מצורף נספח תרשימים מהספר לשאלות חומרה חומרה ונספח‬
‫תזכורת העברה קדימה)‬

‫שאלה ‪1‬‬

‫א‪ .‬הפקודה תשמור במקום בזיכרון ‪ 4+$6‬את הערך של אוגר ‪ $2‬יתבצע‪:‬‬

‫‪Mem [0x00400000+4]= 0x00421020‬‬
‫כלומר למקום בזיכרון ‪ 0x00400004‬בו נמצאת הפקודה ‪ bne $2,$6,Exit‬ישמר הערך ‪0x00421020‬‬
‫שהוא למעשה הקידוד של הפקודה ‪ .add $2,$2,$2‬כלומר בקוד "הושתלה" הפקודה הבאה לביצוע ( ‪add‬‬
‫‪ ) $2,$2,$2‬ו"דרסה" את הפקודה ‪. bne $2,$6,Exit‬‬
‫ב‪ $2=0x01084080 .‬בסוף הקוד‬
‫כעת בקוד החדש שנוצר באופן עבודה חד מחזורי יתבצעו ברצף שתי פקודות ‪ add $2,$2,$2‬כלומר ערכו של‬
‫אוגר ‪ $2‬יוכפל פי ‪0x00421020*4=0x01084080 .4‬‬

‫‪ $1=0‬בסוף הקוד‪.‬‬ ‫ג‪.‬‬

‫פקודת ה )‪ lw $3,4($6‬טוענת לאוגר ‪ 3‬את הערך הנמצא במקום בזיכרון ‪ 0x00400004‬ערך זה הוא כזכור‬
‫ערכו של אוגר ‪ ( $2‬שהושתל בפקודת ה ‪ )sw‬לאחר מכן פקודת ה ‪ sll $3,$3,2‬מבצעת הכפלה ב ‪ 4‬לערך זה‬
‫כך שלמעשה ערכו של ‪ $3‬זהה לערכו של ‪ $2‬בסוף הקוד (‪ .)0x01084080‬מאחר וערכים אלו זהים הפקודה‬
‫‪ slt $1,$3,$2‬מחזירה ‪ 0‬באוגר ‪$1‬‬

‫ד‪ .‬כן סעיפים ב ו ג ישתנו כעת ‪ $1=1 $2=0x00421020‬בסוף הקוד‪.‬‬

‫היות ו ‪ ALUSrc=0‬ה ‪ ALU‬יבצע פעולה של ‪ $rs+$rt‬בפקודה )‪ .sw $2,4($6‬כלומר ערכו של אוגר ‪$2‬‬
‫ישמר במקום בזיכרון ‪($rs+$rt) $6+$2‬יתבצע‪:‬‬
‫‪Mem [0x00400000+0x00421020]= 0x00421020‬‬
‫מקום בזיכרון ‪ 0x00821020‬יקבל את הערך ‪ .0x00421020‬היות ובהגדרות השאלה ניתן לגשת לכל מרחב‬
‫הזיכרון לא ברור מה היה קודם במקום זה‬
‫במצב זה פקודת ה ‪ bne‬לא "נדרסה" והקוד לא השתנה‪ .‬פקודת ה ‪ bne‬תקיים )‪ ($2≠$6‬והקפיצה תלקח‬
‫)‪ .(branch taken‬תתבצע קפיצה לתווית ‪ ,Exit‬בסופו של קוד ערכם של אוגרים ‪ $3 $2‬לא השתנה ונשאר‬
‫בערכם ההתחלתי ‪ .$3=0 ,$2=0x00421020‬מאחר ו ‪ $3‬קטן בערכו מ ‪ $2‬הפקודה ‪ slt $1,$3,$2‬מחזירה‬
‫‪ 1‬באוגר ‪.$1‬‬

‫ה‪ .‬סעיף ב ללא שינוי‪ $2=0x01084080,‬סעיף ג ‪ $1=0x02108100‬בסיום הקוד‪.‬‬

‫קו הבקרה ‪ ALUOp=00‬מגדיר פעולת חיבור ל ‪ ALU‬ללא תלות בערך שדה ‪ func‬בפקודה ‪ .slt‬ה ‪ALU‬‬
‫יבצע פעולה של ‪ $rs+$rt‬התוצאה תיכתב לאוגר ‪ .$1‬כלומר ‪. $1= $2+$3‬‬
‫ערכם של ‪ $2=$3=0x01084080‬כמוסבר בסעיף ג ולכן‪:‬‬
‫‪$1=0x01084080+0x01084080=0x02108100‬‬

‫‪ 8‬פעימות שעון‪ .‬במצב של עבודה בצנרת הכתיבה של פקודת ה ‪ sw‬לכתובת ‪ 0x00400004‬מתבצעת‬ ‫ו‪.‬‬
‫בפעימת השעון הרביעית בביצוע הקוד‪ ,‬כבר בפעימה השניה מתבצעת הבאה )‪ (fetch‬של פקודת ה ‪bne‬‬
‫מכתובת זו‪ ,‬כך שלמעשה השינוי בקוד לא ישפיע על ביצועו‪ .‬פקודת ה ‪ bne‬תקיים )‪ ($2≠$6‬והקפיצה תלקח‬
‫)‪ .(branch taken‬תתבצע קפיצה לתווית ‪ Exit‬שם נמצאת הפקודה האחרונה בקוד‪ .‬כך שיש ‪ 3‬פקודות‬
‫לביצוע ‪ +‬פעימת שעון לסיכון הבקרה של ה ‪( branch‬נדרש ‪ flush‬אחד)‪ 4 +‬פעימות למילוי הצנרת‪ ,‬סה"כ‬
‫‪ 8‬פעימות שעון‪.‬‬
‫כן ‪ ,‬סעיפים ב ו ג ישתנו כעת ‪ $1=1 $2=0x00421020‬בסוף הקוד‪ .‬כמו שמוסבר בסעיף ו היות וה‬ ‫ז‪.‬‬
‫‪ branch‬נלקח הקוד יורץ באופן המתואר בסעיף ד ולכן החישובים הם כמתואר בסעיף ד‪.‬‬

‫ח‪ .‬כן סעיפים ב ו ג ישתנו כעת ‪ $1=1 $2=0x00824040‬בסוף הקוד‪.‬‬

‫פקודת ה ‪ bne‬תקיים )‪ ($2≠$6‬והקפיצה תלקח )‪ (branch taken‬ותתבצע קפיצה לתווית ‪ ,Exit‬אבל‬
‫בתצורת עבודה ‪ delay slot‬הפקודה שלאחר ה ‪ branch‬מתבצעת בכל מקרה כלומר מתבצעת הפקודה‬
‫‪( add $2,$2,$2‬הנמצאת בכתובת ‪: ) 0x00400008‬‬
‫‪$2=0x00421020+0x00421020=0x00842040‬‬
‫(כלומר בוצעה רק פקודת ‪ add $2,$2,$2‬אחת והוכפל ערכו של ‪ $2‬בשונה מסעיף ב בו בוצעה פקודה‬
‫זו פעמיים ולכן ערכו הראשוני של ‪ $2‬הוכפל פי ‪ .4‬וגם בשונה מסעיפים ז ו ד בהן ערכו של ‪ $2‬לא‬
‫השתנה במהלך הריצה‪).‬‬
‫ערכו של ‪ $3‬לא השתנה במהלך הריצה ונשאר ‪ .0‬מאחר ו ‪ $3‬קטן בערכו מ ‪ $2‬הפקודה ‪slt‬‬
‫‪ $1,$3,$2‬מחזירה ‪ 1‬באוגר ‪. $1‬‬

‫ט‪ .‬בפעימת השעון החמישית בביצוע הקוד )‪ sw $2,4($6‬נמצאת בשלב ‪ WB 5‬בשלב ‪ 4‬נמצאת הפקודה ‪bne‬‬
‫‪ $2,$6,Exit‬ובשלב ‪ 3‬נמצאת הבועה (הפקודה ‪ add $2,$2,$2‬שעברה ‪(flush‬‬
‫במצב זה בכל מקרה ‪ RegWrite‬בפקודות אלו הוא ‪ 0‬ואין סיכון נתונים‪ .‬לכן שאר הבדיקות אינן‬
‫רלוונטיות‪.‬‬
‫(לא ניתן לדעת במדויק אלו ערכים יכנסו לבדיקה ליחידת העברה קדימה‪ ,‬מאחר ו ‪ regdst‬בפקודות‬
‫בשלב ‪ sw 5‬ושלב ‪ bne 4‬לא מוגדר ולכן לא ניתן לדעת את ערכי ‪ EX/MEM.RegisterRD‬ו‬
‫‪ MEM/WB.RegisterRD‬כמובן שהבדיקה מול ערכי הבועה בשלב ‪ID/EX.RegisterRs 3‬‬
‫‪ ID/EX.RegisterRt‬היא חסרת משמעות )‬
 ‫שאלה ‪:2‬‬
‫בשלב הראשון ‪: Fetch-‬‬
‫ע"פ ערך הקידוד ‪ 0x8ca4fff8=10001100101001001111111111111000‬היוצא מזיכרון הפקודות ניתן לראות‬
‫שהפקודה היא‪:‬‬
‫)‪lw $4,-8($5) lw $a0,-8($a1‬‬
‫הפקודה מחשבת כתובת בזיכרון הנתונים באמצעות חיבור תוכן אוגר ‪ $5‬והיסט ‪ -8‬ומאחסנת את המילה מכתובת‬
‫זו באוגר ‪.$4‬‬
‫תוכן האוגרים ‪ $4‬או ‪ $5‬לא ידוע ע"פ נתוני השאלה וע"פ הערכים הנמצאים בפקודות בשלב מתקדם יותר בצנרת‪.‬‬

‫כתובת הפקודה ידועה ע"ס הפקודה שבשלב ‪( EXE-3‬ראו חישוב שם)וערכה ‪(0x3034‬בהנחה סבירה שאין‬
‫פסיקות והפקודות רציפות בזיכרון)‬

‫שלב השני‪:Decode-‬‬
‫הפקודה בשלב זה ‪ ) sub $v1,$t0,$s2) sub $3,$8,$18‬קידוד ב ‪ 8‬ספרות הקסא‪0x01121822 :‬‬
‫ל‪ control-‬מועבר ‪ 0‬זה ה‪ opcode-‬ולכן מדובר ב‪. R-Fromat-‬‬
‫משדה ה‪ (0x1822=0001100000100010) imeediate-‬ניתן לגלות את אוגר ‪ $rd‬ואת ‪ function‬שהוא ‪0x22‬‬
‫שזוהי פעולת ‪ sub‬לכן זוהי הפקודה‪.‬‬
‫מהערך ‪ Read register 1‬בכניסה למקבץ האוגרים ניתן לראות ‪ $rs=8‬ומהערך של סיביות ‪ 16-20‬ניתן לראות‬
‫ש ‪$rt=0x12=18dec‬‬
‫מהיציאות ממקבץ האוגרים ניתן לראות כי תוכן אוגר )‪ 0x12(18dec‬הוא ‪ 0x100‬ותוכן אוגר ‪ 8‬הוא ‪.0x200‬‬
‫כלומר הפקודה תבצע‪:‬‬
‫‪$3=$8-$18=0x200-0x100=0x100 → $3=0x100‬‬
‫כתובת הפקודה ידוע ע"ס הפקודה שבשלב ‪ EXE-3‬וערכו ‪( 0x3030‬בהנחה סבירה שאין פסיקות והפקודות‬
‫רציפות בזיכרון)‬

‫שלב השלישי‪:Exe-‬‬
‫הפקודה המבוצעת בשלב זה היא )?(‪sw $8,-4‬‬
‫לא ניתן לדעת מהו האוגר ‪ rs‬אבל תוכנו ע"ס הכניסה הראשונה ל ‪ ALU‬הוא ‪.0x1004=4100dec‬‬
‫לכן הקידוד בבינארי הידוע לנו‪1010 ?????010001111111111111100 :‬נוד‪2‬נוד‬
‫‪ 11‬ולא ניתן לתרגם ל ‪ 8‬ספרות הקסא‪.‬‬
‫היות וקווי הבקרה של שלב ה ‪ MEM‬הם ‪ 001bin‬ע"ס טבלה ‪ 4.49‬הפקודה היא ‪( . sw‬ניתן גם לראות‬
‫שהבקרות של שלב‪ WB‬הן ‪) 00‬‬
‫ע"ס הכניסות ל ‪ ALU‬כניסה ‪ 0x1004 :1‬כניסה ‪ ( aluctrl=0010bin -4 : 2‬ניתן לראות שגם ‪) aluop=00‬‬
‫כלומר ה ‪ ALU‬מבצע פעולת חיבור בין )‪0x1004+(-4)=0x1000(4096dec‬‬
‫לכתובת זו נכתב התוכן של אוגר ‪ ( $8‬ניתן לדעת ע"ס כניסה ‪ 0‬למרבב של ‪.) regdst‬‬
‫התוכן עצמו מוזכר בשלב השני (‪ )ID‬והוא ‪. 0x200‬‬
‫כלומר‪:‬‬
‫‪Mem(0x1000)=0x200‬‬

‫את כתובת הפקודה ניתן לחלץ ע"ס הערך שב ‪ branch target‬כאשר הערך שנציב עבור ‪ PC‬במשוואה זה‬
‫למעשה הכתובת בזיכרון של הפקודה ‪ SW‬הנמצאת כעת בשלב ‪ 3‬בצנרת‪.‬‬
‫‪(+4+ (-4)*4=0x3020‬כתובת הפקודה)‪PC‬‬
‫כלומר ‪ 0x302C‬היא כתובת הפקודה שבשלב ‪ 3‬והיות ואין פקודות קפיצה במעבד (בתוך ‪ 5‬הפקודות הנמצאות‬
‫בזמן זה בצנרת) ובהנחה שאין פסיקות ניתן ע"ס ערך זה לדעת את רצף הכתובות של כל הפקודות‬
‫הנמצאות בנקודת זמן זו בצנרת)‬

‫שלב ה‪:Mem-‬‬
‫הפקודה היא )?(?‪( lw $12,‬לא ניתן לדעת קידוד מלא)‬
 ‫ניתן לדעת שזו ‪( lw‬במימוש המצומצם ע"פ פרק ‪) 4‬על סמך קו הבקרה ‪ MemRead‬הוא ‪.1‬‬
‫ערך ‪ EX/MEM.RD=12‬כלומר הפקודה תכתוב בשלב ‪ 5‬לאוגר מספר ‪.12‬‬
‫הערך של ה ‪ ALUResult‬שחושב בשלב הקודם (שלב ‪ ) 3‬הוא ‪ 0x7000‬כלומר הפקודה תיקח את התוכן של מה‬
‫שנימצא בכתובת זו בזיכרון הנתונים‪ .‬כלומר הפקודה תבצע‪:‬‬
‫)‪$12= Mem(0x7000‬‬

‫כתובת הפקודה ידועה ע"ס הפקודה שבשלב ‪ EXE-3‬וערכה ‪0x3028‬‬

‫שלב ה‪:WB-‬‬
‫הפקודה היא )?(?‪( lw $31,‬לא ניתן לדעת קידוד מלא)‬
‫ניתן לדעת שזו ‪( lw‬במימוש המצומצם ע"פ פרק ‪) 4‬על סמך קווי הבקרה ‪Rewrite=1 MemtoReg=1‬‬
‫ערך ‪ MEM/WB.RD=31‬כלומר הפקודה כותבת בשלב זה לאוגר מספר ‪($ra) 31‬‬
‫הערך שייכתב לאוגר ‪ 31‬הוא הערך ‪ 6‬היושב ב ‪MEM/WB.readData‬‬
‫כלומר הפקודה תבצע ‪$31=6 :‬‬
‫כתובת הפקודה ידועה ע"ס הפקודה שבשלב ‪ EXE-3‬וערכה ‪0x3024‬‬
 ‫שאלה ‪3‬‬

‫א‪.‬‬
‫‪EX‬‬ ‫‪MEM‬‬ ‫‪WB‬‬
‫‪Mem-‬‬ ‫‪Mem-‬‬ ‫‪Reg-‬‬ ‫‪Memto-‬‬
‫‪Instruction‬‬ ‫‪RegDst‬‬ ‫‪ALUOp1‬‬ ‫‪ALUOp0‬‬ ‫‪ALUSrc‬‬ ‫‪Branch‬‬ ‫‪Read‬‬ ‫‪Write‬‬ ‫‪Write‬‬ ‫‪Reg‬‬

‫‪addi‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬

‫ב‪.‬‬

‫)‪0x1000 lw $13, 8 ($0‬‬

‫‪0x1004 addi $8, $7, -3‬‬

‫‪0x1008 sub $11, $8, $13‬‬

‫)‪0x100C sw $15, 12($0‬‬

‫‪0x1010 add $16,$8,$11‬‬

‫פירוט סיכוני הנתונים‪:‬‬
‫‪ )1‬בין ה‪ lw‬ל‪ sub‬ישנו סיכון נתונים על ערכו של ‪ $13‬שיזוהה ע"י יחידת ההעברה קדימה מקרה‬
‫‪ 2b‬בהעברה קדימה בבדיקה‪:‬‬
‫‪ MEM/WB.RegisterRd = ID/EX.RegisterRt‬ולפיכך מרבב ‪ ForwardB‬ינותב לכניסה ‪01‬‬
‫ויעביר את ‪ $13‬המעודכן (מה‪.)MEM/WB -‬‬
‫‪ )2‬בין ה‪ addi‬ל‪ sub‬ישנו סיכון נתונים על ערכו של ‪ $8‬שיזוהה (באותה פעימת השעון של זיהוי‬
‫הסיכון הקודם) ע"י יחידת ההעברה מקרה ‪ 1a‬בהעברה קדימה בבדיקה ‪:‬‬
‫‪ EX/MEM.RegisterRd = ID/EX.RegisterRs‬ולפיכך מרבב ‪ ForwardA‬ינותב לכניסה ‪10‬‬
‫ויעביר את ‪ $8‬המעודכן (מה‪.) EX/MEM-‬‬
‫‪ )3‬בין ה‪ add‬ל‪ addi‬סיכון הנתונים על ‪ $8‬נפתר ע"י חציית מקבץ האוגרים‪ .‬כלומר באותו מחזור‬
‫שעון מקבץ האוגרים נכתב תחילה (באמצע המחזור) ואח"כ (בסוף המחזור) נקרא‪ .‬לכן נקרא‬
‫ממקבץ האוגרים הערך המעודכן של אוגר ‪( .$8‬הרבה לא יתייחסו לחציית מקבץ האוגרים‬
‫כסיכון וקיבלנו גם תשובה זו)‬
‫‪ )4‬בין ה‪ add‬ל‪ sub‬ישנו סיכון נתונים שיזוהה ע"י יחידת ההעברה מקרה ‪ 2b‬בהעברה קדימה‬
‫בבדיקה‪:‬‬
‫‪ MEM/WB.RegisterRd = ID/EX.RegisterRt‬ולפיכך מרבב ‪ ForwardB‬ינותב לכניסה ‪01‬‬
‫ויעביר את ‪ $11‬המעודכן‪.‬‬
 ‫ג‪ .‬היחידות החסרות הן המרבב של ‪ alusrc‬בכניסה ל ‪ ALU‬יחידת ה‪ sign-extend-‬וכן כל היחידות העוסקות‬
‫בחישוב כתובת הקפיצה‪ .‬המטרה היא לפשט את השרטוט על מנת להדגיש את היחידות העוסקות בסיכוני נתונים‬
‫)‪ (forwarding unit ,HDU‬בצורה ברורה יותר‪.‬‬

‫ד‪.‬‬
‫‪W1=0x1‬‬
‫קו ‪ PC Write‬מקבל ‪ (Disable) 0‬רק בזיהוי של ‪ load use‬בכל שאר המצבים ערכו ‪(Enable) 1‬‬
‫‪W2= 0x0‬‬
‫קו ‪ ID/EX.NemRead‬מקבל ‪ 1‬רק בפקודה ‪lw‬‬
‫‪W3=0x00000040‬‬
‫ערך אוגר ‪ 8‬המקורי כפי שנקרא ממקבץ האוגרים‬
‫‪W4=0x000000A9‬‬
‫ערך אוגר ‪ 13‬המקורי כפי שנקרא ממקבץ האוגרים‬
‫‪W5=0x0000002E‬‬
‫ערך אוגר ‪ 8‬שהועבר קדימה מהפקודה ‪ addi‬כמפורט בסיכון נתונים ‪ 2‬בסעיף ב‬
‫‪W6=0x2‬‬
‫ניתוב המרבב כמפורט בסיכון נתונים ‪ 2‬סעיף ב‬
‫‪W7=0x1‬‬
‫ניתוב המרבב כמפורט בסיכון נתונים ‪ 1‬סעיף ב‬
‫)‪W8=0x0b (RD‬‬
‫)‪W9= 0x08 (ID/EX.rs‬‬
‫)‪W10=0x0D (ID/EX.rt‬‬
‫‪W11=W5=0x2E‬‬
‫)‪W12= 0x08 (EX/MEM.RD‬‬
‫)‪W13=0x0D (MEM/WB.RD‬‬
‫(לפי נתוני השאלה) ‪W14=0x0c0c0c0c‬‬
‫)‪)W16=0x1 (MEM/WB.RegWrite‬הכתובת אליה ניגשנו בפקודה ( ‪W15= 0x00000008‬‬

‫ה‪ .‬לפי תרשים ‪ ,4.65‬פעולת חישוב ‪ branch target‬מבוצעת בשלב ה ‪ ID‬בו נמצאת הפקודה ‪ sw‬ולכן יחבר‬
‫ביחס לנתוני ‪ (pc=0x100c imm=12=0xc) sw‬יתבצע‪:‬‬
‫)‪Branch target=PC + 4 + 4*imm = 0x100c + 4 + 4*0xc = 0x1040 (=4160dec‬‬
‫לעומת זאת‪ ,‬לפי תרשים ‪ ,4.51‬פעולת חישוב ‪ branch target‬מבוצעת בשלב ה ‪ EX‬בו נמצאת הפקודה ‪sub‬‬
‫ולכן יחבר ביחס לנתוני ‪pc=0x1008 . sub‬‬
‫שדה ה ‪ imm‬יתקבל כצירוף של‪rd+shamt+func=0101100000100010=0x5822 :‬‬
‫‪Branch target=PC + 4 + 4*imm = 0x1008 + 4 + 4*0x5822 = 0x17094‬‬
‫)‪(=94356dec‬‬

‫ו‪ .‬בתרשים ‪ beq 4.65‬מבוצעת בשלב ‪ ,ID‬ולכן אפשר להוריד מטבלה ‪ 4.49‬את קו הבקרה ‪ branch‬שאמור‬
‫לפעול בשלב ה ‪ .MEM‬כמו כן אפשר להוריד את כל השורה המתייחסת לפקודה ‪ ,beq‬מאחר שגם שם‬
‫ההתייחסות הינה לשלבים מתקדמים בביצוע הפקודה (‪ EX‬ו ‪.)MEM‬‬