‫ת‪.‬ז‪:.

‬‬

‫פתרון מבוא למערכות מחשב ‪60069‬‬

‫ד"ר אילת בוטמן‪ ,‬ד"ר דני זידנר‪ ,‬ד"ר נסים הראל‪ ,‬מר מוטי רוסו‬

‫סמסטר סתיו‪ ,‬תש"פ‪ ,‬מועד ב'‬

‫תאריך‪17.03.2020 :‬‬

‫הוראות לנבחן‪ :‬בבחינה ‪ 4‬חלקים‪ .‬משקלו של כל חלק ניתן בצמוד אליו‪ .‬החלק הראשון כולל שאלות‬
‫ברירה‪ .‬משקלו של החלק הוא ‪ 48‬נקודות והוא כולל ‪ 12‬שאלות ברירה במשקל ‪ 4‬נקודות כל אחת‪ .‬החלק‬
‫השני כולל שאלה על לוגיקה צירופית‪ .‬משקל החלק הוא ‪ 18‬נקודות‪ .‬החלק השלישי כולל שאלה על ה‪-‬‬
‫‪ datapath‬של ה‪ MIPS-‬ומשקלו ‪ 26‬נקודות‪ .‬החלק הרביעי כולל שאלות באסמבלי של ה‪ MIPS-‬ומשקלן‬
‫הכולל הוא ‪ 18‬נקודות‪.‬‬

‫אין בחירה בין השאלות‪ ,‬אולם סכום הנקודות אותו ניתן לצבור במבחן זה הוא ‪ .110‬הציון המקסימלי אותו‬
‫ניתן לקבל במבחן זה הוא‪( 100 :‬כלומר‪ ,‬סכום נקודות גדול מ‪ 100-‬יחשב כ‪.)100-‬‬

‫יש לענות בטופס הבחינה על כל החלקים במקום המיועד לכך‪ .‬יש לציין מספר תעודת זהות על טופס‬
‫הבחינה ולצרף אותו למחברת הבחינה‪ .‬מחברת הבחינה לא תיבדק‪.‬‬

‫משך הבחינה‪ :‬שלש שעות (‪ 3‬שעות)‬

‫חומר עזר‪ :‬דפי נוסחאות מצורפים למבחן ומחשב כיס שאינו ניתן לתכנות‬

‫(משקל‪ 48 :‬נקודות‪ 4 ,‬נקודות לכל שאלה)‬ ‫חלק ראשון – שאלות ברירה‬

‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪1‬‬

‫מי מהמשוואות הבאות אינה נכונה?‬

‫‪A ⊕ B ⊕ C̅ = A‬‬
‫‪̅⊕B‬‬
‫א) ‪̅ ⊕ C‬‬

‫‪A ⊕ B ⊕ C̅ = A‬‬
‫‪̅⊕B‬‬
‫ב) ̅‪̅ ⊕ C‬‬

‫̅̅̅̅̅̅̅̅̅̅̅̅̅̅‬
‫‪A⊕B⊕C= A‬‬ ‫‪̅·B·C+A·B‬‬
‫‪̅ · C + A · B · C̅ + A‬‬
‫‪̅·B‬‬
‫ג) ̅‪̅ · C‬‬

‫̅̅̅̅̅̅̅̅̅̅̅̅̅̅ = ‪̅ ⊕ C‬‬
‫‪A⊕B‬‬ ‫̅̅̅̅̅̅̅̅‬
‫ד) ̅‪A ⊕ B ⊕ C‬‬
 ‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪2‬‬

‫מה יהיה באוגר ‪ $2‬אחרי ביצוע ‪ 2‬הפקודות הבאות‪:‬‬
‫‪lui $2, 0xFFFF‬‬
‫‪addi $2, $2, 0xEEEE‬‬

‫‪0xFFFFEEEE‬‬ ‫א)‬
‫‪0xEEEEFFFF‬‬ ‫ב)‬

‫‪0xFFFEEEEE‬‬ ‫ג)‬
‫‪0x0000EEEE‬‬ ‫ד)‬

‫ברגיסטר ‪ $2‬יהיה הערך‬ ‫‪lui‬‬ ‫‪$2, 0xFFFF‬‬ ‫תשובה‪ :‬אחרי ביצוע הפקודה‬
‫‪.0xFFFF0000‬‬
‫כשנוסיף לו ‪ 0xEEEE‬בעזרת פקודת ה‪ add -‬יבוצע גם ‪ Sign Extension‬ובעצם‬
‫נוסיף ‪ .0xFFFFEEEE‬לכן‪:‬‬

