ECE 15B COMPUTER ORGANIZATION

Transcription

1 ECE 15B COMPUTER ORGANIZATION Lecture 4 Arithmetic/Data Transfer Announcements Homework #1 Due tomorrow (Friday 4/10) at 5:00 PM Homework #2 will be posted by Saturday and is due next Friday (4/17) Quiz #1 moved to Tuesday 4/21 from Thursday 4/23 Project #1 will be assigned next week Dr. Rahul Singh 2 Lecture 4: Arithmetic/Data Overview Addition and Subtraction Multiply and Divide Memory Access Review: Abstract View of the Implementation Instruction Address Next Address Ideal Instruction Memory PC Clk 32 Instruction Control Signals Conditions Rd Rs Rt Clk RwRa Rb bit Registers A 32 B Control 32 ALU 32 Datapath Data Address Data In Clk Ideal Data Memory Data Out 3 4 1

2 Review: Assembly Language Basic job of a CPU: execute lots of instructions are the primitive operations that the CPU may execute. Different CPUs implement different sets of instructions. The set of instructions a particular CPU implements is an Instruction Set Architecture (ISA) Examples: Intel 80x86 (Pentium 4), IBM/Motorola PowerPC (Macintosh), MIPS, Intel IA64,... Review: Assembly Variables - Registers Unlike HLL like C or Java, assembly cannot use variables Why not? Keep Hardware Simple Assembly Operands are registers limited number of special locations built directly into the hardware operations can only be performed on these! Benefit: Since registers are directly in hardware, they are very fast (faster than 1 billionth of a second) 5 6 Review: Assembly Variables Registers are numbered from 0 to 31 Each register can be referred to by number or name Number references: $0, $1, $2, $30, $31 $16 - $23 $s0 - $s7 (correspond to C variables) $8 - $15 $t0 - $t7 (correspond to temporary variables) Later will explain other 16 register names Review: MIPS Syntax Instruction Syntax: [label:] Op-code [oper. 1], [oper. 2], [oper. 3] [#comment] (0) (1) (2) (3) (4) (5) where: 1) operation name 2,3,4) operands 5) Comments 0) label field is optional, will discuss later. for arithmetic and logic instruction 2) operand getting result ( destination ) 3) 1st operand for operation ( source1 ) 4) 2nd operand for operation ( source2 ) Syntax is rigid: 1 operator, 3 operands Why? Keep hardware simple via regularity 7 Lecture 3: Arithmetic April 7,

3 Review: Addition & Subtraction of integers Addition in Assembly add $s0, $s1, $s2 (in MIPS) Equivalent to: a = b + c (in C) Where MIPS registers $s0, $s1, $s2 are associated with C variables a, b, c Subtraction in Assembly sub $s3, $s4, $s5 (in MIPS) Equivalent to: d = e - f (in C) Where MIPS registers $s3, $s4, $s5 are associated with C variables d, e, f Review: Addition & Subtraction of Integers How do we do this? f = (g + h) - (i + j); Use intermediate temporary register add $t0, $s1, $s2 # temp = g + h add $t1, $s3, $s4 # temp = i + j sub $s0, $t0, $t1 # f = (g+h) - (i+j) where MIPS registers $s0,$s1,$s2, and $s3 are associated with C variables f, g, h, and i 9 10 Review: Immediates Immediates are numerical constants. They appear often in code, so there are special instructions for them. Add Immediate: addi $s0, $s1, 10 # f = g + 10 (in C) where MIPS registers $s0 and $s1 are associated with C variables f and g Syntax similar to add instruction, except that last argument is a number instead of a register. Integer Multiplication Paper and pencil example (unsigned): Multiplicand Multiplier x 1001 x x 0000xx 1000xxx =1* *2 3 =72 m bits x n bits = m + n bit product

4 Multiplication Multiplication In MIPS, we multiply registers, so: 32-bit value x 32-bit value = 64-bit value Syntax of Multiplication (signed): mult register1, register2 Multiplies 32-bit values in those registers & puts 64-bit product in special result regs: puts product upper half in hi, lower half in lo hi and lo are 2 registers separate from the 32 general purpose registers To move from hi, lo to another register use: mfhi register mflo register 13 in C: a = b * c; in MIPS: let b be $s2 let c be $s3 let a be $s0 and $s1 (since it may be up to 64 bits) mult $s2,$s3 # b*c mfhi $s0 # move upper half of # product into $s0" mflo $s1 # move lower half of" # product into $s1 Note: Often, we only care about the lower half of the product. 14 Integer Division Division Paper and pencil example (unsigned): Decimal digits limited to only 0 or 1 Quotient Divisor Dividend Remainder Dividend = Quotient x Divisor + Remainder Syntax of Division (signed): div register1, register2 Divides 32-bit register 1 by 32-bit register 2 (divisor): Register 1 is dividend Register 2 is divisor puts remainder of division in hi, puts quotient in lo Implements C division (/) and modulo (%), example: a = c / d; b = c % d; In MIPS: a->$s0; b->$s1; c->$s2; d->$s3 div $s2,$s3 # lo=c/d, hi =c%d mflo $s0 # get quotient mfhi $s1 # get remainder

5 Assembly Operands: Memory Anatomy: 5 components of any Computer C variables map into registers What about large data structures like arrays? memory contains such data structures 1 of 5 components of a computer But MIPS arithmetic instructions only operate on registers never directly on memory. Data transfer instructions transfer data between registers and memory: Memory to register Register to memory Registers are in the datapath of the processor Computer Processor Control ( brain ) Datapath Registers Memory Devices Input Output If operands are in memory Must transfer them to the processor to operate on them And then transfer back to memory when done These are data transfer instructions Data Transfer: Memory to Register To transfer a word of data, we need to specify two things: Register: specify this by number (0-31) or symbolic name ($s0,, $t0, ) Memory address: (not as simple) Think of memory as a single one-dimensional array We can address it simply by supplying a pointer to a memory location or address. Other times, will want be able to offset from this pointer. Remember: Load FROM memory Data Transfer: Memory to Register To specify a memory address two values are required: Register containing a pointer to memory Numerical offset (in bytes) The desired memory address is the sum of these two values. 8($t0) specifies the memory address pointed to by the value in $t0 plus 8 bytes

6 Data Transfer: Memory to Register MIPS Load Instruction Syntax: lw register#, offset(register#) (1) (2) (3) (4) where: 1) operation name 2) register that will receive value 3) numerical offset in bytes 4) register containing pointer to memory lw - meaning Load Word 32 bits or one word are loaded at a time Data Transfer: Memory to Register Data Flow lw $t0, 12($s0) Instruction first calculates a memory address Adds 12 bytes to the the pointer in $s0 Then loads into register $t0 the value in the addressed memory location Notes: $s0 is the base register 12 is the offset Offset is generally used in accessing elements of an array or structure Base register points to beginning of array or structure Data Transfer: Register to Memory Want to store value from a register into memory Store and Load instruction syntaxes are identical sw register#, offset(register#) sw - meaning Store Word 32 bits or one word are loaded at a time Data Flow sw $t0, 16($s0) Instruction first calculates a memory address Adds 16 bytes to the the pointer in $s0 Then stores value in register $t0 into the addressed memory location Remember: Store INTO Memory Pointers vs. Values Key Concept: A register can hold any 32-bit value. That value type can be: (signed) int unsigned int pointer (memory address), etc If you write: add $t2,$t1,$t0 then $t0 and $t1 better contain values If you write lw $t2, 0($t0) then $t0 better contain a pointer Donʼt mix these up!

7 Every word in memory has an address Similar to an index in an array Early computers numbered words like C numbers elements of an array: Memory[ 0 ], Memory[ 1 ], Memory[ 2 ], Called the address of a word Computers needed to access bytes (8-bits) as well as words (1 word = 4 bytes), Today machines address memory as bytes Hence 32-bit (4 byte) word addresses differ by 4 Memory[ 0 ], Memory[ 4 ], Memory[ 8 ], Addressing: Byte vs. word 25 Compilation with Memory What offset in lw to select A[8] in C? (4 bytes/word) x (8 words) = (32 bytes) to select A[8] Compile by hand using registers: g = h + A[8]; (in C) where: g: $s1 h: $s2 base address of A: $s3 1st transfer from memory to register: lw $t0, 32($s3) #Load value in A[8] into $t0 add $s1, $s2, $t0 # $s1 = h+a[8] Add 32 to $s3 to select A[8], put into $t0 Next add it to h and place in g 26 Notes about Memory Pitfall: Forgetting that sequential word addresses in machines with byte addressing do not differ by 1. Many an assembly language programmer has toiled over errors made by assuming that the address of the next word can be found by incrementing the address in a register by 1 instead of by the word size in bytes. To be word aligned, remember that for both lw and sw, the sum of the base address and the offset must be a multiple of 4 More Notes about Memory: Alignment MIPS requires that all words start at byte addresses that are multiples of 4 bytes Last hex digit of address is: Aligned Not Aligned 0, 4, 8, or C hex 1, 5, 9, or D hex 2, 6, A, or E hex 3, 7, B, or F hex Alignment: objects must fall on address that is multiple of their size

8 Role of Registers vs. Memory What if more variables than registers? Compiler tries to keep most frequently used variables in registers Less common in memory: spilling Why not keep all variables in memory? Smaller is faster: registers are faster than memory Registers more versatile: MIPS arithmetic instructions can read 2 registers, operate on them, and write to 1 register per instruction MIPS data transfer only read or write 1 operand per instruction, and no operation Conclusion In MIPS Assembly Language: Registers replace C variables One Instruction (simple operation) per line Simpler is Better Smaller is Faster Memory is byte-addressable, but lw and sw access one word at a time. A pointer (used by lw and sw) is just a memory address, so we can add to it or subtract from it (using offset) Review so far: add, addi, sub mult, div mfhi, mflo lw, sw Registers so far: C Variables: $s0 - $s7 Temporary Variables: $t0 - $t9 Zero: $zero 31 8