Transcript MIPS Instructions

‫מבוא למחשב‬
‫• עד כה למדנו תכן לוגי‪:‬‬
‫– הפרדה לבקר ומסלול נתונים‬
‫– ‪Pipelines‬‬
‫– תקשורת‬
‫• ביתרת הקורס נלמד על המחשב כדוגמה אחת מעניינת וחשובה‬
‫– מחשב פשוט‪MIPS :‬‬
‫– ספר‪Patterson & Hennessy, :‬‬
‫‪Computer Organization and Design: The Hardware/Software Interface‬‬
‫• לימוד המחשב עומד בפני עצמו‪ ,‬אבל גם משמש מבוא לקורס‬
‫"מבנה מחשבים ספרתיים"‬
‫– כאן נתמקד על המחשב כדוגמה לתכן לוגי‪ ,‬וכאמצעי לבניית מערכת‬
‫ספרתית מסובכת‬
‫‪1‬‬
‫‪December 2013‬‬
‫מה זה מחשב?‬
‫• לוגיקה מתוכנתת‬
‫• ע"י שינוי הבקר ניתן לבצע בה משימות שונות‬
‫• כיצד משנים בקר?‬
‫– משתמשים בעיקרון של בקר מבוסס ‪( ROM‬זיכרון קריאה‬
‫בלבד)‬
‫– משתמשים ב‪ RAM-‬במקום ב‪ROM-‬‬
‫– מחליפים את תוכן ה‪( RAM-‬כלומר "מתכנתים" אותו)‬
‫‪2‬‬
‫‪December 2013‬‬
‫ממה מורכב המחשב?‬
‫• נהוג לחלק את המחשב לקופסאות‪:‬‬
‫– מעבד‪ ,‬זיכרון‪ ,‬דיסק‪ ,‬מדפסת וכד'‬
‫• החלוקה שלנו‪:‬‬
‫– מסלול נתונים (‪ )Datapath‬הכולל‪:‬‬
‫• לוגיקה צירופית (יחידות עיבוד)‬
‫• רגיסטרים (וגם זיכרון נתונים גדול יותר)‬
‫– בקר מתוכנת‬
‫• כולל זיכרון גדול ל"פקודות"‬
‫• בנוסף‪ ,‬צריך גם‪:‬‬
‫– תכנית המפעילה את הבקר‬
‫– קומפילציה (הידור)‪ :‬המרה מתכנית בשפה עילית (‪ )C‬ל"שפת המכונה"‬
‫‪3‬‬
‫‪December 2013‬‬
‫מסלול נתונים כללי‬
‫• נשתמש במסלול נתונים שיתאים לכל פעולה שנרצה‬
‫לבצע‬
‫‪OPERATION‬‬
‫• נקבע שכל "מילה"‬
‫היא ‪ 32‬סיביות (‪ 4‬בתים)‬
‫‪ALU‬‬
‫‪32‬‬
‫‪32‬‬
‫‪32‬‬
‫‪REGISTERS‬‬
‫‪INPUT‬‬
‫‪4‬‬
‫‪OUTPUT‬‬
‫‪December 2013‬‬
‫מסלול נתונים כללי שני‬
‫•‬
‫למען הפשטות‪ ,‬היעילות והמהירות מחלקים את הזיכרון לשניים‪:‬‬
‫– ‪ Register File‬קטן (‪ 32‬רגיסטרים) ומהיר‬
‫– זיכרון נתונים גדול‪ ,‬איטי יותר‬
‫•‬
‫ה‪ ALU-‬מוזן מהרגיסטרים בלבד‬
‫– ניתן להעביר נתונים מהזיכרון לרגיסטר – ‪LOAD‬‬
‫– ניתן להעביר נתונים מרגיסטר לזיכרון ‪STORE -‬‬
‫‪ALU‬‬
‫‪Data‬‬
‫‪Register #‬‬
‫‪Address‬‬
‫‪REGISTER FILE‬‬
‫‪CONTROLLER‬‬
‫‪Register #‬‬
‫‪DATA MEMORY‬‬
‫‪Register #‬‬
‫‪Data‬‬
‫‪5‬‬
‫‪December 2013‬‬
‫) פשוט‬FSM( ‫בקר‬
Outputs
Outputs
ROM / RAM
Combinational logic
Next state
Next state
State register
Inputs
December 2013
State register
Inputs
6
‫מה בתוכנית?‬
‫• מבנה מסלול הנתונים במחשב‬
‫– מסלול פשוט – מחזור שעון יחיד לכל פעולה‬
‫– מסלול חכם – מספר מחזורים משתנה לכל פעולה‬
‫– מסלול חכם יותר – עם ‪pipeline‬‬
‫• קבוצת הפקודות במחשב (תוכן הבקר)‬
‫– תכנות באסמבלר‬
‫– כיצד מתורגמת תכנית ב‪ C-‬לתכנית בשפת מכונה‬
‫• בקרים חכמים יותר‬
‫‪7‬‬
‫‪December 2013‬‬
‫פקודות מכונה של ‪MIPS‬‬
‫• בשיעורי תרגול נלמד (חומר של פרק ‪ 4‬בספר ‪:)PH‬‬
‫– פקודות מכונה של ‪MIPS‬‬
‫– איך תכנה בשפת ‪ C‬מתורגמת לפקודות מכונה‬
‫– איך לתכנת בשפת המכונה‬
‫– איך לבצע סימולציה (הרצה) של תכניות בשפת המכונה‬
‫– כיצד נראות הפקודות כאשר הן מגיעות אל הבקר‬
‫• בהרצאות נלמד‪:‬‬
‫– איך בנוי ופועל מסלול הנתונים במחשב (ומדוע)‬
‫– איך בנוי ופועל הבקר במחשב (ומדוע)‬
‫• בכדי לגשר בין הנושאים‪ ,‬נתחיל בסקירה קצרה של הפקודות‬
‫‪8‬‬
‫‪December 2013‬‬
‫פקודות המכונה‬
‫• משפט בשפת ‪:C‬‬
‫‪a=b+c‬‬
‫• מתורגם ע"י קומפיילר לפקודת אסמבלי‪:‬‬
‫‪add $s1,$s2,$s3‬‬
‫– ‪ $s1,$s2,$s3‬הם רגיסטרים‬
‫– הפקודה צריכה לבצע‬
‫>‪$s1 <$s2> + <$s3‬‬
‫– בדרך כלל נשמיט את הסימון < > שמשמעותו "התוכן של ‪"...‬‬
‫– מתורגם ע"י אסמבלר לפקודת מכונה (מספר בן ‪ 32‬סיביות)‬
‫• במחשב יהיו ‪ 32‬רגיסטרים מהירים‪ ,‬כל שאר הנתונים יהיו‬
‫בזיכרון נתונים גדול (ואיטי)‬
‫• כל הפעולות האריתמטיות תתבצענה רק בין רגיסטרים‬
‫• למרבית הרגיסטרים שימוש ידוע ושמות משמעותיים‪:‬‬
‫‪9‬‬
‫‪December 2013‬‬
‫שמות הרגיסטרים‬
‫שם‬
‫‪10‬‬
‫שימוש‬
‫מספר‬
‫‪$zero‬‬
‫‪0‬‬
‫קבוע ‪0‬‬
‫‪$at‬‬
‫‪1‬‬
‫שמור לאסמבלר‬
‫‪$v0-$v1‬‬
‫‪2-3‬‬
‫תוצאות חישובים‬
‫‪$a0-$a3‬‬
‫‪4-7‬‬
‫ארגומנטים מועברים לסברוטינות‬
‫‪$t0-$t7‬‬
‫‪8-15‬‬
‫משתנים זמניים‬
‫‪$s0-$s7‬‬
‫‪16-23‬‬
‫משתני שפת התכנות העלית‬
‫‪$t8-$t9‬‬
‫‪24-25‬‬
‫משתנים זמניים‬
‫‪$k0-$k1‬‬
‫‪26-27‬‬
‫שמור למערכת ההפעלה‬
‫‪$gp‬‬
‫‪28‬‬
‫‪Global Pointer‬‬
‫‪$sp‬‬
‫‪29‬‬
‫‪Stack Pointer‬‬
‫‪$fp‬‬
‫‪30‬‬
‫‪ - Frame Pointer‬תיחום אזור משתני סברוטינה‬
‫‪$ra‬‬
‫‪31‬‬
‫‪ - Return Address‬כתובת חזרה מסברוטינה‬
‫‪December 2013‬‬
‫כיצד מיוצגת הפקודה במחשב?‬
‫• דוגמה‪:‬‬
‫‪add $t0,$s1,$s2‬‬
‫• צורה כללית‪:‬‬
‫‪rd=rs+rt : add rd,rs,rt‬‬
‫• יצוג במחשב כמספר בן ‪ 32‬סיביות לפי פורמט קבוע‪:‬‬
‫– ‪10001 10010 01000 00000 100000‬‬
‫‪000000‬‬
‫‪funct‬‬
‫‪shamt‬‬
‫‪rd‬‬
‫‪rt‬‬
‫‪rs‬‬
‫‪op‬‬
‫‪6 bits‬‬
‫‪5 bits‬‬
‫‪5 bits‬‬
‫‪5 bits‬‬
‫‪5 bits‬‬
‫‪6 bits‬‬
‫‪+‬‬
‫הפורמט נקרא ‪R-type‬‬
‫‪11‬‬
‫‪December 2013‬‬
‫פקודות העברת נתונים‬
‫• פקודות אחרות טוענות (‪ )load‬נתונים מזיכרון לרגיסטר או‬
‫ההיפך—שומרות (‪ )store‬מרגיסטר לזיכרון‬
‫• פורמט פקודת אסמבלי‪rt=mem[rs+offset] : lw rt,offset(rs) :‬‬
‫– טוען מילה – ‪ 32‬סיביות‬
‫• דוגמה‪lw $t0, 32($s3) :‬‬
‫• הייצוג במכונה‪:‬‬
‫– ‪0000000000100000‬‬
‫‪100011 10011 01000‬‬
‫‪immediate value / address offset‬‬
‫‪rt‬‬
‫‪rs‬‬
‫‪op‬‬
‫‪16 bits‬‬
‫‪5 bits‬‬
‫‪5 bits‬‬
‫‪6 bits‬‬
‫הפורמט נקרא ‪ I-type‬בגלל הערך ה"מיידי" (קבוע המוכלל בתכנית)‬
‫‪12‬‬
‫‪December 2013‬‬
‫מבנה הזכרונות (נתונים‪ ,‬תכנית)‬
‫• כתובת בת ‪ 32‬סיביות‬
‫• הכתובת מתייחסת לבית‬
‫(של ‪ 8‬סיביות)‬
‫– מרחב הכתובות = ‪ 232‬בתים‬
‫(‪ 4‬גיגה‪-‬בתים) = ‪ 230‬מלים‬
‫• גודל מרחב הכתובות הוא‬
‫הגודל המכסימלי האפשרי‬
‫של הזיכרון‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪7‬‬
‫‪6‬‬
‫‪5‬‬
‫‪4‬‬
‫‪4‬‬
‫‪8‬‬
‫‪8‬‬
‫‪12‬‬
‫• בדרך כלל יכיל המחשב‬
‫זיכרון קטן בהרבה מהגודל‬
‫המכסימלי‬
‫‪13‬‬
‫‪December 2013‬‬
‫יישור מלים של ‪ 32‬סיביות בזיכרון בעל כתובות בתים‬
‫• יישור בכתובת מודולו ‪( 4‬טוב!)‬
‫• מיקום לא מיושר (גרוע!)‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪3‬‬
‫‪0‬‬
‫‪2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪4‬‬
‫‪MSB‬‬
‫‪LSB‬‬
‫‪14‬‬
‫‪8‬‬
‫‪0‬‬
‫‪LSB‬‬
‫‪MSB‬‬
‫‪4‬‬
‫‪8‬‬
‫‪December 2013‬‬
‫התכנית השמורה בזיכרון‬
‫• כל פקודת מכונה היא תבנית בת ‪ 32‬סיביות‬
‫• התכנית בנויה מהרבה פקודות השמורות בזיכרון‬
‫המחשב‬
‫• המחשב מבצע פקודות ברצף סדור‪ ,‬אחת אחרי השנייה‪:‬‬
‫– )‪ Program Counter (PC‬מכיל את כתובת הזיכרון‬
‫בה נמצאת הפקודה הבאה שיש לבצע‬
‫– בזמן ביצוע פקודה אחת מוסיפים ‪ 4‬ל‪ PC-‬כך שיכיל‬
‫את כתובת הפקודה הבאה‬
‫‪15‬‬
‫‪December 2013‬‬
The Program Counter
Instruction Memory
0
4
PC = 8
Instruction
8
Next instruction at PC+4
12
16
December 2013
16
‫פקודות קפיצה‬
‫ לפעמים יש צורך לקפוץ לפקודה אחרת ולא להמשיך בפקודה הבאה‬,‫כזכור‬
‫בתור‬
•
)jump( ‫) או בלתי מותנית‬branch( ‫ קפיצה מותנית‬:‫סוג שלישי של פקודות‬
•
‫ כתוב‬C ‫ בתכנית בשפת‬,‫למשל‬
•
if (i == j) f = g + h; else f = g – h;
bne $s3, $s4, Label_1
add
j
Label_1:
Label_2:
$s0,$s1,$s2
Label_2
sub $s0,$s1,$s2
…
T
+
# if (i  j) Go to Label_1
# “Label_1” : offset from PC to the
# label below
# Always go to Label_2
F
-
F
T
+
December 2013
17
‫עוד על קפיצות מותנות‬
:‫• קפיצה מותנית תלויה בשוויון‬
bne a,b,Label –
beq a,b,Label –
‫ את זה עושה‬.a<b ‫• אבל איננה יכולה לבדוק יחס כגון‬
: bne ‫“ ואחריה‬set if less than” ‫פקודת‬
slt
$t0,a,b
bne $t0,$zero,Label
# $t0 = 1 if a<b else 0
•
# branch if a<b
:I-type ‫• פקודות הקפיצה המותנות מיוצגות בפורמט‬
op
rs
rt
immediate value / address offset
6 bits
5 bits
5 bits
16 bits
December 2013
18
‫קפיצות בלתי מותנות‬
‫• ‪ jump‬קופצת לכתובת בזיכרון‪ .‬אבל כתובת כוללת ‪32‬‬
‫סיביות‪ ,‬ובפקודה יש מקום רק ל‪:26-‬‬
‫‪jump target address‬‬
‫‪26 bits‬‬
‫‪op‬‬
‫‪6 bits‬‬
‫• ננצל את העובדה שהפקודות מיושרות בזיכרון (כל‬
‫פקודה מתחילה בכתובת שהיא כפולה של ‪ ,)4‬ולכן‬
‫תמיד שתי הסיביות הימניות בכתובת הן '‪ .'00‬יש לנו‬
‫כבר ‪ 28 = 26+2‬סיביות‪ ,‬חסרות עוד ‪...4‬‬
‫• נשתמש בארבע הסיביות העליונות של ‪:PC‬‬
‫– הכתובת לקפיצה היא‪:‬‬
‫’‪PC[31:28] || instruction[25:0] || ’00‬‬
‫‪19‬‬
‫‪December 2013‬‬
‫מסלול הנתונים מבוסס ‪ALU‬‬
‫• מסלול הנתונים שלנו יכיל יחידה לביצוע פעולות‬
‫אריתמטיות ולוגיות (‪ .)ALU‬למשל‪:‬‬
‫– ‪A+B‬‬
‫– ‪A-B‬‬
‫– )‪And(A,B‬‬
‫– )‪Or(A,B‬‬
‫• מבנה אפשרי‪:‬‬
‫‪20‬‬
‫‪December 2013‬‬
‫ בסיסי‬ALU
CarryIn
Operation
‫חיסור‬
Binvert
a0
Operation
CarryIn
b0
CarryIn
ALU0
Result0
CarryOut
a
0
a1
b1
1
0
ALU1
Result1
CarryOut
Result
a2
b
CarryIn
2
b2
CarryIn
ALU2
Result2
CarryOut
1
CarryOut
a31
b31
December 2013
CarryIn
ALU31
Result31
21
SLT ‫ כולל‬ALU
lsb-‫' בכל הסיביות חוץ מה‬0' ‫ מציבה‬SLT ‫• פקודת‬
A-B ‫ של החיסור‬msb ‫ תלוי בסיבית‬0/1 ‫ מוצב‬lsb-‫• ב‬
‫ נוסיף חומרה לזיהוי גלישה‬msb-‫• ב‬
B in ve rt
O p e ration
C arryIn
B in v e rt
O p e ra tio n
C a rr y In
a
0
a
0
1
R es u lt
b
0
1
2
R e s u lt
1
b
Le ss
3
0
2
1
Set
L es s
O v e rflo w
de tec tion
3
O ve rflow
C a r ry O u t
msb
December 2013
‫כל השאר‬
22
Binvert
CarryIn
a0
b0
CarryIn
ALU0
Less
CarryOut
a1
b1
0
CarryIn
ALU1
Less
CarryOut
a2
b2
0
CarryIn
ALU2
Less
CarryOut
Operation
Result0
Result1
Result2
CarryIn
a31
b31
0
December 2013
CarryIn
ALU31
Less
Result31
Set
Overflow
23
...‫ תומך קפיצות מותנות‬ALU
Bnegate
‫• נוסיף בדיקה‬
‫לאפס עבור‬
beq ,bne
Operation
a0
b0
CarryIn
ALU0
Less
CarryOut
Result0
a1
b1
0
CarryIn
ALU1
Less
CarryOut
Result1
a2
b2
0
CarryIn
ALU2
Less
CarryOut
Result2
a31
b31
0
December 2013
CarryIn
ALU31
Less
Zero
Result31
Set
Overflow
24
ALU-‫תוספות ל‬
CarryIn
a0
b0
a1
b1
a2
b2
a3
b3
:‫• אפשר כמובן להוסיף‬
CarryIn
Result0--3
ALU0
P0
G0
pi
gi
Carry-lookahead unit
C1
a4
b4
a5
b5
a6
b6
a7
b7
a8
b8
a9
b9
a10
b10
a11
b11
a12
b12
a13
b13
a14
b14
a15
b15
ci + 1
CarryIn
Result4--7
ALU1
P1
G1
‫ לזירוז החיבור‬CLA –
‫ מחלק‬,‫– מכפל‬
...‫– ועוד‬
pi + 1
gi + 1
C2
ci + 2
CarryIn
Result8--11
ALU2
P2
G2
pi + 2
gi + 2
C3
ci + 3
CarryIn
Result12--15
ALU3
P3
G3
pi + 3
gi + 3
C4
ci + 4
CarryOut
December 2013
25