Computer architecture studies the organization and behaviour of computers, connecting the operations visible to software with the hardware that executes them. An instruction set architecture specifies the machine-level contract, including instructions, accessible processor registers and addressing behaviour. A microarchitecture is a particular implementation of that contract, including execution units, instruction pipelining and memory caches.[ref]
Instruction Set Architecture in the Arm documentation. FAQ, distinction between instruction set architecture and microarchitecture
Two CPUs can implement the same instruction set architecture while taking different times to run the same computer program. One might overlap independent instructions or use a larger memory cache; neither choice changes what an addition instruction is required to compute. A useful performance model writes execution time as instruction count times average cycles per instruction divided by clock frequency. The factors interact: a design that raises clock frequency can also change cycles per instruction. This separates a program's required behaviour from the engineering choices that determine its cost.
Memory bandwidth is the rate at which data crosses a specified computer memory interface, commonly measured in bytes per second. If bytes are transferred in time , the measured average is . The interface and counting convention matter: an application-level count can differ from physical traffic caused by memory caches.
A streaming array operation reading two eight-byte values and writing one per element transfers at least 24 useful bytes per element. At a sustained bytes per second, that traffic alone limits throughput to elements per second. Memory access latency instead measures how long one access takes. Overlapping many accesses can achieve high memory bandwidth despite substantial memory access latency. STREAM measures sustained memory bandwidth with simple array kernels and working sets larger than the available memory cache.[ref]
STREAM Benchmark Reference Information by John D. McCalpin. What is STREAM?, Run Rules and byte-count table
STREAM is a benchmark for sustained memory bandwidth using simple operations on large arrays. Its Copy, Scale, Add and Triad kernels exercise different combinations of reads, writes and arithmetic. Working sets must exceed the available memory cache sufficiently to characterize transfers beyond it, rather than merely repeated access to cached values.[ref]
STREAM Benchmark Reference Information by John D. McCalpin. What is STREAM?, Run Rules and Counting Bytes and FLOPS
For eight-byte elements, Triad computes
a[i]=b[i]+s*c[i]: two loads and one store give 24 requested bytes and two floating-point operations per element. Ten million elements therefore account for 240 million requested bytes. An elapsed time of 0.01 seconds would give bytes per second under that counting convention. This is a stipulated calculation, not a measured machine result. Physical bus traffic can differ because of cache behavior, so a bandwidth report must state its convention and test configuration.Cycles per instruction is the average number of processor clock cycles spent per counted instruction for a specified execution interval and counting convention. If instructions complete in cycles, . At constant clock frequency , execution time satisfiesFor example, completed instructions at CPI 1.5 and hertz take 0.5 seconds.
The value depends on instruction mix, dependencies, cache misses, branch behavior and the chosen microarchitecture. It can be less than one when several instructions complete per cycle. A long-latency instruction need not prevent other independent work from overlapping, so individual instruction latencies cannot simply be added to predict elapsed time. Comparing processors by frequency alone ignores both CPI and the number of instructions needed for the same task.
A microarchitecture is a particular hardware organization implementing an instruction set architecture. It specifies mechanisms such as instruction decoding, execution units, pipelines, caches and branch prediction. Two processors can expose the same instruction-set contract while making different choices about those mechanisms.
For example, both processors may correctly execute a load followed by an integer addition. One can overlap independent instructions and obtain the load from a nearby cache, while the other waits for a longer memory access. The architectural result agrees, but cycle counts differ. Speculative work must be discarded or committed in a way that preserves the required visible behavior. This distinction explains why compatibility with one instruction set does not imply equal performance, power consumption or physical implementation.[ref]
Hardware for floating-point arithmetic. Its cost and historical absence on some processors motivate integer arithmetic implementations of raster graphics algorithms.
Articles by others on the same topic
The term loosely refers to certain layers of the computer abstraction layers hierarchy, usually high level hardware internals like CPU pipeline, caching and the memory system. Basically exactly what gem5 models.