Practice Exam 4 Fall 2018: For Each Instruction, Indicate Wh ✓ Solved

Practice Exam 4 Fall 2018: For each instruction, indicate wh

Practice Exam 4 Fall 2018: For each instruction, indicate which sequence of micro-operations best implements it: 1) MOV CAT,AX 2) MOV AX,CAT 3) JZ LOOPX (when Z flag = 1) 4) JMP LOOPX 5) PUSH EAX 6) POP EBX 7) CALL ABC 8) RET 9) If MAR is 12 bits, how many memory cells (bytes) can you address? 10) For 4096 bytes memory, how many bits should MAR be? Study list: 1) What is a register-to-register transfer? 2) What registers are loaded to perform a memory read? 3) What registers are loaded to perform a memory write? 4) What is a decoder? 5) How is the ring counter used to perform an instruction? 6) What is the sequence of circuits for CALL, RET, PUSH AX, POP AX, PUSH EAX, POP EAX, MOV CAT,AX, MOV AX,CAT, JMP LOOPX.

Paper For Above Instructions

Introduction

This paper answers the practice-exam prompts by describing the typical micro-operation sequences for each instruction, explains addressing with the Memory Address Register (MAR), and addresses the study-list conceptual questions. The micro-operation patterns follow common von Neumann fetch-execute cycles and stack-call conventions used in many instructional computer-architecture texts (Hennessy & Patterson, 2017; Mano, 2017).

Fetch cycle (common preface)

Before executing nearly every instruction the processor performs a fetch cycle: IP->MAR; MEM[MAR] -> MDR; MDR -> IR; update IP (for example IP + instruction length -> IP). This fetch sequence places the instruction opcode and operand fields into IR and prepares the IP for the next instruction (Hennessy & Patterson, 2017).

1) MOV CAT,AX (store AX to memory label CAT)

Semantic goal: store AX into memory at address CAT. Typical micro-operations after fetch:

  • ADDR(IR) -> MAR (place address field of instruction into MAR)
  • AX -> MDR (place register data into the memory data register)
  • MDR -> MEM[MAR] (write data to memory location CAT)
  • IP + instrLength -> IP (finalize fetch/advance IP)

This sequence writes the contents of AX into memory; MAR and MDR coordinate address and data (Mano, 2017).

2) MOV AX,CAT (load memory label CAT into AX)

Semantic goal: load AX from memory at address CAT. Typical micro-operations:

  • ADDR(IR) -> MAR
  • MEM[MAR] -> MDR
  • MDR -> AX
  • IP + instrLength -> IP

The data flows from memory into MDR, then into register AX (Hennessy & Patterson, 2017).

3) JZ LOOPX (conditional jump when Z flag = 1)

Semantic goal: if zero-flag Z is set, load IP with target address; otherwise continue. Typical micro-operations:

  • Check Z flag; if Z = 1 then ADDR(IR) -> IP
  • Else IP + instrLength -> IP

Implementations often place the decision after the fetch cycle; the ADDR(IR) -> IP micro-op implements the jump (Stallings, 2016).

4) JMP LOOPX (unconditional jump)

Semantic goal: set IP to target address unconditionally. After fetch:

  • ADDR(IR) -> IP

There is no conditional evaluation; the IP is loaded with the jump target (Patterson & Hennessy, 2013).

5) PUSH EAX

Semantic goal: push register EAX onto the stack (assuming full-descending stack). Typical micro-operations:

  • ESP ESP)
  • ESP -> MAR
  • EAX -> MDR
  • MDR -> MEM[MAR]
  • IP + instrLength -> IP

The decrement of the stack pointer precedes the memory write so the new top-of-stack receives the pushed value (Tanenbaum, 2016).

6) POP EBX

Semantic goal: pop top-of-stack into EBX. Typical micro-operations:

  • ESP -> MAR
  • MEM[MAR] -> MDR
  • MDR -> EBX
  • ESP ESP)
  • IP + instrLength -> IP

This reads the memory at the stack pointer into MDR, transfers to EBX, then increments ESP (Mano, 2017).

7) CALL ABC

Semantic goal: push return address (IP of next instruction) then jump to procedure ABC. Typical micro-operations:

  • Compute return address: IP + instrLength -> TEMP (or MDR)
  • ESP
  • ESP -> MAR
  • TEMP -> MDR (return address into MDR)
  • MDR -> MEM[MAR] (store return address on stack)
  • ADDR(IR) -> IP (load procedure entry address)