‫‪0xFFFF0000‬‬
‫‪0xFFFFEEEE‬‬
‫========‬
‫‪0xFFFEEEEE‬‬
 ‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪3‬‬

‫מהו ההפרש בין שני המספרים החיוביים (גדולים מ‪ )0-‬הקטנים ביותר שניתן להציג ב‬
‫‪ 1( Single Precision Floating Point‬סיבית סימן‪ 8 ,‬סיביות אקספוננט ו‪ 23 -‬סיביות שבר)‬
‫לבין המספר הבא מעליו?‬

‫‪1·2-126‬‬ ‫א)‬

‫‪1·2-127‬‬ ‫ב)‬
‫‪2-23·2-126‬‬ ‫ג)‬

‫‪2-23·2-127‬‬ ‫ד)‬

‫ג'‬
‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪4‬‬

‫ידוע שהשבר ‪ 1/7‬בבסיס ‪ 3‬ניתן על ידי ‪[0.010212 010212 010212 ... ]3‬‬
‫איך ייראה השבר ‪ 6/7‬בבסיס ‪? 3‬‬

‫א) ‪[0.210211 210211 210211 . . . ]3‬‬

‫ב) ‪[0.212020 212020 212020 . . . ]3‬‬
‫ג) ‪[0.201021 201021 201021 . . . ]3‬‬
‫‪[0.212010 212010 212010 . . . ]3‬‬ ‫ד)‬

‫ד'‬
‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪5‬‬

‫‪ X‬הוא מספר ‪ 2’s complement‬בן ‪ 15‬ביט מהם ‪ 8‬הם מימין לנקודה הבינרית‪.‬‬
‫סיביות ‪ X2 , X3‬ו‪ X-2 -‬הן "‪ ."1‬פירוש הדבר הוא ש‪-‬‬

‫‪31‬‬
‫‪ X‬לא יכול להיות גדול מ ‪15 32 -‬‬ ‫א)‬
‫‪ X‬יכול להיות קטן מ ‪(-60) -‬‬ ‫ב)‬
‫‪1‬‬
‫‪0 < X < 12‬‬ ‫‪ X‬יכול להיות בתחום‬ ‫ג)‬
‫‪8‬‬
‫‪ X‬לא יכול להיות בתחום ‪3 < X < 12‬‬ ‫ד)‬

‫לכן א' – לא נכון‪ ,‬ב' – לא נכון‪ ,‬ג' – לא נכון‪ ,‬ד' – נכון!‬

‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪6‬‬

‫‪:[0.04 004 004 004 ... ]5‬‬ ‫מה ערכו של השבר הבא הניתן בבסיס ‪5‬‬
‫א) ‪4/25‬‬

‫‪5/31‬‬ ‫ב)‬
‫‪8/125‬‬ ‫ג)‬

‫‪1/6‬‬ ‫ד)‬
 ‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪7‬‬

‫ב‪ Latch -‬המצויר משמאל‪:‬‬

‫‪A‬‬ ‫‪Q1‬‬ ‫א) המצב בו "‪ Q1="0", Q2="1‬הינו מצב יציב‬

‫ב) צירוף אדיש בכניסה הוא‪A=B="0" :‬‬

‫ג) צירוף אדיש בכניסה הוא‪A=B="1" :‬‬

‫‪Q2‬‬
‫‪B‬‬ ‫ד) המצב בו "‪ Q1=Q2="1‬הינו מצב יציב‬
 ‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪8‬‬

‫לפניכם שלושה דלגלגים (‪-FF‬ים)‪ ,‬המחוברים בצורת אוגר הזזה (‪ .)Shift Register‬הכניסה‬
‫משמאל (ל‪ )D2-‬מחוברת לשער ‪ ,XOR‬המבצע פעולת ‪ XOR‬בין ‪ Q0‬ל‪.Q1-‬‬
‫הערך ההתחלתי באוגר ההזזה הוא‪ ,[Q2, Q1, Q0] = [1, 0, 1] :‬כמצויר‪ .‬מה יהיה הערך‬
‫באוגר ההזזה לאחר ‪ 3‬עליות שעון?‬

‫‪D2‬‬ ‫”‪Q2=“1‬‬ ‫”‪Q0=“1‬‬

‫‪D‬‬ ‫‪Q‬‬ ‫‪D‬‬ ‫‪Q‬‬ ‫‪D‬‬ ‫‪Q‬‬
‫”‪Q1= “0‬‬

‫‪C‬‬ ‫‪G‬‬
‫‪K‬‬ ‫]‪[Q2,Q1,Q0]=[0,0,0‬‬ ‫א)‬

