Question bank — Cache lines, tags, index, offset

True — one set means $S=1$ and ${\log }_{2}1=0$, so no bits are spent choosing a row; every non-offset bit becomes tag and the hardware compares all slots.

False — offset is ${\log }_{2}B$ and depends only on line size $B$; a bigger cache adds sets/ways (more index or tag), never more offset.

True — 8-way means $k=8$, so $S$ shrinks by 8, index loses ${\log }_{2}8=3$ bits and the tag gains exactly those 3 bits.

False — only the tag field is stored and compared; the index already picked the row and the offset only picks a byte, so they are not part of the identity check.

True — that is the whole point: memory is far bigger than the cache, so many blocks share each set and the tag disambiguates which one is currently resident.

False — bigger $B$ increases offset bits (${\log }_{2}B$); you need more bits to name more bytes inside the larger line.

True — direct-mapped is 1-way ($k=1$), so $S=L$, and ${\log }_{2}S={\log }_{2}L$.

False — with high bits as index, a contiguous run of blocks shares the same high bits, so they all collide in one set and thrash; low bits are used precisely so neighbors scatter.

Wrong — the offset (6 bits) is not nibble-aligned, so the index starts at bit 6, not on a hex boundary; the real index is bits 13..6 = 11111011 (0xFB = set 251).

Wrong — offset depends only on line size, so both have ${\log }_{2}64=6$ offset bits; only their index/tag split differs.

Wrong — the valid bit is checked first to see if the slot holds real data at all; only if it is 1 do we compare the stored tag against the address's tag.

Wrong — it has zero index bits; it is costly because it must compare the tag against every line's tag in parallel (lots of comparators), not because of indexing.

Wrong — the field boundaries fall at ${\log }_{2}B$ and ${\log }_{2}B+{\log }_{2}S$ bit positions, which rarely align with 4-bit hex boundaries; you must peel bits, not nibbles.

Wrong — more ways ($k$) means fewer sets, hence fewer index bits; a lookup touches exactly one set but that set now holds more lines compared in parallel.

Wrong — one more offset bit is stolen from the fields above; with fixed sets the tag shrinks by one bit (or if sets halve to keep line count, index shrinks). Bits are conserved across the fixed $32$-bit address width.

So consecutive blocks land in different sets; this spreads a sequential scan across the cache instead of hammering one set and evicting itself repeatedly.

Spatial locality — nearby bytes are likely used soon — and it amortizes the fixed per-line overhead (tag + valid bits) over many data bytes.

Because many blocks map to the same row; the index only narrows to a set, and the tag proves which of those competing blocks is the one actually stored.

Associativity regroups a fixed number of lines into wider sets; it changes how many sets exist ($S$) but never the line size $B$, so only index↔tag shift while offset stays put.

Bit slicing is pure wiring — no adders, no search, so it resolves in a fraction of a cycle, which is essential because the lookup sits on the critical path of every load.

If the program touches only one byte and then jumps far away, you still hauled the whole line across the bus, paying for many bytes you never read.

Offset grows by ${\log }_2$(growth), and since index is pinned, the tag shrinks by the same amount — the total $32$-bit address width is conserved.

It is trivially both direct-mapped and fully associative: $S=1$ so zero index bits, and everything above the offset is tag.

Zero — one line means one set, so ${\log }_{2}1=0$ index bits; the address is just tag plus a large offset.

Yes — if their tags differ they are entirely different memory blocks that merely collide on the same set; only one can reside there at a time.

Then ${\log }_{2}S$ is not an integer and simple bit-slicing breaks; real caches keep $S$ (and $B$) as powers of two precisely so each field is a clean bit range.

It compares the address's tag against the stored tag of every line in parallel (one comparator per line), since any block may live in any slot.