1 / 39

מבנה מחשבים ספרתיים 234267

מבנה מחשבים ספרתיים 234267. תרגול מס' 3 : Data Hazards מבוסס על תרגול של מורן גביש. ADD $1 $2 $3 (R1  R2 + R3) ADD $4 $1 $5 (R4  R1 + R5). קטע קוד זה יוצר Data Hazard (תלות מידע) מסוג RAW (read after write) .

favian
Download Presentation

מבנה מחשבים ספרתיים 234267

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. מבנה מחשבים ספרתיים234267 תרגול מס' 3: Data Hazards מבוסס על תרגול של מורן גביש 234267 - November 2005

  2. ADD $1 $2 $3 (R1  R2 + R3) • ADD $4 $1 $5 (R4  R1 + R5) קטע קוד זה יוצר Data Hazard (תלות מידע) מסוג RAW (read after write). בעיית ה- Data Hazard נוצרת כשפקודה הנמצאת בשלב ה- ID קוראת ערך של רגיסטר שפקודה קודמת לה, הנמצאת בשלב ה- EX ,MEM או WB צריכה לעדכן ועדיין לא כתבה את העדכון לתוך ה- RF. בעיית ה- RAW Data Hazard יכולה להיווצר בין פקודות ב- pipelined MIPS, שקיים בינן הפרש של לכל היותר שתי פקודות. 234267 - November 2005

  3. ID/EX IF/ID WB M EX ALU Zero Instruction Memory result 0 m u x Read Address 1 EX/MEM MEM/WB WB WB M R1 new value is still being processed Value that was read from R1 is the old one! Data Memory Read reg 1 Read data 1 Read reg 2 Write Address Register File Read data 2 Instruction Read Data Write reg Read Address Write data Write Data 32 ADD $1 $2 $3 ADD $4 $1 $5ADD $1 $2 $3 Rd\Rt Rd\Rt ADD $4 $1 $5ADD $1 $2 $3 234267 - November 2005

  4. פתרונות ל- Data Hazards stall הפתרון הפשוט ביותר הוא לבצע stall ל- pipeline. פעולה כזו תעכב את ריצת הפקודות התלויות עד לסיום הפקודה שמעדכנת את הרגיסטר. פתרון זה פוגע בביצועי ה- pipeline והינו בזבזני ביותר. 234267 - November 2005

  5. ID/EX IF/ID WB M EX ALU Zero Instruction Memory result 0 m u x Read Address 1 EX/MEM MEM/WB WB WB M Data Memory Read reg 1 Read data 1 Read reg 2 Write Address Register File Read data 2 Instruction Read Data Write reg Read Address Write data Write Data 32 ADD $1 $2 $3 ADD $1 $2 $3 ADD $4 $1 $5 ADD $4 $1 $5 ADD $1 $2 $3 ADD $4 $1 $5 ADD $1 $2 $3 Rd\Rt ADD $1 $2 $3 ADD $4 $1 $5 Rd\Rt ADD $4 $1 $5 234267 - November 2005

  6. פתרונות ל- Data Hazards (2) חציית RF) register File) אם קיים הפרש של שתי פקודות בין הפקודה הכותבת לפקודה הקוראת, אז הפקודה שכותבת לרגיסטר Rx נמצאת בשלב ה- WB כשהפקודה שקוראת מרגיסטר Rx נמצאת בשלב ה- ID. לפי השיטה הקודמת היינו צריכים לבצע stall יחיד ל- pipeline. פתרון יעיל יותר למקרה זה הוא חציית RF – הכתיבה ל- RF בשלב ה- WB מתבצעת בחצי הראשון של מחזור השעון והקריאה מ- RF בשלב ה- ID מתבצעת בחצי השני של מחזור השעון. 234267 - November 2005

  7. ID/EX IF/ID WB M EX ALU Zero Instruction Memory result 0 m u x Read Address 1 EX/MEM MEM/WB WB WB M Data Memory Read reg 1 Read data 1 Read reg 2 Write Address Register File Read data 2 Instruction Read Data Write reg Read Address Write data Write Data 32 ADD $1 $2 $3 ADD $1 $2 $3 ADD $4 $1 $5 ADD $4 $1 $5 ADD $1 $2 $3 ADD $4 $1 $5 ADD $1 $2 $3 ADD $4 $1 $5 Rd\Rt ADD $1 $2 $3 Rd\Rt 234267 - November 2005

  8. פתרונות ל- Data Hazards (3) Forwarding / Bypassing שיטה זאת מסתמכת על העובדה הבאה: ערך רגיסטר המטרה של הפקודה הכותבת ידוע כבר בסוף שלב ה- EX שלה ונכתב ל- רגיסטר (EX\MEM (latch בסוף שלב זה. בסיום שלב ה- MEM ערך זה נכתב לרגיסטר MEM\WB ורק בשלב ה- WB נכתב הערך לרגיסטר המטרה. כלומר, נוכל להשתמש בערך רגיסטר המטרה לפני שערך זה נכתב בפועל לרגיסטר. 234267 - November 2005

  9. אם הפקודות שיש בינן RAW Data Hazard הן צמודות (והפקודה הראשונה איננה LW) אז הפקודה שכותבת לרגיסטר Rx נמצאת בשלב MEM כאשר הפקודה שקוראת מרגיסטר Rx נמצאת בשלב ה- EX (לאחר שכבר קראה ערך לא נכון של Rx בשלב ה- ID שלה). הפתרון למקרה זה הוא העברת התוכן החדש של רגיסטר Rx משלב MEM (של הפקודה הכותבת) לשלב EX (של הפקודה שמשתמשת בנתון) לכניסה המתאימה של ה- ALU. כלומר נבצע forwarding משלב ה- MEM לשלב ה- EX. אם הפקודה הראשונה (הכותבת לרגיסטר) היא פקודת LW, לא נוכל לבצע forwarding משלב ה- MEM לשלב ה- EX כי ערך רגיסטר המטרה ידוע רק בסוף שלב ה- MEM. לא נוכל לפתור בעיה זאת מבלי להשהות את ה- pipeline. • פתרונות ל- Data Hazards (4) 234267 - November 2005

  10. 0 m u x ID/EX 1 IF/ID WB M EX ALU Zero Instruction Memory result 0 m u x Read Address 1 EX/MEM MEM/WB WB WB M Value that was read from R1 is the old one! Data Memory Read reg 1 Read data 1 Read reg 2 Write Address X Register File Read data 2 Instruction Read Data Write reg Read Address Write data Write Data 32 ADD $4 $1 $5 ADD $1 $2 $3 ADD $4 $1 $5 ADD $1 $2 $3 ADD $4 $1 $5 LW $1 100($4) Rd\Rt Rd\Rt ADD $4 $1 $5 LW $1 100($4) 234267 - November 2005

  11. אם קיים הפרש של פקודה אחת בין הפקודות שיש בינן RAW Data Hazard אז הפקודה שכותבת לרגיסטר Rx נמצאת בשלב ה- WB כאשר הפקודה שקוראת מרגיסטר Rx נמצאת בשלב EX (לאחר שכבר קראה את הערך הישן של RX). הפתרון למקרה זה הוא העברת התוכן החדש של רגיסטר RX משלב ה- WB לשלב ה- EX לכניסה המתאימה של ה- ALU, כלומר נבצע forwarding משלב ה- WB לשלב ה- EX. מקרה זה כולל מצב בו קיים הפרש של פקודה אחת בין פקודת LOAD ופקודה אחרת ,שיש בינה לבין פקודת ה- LOADRAW Data Hazard. • פתרונות ל- Data Hazards (5) 234267 - November 2005

  12. 0 m u x ID/EX 1 IF/ID WB M EX ALU Zero Instruction Memory result 0 m u x Read Address 1 EX/MEM MEM/WB WB WB M Data Memory Read reg 1 Read data 1 Read reg 2 Write Address Register File Read data 2 Instruction Read Data Write reg Read Address Write data Write Data 32 Independent instruction ADD $1 $2 $3 ADD $4 $1 $5 ADD $4 $1 $5 LW $1 100($4) Rd\Rt Independent instruction Rd\Rt 234267 - November 2005

  13. תמיד נבצע את ה- forwarding מהפקודה האחרונה שכתבה לרגיסטר (ולכן במקרה ששתי הפקודות הקודמות כתבו לרגיסטר אותו צריך לקרוא, נבצע forwarding משלב ה- MEM ולא משלב ה- WB. זיהוי ומניעת RAW Data Hazard מתבצע ע"י forwarding unit אשר מקבלת את הנתונים הנדרשים לזיהוי RAW Data Hazard מהפקודה שבשלב ה- EX ומפקודות בשלבי WB ו-MEM. ה- forwarding unit מבצעת פיקוד על שני MUX -ים בכניסות המידע של ה- ALU. ע"מ לזהות אם קיים RAW Data Hazard בין פקודה בשלב MEM או WB לבין הפקודה בשלב EX, ה- forwarding unit חייבת לקבל את הנתונים הבאים: מהפקודה בשלבי MEM\WB: האם הפקודה כותבת בסוף ל- RF(RegWrite = 1) ולאיזה רגיסטר. מהפקודה בשלב ה- EX: מספרי רגיסטרי המקור של הפקודה. • פתרונות ל- Data Hazards (6) 234267 - November 2005

  14. ID/EX IF/ID WB M EX m u x m u x ALU Zero Instruction Memory result 0 m u x Read Address 1 Forwarding unit EX/MEM MEM/WB WB WB M Read data 1 Data Memory Read reg 1 Read reg 2 Write Address Register File Instruction Read Data Write reg Read Address Read data 2 Write data Write Data 32 234267 - November 2005

  15. שימו לב לכך שלא חובה לבדוק אם Rt משמש את הפקודה כרגיסטר מקור או תוצאה מהסיבה הבאה: נניח שלמרות ש- Rt משמש את הפקודה הנוכחית בשלב EX לכתיבה ולא לקריאה, ה- forwarding unit תבצע בדיקה שלו מול רגיסטרי התוצאה של פקודות בשלב MEM ו- WB. נניח גם שאכן מתקיים שוויון בין מספר Rt של הפקודה בשלב EX לבין רגיסטר תוצאה של אחת הפקודות בשלב MEM או WB (או שתיהן יחד, זה לא משנה). במקרה זה ה- forwarding unit תבצע העברה של תוכן הרגיסטר החדש מהשלב המתאים דרך ה- MUX הבוחר בין תוכן הרגיסטר הנקרא בשלב ID לבין הערכים משלב WB או MEM. עפ"י השרטוט המפורט יותר בעמוד הבא, אפשר לראות שלאחר מכן נמצא MUX הבוחר בין Rt לבין Imm, ולכן אם הפקודה לא משתמשת ב- Rt לא Rt יעבור את ה- MUX הזה אלא Imm. לכן העברת הערך של Rt שהתבצעה ע"י ה- forwarding unit לא תשפיע על מה שבאמת ייכנס בכניסה התחתונה של ה- ALU. • פתרונות ל- Data Hazards (5) 234267 - November 2005

  16. 0 0 0 m u x m u x m u x ID/EX IF/ID 1 1 1 WB M + EX Control + 4 Shift left 2 ALU Zero result 0 m u x PC 1 6 Sign extend ALU Control 16 32 Rd\Rt Rd\Rt PCSrc EX/MEM RegWrite MEM/WB WB WB M MemWrite Branch MemRead RegWrite ALUSrc RegDst ALUop Read data 1 Data Memory Read reg 1 m u x MemtoReg Read reg 2 Write Address Instruction Memory Register File Instruction Read Data Write reg Read data 2 Read Address Read Address m u x Write data Write Data [15-0] [20-16] [15-11] RegDst Forwarding unit

  17. EX • נסתכל על התכנית הבאה: • SUB $2 $1 $3 • AND $4 $2 $5 • OR $8 $2 $6 • LW $9 1000($4) • <Any independent command> • SLT $1 $6 $9 • דוגמא בין פקודה מס' 1 לפקודה מס' 2 נוצר RAW Data Hazard. נבצע forwarding משלב ה- MEM לשלב ה- EX כלומר נעביר את הערך המעודכן של רגיסטר R2 משלב ה-MEM של פקודה מספר 1 לכניסה העליונה של ה ALU בשלב ה EX של פקודה מס' 2. 234267 - November 2005

  18. ID/EX IF/ID WB M EX m u x m u x ALU Zero Instruction Memory result 0 m u x Read Address 1 Forwarding unit EX/MEM MEM/WB WB WB M Read data 1 Data Memory Read reg 1 Read reg 2 Write Address Register File Instruction Read Data Write reg Read Address Read data 2 Write data Write Data New $2 32 Writes to $2 $2 needed as 1st arg LW $9 1000($4) OR $8 $2 $6 AND $4 $2 $5 SUB $2 $1 $3

  19. EX • SUB $2 $1 $3 • AND $4 $2 $5 • OR $8 $2 $6 • LW $9 1000($4) • <Any independent command> • SLT $1 $6 $9 • דוגמא (2) בין פקודה מס' 1 לפקודה מס' 3 נוצר RAW Data Hazard. נבצע forwarding משלב ה- WB לשלב ה- EX כלומר נעביר את הערך המעודכן של רגיסטר R2 משלב ה- WB של פקודה מספר 1 לכניסה העליונה של ה ALU בשלב ה EX של פקודה מס' 3. 234267 - November 2005

  20. ID/EX IF/ID WB M EX m u x m u x ALU Zero Instruction Memory result 0 m u x Read Address 1 New $4 New $2 Forwarding unit EX/MEM MEM/WB WB WB M Read data 1 Data Memory Read reg 1 Read reg 2 Write Address Register File Instruction Read Data Write reg Read Address Read data 2 Write data Write Data 32 Writes to $4 Writes to $2 $2 needed as 1st arg Instruction LW $9 1000($4) OR $8 $2 $6 SUB $2 $1 $3 AND $4 $2 $5

  21. EX • SUB $2 $1 $3 • AND $4 $2 $5 • OR $8 $2 $6 • LW $9 1000($4) • <Any independent command> • SLT $1 $6 $9 • דוגמא (3) בין פקודה מס' 2 לפקודה מס' 4 נוצר RAW Data Hazard. נבצע forwarding משלב ה- WB לשלב ה- EX כלומר נעביר את הערך המעודכן של רגיסטר R4 משלב ה- WB של פקודה מספר 2 לכניסה העליונה של ה ALU בשלב ה EX של פקודה מס' 4. 234267 - November 2005

  22. ID/EX IF/ID WB M EX m u x m u x ALU Zero Instruction Memory result 0 m u x Read Address 1 New $8 New $4 Forwarding unit EX/MEM MEM/WB WB WB M Read data 1 Data Memory Read reg 1 Read reg 2 Write Address Register File Instruction Read Data Write reg Read Address Read data 2 Write data Write Data 32 Writes to $8 Writes to $4 $4 needed as 1st arg SLT $1 $6 $9 OR $8 $2 $6 AND $4 $2 $5 Instruction LW $9 1000($4)

  23. EX • SUB $2 $1 $3 • AND $4 $2 $5 • OR $8 $2 $6 • LW $9 1000($4) • <Any independent command> • SLT $1 $6 $9 • דוגמא (4) בין פקודה מס' 4 לפקודה מס' 6 נוצר RAW Data Hazard. נבצע forwarding משלב ה- WB לשלב ה- EX כלומר נעביר את הערך המעודכן של רגיסטר R9 משלב ה- WB של פקודה מספר 4 לכניסה התחתונה של ה ALU בשלב ה EX של פקודה מס' 6. המקרה המתואר בדוגמא הוא מקרה בו קיים הפרש של פקודה אחת בין פקודת LW לבין פקודה שצריכה את הערך שברגיסטר שאליו טוענת פקודת LW. 234267 - November 2005

  24. ID/EX IF/ID WB M EX m u x m u x ALU Zero Instruction Memory result 0 m u x Read Address 1 New $9 Forwarding unit EX/MEM MEM/WB WB WB M Read data 1 Data Memory Read reg 1 Read reg 2 Write Address Register File Instruction Read Data Write reg Read Address Read data 2 Write data Write Data 32 Writes to $9 $9 needed as 2nd arg Instruction LW $9 1000($4) SLT $1 $6 $9

  25. EX • LW $9, 1000($4) • SLT $1 $6 $9 • המצב היותר בעייתי הוא כאשר אין מרווח בין פקודת ה- LOAD לפקודה הבאה אחריה כעת נוצר מצב בו פקודת ה- LOAD צמודה לפקודה הצורכת את הרגיסטר שה- LW טוענת לתוכו (R9). במקרה זה הערך החדש של R9 מוכן רק בסוף שלב MEM של LW שזה גם סוף שלב EX של הפקודה שצריכה את הערך הזה (במקרה שלנו – SLT). זה המקרה היחיד בו לא נוכל לבצע forwarding של הערך המחושב וחייבים לעקב את ה- pipeline ע"י ביצוע stall. 234267 - November 2005

  26. בשביל לטפל במקרה הזה קיימת יחידת ה- HDU (Hazard Detection Unit). יחידה זו מבצעת stall בשלב ה- ID (לפקודת ה- SLT) ובכך מאפשרת לבצע forwarding משלב ה- WB לשלב ה- EX. • ע"מ לזהות אם יש צורך ב-stall ה- HDU צריכה לזהות את הדברים הבאים: • האם הפקודה שבשלב ה- EX היא אכן פקודת LW. אות הבקרה MemToReg מציין האם זאת פקודת LW. • האם קיים RAW בין Rt של LW לבין אחד מרגיסטרי המקור של הפקודה בשלב ה- ID (שימו לב שכאן מוטב לזהות בוודאות האם הפקודה בשלב ID משתמשת ב- Rt כרגיסטר מקור או כרגיסטר תוצאה! – למה?) 234267 - November 2005

  27. יחידת ה-HDU שולטת ברגיסטר PC, בבריח (latch) IF/ID וב-MUX בעזרתו ניתן לאפס את אותות הבקרה. • במקרה וה-HDU זיהתה את ה-RAW בין LW לבין הפקודה שאחריה היא מבצעת את הדברים הבאים: • stall ל-PC ולבריח IF/ID כך שתוכנם לא ישתנה במחזור השעון הבא. • נטרול הפקודה שבשלב ID כך שהיא לא תשפיע על מצב המעבד ולא תכתוב לזיכרון ול-RF. הנטרול מבוצע ע"י איפוס קווי הבקרה. פקודה עם קווי בקרה אפס הופכת להיות "בועה" (bubble). • רק במחזור השעון הבא תשתחרר הפקודה האמיתית משלב ה-ID. 234267 - November 2005

  28. Stall PC and IF/ID latch EX instruction write register Is EX Instruction LOAD? Make ID instruction a bubble ID instruction’s source regs HDU 0 m u x ID/EX 1 0 m u x WB IF/ID M EX Control + 4 m u x m u x ALU Zero Instruction Memory result 0 m u x Read Address PC 1 Forwarding unit EX/MEM MEM/WB RegWrite WB WB M Read data 1 Data Memory Read reg 1 Read reg 2 Write Address Register File Instruction Read Data Write reg Read Address Read data 2 Write data Write Data 32 234267 - November 2005

  29. HDU 0 m u x ID/EX 1 0 m u x WB IF/ID M EX Control + 4 m u x m u x ALU Zero Instruction Memory result 0 m u x Read Address PC 1 Forwarding unit EX/MEM MEM/WB RegWrite WB WB M Read data 1 Data Memory Read reg 1 Read reg 2 Write Address Register File Instruction Read Data Write reg Read Address Read data 2 Write data Write Data 32 SLT $1 $6 $9 LW $9, 1000($4) NEXT OP SLT $1 $6 $9 LW $9, 1000($4) ( SLT $1 $6 $9 ) NEXT OP SLT $1 $6 $9 LW $9, 1000($4) ( SLT $1 $6 $9 ) LW $9, … NEXT OP SLT $1 $6 $9 234267 - November 2005

  30. תלויות מידע נוספות כל ה Data Hazard-שדברנו עליהם עד עכשיו היו מסוג (RAW) Read After Write . קיימים 3 סוגים שונים של Data Hazards: RAW ­ Read After Write WAW ­ Write After Write WAR ­ Write After Read במערכות In Order(מעבד שמבצע פקודות רק בסדר הופעתן בקוד) יכולים לקרות Data Hazard מסוג RAW בלבד. MIPSהיא מערכת In Order ולכן מעבד MIPS לא מושפע מ Data Hazards-מסוגים אחרים. Data Hazards מסוג WAW אוWAR עלולים להיות בעיה רק במערכות Out Of Order. 234267 - November 2005

  31. דוגמא של WAW (Write after Write) Data Hazard • DIV $1 $2 $3 • ADD $4 $1 $5 • ADD $4 $7 $9 • פקודת DIV לוקחת הרבה זמן, ולכן פקודת ADD ראשונה מתעכבת ולא יכולה להמשיך (למה?) • במערכת OOOE המעבד יבצע את פקודת ה-ADD השנייה לפני פקודת ה-ADD הראשונה (המתעכבת עד לחישוב תוצאת R1). מה שעלול לקרות אז הוא שהתוכן הסופי של R4 אחרי שלושת הפקודות הוא זה שהיה אמור להיות אחרי הפקודה השנייה ולא אחרי הפקודה השלישית. • זהו WAW Data Hazard. 234267 - November 2005

  32. דוגמא של WAR (Write after Read) Data Hazard • DIV $1 $2 $3 • ADD $4 $1 $5 • ADD $5 $7 $9 • כמו בדוגמא הקודמת, פקודה 1 האיטית גורמת לעיכוב פקודה 2, פקודה 3 הבלתי תלויה מתבצעת וכותבת ערך ל- R5, צריך לדאוג שפקודה 2 שמשתמשת ב- R5 תקבל את ערכו לפני העדכון של פקודה מספר 3. • במערכות OOOE צריך לדאוג לטפל ב-Data Hazards אלו. 234267 - November 2005

  33. backups 234267 - November 2005

  34. 0 0 0 m u x m u x m u x ID/EX 1 1 1 IF/ID WB M + EX Control + 4 Shift left 2 ALU Zero Instruction Memory result 0 m u x Read Address PC 1 6 Sign extend ALU Control 32 16 PCSrc EX/MEM RegWrite MEM/WB WB WB M MemWrite Branch MemRead RegWrite RegDst ALUSrc ALUop Data Memory Read reg 1 MemtoReg Read data 1 Read reg 2 Write Address Register File Read data 2 Instruction Read Data Write reg Read Address Write data Write Data 32 [15-0] [20-16] Rd\Rt Rd\Rt [15-11] RegDst 234267 - November 2005

  35. ID/EX IF/ID WB M EX ALU Zero Instruction Memory result 0 m u x Read Address 1 EX/MEM MEM/WB WB WB M Data Memory Read reg 1 Read data 1 Read reg 2 Write Address Register File Read data 2 Instruction Read Data Write reg Read Address Write data Write Data 32 Rd\Rt Rd\Rt 234267 - November 2005

  36. ID/EX IF/ID WB M EX m u x m u x ALU Zero Instruction Memory result 0 m u x Read Address 1 Forwarding unit EX/MEM MEM/WB WB WB M Read data 1 Data Memory Read reg 1 Read reg 2 Write Address Register File Instruction Read Data Write reg Read Address Read data 2 Write data Write Data 32 234267 - November 2005

  37. EX instruction write register ID instruction’s source regs Is EX Instruction LOAD? Stall PC and IF/ID latch Make ID instruction a bubble HDU 0 m u x ID/EX 1 m u x m u x m u x IF/ID WB M EX Control + 4 m u x m u x ALU Zero Instruction Memory result 0 m u x Read Address PC 1 Forwarding unit EX/MEM 0 MEM/WB RegWrite 0 WB WB M 0 Read data 1 Data Memory Read reg 1 Read reg 2 Write Address Register File Instruction Read Data Write reg Read Address Read data 2 Write data Write Data 32 234267 - November 2005

  38. 0 0 0 m u x m u x m u x ID/EX IF/ID 1 1 1 WB M + EX Control + 4 Shift left 2 ALU Zero result 0 m u x PC 1 6 Sign extend ALU Control 16 32 Rd\Rt Rd\Rt PCSrc EX/MEM RegWrite MEM/WB WB WB M MemWrite Branch MemRead RegWrite ALUSrc RegDst ALUop Read data 1 Data Memory Read reg 1 m u x MemtoReg Read reg 2 Write Address Instruction Memory Register File Instruction Read Data Write reg Read data 2 Read Address Read Address m u x Write data Write Data [15-0] [20-16] [15-11] RegDst Forwarding unit

  39. PCSrc 0 0 0 m u x m u x m u x ID/EX IF/ID EX/MEM RegWrite MEM/WB 1 1 1 WB WB WB M M + EX MemWrite Control MemRead Branch RegWrite + Shift left 2 4 ALUSrc RegDst ALUop Read data 1 Data Memory Read reg 1 MemtoReg m u x ALU Read reg 2 Write Address Zero Instruction Memory Register File result Instruction Read Data 0 Write reg Read data 2 Read Address m u x Read Address PC m u x Write data 1 Write Data [15-0] 6 Sign extend ALU Control 32 16 [20-16] Rd\Rt [15-11] Rd\Rt RegDst Forwarding unit

More Related