1 / 40

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

מבנה מחשבים ספרתיים 234267. תרגול מס' 3 : Data Hazards מבוסס על תרגול של מורן גביש Yohai Devir Franck Sala. ADD $1 $2 $3 (R1  R2 + R3) ADD $4 $1 $5 (R4  R1 + R5). ALU. Instruction Memory. Data Hazard. ID. EX. MEM. WB. Register File. Data Memory.

tien
Télécharger la présentation

מבנה מחשבים ספרתיים 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 מבוסס על תרגול של מורן גביש YohaiDevir Franck Sala 234267 - November 2005

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

  3. ALU Zero Instruction Memory result 0 m u x Read Address 1 Data Hazard IF ID EX MEM WB WB 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 Instruction Register File Read data 2 Read Data Write reg Read Address Write data Write Data ADD $1 $2 $3 ADD $4 $1 $5ADD $1 $2 $3 ADD $4 $1 $5ADD $1 $2 $3

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

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

  6. ALU Instruction Memory פתרונות ל- Data Hazards (2):חציית RF) register File) ID EX MEM WB Register File Data Memory • Reduce the cases where we need to stall the pipeline • Use the clock phases • Write the RF at first phase • Read the RF at the second phase • Possible to update the RF and read it in the same pipe stage

  7. ALU Zero Instruction Memory result 0 m u x Read Address 1 חציית register File IF ID EX MEM WB WB Data Memory Read reg 1 Read data 1 Read reg 2 Write Address Instruction Register File Read data 2 Read Data Write reg Read Address Write data Write Data 32 ADD $1 $2 $3 ADD $4 $1 $5 ADD $1 $2 $3 ADD $4 $1 $5 ADD $1 $2 $3 ADD $1 $2 $3 ADD $4 $1 $5 Rd\Rt Rd\Rt ADD $4 $1 $5 ADD $4 $1 $5 ADD $4 $1 $5 ADD $1 $2 $3

  8. ALU Instruction Memory ID EX MEM WB • פתרונות ל- Data Hazards (3) • Forwarding / bypassing Register File Data Memory • ערך רגיסטר המטרה של הפקודה הכותבת ידוע כבר בסוף שלב ה- EX שלה ונכתב ל- רגיסטר (EX\MEM (latch בסוף שלב זה • בסיום שלב ה- MEM ערך זה נכתב לרגיסטר MEM\WB ורק בשלב ה- WB נכתב הערך לרגיסטר המטרה • כלומר, נוכל להשתמש בערך רגיסטר המטרה לפני שערך זה נכתב בפועל לרגיסטר.

  9. ALU Instruction Memory • פתרונות ל- Data Hazards (4) • Forwarding / bypassing ID EX MEM WB B A • הפקודות שיש בינן RAW Data Hazard הן צמודות • הפקודה שכותבת לרגיסטר Rx נמצאת בשלב MEM • הפקודה שקוראת מרגיסטר Rx נמצאת בשלב EX • לאחר שכבר קראה ערך לא נכון של Rx בשלב ID • פתרון: העברת התוכן החדש של רגיסטר Rx משלב MEM (של הפקודה הכותבת) לשלב EX (של הפקודה שמשתמשת בנתון) לכניסה המתאימה של ה- ALU • כלומר נבצע Forwarding משלב MEMלשלב EX Register File Data Memory אם הפקודה הראשונה (הכותבת לרגיסטר) היא פקודת LW, לא נוכל לבצע forwarding משלב ה- MEM לשלב ה- EX כי ערך רגיסטר המטרה ידוע רק בסוף שלב ה- MEM. לא נוכל לפתור בעיה זאת מבלי להשהות את ה- pipeline.

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

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

  12. ALU Instruction Memory • פתרונות ל- Data Hazards (5) • Forwarding / bypassing ID EX MEM WB B A Register File Data Memory • מקרה זה כולל מצב בו קיים הפרש של פקודה אחת בין פקודת LOAD ופקודה אחרת ,שיש בינה לבין פקודת ה- LOADRAW Data Hazard. • קיים הפרש של פקודה אחת בין הפקודות שיש בינן RAW Data Hazard • הפקודה שכותבת לרגיסטר Rx נמצאת בשלב WB • הפקודה שקוראת מרגיסטר Rx נמצאת בשלב EX • לאחר שכבר קראה את הערך הישן של RX • פתרון:העברת התוכן החדש של רגיסטר RXמשלבWB לשלבEXלכניסה המתאימה של ALU • כלומר נבצע forwarding משלב ה- WB לשלב ה- EX.

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

  14. ALU Instruction Memory • פתרונות ל- Data Hazards: • Forwarding Unit ID EX MEM WB • תמיד נבצע את ה- 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: • מספרי רגיסטרי המקור של הפקודה. Register File Data Memory

  15. 0 m u x A 1 2 1 m u x 0 m u x B 0 1 2 0 m u x 1 Forwarding Unit IF ID EX MEM WB WB Control M WB M EX WB EX/MEM.RegWrite MEM/WB.RegWrite Instruction Register File Instruction Memory Data Memory RegDst ALU PC WrData IF/ID.Rs Rs IF/ID.Rt Rt IF/ID.Rt Rt EX/MEM.Rd RegDst Rt/Rd Rt/Rd IF/ID.Rd Rd Forwarding Unit MEM/WB.Rd WrData RegDst

  16. שימו לב לכך שלא חובה לבדוק אם 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 HazardsForwarding Unit : • No need to check if Rt is source or dest • If RT is dest @ EXE  so no need for RT value @ EXE • Check dest @ MEM, WB and forward Rt • Rt forwarded value won’t be used • If RT is src @ EXE • Check dest @ MEM, WB • Rt forwarded value will be used

  17. 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 32 16 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] RegDst [15-11] RegDst Forwarding unit WrData

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

  19. 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 Instruction Read reg 2 Write Address Register File Read Data Write reg Read Address Read data 2 Write data Write Data 32 RegDst = $2 New $2 RegDst $2 needed as 1starg OR $8 $2 $6 AND $4 $2 $5 SUB $2 $1 $3 LW $9 1000($4)

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

  21. ID/EX IF/ID WB M EX m u x m u x ALU Instruction Memory result 0 m u x Read Address 1 New $2 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 RegDst = $4 RegDst = $2 $2 needed as 1starg Instruction LW $9 1000($4) OR $8 $2 $6 AND $4 $2 $5 SUB $2 $1 $3

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

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

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

  25. ID/EX IF/ID WB M EX m u x m u x ALU 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 RegDst RegDst= $9 $9 needed as 2ndarg Instruction SLT $1 $6 $9 LW $9 1000($4)

  26. EX ALU Instruction Memory ID EX MEM WB • המצב היותר בעייתי הוא כאשר אין מרווח בין פקודת ה- LOAD לפקודה הבאה אחריה Register File Data Memory • LW $9, 1000($4) • SLT $1 $6 $9 כעת נוצר מצב בו פקודת ה- LOAD צמודה לפקודה הצורכת את הרגיסטר שה- LW טוענת לתוכו (R9) במקרה זה הערך החדש של R9 מוכן רק בסוף שלב MEM של LW שזה גם סוף שלב EX של הפקודה שצריכה את הערך הזה (במקרה שלנו – SLT). זה המקרה היחיד בו לא נוכל לבצע forwarding של הערך המחושב וחייבים לעקב את ה- pipeline ע"י ביצוע stall.

  27. ALU Instruction Memory HDU: Hazard Detection Unit ID EX MEM WB B A=LW • בשביל לטפל במקרה הזה קיימת יחידת ה- HDU • יחידה זו מבצעת stall בשלב ה- ID (לפקודת ה- SLT) ובכך מאפשרת לבצע forwarding משלב ה- WB לשלב ה- EX. • ע"מ לזהות אם יש צורך ב-stall ה- HDU צריכה לזהות את הדברים הבאים: • האם הפקודה שבשלב ה- EX היא אכן פקודת LW. אות הבקרה MemToReg מציין האם זאת פקודת LW. • האם קיים RAW בין Rt של LW לבין אחד מרגיסטרי המקור של הפקודה בשלב ה- ID • שימו לב שכאן מוטב לזהות בוודאות האם הפקודה בשלב ID משתמשת ב- Rt כרגיסטר מקור או כרגיסטר תוצאה! – למה? Register File Data Memory

  28. ALU Instruction Memory HDU: Hazard Detection Unit ID EX MEM WB B A=LW • יחידת ה-HDUשולטת • ברגיסטר PC • בבריח (latch) IF/ID • ב-MUX בעזרתו ניתן לאפס את אותות הבקרה. • במקרה וה-HDU זיהתה את ה-RAW בין LW לבין הפקודה שאחריה היא מבצעת את הדברים הבאים: • stall ל-PC ולבריח IF/ID • כך שתוכנם לא ישתנה במחזור השעון הבא • נטרול הפקודה שבשלב ID • כך שהיא לא תשפיע על מצב המעבד ולא תכתוב לזיכרון ול-RF. • הנטרול מבוצע ע"י איפוס קווי הבקרה. פקודה עם קווי בקרה אפס הופכת להיות "בועה" (bubble). • רק במחזור השעון הבא תשתחרר הפקודה האמיתית משלב ה-ID. Register File Data Memory

  29. Stall PC and IF/ID latch Make ID instruction a bubble ID instruction’s source regs EX instruction write register Is EX Instruction LOAD? 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 Instruction Memory result 0 m u x Read Address PC 1 Forwarding unit EX/MEM MEM/WB RegWrite WB WB EX.MemRead M Read data 1 Data Memory Read reg 1 Zero Read reg 2 Instruction Write Address Register File Read Data Write reg Read Address Read data 2 Write data Write Data 32 RegDst RegDst

  30. 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 Kill Exe Stall PC Exe Inst = LW EX/MEM MEM/WB RegWrite WB WB SrcReg = $9 M WrReg = $9 Read data 1 Data Memory Read reg 1 Read reg 2 Instruction Write Address Register File 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

  31. תלויות מידע נוספות • כל ה 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.

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

  33. דוגמא של 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. • במערכות OOO צריך לדאוג לטפל ב-Data Hazards אלו.

  34. backups

  35. 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

  36. 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

  37. 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

  38. 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

  39. 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

  40. 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