History of Computers - Von Neumann Architecture

Introduction

Von Neumann architecture was developed by computer scientists/mathematicians John von Neumann, John William Mauchly, J. Presper Eckert, and Arthur Burks in 1945. The term originated when Von Neumann, with the help of Mauchly, Eckert, and Burks, wrote a paper titled First Draft of a Report on the EDVAC (1945) that proposed the concept of a stored-program computer that would be the successor to the ENIAC. (The term stored-program indicates that programs are stored and executed in main memory.)

Von Neumann

Overview

In contrast to the more modern Modified Harvard architecture, Von Neumann stored-program computers use the same storage to hold both the instructions needed for a computation and the data needed or generated by the computation. (Modified Harvard architecture uses different sets of data and address buses to read/write data and fetch instructions.)

The first Von Neumann computer was the Manchester Small-Scale Experimental Machine (SSEM), built in Manchester University in England. In 1948, the SSEM ran its first stored-program out of a 96-word memory, at a speed of 0.00083 MIPS (millions of instructions per second).

In 1952, the EDVAC (electronic discrete variable automatic computer) was completed with Von Neumann's design.

In previous, more special-purpose computers, the instruction set was programmed into the hardware, and only the data set and the immediate computational results were stored, and thus these computers were restricted to performing only the one computational procedure that they were built for. If these computers needed to be reprogrammed, they had to be physically re-wired or rebuilt. With the development of Von Neumann architecture, the instructions were encoded into binary and stored in working memory, and thus Von Neumann computers were electronically reprogrammable and thus more general-purpose since instructions could be changed/replaced easily.

A basic Von Neumann computer is composed of five main parts: memory/storage for both the data set and the program (nowadays, this memory is RAM), a control unit (part of the CPU), an arithmetic logic unit (ALU; also part of the CPU), input and output structures, and a data bus that connects these parts. The control unit executes the program instructions sequentially, one at a time, and has a register (sometimes called an accumulator) to store immediate results.

A true Von Neumann computer performs the following sequence of steps to execute a single instruction:

1. Check the memory address in the control unit's program counter.
2. Fetch the instruction located at the given address.
3. Add the length of instruction to the program counter.
4. Execute the instruction using the control unit, which commands the rest of the computer to perform the instruction/operation.
   1. The instruction may change the address in the program counter for two reasons:
      1. If some arithmetic condition is true
      2. To perform a repetitive operation
5. Proceed to step 1 and repeat the process for the next instruction.

Most computers do not have pure Von Neumann architecture and add another step to check for interrupts (electronic events).

A drawback of Von Neumann architecture is that computers built with this architecture can only do either an instruction fetch or a data operation at a time, and they spend a lot of time moving data to and from memory, so performance slows down and reaches a bottleneck (i.e. the Von Neumann Bottleneck). However, this issue has been corrected with the development of parallel computing, in which a multi-processor computer divides a large problem into several smaller ones and performs many calculations at the same time.

Another downside of Von Neumann architecture stems from the fact that the control unit can't effectively distinguish whether a piece of fetched data is an instruction or computational data, for there is no distinction between the two in memory. Thus, the control unit can sometimes be made to recognize an instruction as computational data, and thus instructions can sometimes operate upon other instructions, and that allows for self-modifying programs. Self-modifying programs are usually not considered to be within good programming practice, due to the complications they cause in debugging and the possibility that a malfunctioning program could damage itself, other programs, and even the operating system, leading to a computer crash.

On the other hand, the Von Neumann computer's ability to treat instructions as data was essential to the development of assemblers, compilers, and other "programs that write programs". With this in mind, the ability to treat instructions as data has been retained, and memory protection and other types of access control are now used to prevent erroneous program modification.

Significance

Von Neumann architecture allowed computers to become truly reprogrammable for the first time, for it allowed for instructions to be changed easily since only the working storage (and not the permanent storage) had to be changed. This set the stage for future, more general-purpose computers more directed towards the general public since a single computer could be used to perform a variety of different computational procedures, due to the fact that new instruction sets could be inputted.

In addition, Von Neumann computers, because of their ability to treat instructions as data, led to the development of self-modifying code, which can be used to improve algorithmic efficiency and execution speed.

Computers today, although most use the two-bus system of Modified Harvard architecture, are still based upon the Von Neumann concept of stored-program.