Von Neumann vs Harvard Architecture
In Von Neumann vs Harvard architecture, a Von Neumann computer stores program instructions and data in the same memory and reaches them over one shared bus, so it cannot fetch an instruction and access data at the same moment. A Harvard computer has separate memories and buses for instructions and data, so it can do both at once. Most modern processors are a modified Harvard design: split instruction and data caches inside the chip, one shared main memory outside.
Every digital computer needs a way to fetch its program and move its data. The two classic answers are named after John von Neumann, whose 1945 report on the EDVAC described the stored program computer, and the Harvard Mark I, an electromechanical computer that read instructions from punched tape separately from its data. The difference shapes processor speed, design complexity and how programs can be loaded.
Von Neumann architecture
The Von Neumann (or Princeton) architecture has four main parts: a central processing unit with a control unit, arithmetic logic unit (ALU) and registers; a single memory holding both instructions and data; input and output devices; and a bus connecting them.
The processor repeats the fetch, decode, execute cycle:
- Fetch the instruction at the address in the program counter from memory.
- Decode it to find the operation and operands.
- Execute it, which may read or write data in the same memory.
- Update the program counter and repeat.
Storing programs as data was a breakthrough. A program can be loaded, replaced or even generated by another program, which makes compilers, operating systems and interpreters possible. The cost is the Von Neumann bottleneck: instruction fetches and data accesses compete for one path, and memory is much slower than the processor.
Harvard architecture
The Harvard architecture uses physically separate memories, and separate address and data buses, for instructions and data. The CPU can fetch the next instruction while the current one reads or writes data, so pipelined execution is smoother. The two memories can even have different widths and technologies, for example 16 bit wide flash for instructions and 8 bit wide RAM for data.
The downsides are more wiring and pins, fixed division of memory between program and data, and less flexibility: a pure Harvard machine cannot easily treat its program as data, so special instructions or mechanisms are needed to read constants stored in program memory or to update firmware.
Von Neumann vs Harvard architecture: comparison
| Feature | Von Neumann | Harvard |
|---|---|---|
| Memory for instructions and data | One shared memory | Two separate memories |
| Buses | One set, shared | Separate instruction and data buses |
| Simultaneous fetch and data access | No | Yes |
| Speed | Limited by the bottleneck | Higher throughput per clock |
| Hardware complexity and cost | Lower | Higher |
| Flexibility | Memory split decided by software | Fixed split between program and data |
| Self-modifying or loaded code | Natural | Needs special support |
| Typical use | General purpose computers (at system level) | Microcontrollers, DSPs, CPU caches |
Modified Harvard architecture
Modern high performance processors combine both ideas. Main memory is shared (Von Neumann), so the operating system can load any program as data. But inside the chip, the level 1 cache is split into an instruction cache and a data cache with separate paths to the execution core (Harvard), so the processor can fetch instructions and load data in the same cycle. Higher cache levels are usually unified. Many microcontrollers are also “modified Harvard”, allowing instructions to read constant tables from program memory.
Caches exploit locality: programs tend to reuse recent data and access neighbouring addresses. That is why contiguous structures perform well, as shown in arrays vs linked lists.
- Given
- A simple processor where every instruction needs one memory fetch, and 40 percent of instructions also need one data access. Each memory access takes one bus cycle.
- Find
- Average bus cycles per instruction on a Von Neumann and a Harvard design.
- Assumptions
- No caches; one access per bus per cycle; execution overlaps fully with memory access.
- Solution
- Von Neumann: 1 fetch + 0.4 data = 1.4 cycles on the single bus per instruction
Harvard: fetch and data proceed on separate buses in parallel, so the limit is the busier bus: 1 cycle per instruction - Answer
- About 1.4 cycles per instruction for Von Neumann against 1.0 for Harvard, roughly 40 percent more throughput in this simple model
- Limitations
- Real processors use caches, pipelines and wider buses, so the actual difference depends heavily on hit rates and workload.
The memory hierarchy
Because main memory is far slower than the processor, every modern computer uses a hierarchy of storage: registers inside the core, then level 1, level 2 and level 3 caches, then main memory, then solid state or disk storage. Each level is larger and slower than the one above. The processor looks for data in the fastest level first and only goes further down on a miss. This hierarchy is the main practical answer to the Von Neumann bottleneck, and it is why the split L1 instruction and data caches matter so much: they keep the execution core fed every cycle.
Programmers can help the hierarchy by keeping data that is used together close together in memory and by processing it in order.
Where each architecture is used
- Desktop, laptop and server processors: modified Harvard, with split L1 caches and shared main memory.
- Microcontrollers: many families (for example AVR and PIC) use Harvard; ARM Cortex-M cores have separate instruction and data bus interfaces. See microcontroller vs microprocessor.
- Digital signal processors: Harvard or extended Harvard designs with multiple data memories to feed multiply accumulate operations every cycle, important in applications built on the sampling theorem.
- Teaching models and simple CPUs: usually Von Neumann.
The architecture also affects software: operating systems manage how processes and threads share memory, and the performance of algorithms depends on how well their memory access patterns suit the cache hierarchy.
Frequently asked questions
Do modern PCs use Von Neumann or Harvard architecture?
Both, in a sense. Programs and data share one main memory, which is Von Neumann at the system level. Inside the processor, the first level cache is split into separate instruction and data caches that can be accessed at the same time, which is Harvard style. This combination is called a modified Harvard architecture.
What is the Von Neumann bottleneck?
The limit on performance caused by a single path between the processor and memory. Instructions and data must take turns on that path, and the processor can execute far faster than main memory can supply them, so it often waits. Caches, wider buses and parallel fetching reduce the effect.
Why do microcontrollers often use Harvard architecture?
Many microcontrollers keep the program in flash and data in RAM. Separate buses let the CPU fetch the next instruction while reading or writing data, giving predictable single cycle execution, and different word widths can be used for program and data memory.
References
- J. von Neumann, First Draft of a Report on the EDVAC, 1945
- J. L. Hennessy and D. A. Patterson, Computer Architecture: A Quantitative Approach, 6th ed., Morgan Kaufmann
- D. A. Patterson and J. L. Hennessy, Computer Organization and Design, RISC-V Edition, Morgan Kaufmann
- J. Backus, Can Programming Be Liberated from the von Neumann Style?, Communications of the ACM, 1978
Get one engineering email a week
New articles, worked examples and study notes every week. Free, no spam, unsubscribe any time.
