תרגול מס' 1: מנהלות חזרה על ארכיטקטורת ה- MIPS

מצגת בנושא: "תרגול מס' 1: מנהלות חזרה על ארכיטקטורת ה- MIPS"— תמליל מצגת:

1 תרגול מס' 1: מנהלות חזרה על ארכיטקטורת ה- MIPS
מבנה מחשבים ספרתיים תרגול מס' 1: מנהלות חזרה על ארכיטקטורת ה- MIPS Last update: Mar 1th 2010 234267

2 רגיסטרים (אוגרים) ישנם 32 רגיסטרים לשימוש כללי. רגיסטר R0 ערכו קבוע ושווה 0. כמו כן ישנם 16 רגיסטרים של 64 סיביות עבור פעולות float (0F שמיש) ניתן להשתמש בכל אחד מהם כשני רגיסטרים float של 32 סיביות. R0 = 0 R1 R30 32 R31 F1 F3 F29 F31 F0 F2 F28 F30

3 אופני מיעון ב-MIPS רגיסטר (register): האופרנד מאוחסן ברגיסטר
ADD $2,$3,$4; reg 2  reg3 + reg4 מיידי (Immediate): האופרנד הוא קבוע (מקודד בפקודה) בגודל 16 סיביות עם סימן ADDI $2,$3,15; reg 2  reg3 + 15 בסיס + היסט (Base + Displacement): -האופרנד נמצא בזיכרון הכתובת בזיכרון = ערך שדה ההיסט + הערך שברגיסטר הבסיס LW $2,105($3); reg 2  mem(Reg ) יחסי למונה התוכנית (PC-relative): הערך מחושב ע"י חיבור הערך שב-PC לערך שדה ה-immediate (16 סיביות). מיועד אך ורק עבור קפיצות מותנות (branches) BEQ $3,$4,15000; if reg3 == reg4 then PC  PC *15000

4 פקודות MIPS נוספות גישה לזיכרון, אכסן (Store) מילה (32 סיביות) לכתובת קבועה) שימו לב ש- reg0 = 0) SW $3,100($0); mem(100+reg0)  reg3 טעינת / העתקת ערך אוגר (אין פקודת MOV מיוחדת): ADDI $4,$0,15; reg4  15 (שימו לב להרחבת הסימן) ADD $4,$8,$0; reg4  reg8 Branch מותנה BEQ $0,$1,Label1; if reg1 == 0 then jump to Label1 השוואת "קטן-מ" (פסאודו פקודה 2L,3$,2$ BLT) SLT $1,$2,$3 if reg2 < reg3 then reg1  1 else reg1  0 BNE $0,$1,L2 if reg0 != reg1 then jump to L2 (מאחר ו-reg0=0 צמד הפקודות יגרום לקפיצה אם reg2<reg3 אחרת המשך כרגיל) קפיצה בלתי מותנית (מיעון מוחלט) J 10000 קפיצה עקיפה (מיעון לפי ערך האוגר) JR $31

5 קידוד הפקודות כל הפקודות בנות 32 סיביות – כלומר 4 בתים
כל סוג מגדיר את החלוקה הפנימית בתוך אותן 32 סיביות: ישנם שלושה סוגי פקודות: R-type - register instructions I-type - immediate J-type - jumps (unconditional) שדה ה-op (opcode) קבוע בגודלו ונמצא תמיד. הוא חיוני כדי לדעת מהו סוג הפקודה וכיצד לבצע את החלוקה הפנימית השונה בין פורמט לפורמט

6 קידוד הפקודות בפקודות מסוג R
שדה ה-op תמיד שווה 0 ואילו שדה ה-func אומר מהי הפקודה שדות ה-rs וה-rt עבור רגיסטר המקור, ושדה ה-rd עבור רגיסטר המטרה. שדה ה-shamt (shift amount) מיועד לפקודה הזזת סיביות (SLL,SRL,SRA) בלבד Opcode = 0 Rs Rt Rd Shift amount func 6bit 5bit

7 קידוד הפקודות בפקודות מסוג I
בפקודות load ופקודות עם שדה imm שדה ה-rs עבור רגיסטר הבסיס ושדה ה-rt עבור רגיסטר המטרה בפקודות store שדה ה- rs עבור רגיסטר הבסיס ושדה ה-rt מכיל את הערך לאחסון בזיכרון בפקודות branch, rs ו-rt עבור רגיסטרי המקור והקבוע מקודד את כתובת הקפיצה ביחס ל-PC Opcode Rs Load: Base Store: Base Rt Load:Target Store: data Address \ Immediate 6bit 5bit 16 bit