‫]‪[Q2,Q1,Q0]=[1,1,0‬‬ ‫ב)‬
‫]‪[Q2,Q1,Q0]=[1,0,0‬‬ ‫ג)‬

‫]‪[Q2,Q1,Q0]=[0,1,0‬‬ ‫ד)‬
 ‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪9‬‬

‫לפניכם קטע קוד כתוב באסמבלי של ה‪ .MIPS-‬איזה מבנה מייצג קטע הקוד?‬
‫‪Start:‬‬
‫‪beq‬‬ ‫‪$s3, $s2, Cont‬‬
‫‪sll‬‬ ‫‪$t1, $s3, 2‬‬
‫‪addu‬‬ ‫‪$t1, $t1, $s5‬‬
‫‪lw‬‬ ‫)‪$t1, 0($t1‬‬
‫‪add‬‬ ‫‪$s3, $s3, $s4‬‬
‫‪beq‬‬ ‫‪$0, $s0, Start‬‬
‫‪Cont:‬‬
‫לולאת ‪while‬‬ ‫א)‬
‫לולאת ‪do … while‬‬ ‫ב)‬

‫לולאת ‪for‬‬ ‫ג)‬

‫זו בכלל לא לולאה‬ ‫ד)‬

‫תשובה‪ :‬כאן קודם כל בודקים תנאי ליציאה מהלולאה ולכן זוהי לולואת ‪.while‬‬
 ‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪10‬‬

‫עליכם לציין אלו שלבים מתבצעים במהלך ביצוע הפקודה‪:‬‬
‫‪beq $s1, $s2, 20‬‬

‫‪Fetch, Decode, ALU‬‬ ‫א)‬

‫‪Fetch, Decode, Memory‬‬ ‫ב)‬
‫‪Fetch, Decode, ALU, Memory‬‬ ‫ג)‬
‫‪Fetch, Decode, ALU, Memory, Write-Back‬‬ ‫ד)‬

‫שאלה מספר ‪11‬‬

‫כמה פונקציות לוגיות שונות אפשר לייצר עם ‪ 4‬משתנים (‪ C ,B ,A‬ו‪?)D -‬‬

‫א) ‪42‬‬
‫ב) ‪162‬‬
‫ג) ‪216‬‬
‫ד) ‪44‬‬

‫תשובה‪ :‬ל‪ 4 -‬משתנים יש ‪ 16‬בטויי ‪ .minterm‬במשוואה שמתארת פונקציה לוגית אפשר‬

‫לכן לכלול או לא לכלול ‪-minterm 16‬ים‪ .‬לכן יש ‪ 216‬אפשרויות ליצירת פונקציות שונות‪.‬‬
 ‫ת‪.‬ז‪:.‬‬

‫שאלה מספר ‪12‬‬

‫במחבר ‪ 2’s Comp.‬של ‪ 8‬ביט יש יציאה הנדלקת כאשר יש ‪ .Overflow‬באיזה מהחישובים‬
‫הבאים תידלק יציאה זו?‬

‫‪11100001 + 10001110‬‬ ‫א)‬

‫‪00011000 – 01010101‬‬ ‫ב)‬

‫‪11100000 + 11101110‬‬ ‫ג)‬

‫‪11100000 – 11101110‬‬ ‫ד)‬

 ‫ת‪.‬ז‪:.‬‬

‫(משקל‪ 18 :‬נקודות)‬ ‫חלק שני – שאלות בלוגיקה צירופית‬

‫‪ 11( 13‬נקודות)‬ ‫שאלה מספר‬

‫נתונה הפונקציה הבאה‪:‬‬
‫)‪F ( A, B, C , D) =  m (2,3, 6, 7,9,10,11,15‬‬
‫(‪ 4‬נקודות) ממשו פונקציה זו בעזרת מרבב ‪ )8→1 multiplexer( 8→1‬ושער ‪NOT‬‬ ‫א‪.‬‬
‫אחד כשהמשתנים ‪ A, B‬ו‪ C-‬מחוברים לקווי הבחירה (ה‪)select-‬‬
‫(‪ 7‬נקודות) חברו את המשתנים ‪ D‬ו‪ A-‬לקווי הבחירה (ה‪ )select-‬וממשו פונקציה‬ ‫ב‪.‬‬
‫זו בעזרת מרבב ‪)4→1 multiplexer( 4→1‬‬

‫פתרון‪:‬‬
‫ת‪.‬ז‪:.‬‬
 ‫ת‪.‬ז‪:.‬‬

‫(‪ 6‬נקודות)‬ ‫שאלה מספר ‪14‬‬

‫בנו מעגל‪ ,‬הכופל את המספר ‪ ) [111]2 ( 7‬במספר שלם מטיפוס ‪ unsigned‬בן שלוב ביטים‬
‫‪ ]a2, a1, a0[2‬בעזרת רכיבי ‪ )Adder-Half( HA‬ו‪.)Full-Adder( FA -‬‬

‫פתרון‪:‬‬
 ‫ת‪.‬ז‪:.‬‬

‫(משקל‪ 25 :‬נקודות)‬ ‫חלק שלישי – ה‪ datapath-‬של ה‪MIPS-‬‬

‫שאלה מספר ‪ 26( 15‬נקודות)‬

‫מחשב ה‪ MIPS -‬בתצורת ה‪ Single-Cycle -‬שלמדנו‪ ,‬תומך בפקודת )‪. lw R1,imm(R2‬‬

‫בפקודה זו )‪ )load word‬קוראים מילה מהזיכרן וכותבים אותה לאוגר ‪.R1‬‬

