איפה אנחנו ולאן ממשיכים ??

1. Arithmetic Single/multicycle Datapaths IFetch Dcd Exec Mem WB µProc 60%/yr. (2X/1.5yr) 1000 CPU IFetch Dcd Exec Mem WB “Moore’s Law” IFetch Dcd Exec Mem WB 100 Processor-Memory Performance Gap:(grows 50% / year) IFetch Dcd Exec Mem WB 10 Performance DRAM 9%/yr. (2X/10 yrs) DRAM 1 Pipelining 1980 1982 1984 1987 1988 1989 1990 1991 1993 1996 2000 1981 1983 1985 1986 1992 1994 1995 1997 1998 1999 I/O Time Memory Systems איפה אנחנו ולאן ממשיכים?? מבנה מחשבים 

2. מה נלמד ? • כיצד מחשב בנוי. • כיצד לנתח ביצועי מחשב. • נושאים המשפיעים על מעבדים חדשים (cache, pipeline ) • הספר: • Computer Organization & Design The hardware/software interface, • David A. Patterson and • John L. Hennessy. • Third Edition 2005

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

7. lw $15,0($2) lw $16, 4($2) sw $16, 0($2) sw $15, 4($2) Levels of Representation temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; High Level Language Program Compiler Assembly Language Program Assembler 0000 1001 1100 0110 1010 1111 0101 1000 1010 1111 0101 1000 0000 1001 1100 0110 1100 0110 1010 1111 0101 1000 0000 1001 0101 1000 0000 1001 1100 0110 1010 1111 Machine Language Program Machine Interpretation Control Signal Specification ALUOP[0:3] <= InstReg[9:11] & MASK ° °

8. MIPS Instruction Set Use the MIPS ISA document as the final word on the ISA MIPS ISA document available on Course Web Site.

9. Application (iTunes) Operating Compiler System (Mac OS X) Software Assembler Hardware Processor Memory I/O system Datapath & Control Digital Design “R-Format” Circuit Design Transistors Fieldsize: 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits Bitfield: opcode rs rt rd shamt funct Binary: 01010 01000 100000 000000 01001 00000 Instruction Sets: A Thin Interface Syntax: ADD $8 $9 $10 Semantics: $8 = $9 + $10 Instruction Set Architecture In Hexadecimal:012A4020

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

11. Control Datapath The Big Picture • Since 1946 all computers have had 5 components Processor Input Memory Output

12. Instruction Fetch opcode rs rt rd shamt funct Instruction Decode Decode fields to get : ADD $8 $9 $10 Operand Fetch Execute Result Store Next Instruction Hardware implements semantics ... Syntax: ADD $8 $9 $10 Semantics: $8 = $9 + $10 Fetch next inst from memory:012A4020 “Retrieve” register values: $9 $10 Add $9 to $10 Place this sum in $8 Prepare to fetch instruction that follows the ADD in the program.

13. Instruction Fetch “I-Format” opcode rs rt offset Instruction Decode Decode fields to get : LW $1, 32($2) Operand Fetch Execute Result Store Next Instruction Memory Instructions: LW $1,32($2) Fetch the load inst from memory “Retrieve” register value: $2 Compute memory address: 32 + $2 Load memory address contents into: $1 Prepare to fetch instr that follows the LW in the program. Depending on load semantics, new $1 is visible to that instr, or not until the following instr (”delayed loads”).

14. Instruction Fetch “I-Format” opcode rs rt offset Instruction Decode Decode fields to get: BEQ $1, $2, 25 Operand Fetch Execute Result Store Next Instruction Branch Instructions: BEQ $1,$2,25 Fetch branch inst from memory “Retrieve” register values: $1, $2 Compute if we take branch: $1 == $2 ? ALWAYS prepare to fetch instr that follows the BEQ in the program (”delayed branch”). IF we take branch, the instr we fetch AFTER that instruction is PC + 4 + 100. PC == “Program Counter”

15. Why ISA is important? • Code size • long instructions may take more time to be fetched • Requires larges memory (important in small devices, e.g., cell phones) • Number of instructions (IC) • Reducing IC reduce execution time (assuming same CPI and frequency) • Code “simplicity” • Simple HW implementation which leads to higher frequency and lower power • Code optimization can better be applied to “simple code”

16. The impact of the ISA RISC vs CISC

17. CISC Processors • CISC - Complex Instruction Set Computer • The idea: a high level machine language • Characteristic • Many instruction types, with many addressing modes • Some of the instructions are complex: • Perform complex tasks • Require many cycles • ALU operations directly on memory • Usually uses limited number of registers • Variable length instructions • Common instructions get short codes  save code length • Example: x86

18. CISC Drawbacks • Compilers do not take advantage of the complex instructions and the complex indexing methods • Implement complex instructions and complex addressing modes  complicate the processor  slow down the simple, common instructions  contradict Amdahl’s law corollary: Make The Common Case Fast • Variable length instructions are real pain in the neck: • It is difficult to decode few instructions in parallel • As long as instruction is not decoded, its length is unknown  It is unknown where the instruction ends  It is unknown where the next instruction starts • An instruction may not fit into the “right behavior” of the memory hierarchy (will be discussed next lectures) • Examples: VAX, x86 (!?!)

