1. 1 הקדמה מה נלמד ? כיצד מחשב בנוי. כיצד לנתח ביצועי מחשב. נושאים המשפיעים על מעבדים חדשים (cache, pipeline ) הספר המלווה Computer Organization & Design The hardware/software interface, David A. Patterson and John L. Hennsy. Second Edition 1998 http://www.cs.tau.ac.il/~natali/CS02a.html natali@cs.tau.ac.il

2. 2 שפת מכונה שפת מכונה - הפקודות שהמחשב מכיר. אסמבלי - נוח יותר לקריאה. - אבסטרקציה. - מעבר חד חד ערכי משפת המכונה. שפת C - נוח יותר לתיכנות. - לא מעבר חד חד ערכי. - תלוי קומפיילר ואופטימיזציה - Portable מתי מתכנתים באסמבלי ? דומה יותר לאנגלית רגילה. ( אפשר להתאים השפה לעיבוד שהיא אמורה לבצע.) פרודקטיביות גבוהה : במשפט אחד מגדירים הרבה חישובים שהמכונה נדרשת לעשות. והכי חשוב : לא תלוי במחשב !!! דומה לאנגלית רגילה. תלויה במחשב. לכל מחשב פקודות Assembly שונות. לכל מחשב יש רגיסטרים אחרים, פקודות אחרות וכו ’. כיום מתכנתים בשפת אסמבלי רק כשמוכרחים : * כאשר הזמן הוא קריטי וצריך לבצע אופטימיזציה “ ידנית ” של הקוד * כאשר צריך להשתמש בכל המשאבים של המחשב שאי אפשר לנצלם ע ” י שפה עילית, כמו למשל, בדיקת overflow או שימוש ב - index register וכו ’ * כאשר הזיכרון הוא קריטי וצריך אופטימיזציה של ניהול הזיכרון ( בעיקר במחשבים מיוחדים כמו DSPs)

3. 3 Instruction Set Architecture יש דמיון רב בין שפות המכונה השונות אנו נלמד את שפת המכונה של מעבד ה- MIPS שפותח בתחילת שנות ה- 80 ( משתמשים בו ב- Silicon Graphics,NEC,Sony ). RISC v. CISC –Reduced Instruction Set Computer - MIPS –8086 - Complex Instruction Set Computer המוטו “ פחות זה יותר “ כלומר : סט פקודות קטן יותר, כאשר הפקודות עצמן פשוטות יותר, מאפשר ביצועים טובים יותר. זאת היות והחומרה הדרושה לביצוע הפקודות הנ ” ל תהיה פשוטה יותר המהירות תגדל ושטח הסיליקון הדרוש (= המחיר ) יצטמצם.

4. 4 כלל תכנון מספר 1: Simplicity favors Regularity פעולות אריתמטיות MIPS addi a,b,100 # a=b+100 add a,b,c # a=b+c 8086 ADD EAX,B # EAX= EAX+B אנו מעדיפים מנגנון פשוט עם פקודות מינימליות כמו R3 = R1 op R2 על מחשב שקל יותר לתכנות עם כמה משתנים שרוצים בפקודה למשל ( R5 = ( R1 op1 R2) op2 (R3 op3 R4 אבל קשה מאוד לתכנן ולממש אותו.

5. 5 כלל תכנון מס’ 2: Smaller is faster נאפשר פעולות אריתמטיות רק על רגיסטרים. האופרנדים יכולים להיות רגיסטר או קבוע (אחד). סה”כ יש 32 רגיסטרים. spilling רגיסטר word = 32 bits = 4 bytes קונבנציות $1,$2 … $s0,$s1... - C משתנים של $t1,$t2 … - משתנים זמניים דוגמא: f=(g+h)-(k+j) #$s0=f, $s1=g, $s2=h, $s3=k, $s4=j add $t0,$s1,$s2 add $t1,$s3,$s4 sub $s0, $t0, $t1 הרגיסטרים מסומנים ע ” י $. או $ 31 - $0 או ע ” י שמות הקשורים לתפקידיהם בתכנית. יש הסכמה על תפקידי הרגיסטרים הנ ” ל בכל התכניות בשפת C למשל.. הדוגצא מתארת איך המשפט ( f=(g+h)-(k+j מיוצג ע ” י פקודות אסמבלי. הרגיסטרים הם ליבו של הפרוססור. הגישה אליהם מהירה מלזיכרון. נגשים, בוזמנית ” ל - 3 רגיסטרים : מ - 2 קוראים ולשלישי כותבים.. עמ ’ 110