‫הכתובת ממנה קוראים את המילה היא תוכן אוגר ‪ R2‬אליו מוסיפים את הערך שבשדה ה‪-‬‬
‫‪ )immediate( imm‬שהוא מספר של משלים ל‪ 2-‬בעל ‪ 16‬סיביות‪.‬‬

‫כלומר‪:‬‬
‫] )‪GPR[R1] = M[ GPR[R2] + sext(imm‬‬
‫‪ 3( )15.1‬נקודות) מהם השדות בפקודה ותפקידם‪ .‬ציירו את מבנה השדות השונים והסבירו‬
‫את תפקידיהם‪.‬‬

‫‪3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 9 8 7 6 5 4 3 2 1 0‬‬
‫‪1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0‬‬
 ‫ת‪.‬ז‪:.‬‬

‫‪ 8( )15.2‬נקודות) תארו את ביצוע הפקודה על גבי הציור שלהלן‪ .‬סמנו בקו עבה את‬
‫מסלול ה‪ data‬בו משתמשים (סמנו את כל הקוים הפעילים) והסבירו את אותות הבקרה‪.‬‬
‫את אותות הבקרה יש לקבוע לפי המופיע בציור‪.‬‬

‫הסבר (יש מקום גם בעמ' הבא)‪:‬‬

 ‫ת‪.‬ז‪:.‬‬

‫‪ )15.3‬ברצוננו להוסיף פקודה חדשה ל‪ .datapath-‬הפקודה היא ‪( blt‬קיצור של ‪branch less‬‬

‫‪.)than‬‬
‫נ‪blt R1, R2, imm‬‬

‫בפקודה משווים בין תוכן אוגר ‪ R1‬ותוכן אוגר ‪.R2‬‬

‫אם תוכן ‪ R1‬קטן מתוכן ‪ R2‬מוסיפים ל‪ PC+4 -‬את הערך שבשדה ה‪)immediate( imm -‬‬
‫שהוא מספר של משלים ל‪ 2-‬בעל ‪ 16‬סיביות‪ ,‬מוכפל ב‪ .4-‬בכך קופצים )‪ (imm+1‬מילים‬
‫קדימה‪.‬‬
‫אם לא‪ ,‬ה‪ PC -‬יקבל את הערך ‪ , PC+4‬כלומר נמשיך לפקודה הבאה‪.‬‬
‫כלומר‪:‬‬
‫]‪If GPR[R1] < GPR[R2‬‬
‫‪PC=PC+4+sext(imm)*4‬‬
‫‪else‬‬
‫‪PC=PC+4‬‬

‫יש לממש את הפקודה החדשה תחת התנאים הבאים‪:‬‬

‫א) אסור לשנות את ה‪ ALU-‬ואת ה‪.GPR File -‬‬

‫ב) הפקודות של המחשב המקורי )‪ (add, sub, or, and, slt, beq, lw, sw‬תבוצענה‬
‫כהלכה‬

‫ג) יש להוסיף מינימום חומרה‬