8 קידוד הפקודות בפקודות מסוג J
קופצים אל הכתובת המתחילה משמאל ב-4 סיביות מה-PC (ה-segment בזיכרון) שלאחריהן 26 הסיביות שבשדה ה-address ו-2 סיביות אחרונות מימין שהן תמיד 00מאחר וכל הפקודות נמצאות בכתובות המתחלקות ב-4. Opcode כתובת קפיצה 6bit 26 bit Current PC 00 + 0000 Target (26 bits) 00 31 28 27 2 1 Target address 00

9 קונפיגורציות של ה-MIPS
Single Cycle כל פקודה מבוצעת במחזור שעון יחיד בעל זמן מחזור ארוך מאוד Multicycle חלוקת הפקודות למספר שלבים ועבור כל פקודה לבצע בכל שלב חלק מהפעולות. רוב הפקודות עדיין משתמשות ב-4 מחזורי שעון לפחות (קצרים יותר). אין שיפור משמעותי Pipeline מחלקים את ה- datapath הסדרתי לשלבים כאשר פקודה מסוימת מסיימת את השלב הראשון ועוברת לשלב השני, פקודה חדשה נכנסת לשלב הראשון וכן הלאה מתקבל מצב בו בכל מחזור שעון כל פקודה מתקדמת בשלב אחד. כלומר, בכל מחזור מסתיימת פקודה אחת ופקודה חדשה נכנסת לביצוע.

10 השלבים הבסיסיים בביצוע פקודות
כל פקודה (למעט נקודה צפה) ניתנת לחלוקה ל-5 שלבים בסיסיים: 1. Fetch שליפת הפקודה לביצוע מהזיכרון קידום מונה התוכנית לפקודה הבאה לביצוע. אכסון הפקודה ברגיסטר זמני (IR)

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

12 השלבים הבסיסיים בביצוע פקודות
2. Decode פענוח הפקודה ויצירת את אותות הבקרה שילוו את הפקודה בהמשך שליפת ערכי הרגיסטרים המתאימים מתוך Register File Sign Extension: הרחבה של האופרנד המקודד מ-16 סיביות ל-32 סיביות

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

14 השלבים הבסיסיים בביצוע פקודות
3. Execute ביצוע הפעולה הנדרשת על בסיס הערכים בערוצי המידע: עבור פעולת ALU – ביצוע הפעולה הנדרשת עבור גישה לזיכרון – חישוב הכתובת האפקטיבי עבור הסתעפות (branch) – חישוב כתובת היעד וחישוב תנאי הקפיצה מבצעים את החישוב על 2 האופרנדים מהרגיסטרים הנכנסים ל-ALU הראשי אשר מבצע פעולת חיסור אם התוצאה היא 0 נדלק דגל ZERO וכך ידוע האם יש לקפוץ (BEQ) חישוב כתובת היעד של הקפיצה חישוב כתובת היעד: ה-offset של הקפיצה מקודד במילים ולא בבתים. מאחר וכל הפקודות הן aligned מבצעים Shift left 2 (למעשה מכפילים את הכתובת פי 4) ואז מוסיפים את ה- PC(של הפקודה הבאה) ומקבלים את כתובת הקפיצה.

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