6. 6 Policy of Use Conventions רגיסטרים נוספים הם at = $1 $ השמור לאסמבלר ו - k0, $ k1 = $ 26, $ 27 $ השמורים למערכת ההפעלה

7. 7 הזיכרון הזיכרון - מערך גדול. כתובת לזיכרון - אינדקס למערך. Byte addressing - האינדקס בבתים. גודל הזיכרון המכסימלי 2 30 words = 2 32 bytes 0 1 2 3 4 5 6... 8 bits of data

8. 8 פניה לזיכרון פקודות Load and Store טוענים מילה אבל הכתובת בזיכרון היא בבתים - LW lw $s1,100($s2) # $s1=Memory[$s2+100] sw $s1,100($s2) # Memory[$s2+100]=$s1 דוגמא נוספת : save - מערך של Word muli $9,$19,4 # Temporary reg $9:=i*4 lw $8,save($9) # Temporary reg $8:=save[i] מקום במערך = offset מצביע למערך = base register מקום במערך = offset

9. 9 קריאה של byte ישנם גם פקודות כמו (lb (load byte ו - (sb(store byte שימושי לקריאת char: גודל byte ב - ASCII American Standard Code For information Interchange ב - Unicode - גודל char הוא 2 בתים.

10. 10 ASCII

11. 11 גישה לזיכרון דוגמא: A מערך של words כתובת A ב- s3 $ h נמצא ב-s2 $ C code: A[2] = h + A[2]; MIPS code: lw $t0, 8($s3) # $t0=$s3[8] add $t0, $s2,$t0 # $t0=$s2+$t0 sw $t0, 8($s3) # $s3[8]=$t0 0 4 8 12 16 32 bits of data A A[0] A[1] INTEL = Little endian A[2] MIPS = Big endian 013 0123 2

12. 12 הפקודות ב- MIPS בגודל זהה של 32 ביט. ב - 8086 - פקודות בגודל משתנה מ-1 עד ל-17 בתים. : דוגמא add $s1,$s2,$s3 # $s1=$17,$s2=$18, $s3=$19 פורמט הפקודה מסוג R-type 0 31 3201719180 000000 10010100111000100000100000 op rs rt rdshamtfunct op - opecoders - register source rt- register source no 2rd - register destination funct - function shamt - shift amount שפת המכונה 655556655556

13. 13 צמצום מספר סוגי הפקודות השונים. דמיון בין הפקודות. Example: lw $s1, 32($s2) # $s1 =$17, $s2=18 35 18 17 32 op rs rt 16 bit number כלל תכנון מס’ 3 : תכנון טוב דורש לעיתים פשרות op rs rt rdshamtfunct op rs rt 16 bit address op 26 bit address RIJRIJ 655556655556 6 5 5 5 5 6

14. 14 התוכנית נשמרת בזיכרון בדיוק כמו נתונים ביצוע תוכנית רגיסטר מיוחד PC - Program Counter שומר את כתובת הפקודה. קוראים מילה שלמה מהזיכרון. מקדמים את ה - PC. ProcessorMemory memory for data, programs, compilers, editors, etc. התוכנית בזיכרון

15. 15 Jump - קפיצה “ אבסולוטית ” ללא תנאים j label Branch - קפיצה יחסית מותנת bne $1,$2,label# $1!=$2 go to label Example: if (i!=j) beq $s4, $s5, Lab1 h=i+j;add $s3, $s4, $s5 else j Lab2 h=i-j;Lab1:sub $s3, $s4, $s5 Lab2:... Branch vs Jump ($s3=h $s4 =i $s5=j )

16. 16 Instructions: bne $t4,$t5,Label Next instruction is at Label if $t4!= $t5 beq $t4,$t5,Label Next instruction is at Label if $t4 = $t5 j Label Next instruction is at Label Formats: מכאן branch - קפיצה יחסית בגבולות 16^2 מילים. הנחה: רוב ה- branches יהיו קפיצות לוקאליות. Beq $s1,$s2,25 # if ($s1 ==$s2) go to PC +4 +25*4 op rs rt 16 bit address op 26 bit address IJIJ Addresses in Branches and Jumps

17. 17 דוגמא לקידוד

18. 18 כלל שחשוב לזכור : מקודדים MIPS באסמבלי של כתובת code במילים כתובת data בבתים ניגש לזיכרון הוא מבקש את הכתובת בבתים MIPS כאשר מעבד

19. 19 Slt- set less then if $s1 < $s2 then $t0 = 1 slt $t0, $s1, $s2 else $t0 = 0 ניתן לבנות את blt: Blt –branch less then blt $s0,$s1, Less slt $at,$s0,$s1 # $t0 gets 1 if $s0<$s1 bne $at,$zero, Less # go to Less if $t0 != 0 blt היא Pseudo instruction Assembler uses $at (= $1) for pseudo instructions Branch-if-less-than?

20. 20 דוגמאות נוספות ל- Pseudo instruction bne $8,$21,far_adrs שקול ל - beq $8,$21,nxt j far_adrs nxt: move $t1,$s4 add $t1,$s4,$zero שקול ל -

21. 21 כלל תכנון מס’ 4 : בנה את המקרה השכיח - מהיר הרבה פעולות ארתמטיות מתבצעות עם קבועים קטנים. קבועים גדולים $t0=10101010101010101010101010101010 addi $29, $29, 4 1010101010101010 00000000000000001010101010101010 0000000000000000 lui $t0,1010101010101010 # $t0=2^16*(101010101010101010) 2 ori $t0,$t0,1010101010101010 # $t0=$t0||1010101010101010 $to=1010101010101010101010101010… לכן הוקצו פקודות מיוחדות לחיבור חיסור והשוואה של קבועים קטנים : addi, slti, andi, ori, xori נחשב ב - 2 פקודות, כלומר לאט יותר, אבל נדרשת רק פקודה אחת נוספת : lui

22. 22 לסיכום

23. 23 RISC v. CISC I - מספר פקודות בתוכנית T– הזמן לביצוע פקודה RISC: I * T CISC: I * T

24. 24 תרגיל שאלה 1: לפניך קוד הכתוב ב-C, ושני תרגומים שלו לשפת האסמבלי של MIPS: while (save[i]!=k) do i=i+j ; save:array [ 0..100] of word $19 מתפקד כ-i, $20 כ-j ו-$21 כ-k. $19 תרגום ראשון: Loop: muli $9,$19,4 # Temporary reg $9:=i*4 lw $8,save($9) # Temporary reg $8:=save[i] bne $8,$21,Exit # Goto Exit if save[i]<>k add $19,$19,$20 # i:=i+j j Loop # Goto Loop Exit:

25. 25 המשך תרגיל תרגום שני: muli $9,$19,4# Temporary reg $9:=i*4 lw $8,save($9)# Temporary reg $8:=save[i] bne $8,$21,Exit# Goto Exit if save[i]<>k Loop: add $19,$19,$20# i:=i+j muli $9,$19,4# Temporary reg $9:=i*4 lw $8,save($9)# Temporary reg $8:=save[i] beq $8,$21,Loop# Goto Loop if save[i]=k Exit: שאלה: בהנחה שהלולאה מתבצעת 10 פעמים, מה מספר הפקודות שמתבצעות בכל אחד מהתרגומים?

26. 26 Compiler A.asm B.asm compiler A.obj B.obj linker C.lib (c.obj) P.exe loader Memory

27. 27 תהליך הקומפילציה

28. 28 דוגמא B.asm compiler A.obj B.obj s:.word 3,4 j k lw $1,s ($2) k: add $1,$2,$3 m:.word 2 sw 7, m($3) A.asm 3 4 j 2 lw $1,0($2) add $1,$2,$3 2 sw $7,0($3) 2 3 4 sw $7,0($3) j 3 lw $1,4($2) add $1,$2,$3 linker P.exe

29. 29 קובץ Object ב- Unix Object file header text segment data segment relocation information symbol table debugging information

30. 30 מבנה הזיכרון במחשב MIPS