‫הפקודה ‪ blt‬תמומש באמצעות פקודה מטיפוס ‪ ,)I-type( I‬כש‪ Rs-‬יהיה האוגר ‪ Rt ,R1‬יהיה‬
‫נאוגר ‪ R2‬וה‪ imm -‬המספר שב ‪ 16‬הסיביות הימניות בפקודה‪ .‬כלומר‪:‬‬

‫‪+-----------+--------+-------+-----------------------------+‬‬
‫|‪| blt opcode‬‬ ‫‪R1‬‬ ‫‪| R2‬‬ ‫|‬ ‫‪imm‬‬ ‫|‬
‫‪+----------_+--------+-------+-----------------------------+‬‬

‫(‪ 5‬נקודות) הסבירו את השנויים שיש לבצע ב‪ CPU -‬במסלול ה‪ Data-‬כדי לתמוך בפקודה‬
‫החדשה‪( .‬כל שנוי – עבור מה נדרש)‪ .‬הוסיפו אותם על הציור והסברו את מטרתם‪:‬‬
‫ת‪.‬ז‪:.‬‬

‫הסבר (יש מקום גם בעמ' הבא)‪:‬‬

 ‫ת‪.‬ז‪:.‬‬

‫‪ 5( )15.4‬נקודות) האם נדרשו אותות בקרה חדשים (הנוספים לאלה של המחשב המקורי)?‬
‫אם כן‪ ,‬פרטו את האותות האלה ואת תפקידיהם‪ .‬רשמו גם קווי בקרה קיימים שהוספתם‬
‫להם תפקידים נוספים‪.‬‬
 ‫ת‪.‬ז‪:.‬‬

‫‪ 5( )15.5‬נקודות) האם ניתן לבצע פקודת ‪ add2i‬המוגדרת כדלקמן‪:‬‬

‫‪add2i R1, R2, imm‬‬ ‫הפקודה‬

‫תבצע‬

‫)‪GPR[R1] = GPR[R1]+ sext(imm‬‬

‫וגם)‪GPR[R2] = GPR[R2]+ sext(imm‬‬

‫כאשר ‪ imm‬הוא מספר ‪ 2’s complement‬של ‪ 16‬סיביות‪.‬‬

‫כלומר חבר לערך שב‪ R1 -‬את ‪ sign extension‬של ה‪ imm -‬ורשום אותו בחזרה ל‪ .R1 -‬וכנ"ל‬
‫ל‪.R2 -‬‬

‫הסבר ‪ -‬אם ניתן לבצע את הפקודה‪ ,‬הסבר כיצד ואם לא הסבר מדוע לא‪:‬‬
‫(יש מקום גם בעמ' הבא)‬
 ‫ת‪.‬ז‪:.‬‬

‫(משקל‪ 18 :‬נקודות)‬ ‫חלק רביעי – אסמבלי של ה‪MIPS-‬‬

‫(‪ 5‬נקודות)‬ ‫שאלה ‪16‬‬

‫תרגם את הפקודה הבאה לשפת מכונה של ה‪:MIPS-‬‬

‫‪beq‬‬ ‫‪$t0, $s2, -12‬‬

‫‪3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 9 8 7 6 5 4 3 2 1 0‬‬
‫‪1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0‬‬

‫(‪ 13‬נקודות)‬ ‫שאלה ‪17‬‬

‫תרגם את קטע ה‪ C -‬הבא לשפת הסף (אסמבלי) של מחשב ‪ .MIPS‬הנח כי כתובת‬
‫ההתחלה של ‪ array‬נמצאת באוגר ‪ .$4‬גודל המערך‪ ,size ,‬נמצא באוגר ‪ $5‬והערך ‪sum‬‬
‫נמצא באוגר ‪ .$6‬המערך הינו מערך של מילים (‪ .)Words=4 bytes‬אוגרים ‪ $4‬ו‪ $5 -‬צריכים‬
‫להשאר ללא שנוי‪.‬‬

‫;‪sum = 0‬‬
‫)‪for (i=0;i<size;i++‬‬
‫{‬
‫) ‪if (array[i] & 1 == 1‬‬
‫;]‪sum += array[i‬‬
‫}‬

‫הערה – מותר להשתמש בפקודות הבאות בלבד‪:‬‬

‫‪add , sub, and, or, xor, slt, addi, ori, lui, beq, bne, j, lw, sw‬‬
 :.‫ז‬.‫ת‬

# definitions:
# $4=Arra[0] ptr, $5=size $6=sum,
# $7=ptr, $8=i, $9=1,
# $10=temp1= data read from array
# $11=temp2= result of cpmarison

# initialize
addi $6, $0, 0 # sum=0;
addi $7, $4, 0 # ptr=array
addi $8, $0, 0 # i=0
addi $9, $0, 1 # $9=1

loop:
beq $8, $5, end # if i=size end the loop
addi $8, $8, 1 # i++
lw $10,0($7) # $10=array[i]
addi $7, $7, 4 # increment array ptr
and $11, $10, $9 # $11 = array[i] & 1
beq $11, $0, loop # if not 1, goto loop
add $6, $6, $10 # else, sum += array[i];
j loop
end:

!‫בהצלחה‬