Call combines a push of the return address and updating IP to the called routine (Hennessy & Patterson, 2017).

8) RET

Semantic goal: pop return address from stack into IP and resume execution there. Typical micro-operations:

  • ESP -> MAR
  • MEM[MAR] -> MDR
  • MDR -> IP
  • ESP

Some designs update ESP before or after the memory read depending on stack convention; the essential effect is restoring IP from the top of stack (Stallings, 2016).

9) MAR width and addressable memory

If the Memory Address Register (MAR) is 12 bits, it can represent 2^12 distinct addresses. Thus it can address 4096 memory cells (bytes) (2^12 = 4096 ≈ 4 KB) (Patterson & Hennessy, 2013).

10) MAR bits for 4096 bytes

To address 4096 distinct byte addresses (0 through 4095) you need log2(4096) = 12 bits in the MAR. Therefore MAR = 12 bits (Mano, 2017).

Study-list conceptual answers

1) A register-to-register transfer is a micro-operation that moves data from one processor register to another (e.g., AX -> BX) without using main memory. These are implemented by enabling the source register onto an internal bus and loading the destination register (Hamacher et al., 2012).

2) Registers loaded to perform a memory read: the MAR is loaded with the address, the memory read control is asserted, and the memory returns data into the MDR. After the memory read, MDR -> destination register (Hennessy & Patterson, 2017).

3) Registers loaded to perform a memory write: MAR is loaded with the address, MDR is loaded with the data to write (usually from a register), then the memory write control stores MDR into MEM[MAR] (Mano, 2017).

4) A decoder is a combinational circuit that converts an n-bit binary input to one of 2^n mutually exclusive outputs (one-hot), often used to select registers, memory locations, or microinstruction fields (Tanebaum, 2016).

5) A ring counter (or sequencer) is used as a microsequencer to step through time steps (T0, T1, T2...) in the execution of an instruction. Each ring-counter state enables the particular set of micro-operations for that time step (Hennessy & Patterson, 2017).

6) The sequence of circuits for the listed instructions follows the patterns above: fetch (IP->MAR; MEM->MDR; MDR->IR; IP update), then address-forming (ADDR(IR)->MAR), data movement (MDR register), stack pointer updates (ESP +/- wordSize), and memory read/write via MAR/MDR. CALL and RET incorporate stack push/pop of return addresses, while MOV to/from memory uses MAR/MDR to transfer between memory and registers (Mano, 2017; Stallings, 2016).

Conclusion

Understanding the micro-operations underlying each instruction clarifies how the datapath and control sequences implement high-level language semantics. The consistent use of MAR and MDR for address and data movement, the IP updates for sequencing, and the ESP manipulations for stack-based operations are foundational for designing and analyzing simple CPUs (Hennessy & Patterson, 2017; Hamacher et al., 2012).

References

  • Hamacher, C., Vranesic, Z., & Zaky, S. (2012). Computer Organization. McGraw-Hill Education.
  • Hennessy, J. L., & Patterson, D. A. (2017). Computer Architecture: A Quantitative Approach (6th ed.). Morgan Kaufmann.
  • Hennessy, J. L., & Patterson, D. A. (2017). Computer Organization and Design RISC-V Edition: The Hardware/Software Interface. Morgan Kaufmann.
  • Mano, M. M., Kime, C. R., & Cochran, J. R. (2017). Logic and Computer Design Fundamentals (5th ed.). Pearson.
  • Patterson, D. A., & Hennessy, J. L. (2013). Computer Organization and Design (5th ed.). Morgan Kaufmann.
  • Stallings, W. (2016). Computer Organization and Architecture: Designing for Performance (10th ed.). Pearson.
  • Tanenbaum, A. S., & Austin, T. (2016). Structured Computer Organization (6th ed.). Pearson.
  • Wilkes, M. V., Wheeler, D. J., & Gill, S. (1951). The Design of an Electronic Computer. Technical Monograph. (Classic foundational work on microprogramming concepts).
  • Patterson, D. A., Hennessy, J. L., & Ditzel, D. R. (2017). RISC-V Reader: An Open Architecture Atlas. (Practical reference on instruction sequencing and micro-ops.)
  • Smith, J. E. (1995). The microarchitecture of modern processors. ACM Computing Surveys. (Review article on micro-operations and control sequencing.)

Related Assignments