??איפה אנחנו ולאן ממשיכים Input Multiplier Input Multiplicand 32 Multiplicand Register LoadMp 32=>34 signEx <<1 32 34 34 32=>34 signEx 1 Arithmetic Multi x2/x1 34 34 Sub/Add 34-bit ALU Control Logic 32 32 2 ShiftAll LO register (16x2 bits) Prev 2 Booth Encoder HI register (16x2 bits) LO[1] 2 "LO [0]" 34 Extra 2 bits ENC[2] ENC[1] ENC[0] LoadLO LoadHI 2 ClearHI Single/multicycle Datapaths 0 34x2 MUX 32 Result[HI] LO[1:0] 32 Result[LO] 1000 CPU IFetchDcd WB Exec Mem WB Performance Processor-Memory Performance Gap: (grows 50% / year) 10 DRAM 9%/yr. DRAM (2X/10 yrs) 1 198 2 3 198 498 1 5 198 6 198 7 198 8 198 9 199 0 199 199 2 199 399 1 4 199 5 199 699 1 7 199 8 199 9 200 0 Exec Mem 100 198 098 1 1 198 IFetchDcd מבנה מחשבים “Moore’s Law” µProc 60%/yr. (2X/1.5yr) Time IFetchDcd Exec Mem IFetchDcd WB Exec Mem WB Pipelining I/O Memory Systems 1 ? מה נלמד .כיצד מחשב בנוי • .כיצד לנתח ביצועי מחשב • ) cache, pipeline( נושאים המשפיעים על מעבדים חדשים • :הספר Computer Organization & Design The hardware/software interface, David A. Patterson and John L. Hennessy. Third Edition 2005 2 3 4 שפת מכונה )swap(int v[], int k ;{int temp ;]temp = v[k ;]v[k] = v[k+1 ;v[k+1] = temp } High-level language program )(in C • אסמבלי -נוח יותר לקריאה. -הפשטה. C compiler swap: muli $2, $5,4 add $2, $4,$2 )lw $15, 0($2 )lw $16, 4($2 )sw $16, 0($2 )sw $15, 4($2 jr $31 Assembly language program )(for MIPS מעבר חד חד ערכי משפתהמכונה. • שפת - Cנוח יותר לתיכנות. לא מעבר חד חד ערכי.Binary machine language program )(for MIPS תלוי קומפיילרואופטימיזציה - Portable 5 דומה לאנגלית רגילה .תלויה במחשב. לכל מחשב פקודות Assemblyשונות. לכל מחשב יש רגיסטרים אחרים ,פקודות אחרות וכו’. דומה יותר לאנגלית רגילה( .אפשר להתאים השפה לעיבוד שהיא אמורה לבצע). פרודקטיביות גבוהה :במשפט אחד מגדירים הרבה חישובים שהמכונה נדרשת לעשות. והכי חשוב :לא תלוי במחשב !!! Assembler 00000000101000010000000000011000 00000000100011100001100000100001 10001100011000100000000000000000 10001100111100100000000000000100 10101100111100100000000000000000 10101100011000100000000000000100 00000011111000000000000000001000 • שפת מכונה -הפקודות שהמחשב מכיר. כיום מתכנתים בשפת אסמבלי רק כשמוכרחים: * כאשר הזמן הוא קריטי וצריך לבצע אופטימיזציה “ידנית” של הקוד * כאשר צריך להשתמש בכל המשאבים של המחשב שאי אפשר לנצלם ע”י שפה עילית ,כמו למשל ,בדיקת overflowאו שימוש בindex - registerוכו’ * כאשר הזיכרון הוא קריטי וצריך אופטימיזציה של ניהול הזיכרון (בעיקר במחשבים מיוחדים כמו )DSPs 6 Levels of Representation temp = v[k]; High Level Language Program v[k] = v[k+1]; v[k+1] = temp; Compiler Assembly Language Program Assembler Machine Language Program 0($2)$15, lw 4($2)$16, lw 0($2) $16, sw 4($2) $15, sw 0000 1010 1100 0101 1001 1111 0110 1000 Machine Interpretation Control Signal Specification ° ° 1100 0101 1010 0000 0110 1000 1111 1001 1010 0000 0101 1100 1111 1001 1000 0110 0101 1100 0000 1010 1000 0110 1001 1111 ALUOP[0:3] <= InstReg[9:11] & MASK 7 MIPS Instruction Set Use the MIPS ISA document as the final word on the ISA MIPS ISA document available on Course Web Site. 8 Instruction Sets: A Thin Interface Syntax: ADD $8 $9 $10 Semantics: $8 = $9 + $10 Application (iTunes) Compiler Software Hardware Assembler Operating System (Mac OS X) Processor Memory I/O system Instruction Set Architecture Datapath & Control Digital Design Circuit Design Transistors “R-Format” Fieldsize: 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits Bitfield: opcode rs rt rd shamt funct Binary: 000000 01001 01010 01000 00000 100000 9 In Hexadecimal: 012A4020 Instruction Set Architecture • יש דמיון רב בין שפות המכונה השונות • אנו נלמד את שפת המכונה של מעבד ה MIPS -שפותח בתחילת שנות ה ( 80 -משתמשים בו בSilicon - .) Graphics,NEC,Sony • RISC v. CISC – Reduced Instruction Set Computer - MIPS – 8086 - Complex Instruction Set Computer המוטו “פחות זה יותר“ • כלומר :סט פקודות קטן יותר ,כאשר הפקודות עצמן פשוטות יותר ,מאפשר ביצועים טובים יותר .זאת היות והחומרה הדרושה לביצוע הפקודות הנ”ל תהיה פשוטה יותר המהירות תגדל ושטח הסיליקון הדרוש (=המחיר) יצטמצם. 10 The Big Picture Since 1946 all computers have had 5 components • Processor Input Control Memory Datapath Output 11 Hardware implements semantics ... Syntax: ADD $8 $9 $10 Semantics: $8 = $9 + $1 Instruction Fetch Instruction Decode Operand Fetch Execute Result Store Next Instruction Fetch next inst from memory:012A4020 opcode rs rt rd shamt funct Decode fields to get : ADD $8 $9 $10 “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. 12 Memory Instructions: LW $1,32($2) Instruction Fetch Instruction Decode Operand Fetch Execute Result Store Next Instruction Fetch the load inst from memory opcode rs rt offset “I-Format” Decode fields to get : LW $1, 32($2) “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”). 13 Branch Instructions: BEQ $1,$2,25 Instruction Fetch Instruction Decode Operand Fetch Execute Result Store Next Instruction Fetch branch inst from memory opcode rs rt offset “I-Format” Decode fields to get: BEQ $1, $2, 25 “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” 14 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” 15 The impact of the ISA RISC vs CISC 16 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 • 17 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 (!?!) • 18 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 • 19 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 20 RISC v. CISC - Iמספר פקודות בתוכנית –Tהזמן לביצוע פקודה RISC: T * I CISC: I * T 21 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” 22 כלל תכנון מספר Simplicity favors Regularity :1 פעולות אריתמטיות • 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 אבל קשה מאוד לתכנן ולממש אותו. 23 כלל תכנון מס’ Smaller is faster :2 • • • • • נאפשר פעולות אריתמטיות רק על רגיסטרים. האופרנדים יכולים להיות רגיסטר או קבוע (אחד). סה”כ יש 32רגיסטרים. רגיסטר word = 32 bits = 4 bytes קונבנציות הרגיסטרים מסומנים ע”י .$ או 0$ - 31$או ע”י שמות הקשורים לתפקידיהם משתנים של $s0,$s1 ... - C בתכנית .יש הסכמה על תפקידי הרגיסטרים הנ”ל בכל משתנים זמניים $t1,$t2 … - התכניות בשפת Cלמשל. … $1,$2 עמ’ 110 24 דוגמא: $s0=f, $s1=g, $s2=h, $s3=k, $s4=j הדוגצא מתארת איך המשפט ( f=(g+h)-(k+jמיוצג ע”י פקודות אסמבלי. הרגיסטרים הם ליבו של הפרוססור. הגישה אליהם מהירה מלזיכרון .נגשים ,בוזמנית” ל 3-רגיסטרים :מ 2-קוראים ולשלישי כותבים. f=(g+h)-(k+j) # add $t0,$s1,$s2 add $t1,$s3,$s4 sub $s0, $t0, $t1 Policy of Use Conventions Name Register number $zero 0 $v0-$v1 2-3 $a0-$a3 4-7 $t0-$t7 8-15 $s0-$s7 16-23 $t8-$t9 24-25 $gp 28 $sp 29 $fp 30 $ra 31 Usage the constant value 0 values for results and expression evaluation arguments temporaries saved more temporaries global pointer stack pointer frame pointer return address השמור לאסמבלר$ at = $1 רגיסטרים נוספים הם השמורים למערכת ההפעלה$ k0 , $ k1 = $ 26, $ 27 -ו 25 הזיכרון . מערך גדול- • הזיכרון . אינדקס למערך- • כתובת לזיכרון . האינדקס בבתים- Byte addressing • 0 1 2 3 4 5 6 ... 8 bits of data 8 bits of data גודל הזיכרון המכסימלי 8 bits of data 230 words = 232 bytes • 8 bits of data 8 bits of data 8 bits of data 8 bits of data 26 פניה לזיכרון Load and Store פקודות LW - טוענים מילה אבל הכתובת בזיכרון היא בבתים lw $s1,100($s2) # $s1=Memory[$s2+100] offset = מקום במערך sw $s1,100($s2) base register = מצביע למערך # Memory[$s2+100]=$s1 :דוגמא נוספת Word מערך של- save muli lw $9,$19,4 $8,save($9) base register = מצביע למערך • • • # Temporary reg $9:=i*4 # Temporary reg $8:=save[i] = מקום במערך offset 27 byte קריאה של lb (load byte( • ישנם גם פקודות כמו sb(store byte( -ו ASCII - בbyte גודל:char • שימושי לקריאת American Standard Code For Information Interchange . בתים2 הואchar גודל- Unicode -• ב 28 גישה לזיכרון MIPS = Big endian A 0 32 bits of data 4 8 12 16 A[0] A[1] A[2] 0 1 2 3 INTEL = Little endian 3 2 1 0 C code: A[2] = h + A[2]; MIPS code: lw $t0, 8($s3) add $t0, $s2,$t0 sw $t0, 8($s3) :• דוגמא words מערך שלA $ s3 - בA כתובת $ s2- נמצא בh # $t0=$s3[8] # $t0=$s2+$t0 # $s3[8]=$t0 29 שפת המכונה . ביט32 בגודל זהה שלMIPS -• הפקודות ב . בתים17- עד ל1- פקודות בגודל משתנה מ- 8086 - • ב :דוגמא add $s1,$s2,$s3 # $s1=$17,$s2=$18, $s3=$19 מסוג R-type פורמט הפקודה 31 0 0 18 000000 10010 19 10011 17 10001 op rs rt rd 6 5 5 5 op - opecode rt- register source no 2 funct - function 0 00000 32 100000 shamt funct 5 6 rs - register source rd - register destination shamt - shift amount 30 תכנון טוב דורש לעיתים פשרות: 3 ’כלל תכנון מס . דמיון בין הפקודות.• צמצום מספר סוגי הפקודות השונים 6 5 op rs rt rd I op rs rt 16 bit address J op R • 5 5 5 shamt 6 funct 26 bit address Example: lw $s1, 32($s2) 6 5 5 35 18 17 op rs rt # $s1 =$17, $s2=18 5 5 6 32 16 bit number 31 התוכנית בזיכרון • התוכנית נשמרת בזיכרון בדיוק כמו נתונים memory for data, programs, compilers, editors, etc. 32 Memory Processor ביצוע תוכנית • רגיסטר מיוחד PC - Program Counterשומר את כתובת הפקודה. • קוראים מילה שלמה מהזיכרון. • מקדמים את ה .PC - Branch vs Jump קפיצה “אבסולוטית” ללא תנאים- Jump • j label קפיצה יחסית מותנת- Branch • bne $1,$2,label • Example: if (i!=j) h=i+j; else h=i-j; # $1!=$2 go to label ($s3=h $s4 =i $s5=j ) beq $s4, $s5, Lab1 add $s3, $s4, $s5 j Lab2 Lab1: sub $s3, $s4, $s5 Lab2: ... 33 Addresses in Branches and Jumps • Instructions: bne $t4,$t5,Label beq $t4,$t5,Label j Label Next instruction is at Label if $t4!= $t5 Next instruction is at Label if $t4 = $t5 Next instruction is at Label Formats: I op J op rs rt • 16 bit address 26 bit address מכאן . מילים2^16 קפיצה יחסית בגבולות- branch . יהיו קפיצות לוקאליותbranches - רוב ה:הנחה Beq $s1,$s2,25 # if ($s1 ==$s2) go to PC +4 +25*4 • 34 דוגמא לקידוד Loop: lw $8, save($19) # $8=save[i] bne $8, $21,Exit #Goto Exit if save[i]<> k add $19,$19,$20 j Loop # i:=i+j # Goto Loop Exit: SAVE - 1000 80,000 35 19 8 1000 80,004 5 8 21 2 80,008 0 19 20 80,012 2 80,016 19 0 32 20,000 35 כלל שחשוב לזכור באסמבלי של MIPSמקודדים: כתובת codeבמילים כתובת dataבבתים כאשר מעבד MIPSניגש לזיכרון הוא מבקש את הכתובת בבתים 36 Branch-if-less-than? Slt- set less then slt $t0, $s1, $s2 if $s1 < $s2 then $t0 = 1 else $t0 = 0 :blt • ניתן לבנות את Blt –branch less then slt $at,$s0,$s1 bne $at,$zero, Less blt $s0,$s1, Less # $t0 gets 1 if $s0<$s1 # go to Less if $t0 != 0 Pseudo instruction היאblt • Assembler uses $at (= $1) for pseudo instructions • 37 Pseudo instruction -דוגמאות נוספות ל bne $8,$21,far_adrs - שקול ל beq $8,$21,nxt j far_adrs nxt: move $t1,$s4 - שקול ל add $t1,$s4,$zero 38 כלל תכנון מס’ : 4בנה את המקרה השכיח -מהיר • הרבה פעולות ארתמטיות מתבצעות עם קבועים קטנים. לכן הוקצו פקודות מיוחדות לחיבור חיסור והשוואה של קבועים קטניםaddi, : slti, andi, ori, xori addi $29, $29, 4 • קבועים גדולים נחשב ב 2-פקודות ,כלומר לאט יותר ,אבל נדרשת רק $t0=101010101010101011111111111111111 פקודה אחת נוספתlui : lui $t0,1010101010101010 0000000000000000 1010101010101010 # $t0=2^16*(101010101010101010)2 ori $t0,$t0, 1111111111111111 1111111111111111 0000000000000000 # $t0=$t0||1010101010101010 …$to=10101010101010101111111111111 39 1111111111111111 1010101010101010 לסיכום MIPS operands Name 32 registers Example Comments $s0-$s7, $t0-$t9, $zero, Fast locations for data. In MIPS, data must be in registers to perform $a0-$a3, $v0-$v1, $gp, arithmetic. MIPS register $zero always equals 0. Register $at is $fp, $sp, $ra, $at reserved for the assembler to handle large constants. Memory[0], 2 30 memory Memory[4], ..., words Memory[4294967292] Accessed only by data transfer instructions. MIPS uses byte addresses, so sequential words differ by 4. Memory holds data structures, such as arrays, and spilled registers, such as those saved on procedure calls. 40 תרגיל :MIPS ושני תרגומים שלו לשפת האסמבלי של,C- לפניך קוד הכתוב ב:1 שאלה while (save[i]!=k) do i=i+j ; save:array [ 0..100] of word .k- כ21$- וj- כi, $20- מתפקד כ19$ $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: 41 המשך תרגיל :• תרגום שני muli lw beq Loop: add muli lw bnq Exit: $9,$19,4 # Temporary reg $9:=i*4 $8,save($9) # Temporary reg $8:=save[i] $8,$21,Exit # Goto Exit if save[i] = k $19,$19,$20 # i:=i+j $9,$19,4 # Temporary reg $9:=i*4 $8,save($9) # Temporary reg $8:=save[i] $8,$21,Loop # Goto Loop if save[i]!=k מה מספר הפקודות, פעמים10 בהנחה שהלולאה מתבצעת:• שאלה ? שמתבצעות בכל אחד מהתרגומים42 Compiler A.asm compiler A.obj P.exe loader Memory linker B.asm compiler B.obj C.lib (c.obj) 43 תהליך הקומפילציה 44 מבנה הזיכרון במחשב MIPS 45 Single Cycle I nstr u ctio n [ 2 5– 0] 26 Shift l eft 2 J u mp a d dr es s [31 – 0] 28 PC +4 [31 – 2 8] Ad d Ad d 1 M u x M u x 1 0 Shift left 2 Re g D st Ju mp 4 A LU r e sult 0 Br a n ch Me mR e a d I nstr uctio n [31 – 2 6] C o ntr ol Me mto Reg AL U Op Me m Write AL U Sr c Re g Writ e I nstr uctio n [25 – 2 1] PC Re a d addr e ss I nstr uctio n [20 – 1 6] I n str ucti o n [3 1– 0] Instr ucti o n me mor y Rea d r e gi st er 1 I nstr uctio n [15 – 1 1] 0 M u x 1 Re a d data 1 Rea d r e gi st er 2 Regi ster s Re a d Wri te data 2 r e gi st er Z er o 0 M u x 1 Wri te dat a AL U AL U r e sult Ad dr e ss Dat a me mory Writ e d ata I nstr uctio n [15 – 0] 16 Re a d dat a 1 M u x 0 32 Sig n ex te nd AL U co ntr ol I n str u cti on [5– 0] 46