Bus Organization, Stored-Program Concept & Processing Cycle
Open in the Padhaiko app1.5 Bus organization of computer system
A bus is a shared group of parallel conducting electrical wires (traces) used to transfer binary information (data, memory addresses, and control commands) between the Central Processing Unit (CPU), primary memory modules, and peripheral input/output (I/O) adapters.
The system bus is partitioned into three distinct functional buses according to the nature and directional flow of signals:
- Address Bus:
- Direction: Strictly unidirectional from the CPU to memory and peripheral interfaces (except during Direct Memory Access, DMA, where a DMA controller assumes bus mastership).
- Function: Carries the binary address designating the specific memory cell (byte) or I/O port with which the CPU intends to communicate.
- Capacity: If an address bus possesses k parallel lines, the processor can uniquely address 2^k memory locations. For example, the 16-bit address bus of the Intel 8085 (A0–A15) addresses 2^16 = 65,536 bytes (64 KB).
- Data Bus:
- Direction: Fully bidirectional. Data words flow from memory/input devices into the CPU during Read operations, and from the CPU into memory/output devices during Write operations.
- Function: Transports actual instruction opcodes, numerical operands, and calculation results.
- Width: Determines the word length and architectural class of the computer. An 8-bit CPU (8085) has an 8-bit data bus (D0–D7), while a 16-bit CPU (8086) has a 16-bit data bus (D0–D15).
- Control Bus:
- Direction: Bidirectional / Multidirectional, consisting of individual dedicated control and status signal lines.
- Function: Coordinates and synchronizes system operations. It transmits read/write strobes (MEMR_bar, MEMW_bar, IOR_bar, IOW_bar), synchronization ready signals (READY), master clock pulses (CLK), interrupt requests (INTR), interrupt acknowledgements (INTA_bar), and bus arbitration signals (HOLD, HLDA).
Tristate Logic and Bus Contention
Because multiple memory chips and I/O devices share the same physical data and address bus wires, electrical bus contention (short circuits caused when one device drives a wire to logic 1 (+5 V) while another drives it to logic 0 (0 V)) must be prevented. This is achieved using tristate logic buffers that exhibit three distinct output states:
- Logic High (1): Actively driving the line to +5 V.
- Logic Low (0): Actively pulling the line to 0 V (Ground).
- High-Impedance State (Hi-Z): The output is electronically disconnected (floating) from the bus trace, presenting megaohms of resistance.
At any given instant, the address decoder enables exactly one selected memory or I/O device onto the bus via its Chip Select (CS_bar) pin, while all unselected devices are forced into the Hi-Z state.
+------------------------------------------+
| INTEL 8085 CPU |
+------------------------------------------+
| ^ ^
16-bit Address | | 8-bit Data | Control &
(Unidirectional)| | (Bidir) | Status
v v v
====================+=================+============+================ Address Bus
| | |
| +------------+---------------- Data Bus
| | |
| | +---------------- Control Bus
v v v
+------------------------------------------+
| PRIMARY MEMORY (RAM/ROM) |
+------------------------------------------+
| ^ ^
v v v
+------------------------------------------+
| I/O INTERFACE PORTS |
+------------------------------------------+1.6 Stored program concept (Von Neumann’s architecture)
The stored-program concept, formulated by mathematician John von Neumann in his historic 1945 First Draft of a Report on the EDVAC, is the single most important architectural principle of modern computing.
Stored-Program Concept
The stored-program concept states that:
- Program instructions and application data are encoded in binary form and stored together in the same electronic primary read/write memory (RAM).
- The computer contains an internal register called the Program Counter (PC) that sequentially tracks the memory address of the next instruction to fetch.
- Instructions are executed automatically and sequentially in order of their memory addresses, unless a conditional or unconditional branch instruction alters the Program Counter.
- The physical hardware remains general-purpose and unspecialized; changing the functional task of the machine requires merely loading a new sequence of instructions into memory without rewiring electrical circuits.
Before the stored-program concept (such as in the early ENIAC), reprogramming a computer required physically re-plugging patch cables, rewiring switches, and manually reconfiguring relay panels—a painstaking process taking days.
Von Neumann Architecture vs. Harvard Architecture
In the classical Von Neumann architecture, a single shared physical memory space and a single shared system bus (address and data) hold both instructions and operands.
In contrast, the Harvard architecture (developed for the Harvard Mark I) utilizes physically separated memory units for program instructions (Code Memory) and data operands (Data Memory), accessed simultaneously over two separate, independent address and data bus pathways.
| Aspect | Von Neumann Architecture | Harvard Architecture |
|---|---|---|
| Memory Structure | Single shared memory space for both instructions and data. | Two physically distinct memory modules (Instruction Memory and Data Memory). |
| System Buses | One shared bus set (address and data) for instructions and data. | Separate bus sets: one for instruction fetching and one for data operand transfers. |
| Bus Contention / Bottleneck | Von Neumann Bottleneck: CPU cannot fetch an instruction and read/write data simultaneously. | No contention: instruction fetch and data operand read/write occur in parallel. |
| Circuit Complexity | Simpler hardware design; fewer pins and lower PCB trace routing complexity. | Higher silicon complexity; requires double the bus routing and higher chip pin counts. |
| Execution Throughput | Lower instruction throughput due to sequential sharing of the single bus. | Higher throughput; ideal for pipelined processors, DSPs, and microcontrollers. |
| Representative Systems | Intel 8085, Intel 8086, general-purpose PC system architectures. | Microchip PIC, AVR (ATmega328P), ARM Cortex (separate L1 instruction and data caches). |
The Von Neumann Bottleneck
Because a Von Neumann computer must use the same physical bus to fetch an instruction opcode and subsequently access data operands, the memory bus becomes an unavoidable performance throttle called the Von Neumann Bottleneck. CPU execution cores operate at clock speeds far exceeding memory bus throughput; the CPU frequently sits idle waiting for memory reads and writes to complete. Modern processors mitigate this bottleneck using multi-level on-chip caches (L1 Instruction and Data caches), instruction prefetch queues, branch prediction, and pipelining.
1.7 Processing cycle of a stored program computer
The processing cycle (or instruction execution cycle) is the continuous, repetitive sequence of elementary hardware steps through which the CPU fetches, decodes, and executes every machine instruction stored in memory.
The Instruction Cycle Hierarchy
The operation of a microprocessor is structured in a strict hierarchical timing division:
- Instruction Cycle: The total elapsed time and sequence of steps required to fetch an instruction from memory and completely execute it.
- Machine Cycle: The basic external bus transaction required to access memory or an I/O device. An instruction cycle consists of one to five machine cycles (e.g., Opcode Fetch, Memory Read, Memory Write, I/O Read, I/O Write).
- T-State (Clock Period): The smallest fundamental unit of processor timing, defined as one complete period of the internal master clock oscillator (T = 1 / f_clock). A machine cycle consists of three to six T-states (labeled T1, T2, T3, T4, T5, T6).
The Three Phases of the Processing Cycle
Every instruction cycle is divided into three fundamental sequential phases:
1. The Fetch Phase (Opcode Fetch)
- Step A: The CPU places the 16-bit address held in the Program Counter (PC) onto the address bus.
- Step B: The control unit asserts the Memory Read (MEMR_bar) control strobe (logic 0).
- Step C: The addressed memory location places the instruction opcode onto the data bus.
- Step D: The CPU reads the opcode byte from the data bus into the internal Instruction Register (IR).
- Step E: The Program Counter is automatically incremented (
PC <- PC + 1) to point to the next sequential memory address.
2. The Decode Phase
- The opcode stored in the Instruction Register (IR) is routed to the Instruction Decoder.
- Combinational logic decodes the bit patterns of the opcode to identify:
- The specific arithmetic/logical operation to execute.
- The required addressing mode (register, immediate, direct, indirect).
- The number of additional bytes (operands/addresses) to fetch from memory.
- The exact sequence of control timing pulses needed to drive the execution units.
3. The Execute Phase
- The control unit sequences micro-operations to perform the commanded task:
- If additional operand bytes or addresses are needed, subsequent Memory Read machine cycles are initiated.
- Operands are transferred into the ALU or internal temporary registers.
- The ALU performs the arithmetic calculation, logical comparison, or bit-shift.
- Status flags in the Flag Register (Zero, Carry, Sign, Parity, Auxiliary Carry) are set or cleared based on the result.
- If the instruction specifies a memory write (e.g.,
STA 2050H), a Memory Write machine cycle is generated to store the result into RAM.
+-------------------------------------------------------------+
| START PROCESSING CYCLE |
+-------------------------------------------------------------+
|
v
+-------------------------------------------------------------+
| 1. FETCH PHASE |
| - Address from PC placed on Address Bus: (MAR <- PC) |
| - Assert MEMR strobe |
| - Read Opcode byte from Data Bus into IR: (IR <- MDR) |
| - Increment Program Counter: (PC <- PC + 1) |
+-------------------------------------------------------------+
|
v
+-------------------------------------------------------------+
| 2. DECODE PHASE |
| - Instruction Decoder decodes opcode in IR |
| - Generate micro-operation control timing sequences |
+-------------------------------------------------------------+
|
v
+-------------------------------------------------------------+
| 3. EXECUTE PHASE |
| - Fetch operands from registers / memory if required |
| - ALU performs operation (ADD, SUB, AND, OR, etc.) |
| - Update ALU status flags (S, Z, AC, P, CY) |
| - Write result to destination register or memory |
+-------------------------------------------------------------+
|
v
Are Interrupts Pending and Enabled (INTE = 1)?
/ \
YES NO
/ \
Execute Interrupt Acknowledge Loop back to Fetch Phase
and Branch to ISR (Vector Address) for next instructionWorked Examples
1
An 8085-based microcomputer system uses a 16-bit address bus (A0–A15). The system designer wants to map a 32 KB EPROM (for system firmware) and a 32 KB SRAM (for user variables) into the 64 KB memory space. The top address line A15 is connected directly to the chip select logic such that:
- When A15 = 0, the EPROM is enabled.
- When A15 = 1, the SRAM is enabled.
- Determine the exact hexadecimal address range allocated to the 32 KB EPROM.
- Determine the exact hexadecimal address range allocated to the 32 KB SRAM.
- If an instruction executes
LDA 8500H, explain which memory chip is selected and show the binary status of address lines A15 through A0.
Analysis of 32 KB Memory Address Space: A 32 KB memory chip contains: 32 KB = 32 * 1,024 bytes = 32,768 bytes = 2^15 bytes. Therefore, exactly 15 address lines (A0 through A14) are required to select an individual byte inside each 32 KB chip. The remaining address line A15 acts as the high-order chip select decoder line.
1. Computing the EPROM Address Range (A15 = 0): The EPROM is enabled when A15 = 0.
- Starting Address: A15 = 0, and all internal address lines A14–A0 = 0:
0000 0000 0000 0000B = 0000H. - Ending Address: A15 = 0, and all internal address lines A14–A0 = 1:
0111 1111 1111 1111B = 7FFFH.
EPROM address range = 0000H to 7FFFH (32,768 bytes).
2. Computing the SRAM Address Range (A15 = 1): The SRAM is enabled when A15 = 1.
- Starting Address: A15 = 1, and all internal address lines A14–A0 = 0:
1000 0000 0000 0000B = 8000H. - Ending Address: A15 = 1, and all internal address lines A14–A0 = 1:
1111 1111 1111 1111B = FFFFH.
SRAM address range = 8000H to FFFFH (32,768 bytes).
3. Decoding Address 8500H: Convert 8500H to 16-bit binary:
8500H = 1000 0101 0000 0000B.
Inspect bit A15 (MSB):
- A15 = 1.
Because A15 = 1, the SRAM chip is selected, while the EPROM remains in the High-Impedance (Hi-Z) unselected state. Within the SRAM, the offset address driven by A14–A0 is: 000 0101 0000 0000B = 0500H (the 1,280th byte of the SRAM chip).
- EPROM address range: 0000H to 7FFFH (32 KB).
- SRAM address range: 8000H to FFFFH (32 KB).
- For
LDA 8500H, A15 = 1, so the SRAM chip is selected at internal offset 0500H.
2
A short 8085 assembly language program segment consists of three instructions:
MVI A, 45H(Move immediate: requires Opcode Fetch + Memory Read = 2 machine cycles, 7 T-states)MOV B, A(Move register to register: requires Opcode Fetch = 1 machine cycle, 4 T-states)STA 2050H(Store accumulator direct: requires Opcode Fetch + Memory Read + Memory Read + Memory Write = 4 machine cycles, 13 T-states)
Calculate:
- The total number of machine cycles and total T-states required to execute this program.
- The total program execution time in microseconds assuming a clock frequency of 3 MHz.
- The total program execution time in microseconds if the clock frequency is reduced to 2 MHz.
Summing Machine Cycles and T-States: For each instruction:
MVI A, 45H: 2 machine cycles (OF = 4T, MR = 3T) -> 7 T-states.MOV B, A: 1 machine cycle (OF = 4T) -> 4 T-states.STA 2050H: 4 machine cycles (OF = 4T, MR = 3T, MR = 3T, MW = 3T) -> 13 T-states.
Total Machine Cycles = 2 + 1 + 4 = 7 machine cycles. Total T-states = 7 + 4 + 13 = 24 T-states. (Wait: 7 + 4 + 13 = 24 T-states). Let us verify the sum: 7 + 4 = 11; 11 + 13 = 24 T-states.
Evaluating Execution Time at Clock Frequency = 3 MHz: Period of one clock cycle: T = 1 / f_clock = 1 / (3 * 10^6 Hz) = 0.3333 microseconds. Total Execution Time = Total T-states * T Execution Time (3 MHz) = 24 * (1 / 3) microseconds = 8.0 microseconds.
Evaluating Execution Time at Clock Frequency = 2 MHz: Period of one clock cycle: T = 1 / f_clock = 1 / (2 * 10^6 Hz) = 0.5000 microseconds. Total Execution Time = 24 * 0.5000 microseconds = 12.0 microseconds.
- Total machine cycles = 7 machine cycles; Total T-states = 24 T-states.
- Execution time at 3 MHz = 8.0 microseconds.
- Execution time at 2 MHz = 12.0 microseconds.
3
(Tribhuvan University Past exam questions Guide) Describe the complete register-level sequence of micro-operations that occur during the fetch, decode, and execute phases when an 8085 microprocessor executes the single-byte instruction ADD B (Opcode: 80H). Assume initially: PC = 2000H, Accumulator (A) = 25H, Register B = 13H, and memory location 2000H contains 80H. Show the exact contents of the PC, MAR, MDR, IR, and Accumulator at each stage.
1. Fetch Phase Micro-Operations (T1 to T3):
- State T1: The CPU transfers the contents of the Program Counter (PC) to the Memory Address Register (MAR) and places it on the address bus:
MAR <- PC = 2000H. Address bus carries2000H. The CPU asserts the ALE (Address Latch Enable) pulse to latch low address bits A0–A7. - State T2: The CPU asserts the
MEMR_barcontrol line (active low). Memory at address2000Haccesses the stored opcode byte (80H) and puts it on the data bus. The CPU reads this byte into the Memory Data Register (MDR):MDR <- Memory[2000H] = 80H. Simultaneously, the Program Counter increments to point to the next instruction:PC <- PC + 1 = 2001H. - State T3: The opcode byte is transferred from the MDR into the internal Instruction Register (IR):
IR <- MDR = 80H. TheMEMR_barsignal returns high.
2. Decode Phase (State T4):
- The Instruction Decoder receives
80Hfrom the IR. - The decoder recognizes
80Has the instructionADD B:- Operation: Add contents of register B to the Accumulator.
- Number of operands: 1 (stored in register B).
- No further memory read cycles are required.
3. Execute Phase (Internal ALU Operation during T4):
- The control unit enables the contents of Register B (
13H) and Accumulator (25H) onto the internal CPU ALU input buses:- Operand 1 (Accumulator) =
25H = 0010 0101B. - Operand 2 (Register B) =
13H = 0001 0011B.
- Operand 1 (Accumulator) =
- The ALU binary adder performs addition:
25H + 13H = 38H = 0011 1000B. - The sum
38His written into the Accumulator:A <- 38H. - Status flags are updated:
- Sign flag
S = 0(bit 7 is 0). - Zero flag
Z = 0(result non-zero). - Auxiliary Carry
AC = 0(no carry from bit 3 to 4:5H + 3H = 8H). - Parity flag
P = 0(odd parity:0011 1000Bhas three 1s). - Carry flag
CY = 0(no carry out of bit 7).
- Sign flag
During ADD B, the PC loads 2000H to MAR; memory returns 80H to MDR and IR while PC increments to 2001H. During T4, the decoder identifies ADD B, the ALU adds A (25H) + B (13H) = 38H, writes 38H to Accumulator, and updates flags (S=0, Z=0, AC=0, P=0, CY=0).
Exercises
Exercises
Explain the bus organization of a computer system. Differentiate clearly between the address bus, data bus, and control bus in terms of function, width, and signal directionality.
System Bus Organization Overview: A bus is a collection of parallel electrical traces connecting the CPU, memory, and I/O devices. The system bus is divided into three distinct functional groups:
- Address Bus:
- Function: Carries memory addresses and I/O port numbers generated by the CPU to select a specific target device.
- Direction: Strictly unidirectional (out from CPU to memory/peripherals).
- Width: Determines the addressable memory capacity (e.g., 16 bits in 8085 yields 2^16 = 64 KB; 20 bits in 8086 yields 2^20 = 1 MB).
- Data Bus:
- Function: Transports instruction opcodes, data operands, and computational results.
- Direction: Bidirectional (data flows into CPU during Reads, and out from CPU during Writes).
- Width: Defines the CPU's word length and processing throughput (e.g., 8 bits in 8085, 16 bits in 8086, 32 bits in 80386).
- Control Bus:
- Function: Emits timing strobes, read/write commands, and control/status handshakes (MEMR_bar, MEMW_bar, IOR_bar, IOW_bar, READY, RESET, ALE, HOLD).
- Direction: Bidirectional / Multidirectional (some lines originate from the CPU, while others, like READY or INTR, are inputs to the CPU).
Tristate Bus Protection: Because all devices share the same data and address bus wires, devices not currently addressed are switched to a High-Impedance (Hi-Z) state using tristate buffers to prevent electrical bus contention and signal distortion.
The address bus is unidirectional and dictates addressable space (16 lines = 64 KB); the data bus is bidirectional and dictates processor word width (8 lines = 8-bit word); and the control bus is multidirectional and synchronizes memory and I/O transactions via read, write, and handshake strobes.
Define the stored-program concept. Compare the Von Neumann architecture with the Harvard architecture and explain the significance of the "Von Neumann Bottleneck".
Definition of Stored-Program Concept: The stored-program concept is the foundational architecture principle (formulated by John von Neumann) where program instructions and operational data reside together in the same physical read/write semiconductor memory in binary format. The CPU automatically and sequentially fetches instructions pointed to by the Program Counter, decodes them, and executes them, allowing the system's function to be changed simply by altering the stored software.
Comparison of Von Neumann and Harvard Architectures:
- Memory & Buses: Von Neumann uses a single unified memory and a single bus set for both code and data. Harvard uses two physically separated memories (Instruction Memory and Data Memory) accessed over two independent, parallel bus systems.
- Speed & Concurrency: In Von Neumann, instruction fetch and data operand read/write must take turns sequentially over the shared bus. In Harvard, instruction prefetching occurs simultaneously with data access, achieving significantly higher execution throughput.
- Hardware Complexity: Von Neumann is simpler to design with lower pin count and simpler PCB routing. Harvard requires double the bus routing and higher chip pin counts.
The Von Neumann Bottleneck: Because instruction fetches and data transfers must contend for the single shared memory bus, the throughput between the fast CPU core and memory is severely constrained. The CPU wastes clock cycles waiting for memory bus access. Modern processors mitigate this bottleneck using on-chip Harvard-split L1 caches (separate L1 Code and L1 Data caches), instruction prefetch queues, and branch prediction.
The stored-program concept stores binary code and data in the same primary memory for automatic execution by the CPU. Von Neumann shares a single memory and bus for both (leading to the throughput-limiting Von Neumann Bottleneck), whereas Harvard uses separate instruction and data memories and buses for simultaneous access.
Explain the complete processing cycle of a stored-program computer. Clearly delineate the fetch, decode, and execute phases, detailing the role of the Program Counter, MAR, MDR, and Instruction Register.
The Processing Cycle Phases:
- Fetch Phase:
- The address in the Program Counter (PC) is loaded into the Memory Address Register (MAR) and driven onto the address bus.
- The control unit asserts the Memory Read (
MEMR_bar) strobe. - The memory places the opcode byte onto the data bus into the Memory Data Register (MDR).
- The opcode is transferred from the MDR into the Instruction Register (IR).
- The Program Counter is incremented (
PC <- PC + 1) to point to the next instruction byte.
- Decode Phase:
- The Instruction Decoder receives the opcode from the IR.
- Combinational logic determines the required operation, operand addressing mode, and whether additional operand/address bytes must be fetched.
- The control unit generates the required sequence of internal clock pulses and bus strobes.
- Execute Phase:
- If memory operands are needed, additional Memory Read cycles are executed.
- The ALU executes the commanded operation (addition, logic, shift, compare).
- Status flags in the Flag Register are updated based on the ALU result.
- The result is stored back into the designated register or written to memory via a Memory Write cycle.
The processing cycle consists of: (1) Fetch (PC -> MAR, read opcode from memory into MDR -> IR, PC incremented); (2) Decode (decoder interprets opcode in IR and configures datapath control signals); and (3) Execute (operands read, ALU computes result, flags updated, and result saved).
A 64 KB memory space (0000H to FFFFH) in an 8085 microprocessor system is partitioned into two equal halves: the lower 32 KB is allocated to ROM, and the upper 32 KB is allocated to RAM.
- Specify the starting and ending hexadecimal addresses for the ROM and RAM blocks.
- If the ROM block is constructed using 4 KB x 8 ROM chips, how many ROM chips are required, and how many address lines are connected directly to each ROM chip?
- Which address line can be used as the primary chip-select decoder line to distinguish between the ROM and RAM blocks?
1. Address Ranges for ROM and RAM: Total memory = 64 KB = 65,536 bytes. Divided into two equal halves of 32 KB (32,768 bytes) each:
- Lower 32 KB (ROM): Starts at
0000Hand ends at32,767in decimal, which is7FFFH(0111 1111 1111 1111B). ROM address range: 0000H to 7FFFH. - Upper 32 KB (RAM): Starts at
32,768in decimal (8000H=1000 0000 0000 0000B) and ends at65,535(FFFFH=1111 1111 1111 1111B). RAM address range: 8000H to FFFFH.
2. Number of 4 KB x 8 ROM Chips and Address Lines: Capacity of one ROM chip = 4 KB = 4 * 1,024 bytes = 4,096 bytes = 2^12 bytes. Total ROM space = 32 KB = 32,768 bytes. Number of 4 KB chips required = 32 KB / 4 KB = 8 chips. Address lines connected directly to each chip: Since each chip contains 2^12 locations, exactly 12 address lines (A0 to A11) connect to each ROM chip.
3. Primary Chip-Select Decoder Line: In the binary address representations:
- All ROM addresses (0000H to 7FFFH) have bit A15 = 0.
- All RAM addresses (8000H to FFFFH) have bit A15 = 1.
Therefore, the most significant address line A15 serves as the primary chip-select line:
- When A15 = 0, ROM is selected.
- When A15 = 1, RAM is selected.
- ROM range: 0000H to 7FFFH; RAM range: 8000H to FFFFH.
- Total 4 KB chips required = 8 chips; each chip uses 12 address lines (A0–A11).
- Primary chip-select line is A15 (A15 = 0 selects ROM; A15 = 1 selects RAM).
Define the relationship between an instruction cycle, machine cycle, and T-state. An instruction requires 3 machine cycles consisting of 4 T-states, 3 T-states, and 3 T-states respectively.
- Find the total number of T-states for this instruction.
- Calculate the execution time of this instruction when the microprocessor clock operates at 4 MHz.
- Calculate the execution time if the clock operates at 2 MHz.
1. Relationship and Total T-States:
- An instruction cycle is the complete time required to fetch, decode, and execute an instruction.
- An instruction cycle is composed of one or more machine cycles (such as Opcode Fetch, Memory Read, Memory Write), each representing one external bus transaction.
- Each machine cycle is subdivided into individual T-states, where one T-state equals one clock cycle of the system clock.
Total T-states = 4 + 3 + 3 = 10 T-states.
2. Execution Time at 4 MHz: Clock frequency f_clock = 4 MHz = 4 * 10^6 Hz. Clock period T = 1 / f_clock = 1 / (4 * 10^6) = 0.25 microseconds. Total Execution Time = 10 * 0.25 microseconds = 2.50 microseconds.
3. Execution Time at 2 MHz: Clock frequency f_clock = 2 MHz = 2 * 10^6 Hz. Clock period T = 1 / f_clock = 1 / (2 * 10^6) = 0.50 microseconds. Total Execution Time = 10 * 0.50 microseconds = 5.00 microseconds.
- Total T-states = 10 T-states (4T + 3T + 3T).
- Execution time at 4 MHz = 2.50 microseconds.
- Execution time at 2 MHz = 5.00 microseconds.