16 השלבים הבסיסיים בביצוע פקודות
3. Memory קריאה / כתיבה לזיכרון בפקודות Store / Load החלטה האם לקפוץ בפקודות branch (עדכון PC) שימו לב - Control Hazard בכל שלב נכנסות פקודות חדשות ל- pipeline. עד שהבנו שצריך לקפוץ, אולי נכנסו פקודות שכלל אינן צריכות להתבצע 4. Write back: אכסון התוצאה (מ-ALU או מהזיכרון) לרגיסטר היעד. שאלה: איך יודעים האם צריך לקפוץ? תשובה: מבצעים AND על בדיקת קיום של שני דברים: שמדובר בפקודת branch, ושהתנאי לקפיצה מתקיים. רק אם שני הדברים הללו מתקיימים- מתבצעת קפיצה (ע"י עדכון ה- pc). איזה hazards נוספים ישנם?

17 MEMory \ WriteBack + + IF/ID ID/EX EX/MEM MEM/WB 4 Data Memory ALU PC
PCSrc m u x 1 IF/ID ID/EX WB EX M EX/MEM MEM/WB RegWrite Control WB WB M Shift left 2 + 4 + RegWrite Branch MemWrite MemRead NewPC NewPC RegDst ALUop ALUSrc Read reg 1 Data Memory ALU result Zero MemtoReg Read data 1 Read reg 2 Instruction Memory Read Address m u x 1 Write Address PC Register File Read data 2 Write reg Read Data m u x 1 Instruction Read Address Write data Write Data Sign extend 32 ALU Control [15-0] להראות גם את ה- latches בין השלבים הערה: ב-MIPS pipeline ה-CPI הוא 1 (אידיאלי כשאין stalls) ובפועל קצת יותר מזה. שאלה: מה ה- CPI ב- single cycle , multy cycle? תשובה: אחד ב- single cycle (כשמו כן הוא – מחזור אחד ארוך לכל פקודה), ב- multi cycle כ- 4 בקרוב (המספר המדויק נעוץ בתוחלת מספר המחזורים שנדרשים לפעולה. התוחלת תלויה בהתפלגות הפקודות שתלויה ב- benchmark) שאלה: למה למרות ה- CPI ה-single cycle פחות יעיל מ pipeline ומ- multy cycle? הפרמטר החשוב בפועל הוא instructions per second לא cycles per instruction ולא cycles per second (MHz). ב- multi cycle זמן המחזור קצר יותר (נניח כרבע מזמן המחזור ב- single cycle), וחלק מהפעולות מבוצעות בפחות מארבעה מחזורים – בממוצע פקודה לוקחת פחות זמן ולכן IPS גדול יותר. ב- single cycle זמן המחזור הוא ארוך מאוד (כאורך הפעולה הקשה ביותר לחישוב) ולכן מקטין את ה IPS. 6 Imm ALUresult 16 32 [20-16] Rt m u x 1 Rd\Rt Rd\Rt Rd [15-11] RegDst

18 אותות הבקרה Signal Name Effect when 0 Effect when 1
MemRead None. Data Memory contents at the read address are put on read data output. MemWrite Data memory contents at address given by write address are replaced by value on write data input ALUSrc The second ALU operand comes from the second register file output. The second ALU operand is the sign-extended lower 16 bits of the instruction. RegDst The register destination for the register write comes from the rt field. The register destination number for the register write comes from the rd field. RegWrite The register given by write register number input is written into with the value on the write data input. PCSrc (== Branch & cond) The PC is replaced by the output of adder that computes the value of PC+4. The PC is replaced by the output of the adder that computes the branch target. MemtoReg The value fed to the register write data input comes from the ALU. The value fed to the register write data input comes from the data memory. בשני השלבים הראשונים (IF ו-ID) עדיין אין אותות בקרה (טרם בוצע parsing לפקודה). ה-latches בין כל שלב ושלב כוללים את כל המידע שנוצר בשלבים הקודמים והרלוונטי לשלבים הבאים (כולל אותות בקרה). בשלב ה-Execute RegDst – אות בקרה האומר באילו סיביות בפקודה מקודד מספר הרגיסטר שאליו נכתוב בשלב WB (סיביות – בפקודה מסוג R או סיביות – בפקודה מסוג I ( אומר אם רגיסטר המטרה הוא rt או rd. ALUSrc – האם האופרנד השני לפעולת ה-ALU מגיע מ RF או מיחידת הרחבת הסימן. שאלה: מאיפה מגיע האופרנד הראשון? ALU control, ALUop – האם ברור לך תפקידם? בשלב ה-Memory MemRead – מציין שיש לקרוא כעת מהזיכרון (פקודת load). MemWrite – מציין שיש לכתוב כעת לזיכרון (פקודה store). Branch – אות בקרה שמסמן האם הפקודה הייתה פקודת branch ונכנס יחד עם תוצאת ההשוואה לשער ה-and הקובע ל-PC האם לקפוץ או להמשיך בביצוע כרגיל. בשלב ה-Write back MemtoReg – אות בקרה האומר האם יש לכתוב ל-Regfile את תוצאת פעולת ה-ALU או את הערך מהזיכרון. RegWrite – אות בקרה האומר שיש לכתוב תוצאה לתוך רגיסטר ב-Regfile.

19 אותות הבקרה + + IF/ID ID/EX EX/MEM MEM/WB 4 Data Memory ALU
PCSrc m u x 1 IF/ID ID/EX WB EX M EX/MEM MEM/WB RegWrite Control WB WB M Shift left 2 + 4 + RegWrite Branch MemWrite MemRead NewPC NewPC RegDst ALUop ALUSrc Read reg 1 Data Memory ALU result Zero MemtoReg Read data 1 Read reg 2 Instruction Memory Read Address Register File m u x 1 Write Address PC Read data 2 Write reg Read Data m u x 1 Read Address Instruction Write data Write Data Sign extend [15-0] 32 ALU Control 6 Imm ALUresult 16 32 [20-16] Rt m u x 1 Rd\Rt Rd\Rt [15-11] Rd RegDst

20 Instruction operation
ALU control, ALUop func Instruction opcode ALUop Instruction operation Function code Desired ALU action ALU control input LW 00 load word - add 010 SW store word BEQ 01 branch equal subtract 110 ADD 10 100000 SUB 100010 AND 100100 and 000 OR 100101 or 001 SLT set-on-less-than 101010 111

21 דוגמאות לערכי control lines עבור פקודות שונות:
WriteBack Memory Execution stage Memto Reg Reg Write Mem Write Mem Read Branch PCsrc ALU control ALU src ALU op0 ALU op1 RegDst פקודה 1 010 add X 1/0 110 beq דוגמא לקידוד offset של פקודת branch שאלה: אנו נמצאים בכתובת 700 (כתובת פקודת ה-branch) ורוצים לקפוץ לכתובת 800. מה עלינו לקודד? Displacement = 800 – 704 = 96 bytes 96 / 4 = 24 instructions  24 תשובה: הפקודה הבאה לביצוע נמצאת בכתובת = 704 , ולכן צריך לקפוץ רק 96 בתים. את 96 הבתים מחלקים ב- 4, כי מקודדים אופסט במילים. לכן נקודד קפיצה בגודל 24 (=96/4). הצעה מתודית מה לעשות עם הטבלה?

22 תחביר הפקודה addconst R1,R2,const והפעולה המתבצעת היא R1=R2+const
שאלה: ברצוננו להוסיף פקודה בשם addconst לסט הפקודות של ה- MIPS. הפקודה תבצע חיבור של רגיסטר לקבוע חסר סימן (unsigned) תחביר הפקודה addconst R1,R2,const והפעולה המתבצעת היא R1=R2+const הקבוע const הינו מספר חיובי בטווח (216-1) - [0 קידוד הפקודה החדשה הוא מסוג: R I J לא ניתן לממש פקודה כזאת במעבד מסוג RISC אף תשובה אינה נכונה במידה וניתן לממש את הפקודה, מה השינוי שנדרש במבנה ה- MIPS ? הפקודה החדשה היא מסוג Immediate. ההבדל מפקודת addi הוא שפקודת addi מקבלת ערכים בטווח של 215 ± השינוי הנדרש: הכפלת ה- sign extend כך שתהיה גם הרחבה ע"י שרשור ערך ה- immediate ל- 16 אפסים הגדלת ה MUX שבורר את הכניסה ל- ALU ל MUX31, מה שמחייב קו בקרה נוסף ל- MUX זה ועל כן שינוי ברכיב ה- control. אין חשיבות איזה מה- 32 bit bus יחובר ל- ALU control שכן הוא קורא רק את 6 הביטים הימניים ביותר אבל לחישוב קפיצות יש צורך ב- sign extended 32bit bus ולכן נחבר את שני הרכיבים הנ"ל ל- bus זה. בנוסף יש לעדכן את ה- הלוגיקה שמשפיעה על alu control input, במקרה זה עדכון נוסף ברכיב ה- control כך שיזהה את ה- opcode החדש.

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

24 אתר הקורס: http://webcourse.cs.technion.ac.il/234267 תרגילי בית:
יינתנו 4 תרגילי בית במהלך הסמסטר 20% תקף (80% בחינה סופית) הגשה בזוגות 5 נקודות יורדו על כל יום איחור ספרי קורס: Hennessy & Patterson - Computer Architecture: A Quantitative Approach. Hennessy & Patterson - Computer Organization and Design: The Hardware/ Software Interface