Revision approach
- Program execution cooperation
- Representation, registers, memory, control, I/O
- Stated machine model
- Labels ≠ timing or power
- Labels ≠ width or core count
👁 Full explanation
Understand how representation, registers, memory, control and I/O cooperate to execute a program. Use the stated machine model: architectural labels alone do not fix timing, power, word size or core count. - Calculation assumptions
- Representation and operand width
- Addressing mode
- Timing assumptions
👁 Full explanation
For each problem identify the representation, operand width, addressing mode and timing assumptions before calculating. - Mechanism-based practice
- Boolean simplification
- Signed subtraction
- Effective addresses
- Cache traces
- Register transfers
- Pipeline timing
👁 Full explanation
Practice Boolean simplification, signed subtraction, effective addresses, cache traces, register transfers and pipeline timing; comparisons should explain the mechanism. - Four equal blueprint outcomes
- Hardware/software structure
- CPU operations
- I/O communication
- Performance enhancement
- Historical facts: supplementary
👁 Full explanation
Give the four blueprint outcomes equal attention: hardware/software structure, CPU operations, I/O communication and performance enhancement. Use historical architecture facts as a small supplement to the core principles.
COA01
Architecture and system structure
[Exam Focus]- Architecture versus organization
- Programmer-visible instructions and registers
- Data types and address spaces
- I/O conventions
- Implementation: signals, buses, pipelines, memory
- Same architecture, different organizations
- No definition-imposed maximum lifetime
- Microarchitecture: internal processor design
👁 Full explanation
Architecture describes programmer-visible behavior: instructions, registers, data types, address spaces and I/O conventions. Organization is the implementation: control signals, internal buses, pipelines and memory technology. Different organizations can implement the same architecture; neither definition imposes a maximum lifetime. Microarchitecture names the internal processor design. - System structural components
- CPU, memory, I/O, interconnection
- CPU: ALU, control unit, registers
- Microcontroller: integrated control system
- Microcontroller ≠ mandatory CPU subunit
- Motherboard: physical connections
- Gates: fundamental logic building blocks
- Missing gates option: ambiguous answer
👁 Full explanation
CPU, main memory, I/O and their interconnection are the major structural parts. The CPU contains an ALU, control unit and registers; a microcontroller is a complete integrated control system, not another mandatory CPU subunit. A motherboard physically connects components. Gates are fundamental logic building blocks; distinguish that level from CPU, memory, disk and motherboard components.
9 related practice questions
Blueprint: COA-LO3 · Note references: COA-M
- Architecture versus organization
COA02
Stored programs and software
[Exam Focus]- Von Neumann versus Harvard
- Shared addressed instructions and data
- Sequential execution unless control changes
- Harvard: separate memories or paths
- Unified address space, split caches
- Modern architecture: nonexclusive labels
- Separate regions ≠ Harvard
👁 Full explanation
In the textbook Von Neumann model, instructions and data share an addressed memory system; the CPU normally advances sequentially unless control flow changes. Harvard separates instruction and data memories or paths. Modern systems may combine a unified address-space view with separate instruction/data caches, so “architecture used nowadays” is not an exclusive choice. Separate program/data regions within one memory do not make a Harvard machine. - Software roles
- OS: resources and services
- Applications: user tasks
- Compiler: source→target code
- Assembly: symbolic machine instructions
- JIT: compilation during execution
- Intermediate-code translation
- Before execution ≠ uniquely JIT
- Machine language: registers, types, addressing
👁 Full explanation
An operating system manages resources and provides services. Applications solve user tasks. A compiler translates source into target code; assembly is a symbolic form of machine instructions. JIT compilation happens during program execution, often translating intermediate code. Translation before execution alone does not distinguish JIT from an ahead-of-time compiler. Machine-language programming depends on the register set, supported types and memory/addressing structure.
8 related practice questions
Blueprint: COA-LO3 · Note references: COA-M
- Von Neumann versus Harvard
COA03
Gates and truth tables
- Logic gate behavior
- AND: all inputs 1
- OR: any input 1
- NOT: bit complement
- NAND: complemented AND
- NOR: complemented OR
- XOR: two inputs differ
- XNOR: two inputs agree
- Enabled buffer: input copied
- Output bubble: inversion
- AND shape plus bubble: NAND
👁 Full explanation
AND is 1 only when all inputs are 1; OR is 1 if any input is 1. NOT complements a bit. NAND complements AND; NOR complements OR. For two inputs XOR is 1 when inputs differ, and XNOR when they agree. An enabled buffer copies its input. A bubble at a gate output indicates inversion: an AND-shaped symbol with a bubble is NAND. - Truth-table construction
- n inputs → 2^n rows
- Complements before products before sums
- Boolean + means OR
👁 Full explanation
With n binary inputs, enumerate 2^n truth-table rows. Evaluate complements, products and then sums. A plus sign means Boolean OR, not integer addition. - Worked example Boolean evaluation example
- F=x+y′z; x=0,y=1,z=1
- y′=0 → F=0
- Four inputs → 16 rows
👁 Full explanation
Worked microexampleF=x+y'z at x=0,y=1,z=1: y'=0, so F=0 OR (0 AND 1)=0. Four independent inputs give 16 rows.
7 related practice questions
Note references: COA-M
- Logic gate behavior
COA04
Boolean reduction and universal gates
- Boolean identities
- A+0=A; A·1=A
- A+A=A; AA=A
- A+A′=1; AA′=0
- A+AB=A; A(A+B)=A
- De Morgan transformations
- (AB)′=A′+B′
- (A+B)′=A′B′
- Truth-table equivalence check
👁 Full explanation
Useful identities are A+0=A, A·1=A, A+A=A, AA=A, A+A'=1, AA'=0, A+AB=A and A(A+B)=A. De Morgan gives (AB)'=A'+B' and (A+B)'=A'B'. Check a proposed simplification with a truth table if uncertain. - Universal gates and Karnaugh maps
- NAND alone; NOR alone
- Tied inputs construct NOT
- Complemented gates construct AND/OR
- Gray-code ordering
- Adjacent power-of-two rectangular groups
- Wraparound and overlap allowed
- Cover every required 1
- Eliminate changing variables
- No diagonal groups or required 0s
👁 Full explanation
NAND and NOR are each universal: feeding the same input to both inputs constructs NOT; combine complemented gates to construct AND or OR. For Karnaugh maps, use Gray-code order, group adjacent 1s in rectangles of powers of two, allow wraparound and overlap, cover every required 1, and remove variables changing within a group. Do not group diagonally or include a required 0. - Worked example Reduction and NAND construction
- AB+AB′=A(B+B′)=A
- A NAND A=A′
- NAND then inversion → AND
👁 Full explanation
Worked microexampleAB+AB'=A(B+B')=A. A NAND A=A'; NAND followed by inversion gives AND.
4 related practice questions
Note references: COA-M
- Boolean identities
COA05
Combinational and sequential circuits
- Combinational versus sequential
- Present inputs plus propagation delay
- Adders, muxes, demuxes
- Encoders and decoders
- Combinational: no stored logical state
- Sequential: stored state plus inputs
- Registers, counters, flip-flops
- Shift register: sequential criterion
👁 Full explanation
A combinational output depends on present inputs after propagation delay. Adders, multiplexers, demultiplexers, encoders and decoders have no stored logical state. A sequential circuit depends on stored state as well as inputs; registers, counters and flip-flops are examples. This is the defensible criterion when comparing a shift register against decoder, encoder and multiplexer. - Powered state retention
- Flip-flop: one bit
- Retention ≠ nonvolatility
- Flip-flops/SRAM lose unpowered state
- Clocked updates: designated clock events
- Combinational logic: no inherent clock
👁 Full explanation
A flip-flop stores one bit while powered. State retention during operation does not mean nonvolatile storage. Ordinary flip-flops and SRAM lose state when power is removed. Clocked sequential circuits update at designated clock events; combinational logic does not inherently require a clock.
7 related practice questions
Note references: COA-M, COA-N
- Combinational versus sequential
COA06
Flip-flops and counter traces
- Latch and flip-flop transitions
- Active-high NOR SR latch
- SR=10: set; 01: reset
- SR=00: hold; 11: forbidden
- Active-low NAND conventions differ
- D: active-edge input copy
- JK=00: hold; 01: reset
- JK=10: set; 11: toggle
- T=1: toggle; T=0: hold
👁 Full explanation
For an active-high SR latch, S=1,R=0 sets, S=0,R=1 resets, and S=R=0 holds; S=R=1 is forbidden for the NOR-latch model. Active-low NAND-latch conventions differ. A D flip-flop copies D at its active edge. JK holds for 00, resets for 01, sets for 10 and toggles for 11. T toggles when T=1 and holds when T=0. - Sequential state tracing
- Given initial state
- One clock at a time
- k-bit counter: 2^k states
- Modulo 2^k wraparound
- Extra control may alter sequence
- Ripple: asynchronous propagation
- Synchronous: shared clock
👁 Full explanation
Trace a sequential circuit one clock at a time from the given initial state. A k-bit binary counter has 2^k states and wraps modulo 2^k unless extra control changes the sequence. Ripple counters propagate changes asynchronously; synchronous counters share a clock. - Worked example Counter and T examples
- 3-bit: 110→111→000
- Initial T-flop state: 0
- T inputs 1,0,1 → 1,1,0
👁 Full explanation
Worked microexampleA 3-bit counter at 110 advances to 111, then 000. A T flip-flop starting at 0 with T inputs 1,0,1 gives states 1,1,0.
Note references: COA-M
- Latch and flip-flop transitions
COA07
Adders, selectors and converters
- Adder equations
- Half-adder sum=A XOR B
- Half-adder carry=AB
- Full-adder includes Cin
- Sum=A XOR B XOR Cin
- Carry=AB+Cin(A XOR B)
- Cascading: word-wide carry propagation
👁 Full explanation
A half-adder has sum A XOR B and carry AB. A full-adder includes carry-in: sum=A XOR B XOR Cin and carry=AB+Cin(A XOR B). Cascading full-adders propagates carry across a word. - Data selection and encoding
- 2^k-to-1 mux: k selects
- Demux: one input→selected output
- k-to-2^k decoder
- Decoder enable and active level
- Ordinary encoder: one active input
- Priority encoder: multiple-input winner
- Registers: storage, not combinational converters
👁 Full explanation
A 2^k-to-1 multiplexer uses k select bits to choose one data input. A demultiplexer routes one input to a selected output. A k-to-2^k decoder asserts the selected output, subject to enable and active-level conventions. An ordinary encoder assumes one active input; a priority encoder defines which wins if several are active. Registers are storage, not combinational code converters. - Worked example Adder and mux examples
- A=B=Cin=1 → binary 11
- Sum=1; carry=1
- 8-to-1 mux: 3 selects
👁 Full explanation
Worked microexampleFor a full-adder with A=B=Cin=1, binary total is 11: sum=1 and carry=1. An 8-to-1 mux needs 3 select bits.
Note references: COA-M
- Adder equations
COA08
Bases and binary codes
- Positional representation
- Digit value=digit×b^i
- Binary digits: 0–1
- Octal digits: 0–7
- Hex digits: 0–9,A–F
- F=15
- Integer: repeated division by 2
- Remainders read upward
- Fraction: repeated multiplication by 2
- Integer parts read downward
👁 Full explanation
In base b, a digit at position i has value digit×b^i. Binary uses 0–1, octal 0–7 and hexadecimal 0–9,A–F; F=15. Convert a positive integer to binary by repeated division by 2 and read remainders upward. For fractions, repeatedly multiply by 2 and read integer parts downward. - Grouping and encodings
- Octal: groups of three bits
- Hex: groups of four bits
- Group outward from radix point
- BCD: four bits per decimal digit
- BCD 12: 0001 0010
- Binary 12: 1100
- ASCII: character code, not I/O interface
👁 Full explanation
Group binary bits in threes for octal and fours for hexadecimal, outward from the radix point. BCD encodes each decimal digit separately in four bits; BCD 12 is 0001 0010, while ordinary binary 12 is 1100. ASCII is a character code, not a physical I/O interface. - Worked example Base-conversion examples
- 1011₂=8+2+1=11
- 2F₁₆=47
- 101.101₂=5.625
- 13: remainders 1,0,1,1
- Reverse remainders → 1101₂
👁 Full explanation
Worked microexample1011₂=8+2+1=11. 2F₁₆=47. 101.101₂=5.625. Decimal 13 gives remainders 1,0,1,1 and hence 1101₂.
5 related practice questions
Note references: COA-M
- Positional representation
COA09
Signed arithmetic and overflow
- Fixed-width integer representations
- Unsigned: 0…2^n−1
- Two’s complement: −2^(n−1)…2^(n−1)−1
- Negation: invert n bits, add one
- A−B=A+two’s-complement(B)
- Retain n result bits
- Signed magnitude: two zeros
- One’s complement: two zeros
- Two’s complement: one zero
👁 Full explanation
For n-bit unsigned values the range is 0 through 2^n−1. Two’s complement ranges from −2^(n−1) through 2^(n−1)−1. Negate by inverting all n bits and adding one. Compute A−B as A+(two’s complement of B), retaining n result bits. Signed magnitude and one’s complement have two zero encodings; two’s complement has one. - Carry versus signed overflow
- Unsigned carry ≠ signed overflow
- Same-sign inputs, opposite-sign result
- Fixed width throughout
👁 Full explanation
Unsigned carry and signed overflow are different. Signed addition overflows when equal-sign operands produce an opposite-sign result. Keep the width fixed throughout the calculation. - Worked example Four-bit arithmetic examples
- 7−3: 0111+1101=1 0100
- Discard carry → 4
- 0111+0001=1000: signed overflow
- +8 outside −8…+7
👁 Full explanation
Worked microexampleIn 4 bits, 7−3 = 0111+1101 = 1 0100; discard carry to get 4. But 0111+0001=1000 is signed overflow, since +8 is outside −8…+7.
1 related practice question
Note references: COA-M
- Fixed-width integer representations
COA10
Floating point and arithmetic pipelines
- Binary floating-point representation
- Sign×significand×2^exponent
- Binary32 normal: (−1)^s(1.f)2^(e−127)
- Binary64: 11 exponent bits
- Binary64 bias: 1023
- Special patterns: zero/subnormal
- Special patterns: infinities/NaNs
- Implicit leading 1: not universal
👁 Full explanation
A normalized binary floating-point value is sign×significand×2^exponent. For ordinary IEEE binary32 normal values, value=(−1)^s(1.f)2^(e−127); binary64 uses 11 exponent bits and bias 1023. Special exponent patterns represent zero/subnormal values or infinities/NaNs, so the implicit leading 1 is not universal. - Floating addition sequence
- Compare exponents
- Shift smaller significand: alignment
- Add/subtract, normalize, round
- Alignment loses low-order bits
- Overflow: exponent range
- Rounding error: finite precision
- Arithmetic pipeline: overlapping operand pairs
- All steps ≠ one cycle
👁 Full explanation
For floating addition, compare exponents, shift the smaller significand to align, add or subtract, normalize and round. Alignment may lose low-order bits. Overflow concerns exponent range; rounding error concerns finite precision. An arithmetic pipeline overlaps these steps for different operand pairs; it need not perform all steps in one cycle. - Worked example Floating alignment example
- 1.10₂×2³+1.00₂×2¹
- Align: (1.10₂+0.01₂)×2³
- Normalize: 1.11₂×2³=14
👁 Full explanation
Worked microexample1.10₂×2³ + 1.00₂×2¹ becomes (1.10₂+0.01₂)×2³=1.11₂×2³=14.
1 related practice question
Note references: COA-M
- Binary floating-point representation
COA11
Register transfers and memory cycles
[Exam Focus]- Register transfer semantics
- R2←R1: copy, preserve R1
- P:R2←R1: conditional clocked transfer
- Simultaneous transfers: old values
- Sequential transfers: newly written values
- Common bus: one selected source
- Load signals: selected destinations
👁 Full explanation
R2←R1 copies R1 into R2; it does not erase R1. A control condition P:R2←R1 performs the transfer only when P is true at the relevant clock event. Simultaneous transfers read old register values; sequential statements can use a newly written value. A common bus selects one source at a time, while destination load signals select receivers. - Memory read/write microoperations
- Read: address→MAR/AR
- Assert read; wait for memory
- Capture→MDR/MBR/DR
- Write: address plus data
- Assert write
- ALU: computation
- Control unit: sequencing and enables
- Microoperation: elementary register operation
👁 Full explanation
A read places an address in MAR/AR, asserts read, waits for memory and captures data in MDR/MBR/DR. A write supplies both address and data and asserts write. The ALU computes; the control unit sequences and enables the transfers. A microoperation is one elementary operation on register contents. - Worked example Simultaneous versus sequential example
- Initially R1=3,R2=7
- R1←R2,R2←R1 simultaneously → 7,3
- Same transfers sequentially → 7,7
👁 Full explanation
Worked microexampleWith R1=3,R2=7, simultaneous R1←R2,R2←R1 swaps to 7,3. Executed sequentially, both end at 7.
1 related practice question
Blueprint: COA-LO3, COA-LO4 · Note references: COA-M
- Register transfer semantics
COA12
Address, data and control buses
- Bus signal roles
- Address: select location
- Data: carry values
- Control: read/write and timing
- Requests and acknowledgements
- CPU-master addresses: CPU→memory
- Data: either direction
- DMA controller: alternate bus master
- Control: CPU outputs/device inputs
- Bidirectional: data and control ambiguity
👁 Full explanation
Address signals select a location; data signals carry values; control signals coordinate read/write, timing, requests and acknowledgements. In the simple CPU-master model, addresses flow from CPU to memory, while data travels in either direction. A DMA controller can also become bus master. Aggregate control signals include both CPU outputs and device inputs; both data and control buses can therefore be bidirectional under that scope. - Addressability versus widths
- a address bits → 2^a locations
- Byte capacity=locations×bytes/location
- Word/data-bus/instruction/address widths may differ
👁 Full explanation
With a address bits there are 2^a addressable locations. Multiply by bytes per location before calling this a byte capacity. Word width, data-bus width, instruction width and address width need not match. - Worked example Address-space example
- 32-bit byte addressing: 2^32 bytes
- 4 GiB; bank wording 4 GB
- 16-bit data bus ≠ 16-bit addresses
👁 Full explanation
Worked microexample32 address bits and byte addressing give 2^32 bytes=4 GiB (often called 4 GB in introductory questions). A 16-bit data bus does not itself imply a 16-bit address space.
9 related practice questions
Note references: COA-M
- Bus signal roles
COA13
Bit masks and shifts
- Mask operations
- Set: A OR mask
- Clear: A AND NOT(mask)
- Toggle: A XOR mask
- Retain: A AND mask
- A XOR A: entire register cleared
- Arbitrary XOR mask ≠ clearing
👁 Full explanation
To set selected bits use A OR mask; to clear them use A AND NOT(mask); to toggle use A XOR mask; to retain only selected bits use A AND mask. A XOR A clears the entire register. Clearing with XOR is valid only with the appropriate operand, not any arbitrary mask. - Shifts, rotates and shift registers
- Logical shifts: zero fill
- Arithmetic right: sign replication
- Left shift: zero fill, overflow possible
- Left shift may change sign
- Rotate: wrap shifted-out bit
- SISO: serial delay
- SIPO: serial→parallel word
- PISO: parallel→serial word
👁 Full explanation
Logical shifts insert zero. Arithmetic right shift replicates the sign bit. Left shift inserts zero and may overflow; it does not preserve the sign in every case. Rotate returns a shifted-out bit at the opposite end. SISO shift registers delay serial streams; SIPO collects a word and PISO serializes a parallel word. - Worked example Masking and shift examples
- A=1010; mask=1100
- Set→1110; clear→0010; toggle→0110
- Arithmetic-right 1100→1110: −4→−2
- Logical-right 1100→0110
👁 Full explanation
Worked microexampleA=1010, mask=1100: set→1110, selective clear→0010, toggle→0110. Arithmetic-right 1100 gives 1110 (−4 to −2 in two’s complement); logical-right gives 0110.
2 related practice questions
Note references: COA-M
- Mask operations
COA14
CPU registers and control words
[Exam Focus]- CPU register roles
- PC: next instruction to fetch
- IR: fetched instruction
- MAR: current memory-access address
- MDR: transferred data
- Accumulator: operands/results
- SP: stack tracking
- Status flags: conditions
- Instruction address: PC/MAR phase ambiguity
- Registers: explicit execution operands
- Cache: copied memory blocks
- Both: temporary storage
👁 Full explanation
PC identifies the next instruction to fetch. IR holds the fetched instruction; MAR holds an address used for the current memory access; MDR holds transferred data. The accumulator holds operands/results, SP tracks the stack, and status flags report conditions. “Address of the instruction” without a phase can describe PC or MAR. Registers and cache both store temporary information, but registers are explicit execution operands and cache holds copies of memory blocks. - Control-word construction
- Select ALU sources, destination, operation
- Machine encoding table required
- Module control word: 14 bits
- SELA/SELB/SELD: 3 bits each
- Operation field: 5 bits
👁 Full explanation
A control word chooses ALU sources, destination and operation. Use the machine’s encoding table rather than guessing opcodes. In this 14-bit control-word example, SELA, SELB and SELD each have 3 bits, followed by a 5-bit operation field. - Worked example Encoded subtraction example
- R1←R2−R3
- SELA=010; SELB=011; SELD=001
- Subtraction=00101
- 010 011 001 00101
- Source/destination order matters
👁 Full explanation
Worked microexampleFor R1←R2−R3 in this encoding, select 010,011,001 and subtraction 00101: 010 011 001 00101. Source and destination order matters.
6 related practice questions
Blueprint: COA-LO3, COA-LO4 · Note references: COA-M
- CPU register roles
COA15
Instruction cycle and next PC
[Exam Focus]- Conceptual instruction cycle
- Fetch; decode opcode/addressing fields
- Obtain operands; execute
- Write required results
- Check permitted interrupts
- Example stages: IF, ID, EX, MEM, WB
- Five stages: not architecturally mandatory
👁 Full explanation
A conceptual instruction cycle fetches an instruction, decodes opcode/addressing fields, obtains operands, executes, writes results where required and checks permitted interrupts. A five-stage implementation may name stages IF, ID, EX, MEM and WB; these stages are not mandatory for every architecture. - Fetch and next-PC distinctions
- MAR←PC; MDR←M[MAR]; IR←MDR
- PC←PC+instruction_length
- Later branch replaces sequential PC
- Read PC versus calculate branch target
- Control unit: fetch/data-flow coordination
- ALU: arithmetic and logic
- Write-back ≠ another fetch
👁 Full explanation
A sample fetch is MAR←PC; MDR←M[MAR]; IR←MDR; PC←PC+instruction_length. A branch can replace the sequential PC later. Thus “which phase determines the next instruction?” needs to distinguish reading the current PC from calculating a branch target. The control unit coordinates fetching and data flow; the ALU performs arithmetic and logic. A write-back/result-storage phase is not another fetch.
8 related practice questions
Blueprint: COA-LO4 · Note references: COA-M
- Conceptual instruction cycle
COA16
Instruction fields and operand counts
[Exam Focus]- Instruction field interpretation
- Opcode: operation
- Operand fields: data/register locations
- Mode field: interpretation
- 4-bit opcode: ≤16 encodings
- Encodings ≠ implemented instructions
- 6-bit reference: 64 encodings
- Machine determines referenced objects
👁 Full explanation
An opcode specifies the operation; operand fields locate data or registers, and a mode field explains interpretation. A 4-bit opcode permits at most 16 encodings, not necessarily 16 implemented instructions. A 6-bit operand-reference field has 64 encodings; what they designate depends on the machine. - Explicit address-count formats
- Three-address ADD X,Y,Z: X←Y+Z
- Destination-first convention
- Two-address ADD X,Y: X←X+Y
- Accumulator ADD X: AC←AC+M[X]
- Zero-address ADD: implicit stack operands
- Count explicit operand fields
- INC X ≠ necessarily accumulator instruction
👁 Full explanation
Three-address ADD X,Y,Z means X←Y+Z under destination-first notation. Two-address ADD X,Y overwrites X with X+Y. One-address accumulator ADD X means AC←AC+M[X]. Zero-address stack ADD uses two implicit top-of-stack operands. Count explicit operand fields; an instruction such as INC X does not become an accumulator instruction merely because it has one written operand.
9 related practice questions
Blueprint: COA-LO4 · Note references: COA-M
- Instruction field interpretation
COA17
Stacks and operand order
- Stack organization and conventions
- LIFO; PUSH adds; POP removes
- Register stack versus RAM stack
- SP: top or next free
- Address growth: upward or downward
- SP update: before/after access
- Overflow: push full stack
- Underflow: pop empty stack
👁 Full explanation
A stack is last-in, first-out. PUSH adds an item and POP removes the logical top. A register stack uses registers; a memory stack uses RAM and a stack pointer. Check whether SP points to the top or the next free location, whether addresses increase or decrease, and whether the update occurs before or after access. Overflow means pushing a full stack; underflow means popping an empty one. - Stack arithmetic order
- Second operand popped first
- First operand popped second
- Subtraction: operand order matters
- Stack PUSH/POP: explicit addresses possible
👁 Full explanation
Zero-address arithmetic typically pops the second operand first, then the first operand; subtraction therefore needs careful order. PUSH and POP may still contain an explicit address even on a stack machine. - Worked example Stack expression example
- (A+B)×(C+D)
- PUSH A; PUSH B; ADD
- PUSH C; PUSH D; ADD; MUL
- Downward full stack PUSH: decrement, store
- POP: read, increment
👁 Full explanation
Worked microexampleFor (A+B)×(C+D): PUSH A; PUSH B; ADD; PUSH C; PUSH D; ADD; MUL. For a downward-growing full stack, PUSH commonly decrements SP before storing and POP reads before incrementing.
1 related practice question
Note references: COA-M
- Stack organization and conventions
COA18
Effective addresses and addressing modes
[Exam Focus]- Operand addressing rules
- A: field; R: register; M[x]: contents
- Immediate: value A
- Direct: EA=A; operand=M[A]
- Indirect: EA=M[A]; operand=M[EA]
- Register: operand R
- Register-indirect: EA=R
- Indexed/base displacement: EA=R+A
- PC-relative: defined PC+signed displacement
- Auto-increment/decrement: operand-size register update
👁 Full explanation
Let A be an instruction field, R a register value and M[x] the contents at x. Immediate uses value A; direct uses EA=A and operand M[A]; indirect uses EA=M[A] then operand M[EA]. Register uses operand R; register-indirect uses EA=R. Indexed/base displacement uses EA=R+A; PC-relative uses the architecture-defined PC plus a signed displacement. Auto-increment/decrement also updates the register by operand size. - Transfer versus addressing mode
- Register↔memory transfer: nonunique mode
- Direct, indexed or indirect possible
👁 Full explanation
A transfer between a register and memory does not uniquely specify addressing mode; either direct, indexed or indirect addressing may produce it. - Worked example Addressing example
- A=100; R=20; M[100]=300; M[300]=9
- Direct operand: 300
- Indirect operand: 9
- Indexed EA: 120
- Immediate 100 ≠ M[100]
👁 Full explanation
Worked microexampleA=100,R=20,M[100]=300,M[300]=9: direct operand is 300; indirect operand is 9; indexed EA is 120. An immediate field 100 is the value 100, not M[100].
2 related practice questions
Blueprint: COA-LO4 · Note references: COA-M
- Operand addressing rules
COA19
Instruction classes and interrupts
- Instruction functions
- Data transfer: value copying
- Arithmetic/logic: computed values
- TEST/CMP: condition information
- Arithmetic result often discarded
- Branch: conditional/unconditional target
- CALL: save return point
- RETURN: restore return point
- SKIP: conditional next-instruction bypass
- Jump-to-next wording ≠ clear skip
👁 Full explanation
Data-transfer instructions copy values. Arithmetic/logic instructions compute values. TEST/CMP examine values and set condition information, often without retaining the arithmetic result. Branch instructions choose a target, conditionally or unconditionally. CALL saves a return point; RETURN restores it. SKIP, where supported, bypasses the next instruction when its condition holds. “Jump to the next instruction” does not clearly mean skip. - Interrupt and exception origins
- External: device/timer
- Internal synchronous: executing instruction
- Divide errors; illegal opcodes
- Access violations
- Software interrupt: deliberate instruction
- Overflow traps: architecture/instruction dependent
- Overflow flag ≠ automatic interrupt
👁 Full explanation
External interrupts arise from devices or timers; synchronous internal exceptions arise from the executing instruction, such as divide errors, illegal opcodes or access violations. A software interrupt is deliberately requested by an instruction. Arithmetic overflow trapping depends on architecture and instruction; ordinary overflow flags need not trigger an interrupt.
5 related practice questions
Note references: COA-M
- Instruction functions
COA20
RISC, CISC and control
[Exam Focus]- RISC/CISC design tendencies
- RISC: simple operations, regular encodings
- Load/store access; plentiful registers
- Pipeline-friendly control
- CISC: complex operations, richer addressing
- Variable instruction lengths
- Hardwired: direct control signals
- Microprogrammed: stored control-word sequences
- Tendencies ≠ universal guarantees
👁 Full explanation
Textbook RISC emphasizes simple operations, regular encodings, load/store memory access, plentiful registers and pipeline-friendly control. CISC commonly supplies more complex operations, richer addressing modes and variable lengths. Hardwired control directly generates control signals; microprogrammed control sequences stored control words. These are tendencies, not universal guarantees. - RISC/CISC interpretation traps
- One completion/cycle: throughput, not latency
- RISC instructions: multiple cycles possible
- CISC: simpler internal operations possible
- Labels ≠ power/cost/time guarantees
- Semantic gap: high-level→machine distance
- Richer instructions: reduced semantic gap
- Gap reduction: not universal shared objective
👁 Full explanation
One instruction completing per pipeline cycle is throughput, not proof that every instruction has one-cycle latency. Modern RISC instructions can take multiple cycles and modern CISC processors can translate instructions into simpler internal operations. Neither label guarantees lower power, cost or execution time. The semantic gap is the distance between high-level constructs and machine operations; reducing it is associated with richer instructions, not a universal shared objective of both design approaches.
6 related practice questions
Blueprint: COA-LO2, COA-LO4 · Note references: COA-M, COA-N
- RISC/CISC design tendencies
COA21
x86 register names and classes
- x86 register map
- 16-bit: AX/BX/CX/DX, BP/SP, SI/DI
- Conventional special roles
- AL: AX low byte
- AH: AX high byte
- BX/CX/DX: analogous byte names
- EAX: 32-bit; RAX: 64-bit
- FLAGS/EFLAGS/RFLAGS: status
- IP/EIP/RIP: instruction position
- CS: code segment; SS: stack segment
- DX: programmer-visible
- IR/MDR: conceptual internal registers
👁 Full explanation
In Intel x86 notation, AX/BX/CX/DX, BP/SP and SI/DI are 16-bit general-purpose registers, with conventional special roles. AL is AX’s low byte and AH its high byte; analogous byte names apply to BX/CX/DX. EAX is 32-bit and RAX 64-bit. FLAGS/EFLAGS/RFLAGS report status; IP/EIP/RIP identifies instruction position. CS and SS are code/stack segment registers. DX is programmer-visible; IR/MDR are conceptual internal registers. - x86 classification caveats
- SP: general-purpose despite stack role
- EAX/EIP: 80386, before Pentium
- R8–R15: 64-bit extension
- R8–R15 ≠ original Pentium
- Narrow multipurpose category requires definition
👁 Full explanation
SP’s stack role does not remove it from Intel’s general-purpose register classification. EAX/EIP existed with the 80386, before Pentium; R8–R15 belong to the 64-bit extension, not original Pentium. State the textbook convention when using a narrower “multipurpose” register category.
5 related practice questions
Note references: COA-X1
- x86 register map
COA22
x86 legality and implicit operands
- Legacy x86 operand legality
- Intel destination-first syntax
- MOV AL,BP: invalid 8/16-bit mismatch
- INC CX; DEC CX: valid words
- Segment MOV: register/memory forms
- Immediate→segment: no direct form
- Immediate→AX; MOV DS,AX
👁 Full explanation
Assume Intel destination-first syntax and ordinary legacy x86 forms. MOV AL,BP is invalid because operand widths differ (8 versus 16 bits). INC CX and DEC CX are valid word operations. Segment-register MOV has register/memory forms, not a direct immediate-to-segment form: load an immediate into AX, then MOV DS,AX. - Implicit MUL and instruction classes
- Byte MUL: AL×operand→AX
- Word MUL: AX×operand→DX:AX
- AL=8,BH=10; MUL BH → AX=80
- CL irrelevant
- MOVS/LODS: string transfers
- XCHG: operand exchange
- INC: arithmetic
- Different: transfer-versus-arithmetic criterion
👁 Full explanation
Unsigned MUL with a byte operand multiplies AL by that byte and writes AX. With a word operand it multiplies AX and writes DX:AX. Thus AL=8 and BH=10 gives AX=80 after MUL BH; CL is irrelevant. MOVS and LODS are string transfer operations, XCHG exchanges operands, and INC is arithmetic. “Different” requires the transfer-versus-arithmetic criterion.
4 related practice questions
Note references: COA-X2
- Legacy x86 operand legality
COA23
Memory hierarchy and timing
[Exam Focus]- Hierarchy and timing measures
- Speed/cost order: registers→L1/L2/L3→DRAM
- Then SSD→HDD→archival tape
- Faster: smaller, costlier per bit
- Access time: read/write latency
- Cycle time: minimum operation interval
- Recovery may extend cycle time
- Transfer rate: data/time, not delay
👁 Full explanation
A usual speed/cost-per-bit order is registers, L1/L2/L3 cache, DRAM, SSD, HDD and archival tape. Faster levels are generally smaller and more expensive per bit. Access time measures latency of a read/write; cycle time is the minimum interval before another operation and may include recovery. Transfer rate measures data per time, not individual-request delay. - Locality and cache metrics
- Temporal: reuse recent data
- Spatial: access nearby locations
- Cache: nearby memory-block copies
- Hit ratio=hits/accesses
- Miss ratio=1−hit ratio
- Capacity versus latency versus bandwidth
- Hit ratio: separate comparison dimension
👁 Full explanation
Temporal locality reuses recent data; spatial locality uses nearby locations. Cache copies memory blocks near the CPU. Hit ratio=hits/accesses; miss ratio=1−hit ratio. Distinguish capacity, latency, bandwidth and hit ratio before comparing alternatives. - Worked example Hit ratio and AMAT example
- 90/100 hits → 0.9
- Hit time: 2 ns
- Additional miss penalty: 50 ns
- AMAT=2+0.1×50=7 ns
👁 Full explanation
Worked microexampleFor 90 hits in 100 accesses, hit ratio=0.9. If hit time is 2 ns and an additional miss penalty is 50 ns, AMAT=2+0.1×50=7 ns.
10 related practice questions
Blueprint: COA-LO2 · Note references: COA-M
- Hierarchy and timing measures
COA24
RAM, firmware and chip capacity
- Memory technologies
- SRAM: powered bistable storage
- SRAM: fast, costly, no refresh
- DRAM: charge storage, refresh required
- DRAM: dense main memory
- SRAM/DRAM: ordinarily volatile
- ROM/flash: retain unpowered contents
- Erasable/programmable ROM variants
- ROM never modifiable: overbroad
- Firmware: low-level system code
- Commonly nonvolatile storage
👁 Full explanation
SRAM uses powered bistable storage: fast and costly per bit, without periodic refresh. DRAM stores charge and requires refresh: denser and commonly used for main memory. Both are ordinarily volatile. ROM and flash retain contents without power; erasable/programmed variants mean “ROM can never be modified” is too broad. Firmware is low-level system code, commonly in nonvolatile storage. - Memory-chip organization
- 2^a×w: words×width
- a address inputs; w data bits
- Parallel chips: increased word width
- Banks: increased word count
- Address decoding versus data selection
👁 Full explanation
For a chip described as 2^a×w, a is the number of address inputs and w the data width. Combine chips in parallel to increase word width and in banks to increase the number of words. Distinguish address decoding from data selection. - Worked example Chip-combination example
- Eight 1K×1 parallel → 1K×8
- 10 shared address lines
- 8 data bits
- Four banks → 4K×8
- Overall address bits: 12
👁 Full explanation
Worked microexampleEight 1K×1 chips in parallel make 1K×8 storage: 10 shared address lines and 8 data bits. Four such banks make 4K×8 and require 12 address bits overall.
4 related practice questions
Note references: COA-M
- Memory technologies
COA25
Cache placement and index bits
[Exam Focus]- Cache mapping equations
- B: block bytes; L: lines
- Block=floor(address/B)
- Offset=address mod B
- Direct: line=block mod L
- Fully associative: any line
- W-way: S=L/W sets
- Set=block mod S
- Any W ways within set
👁 Full explanation
Let B be block size in bytes and L the number of cache lines. Block number=floor(address/B); offset=address mod B. Direct mapping uses line=block mod L. Fully associative placement permits any line. A W-way set-associative cache has S=L/W sets and set=block mod S; any of W ways in that set may hold the block. - Cache address decomposition
- Power-of-two sizes assumed
- Offset bits=log2 B
- Index bits=log2 S
- Remaining address bits: tag
- Hit: matching tag and valid bit
- Same direct index: mutual conflict
- Associativity: fewer placement conflicts
- More tag comparisons
👁 Full explanation
For power-of-two sizes, offset bits=log2 B, index bits=log2 S and remaining address bits form the tag. Compare tags and valid bits to identify a hit. Two blocks with the same direct-mapped index cannot reside together. Associations reduce placement conflicts but require more tag comparisons. - Worked example Direct-mapped conflict example
- B=16 bytes; L=4 lines
- Addresses 0,64 → blocks 0,4
- Both index 0
- Alternating accesses: conflict misses
👁 Full explanation
Worked microexample16-byte blocks and four direct-mapped lines: addresses 0 and 64 have block numbers 0 and 4, both index 0, so alternating them causes conflict misses.
4 related practice questions
Blueprint: COA-LO2 · Note references: COA-M
- Cache mapping equations
COA26
Cache replacement and write policies
[Exam Focus]- Replacement trace rules
- FIFO: earliest inserted victim
- LRU: least recently accessed victim
- Track hit/miss, set, policy state
- Hits update LRU order
- Hits preserve FIFO insertion order
- Direct mapping: no victim choice
👁 Full explanation
FIFO evicts the earliest inserted line; LRU evicts the least recently accessed line. On each access, record hit/miss, the set involved and policy state. Hits update LRU order but do not reset FIFO insertion order. Direct mapping has no replacement choice within a line. - Write policies and cache classifications
- Write-through: lower-level update each write
- Write-back: cache update, dirty bit
- Dirty eviction: lower-level write
- Write-allocate: fetch missed block
- No-write-allocate: write below, no installation
- L1/L2: hierarchy levels
- Split: separate instruction/data caches
- Unified: combined instruction/data cache
- Internal/external: separate classification
- Location ≠ split/unified
👁 Full explanation
Write-through updates the lower level on each write; write-back modifies cache and marks a dirty bit, writing to the lower level on eviction. Write-allocate fetches a missed block before writing; no-write-allocate writes below without installing it. L1/L2 describe hierarchy levels; split cache means separate instruction/data caches and unified means combined. Internal/external location is another classification, not synonymous with split/unified. - Worked example FIFO versus LRU trace
- Two fully associative lines
- A,B,A,C: second A hits
- Remaining accesses miss
- LRU evicts B
- FIFO evicts A
👁 Full explanation
Worked microexampleTwo fully associative lines, references A,B,A,C: all except the second A are misses. LRU evicts B for C; FIFO evicts A.
1 related practice question
Blueprint: COA-LO2 · Note references: COA-M
- Replacement trace rules
COA27
Virtual addresses and page faults
- Virtual-memory mechanisms
- Translated process address spaces
- Protection
- Nonresident pages: backing storage
- MMU: virtual/logical→physical translation
- Page tables
- TLB: recent translations
- Virtual memory ≠ merely disk RAM
👁 Full explanation
Virtual memory gives processes translated address spaces and protection; backing storage can hold nonresident pages. The MMU translates virtual/logical addresses to physical addresses, using page tables and often a TLB of recent translations. Virtual memory is not just extra disk disguised as RAM. - Paging equations and fault distinctions
- Page=floor(virtual_address/P)
- Offset=virtual_address mod P
- Physical_address=frame×P+offset
- Valid nonresident access: page fault
- Invalid/forbidden accesses can fault
- Cache miss ≠ TLB miss
- TLB miss ≠ page fault
- Page fault ≠ mandatory disk read
- Zero-fill; resident shared pages
👁 Full explanation
With page size P, page=floor(virtual_address/P), offset=virtual_address mod P and physical_address=frame×P+offset. A valid nonresident page access faults and may require loading data; invalid or forbidden accesses can also fault. A cache miss, TLB miss and page fault are different events; not every page fault reads a disk, since zero-fill and already-resident shared pages exist. - Worked example Address-translation example
- P=1024; virtual_address=2053
- Page=2; offset=5
- Page 2→frame 7
- Physical_address=7×1024+5=7173
👁 Full explanation
Worked microexampleWith 1024-byte pages, address 2053 is page 2, offset 5. If page 2 maps to frame 7, physical address=7173.
3 related practice questions
Note references: COA-M
- Virtual-memory mechanisms
COA28
Persistent storage and access methods
- Storage media mechanisms
- HDD: magnetic tracks and sectors
- Addressed blocks; rotating platters
- Reading: head over track
- Seeking: radial head movement
- HDD bits survive power removal
- SSD: nonvolatile semiconductors, no mechanical seek
- Optical media: lasers
- Tape: sequential streaming and archives
- Ethernet cable: communication, not disk/RAM
👁 Full explanation
An HDD stores magnetic patterns on tracks divided into sectors; reads/writes access addressed blocks while platters rotate. A head normally stays over a track while reading but moves radially for seeks. It does not need continuous power to preserve stored bits. SSDs use nonvolatile semiconductor storage without mechanical seek. Optical media use lasers; tape is suited to sequential streaming and archives. An Ethernet cable is a communication medium, not a disk or RAM. - Access-method taxonomy
- Tape: sequential access
- Disk: direct, positioning delay
- RAM: random, broadly address-independent timing
- Associative: content matching
- Informal disk random-access usage
- Direct/random options require taxonomy
- Optical 100–300 ms: historical example
- Device timings: not universal
👁 Full explanation
In textbook access taxonomy, tape is sequential, disk is direct access with positioning delay, RAM is random access with broadly address-independent timing, and associative access matches content. “Random-access disk” is also common informal usage; specify the taxonomy when comparing direct and random access. Optical access ranges such as 100–300 ms are historical examples, not universal device specifications.
7 related practice questions
Note references: COA-M, COA-N
- Storage media mechanisms
COA29
I/O interfaces and commands
[Exam Focus]- Peripheral and interface roles
- Peripheral: input/output/storage beyond execution core
- CPU ≠ peripheral
- Input units: external information encoding
- Output units: processed-result presentation
- Controller: device protocol and timing
- Interface: data/status/control registers
- Buffers: speed mismatch absorption
- Error/status bits: condition reporting
👁 Full explanation
A peripheral performs input, output or storage outside the CPU’s execution core; CPU itself is not a peripheral. Input units encode external information and output units present processed results. A device controller handles device protocol/timing; its interface commonly exposes data, status and control registers. Buffers absorb speed differences and error/status bits report conditions. - I/O command categories
- Control: start actions
- Test/status: readiness/errors
- Read: device→system
- Write/output: system→device
- Issue: sending, not command category
- Controller: hardware
- Driver: controlling software
👁 Full explanation
Control commands start actions, test/status commands inspect readiness or errors, read commands bring device data toward the system, and write/output commands send system data to the device. “Issue” describes sending a command, not a standard fourth command category. A controller is hardware; a driver is software that operates it.
4 related practice questions
Blueprint: COA-LO1, COA-LO3 · Note references: COA-M
- Peripheral and interface roles
COA30
Polling, interrupts and DMA
[Exam Focus]- I/O transfer mechanisms
- Polling: repeated status checks
- CPU moves each item
- Interrupt-driven: other work until event
- Handler still consumes CPU time
- DMA: controller device↔memory block transfer
- CPU setup first
- Completion/errors may interrupt CPU
👁 Full explanation
Programmed/polled I/O repeatedly checks status and lets the CPU move each item. Interrupt-driven I/O lets the CPU do other work until an event requests service; the handler still consumes CPU time to service the device. DMA lets a controller move a block directly between device and memory after CPU setup. Completion or errors can interrupt the CPU. - DMA responsibilities and modes
- CPU: configuration and ownership
- Address mapping and completion
- Burst: bus held for block
- Cycle stealing: individual transfer opportunities
- Transparent: idle opportunities
- Reduced per-word CPU work
- Competes for memory bandwidth
- Substantial blocks favor DMA
- Device address mapping: separate dimension
👁 Full explanation
DMA does not eliminate CPU involvement in configuration, ownership, address mapping or completion. Burst mode can hold the bus for a block; cycle stealing takes individual transfer opportunities, and transparent DMA uses idle opportunities. DMA reduces per-word CPU work but competes for memory bandwidth. Choose it for substantial blocks; mapping devices to addresses is a separate design dimension. - Worked example Thousand-word transfer comparison
- Polling/interrupts: CPU work per word
- DMA: setup plus completion
- Actual memory transfers still take time
👁 Full explanation
Worked microexampleFor 1000 words, polling or interrupt transfer may require CPU work per word. DMA replaces much of that work with setup and completion, although the actual memory transfers still take time.
12 related practice questions
Blueprint: COA-LO1 · Note references: COA-M
- I/O transfer mechanisms
COA31
I/O spaces, priorities and handshaking
[Exam Focus]- Memory-mapped versus isolated I/O
- MMIO: device registers in memory space
- Suitable load/store operations
- Isolated: separate port space
- Special IN/OUT instructions
- Device access widths matter
- Ordering and side effects
- Status read ≠ harmless RAM read
👁 Full explanation
Memory-mapped I/O assigns device registers addresses in the memory address space and uses suitable load/store operations. Isolated/port-mapped I/O has a separate port space and special instructions such as IN/OUT. MMIO must respect device access widths, ordering and side effects; a status read is not necessarily a harmless RAM read. - Handshaking and interrupt priority
- Asynchronous request/ready plus acknowledgement
- Sender: data then request
- Receiver: accept then acknowledge
- Withdraw signals after acceptance
- Unequal-speed tolerance
- Single strobe: no feedback
- Priority: simultaneous interrupt selection
- Polling, daisy chains, priority hardware
- Serial: bits over time
- Parallel: multiple bits/lines
- Parallel ≠ guaranteed faster
👁 Full explanation
Asynchronous handshaking uses request/ready and acknowledgement signals to tolerate unequal speeds: sender presents data and requests, receiver accepts and acknowledges, then each withdraws its signal. A single strobe lacks this feedback. Interrupt priority selects among simultaneous requests, using schemes such as polling, daisy chains or priority hardware. Serial sends bits over time; parallel transfers multiple bits on multiple lines, without guaranteeing higher real-world speed.
4 related practice questions
Blueprint: COA-LO1 · Note references: COA-M
- Memory-mapped versus isolated I/O
COA32
Interfaces by connection role
[Exam Focus]- Named interface roles
- USB: serial peripherals, keyboards/storage
- RS-232: point-to-point serial electrical/interface standard
- Serial alone: USB/RS-232 ambiguity
- HDMI: digital video/audio
- Ethernet: networking, not memory
- SATA: storage interface
- Legacy IDE/PATA and SCSI
- iSCSI: SCSI commands over IP
👁 Full explanation
USB is a serial peripheral interconnect used by keyboards and external storage; RS-232 specifies a traditional point-to-point serial electrical/interface standard. Both RS-232 and USB use serial communication; distinguish their interface roles and specifications. HDMI carries digital video and audio. Ethernet connects network devices; it is not memory. SATA is a storage interface; legacy IDE/PATA and SCSI represent other storage connections, while iSCSI carries SCSI commands over IP. - Interconnect versus software standards
- PCI: peripheral expansion interconnect
- PCI ≠ disk protocol
- Unlike buses: bridge/controller logic
- Processor-bus extension needs topology
- PCI/Multibus: ambiguous without topology
- POSIX: software interface standard
- POSIX open/read/write/close
- ASCII: character encoding
- Standard disk interface requires era/requirements
👁 Full explanation
PCI is a peripheral expansion interconnect, not a disk protocol; connecting unlike bus segments requires suitable bridge/controller logic. “Extends processor-bus connectivity” without topology does not uniquely identify PCI or Multibus. POSIX is a software interface standard with operations such as open/read/write/close; ASCII is a character encoding. An unqualified “standard PC disk interface” needs an era or device requirement.
8 related practice questions
Blueprint: COA-LO1 · Note references: COA-USB, COA-RS, COA-HDMI, COA-ATA
- Named interface roles
COA33
Analog interfaces and component identity
- Conversion direction and named components
- ADC: analog input→digital code
- DAC: digital code→analog output
- ADC080x: 8-bit successive-approximation ADC
- DAC0830: DAC
- 82C55: programmable parallel I/O
- 82C55 ≠ ADC
- Component identity versus conversion direction
👁 Full explanation
An ADC measures an analog input and produces a digital code; a DAC produces an analog output from a digital code. ADC080x parts are 8-bit successive-approximation analog-to-digital converters; DAC0830 is a digital-to-analog converter, while 82C55 denotes a programmable parallel I/O interface, not an ADC. Component names are not interchangeable with the direction of conversion. - Converter resolution
- Ideal n-bit voltage span V
- Approximate code step=V/2^n
- Endpoint conventions/specifications required
- Quantization: analog ranges→discrete codes
- Sample rate ≠ resolution
👁 Full explanation
For an ideal n-bit converter spanning a voltage range V, one code step is approximately V/2^n; actual endpoint conventions and specifications must be stated. Quantization rounds an analog range into discrete codes; sample rate and resolution measure different properties. - Worked example ADC step-size example
- 8 bits; 5.12 V span
- 256 codes
- Step=5.12/256=0.02 V
- Same span, more bits: smaller steps
👁 Full explanation
Worked microexampleAn ideal 8-bit ADC over a 5.12 V span has 256 codes and a 0.02 V step. Greater bit depth reduces the quantization step for the same span.
1 related practice question
Note references: COA-TI
- Conversion direction and named components
COA34
Execution time and bottlenecks
[Exam Focus]- CPU performance equations
- CPU_time=instruction_count×CPI×clock_period
- CPU_time=instruction_count×CPI/clock_rate
- CPI: instruction-class weighted average
- IPC=1/CPI: consistent whole-program definitions
- Higher frequency ≠ faster program
- Increased instruction count/stalls
- Throughput: completed work/time
- Latency: individual job delay
👁 Full explanation
CPU time=instruction_count×CPI×clock_period=instruction_count×CPI/clock_rate. CPI may be a weighted average across instruction classes; IPC is its reciprocal only under a consistent whole-program definition. Raising clock frequency does not guarantee a faster program when instruction count or stalls increase. Throughput counts completed work per unit time; latency measures one job’s delay. - Amdahl’s law
- f: accelerated execution fraction
- s: local speedup factor
- Speedup=1/((1−f)+f/s)
- Unaffected fraction limits gains
- Same workload comparison
- Include memory and branch penalties
- Clock speed ≠ performance
👁 Full explanation
When a fraction f of execution is sped up by factor s, overall speedup=1/((1−f)+f/s). The unaffected fraction limits gains. Compare the same workload and include memory and branch penalties instead of equating clock speed with performance. - Worked example Performance calculation examples
- 10^6 instructions; CPI=2; 1 GHz
- CPU time=2 ms
- f=0.5; s=2
- Speedup=1/(0.5+0.25)=4/3
- Overall speedup ≠ 2
👁 Full explanation
Worked microexample10^6 instructions, CPI=2 and 1 GHz take 2 ms. If half the time becomes twice as fast, overall speedup=1/(0.5+0.25)=4/3, not 2.
1 related practice question
Blueprint: COA-LO2 · Note references: COA-M
- CPU performance equations
COA35
Pipeline overlap and timing
[Exam Focus]- Ideal pipeline timing
- Different instructions overlap stages
- Primary gain: throughput
- Balanced k-stage single-issue pipeline
- n instructions: k+n−1 cycles
- No stalls assumed
- Nonoverlapped work: nk stage cycles
- Steady-state: one instruction/cycle
- Individual latency: multiple stages
👁 Full explanation
A pipeline overlaps stages of different instructions; it primarily improves throughput. In an ideal k-stage single-issue pipeline, n instructions take k+n−1 cycles when stages are balanced and there are no stalls. Without overlap, comparable work takes nk stage cycles. The ideal steady-state completion rate is one instruction per cycle, while an individual instruction still spans multiple stages. - Pipeline clock and overhead
- Clock: slowest stage plus register overhead
- Short streams: fill/drain cost
- Fetch/decode overlaps another execution
- Multiple issue: several instructions/cycle
- Multiple-issue resources required
👁 Full explanation
Choose the pipeline clock using the slowest stage plus register overhead. Fill/drain overhead matters for short streams. “Fetch/decode one instruction while executing another” describes pipelining, whereas issuing several instructions in one cycle requires multiple-issue resources. - Worked example Five-stage timing example
- k=5; n=10
- Ideal cycles=14
- Nonoverlapped cycles=50
- Speedup=50/14≈3.57
- Short stream: below limiting fivefold gain
👁 Full explanation
Worked microexampleA five-stage pipeline processing 10 instructions takes 14 ideal cycles versus 50 without overlap: speedup=50/14≈3.57. It does not reach the limiting factor of five for this short stream.
4 related practice questions
Blueprint: COA-LO2 · Note references: COA-M
- Ideal pipeline timing
COA36
Hazards and instruction-level parallelism
[Exam Focus]- Pipeline hazard classes
- Structural: shared-resource competition
- Data: unavailable required result
- Forwarding: early result supply
- Some dependencies still stall
- Control: unresolved branch next PC
- Prediction: guess direction/target
- Speculative continuation
- Misprediction: discard work
👁 Full explanation
Structural hazards compete for one resource. Data hazards arise when an instruction needs a result not yet available; forwarding can supply results early, but some dependencies still stall. Control hazards arise when the next PC depends on an unresolved branch. Branch prediction guesses direction/target and continues speculatively; wrong guesses discard work. - Instruction-level parallelism mechanisms
- Superscalar: multiple instructions/units per cycle
- Dependencies constrain issue
- Out-of-order: ready before stalled older operations
- Preserve architectural results and exceptions
- Dynamic allocation: runtime entries/units
- Wider fetch: improved instruction supply
- Wider fetch ≠ lower memory latency
👁 Full explanation
Superscalar execution issues multiple instructions to multiple functional units in a cycle when dependencies permit. Out-of-order execution schedules ready operations before stalled older ones while preserving architectural results and exception behavior. Dynamic resource allocation assigns available internal entries/units at runtime. These mechanisms exploit instruction-level parallelism; wider fetch improves instruction supply, not necessarily individual memory latency.
6 related practice questions
Blueprint: COA-LO2 · Note references: COA-M, COA-ILP
- Pipeline hazard classes
COA37
Multiprocessing, vectors and Flynn classes
[Exam Focus]- Flynn stream classification
- SISD: one instruction, one data
- SIMD: one instruction, multiple data
- MIMD: multiple instruction/data streams
- MISD: multiple instructions, common data
- MISD uncommon
- Vector instruction: sequence of elements
- Physical lanes may batch elements
- Vector ≠ simultaneous entire sequence
👁 Full explanation
Flynn classifies instruction and data streams: SISD has one of each; SIMD applies one instruction stream to multiple data elements; MIMD uses multiple instruction and data streams; MISD has multiple instruction streams for a common data stream and is uncommon. A vector instruction describes an operation over a sequence of elements; physical lanes may process them in batches, not all in one instant. - Multiprocessor organization and scaling
- SMP: shared memory/I/O
- Peer processors under OS
- Distributed memory: separate address spaces
- Interprocessor communication
- More cores: available parallel work
- Serial dependencies and coordination limits
- Core i7: product family
- Core count requires model
👁 Full explanation
SMP processors share memory/I/O and have peer roles under an OS. Distributed-memory systems communicate between separate address spaces. More cores increase available parallel work, but serial dependencies and coordination limit speedup. “Core i7” is a product family rather than one core count; a model number is essential.
5 related practice questions
Blueprint: COA-LO2 · Note references: COA-M, COA-N
- Flynn stream classification
COA38
Historical generations and processor widths
- Generation conventions and caveats
- First: vacuum tubes
- Second: transistors
- Third: integrated circuits
- Fourth: microprocessor/VLSI-era PCs
- Stored programs: first era
- High-level languages: transition into second
- Dates cross generation boundaries
- Magnetic-core memory spans eras
- Witnessed-use clue: nonunique generation
- Multiple generations improved performance
👁 Full explanation
The familiar generation convention associates first with vacuum tubes, second with transistors, third with integrated circuits and fourth with microprocessor/VLSI-era personal computers. Stored-program machines arose in the first era. High-level languages became prominent around the transition into the second; introduction dates do not fit every generation boundary. Magnetic-core memory spanned more than one era, so “witnessed use” cannot identify exactly one. Several generations improved performance. - Integration and x86 width history
- Smaller individual components
- Increased capacity, density, performance
- Trends ≠ every-model guarantees
- 80386: 32-bit x86, 1985
- Before 80486/Pentium
- 80286: 16-bit predecessor
- n-bit CPU ≠ uniform register widths
- PC/IR/address widths may differ
👁 Full explanation
Integration generally reduced individual component dimensions while capacity, density and processor performance grew; these are trends rather than guarantees for every model. Intel’s 80386 introduced 32-bit x86 execution in 1985, before 80486/Pentium; the 80286 was a 16-bit predecessor. An n-bit processor label does not force its PC, IR or address register to be n bits.
12 related practice questions
Note references: COA-H, COA-386, COA-M
- Generation conventions and caveats
COA39
Underspecified and malformed questions
- Question-scope ambiguities
- Temporary storage: RAM/registers/cache
- Explicit role determines interpretation
- Memory includes ROM/flash
- Power-off disk/memory choice: RAM assumption
- Architecture lifetime requires assumptions
- Power efficiency requires assumptions
- Generational gains: not exclusive definitions
👁 Full explanation
Main memory, registers and cache can all provide temporary storage; identify the scope and role. Memory can also include nonvolatile ROM/flash, so distinguish RAM when comparing power-off data retention with disk storage. Architecture lifetime, power efficiency and generational improvements require assumptions; definitions alone do not make these exclusive. - Malformed bank-item handling
- TEST options displaced into stem
- Reconstructed intent ≠ unique answer
- Gate question: actual symbol required
- Absent drawing: definitions insufficient
- Opcode role explicit: figure unnecessary
- Identify minimal missing phrase
- Repair options or diagram
- Weak key ≠ authority
👁 Full explanation
For a TEST-instruction question, identify the instruction and the complete statements being compared before drawing a conclusion. Identify a logic gate from its actual graphical symbol. An opcode can be identified from an explicit description of its operation-field role even without a figure. Check that the question includes the phrase, choices or diagram needed to apply the relevant architecture rule.
1 related practice question
Note references: COA-M
- Question-scope ambiguities
No matching topics. Clear the search or change the filter.
Blueprint learning outcomes
- COA-LO1 · Identify different ways of communicating with I/O devices and standard I/O interfaces.
COA29, COA30, COA31, COA32 - COA-LO2 · Describe different performance enhancement of computer architecture
COA20, COA23, COA25, COA26, COA34, COA35, COA36, COA37 - COA-LO3 · Explain the basic structure of computer hardware & software
COA01, COA02, COA11, COA14, COA29 - COA-LO4 · Identify the processes involved in the basic operations of CPU
COA11, COA14, COA15, COA16, COA18, COA20