1 / 28

Computer Architecture: A Constructive Approach Combinational ALU Arvind

Computer Architecture: A Constructive Approach Combinational ALU Arvind Computer Science & Artificial Intelligence Lab. Massachusetts Institute of Technology. Computing Devices Then… EDSAC, University of Cambridge, UK, 1949. Computing Devices Now.

dexter
Télécharger la présentation

Computer Architecture: A Constructive Approach Combinational ALU Arvind

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Computer Architecture: A Constructive Approach Combinational ALU Arvind Computer Science & Artificial Intelligence Lab. Massachusetts Institute of Technology http://csg.csail.mit.edu/SNU

  2. Computing Devices Then…EDSAC, University of Cambridge, UK, 1949 http://csg.csail.mit.edu/SNU

  3. Computing Devices Now Dramatic progress in terms of size, speed, cost, reliability http://csg.csail.mit.edu/SNU

  4. How does a program execute on hardware • A C program to add two arrays: • The hardware must know, for example, • How to add and compare two numbers • Must have a place to keep the program and data • Must know how to fetch instructions and data • Must know how to sequence instructions: • Fetch a[i], Fetch b[i], add, store results in c[i], increment i, … void vvadd( int n, int a[], int b[], int c[] ){ int i;  for ( i = 0; i < n; i++ )    c[i] = a[i] + b[i];} Computer Architecture is learning about how programs execute and designing hardware to execute them efficiently http://csg.csail.mit.edu/SNU

  5. Instruction Set Architecture (ISA) • Computer architecture is the discipline of designing and implementing interfaces through which hardware and software interact • This interface is often referred to as the Instruction Set Architecture (ISA) • Examples: Intel’s IA-32, ARM, ARM-Thumb, PowerPC • In this class we will use SMIPS, a subset of MIPS ISA • Implementations are deeply affected by the technology issues; we will assume a simple and abstract model of technology based on Silicon http://csg.csail.mit.edu/SNU

  6. Goal of the Intensive Course • Learn a constructive approach to studying computer architecture • Learn a new method of describing architectures where there is less emphasis on figures/diagrams and more emphasis on executable descriptions • Each architecture and each part of it would be defined as executable code in Bluespec By this Friday you will have designed several different computers on which you will be able to execute your C programs http://csg.csail.mit.edu/SNU

  7. In this lecture we will study how to implement simple arithmetic-logic operations we will first look at circuits for component functions such as Add, Shift and then put them together to form an Arithmetic-Logic Unit (ALU) http://csg.csail.mit.edu/SNU

  8. Arithmetic-Logic Unit (ALU) • Computers have many important interconnected parts or subsystems: • Central Processing Unit • Memory system including caches • I/O systems Op - Add, Sub, ... - And, Or, Xor, Not, ... - GT, LT, EQ, Zero, ... ALU resides inside the CPU and carried out all the arithmetic and logical functions A Result ALU Comp? B http://csg.csail.mit.edu/SNU

  9. Full Adder: A one-bit adder functionfa(a, b, c_in); s = (a ^ b)^ c_in; c_out = (a & b) | (c_in & (a ^ b)); return {c_out,s}; endfunction Not quite correct –needs type annotations http://csg.csail.mit.edu/SNU

  10. Full Adder: A one-bit addercorrected functionBit#(2) fa(Bit#(1) a, Bit#(1) b, Bit#(1) c_in); Bit#(1) s = (a ^ b)^ c_in; Bit#(1) c_out = (a & b) | (c_in & (a ^ b)); return {c_out,s}; endfunction Bit#(1) a declaration says that a is one bit wide {c_out,s} represents bit concatenation How big is {c_out,s}? http://csg.csail.mit.edu/SNU

  11. Types • Every expression and variable in a Bluespec program has a type; sometimes it is specified explicitly and sometimes it is deduced by the compiler • A type is a grouping of values: • Integer: 1, 2, 3, … • Bool: True, False • Bit: 0,1 • A pair of Integers: Tuple2#(Integer, Integer) • A function fnamefrom Integers to Integers: function Integer fname (Integer arg) • Thus we say an expression has a type, belongs to a type The type of each expression is unique http://csg.csail.mit.edu/SNU

  12. Type declaration versus deduction • User writes down types of some expressions in a program and the compiler deduces the types of the rest of expressions • If the type deduction cannot be performed or the type declarations are inconsistent then the compiler complains functionBit#(2) fa(Bit#(1) a, Bit#(1) b, Bit#(1) c_in); Bit#(1) s = (a ^ b)^ c_in; Bit#(2) c_out = (a & b) | (c_in & (a ^ b)); return {c_out,s}; endfunction type error Type checking prevents lots of silly mistakes http://csg.csail.mit.edu/SNU

  13. 2-bit Ripple-Carry Adder function Bit#(3) add(Bit#(2) x, Bit#(2) y, Bit#(1) c0); Bit#(2) s = 0; Bit#(3) c; c[0] = c0; let cs0 = fa(x[0], y[0], c[0]); c[1] = cs0[1]; s[0] = cs0[0]; let cs1 = fa(x[1], y[1], c[1]); c[2] = cs1[1]; s[1] = cs1[0]; return{c[2],s}; endfunction x[0] y[1] y[0] x[1] fa fa c[1] c[0] c[2] s[1] s[0] http://csg.csail.mit.edu/SNU

  14. “let” syntax • The “let” syntax: avoids having to write down types explicitly • let cs0 = fa(x[0], y[0], c[0]); • Bits#(2) cs0 = fa(x[0], y[0], c[0]); The same http://csg.csail.mit.edu/SNU

  15. Parameterized types: # • A type declaration itself can be parameterized – the parameters are indicated by using the syntax ‘#’ • For example Bit#(n) represents n bits and can be instantiated by specifying a value of n • Bit#(1), Bit#(32), Bit#(8), … http://csg.csail.mit.edu/SNU

  16. An w-bit Ripple-Carry Adder function Bit#(w+1) addN(Bit#(w) x, Bit#(w) y, Bit#(1) c0); Bit#(w) s; Bit#(w+1) c; c[0] = c0; for(Integer i=0; i<w; i=i+1) begin letcs= fa(x[i],y[i],c[i]); c[i+1] = cs[1]; s[i] = cs[0]; end return {c[w],s}; endfunction Not quite correct // concrete instances of addN! function Bit#(33) add32(Bit#(32) x, Bit#(32) y, Bit#(1) c0) = addN(x,y,c0); function Bit#(4) add3(Bit#(3) x, Bit#(3) y, Bit#(1) c0) = addN(x,y,c0); http://csg.csail.mit.edu/SNU

  17. valueOf(w)versus w • Each expression has a type and a value and these come from two entirely disjoint worlds • n in Bit#(n) resides in the types world • Sometimes we need to use values from the types world into actual computation. The function valueOf allows us to do that • Thus i<w is not type correct i<valueOf(w)is type correct http://csg.csail.mit.edu/SNU

  18. Tadd#(w,1)versus w+1 • Sometimes we need to perform operations in the types world that are very similar to the operations in the value world • Examples: Add, Mul, Log • We define a few special operators in the types space for such operations • Examples: Tadd#(m,n), Tmul#(m,n), … http://csg.csail.mit.edu/SNU

  19. A w-bit Ripple-Carry Addercorrected function Bit#(Tadd#(w,1)) addN(Bit#(w) x, Bit#(w) y, Bit#(1) c0); Bit#(w) s; Bit#(Tadd#(w,1)) c; c[0] = c0; letvalw=valueOf(w); for(Integer i=0; i<valw; i=i+1) begin letcs= fa(x[i],y[i],c[i]); c[i+1] = cs[1]; s[i] = cs[0]; end return {c[valw],s}; endfunction http://csg.csail.mit.edu/SNU

  20. Integerversus Int#(32) • In mathematics integers are unbounded but in computer systems integers always have a fixed size • Bluespec allows us to express both types of integers, though unbounded integers are used only as a programming convenience for(Integer i=0; i<valw; i=i+1) begin letcs= fa(x[i],y[i],c[i]); c[i+1] = cs[1]; s[i] = cs[0]; end http://csg.csail.mit.edu/SNU

  21. Static Elaboration phase • When Bluespec program are compiled, first type checking is done and then the compiler gets rid of many different constructs which have no direct hardware meaning, like Integers, loops for(Integer i=0; i<valw; i=i+1) begin letcs= fa(x[i],y[i],c[i]); c[i+1] = cs[1]; s[i] = cs[0]; end cs0 = fa(x[0], y[0], c[0]); c[1]=cs0[1]; s[0]=cs0[0]; cs1 = fa(x[1], y[1], c[1]); c[2]=cs1[1]; s[1]=cs1[0]; … csw = fa(x[w-1], y[w-1], c[w-1]); c[w] = csw[1]; s[w-1] = csw[0]; http://csg.csail.mit.edu/SNU

  22. Logical right shift by 2 a b c d • Fixed size shift operation is cheap in hardware – just wire the circuit appropriately • Rotate, sign-extended shifts – all are equally easy 0 0 0 0 a b http://csg.csail.mit.edu/SNU

  23. Conditional operation: shift versus no-shift • We need a Mux to select the appropriate wires: if s is one the Mux will select the wires on the left otherwise it would select wires on the right 0 0 s (s==0)?{a,b,c,d}:{0,0,a,b}; http://csg.csail.mit.edu/SNU

  24. Gate-level implementation of a multiplexer A A AND B OR S0 B AND C S S1 A 2-way multiplexer A 4-way multiplexer D A S0 case {s1,s0} matches 0: return A; 1: return B; 2: return C; 3: return D; endcase B S (s==0)?A:B http://csg.csail.mit.edu/SNU

  25. Logical right shift by n • Shift n can be broken down in several steps of fixed-length shifts of 1, 2, 4, … • Thus a shift of size 3 can be performed by first doing a shift of length 2 and then a shift of length 1 • We need a Mux to select whether we need to shift at all • The whole structure can be expressed an a bunch of nested conditional expressions 0 0 s1 0 s0 You will write a Blusepec program to produce a variable size shifter in Lab 1 this afternoon http://csg.csail.mit.edu/SNU

  26. Combinational ALU functionBit#(width) combALU(Bit#(width) a, Bit#(width) b, OP op); case op matches NOT: return ~a; AND: returna&b; OR: returna|b; SHL: return a<<b; SHR: return a>>b; ADD: returnaddN(a,b); SUB: return a-b; MUL: return combMulN(a,b); endcase endfunction Once we have implemented the primitive operations like addN, >>, the ALU can be implemented simply by introducing a Mux controlled by op to select the appropriate circuit slightly stylized code Other operations may be needed http://csg.csail.mit.edu/SNU

  27. Conditional operations • Generate one-bit result which is used for branching • Eq (a,b) : (a == b); • Neq(a,b) : (a != b); • Le(a) : signedLE(a, 0); • Lt(a) : signedLT(a, 0); • Ge(a) : signedGE(a, 0); • Gt(a) : signedGT(a, 0); • Straightforward to implement; can be combined with the ALU with an extra bit of output http://csg.csail.mit.edu/SNU

  28. ALU with Conditionals b a add comb MulN EQ … 0 op mux mux Next - Sequential Circuits http://csg.csail.mit.edu/SNU

More Related