Computer Architecture

  1. Processor Design and Implementation
    1. Basic Processor Components
      1. Clock System
        1. Clock Signal Generation
          1. Clock Distribution
          2. Functional Units
            1. Arithmetic Logic Unit
              1. Register File
                1. Multiplexers
                  1. Program Counter
                    1. Instruction Register
                  2. Datapath Construction
                    1. Instruction Fetch
                      1. Instruction Memory Interface
                        1. Program Counter Management
                        2. Instruction Decode
                          1. Control Signal Generation
                            1. Register Selection
                            2. Execution Stage
                              1. ALU Operations
                                1. Operand Routing
                                2. Memory Access
                                  1. Data Memory Interface
                                    1. Address Calculation
                                    2. Write Back
                                      1. Result Storage
                                        1. Register Updates
                                      2. Single-Cycle Implementation
                                        1. Datapath Design
                                          1. Load/Store Instructions
                                            1. Arithmetic Instructions
                                              1. Branch Instructions
                                              2. Control Unit Design
                                                1. Hardwired Control Logic
                                                  1. Control Signal Timing
                                                  2. Performance Analysis
                                                    1. Critical Path Identification
                                                      1. Cycle Time Determination
                                                    2. Multi-Cycle Implementation
                                                      1. Instruction Decomposition
                                                        1. Fetch Stage
                                                          1. Decode Stage
                                                            1. Execute Stage
                                                              1. Memory Stage
                                                                1. Write Back Stage
                                                                2. Datapath Modifications
                                                                  1. Resource Sharing
                                                                    1. Intermediate Storage
                                                                    2. Control Implementation
                                                                      1. Finite State Machine
                                                                        1. State Transitions
                                                                        2. Performance Comparison
                                                                        3. Microprogrammed Control
                                                                          1. Microcode Concepts
                                                                            1. Microinstructions
                                                                              1. Microprogram Structure
                                                                              2. Control Store Design
                                                                                1. Microinstruction Format
                                                                                  1. Sequencing Logic
                                                                                  2. Implementation Trade-offs

                                                                                Previous

                                                                                3. Instruction Set Architecture

                                                                                Go to top

                                                                                Next

                                                                                5. Pipelining and Performance Enhancement