Introduction. ENG3380 Computer Organization and Architecture MIPS: Data Path Design Part 3. Topics. References. School of Engineering 1
|
|
- Angelica Wilkinson
- 5 years ago
- Views:
Transcription
1 ENG8 Computer Organization and rchitecture MIPS: Data Path Design Part Winter 7 S. reibi School of Engineering University of Guelph Introduction Topics uilding a Complete Data Path for MIPS Multi Cycle Computer Datapath Design Design of the Unit dvantages & Disadvantages Summary Single Cycle Implementation Cycle Time Unfortunately, though simple, the single cycle approach is not used because it is very slow Clock cycle must have the same length for every instruction What is the longest (slowest) path (slowest instruction)? With thanks to W. Stallings, Hamacher, J. Hennessy, M. J. Irwin for lecture slide contents Many slides adapted from the PPT slides accompanying the textbook and CSE Course References I. Computer Organization and rchitecture: Designing for Performance, th edition, by William Stalling, Pearson. II. Computer Organization and Design: The Hardware/Software Interface, th editino, by D. Patterson and J. Hennessy, Morgan Kaufmann III. Computer Organization and rchitecture: Themes and Variations,, by lan Clements, CENGGE Learning Review: Single Cycle Data and Path Instr[5-] 8 6 left +[-8] Jump Op ranch dd Instr[-6] Instr[5-] Instruction Instr[-6] Instr[-] Instr[5 -] Src ddr RegisterData ddr Write ddr Data dd left ovf Src Mem Data Data Instr[5-] 6 Instr[5-] School of Engineering
2 Single Cycle Disadvantages & dvantages Uses the clock cycle inefficiently the clock cycle must be timed to accommodate the slowest instr especially problematic for more complex instructions like floating point multiply Clk Cycle Cycle lw sw Waste May be wasteful of area since some functional units (e.g., adders) must be duplicated since they can not be shared during a clock cycle but It is simple and easy to understand Our Multicycle pproach reak up the instructions into steps where each step takes a clock cycle while trying to balance the amount of work to be done in each step use only one major functional unit per clock cycle t the end of a clock cycle Store values needed in a later clock cycle by the current instruction in a state element (internal register not visible to the programmer) Instruction Register Data Register and Register read data registers out output register - ll (except ) hold data only between a pair of adjacent clock cycles (so they don t need a write signal) Data used by subsequent instructions are stored in programmer visible state elements (i.e., Register,, or ) The Multicycle Datapath High Level View Registers have to be added after every major functional unit to hold the output value until it is used in a subsequent clock cycle MIPS Data Path Multi Cycle Data ddr RegisterData ddr Write ddr Data out 8 Multicycle Implementation Overview Clocking the Multicycle Datapath Each instruction step takes clock cycle Therefore, an instruction takes more than clock cycle to complete (fetch, decode, execute, ) Not every instruction takes the same number of clock cycles to complete Multicycle implementations allow faster clock rates different instructions to take a different number of clock cycles functional units to be used more than once per instruction as long as they are used on different clock cycles, as a result - only need one memory - only need one /adder System Clock clock cycle ddr RegisterData Data ddr Write ddr Data out School of Engineering
3 The Multicycle Datapath High Level View Multiplexors have to be added since we are using a single memory and a single The Complete Multicycle Data with Data ddr RegisterData ddr Write ddr Data out Data Instr[-6] Instr[5-] Instr[5-] Instr[5-] ddr RegisterData ddr Write ddr Data left [-8] 8 left out The Multicycle Datapath with more Support lthough this datapath supports normal incrementing of the, a few more connections and a multiplexor will be needed for branches and jumps The additions versus the single-clock datapath include Data Instr[5-] Instr[5-] ddr RegisterData ddr Write ddr Data left out The Complete Multicycle Data with Data The is written both unconditionally and conditionally. Cond Instr[-6] Instr[5-] Instr[5-] ddr RegisterData ddr Write ddr During a normal increment and for jumps, the is written unconditionally. If the instruction is a conditional branch, the increment is replaced with the value in Out only if registers are equal. [-8] Instr[5-] Data left left 8 out The MC Datapath with support to ranch/jump The Complete Multicycle Data with. The output of the, which is the value + during instruction fetch. This value should be stored directly into the.. The register Out, which is where we will store the address of the branch target after it is computed.. The lower 6 bits of the instruction register () shifted left by two and concatenated with the upper bits of the incremented, which is the source when the instruction is a jump. [-8] Data ddr RegisterData ddr Write ddr Instr[5-] Instr[5-] Instr[5-] Data left left 8 out Data Cond Mem Write Source Op Src Src Instr[-6] Instr[5-] Instr[5-] ddr RegisterData ddr Write ddr Instr[5-] Data left [-8] left 8 out School of Engineering
4 The Instruction & Instruction Register Five Instruction Steps R-type: I-Type: J-Type: op rs rt rd shamt funct 5 5 op rs rt address offset op jump target address Data Instr[5-] Write ddr Instr[5-] to branch Instr[-6] to unit for opcode Instr[5-] used for jump Instr[5-] ddr Instr[-6] ddr ddr RegisterData ddr Write ddr Data left. Instruction. Instruction and Register. R-type Instruction Execution, /Write Computation, ranch Completion, or Jump Completion. ccess, Write Completion or R-type Instruction Completion 5. Completion (Write ack) INSTRUCTIONS TKE FROM - 5 CYCLES! Instr[5-] to Review: Our ling the uses of multiple decoding levels main unit generates the Op bits unit generates bits Instr op funct Op action lw xxxxxx add sw xxxxxx add beq xxxxxx subtract add add subt subtract and and or or xor xor nor nor slt slt Step : Instruction Use to get instruction from the memory and put it in the Instruction Register Increment the by and put the result back in the Can be described succinctly using the RTL "Register- Transfer Language = []; = + ; Can we figure out the values of the signals? What is the advantage of updating the now? Our Multicycle pproach, con t Datapath ctivity During Instruction ing from or writing to any of the internal registers, Register, or the occurs (quickly) at the beginning (for read) or the end of a clock cycle (for write) Cond Mem Write Source Op Src Src ing from the Register takes ~5% of a clock cycle since it has additional and access overhead (but reading can be done in parallel with decode) Had to add multiplexors in front of several of the functional unit input ports (e.g.,, ) because they are now shared by different clock cycles and/or do multiple jobs ll operations occurring in one clock cycle occur in parallel This limits us to one operation, one access, and one Register access per clock cycle Data Instr[-6] ddr RegisterData ddr Write ddr Instr[5-] Instr[5-] Instr[5-] Data left [-8] left 8 out School of Engineering
5 als Settings,Write,,= = Instr Mem;Write Src= src= Source,Op= als Settings,Write,,= = Mem;Write Src= src= Source,Op= Instr Src= Src= Op= Cond= Step : Instruction and Register Don t know what the instruction is yet, so can only registers rs and rt in case we need them Compute the branch address in case the instruction is a branch The RTL: R-type: op rs rt rd shamt funct = Reg[[5-]]; I-Type: = Reg[[-6]]; Out = +(sign-extend([5-])<< ); 5 5 op rs rt address offset Note we aren't setting any lines based on the instruction (since we don t know what it is (the logic is busy "decoding" the op code bits)) Step (instruction dependent) is performing one of four functions, based on instruction type. reference (lw and sw): op rs rt address offset Out = + sign-extend([5-]);. R-type: Out = op ; I-Type: 5 5 R-type: op rs rt rd shamt funct. ranch: I-Type: op rs rt address offset if (==) = Out;. Jump: = [-8] ([5-] << ); J-Type: 5 5 op jump target address Datapath ctivity During Instruction Cond Mem Write Source Op Src Src Datapath ctivity During () lw & sw Cond Mem Write Source Op Src Src Out = + sign-extend([5-]); Data Instr[-6] Instr[5-] ddr RegisterData ddr Write ddr Data Instr[5-] left Instr[5-] [-8] 8 left out Data Instr[-6] Instr[5-] ddr RegisterData ddr Write ddr Data Instr[5-] left Instr[5-] [-8] 8 left out School of Engineering 5
6 Datapath ctivity During () R-type R-type: Cond Mem Write op rs rt rd shamt funct Source Op Src Src Out = op ; als Settings,Write,,= = Mem;Write Src= src= Source,Op= Instr Src= Src= Op= Cond= Data Instr[-6] Instr[5-] ddr RegisterData ddr Write ddr Data Instr[5-] left Instr[5-] [-8] 8 left out Src= Src= Op= Cond= Src= Src= Op= Cond= Src= Src= Op= Source= Cond Source= fter state the signals asserted depend on the class of instruction. Thus, the finite state machine has four arcs exiting state, corresponding to the four instruction classes: reference (lw, sw) R-type ranch on equal Jump This process of branching to different states depending on the instruction is called decoding. Datapath ctivity During () beq Data I-Type: 5 5 Cond Mem Write op rs rt address offset ddr RegisterData ddr Write ddr Instr[5-] Data left Source Op Src Src Instr[-6] Instr[5-] Instr[5-] if (==) = Out; [-8] left 8 out Step or Write (also instruction dependent) reference: = [Out]; or [Out] = ; -- lw -- sw R-type instruction completion (write to Reg) Reg[[5-]] = Out; R-type: op rs rt rd shamt funct Remember, the register write actually takes place at the end of the cycle on the clock edge Datapath ctivity During () j J-Type: op jump target address Cond Mem Write = [-8] ([5-] << ); Source Op Src Src Datapath ctivity During lw ccess Cond Mem Write Source Op Src Src Data Instr[-6] Instr[5-] ddr RegisterData ddr Write ddr Data Instr[5-] left Instr[5-] [-8] 8 left out Data Instr[-6] Instr[5-] ddr RegisterData ddr Write ddr Data Instr[5-] left Instr[5-] [-8] 8 left out School of Engineering 6
7 Datapath ctivity During sw ccess Step 5: Completion (Write ack) Data Cond Mem Write Source Op Src Src Instr[-6] Instr[5-] Instr[5-] ddr RegisterData ddr Write ddr Instr[5-] Data left [-8] left 8 out ll we have left is the write back into the register file the data just read from memory for the load lw instruction Reg[[-6]]= ; I-Type: 5 5 op rs rt address offset Write the load data, which was stored into in the previous cycle into the register file. What about all the other instructions? Datapath ctivity During R-type Completion Datapath ctivity During lw Write ack Cond Mem Write Source Op Src Src Cond Mem Write Source Op Src Src Data Instr[-6] Instr[5-] ddr RegisterData ddr Write ddr Data Instr[5-] left Instr[5-] [-8] 8 left out Data Instr[-6] Instr[5-] ddr RegisterData ddr Write ddr Data Instr[5-] left Instr[5-] [-8] 8 left out ccess als Settings,Write,,= = Mem;Write Src= src= Source,Op= Instr Src= Src= Op= Cond= Write ack als Settings,Write,,= = Mem;Write Src= src= Source,Op= Instr Src= Src= Op= Cond= Src= Src= Op= Cond= Src= Src= Op= Cond= Src= Src= Op= Source= Cond Source= Src= Src= Op= Cond= Src= Src= Op= Cond= Src= Src= Op= Source= Cond Source= Mem = Cond= ccess = Cond= = = Cond= Mem = Cond= ccess = Cond= = = Cond= = = Cond= Write ack School of Engineering 7
8 RTL Summary (from 5 cycles) Instruction & will be common to all Instructions Step R-type Mem Ref ranch Jump Instr fetch = []; = + ; = Reg[[5-]]; = Reg[[-6]]; Out = +(sign-extend([5-])<< ); Operations for Each Cycle RTL Summary (from 5 cycles) Step R-type Mem Ref ranch Jump nswering Simple Questions How many cycles will it take to execute this code? Out = op ; Out = + sign-extend ([5-]); if (==) = Out; = [-8] ([5- ] << ); lw $t, ($t) lw $t, ($t) beq $t, $t, Label #assume not add $t5, $t, $t sw $t5, 8($t) Label:... address for second lw being calculated What is going on during the 8 th cycle of execution? In what cycle does the actual addition of $t and $t takes place? 6 th cycle th cycle In what cycle is the branch target address calculated? 5 5 = cycles RTL Summary (from 5 cycles) Cycles /5 Cycles Cycles Cycles Step R-type Mem Ref ranch Jump Instr fetch Out = op ; access = []; = + ; = Reg[[5-]]; = Reg[[-6]]; Out = +(sign-extend([5-])<< ); Reg[ [5-] ] = Out; Out = + sign-extend ([5-]); = [Out]; or [Out] = ; if (==) = Out; X = [-8] ([5- ] << ); X Multi Cycle Writeback X Reg[[-6]] = ; X X School of Engineering 8
9 Unit Design Recall (in Single-Cycle datapath) we used a set of truth tables (hardwired) that specified the setting of the signals based on the instruction class. For the Multi-Cycle datapath, the is more complex!! Why? ecause the instruction is executed in a series of steps. The for the Multi-Cycle datapath must specify the signals to be set in any step and the next step in the sequence. Possible Implementations: Finite Sate Machine (FSM) Microprogrammed Finite State Machine Implementation Use D-FF or JK FF to realize the unit From State Diagram obtain the State Table. Determine the number of FFs required. Use excitation tables to design input logic for FF. Op5 Op Op Op Combinational logic Op Inst[-6] Inputs Op System Clock Outputs State Reg Cond Mem Write Source Op Source Source Next State Multicycle Multicycle datapath signals are not determined solely by the bits in the instruction e.g., op code bits tell what operation the should be doing, but not what instruction cycle is to be done next We can use a finite state machine for a set of states (current state stored in State Register) next state function (determined by current state and the input) output function (determined by current state) (Type of FSM?) Combinational logic Inst Opcode State Reg Datapath points Next State So we are using a Moore machine (datapath signals based only on current state) lgorithmic State Machine (SM) Implementation We can also use lgorithmic State Machines (SM) to implement the Unit. Translate the FSM to an SM and then: Use one flipflop per state Use Sequence Register and r. The SM implementation based on VHDL can be realized using: Schematic Capture Structural VHDL ehavioral VHDL Multicycle Datapath Finite State Machine,Write,,= Src= Src= Op= Cond= Mem = Cond= ccess = = Cond= Write ack = Instr Mem;Write Src= Src= Src= src= Op= Source,Op= Cond= 5 = Cond= 6 Src= Src= Op= Cond= 7 = = Cond= 8 9 Src= Src= Source= Op= Source= Cond State ssignment Total of States The Complete Multicycle Data with Data Cond Mem Write Source Op Src Src Instr[-6] Instr[5-] Instr[5-] ddr RegisterData ddr Write ddr Instr[5-] Data left [-8] left 8 out School of Engineering 9
10 The Effect of -bit als Datapath Outputs Truth Table Outputs Cond X Mem Write X Source Op Src Src X Input Values (Current State[-]) The Effect of -bit als Datapath Outputs Truth Table Outputs Input Values (Current State[-]) Cond X X X X X X X X X Mem Write X X X X X X X X Source XX XX XX XX XX XX XX Op XX XX XX XX XX Src XX XX XX XX XX Src X X X X X X X X X X X X X Datapath ctivity During Instruction Data Cond Mem Write Source Op Src Src Instr[-6] ddr RegisterData ddr Write ddr Instr[5-] Instr[5-] Instr[5-] Data left [-8] left 8 out Multicycle Datapath FSM,Write,,= Src= Src= Op= Cond= Mem = Cond= ccess = = Cond= Write ack = Instr Mem;Write Src= Src= Src= src= Op= Source,Op= Cond= 5 = Cond= 6 Src= Src= Op= Cond= 7 = = Cond= 8 9 Src= Src= Source= Op= Source= Cond Total of States School of Engineering
11 Next State Truth Table ( ) Current State [-] (Rtype) (jmp) Inst[-6] (beq) (Op[5-]) (lw) (sw) ny other 6 Next State Truth Table (ll return to state ) Recall.. Simple Sequencer.. Current State [-] (Rtype) (jmp) Inst[-6] (beq) (Op[5-]) (lw) (sw) ny other illegal XXXX XXXX XXXX illegal XXXX XXXX XXXX XXXX illegal XXXX XXXX XXXX XXXX illegal XXXX XXXX XXXX XXXX illegal XXXX XXXX XXXX XXXX illegal XXXX XXXX XXXX XXXX illegal XXXX XXXX XXXX XXXX illegal XXXX XXXX XXXX XXXX illegal Instruction Register En Mapping Logic MUX Register Incrementer + als (micro-operations) Simplifying the Unit Design For an implementation of the full MIPS IS instr s can take from clock cycles to + clock cycles resulting in finite state machines with hundreds to thousands of states with even more arcs (state sequences) - Such state machine representations become impossibly complex Instead, can represent the set of signals that are asserted during a state as a low-level instruction to be executed by the datapath microinstructions Executing the microinstruction is equivalent to asserting the signals specified by the microinstruction Microprogramming Units microinstruction has to specify what signals should be asserted what microinstruction should be executed next Each microinstruction corresponds to one state in the FSM and is assigned a state number (or address ). Sequential behavior increment the state (address) of the current microinstruction to get to the state (address) of the next. Jump to the microinstruction that begins execution of the next MIPS instruction (state ). ranch to a microinstruction based on unit input using dispatch tables (Will Discuss this later!!) - need one for microinstructions following state - need another for microinstructions following state The set of microinstructions that define a MIPS assembly language instruction (macroinstruction) is its microroutine School of Engineering
12 Microcode Implementation Our Microinstruction Format PL Outputs Cond Mem Write Source Op Source Source Field Value al setting Comments dd Op = Cause to add Subt Op = Cause to subtract (compare op for beq) Func code Op = Use function code to determine SRC Src = Use as top input Src = Use reg as top input ddrctl dder Microprogram Counter System clock To Datapath ddr select logic Op5 Op Op Op Op Op sequencing Inst[-6] (Opcode) Defining a Microinstruction Format Format the fields of the microinstruction and the signals that are affected by each field signals specified by a field usually have functions that are related format is chosen to simplify the representation and to make it difficult to write inconsistent microinstructions - i.e., that allow a given signal be set to two different values Make each field of the microinstruction responsible for specifying a nonoverlapping set of signals signals that are never asserted simultaneously may share the same field seven fields for our simple machine - ; SRC; SRC; Register ; ; ; Sequencing Our Microinstruction Format Field Value al setting Comments dd Op = Cause to add Subt Op = Cause to subtract (compare op for beq) Func code Op = Use function code to determine SRC Src = Use as top input Src = Use reg as top input SRC Src = Use reg as bottom input Src = Use as bottom input Src = Use sign ext output as bottom input Extshft Src = Use shift-by-two output as bottom input Our Microinstruction Format Field Value al setting Comments dd Op = Cause to add Subt Op = Cause to subtract (compare op for beq) Func code Op = Use function code to determine Our Microinstruction Format Field Value al setting Comments dd Op = Cause to add Subt Op = Cause to subtract (compare op for beq) Func code Op = Use function code to determine SRC Src = Use as top input Src = Use reg as top input SRC Src = Use reg as bottom input Register Src = Use as bottom input Src = Use sign ext output as bottom input Extshft Src = Use shift-by-two output as bottom input Write Write, =, =, =, = Reg using rs and rt fields of as read addr s; put data into and Write Reg using rd field of as write addr and Out as write data Write Reg using rt field of as write addr and as write data School of Engineering
13 Our Microinstruction Format, con t Field Value al setting Comments Mem, =,Write Write Mem, lord =, = memory using as addr; write result into (and ) memory using Out as addr; write results into Write memory using Out as addr and as write data Creating the Microprogram microinstruction Label (ddr) () SRC SRC Reg dd Seq Seq ing compute + fetch instr write into output into go to µinstr Label field represents the state (address) of the microinstruction microinstruction assigned state (address) Our Microinstruction Format, con t Field Value al setting Comments Mem, =,Write write Write Mem, lord =, = Source = Jump address Source =, Cond Source =, memory using as addr; write result into (and ) memory using Out as addr; write results into Write memory using Out as addr and as write data Write with output of If Zero output of is true, write with the contents of Out Write with jump address after shift-by-two Multicycle Datapath FSM,Write,,= Src= Src= Op= Cond= Mem = Cond= ccess 5 = Cond= = Instr Mem;Write Src= Src= Src= src= Op= Source,Op= Cond= 6 Src= Src= Op= Cond= 7 = = Cond= 8 9 Src= Src= Source= Op= Source= Cond = = Cond= Write ack Our Microinstruction Format, con t Field Value al setting Comments Mem, =,Write write Outcond Sequencing Write Mem, lord =, = Source = Outcond Jump address Source =, Cond Source =, memory using as addr; write result into (and ) memory using Out as addr; write results into Write memory using Out as addr and as write data Write with output of If Zero output of is true, write with the contents of Out Write with jump address after shift-by-two Seq ddrctl = Choose next microinstruction sequentially ddrctl = Jump to the first microinstruction (i.e., ) to begin a new instruction Dispatch ddrctl = ranch using PL_ Dispatch ddrctl = ranch using PL_ The Entire Microprogram ddr SRC SRC Reg Seq ing dd Seq dd Ext shft Disp dd Disp Seq Write 5 Write 6 Func code Seq 7 Write 8 Subt Outcond 9 Jump address School of Engineering
14 Multicycle Datapath FSM,Write,,= Src= Src= Op= Cond= Mem = Cond= ccess = Instr Mem;Write Src= Src= Src= src= Op= Source,Op= Cond= 5 = Cond= 6 Src= Src= Op= Cond= 7 = = Cond= 8 9 Src= Src= Source= Op= Source= Cond = = Cond= Write ack Implementing Dispatches School of Engineering
15 Multicycle dvantages & Disadvantages Uses the clock cycle efficiently the clock cycle is timed to accommodate the slowest instruction step balance the amount of work to be done in each step restrict each step to use only one major functional unit Multicycle implementations allow faster clock rates different instructions to take a different number of clock cycles functional units to be used more than once per instruction as long as they are used on different clock cycles but Requires additional internal state registers, muxes, and more complicated (FSM) 85 Path Design lternatives Single Cycle vs. Multiple Cycle Timing Initial representation Sequencing Logic representation Implementation technique Finite state diagram Microprogram Explicit next Microprogram counter state function + dispatch PLs Logic equations Programmable Logic rray (PL) Microcode ROM/RM Single Cycle Implementation: Clk Clk Cycle Cycle Cycle lw sw Waste multicycle clock slower than /5 th of single cycle clock Multiple Cycle Implementation: due to state register overhead Cycle Cycle Cycle Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9 Cycle Microprogram representation advantages Easier to design, write, and debug lw I Dec Exec Mem W sw I Dec Exec Mem R-type I Summary 87 School of Engineering 5
Computer Science 141 Computing Hardware
Computer Science 4 Computing Hardware Fall 6 Harvard University Instructor: Prof. David Brooks dbrooks@eecs.harvard.edu Upcoming topics Mon, Nov th MIPS Basic Architecture (Part ) Wed, Nov th Basic Computer
More informationCENG 3420 Lecture 06: Datapath
CENG 342 Lecture 6: Datapath Bei Yu byu@cse.cuhk.edu.hk CENG342 L6. Spring 27 The Processor: Datapath & Control q We're ready to look at an implementation of the MIPS q Simplified to contain only: memory-reference
More informationCENG 3420 Computer Organization and Design. Lecture 06: MIPS Processor - I. Bei Yu
CENG 342 Computer Organization and Design Lecture 6: MIPS Processor - I Bei Yu CEG342 L6. Spring 26 The Processor: Datapath & Control q We're ready to look at an implementation of the MIPS q Simplified
More informationReview: Abstract Implementation View
Review: Abstract Implementation View Split memory (Harvard) model - single cycle operation Simplified to contain only the instructions: memory-reference instructions: lw, sw arithmetic-logical instructions:
More informationSystems Architecture I
Systems Architecture I Topics A Simple Implementation of MIPS * A Multicycle Implementation of MIPS ** *This lecture was derived from material in the text (sec. 5.1-5.3). **This lecture was derived from
More informationCPE 335 Computer Organization. Basic MIPS Architecture Part I
CPE 335 Computer Organization Basic MIPS Architecture Part I Dr. Iyad Jafar Adapted from Dr. Gheith Abandah slides http://www.abandah.com/gheith/courses/cpe335_s8/index.html CPE232 Basic MIPS Architecture
More informationThe Processor: Datapath & Control
Chapter Five 1 The Processor: Datapath & Control We're ready to look at an implementation of the MIPS Simplified to contain only: memory-reference instructions: lw, sw arithmetic-logical instructions:
More informationCC 311- Computer Architecture. The Processor - Control
CC 311- Computer Architecture The Processor - Control Control Unit Functions: Instruction code Control Unit Control Signals Select operations to be performed (ALU, read/write, etc.) Control data flow (multiplexor
More informationLecture Topics. Announcements. Today: Single-Cycle Processors (P&H ) Next: continued. Milestone #3 (due 2/9) Milestone #4 (due 2/23)
Lecture Topics Today: Single-Cycle Processors (P&H 4.1-4.4) Next: continued 1 Announcements Milestone #3 (due 2/9) Milestone #4 (due 2/23) Exam #1 (Wednesday, 2/15) 2 1 Exam #1 Wednesday, 2/15 (3:00-4:20
More informationELEC 5200/6200 Computer Architecture and Design Spring 2017 Lecture 4: Datapath and Control
ELEC 52/62 Computer Architecture and Design Spring 217 Lecture 4: Datapath and Control Ujjwal Guin, Assistant Professor Department of Electrical and Computer Engineering Auburn University, Auburn, AL 36849
More informationCPE 335. Basic MIPS Architecture Part II
CPE 335 Computer Organization Basic MIPS Architecture Part II Dr. Iyad Jafar Adapted from Dr. Gheith Abandah slides http://www.abandah.com/gheith/courses/cpe335_s08/index.html CPE232 Basic MIPS Architecture
More informationCO Computer Architecture and Programming Languages CAPL. Lecture 18 & 19
CO2-3224 Computer Architecture and Programming Languages CAPL Lecture 8 & 9 Dr. Kinga Lipskoch Fall 27 Single Cycle Disadvantages & Advantages Uses the clock cycle inefficiently the clock cycle must be
More informationImplementing the Control. Simple Questions
Simple Questions How many cycles will it take to execute this code? lw $t2, 0($t3) lw $t3, 4($t3) beq $t2, $t3, Label add $t5, $t2, $t3 sw $t5, 8($t3) Label:... #assume not What is going on during the
More informationENE 334 Microprocessors
ENE 334 Microprocessors Lecture 6: Datapath and Control : Dejwoot KHAWPARISUTH Adapted from Computer Organization and Design, 3 th & 4 th Edition, Patterson & Hennessy, 2005/2008, Elsevier (MK) http://webstaff.kmutt.ac.th/~dejwoot.kha/
More informationMulticycle Approach. Designing MIPS Processor
CSE 675.2: Introduction to Computer Architecture Multicycle Approach 8/8/25 Designing MIPS Processor (Multi-Cycle) Presentation H Slides by Gojko Babić and Elsevier Publishing We will be reusing functional
More informationLecture 5 and 6. ICS 152 Computer Systems Architecture. Prof. Juan Luis Aragón
ICS 152 Computer Systems Architecture Prof. Juan Luis Aragón Lecture 5 and 6 Multicycle Implementation Introduction to Microprogramming Readings: Sections 5.4 and 5.5 1 Review of Last Lecture We have seen
More informationSystems Architecture
Systems Architecture Lecture 15: A Simple Implementation of MIPS Jeremy R. Johnson Anatole D. Ruslanov William M. Mongan Some or all figures from Computer Organization and Design: The Hardware/Software
More information5.7. Microprogramming: Simplifying Control Design 5.7
5.7 Microprogramming: Simplifying Control Design 5.7 For the of our simple MIPS subset, a graphical representation of the finite state machine, as in Figure 5.40 on page 345, is certainly adequate. We
More informationLets Build a Processor
Lets Build a Processor Almost ready to move into chapter 5 and start building a processor First, let s review Boolean Logic and build the ALU we ll need (Material from Appendix B) operation a 32 ALU result
More informationLecture 3: The Processor (Chapter 4 of textbook) Chapter 4.1
Lecture 3: The Processor (Chapter 4 of textbook) Chapter 4.1 Introduction Chapter 4.1 Chapter 4.2 Review: MIPS (RISC) Design Principles Simplicity favors regularity fixed size instructions small number
More informationMicroprogrammed Control Approach
Microprogrammed Control Approach Considering the FSM for our MIPS subset has 10 states, the complete MIPS instruction set, which contains more than 100 instructions, and considering that these instructions
More informationCS Computer Architecture Spring Week 10: Chapter
CS 35101 Computer Architecture Spring 2008 Week 10: Chapter 5.1-5.3 Materials adapated from Mary Jane Irwin (www.cse.psu.edu/~mji) and Kevin Schaffer [adapted from D. Patterson slides] CS 35101 Ch 5.1
More informationECE232: Hardware Organization and Design
ECE232: Hardware Organization and Design Lecture 14: One Cycle MIPs Datapath Adapted from Computer Organization and Design, Patterson & Hennessy, UCB R-Format Instructions Read two register operands Perform
More informationChapter 4 The Processor (Part 2)
Department of Electr rical Eng ineering, Chapter 4 The Processor (Part 2) 王振傑 (Chen-Chieh Wang) ccwang@mail.ee.ncku.edu.tw ncku edu Feng-Chia Unive ersity Outline A Multicycle Implementation Mapping Control
More informationThe overall datapath for RT, lw,sw beq instrucution
Designing The Main Control Unit: Remember the three instruction classes {R-type, Memory, Branch}: a) R-type : Op rs rt rd shamt funct 1.src 2.src dest. 31-26 25-21 20-16 15-11 10-6 5-0 a) Memory : Op rs
More informationLECTURE 5. Single-Cycle Datapath and Control
LECTURE 5 Single-Cycle Datapath and Control PROCESSORS In lecture 1, we reminded ourselves that the datapath and control are the two components that come together to be collectively known as the processor.
More informationMark Redekopp and Gandhi Puvvada, All rights reserved. EE 357 Unit 15. Single-Cycle CPU Datapath and Control
EE 37 Unit Single-Cycle CPU path and Control CPU Organization Scope We will build a CPU to implement our subset of the MIPS ISA Memory Reference Instructions: Load Word (LW) Store Word (SW) Arithmetic
More informationLearning Outcomes. Spiral 3-3. Sorting: Software Implementation REVIEW
3-3. Learning Outcomes 3-3. Spiral 3-3 Single Cycle CPU I understand how the single-cycle CPU datapath supports each type of instruction I understand why each mux is needed to select appropriate inputs
More informationChapter 4 The Processor 1. Chapter 4A. The Processor
Chapter 4 The Processor 1 Chapter 4A The Processor Chapter 4 The Processor 2 Introduction CPU performance factors Instruction count Determined by ISA and compiler CPI and Cycle time Determined by CPU hardware
More informationMulticycle conclusion
Multicycle conclusion The last few lectures covered a lot of material! We introduced a multicycle datapath, where different instructions take different numbers of cycles to execute. A multicycle unit is
More informationProcessor (I) - datapath & control. Hwansoo Han
Processor (I) - datapath & control Hwansoo Han Introduction CPU performance factors Instruction count - Determined by ISA and compiler CPI and Cycle time - Determined by CPU hardware We will examine two
More informationCOMPUTER ORGANIZATION AND DESIGN. 5 th Edition. The Hardware/Software Interface. Chapter 4. The Processor
COMPUTER ORGANIZATION AND DESIGN The Hardware/Software Interface 5 th Edition Chapter 4 The Processor Introduction CPU performance factors Instruction count Determined by ISA and compiler CPI and Cycle
More informationMapping Control to Hardware
C A P P E N D I X A custom format such as this is slave to the architecture of the hardware and the instruction set it serves. The format must strike a proper compromise between ROM size, ROM-output decoding,
More informationLecture 8: Control COS / ELE 375. Computer Architecture and Organization. Princeton University Fall Prof. David August
Lecture 8: Control COS / ELE 375 Computer Architecture and Organization Princeton University Fall 2015 Prof. David August 1 Datapath and Control Datapath The collection of state elements, computation elements,
More informationOutline of today s lecture. EEL-4713 Computer Architecture Designing a Multiple-Cycle Processor. What s wrong with our CPI=1 processor?
Outline of today s lecture EEL-7 Computer Architecture Designing a Multiple-Cycle Processor Recap and Introduction Introduction to the Concept of Multiple Cycle Processor Multiple Cycle Implementation
More informationCOMPUTER ORGANIZATION AND DESIGN. 5 th Edition. The Hardware/Software Interface. Chapter 4. The Processor
COMPUTER ORGANIZATION AND DESIGN The Hardware/Software Interface 5 th Edition Chapter 4 The Processor COMPUTER ORGANIZATION AND DESIGN The Hardware/Software Interface 5 th Edition The Processor - Introduction
More informationChapter 4. Instruction Execution. Introduction. CPU Overview. Multiplexers. Chapter 4 The Processor 1. The Processor.
COMPUTER ORGANIZATION AND DESIGN The Hardware/Software Interface 5 th Edition COMPUTER ORGANIZATION AND DESIGN The Hardware/Software Interface 5 th Edition Chapter 4 The Processor The Processor - Introduction
More informationﻪﺘﻓﺮﺸﻴﭘ ﺮﺗﻮﻴﭙﻣﺎﻛ يرﺎﻤﻌﻣ MIPS يرﺎﻤﻌﻣ data path and ontrol control
معماري كامپيوتر پيشرفته معماري MIPS data path and control abbasi@basu.ac.ir Topics Building a datapath support a subset of the MIPS-I instruction-set A single cycle processor datapath all instruction actions
More informationTopic #6. Processor Design
Topic #6 Processor Design Major Goals! To present the single-cycle implementation and to develop the student's understanding of combinational and clocked sequential circuits and the relationship between
More informationDesigning a Multicycle Processor
Designing a Multicycle Processor Arquitectura de Computadoras Arturo Díaz D PérezP Centro de Investigación n y de Estudios Avanzados del IPN adiaz@cinvestav.mx Arquitectura de Computadoras Multicycle-
More informationThe Processor (1) Jinkyu Jeong Computer Systems Laboratory Sungkyunkwan University
The Processor (1) Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu EEE3050: Theory on Computer Architectures, Spring 2017, Jinkyu Jeong (jinkyu@skku.edu)
More informationThe Big Picture: Where are We Now? EEM 486: Computer Architecture. Lecture 3. Designing a Single Cycle Datapath
The Big Picture: Where are We Now? EEM 486: Computer Architecture Lecture 3 The Five Classic Components of a Computer Processor Input Control Memory Designing a Single Cycle path path Output Today s Topic:
More informationCOMPUTER ORGANIZATION AND DESIGN. The Hardware/Software Interface. Chapter 4. The Processor: A Based on P&H
COMPUTER ORGANIZATION AND DESIGN The Hardware/Software Interface Chapter 4 The Processor: A Based on P&H Introduction We will examine two MIPS implementations A simplified version A more realistic pipelined
More informationProcessor: Multi- Cycle Datapath & Control
Processor: Multi- Cycle Datapath & Control (Based on text: David A. Patterson & John L. Hennessy, Computer Organization and Design: The Hardware/Software Interface, 3 rd Ed., Morgan Kaufmann, 27) COURSE
More informationEECE 417 Computer Systems Architecture
EECE 417 Computer Systems Architecture Department of Electrical and Computer Engineering Howard University Charles Kim Spring 2007 1 Computer Organization and Design (3 rd Ed) -The Hardware/Software Interface
More informationThe Processor. Z. Jerry Shi Department of Computer Science and Engineering University of Connecticut. CSE3666: Introduction to Computer Architecture
The Processor Z. Jerry Shi Department of Computer Science and Engineering University of Connecticut CSE3666: Introduction to Computer Architecture Introduction CPU performance factors Instruction count
More informationChapter 4. The Processor
Chapter 4 The Processor Introduction CPU performance factors Instruction count Determined by ISA and compiler CPI and Cycle time Determined by CPU hardware We will examine two MIPS implementations A simplified
More informationTDT4255 Computer Design. Lecture 4. Magnus Jahre. TDT4255 Computer Design
1 TDT4255 Computer Design Lecture 4 Magnus Jahre 2 Outline Chapter 4.1 to 4.4 A Multi-cycle Processor Appendix D 3 Chapter 4 The Processor Acknowledgement: Slides are adapted from Morgan Kaufmann companion
More informationInitial Representation Finite State Diagram. Logic Representation Logic Equations
Control Implementation Alternatives Control may be designed using one of several initial representations. The choice of sequence control, and how logic is represented, can then be determined independently;
More informationLecture 5: The Processor
Lecture 5: The Processor CSCE 26 Computer Organization Instructor: Saraju P. ohanty, Ph. D. NOTE: The figures, text etc included in slides are borrowed from various books, websites, authors pages, and
More informationECE468 Computer Organization and Architecture. Designing a Multiple Cycle Controller
ECE468 Computer Organization and Architecture Designing a Multiple Cycle Controller ECE468 multicontroller Review of a Multiple Cycle Implementation The root of the single cycle processor s problems: The
More informationCOMP303 Computer Architecture Lecture 9. Single Cycle Control
COMP33 Computer Architecture Lecture 9 Single Cycle Control A Single Cycle Datapath We have everything except control signals (underlined) RegDst busw Today s lecture will look at how to generate the control
More informationInitial Representation Finite State Diagram Microprogram. Sequencing Control Explicit Next State Microprogram counter
Control Implementation Alternatives Control may be designed using one of several initial representations. The choice of sequence control, and how logic is represented, can then be determined independently;
More informationECE170 Computer Architecture. Single Cycle Control. Review: 3b: Add & Subtract. Review: 3e: Store Operations. Review: 3d: Load Operations
ECE7 Computer Architecture Single Cycle Control Review: 3a: Overview of the Fetch Unit The common operations Fetch the : mem[] Update the program counter: Sequential Code: < + Branch and Jump: < something
More informationRISC Processor Design
RISC Processor Design Single Cycle Implementation - MIPS Virendra Singh Indian Institute of Science Bangalore virendra@computer.org Lecture 13 SE-273: Processor Design Feb 07, 2011 SE-273@SERC 1 Courtesy:
More informationCOMP303 - Computer Architecture Lecture 8. Designing a Single Cycle Datapath
COMP33 - Computer Architecture Lecture 8 Designing a Single Cycle Datapath The Big Picture The Five Classic Components of a Computer Processor Input Control Memory Datapath Output The Big Picture: The
More informationCS/COE0447: Computer Organization
CS/COE0447: Computer Organization and Assembly Language Datapath and Control Sangyeun Cho Dept. of Computer Science A simple MIPS We will design a simple MIPS processor that supports a small instruction
More informationCS/COE0447: Computer Organization
A simple MIPS CS/COE447: Computer Organization and Assembly Language Datapath and Control Sangyeun Cho Dept. of Computer Science We will design a simple MIPS processor that supports a small instruction
More informationChapter 4. The Processor. Instruction count Determined by ISA and compiler. We will examine two MIPS implementations
Chapter 4 The Processor Part I Introduction CPU performance factors Instruction count Determined by ISA and compiler CPI and Cycle time Determined by CPU hardware We will examine two MIPS implementations
More informationChapter 4. The Processor
Chapter 4 The Processor Introduction CPU performance factors Instruction count Determined by ISA and compiler CPI and Cycle time Determined by CPU hardware 4.1 Introduction We will examine two MIPS implementations
More information361 datapath.1. Computer Architecture EECS 361 Lecture 8: Designing a Single Cycle Datapath
361 datapath.1 Computer Architecture EECS 361 Lecture 8: Designing a Single Cycle Datapath Outline of Today s Lecture Introduction Where are we with respect to the BIG picture? Questions and Administrative
More informationCS61C : Machine Structures
CS 61C L path (1) insteecsberkeleyedu/~cs61c/su6 CS61C : Machine Structures Lecture # path natomy: 5 components of any Computer Personal Computer -7-25 This week Computer Processor ( brain ) path ( brawn
More informationOutline. EEL-4713 Computer Architecture Designing a Single Cycle Datapath
Outline EEL-473 Computer Architecture Designing a Single Cycle path Introduction The steps of designing a processor path and timing for register-register operations path for logical operations with immediates
More informationMajor CPU Design Steps
Datapath Major CPU Design Steps. Analyze instruction set operations using independent RTN ISA => RTN => datapath requirements. This provides the the required datapath components and how they are connected
More informationComputer Science 324 Computer Architecture Mount Holyoke College Fall Topic Notes: Data Paths and Microprogramming
Computer Science 324 Computer Architecture Mount Holyoke College Fall 2007 Topic Notes: Data Paths and Microprogramming We have spent time looking at the MIPS instruction set architecture and building
More informationCSE140: Components and Design Techniques for Digital Systems
CSE4: Components and Design Techniques for Digital Systems Tajana Simunic Rosing Announcements and Outline Check webct grades, make sure everything is there and is correct Pick up graded d homework at
More informationECE369. Chapter 5 ECE369
Chapter 5 1 State Elements Unclocked vs. Clocked Clocks used in synchronous logic Clocks are needed in sequential logic to decide when an element that contains state should be updated. State element 1
More informationCPU Organization (Design)
ISA Requirements CPU Organization (Design) Datapath Design: Capabilities & performance characteristics of principal Functional Units (FUs) needed by ISA instructions (e.g., Registers, ALU, Shifters, Logic
More informationECE 313 Computer Organization EXAM 2 November 9, 2001
ECE 33 Computer Organization EA 2 November 9, 2 This exam is open book and open notes. You have 5 minutes. Credit for problems requiring calculation will be given only if you show your work. Choose and
More informationECE 361 Computer Architecture Lecture 11: Designing a Multiple Cycle Controller. Review of a Multiple Cycle Implementation
ECE 6 Computer Architecture Lecture : Designing a Multiple Cycle ler 6 multicontroller. Review of a Multiple Cycle Implementation The root of the single cycle processor s problems: The cycle time has to
More informationThe Processor: Datapath and Control. Jin-Soo Kim Computer Systems Laboratory Sungkyunkwan University
The Processor: Datapath and Control Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu Introduction CPU performance factors Instruction count Determined
More informationRISC Design: Multi-Cycle Implementation
RISC Design: Multi-Cycle Implementation Virendra Singh Associate Professor Computer Architecture and Dependable Systems Lab Department of Electrical Engineering Indian Institute of Technology Bombay http://www.ee.iitb.ac.in/~viren/
More informationChapter 4. The Processor. Computer Architecture and IC Design Lab
Chapter 4 The Processor Introduction CPU performance factors CPI Clock Cycle Time Instruction count Determined by ISA and compiler CPI and Cycle time Determined by CPU hardware We will examine two MIPS
More informationInf2C - Computer Systems Lecture Processor Design Single Cycle
Inf2C - Computer Systems Lecture 10-11 Processor Design Single Cycle Boris Grot School of Informatics University of Edinburgh Previous lectures Combinational circuits Combinations of gates (INV, AND, OR,
More informationECE260: Fundamentals of Computer Engineering
Datapath for a Simplified Processor James Moscola Dept. of Engineering & Computer Science York College of Pennsylvania Based on Computer Organization and Design, 5th Edition by Patterson & Hennessy Introduction
More informationCS3350B Computer Architecture Winter 2015
CS3350B Computer Architecture Winter 2015 Lecture 5.5: Single-Cycle CPU Datapath Design Marc Moreno Maza www.csd.uwo.ca/courses/cs3350b [Adapted from lectures on Computer Organization and Design, Patterson
More informationProcessor (multi-cycle)
CS359: Computer Architecture Processor (multi-cycle) Yanyan Shen Department of Computer Science and Engineering Five Instruction Steps ) Instruction Fetch ) Instruction Decode and Register Fetch 3) R-type
More informationEECE 417 Computer Systems Architecture
EECE 417 Computer Systems Architecture Department of Electrical and Computer Engineering Howard University Charles Kim Spring 2007 1 Computer Organization and Design (3 rd Ed) -The Hardware/Software Interface
More informationComputer and Information Sciences College / Computer Science Department The Processor: Datapath and Control
Computer and Information Sciences College / Computer Science Department The Processor: Datapath and Control Chapter 5 The Processor: Datapath and Control Big Picture: Where are We Now? Performance of a
More informationCh 5: Designing a Single Cycle Datapath
Ch 5: esigning a Single Cycle path Computer Systems Architecture CS 365 The Big Picture: Where are We Now? The Five Classic Components of a Computer Processor Control Memory path Input Output Today s Topic:
More informationOutline. Combinational Element. State (Sequential) Element. Clocking Methodology. Input/Output of Elements
Outline ombinational Element ombinational & sequential logic Single-cycle PU ulti-cycle PU Examples of ombinational Elements State (Sequential) Element! "#$$$ #$$ #$$ #$ # & & ) *.// * - + #3, * + - locking
More informationComputer Architecture. Lecture 6.1: Fundamentals of
CS3350B Computer Architecture Winter 2015 Lecture 6.1: Fundamentals of Instructional Level Parallelism Marc Moreno Maza www.csd.uwo.ca/courses/cs3350b [Adapted from lectures on Computer Organization and
More informationENGN1640: Design of Computing Systems Topic 04: Single-Cycle Processor Design
ENGN64: Design of Computing Systems Topic 4: Single-Cycle Processor Design Professor Sherief Reda http://scale.engin.brown.edu Electrical Sciences and Computer Engineering School of Engineering Brown University
More informationare Softw Instruction Set Architecture Microarchitecture are rdw
Program, Application Software Programming Language Compiler/Interpreter Operating System Instruction Set Architecture Hardware Microarchitecture Digital Logic Devices (transistors, etc.) Solid-State Physics
More informationThe Processor: Datapath & Control
Orange Coast College Business Division Computer Science Department CS 116- Computer Architecture The Processor: Datapath & Control Processor Design Step 3 Assemble Datapath Meeting Requirements Build the
More informationFundamentals of Computer Systems
Fundamentals of Computer Systems Single Cycle MIPS Processor Stephen. Edwards Columbia University Summer 26 Illustrations Copyright 27 Elsevier The path The lw The sw R-Type s The beq The Controller Encoding
More informationEECS150 - Digital Design Lecture 10- CPU Microarchitecture. Processor Microarchitecture Introduction
EECS150 - Digital Design Lecture 10- CPU Microarchitecture Feb 18, 2010 John Wawrzynek Spring 2010 EECS150 - Lec10-cpu Page 1 Processor Microarchitecture Introduction Microarchitecture: how to implement
More informationECE468 Computer Organization and Architecture. Designing a Single Cycle Datapath
ECE468 Computer Organization and Architecture Designing a Single Cycle Datapath ECE468 datapath1 The Big Picture: Where are We Now? The Five Classic Components of a Computer Processor Control Input Datapath
More informationChapter 4. The Processor
Chapter 4 The Processor Introduction CPU performance factors Instruction count Determined by ISA and compiler CPI and Cycle time Determined by CPU hardware We will examine two MIPS implementations A simplified
More informationRecap: A Single Cycle Datapath. CS 152 Computer Architecture and Engineering Lecture 8. Single-Cycle (Con t) Designing a Multicycle Processor
CS 52 Computer Architecture and Engineering Lecture 8 Single-Cycle (Con t) Designing a Multicycle Processor February 23, 24 John Kubiatowicz (www.cs.berkeley.edu/~kubitron) lecture slides: http://inst.eecs.berkeley.edu/~cs52/
More informationCS359: Computer Architecture. The Processor (A) Yanyan Shen Department of Computer Science and Engineering
CS359: Computer Architecture The Processor (A) Yanyan Shen Department of Computer Science and Engineering Eecuting R-type Instructions 7 Instructions ADD and subtract add rd, rs, rt sub rd, rs, rt OR Immediate:
More informationData paths for MIPS instructions
You are familiar with how MIPS programs step from one instruction to the next, and how branches can occur conditionally or unconditionally. We next examine the machine level representation of how MIPS
More informationComputer Architecture
CS3350B Computer Architecture Winter 2015 Lecture 4.2: MIPS ISA -- Instruction Representation Marc Moreno Maza www.csd.uwo.ca/courses/cs3350b [Adapted from lectures on Computer Organization and Design,
More informationChapter 4. The Processor Designing the datapath
Chapter 4 The Processor Designing the datapath Introduction CPU performance determined by Instruction Count Clock Cycles per Instruction (CPI) and Cycle time Determined by Instruction Set Architecure (ISA)
More informationReview. N-bit adder-subtractor done using N 1- bit adders with XOR gates on input. Lecture #19 Designing a Single-Cycle CPU
CS6C L9 CPU Design : Designing a Single-Cycle CPU () insteecsberkeleyedu/~cs6c CS6C : Machine Structures Lecture #9 Designing a Single-Cycle CPU 27-7-26 Scott Beamer Instructor AI Focuses on Poker Review
More informationThe MIPS Processor Datapath
The MIPS Processor Datapath Module Outline MIPS datapath implementation Register File, Instruction memory, Data memory Instruction interpretation and execution. Combinational control Assignment: Datapath
More informationLecture 10: Simple Data Path
Lecture 10: Simple Data Path Course so far Performance comparisons Amdahl s law ISA function & principles What do bits mean? Computer math Today Take QUIZ 6 over P&H.1-, before 11:59pm today How do computers
More informationCpE242 Computer Architecture and Engineering Designing a Single Cycle Datapath
CpE242 Computer Architecture and Engineering Designing a Single Cycle Datapath CPE 442 single-cycle datapath.1 Outline of Today s Lecture Recap and Introduction Where are we with respect to the BIG picture?
More informationSingle Cycle Datapath
Single Cycle atapath Lecture notes from MKP, H. H. Lee and S. Yalamanchili Section 4.1-4.4 Appendices B.3, B.7, B.8, B.11,.2 ing Note: Appendices A-E in the hardcopy text correspond to chapters 7-11 in
More informationEECS150 - Digital Design Lecture 9- CPU Microarchitecture. Watson: Jeopardy-playing Computer
EECS150 - Digital Design Lecture 9- CPU Microarchitecture Feb 15, 2011 John Wawrzynek Spring 2011 EECS150 - Lec09-cpu Page 1 Watson: Jeopardy-playing Computer Watson is made up of a cluster of ninety IBM
More information