מבוא למחשבים – חוברת תרגולים
מרצה :דר משה שוורץ
מתרגל :חורש בן שטרית
תרגול : Iייצוג מספרים
נושאי התרגול
.1הגדרות כלליות והנחיות לתרגילי הבית
.2ייצוג מספרים
הנחיות
אתר הקורס www.ee.bgu.ac.il/~compintr :
דוא"ל אלקטורני למתרגלhoreshb@gmail.com :
בכל פנייה דרך האמייל יש לכתוב compintrבתחילת כותרת האמייל.
תרגילי בית -עשרה תרגילים ,חובת הגשה ,ניתן להגיש בזוגות.
התרגילים מהוים 10%מן הציון הסופי
התרגילים יופיעו באתר קורס ,עם תאריך הגשה )בד"כ שבוע וחצי(.
שעות קבלה :יום שלישי 12:00 -11:00בחדר ) 515/ 3 3קומה חמישית(
ייצוג מספרים
ישנם שתי שיטות עקריות לייצוג מספרים Unsigned ,signed , unsigned :
נראה שלוש שיטות לייצוג מספרים : signed
שיטת גודל וסימן
בשיטה זו ביט ה msbמייצג את הסימן וכל שאר הביטים את גודל המספר ,
לדוגמא :
1
יתרונות :ניתן בקלות לדעת את ערך המספר ואת כיוונו.
חסרונות :שני ייצוגים לאיבר אפס:
לא ניתן לבצע חיסור בצורה פשוטה :
1 − 5 = 1 + (− 5) = −4
⎧0001
⎨+
⎩1101
= 1110 = −6 ≠ −4
שיטת המשלים ל 1
שיטת המשלים ל – 1הינה שיטה סימטרית בה כל מספר שלילי הוא היפוך הביטים של המקביל
החיובי ,גם כאן הביט הגדול ביותר msbמתאר את הסימן :
0111 = 7
0110 = 6
0101 = 5
M
0001 = 1
0000 = 0
1111 = 0
1110 = −1
M
1001 = −6
1000 = −7
גם בשיטה זו ישנם שני סימונים לאיבר האפס.
לצורך חישוב המשלים ל 1עבור מספר xיש להשתמש בנוסחא :
1' comp = 2 n − 1 − x
כאשר nזהו מספר הביטים בייצוג שלנו
לדוגמא המשלים ל 1של המספר 7עבור n = 4הינו :
− 7 = 2 − 1 − 7 = 8 = (1000 )2
ואילו עבור n = 8נקבל:
− 7 = 2 8 − 1 − 7 = 248 = (11111000 )2
4
2
שיטת המשלים ל 2
שיטת המשלים ל 2שונה מהשיטות הקודמות במובן זה שלאפס ישנו ייצוג אחד בלבד ,
"חוק ההתמרה" הינו
n
2' comp = 2 − x if x ≠ 0
2' comp = 0 if x = 0
בפועל אנו הופכים את הביטים ומוסיפים 1לתוצאה .
0111 = 7
0110 = 6
0101 = 5
M
0001 = 1
0000 = 0
1111 = −1
1110 = −2
M
1001 = −7
1000 = −8
לדוגמא נמצא את המשלים של : x = 3
2 − 3 = 16 − 3 = 13 = (1101)2
4
0011
↓
⎧1100
⎨+
⎩0001
= 1101
דוגמא חיסור מספרים ? = 2 − 3בשיטת משלים ל:2
= )2 − 3 = 2 + (− 3
⎧0010
⎨+
⎩1101
)= 1111 = (− 1
3
קיבלנו מספר שלילי -כיצד נדע מה ערכו?
דוגמא מציאת ערך מספר שלילי ? = (1100010101)2עבור n = 10
)(1100010101
↓
⎧0011101010
⎨+
⎩ 0000000001
= 0011101011 = − 2 7 + 2 6 + 2 5 + 2 3 + 21 + 2 0 = −235
(
)
בעיות בחיבור מספרים מכוונים :
ישנן שתי בעיות העלולות להווצר בזמן חיבור מספרים :
, CARRYנשא :בזמן חיבור מספר חיובי עם מספר שלילי כך שיש נשא -
⎧0 xxx
⎨+
⎩1yyy
= (1)0 zzz
, CARRYבזמן חיבור מספר שלילי עם מספר שלילי כך שיש נשא -
⎧1xxx
⎨+
⎩1 yyy
= (1)1zzz
הפתרון במקרה כזה :
בשיטת המשלים ל 1נוסיף את ה carryל LSBשל התוצאה – כלומר נוסיף 1לתוצאה .
בשיטת המשלים ל 2נתעלם מה . carry
, Overflowגלישה :בזמן חיבור שני מספרים חיוביים כך שה msbמתקבל אחד:
⎧0 xxx
⎨+
⎩0 yyy
= 1zzz
גלישה בזמן חיבור שני מספרים שליליים כך שה lsbמתקבל אפס:
⎧1xxx
⎨+
⎩1yyy
= 0 zzz
במצב של גלישה לא נוכל לתת פתרון נכון ,יש לעצור ולהתריע למשתמש .
דוגמאות :
חיסור מספרים ? = − 1 − 2בשיטת משלים ל:2
⎧1111
⎨+
⎩1110
= (1)1101 = 1101 = −3
במקרה זה התעלמנו מהנשא.
4
חיסור מספרים ? = − 1 − 2בשיטת משלים ל:1
⎧1110
⎨+
⎩1101
= = (1)1011
⎧1011
= 1100 = −(0011) = −3
⎨+
⎩0001
במקרה זה הוספנו את הנשא לתוצאה.
טבלה מסכמת n = 3 :
משלים ל 1
0
משלים ל 2
0
1
2
3
−3
−2
−1
0
לא מסומן
0
1
2
1
2
3
010
011
3
4
−4
−3
100
101
5
6
7
−2
−1
000
001
110
111
תכונות:
.1ניתן לקבל את המשלים ל 2ע"י שימוש במשלים לאחד שלו בתוספת . 1
שיטה טכנית נוספת הינה למצוא את ה 1הימיני ביותר ,ולהפוך את כל הביטים שמשמאלו:
1100 = −4
↓
0100 = 4
.2במשלים ל 2מתקיים הקשר :
n−2
נתון המספר x = ( x n −1 , x n − 2 , L , x1 , x 0 )2 = ∑ xi ⋅ 2 i − x n −1 ⋅ 2 n −1
i =0
לדוגמא:
x = (1011)2 = 2 + 2 − 2 = 1 + 2 − 8 = −5
.3הגדלת הייצוג נעשית ע"י שיכפול ביט הסימן } :הרחבת סימן{
לדוגמא עבור : n = 4
x = −5 = (1011)2
עבור : n = 8
x = −5 = (11111011)2
3
1
0
5
ייצוג שברים :
שיטת משלים ל:1
בשיטת משלים ל 1עבור nביטים משמאל לנקודה ו mמימין לנקודה ,נקבל את הנוסחא:
1' comp = 2 n − 2 − m − x
נשים לב שבמקרה של המספרים השלמים 2 m = 1 ⇔ m = 0
עדיין בכדי למצוא את המשלים של מספר מסויים אנו הופכים את הביטים
דוגמא :
המספר (010.0111)2עבור n = 3, m = 4מייצג
(010.0111)2 = 21 + 2 −2 + 2 −3 + 2 −4 = 2 + 1 + 1 + 1 = 2 7
4 8 16
16
נמצא את המשלים ל 1שלו :
1
7
8
⇒ 2 n − 2 −m, − x = 8 − − 2 = 5
16
16
16
(101.1000)2 = −2 7
16
שיטת משלים ל: 2
בשיטת משלים ל 2עבור nביטים משמאל לנקודה ו mמימין לנקודה ,נקבל את אותה הנוסחא
כמו הייצוג של המספרים השלמים :
n
2' comp = 2 − x
−m
אך כעת המקום להוסיף 1לתוצאת היפוך הביטים – אנו מוסיפים , 2
} בעצם עדיין מוסיפים " "1ב .{ lsb
דוגמא :
7
המספר (010.0111)2עבור n = 3, m = 4מייצג
2
16
⎧101.1000
⎨+
המשלים ל 2שלו הינו ⎩000.0001 :
= 101.1001
6
2 תירגול מספר
3-state .1
In
Out
3-state
En
:טבלת אמת
En
0
0
1
1
In
0
1
0
1
In
out
High Z - נתק
High Z - נתק
0
1
Out
In
En = 0
Out
En = 1
3-state בשביל מה צריך
Bus
“0”
“1”
:3-state-במקרה כזה יש התנגשות אך אם נשתמש ב
Bus
“0”
“1”
En2
En1
En1
1
0
0
1
En2
0
1
0
1
Out
“1”
“0”
לא מוגדר
מצב אסור
:3-state- מבנה ה.2
: ושערים לוגיים3-state בעזרתMux (2-1) ממש.3
I0
Mux
2-1
I0
Out
I1
Out
S0
I1
S0
Latch .4בעזרת D-FF
כל עוד ה clk-ב "1"-מה שיש ב D-עובר ל Q-אם clkעובר ל "0"-אז Qשומר על הערך האחרון של .D
)Q(n+1
)Q(n+1
0
1
D
Don’t care
0
1
clk
0
1
1
Q
D
clk
D
clk
Q
”clk = “0
Qשומר על
ערכו האחרון
”clk = “1
Qעוקב אחר המצב של D
”clk = “0
Qשומר על
ערכו האחרון
D-FF .5שמגיב לעליית שעון
רק בעליית שעון מה שיש ב D-עובר ל Q-עד לעלייה הבאה.
Q
D
clk
D
clk
Q
D in
Master – Slave מסוגFlip – Flop .6
. – מגיב לירידהMaster
Q out
. – מגיב לעלייהSlave
Ds Qs
Dm Qm
clk
clk
clk
D
clk
Qm
Qs
Register – אוגר.7
. המאחסנת מספר ביטיםCPU- – יחידת איחסון מידע בRegister
סימון
: ביטיםm אוגר בעל
m
m
D
clk
Q
A out
A <m..1>
Bus
.8פירוש הסימון ברמת ה:FF-
כל ה FF-הם בעלי אותו clkהמגיב לירידה במקרה זה .מכיוון שמדובר באוגר אנו רוצים לגשת לכולו באותו
זמן – לקריאה או לכתיבה.
Bus
m
Q
D1 in
D
A<1
> clk
Q
D2 in
D
A<2
>clk
Q
Dm in
D
>A<m
clk
clk
A out
m
m
Q
D
Q
D
clk
clk
FFהמגיב לירידה
FFהמגיב לעליה
: העברת נתונים בין אוגרים.9
m
:נרצה לבצע
m
Bus
D
Q
m
m
R0
R0 in
m
R1←R0
:פיתרון
R0 out
clk
R0 out="1", R1 in="1"
m
D
יש לשים לב כי המצב
Q
m
R0 out="1"
m
R1
R1 in
m
R1 out="1"
R1 out
clk
.בו זמנית הוא אינו חוקי
: במכונה הבאהAbstract RTN: R1←R1+R2 רוצים לממש.10
m
m
D
Q
m
m
R1
R1 in
m
Bus
clk
D
m
R1 out
m
Y
m
clk
Y in
m
D
Q
בעלALU
add פעולת
Adder
Q
m
m
R2
R2 in
m
clk
R2 out
m
D
Q
Z
Z in
clk
m
Z out
m
:קווי הבקרה הקיימים
R1 in, R2 in, Y in, Z in, R1 out, R2 out, Z out
זמן
Concrete RTN שלבי פעולה
Control signals קווי בקרה
T0
Y←R1
R1 out, Y in
T1
Z←R2+Y
R2 out, Z in
T2
R1←Z
Z out, R1 in
R1 out
Y in
Y←R1
R2 out
Z in
Z←R2+Y
Z out
R1 in
R1←Z
מרצה :דר משה שוורץ
מתרגל :חורש בן שטרית
תרגול : IIIמעבדים ,שיטות מיעון ומודל SRC
נושאי התרגול
.1מעבדים 0-4כתובות
.2שיטות מיעון
.3מודל SRC
מעבדים 0-4כתובות
ניתן לחלק מעבדים לפי כמות הכתובות המקסימאלית הנמצאת בפקודה .
ככל שיש יותר כתובות אליהן ניתן לפנות ,כל המעבד יותר "משוכלל" ומאפשר לבצע פעולות
מסובכות במספר פקודות קטן יחסית למעבדים בעלי מספר פקודות קטן יותר.
הנתונים שאנו צריכים לדעת עבור כל פקודת מכונה הינם:
א .סוג הפעולה ) ( opcode
ב .הכתובת בה תשמר התוצאה ) ( res
ג .כתובת האופרנד הראשון ) ( opr1
ד .כתובת האופרנד השני ) ( opr2
ה .מיקום הפקודה הבאה.
בחלק מהמעבדים ,בחלק מהפקודות הנתונים מובאים בצורה מפורשת ) ( explicitואילו אחרים
מובאים הצורה בלתי מפורשת ) .( implicit
מעבד 4כתובות
בשיטה זו כל הנתונים מובאים בצורה מפורשת בכל פקודה :
רוחב כל מילה בזכרון הינו 24ביט ,ואורך כל פקודה הינו 13בתים.
ניכר שיש בשיטה זו יתירות משום שבד"כ הפקודה הבאה נמצאת מיד בהמשך הפקודה הקודמת ) למעט
הסתעפויות( ולכן ניתן לחסוך נתון זה ולהשאירו בצורה לא מפורשת
1
מעבד 3כתובות
מיקום הפקודה הבאה איננו נמצא בקידוד בפקודה,
אלא מחושב בנפרד ע"י רגיסטר ה ( Program Counter ) PC
במקרה זה רוחב כל פקודה הינו 10בתים.
דוגמא:
A← B+C
A, B, C
Add
מעבד 2כתובות
במקרה זה האופרנד השני משמש גם שאוגר תוצאת החישוב ,התוצאה לכן "דורסת" את הנתון הקודם
באופרנד זה .במקרה זה אורך כל פקודה הינו 7בתים.
דוגמא:
A ← A+ B
A, B
Add
מעבד בעל כתובת אחת
בשיטה זו ,אנו משתמשים באוגר נוסף -אקומולטר ) ( ACCהמשמש כאופרנד השני וכן גם אוגר תוצאת
החישוב ,
ניתן לאתחל את ה ACCמהזכרון ולשמור את התוצאה בזכרון :
ld B
ACC ← B
st B
B ← ACC
דוגמא:
ACC ← A + ACC
A
Add
במקרה זה אורך כל פקודה הינו 4בתים.
2
מעבד בעל 0כתובות
בשיטה זו ,אנו משתמשים במחסנית ומפעילים את כל החישובים על הערך הנמצא בראש המחסנית
) ( Top Of Stack - TOSעם הערך הנמצא במיקום הבא אחריו ) , ( Second Of Stack – SOSעדיין
ישנן פקודות בעלות כתובת אחת ) טעינה מהזכרון ושמירה בזכרון(
ולכן חלק מהפקודות הינן באורך בית אחד וחלק באורך 4בתים.
TOS ← B
B ← TOS
דוגמא:
push B
pop B
TOS ← TOS + SOS
דוגמא מסכמת
תכנת קטע קוד המחשב את הביטוי + D
פתרון :
אפס כתובות
Push B
Push C
Sub
Mult
Push D
Add
Pop A
7פקודות ) 19בתים(
4פניות לזיכרון
2
Add
) A ← (B − Cבאמצעות מעבדים בעלי 0-3כתובות.
כתובת אחת
ld B
Sub C
St A
Mult A
Add D
St A
6פקודות ) 24בתים(
6פניות לזיכרון
2כתובות
ld A, B
Sub A, C
Mult A, A
Add A, D
4פקודות ) 28בתים(
11פניות לזיכרון ) שתי
פניות ב , ldשלוש
פניות בכל השאר(
3כתובות
Sub A, B, C
Mult A, A, A
Add A, A, D
3פקודות ) 30בתים(
9פניות לזיכרון
3
שיטות מיעון
הפנייה לזכרון יכולה להתבצע במספר שיטות צורות פנייה ,שיטות אלו נקראות שיטות מיעון .אנו נציג מספר
שיטות :
א .מיעון מיידי ) (immediate
ב .מיעון ישיר ) (direct
ג .מיעון עקיף ) (indirect
ד .מיעון ישיר רגיסטר ) (register direct
ה .מיעון עקיף רגיסטר ) (register indirect
ו .מיעון היסט ) (displacement
ז .מיעון יחסי ) ( relative addressing
מיעון מיידי ) ( immediate
בשיטה זו נציב בצורה מידית ערך בזכרון/רגיסטר לדוגמא :
R[ra ] ← C 2
R[ra ] ← R[rb ] + C 2
la ra ,C 2
addi
ra , rb , C 2
בד"כ לא נהוג להציב ערך ישירות מהמעבד לזכרון )אלא ,קודם נעביר לרגיסטר וממנו לזכרון(
מיעון ישיר ) ( direct
בשיטה זו נפנה למיקום הזכרון בצורה ישירה לדוגמא :
] R[ra ] ← M [C 2
ra ,C 2
ld
מיעון עקיף ) ( indirect
בשיטה זו נפנה למיקום הזכרון ע"י שימוש בכתובת הנמצאת בזכרון במיקום אחר לדוגמא :
]] R[ra ] ← M [M [C 2
מיעון ישיר רגיסטר ) ( register direct
בשיטה זו נפנה לרגיסטרים בצורה ישירה לדוגמא :
] R[ra ] ← R[rb ] + R[rc
) ra , (C 2
ld
add
ra , rb , rc
מיעון עקיף רגיסטר ) ( register indirect
בשיטה זו נפנה לזיכרון בצורה עקיפה דרך רגיסטרים לדוגמא :
] M [R[rb ]] ← R[ra
) ra , (rb
st
מיעון היסט ) ( displacement
בשיטה זו נפנה לזיכרון בצורה עקיפה דרך רגיסטרים ובנוסף נבצע הסטה )חיבור עם קבוע( לדוגמא :
] ra , C 2 (rb ) M [C 2 + R[rb ]] ← R[ra
מיעון יחסי ) ( relative addressing
בשיטה זו נפנה לזיכרון בצורה יחסית ל PCלדוגמא :
] R[ra ] ← M [PC + C1
ra ,C1
4
ldr
st
מודל SRC
מודל ( Simple RISC computer ) SRCהוא מודל פשוט המשמש כדוגמא למחשב ,מיותר לציין
שהמחשבים של היום מסובכים הרבה יותר ממודל זה ואפילו המעבדים הפשוטים ביותר מורכבים יותר ממודל
זה.
במודל זה נשתמש בהנחות הבאות :
זיכרון ראשי ) ( Main Memory – MMבגודל 2בתים כאשר כל תא בזיכרון מכיל בית אחד.
רגיסטרים כללים ) 32רגיסטרים בגודל 4בתים כל אחד(
– PCרגיסטר המצביע על מיקום הפקודה הבאה.
- Instruction Register – IRמכיל את הפקודה הנוכחית ,המתבצעת כעת.
32
תהליך ביצוע הפקודות
הפקודות מבוצעות בשלבים הבאים :
- Fetch (1הבאת הפקודה הנמצאת בכתובת עליה מצביע ה PCאל רגיסטר ה .IR
- Execution (2פיענוח הפקודה הנמצאת ב IRוביצועה
(3קידום ה PC ← PC + 4 : PCוחזרה לשלב . 1
זיכרון
משום שכל תא בזיכרון מכיל בית אחד ,כאשר אנו טוענים נתונים מהזכרון אל הרגיסטרים או שומרים מידע
מהרגיסטרים אל הזכרון ,הפעולות מתבצעות בבלוקים של 4בתים .ולכן בעצם הסימון :
]M [x] = M [x]# M [x + 1]# M [x + 2]# M [x + 3
הזכרון עצמו הינו בלוק אחד של מידע ,אך מערכת ההפעלה מחלקת אותו לשני חלקים:
- Code segmentמכיל את קידוד הפקודות של התוכנית
– Data segmentמכיל את הנתונים בהם משתמשת התוכנית וכן מאחסן את תוצאות התוכנית.
פקודת חומרה – זוהי פקודה המבוצעת ע"י החומרה )מעגלים( של המעבד
לדוגמא – במעבד בעל פקודת חומרה חיבור בלבד ,פעולת מכפלה תבוצע ע"י מספר פקודות חומרה ואילו
פעולת החיבור תבוצע בפקודה אחת.
ישנם מעבדים בהם קיימת לדוגמא הפקודה MAC- multiply and accumulateבהם מבוצע כפל וחיבור
בפקודת חומרה אחת.
5
פורמט הפקודות
במודל ה SRCקיימות מספר פורמטים של פקודות ,כל פקודה הינה באוך קבוע של 32ביט – 4בתים .
:Type I
דוגמא :פקודת טעינה יחסית
] R[ra ] ← M [PC + C1
דוגמא ספציפית ldr r6 ,12 :
הפקודה ממומשת כך :
opcode = 2
ra ,C1
ldr
)]([00010][00110][0L01100
פקודה זו תכניס אל רגיסטר 6את ערך ה PCועוד ) 12בעצם 3פקודות קדימה(
: Type II
דוגמא :פקודת טעינה
דוגמא ספציפית r2 , r5 ,20 :
הפקודה ממומשת כך :
opcode = 1
]] R[ra ] ← M [C 2 + R[rb
ra , rb , C 2
ld
ld
)]([00001][00010][00101][0L010100
הערה :במקרה ש , rb = 00000לא נשתמש ברגיסטר r0אלא נקבל פקודה שונה :
] R[ra ] ← M [C 2
דוגמא:
פקודת חיבור
דוגמא ספציפית addi r2 , r4 ,9 :
הפקודה ממומשת כך :
opcode = 13
R[ra ] ← R[rb ] + C 2
ra ,C 2
ld
addi ra , rb , C 2
)]([01101][00010][00100][0L01001
6
: Type III
7
4 תירגול מספר
פורמט פקודות
ld,addi פקודות.1
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8
Opcode
ra
rb
c2
5 bit
5 bit
5 bit
17 bit
7
6
5
4
3
2
1
0
0
0
פקודת טעינה
Opcode = 1
ld ra,rb,c2
R[ra]←M[R[rb]+c2]
דוגמא
:נתונה הפקודה
ld r2,r3,20
R[r2]←M[R[r3]+20]
:קידוד הפקודה
0
0
0
0
1
0
0
0
1
0
0
0
0
1
1
0
0
0
0
0
0
0
0
0
Opcode
ra
rb
c2
1
2
3
20
0
0
0
1
0
1
R[ra]←M[c2] אזrb=0 אם
פקודת חיבור
Opcode = 13
addi ra,rb,c2
R[ra]←R[rb]+c2
דוגמא
:נתונה הפקודה
ld r3,r5,10
R[r3]←R[r5]+10
:קידוד הפקודה
0
1
0
1
1
0
0
0
1
1
0
0
1
0
1
0
0
0
0
0
0
0
0
0
Opcode
ra
rb
c2
13
3
5
10
0
0
0
0
1
0
1
0
1
0
0
0
ldr,lar פקודות.2
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
Opcode
ra
c1
5 bit
5 bit
22 bit
8
7
6
5
4
3
2
Load relative פקודת
Opcode = 2
ldr ra,c1
R[ra]←M[PC+c1]
דוגמא
:נתונה הפקודה
ldr r2,4
R[r2]←M[PC+4]
0
0
0
1
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
Opcode
ra
c1
2
2
4
0
0
0
0
0
0
0
1
shr, shra, shl, shc פקודות.3
shra פקודת
. עם עיגול כלפי מטה2-אם המספר הוא חיובי אי זוגי אז מתבצע חילוק ל
דוגמא
00...01010
shra
( זוגי10 )10
00...00101
shra
00...00010
( אי זוגי5)10
( זוגי2 )10
.5div(2)=2 של חילוק ועיגול כלפי מטהdiv זוהי פעולת
אם המספר הוא שלילי ואי זוגי נקבל
11...10110
shra
( זוגי− 10 )10
11...11011
shra
11...11101
( אי זוגי− 5 )10
( אי זוגי− 3)10
.(-5)div(2)=(-3) div-כלומר יש עיגול כלפי מטה וזו פעולת ה
br, brl פקודות הסתעפות.4
br Opcode = 8
brl Opcode = 9
br rb
PC←R[rb]
brl ra,rb
R[ra]←PC
PC←R[rb]
brzr rb,rc
If R[rc]=0 then PC←R[rb]
brlzr ra,rb,rc
R[ra]←PC
If R[rc]=0 then PC←R[rb]
brnz rb,rc
If R[rc]≠0 then PC←R[rb]
brlnz ra,rb,rc
R[ra]←PC
If R[rc]≠0 then PC←R[rb]
brpl rb,rc
If R[rc]≥0 then PC←R[rb]
brlpl ra,rb,rc
R[ra]←PC
If R[rc]≥0 then PC←R[rb]
brmi rb,rc
If R[rc]<0 then PC←R[rb]
brlmi ra,rb,rc
R[ra]←PC
If R[rc]<0 then PC←R[rb]
.IR<2..0>-התנאי שיקבע איזו הסתעפות תתבצע נמצא ב
: פיענוח פקודה.5
(4 A965005)H
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
4
0
1
9
A
0
0
1
0
1
0
1
0
6
0
1
0
1
5
1
0
0
1
9
8
7
6
0
0
1
0
0
5
4
3
2
0
0
0
0
0
1
0
0
1
5
0
9
10
11
5
5
Opcode
ra
rb
rc
cond
0
0
LSB
Condition
Assembly language form
000
Never
brlnv
001
Always
br, brl
010
If rc = 0
brzr, brlzr
011
If rc ≠ 0
brnz, brlnz
100
If rc ≥ 0
brpl, brlpl
101
If rc < 0
brim, brlmi
1
:הפקודה היא
brlmi r10,r11,r5
R[r10]←PC
If R[r5]<0 then PC←R[r11]
המספרים2 אשר משווה ביןSRC-( כתוב תוכנית ב84)H ( ומספר שני בכתובת80 )H נתון מספר אחד בכתובת.6
. (100 )H ומכניסה את הערך הגדול מבין שניהם לכתובת
0
ld r1,80H
R[r1]←M[80H]
4
ld r2,84H
R[r2]←M[84H]
8
sub r3,r2,r1
R[r3]←R[r2]-R[r1]=M[84H]-M[80H]
12
lar r4,16
R[r4]←PC+16=16+16=32
16
brim r4,r3
If R[r3]<0 then PC←R[r4]=32
20
st r2,100H
M[100H]←R[r2]=M[84H]
24
lar r5,8
R[r5]←PC+8=28+8=36
28
br r5
PC←R[r5]
32
st r1,100H
M[100H]←R[r1]=M[80H]
36
stop
:דרך נוספת
0
ld r1,80H
R[r1]←M[80H]
4
ld r2,84H
R[r2]←M[84H]
8
sub r3,r2,r1
R[r3]←R[r2]-R[r1]=M[84H]-M[80H]
12
lar r4,8
R[r4]←PC+8=16+8=24
16
brpl r4,r3
If R[r3]≥0 then PC←R[r4]=24
20
la r2,r1,0
R[r2]←R[r1]+0
24
st r2,100H
M[100H]←R[r2]
28
stop
PC←R[r5]
אם המספר זוגי. הבודקת האם המספר זוגי או אי זוגיSRC-( כתוב תוכנית ב200 )H נתון מספר בזיכרון בכתובת.7
. (200)H התוצאה נשמרת בכתובת.1 אם המספר אי זוגי התוכנית מחסירה ממנו.2-התוכנית מחלקת אותו ב
0
ld r1,200H
R[r1]←M[200H]
4
andi r2,r1,1
R[r2]←R[r1] and 1 בדיקת זוגיות
8
lar r3,16
R[r3]←PC+16=12+16=28
12
brzr r3,r2
If R[r3]=0 then PC←R[r3]=28
16
addi r1,r1,-1
R[r1]←R[r1]-1
20
lar r4,8
R[r4]←PC+8=24+8=32
24
br r4
PC←R[r4]=32
28
shra r1,r1,1
R[r1]←R[r1]/2
32
st r1,200H
M[200H]←R[r1]
36
stop
:דרך נוספת
0
ld r1,200H
R[r1]←M[200H]
4
andi r2,r1,1
R[r2]←R[r1] and 1 בדיקת זוגיות
8
addi r1,r1,-1
R[r3]←R[r1]-1
12
shra r4,r1,1
R[r4]←R[r1]/2
16
lar r5,8
R[r5]←PC+8=20+8=28
20
brzr r5,r2
If R[r2]=0 then PC←R[r5]=28
24
la r4,r3,0
R[r4]←R[r3]+0
28
st r4,200H
M[200H]←R[r4]
32
stop
ומכניסה את המנה
x1
כתוב תוכנית המחשבת את. (204 )H בכתובתx2-( ו200)H בכתובתx1 נתון מספר.8
x2
. (20C )H ( ואת השארית לכתובת208)H לכתובת
0
la r3,0
R[r3]←0 איתחול המונה
4
ld r1,200H
R[r1]←M[200H]
8
ld r2,204H
R[r2]←M[204H]
12
addi r3,r3,1
R[r3]←R[r3]+1
16
sub r1,r1,r2
R[r1]←R[r1]-R[r2]=x1-x2
20
lar r4,-12
R[r4]←PC-12=24-12=12
24
brpl r4,r1
If R[r1]≥0 then PC←R[r4]=12
28
add r1,r1,r2
R[r1]←R[r1]+R[r2] מקבל את השאריתR[r1]
32
addi r3,r3,-1
R[r3]←R[r3]-1 מקבל את המנהR[r3]
36
st r1,20CH
M[20CH]←R[r1]
40
st r3,208H
M[208H]←R[r3]
44
stop
מרצה :דר משה שוורץ
מתרגל :חורש בן שטרית
תרגול : Vתוכניות ב SRC
נושאי התרגול
.1תוכניות אסמבלי במודל ה SRC
תוכניות אסמבלי
תוכנית parity
ביט זוגיות ) ( parity bitמשמש בן השאר לבדיקה האם נכנסו שגיאות למידע מאוחסן /משודר .
ביט הזוגיות בעצם מציין האם סכום ה"אחדים" במידע ,זוגי או אי-זוגי.
תרגיל 1
כתוב תוכנית המקבלת מערך מקור בן 100איברים ,וכותבת במערך מטרה )גם הוא בן 100איברים( את
פונקצית הזוגיות עבור כל איבר.
במקרה שלנו איבר המטרה יהיה 0אם כמות האחדים באיבר המקור הינה זוגית
-1אם כמות האחדים באיבר המקור הינה אי-זוגית
מערך המקור מתחיל בכתובת , 400כתובת תחילת מערך המטרה הינה . 800
פתרון תרגיל 1
עבור כל איבר המערך המקור ,יש לסכום את כמות ה , 1
ניתן לבצע זאת ע"י ביצוע 31הזזות ימינה )כל פעם בכמות אחרת( ,ביצוע כפל ב " "000..00001וסכימה.
בכל שלב) לאחר כל הזזה( נבדוק האם האיבר הינו אפס ,בכדי להפסיק את הלולאה ) בדרך זו לא נדרש
לספור עד . ( 31
1
פתרון תרגיל 1גרסה ראשונה
הסבר
מצביע לאיבר במערך מקור
ערך איבר המקור
סכום ה"אחדים"
מציאת האם הביט הימני
משמעות
כתובת
פקודה
R[r1]←400
la r1,400
0
]]R[r3]←M[R[r1
)ld r3,0(r1
4
R[r7]←0
la r7,0
8
R[r5]←R[r3]&1
andi r5,r3,1
12
ביותר הינו אחד
R[r6]←PC+8=28
lar r6,8
16
If R[r5]=0 then PC←R[r6]=28
Brzr r6,r5
20
R[r7]←R[r7]+1
addi r7, r7,1
24
R[r7]←R[r3]>>1
shr r3, r3,1
28
R[r8]←PC-24=12
lar r8,-24
32
If R[r3] ≠0 then PC←R[r8]=12
Brnz r8,r3
36
R[r7]←R[r7]+1
andi r7, r7,1
40
R[r5]←0
la r5,0
44
R[r6]←PC+8=28
lar r6,8
48
If R[r7]=0 then PC←R[r6]=28
Brzr r6,r7
52
)]R[r5]←not(R[r5
not r5, r5
56
שמירת פונקצית הזוגיות
]M[400+R[r1]]← R[r5
)st r5, 400(r1
60
קידום המצביע על מערך
R[r1]← R[r1]+4
addi r1, r1,4
64
סכימת כמות האחדים
הזזה ימינה
האם הסכום זוגי
הכנסת אפס לאוגר
הכנסת -1לאוגר
המקור
addi r9, r1,-400
בדיקה האם הגענו לסוף
68
המערך
כתובת לולאה ראשית
R[r8]←PC-72=4
lar r10, -72
72
If R[r9] ≠0 then PC←R[r10]=4
Brnz r10,r9
76
stop
80
2
פתרון תרגיל 1גרסה שנייה
בכדי לייעל את התוכנית ,ניתן לבטל את שורות 40-56ולבצע את הקוד הבא:
הסבר
מצביע לאיבר במערך מקור
ערך איבר המקור
סכום ה"אחדים"
מציאת האם הביט הימני
משמעות
כתובת
פקודה
R[r1]←400
la r1,400
0
]]R[r3]←M[R[r1
)ld r3,0(r1
4
R[r7]←0
la r7,0
8
R[r5]←R[r3]&1
andi r5,r3,1
12
ביותר הינו אחד
R[r6]←PC+8=28
lar r6,8
16
If R[r5]=0 then PC←R[r6]=28
Brzr r6,r5
20
)]R[r7]← not(R[r7
not r7, r7
24
R[r7]←R[r3]>>1
shr r3, r3,1
28
R[r8]←PC-24=12
lar r8,-24
32
If R[r3] ≠0 then PC←R[r8]=12
Brnz r8,r3
36
שמירת פונקצית הזוגיות
]M[400+R[r1]]← R[r5
)st r7, 400(r1
40
קידום המצביע על מערך
R[r1]← R[r1]+4
addi r1, r1,4
44
כמות האחדים זוגית/אי זוגית
הזזה ימינה
המקור
addi r9, r1,-400
בדיקה האם הגענו לסוף
48
המערך
כתובת לולאה ראשית
R[r8]←PC-52=4
lar r10, -72
52
If R[r9] ≠0 then PC←R[r10]=4
Brnz r10,r9
56
stop
60
3
פתרון תרגיל 1גרסה שלישית
ניתן לייעל את התוכנית יותר ,ע"י ביצוע השמות ) ( larמחוץ ללולאות ובכך לחסוך המון פקודות מיותרות:
ההשמה הינה קבועה ולכן אין צורך לבצע אותה בתוך הלולאה.
הלולאה החיצונית ביותר ) לא משורטטת( רצה 100פעמים ,
הלולאה הפנימית יכולה לרוץ במקרה הגרוע 100*31פעמים.
הסבר
מצביע לאיבר במערך מקור
כתובת לולאה ראשית
ערך איבר המקור
סכום ה"אחדים"
מציאת האם הביט הימני ביותר
משמעות
כתובת
פקודה
R[r1]←400
la r1,400
0
R[r6]←PC+24=36
lar r6,24
4
R[r8]←PC+1 2=24
lar r8,12
8
R[r8]←PC= 16
lar r10,0
12
]]R[r3]←M[R[r1
)ld r3,0(r1
16
R[r7]←0
la r7,0
20
R[r5]←R[r3]&1
andi r5,r3,1
24
הינו אחד
כמות האחדים זוגית/אי זוגית
הזזה ימינה
שמירת פונקצית הזוגיות
קידום המצביע על מערך המקור
If R[r5]=0 then PC←R[r6]= 36
Brzr r6,r5
28
)]R[r7]← not(R[r7
not r7, r7
32
R[r7]←R[r3]>>1
shr r3, r3,1
36
If R[r3] ≠0 then PC←R[r8]= 24
Brnz r8,r3
40
]M[400+R[r1]]← R[r5
)st r7, 400(r1
44
R[r1]← R[r1]+4
addi r1, r1,4
48
addi r9, r1,-400
52
Brnz r10,r9
56
בדיקה האם הגענו לסוף המערך
If R[r9] ≠0 then
PC←R[r10]=16
stop
60
4
שאלה מבוחן 31/05/2002
5
פתרון השאלה גרסה ראשונה
נתחיל למלא את המערך מסופו )ז"א בערך ,( 1000+1023*4=1000+4092
באיבר האחרון ) הראשון מבחינת התוכנית( – יש לבצע הזזה של 31ימינה.
משמעות
הסבר
מונה את המערך כולו )פחות (32
אוגר המונה 31פעמים )(31*4
איבר המקור
מידת ההזזה הנחוצה ימינה
כתובת
פקודה
R[r30]←3968
la r30,3968
0
R[r 29]←PC=8
lar r29,0
4
R[r31]←124
la r31,12 4
8
R[r28]←PC= 16
lar r28,0
12
]R[r27]← R[r30]+ R[r31
add r27,r30,r31
16
]]R[r7]← M[1000+R[r27
ld r1,r27,1000
20
R[r26]←R[r31]<1..0>#
shr r26,r31,2
24
>R[r31]<31..2
ביצוע הזזה ארטמטית
R[r1]← R[r26]@R[r1]< 31>#
shra r1,r1,r26
28
>]R[r1]<31.. R[r26
שמירת במערך המטרה
]M[10000+R[r27]]← R[r1
st r1, r27,10000
32
R[r31]←R[r31]-4
addi r31, r31,-4
36
If R[r31] >0 then PC←R[r28]=16
brlp r28,r31
40
R[r30]← R[r30]-128
addi r30, r30,-128
44
If R[r30] >0 then PC←R[r29]=8
brlp r29,r30
48
stop
52
lar r28,0
12
R[r28]←PC= 16
) שימו לב יש טעות בספר בטבלת הפקודות ,פקודה ( 27
גם כאן נוכל לחסוך פקודות ע"י ביצוע השמה לפני לולאה ,ובנוסף אם חסרים אוגרים נוכל לאחד את תחילת
הלולאות ובכך לחסוך משתנה – כיצד נבצע זאת? ) הפתרון יובא בתרגול(
6
6 תירגול מספר
.1
Bus
General purpose register
Condition code
logic
Gra
Grb
CONin
CON
Register
Grc
Rin
File
IR
Rout
BAout
PC
IRin
C1out
C2out
PCin
PCout
A
MA
C=B
A
Shr
Inc4
B
Sub
ALU
Shc
Memory
Add
Shl
Or
Shra
MD
MDbus
Not
Shift control
n
C
master-slave
n=0
Cout
Write
MDout
And
Cin
Read
MAin
Ld
Decr
Wait
General purpose registers – register file
– Gra, Grb, Grc .1בוחר את האוגר – אחד בכל פעם.
– BAout .2אם הוא שווה ל 1-יוצא 0ל. bus -
– Rin .3כותב לאוגר.
– Rout .4קורא מהאוגר.
Instruction register – IR
– IRin .1כותב לתוך ה. IR -
– C1out, C2out .2יוצאים ל bus -עם הרחבת סימן מתאימה.
Condition logic
תמיד בודק את מה שיש על ה bus -ב 3-סיביות ה . LSB -כאשר רוצים לקבל תוצאה מעלים את CONinל 1-ובקו
הבקרה CONיש תוצאה.
Shift control
.1הקו n=0עולה ל 1-כאשר . n=0הכניסה היא 5סיביות LSBמה. bus -
.2הקו Decrמבצע . n←n-1
.3הקו Ldטוען ל n -את מה שיש על ה. bus -
Interface to memory
– MA .1מכיל את הכתובת בזיכרון.
– MAin .2מכניס את הכתובת מה bus -ל. MA -
– MD .3מכיל את המידע של תא הזיכרון .מחובר גם ל CPU-Bus -וגם ל. Memory-Bus -
– MDout .4כתיבה מ MD -ל. CPU-Bus -
– MDbus .5קריאה ל MD -מה. CPU-Bus -
– Read .6קריאה מהזיכרון – תא שכתובתו ב MA -ל. MD -
– Write .7כתיבה לזיכרון – תא שכתובתו ב MA -מ. MD -
.2ארעה תקלה במעבד – קו הבקרה notלא פועל .כתוצאה מכך פקודת negלא פועלת .תכנן מחדש את הפקודה
negללא שימוש בקו הבקרה . not
negמקוריAbstract RTN: R[rc]←not(R[rc])+1 :
–R[rc] = 0 – R[rc] :נשתמש במקום
Step
Concrete RTN
קווי בקרה
T0
MA←PC : C←PC+4
PCout, MAin, INC4, Cin
T1
MD←M[MA] : PC←C
Read, Cout, PCin, Wait
T2
IR←MD
MDout, IRin
T3
A←0
BAout, Ain
T4
C←A-R[rc]
Grc, Rout, SUB, Cin
T5
R[ra]←C
Cout, Gra, Rin, End
.סדר כתיבת קווי הבקרה לא משנה כי לא מתייחסים כעת לבעיות תיזמון
. של הפקודה הבאהfetch - להיות מוכן לT0 - לCPU - מחזיר את הEnd קו הבקרה
abs ra,rb : תכנן פקודה חדשה.3
Abstract RTN: R[ra]←|R[rb]|
. תן הצעה לקידוד הפקודה.א
. וקווי בקרהConcrete RTN רשום.ב
: קידוד הפקודה.א
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
0
0
1
1
Opcode
9
8
7
6
5
4
3
1
ra
rb
Un-used
7
2
1
0
1
0
0
cond
4
. R[rb]≥0 התנאי שנבדק הוא
.ב
Step
Concrete RTN
קווי בקרה
T0
MA←PC : C←PC+4
PCout, MAin, INC4, Cin
T1
MD←M[MA] : PC←C
Read, Cout, PCin, Wait
T2
IR←MD
MDout, IRin
T3
CON←cond(R[rb])
Grb, Rout, CONin
T4
CON→C←R[rb]
not(CON)→C←(-1)
CON→(Grb, Rout, C=B, Cin)
not(CON)→(BAout, NOT, Cin)
T5
not(CON)→A←C
not(CON)→(Cout, Ain)
T6
not(CON)→C←A+R[rb]
not(CON)→(Grb, Rout, ADD, Cin)
T7
not(CON)→C←not(C)
not(CON)→(Cout, NOT, Cin)
Master-Slave הואC זה אפשרי כי
T8
R[ra]←C
Gra, Rin, Cout, End
set ra,rb,rc : נתונה פקודה חדשה.4
.LSB - סיביות ה5 – רק32- ל0 – מכיל מספר ביןR[rc]
. – עליו מתבצעת הפעולהR[rb]
. – אוגר המטרהR[ra]
.R[rb] - בR[rc] - בסיבית שמקומה ב1 הפונקציה קובעת
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
9
8
7
6
5
4
3
2
1
0
0
0
0
0
1
R[rc]
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
9
8
7
6
5
4
3
2
1
0
1
1
1
1
0
1
1
0
0
0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
R[rb]
1
1
1
1
1
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
9
8
7
6
5
4
3
2
1
0
1
1
1
1
0
1
1
0
0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
R[ra]
Step
Concrete RTN
T0
קווי בקרה
T0
MA←PC : C←PC+4
T1
MD←M[MA] : PC←C
Read, Cout, PCin, Wait
T2
IR←MD
MDout, IRin
T3
n←R[rc]
Gra, Rout, Ld
T4
C←(-1) : A←0
BAout, Ain, NOT, Cin
T5
C←A – C
Cout, SUB, Cin
T6
shl(:=(n≠0)→(C←C<30..0>#0:n←n-1;shl))
(n≠0)→(Cout, SHL, Decr, goto6, Cin)
T7
A←C
Cout, Ain
T8
C←A OR R[rb]
Grb, Rout, OR, Cin
T9
R[ra]←C
Cout, Gra, Rin, End
T0
T1
T2
T3
T4
T5
T6
T7
T8
T9
Clock
logic
מונה
צעדים
4
Load
: set לפקודתcontrol unit - שינויים ב.5
Opcode
n=0
5
Decoder 5-32
set
T6
goto6
Reset
End
goto6
PCout, MAin, INC4, Cin
T0
פקודותT4
אחרותT5
T8
0110
Rout
Cin
SRC- ייצור מספרים ב.6
BAout על ידי קו בקרה: 0
-1=not(0) : (-1)
0 - (-1) = 1 : 1
INC4(0) = 4 : 4
xor ra,rb,rc : וקווי בקרה לפקודה הבאהConcrete RTN כתוב.7
Abstract RTN: R[ra]←R[rb] xor R[rc]
x ⊕ y = xy + x y
Step
Concrete RTN
קווי בקרה
T0
MA←PC : C←PC+4
PCout, MAin, INC4, Cin
T1
MD←M[MA] : PC←C
Read, Cout, PCin, Wait
T2
IR←MD
MDout, IRin
T3
C←not(R[rb])
Grb, Rout, NOT, Cin
T4
A←C
Cout, Ain
T5
C←A and R[rc]
Grc, Rout, AND, Cin
T6
R[ra]←C
Cout, Gra, Rin
T7
C←not(R[rc])
Grc, Rout, NOT, Cin
T8
A←C
Cout, Ain
T9
C←A and R[rb]
Grb, Rout, AND, Cin
T10
A←C
Cout, Ain
T11
C←A or R[ra]
Gra, Rout, OR, Cin
T12
R[ra]←C
Cout, Gra, Rin, End
even ra,rb : נתונה פקודה חדשה.8
R[ra]←R[rb]/2 : זוגיR[rb] אם
R[ra]←R[rb]-1 : אי זוגיR[rb] אם
. תן הצעה לקידוד הפקודה.א
. וקווי בקרהConcrete RTN רשום.ב
: קידוד הפקודה.א
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
0
0
1
1
9
8
7
6
5
4
3
1
Opcode
ra
rb
2
1
0
0
1
0
cond
Un-used
7
2
.ב
Step
Concrete RTN
קווי בקרה
T0
MA←PC : C←PC+4
PCout, MAin, INC4, Cin
T1
MD←M[MA] : PC←C
Read, Cout, PCin, Wait
T2
IR←MD
MDout, IRin
T3
C←(-1) : A←0
BAout, Ain, NOT, Cin
T4
C←A-C
Cout, SUB, Cin
T5
A←C
Cout, Ain
T6
C←A and R[rb]
Grb, Rout, AND, Cin
T7
CON←cond(C)
Cout, CONin
T8
CON→(C←R[rb]<31>#R[rb]<31..1>)
not(CON)→(C←A-R[rb])
CON→(Grb, Rout, SHRA, Cin)
not(CON)→(Grb, Rout, SUB, Cin)
T9
not(CON)→(A←0)
not(CON)→(BAout, Ain)
T10
not(CON)→(C←A-C)
not(CON)→(Cout, SUB, Cin)
T11
R[ra]←C
Cout, Gra, Rin, End
דר משה שוורץ: מרצה
חורש בן שטרית: מתרגל
Concrete RTN : VII תרגול
נושאי התרגול
Concrete RTN .1
ייצור מספרים
:SRC -ייצור מספרים ב
About על ידי קו בקרה
0
not(0)
-1
0 - (-1) = 1
1
INC4
4
קידוד פקודות חדשות
: XOR פקודת-תרגיל
xor ra,rb,rc : וקווי בקרה לפקודה הבאהConcrete RTN כתוב
Abstract RTN: R[ra]←R[rb] xor R[rc]
x ⊕ y = xy + x y
Step
T0
T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11
T12
Concrete RTN
MA←PC : C←PC+4
MD←M[MA] : PC←C
IR←MD
C←not(R[rb])
A←C
C←A and R[rc]
R[ra]←C
C←not(R[rc])
A←C
C←A and R[rb]
A←C
C←A or R[ra]
R[ra]←C
1
קווי בקרה
PCout, MAin, INC4, Cin
Read, Cout, PCin, Wait
MDout, IRin
Grb, Rout, NOT, Cin
Cout, Ain
Grc, Rout, AND, Cin
Cout, Gra, Rin
Grc, Rout, NOT, Cin
Cout, Ain
Grb, Rout, AND, Cin
Cout, Ain
Gra, Rout, OR, Cin
Cout, Gra, Rin, End
: even פקודת-תרגיל
even ra,rb :נתונה פקודה חדשה
R[ra]←R[rb]/2 : זוגיR[rb] אם
R[ra]←R[rb]-1 : אי זוגיR[rb] אם
. תן הצעה לקידוד הפקודה.א
. וקווי בקרהConcrete RTN רשום.ב
( )ישיר: even פקודת-1 פתרון
: קידוד הפקודה.א
Step
T0
T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11
Concrete RTN
MA←PC : C←PC+4
MD←M[MA] : PC←C
IR←MD
C←(-1) : A←0
C←A-C=1
A←C
C←A and R[rb]
CON←cond(C)
CON→(C←R[rb]<31>#R[rb]<31..1>)
not(CON)→(C←A-R[rb])
not(CON)→(A←0)
not(CON)→(C←A-C)
R[ra]←C
קווי בקרה
PCout, MAin, INC4, Cin
Read, Cout, PCin, Wait
MDout, IRin
BAout, Ain, NOT, Cin
Cout, SUB, Cin
Cout, Ain
Grb, Rout, AND, Cin
Cout, CONin
CON→(Grb, Rout, SHRA, Cin)
not(CON)→(Grb, Rout, SUB, Cin)
not(CON)→(BAout, Ain)
not(CON)→(Cout, SUB, Cin)
Cout, Gra, Rin, End
.ב
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
0 0 1 1 1
Opcode
7
ra
rb
9
8
7
6
5
4
Un-used
. האם הרגיסטר שווה לאפס, cond=2 במקרה שלנו התנאי הינו
2
3
2
0
1
1
cond
2
0
0
( )ישיר: even פקודת-2 פתרון
) גם מספרים. ולכן ניתן רק לאפס ביט זה1 = LSB מתבסס על העובדה כי למספר איזוגי לעולם יהיה
(!שליליים ביצוג לשניים – נסו זאת
Step
T0
T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
Concrete RTN
MA←PC : C←PC+4
MD←M[MA] : PC←C
IR←MD
C←(-1) : A←0
C←A-C=1
A←C
C←A and R[rb]
CON←cond(C)
C←R[rb]<31>#R[rb]<31..1>
not(CON)→(C←C <30..0>#0)
R[ra]←C
קווי בקרה
PCout, MAin, INC4, Cin
Read, Cout, PCin, Wait
MDout, IRin
BAout, Ain, NOT, Cin
Cout, SUB, Cin
Cout, Ain
Grb, Rout, AND, Cin
Cout, CONin
Grb, Rout, SHRA, Cin
not(CON)→( Cout, SHL, Cin )
Cout, Gra, Rin, End
( )ישיר: even פקודת-3 פתרון
X[0] = X-((X>>1)<<1) : מהחישובLSB מתבסס על העובדה כי ניתן לקבל את ביט ה
Step
T0
T1
T2
T3
T4
T5
T6
T7
T8
Concrete RTN
MA←PC : C←PC+4
MD←M[MA] : PC←C
IR←MD
C←( R[rb]<31>#R[rb]<31..1>) : A← R[rb]
C←C←C <30..0>#0: R[ra]← C
C←A-C: A← C
CON←cond(C)
not(CON)→(C←A)
not(CON)→(R[ra]←C)
קווי בקרה
PCout, MAin, INC4, Cin
Read, Cout, PCin, Wait
MDout, IRin
Grb, Rout, Ain , Cin, SHRA
Cout, SHL, Cin, Gra, Rin
Cout, Ain , Cin, SUB
Cout, CONin
not(CON)→( ADD, Cin, About)
not(CON)→(Cout, Gra, Rin), End
:תרגיל
: רוצים ליצור פקודה חדשה. מילים8 המחולק לבלוקים של, 0 המתחיל בכתובת,נתון מערך בזיכרון
Check_Address ra,rb
אז, אם זוהי כתובת התחלה של בלוק במערך הנתון. rb הפקודה בודקת את הכתובת הנתונה בריגסטר
אז הפקודה, אם זוהי איננה כתובת התחלה של בלוק במערך. ra " לתוך רגיסטר1" הפקודה מחזירה
. אליו שייכת הכתובת הנתונה, את כתובת ההתחלה של הבלוקra מחזירה לתוך רגיסטר
. INC5 ( ויש פעולה חדשהOR,AND ) נתון כי במערכת אין את הפעולות
3
כתוב RTNקונקרטי וקוי בקרה לפקודה חדשה .באפשרותך לעשות שינויים בחומרה של מחולל הצעדים
,במידה ובחרת לעשות שינויים ,הצג אותם.
(1הוסף חומרה ביחידת , Condition Logicכך שניתן יהיה לבדוק האם הכתובת הנתונה ב , rbהיא
כתובת התחלת בלוק .פרט את מימוש החומרה ,השתמש בה בכתיבת . RTN
(2ציר את מימוש יחידת הבקרה ע"י שערים לוגיים ,את מחולל הצעדים )כולל שינויים( ,ואת מימוש
אותות הבקרה הבאיםDecr,Shl,Shr,About,Goto7,Grb :
(3כתוב RTNקונקרטי וקווי בקרה ללא תוספת החומרה ב . Condition Logic
(4נתון כי רק ב 10%מהמקרים יש שגיאה בכתובת ההתחלה של הבלוק .חשב את ה speed up
במימוש ע"י החומרה החדשה ) , ( Condition Loginלעומת החומרה הישנה .זמן ביצוע צעד הוא
.T
פתרון :
(1הבלוקים מתחילים בכתובת , 0ולכן הבלוק הבא יחל לאחר 32=4*8כתובות .
שינויים ב control unit -לפקודה:
>IR<2..0
3
Decoder
6 5 4 3 2 1 0
CON
Bus
5
D Q
CON
Q
CON in
><31.. 0
4
(' דרך א- )דרך ישירה: RTN מימוש ה
Step
T0-T2
T3
T4
T5
T6
T7
T8
T9
T10
T11
T12
T13
Concrete RTN
Fetch
CON←cond(R[rb])
not(CON)→(C←5)
CON→(C←(-1):A←0)
not(CON)→(n←C)
CON→(C←A-C)
not(CON)→(C← R[rb])
not(CON)→ (shr(:=(n≠0)→
(C←0#C<31..1>:n←n-1;shr)))
not(CON)→( R[ra]←C)
not(CON)→(C←5)
not(CON)→(n←C)
not(CON)→(C← R[ra])
not(CON)→ shl(:=(n≠0)→
(C←C<30..0>#0:n←n-1;shl))
R[ra]← C
קווי בקרה
Fetch
CONin, Grb ,Rout
not(CON)→(BAout , INC5, Cin)
CON→(NOT, BAout, Ain , Cin)
not(CON)→( Cout , Ld)
CON→( Cout , SUB , Cin)
not(CON)→( Grb ,Rout , Cin )
not(CON)→ (n≠0)→(Cout, SHR, Decr,
goto7, Cin)
not(CON)→( Gra ,Rin, Cout )
not(CON)→(BAout , INC5, Cin)
not(CON)→( Cout , Ld)
not(CON)→( Gra ,Rout , Cin )
not(CON)→ (n≠0)→(Cout, SHL, Decr,
goto12, Cin)
Gra ,Rin , Cout,End
(' דרך ב- )יעיל יותר: RTN מימוש ה
Step
T0-T2
T3
T4
T5
T6
T7
T8
T9
T10
Concrete RTN
Fetch
CON←cond(R[rb])
not(CON)→(C←5)
CON→(C←(-1):A←0)
not(CON)→(n←C)
CON→(C←A-C)
not(CON)→( C←(-1))
CON→( R[ra]← C )
not(CON)→ (shl(:=(n≠0)→
(C←0#C<31..1>:n←n-1;shl)))
not(CON)→(A← C)
not(CON)→(C← R[rb]^A)
not(CON)→(R[ra]← C)
קווי בקרה
Fetch
CONin, Grb ,Rout
not(CON)→(BAout , INC5, Cin)
CON→(NOT, BAout, Ain , Cin)
not(CON)→( Cout , Ld)
CON→( Cout , SUB , Cin)
not(CON)→ (NOT, BAout, Cin)
CON→( Gra ,Rin , Cout,End)
not(CON)→ (n≠0)→(Cout, SHL, Decr,
goto6, Cin)
not(CON)→( Ain , Cout )
not(CON)→( Grb ,Rout , Cin ,AND )
Gra ,Rin , Cout,End
. מימוש קווי הבקרה יובא בכיתה.2
5
: ללא החומרה החדשה ביחידת הבקרהRTN נממש את ה.3
Step
T0-T2
T3
T4
T5
T6
T7
T8
T9
T10
T11
T12
Concrete RTN
Fetch
C←5
n←C
C← R[rb]:A← R[rb]
shr(:=(n≠0)→ (C←0#C<31..1>:n←n-1;shr)
shl(:=(n≠0)→ (C←C<30..0>#0:n←n-1;shl))
C←A-C: R[ra]← C
CON←cond(C)
CON→(C←(-1):A←0)
not(CON)→ (end)
CON→ (C←A-C)
R[ra]← C
קווי בקרה
Fetch
BAout , INC5, Cin
Cout , Ld
Cin, Grb ,Rout ,Ain
(n≠0)→(Cout, SHR, Decr, goto6, Cin)
(n≠0)→(Cout, SHL, Decr, goto7, Cin)
Cout , SUB , Cin, Gra ,Rin
CONin,Cout
CON→(NOT, BAout, Ain , Cin)
not(CON)→( END)
(CON)→( Cout , SUB , Cin)
Gra ,Rin , Cout,End
: נחשב את ההאצה של החומרה החדשה.4
T2 − T1
speed _ up =
T1
זמן הפקודה ללא שינוי החומרה- T2 , זמן הפקודה לאחר שינוי החומרה- T1
T1 = 0.9 * (7T ) + 0.1 * (10T + 5T ) = 7.8T
T2 = 0.9 * (11T + 2 * 5T ) + 0.1 * (9T + 2 * 5T ) = 9.9T + 1.9T = 11.8T
T − T 11.8 − 7.8
speed _ up = 2 1 =
= 0.57
T1
7.8
6
מרצה :דר משה שוורץ
מתרגל :חורש בן שטרית
תרגול 2-Bus ,3-Bus : VIII
נושאי התרגול
2-Bus, 3-Bus .1
Speed-up .2
תרגיל -פקודת : Mult
תכנן פקודה חדשהmult ra,rb,rc :
]Abstract RTN: R[ra]←R[rb]*R[rc
נתון . 0≤R[rc]≤31
א .כתוב קווי בקרה ו Concrete RTN -עבור ארכיטקטורת .2-BUS
ב .כתוב קווי בקרה ו Concrete RTN -עבור ארכיטקטורת .3-BUS
חשב את ה speed-up -עבור פקודה זו במעבר מ 2-BUS -ל 3-BUS -בהנחה כי . τ 3− BUS = 1.5 ⋅ τ 2− BUS
1
: 2-BUS ארכיטקטורת
.C אין רגיסטר.א
.2- אחד במקום בT ניתן להעביר נתונים מרגיסטר לרגיסטר בצעד.ב
A Bus
B Bus
Rout
Rin
Register
File
Sra
Srb
Gra
Grb
Src
Grc
Condition code
logic
IR
PC
MA
Memory
MD
A
A
B
ALU
2
Shift control
n
: 2-BUS פתרון.א
3
Step
T0
T1
Concrete RTN
MA←PC
MD←M[MA] : PC←PC+4
T2
T3
T4
T5
T6
IR←MD
n←R[rc]
A← R[rb]
R[ra]←0
mult(:=(n≠0)→(R[ra]←R[ra]+A:n←n-1;mult))
קווי בקרה
PCout, C=B, MAin
Read, Wait, PCout , INC4,
PCin
MDout, C=B, IRin
Grc, Rout, Ld
Grb, Rout, C=B, Ain
BAout, C=B, Sra, Rin
(n≠0)→(Gra, Rout, ADD,
Sra, Rin, Decr, goto6)
(n=0)→End
: 3-BUS ארכיטקטורת
. פעולות מקבילות.1
. קריאה מהזיכרון בצעד אחד.2
C Bus
A Bus B Bus
Rin
R(A)out
G(A)ra
G(A)rb
G(A)rc
R(B)out
G(B)ra
G(B)rb
G(B)rc
Register
File
Sra
Srb
Src
Condition code
logic
IR
PC
MA(C)in
MA(B)in
MA
Memory
MD
A
B
ALU
4
Shift control
n
: 2-BUS פתרון.ב
Step
T0
T1
T2
T5
Concrete RTN
MA←PC : MD←M[MA] : PC←PC+4
קווי בקרה
PCout, MA(B)in, INC4,
PCin, Read, Wait
IR←MD
MDout, C=B, IRin
n←R[rc] : R[ra]←0 G(B)rc ,R(B)out, Ld, G(A)rc
,R(A)out , SUB, Sra, Rin,
goto5
mult(:=(n≠0)→(R[ra]←R[ra]+R[rb]:n←n-1;mult))
(n≠0)→(G(A)ra,
R(A)out,G(B)rb, R(B)out,
ADD, Sra, Rin, Decr, goto5)
(n=0)→End
Speedup
.ג
T2− BUS − T3− BUS
⋅ 100
T3− BUS
T = IC ⋅ CPI ⋅ τ
. = זמן ביצועT
.1 = = מספר פקודותIC
. = מספר צעדים לפקודהCPI
. τ 3− BUS = 1.5 ⋅ τ 2− BUS = זמן מחזור של שעוןτ
(6 + (R[rc] + 1)) ⋅ τ − (3 + (R[rc] + 1)) ⋅ 1.5 ⋅ τ
Speedup =
(3 + (R[rc] + 1)) ⋅ 1.5 ⋅ τ
Speedup =
5
מרצה :דר משה שוורץ
מתרגל :חורש בן שטרית
תרגול : IXמחברים
נושאי התרגול
.1מחבר/מחסר טורי
Carry Look Ahead – CLA .2
Full Adder
בלוק Full Adderזוה uהרכיב הבסיסי במחברים ,
מחבר שני ביטים )כולל : ( Carry in
המורכב מהשערים הבאים :
1
מחברים
מחבר/מחסר טורי :
נניח שהשהיית FAהינה 2Δוכן השהיית ה XORבכניסה הינה , 2Δ
מכאן נקבל כי השהיית המערכת הינה ) 2Δ(m + 1כאשר mמייצג את כמות הביטים במספרים.
יתרון המערכת הינו בפשטותה ,אך ברור כי ההשהייה גדלה לינארית עם mולכן ,עבור מספר ביטים
גדול המערכת הינה מאוד איטית.
: Carry Look Ahead
בשיטה זו ננסה לייצר את ה Carryמהר יותר בכדי לבצע חישובים בצורה מקבילית.
ישנם שני פרמטרים חדשים :
– ( Generate ) - G jמקבל 1כאשר נוצר נשא בחיבור הביטים ה G j = x j y j : j
– ( Propagate ) - Pjמקבל 1כאשר יש להעביר נשא שנוצר קודם – להמשך המערכת :
Pj = x j + y j
ניתן לרשום את הנשא בכל שלב בצורה הבאה:
c1 = G0 + P0 c0
c 2 = G1 + P1c1 = G1 + P1G0 + P1 P0 c0
c3 = G2 + P2 G1 + P2 P1G0 + P2 P1 P0 c0
) c 4 = G3 + P3 (G2 + P2 G1 + P2 P1G0 + P2 P1 P0 c0
בכדי לייצר את G j , Pjיש צורך בידיעת ) x j , y jניתן לייצר זאת ב Δאחד(
בנוסף יש צורך בחישוב ) c jהשהייה של ( 2Δ
ולבסוף חישוב מוצא ה ) FAהשהייה של .( 2Δ
מכאן – ניתן לייצר את כל מוצאי המערכת בזמן של 5Δבלבד !
הבעייה הינה שישנה הגבלה לכמות הכניסות עבור השערים ) – ( AND ,ORבעיית . FAN-in
ככלל שערים לוגים בעלי כניסות מרובות הינם איטיים יותר משערים לוגים בעלי כניסות מועטות.
הפתרון הינו ביצוע הררכי של : CLA
2
Carry Look Aheadהיררכי :
במבנה זה נבצע את החישובים בצורה היררכית כך שבכל פעם נבצע חישובים עם כמות מוגבלת של
ביטים
לדוגמה עבור k=2נקבל :
נוסחאות הרמה הראשונה:
c1 = G0 + P0 c0
G0 = G1 + P1G0
1
P0 = P1 P0
1
3
באופן דומה נבנה 2bit-CLAלחיבור שני מספרים בני 8ביטים :
מספר הרמות הינו log k m
{log k m − 1) ⋅ 2Δ ⋅ 2 + 2
T= Δ
= Δ + 2Δ
{ + (1
44
42444
{ 3 last CLA
generate
FA
all CLA
זמן החישב הכולל הינו :
G,P
T = (1 + 4 log k m )Δ
כאן אנו רואים כי התלות של ההשהייה ב mהינה לוגרתמית ולכן יעילה יותר מחיבור טורי ככל
ש mגדול יותר.
4
ניתן להגדיל את kולקבל מערכת יעילה יותר ,לדוגמא עבור k=4בלוק הבסיס נראה כך :
c 4 = G0 + P0 c0
1
1
G0 = G3 + P3G 2 + P3 P2 G1 + P3 P2 P1G0
1
P0 = P3 P2 P1 P0
1
תרגיל :
ברצונך לסכם שני מספרים x,yבני 10ביט כל אחד ,השווה את זמן ההשהייה של השיטות הבאות :
א .מחבר/מחסר טורי
ב .מחבר k=2 , CLA
ג .מחבר k=4 , CLA
פתרון :
א.
מחבר/מחסר טורי:
T = 2Δ(m + 1) = 22Δ
ב .מחבר : k=2 , CLA
דרך - Iנבנה מערכת עבור 16ביט ונאפס את הכניסות : 10-15
T = (1 + 4 log 2 16)Δ = 17Δ
דרך – IIנבנה מערכת עבור 8ביט ונוסיף רק את החומרה עבור 10ביט ,
נקבל במקרה זה:
T = (1 + 4 log 2 8)Δ = 13Δ
ג .מחבר :4 k= , CLA
T = (1 + 4 log 4 16)Δ = 9Δ
5
מרצה :דר משה שוורץ
מתרגל :חורש בן שטרית
תרגול : Xמכפלים
נושאי התרגול
.1מכפל מערך מקבילי
.2מכפל טורי/מקבילי – מספרים לא מסומנים
.3מכפל טורי/מקבילי – מספרים מסומנים
מכפל מערך מקבילי
בדומה לכפל ארוך ) כפי שנלמד בכיתה ד' ( ,לדוגמא:
⎧1 0 1
⎨×
⎩1 1 1
−−−−−−−−−−
1 0 1
⎧
⎪
+⎨ 1 0 1
⎪1 0 1
⎩
−−−−−−−−−−
1 0 0 0 1 1
נממש מכפל טורי מקבילי ,ע"י מספר בלוקים זהים:
בלוק זה הינו הרכיב הבסיסי במכפל טורי מקבילי ,מכפיל בין שני ביטים
הרכיב הינו פשוט ביותר ובעצם מורכב מ FAומשער : AND
1
x
y
pk(in)
cin
cout
x2
pk(out)
0
x1
0
x0
0
y0
0
y1
0
y2
0
p2m – 1
p2m – 2
p2m – 3
p2m – 4
p2
T= Δ
Δ(m − 1) + 2{
mΔ =
{ + 41
424
3 first lebel
and
all
other
T = (6m − 3)Δ
2
levels
p1
: השהיית המערכת
p0
(מקבילי )מספרים לא מסומנים/מכפל טורי
Multiplicand
xm –1
xm –2
x2
x1
Partial product generator
x0
yj
Multiplier digit
m + 1-digit adder
0
2m-digit right shift register, p
, חיבור והזזה של התוצאה הזמנית בכל פעם/מכפל זה מבוסס על הכפלה
3
תרגיל :
⎧1 0 1 1
⎨× = 11 × 6
חשב :
⎩0 1 1 0
נאתחל את הצובר ACC -ב 2m ) . 0ביטים(
⎧1 0 1 1
⎨×
⎩0 1 1 0
00 0 0 0
00 0 0 0
PP0
0 0 0 00
0 1 0 1 1
temp
ACC
PP1
temp
0 0 1 0 11 0
01 0 1 1
ACC
PP2
1 0 0 0 01 0
01 0 0 00 1 0
00 0 0 0
temp
ACC
PP3
01 0 1 10
1 0 0 00 1 0
0 1 0 00 0 1 0
temp
ACC
אכן התקבלה תוצאה סופית נכונה )(66
⎛
⎞
= ⎟m
(
)
T =⎜Δ
+
2
Δ
m
+
1
⎟3
⎜ pp{j 1424
השהיית המערכת:
addition
⎝
⎠
T = 2m 2 + 3 Δ
)
(
4
מכפל טורי/מקבילי )מספרים מסומנים(
m -bit multiplicand
register
m -bit multiplier
shift register
0
Subtract
Carry
in
m + 1-bit
2’s complement
adder
m – 1 bits
Sign
extension
2m -bit accumulator
shift register
החישוב מתבצע באופן דומה למכפל למספרים לא מסומנים ,מלבד העובדות שינו הרחבת זימן
למספרים ובנוסף הביט האחרון מוחסר ולא מחובר.
תרגיל :
⎨⎧× = )(− 3) × (− 1
1 0 1
חשב :
⎩1 1 1
⎧1 0 1
⎨×
⎩1 1 1
11 0 1
11 0 1
11 1 0 1
11 0 1
11 0 1 1 1
1 1 0 11 1
00 1 1
10 0 0 0 1 1
0 0 0 01 1
PP0
temp
ACC
PP1
temp
ACC
PP2
temp
ללא הזזה
ACC
את הביט האחרון מקבלים תוך משלים לשניים והרחבת סימן
נבצע חיבור בין ACC + PP2ונקבל את התוצאה (− 3) × (− 1) = 3 :
5
תרגיל :
⎧0. 1 1 0
⎞⎛ 3⎞ ⎛ 5
⎨× = ⎟ ⎜ ⎟ × ⎜ −בשתי בתצורות ) שני סדרי האיברים(
חשב :
⎠⎝ 4⎠ ⎝ 8
⎩1. 0 1 1
מספר חיובי כפול מספר שלילי:
⎧0. 1 1 0
⎨×
⎩1. 0 1 1
0 0. 1 1 0
0 0. 1 1 0
0 0. 0 1 1 0
0 0. 1 1 0
0 1. 0 0 1 0
0 0. 1 0 0 1 0
0 0. 0 0 0
0 0. 1 0 0 1 0
0 0. 0 1 0 0 1 0
1 1. 0 1 0
PP0
temp
ACC
PP1
temp
ACC
PP2
temp
ACC
PP3
1 1. 1 0 0 0 1 0
1 1. 1 0 0 0 1 0
מספר שלילי כפול מספר חיובי:
1
.
0
1
1
⎧
⎨×
⎩0. 1 1 0
= temp
ללא הזזה
ACC
0 0. 0 0 0
0 0. 0 0 0
PP0
0 0 0 00
1 1. 0 1 1
1 1. 0 1 1 0
1 1. 1 0 1 1 0
1 1. 0 1 1
temp
ACC
PP1
temp
ACC
PP2
1 1. 0 0 0 1 0
temp
ACC
PP3
1 1. 1 0 0 0 1 0
1 1. 1 0 0 0 1 0
= temp
ללא הזזה
ACC
1 1. 1 0 0 0 1 0
0 0. 0 0 0
6
מרצה :דר משה שוורץ
מתרגל :חורש בן שטרית
תרגול : XIמחלקים ונקודה צפה
נושאי התרגול
.1מחלק שלמים
.2מחלק שברים
.3נקודה צפה
תכנות חלוקת שלמים
נעסוק בחלוקה של שני מספרים חלוקה של המחולק ) (Dבמחלק ) , (dישנן שתי תוצאות :תוצאת
החלוקה והשארית.
כאשר מחלקים מחולק בן 2mביטים במחלק בעל mביטים ,לא תמיד מקבלים תוצאה ושארית בני
mביטים כ"א .הדוגמא הטובה ביותר הינה חלוקה ב. "1"-
Dividend left shift register
Load
0
Divisor register
Subtractor
Positive
result
Quotient left shift register
1
אלגוריתם חלוקת שלמים:
.1
.2
.3
.4
.5
שים את המחולק בחצי התחתון )הימני( של רגיסטר המחולק .שים את במחלק ברגיסטר
המחלק.אפס את התוצאה ואת ביט הסופר.
הזז את רגיסטר המחולק הזזה אחת שמאלה.
אם תוצאת החיסור חיובית ,הכנס " "1לרגיסטר התוצאה והחלף את החצי השמאלי )
העליון( של המחולק בהפרש.
אם תוצאת החיסור שלילית הכנס " "0לתוך התוצאה.
אם נכנסו פחות מ mביטים לתוצאת החילוק ,חזור ל.2
mהביטים ברגיסטר תוצאת החילוק – הם תוצאת החילוק .
mהביטים בחצי השמאלי של המחולק – הם השארית .
תרגיל :
⎧1 0 1 0 1
⎨ 21 / 6 = /
חשב :
⎩0 0 1 1 0
התוצאה הינה 3ושארית .3
0 0 0 0 01 0 1 0 1
0 0 1 1 0
q=0
0 0 0 0 10 1 0 1
0 0 1 1 0
q = 00
0 0 0 1 01 0 1
0 0 1 1 0
q = 000
0 0 1 0 10 1
0 0 1 1 0
q = 0001
0 1 0 1 01
0 0 1 1 0
0 0 1 0 01
q = 00011
0 1 0 0 1
0 0 1 1 0
0 0 0 1 1
אכן התקבלה תוצאה סופית נכונה :תוצאה 3ושארית : 3
D
d
)diff (−
D
d
)diff (−
D
d
)diff (−
D
d
)diff (−
D
d
) diff (+
D
d
) diff (+
q⋅d + r = D
3 ⋅ 6 + 3 = 21
2
אלגוריתם חלוקת שברים:
.1
.2
.3
.4
.5
.6
שים את המחולק בחצי העליון )השמאלי( של רגיסטר המחולק .שים את במחלק ברגיסטר
המחלק.אפס את התוצאה ואת ביט הסופר.
אם תוצאת החיסור חיובית ,הגדר גלישת חילוק!
הזז את רגיסטר המחולק הזזה אחת שמאלה.
אם תוצאת החיסור חיובית ,הכנס " "1לרגיסטר התוצאה והחלף את החצי השמאלי )
העליון( של המחולק בהפרש.
אם תוצאת החיסור שלילית הכנס " "0לתוך התוצאה.
אם נכנסו פחות מ mביטים לתוצאת החילוק ,חזור ל.3
mהביטים ברגיסטר תוצאת החילוק– הם תוצאת החילוק )מנה( .הנקודה נמצאת משמאל.
quotient
2m
re min der
mהביטים בחצי השמאלי של המחולק – הם השארית .
2 2m
תרגיל :
⎧0. 1 1 0
3 7
⎨/ = /
חשב :
4 8
⎩ 0. 1 1 1
התוצאה הינה 3ושארית .3
אין גלישה משום שההפרש שלילי.
q=0
0. 1 1 0 0 0 0
0. 1 1 1
D
d
)diff ( −
D
q = 0.1
1. 1 0 0 0 0
0. 1 1 1
0. 1 0 1 0 0
q = 0.11
1. 0 1 0 0
0. 1 1 1
0. 0 1 1 0
) diff ( +
q = 0.110
0. 1 1 0
D
0. 1 1 1
d
d
) diff ( +
D
d
)diff ( −
3
= 0. 0 0 0 1 1 0
חישוב השארית הינו :
1
424
3
32
m bits
3
תוצאת החילוק:
4
= q = 0.110
q⋅d + r = D
אכן התקבלה תוצאה סופית נכונה 3 7 3 21 3 24 3 :
⋅ +
=
+
=
=
4 8 32 32 32 32 4
3
נקודה צפה Floating point -
לפי תקן . e = eˆ − 127 : IEEE
בכדי לחשב ערך של מספר ,נבצע את החישוב :
num = (− 1) ⋅ f ⋅ 2 e
S
בבסיס לינארי ישנם שני יצוגים :מספרים מנורמלים /לא מנורמלים .
L4
1.10101
0101
14
42
4
במספר מנורמל :המנטיסה מתחילה ב 1.ונקבל 3
23 bits
0.10101
0101
L4
14
42
4
במספר לא מנורמל :המנטיסה מתחילה ב 0.ונקבל 3
23 bits
אין צורך לרשום את האפס/אחד משמאל לנקודה ,משום שאנו יוצאים מנקודת הנחה שהמספרים מנורמלים).
למעט eˆ = 0
בכדי לדעת את סימן התוצאה במהלך חישובים בין שני מספרים ,נשווה תחילה את האקספוננטים ,אם הם לא
שווים נוכל לדעת את התשובה בוודאות .אם הם שווים נתבונן במנטיסות של המספרים.
תרגיל :
חשב 1.011 ⋅ 2 − 1.001 ⋅ 2 = ? :
Normalize and round
⎧1.101 0 ⋅ 2 2
=
⎨−
2
⎩0.0001 ⋅ 2
2
3
1.1011 ⋅ 2 2
Alignment
⎧1.0110 ⋅ 2 3
=
⎨−
3
⎩0.1001 ⋅ 2
Operands
⎧1.011 ⋅ 2 3
⎨−
2
⎩1.001 ⋅ 2
0.1101 ⋅ 2 3
התוצאה 1.101 ⋅ 2 2 :
4
: חומרה למימוש חיבור וחיסור בנקודה צפה
e1
e2
f1
me
me
f2
mf
Exponent
Sub t r ac t er
mf
Swap
mf
sig n
|e 1 -e 2 |
A lig nm ent
Sh if t er
me
m f + rounding bit s
mf
sub t r ac t
s1
s2
Sig n
Comput at ion
Sig nif ic and
A d der/ sub t r act er
sig n
FA/ FS
e1
e2
me
me
Se lec t
mz
me
m f + rounding bit s
Lead zeros
Count er
No r m aliz e
and Round
Sub t ract
and bias
mf
me
sr
5
êr
fr
תרגיל :
תן טבלאת אמת ומימושו של קו . Subtract
פתרון
שער XORעל הכניסות S1, S2, FA/FS :
תרגיל :
נתון שהקו signשיוצא מ significant adder/subtractorהתקלקל ,כתוצאה מכך המוצא מקבל 0/1
בצורה אקראית .
.1כיצד התקלה תשפיע על תפקוד המערכת?
.2הצע תיקון פשוט כך שברוב המקרים המערכת תעבוד כיאות.
פתרון ינתן בכיתה...
6
מרצה :דר משה שוורץ
מתרגל :חורש בן שטרית
תרגול : XIIזיכרון מטמון
נושאי התרגול
.1זיכרון מטמון
מבוא
אחד מצווארי הבקבוק בעבודה של מעבדים הינו נושא פנייה לזכרון הראשי .
הפנייה לזכרון הראשי עורכת זמן רב ומאיטה את ביצועי המערכת.
בנוסף רוב הזמן אנו עובדים עם מידע "לוקאלי" ,נתונים שבאים אחד אחרי השני או בקרבת מקום
אחד לשני.
זיכרון מטמון ) (Cacheנוצר בכדי לקצר את זמן ההשהייה בעבודה עם נתונים מהזכרון הראשי.
גודל זיכרון המטמון קטן יותר ,וזמן הפניה קצר יותר מאשר לזכרון הראשי.
הזכרון בנוי בצורה ההררכית – כאשר תוכנית פונה לזיכרון ,תחילה נחפש את הנתון בזכרון המטמון .
במידה והנתון נמצא בזכרון המטמון ) ( HITנעבוד איתו ,אחרת יש צורך להביאו מהזכרון הראשי
) . ( MISS
– Valid Bitבכדי לדעת האם הנתונים בזכרון המטמון מעודכנים )בתחילה ישנם ביטים אקראיים(
נחזיק ביט עבור כל בלוק בזכרון המטמון שיגדיר האם בלוק זה מעודכן או לא ) .סה"כ נחזיק ביטים
ככמות הבלוקים(
דוגמא :
נניח שכל בלוק מכיל 128מילים בנות 32ביט כ"א .נניח שגודל ה cacheהינו 4בלוקים .במקרה זה
יהיו 4ביטים שיוגדרו valid bitsויעודכנו כל פעם שנביא נתונים מהזיכרון הראשי לזכרון המטמון.
זמני ריצה אופייניים :
לצורך הדיון והשוואה של ביצועים נשתמש בהנחות הבאות:
⎧CPU ⇔ Cache = 0.1T
⎨ word
⎩CPU ⇔ memory = 1T
block {memory ⇔ Cache = 10T
1
פגיעה HIT
קריאה :
זמן ביצוע 0.1T
כתיבה :
כאשר אנו כותבים לזכרון המטמון ,הוא כבר לא מכיל את אותם הנתונים כמו הזכרון הראשי ולכן
יש צורך לבצע עידכון ,ישנן שתי שיטות בעבודה במצב של : HIT
:Write Backבשיטה זו נכתוב את השינוי רק ב cacheולא בזכרון הראשי ,לפני ביצוע החלפה של
בלוק זה בבלוק אחר מהזיכרון הראשי נעדכן את הזיכרון הראשי .לצורך מימוש עבודה בשיטה זו יש
צורך ב dirty bitעבור כל בלוק בכדי לדעת האם הוא השתנה או לא.
זמן ביצוע HITבמקרה זה הינו 0.1T
: Write Throughבשיטה זו נכתוב את השינוי גם ב cacheוגם בזכרון הראשי .לכן אין צורך
במנגנון המתריע על שינוי בין הזיכרון הראשי לזכרון המטמון משום שהם מעודכנים יחד.
בשיטה זו לא נרוויח את ביצועי הזכרון .
זמן ביצוע HITבמקרה זה הינו T
החטאה MISS
קריאה :
בזמן קריאה במקרה של Missישנן שתי אפשרויות:
:Reread
בשיטה זו – במקרה של החטאה ,נביא את כל הבלוק לתוך זיכרון המטמון .ולאחר מכן נבצע קריאה
מחדש ) כמובן עכשיו תהייה פגיעה(
זמן ביצוע ( miss+hit ) 10.1T
:No Reread
בשיטה זו – במקרה של החטאה ,נביא את כל הבלוק מהזיכרון הראשי לזיכרון המטמון .
אך בניגוד שליטה הקודמת ) - ( Rereadנביא את המילה ל CPUמיד עם הגעתה ל cacheואז
נשלים את הבאת כל הבלוק לתוך זיכרון המטמון .
זמן ביצוע במקרה הגרוע ( Main-> Cache , Cache -> CPU ) 10.1T :
במקרה הממוצע זמן הביצוע יהיה מהיר יותר – לצורך חישוב מהו הזמן המדוייק יש צורך בנתונים
נוספים.
במקרה של שאלה בבחינה – ) אלא אם כן נאמר אחרת( – יש לקחת את הזמן הגרוע קרי . 10.1T
: Read Throughבשיטה זו נקרא את הנתון ישירות מהזיכרון הראשי
זמן ביצוע - 1Tבשיטה זו לא נרוויח את ביצועי הזכרון .
) שיטה זו לא הובאה בתרגול( .
2
החטאה – MISSהמשך
כתיבה :
בזמן כתיבה במקרה של Missנדבר על שתי אפשרויות:
:Write allocate
בשיטה זו – במקרה של החטאה ,נביא את הבלוק מהזכרון הראשי לזיכרון מטמון ,לאחר מכן נכתוב
לזיכרון מטמון ונעדכן את ה – dirty bitכמו ב . write back
זמן ביצוע ( miss+hit ) 10.1T
זמן ביצוע + miss+hit ) 20.1Tאם דרסנו ( dirty bit ==1
:Write no allocate
בשיטה זו – במקרה של החטאה ,לא נביא את הבלוק מהזכרון הראשי לזיכרון מטמון,אלא נכתוב
ישר לזיכרון הראשי כמו . write throughזמן ביצוע T
3
מדיניות החלפת בלוקים
כאשר זיכרון המטמון מלא ,ואנו מעוניינים בהבאת בלוק חדש – יש צורך בהחלפת אחד הבלוקים
הקודמים.
:LRU – Least recently used
בשיטה זו –הבלוק שיוחלף הינו הבלוק שלא היה בו שימוש )הזמן הארוך ביותר לעומת האחרים( .
על מנת לממש שיטה זו יש להחזיק מונה עבור כל אחד מהבלוקים ב , cacheאשר יקודם ב 1בכל זמן
נתון וכאשר תתבצע פנייה מהזיכרון – המונה יאופס.
במקרה זה נחליף את הבלוק עם המונה הגדול ביותר.
:FIFO – first in first out
בשיטה זו –הבלוק שיוחלף הינו הבלוק הראשון שנכנס לזיכרון ,ניתן למימוש בקלות על ידי תור.
:Random
הבלוק שמוחלף נבחר אקראית ע"י המערכת.
תרגיל:
נתןן מערך בזיכרון הראשי המכיל 9בלוקים .כל בלוק מכיל 128מילים .המערך מתחיל בכתובת 0
בזיכרון .זיכרון מטמון הינו בגודל 4בלוקים .
זמני גישה :
⎧CPU ⇔ Cache = 0.1T
⎨ word
⎩CPU ⇔ memory = 1T
block {memory ⇔ Cache = 10T
נתונה התוכנית הבאה:
1151
)] R[32] ← ∑ (M [4i ]and M [4604 − 4i
i =0
חשב את ההבדלים בביצוע התוכנית עם ובלי cacheוגם Tavעבור מדיניות החלפה :
LRU
א(
FIFO
ב(
4
:פתרון
מילים ולכן קטע זיכרון זה מכיל9 × 128 = 1152 בלוקים ישנם9 ב, תאי זיכרון4 כל מילה הינה
. תאי זיכרון1152 × 4 = 4608
: LRU במדיניותcache א( מהלך הפעולות בזיכרון
Block1
Block2
Block3
Block4
Miss
Hit
1
0
?
?
?
1
0
2
0
8
?
?
1
2*127
H R = Hit
3
0
8
1
?
1
0
4
0
8
1
7
1
2*127
5
2
8
1
7
1
0
6
2
6
1
7
1
2*127
7
2
6
3
7
1
0
8
2
6
3
5
1
2*127
9
4
6
3
5
1
127+
128+
2*128
10
4
2
3
5
1
0
11
6
2
3
5
1
2*127
12
6
2
1
5
1
0
13
6
2
1
7
1
2*127
14
0
2
1
7
1
0
15
0
8
1
7
1
2*127
hits
= 1− M R
total requests
+ Tav _ write ⋅ Pwrite
Ratio =
Tav = Tav _ read ⋅ Pread
Tav _ read = H R ⋅ 0.1T + M R ⋅ 10.1T
speed _ up =
T
Tav
:( LRU ) בתרגיל זה
15
= 0.993
2 ⋅ 1152
= 0.993 ⋅ 0.1T + 0.007 ⋅ 10.1T = 0.17T
HR = 1− M R = 1−
Tav _ read
speed _ up =
T
= 5.88
0.17T
: FIFO במדיניותcache ב( מהלך הפעולות בזיכרון
1
0
?
?
?
1
0
Block1
Block2
Block3
Block4
Miss
Hit
2
0
8
?
?
1
2*127
3
0
8
1
?
1
0
4
0
8
1
7
1
2*127
5
2
8
1
7
1
0
6
2
6
1
7
1
2*127
7
2
6
3
7
1
0
8
2
6
3
5
1
2*127
9
4
6
3
5
1
127+
128+
2*128
10
4
2
3
5
1
0
11
4
2
6
5
1
2*127
.. ' וקיבלנו פתרון זהה לסעיף אH R = 1 − M R = 1 −
5
12
4
2
6
7
1
0
13
1
2
6
7
1
2*127
14
1
8
6
7
1
0
15
= 0.993
2 ⋅ 1152
15
1
8
0
7
1
2*127
© Copyright 2024