מבוא למחשבים – חוברת תרגולים

Comments

Transcription

מבוא למחשבים – חוברת תרגולים
‫מרצה‪ :‬דר משה שוורץ‬
‫מתרגל ‪ :‬חורש בן שטרית‬
‫תרגול ‪ : I‬ייצוג מספרים‬
‫נושאי התרגול‬
‫‪ .1‬הגדרות כלליות והנחיות לתרגילי הבית‬
‫‪ .2‬ייצוג מספרים‬
‫הנחיות‬
‫אתר הקורס ‪www.ee.bgu.ac.il/~compintr :‬‬
‫דוא"ל אלקטורני למתרגל‪[email protected] :‬‬
‫בכל פנייה דרך האמייל יש לכתוב ‪ 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