19. RISC Processors • RISC - Reduced Instruction Set Computer • The idea: simple instructions enable fast hardware • Characteristic • A small instruction set, with only a few instructions formats • Simple instructions • execute simple tasks • require a single cycle (with pipeline) • A few indexing methods • ALU operations on registers only • Memory is accessed using Load and Store instructions only. • Many orthogonal registers • Three address machine: Add dst, src1, src2 • Fixed length instructions • Examples: MIPSTM, SparcTM, AlphaTM, PowerPCTM

20. RISC Processors (Cont.) • Simple architecture  Simple micro-architecture • Simple, small and fast control logic • Simpler to design and validate • Room for on die caches: instruction cache + data cache • Parallelize data and instruction access • Shorten time-to-market • Using a smart compiler • Better pipeline usage • Better register allocation • Existing RISC processor are not “pure” RISC • e.g., support division which takes many cycles

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

22. So, what is better, RISC or CISC • Today CISC architectures (X86) are running as fast as RISC (or even faster) • The main reasons are: • Translates CISC instructions into RISC instructions (ucode) • CISC architecture are using “RISC like engine”

23. כלל תכנון מספר 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 אבל קשה מאוד לתכנן ולממש אותו.

24. כלל תכנון מס’ 2: Smaller is faster • נאפשר פעולות אריתמטיות רק על רגיסטרים. • האופרנדים יכולים להיות רגיסטר או קבוע (אחד). • סה”כ יש 32 רגיסטרים. • רגיסטר 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 למשל. עמ’ 110 הדוגצא מתארת איך המשפט ( f=(g+h)-(k+j מיוצג ע”י פקודות אסמבלי. הרגיסטרים הם ליבו של הפרוססור. הגישה אליהם מהירה מלזיכרון. נגשים ,בוזמנית” ל-3 רגיסטרים: מ-2 קוראים ולשלישי כותבים. .

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

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

27. פניה לזיכרון • פקודות 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 מצביע למערך = base register מקום במערך = offset

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

29. גישה לזיכרון MIPS = Big endian • דוגמא: 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 A 0 4 8 12 16 32 bits of data A[0] 0 1 2 3 A[1] A[2] INTEL = Little endian 3 2 1 0

30. שפת המכונה • הפקודות ב- MIPS בגודל זהה של 32 ביט. • ב - 8086 - פקודות בגודל משתנה מ-1 עד ל-17 בתים. :דוגמא add $s1,$s2,$s3 # $s1=$17,$s2=$18, $s3=$19 פורמט הפקודה מסוג R-type 0 31 32 0 17 19 18 0 000000 10010 10011 10001 00000 100000 op rs rt rd shamt funct op - opecode rs - register source rt- register source no 2 rd - register destination funct - function shamt - shift amount 6 5 5 5 5 6

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

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

33. Branch vs Jump • 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: ... ($s3=h $s4 =i $s5=j )

34. Addresses in Branches and Jumps • Instructions: bne $t4,$t5,LabelNext instruction is at Label if $t4!= $t5 beq $t4,$t5,LabelNext instruction is at Label if $t4 = $t5 j LabelNext 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 I J op 26 bit address

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

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

37. Branch-if-less-than? Slt- set less then if $s1 < $s2 then $t0 = 1slt $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

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

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

40. לסיכום

41. תרגיל שאלה 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] beq $8,$21,Exit # Goto Exit if save[i] = k add $19,$19,$20 # i:=i+j j Loop # Goto Loop Exit:

42. המשך תרגיל • תרגום שני: muli $9,$19,4 # Temporary reg $9:=i*4 lw $8,save($9) # Temporary reg $8:=save[i] beq $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] bnq $8,$21,Loop # Goto Loop if save[i]!=k Exit: • שאלה: בהנחה שהלולאה מתבצעת 10 פעמים, מה מספר הפקודות שמתבצעות בכל אחד מהתרגומים?

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

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

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

46. J u m p a d d r e s s [ 3 1 – 0 ] I n s t r u c t i o n [ 2 5 – 0 ] S h i f t l e f t 2 2 6 2 8 0 1 M M P C + 4 [ 3 1 – 2 8 ] u u x x A L U A d d 1 0 r e s u l t A d d S h i f t R e g D s t l e f t 2 J u m p 4 B r a n c h M e m R e a d I n s t r u c t i o n [ 3 1 – 2 6 ] M e m t o R e g C o n t r o l A L U O p M e m W r i t e A L U S r c R e g W r i t e I n s t r u c t i o n [ 2 5 – 2 1 ] R e a d R e a d r e g i s t e r 1 P C R e a d a d d r e s s d a t a 1 I n s t r u c t i o n [ 2 0 – 1 6 ] R e a d Z e r o r e g i s t e r 2 I n s t r u c t i o n 0 R e g i s t e r s A L U R e a d A L U [ 3 1 – 0 ] 0 R e a d W r i t e M d a t a 2 A d d r e s s r e s u l t 1 d a t a I n s t r u c t i o n r e g i s t e r M u M u m e m o r y x u I n s t r u c t i o n [ 1 5 – 1 1 ] W r i t e x 1 D a t a x d a t a 1 m e m o r y 0 W r i t e d a t a 1 6 3 2 I n s t r u c t i o n [ 1 5 – 0 ] S i g n e x t e n d A L U c o n t r o l I n s t r u c t i o n [ 5 – 0 ] Single Cycle