Types Of Architecture

The instruction set architecture (ISA) or simply architecture of a computer defines the set of machine code instructions that the computer can perform or execute and the format of each instruction. It also includes a specification for the size and number of registers along with the data types supported, and support for accessing main memory and working with the input/output system. The ISA is an interface between the software and hardware.

Early Computer Designs

The architectures of computers prior to the early 1980's were designed with instruction sets containing a large number of instructions, some of which were complex and specialized. Multiple versions of each instruction were provided that offered different combinations for accessing registers and/or memory as part of the operation. Thus, one instruction could perform multiple steps. For example, one instruction could load a value from memory, use it in a computation, and store it back into memory. Other versions of the same operation, may only allow only access to registers, or a combination of registers and memory.

The main memory unit of a computer was very expensive and most computers did not contain lots of memory. The original IBM PC desktop, as an example, only contained 640K bytes of memory. Thus, one of the design principles at the time, was to reduce the amount of memory used for the program instructions. The more memory used for instructions, the less was available for data. But accessing memory is very slow relative to other operations performed by the processor due to the use of the system bus to interact with the memory unit. Instructions that accessed memory required far more time to execute than the simple instructions. Having multiple versions of the same operation, many of which were complex, required more digital circuitry within the hardware. The more circuity, the more electricity that flows through the processor, the hotter the processor can get.

In the late 1970's, computer designers began studying and reevaluating a number of design principles that had guided the industry up to that point. They evaluated and observed a large number of programs in use at the time and discovered that data movement or memory access accounted for 45% of all instructions, the use of the ALU accounted for 25%, and flow control for 30%. Although there were a large number of complex instructions available, they were seldom used. It was observed that compilers typically avoided the complex instructions, opting instead for the fastest instructions that accessed registers. This led to an extensive use registers for storing intermediate values to the point of using all that were available. [1]

These observations suggested the possibility of two major improvements in computer architecture. First, the inclusion of more registers could improve the performance or execution time of a program, and second, removing a majority of the complex instructions would not affect the resulting code. Removing a large number of instructions would reduce the size of each machine code instruction and make bits available that could be used to select from among more registers. Based on this work, Patterson and Ditzel published a paper in 1980 that argued for the reduced instruction set computer. [2] This led to an explosion of research and the development of a variety of new computer architectures designed on the idea of reducing the number of instructions and increasing the number of registers.

Modern Computer Designs

Most computers today can be classified as either a complex instruction set computer (CISC) or a reduced instruction set computer (RISC). A CISC architecture refers to the types of computers that were created and designed prior to the early 1980's. As the name suggests, this type of architecture includes a large number of instructions, many of which are complex with multiple versions for accessing memory. RISC architectures, on the other hand, contain a small set of highly-optimized instructions that require more machine code instructions to complete the same task. Although there are more instructions, the underlying hardware can be simplified allowing each instruction to execute faster.

The Intel x86 processor is an example of the CISC instruction set architecture. But, it should be noted that modern Intel processors use a RISC design for the implementation or organization of the processor, while maintaining a CISC instruction set. A number of RISC type architectures were produced by the start of the 21st century, with many continuing to evolve. Some of the more common RISC architectures are listed in Table 1.

Design Principles

There are four major principles of hardware design today, which helped to lead to the development of the RISC architectures:[3]

The ultimate or overall goal of computer design is to find a language or instruction set that makes it easy to build the hardware and compiler, while maximizing performance and minimizing cost. These design principles will be discussed more as we explore the MIPS instruction set and assembly language in the following sections and chapters of the text.

MIPS Architecture

In 1981, Dr. John Hennessy led a team of researchers at Stanford University in designing and building a new processor using the RISC principles. The result was the MIPS architecture. Other technologists joined Dr. Hennessy and helped him to commercialize the MIPS processor. The first commercial processor was released by MIPS Computer Systems in 1985. It was known to provide high performance at a low cost.

The original processor, the R2000, was a 32-bit processor. It had 32 general purpose registers, each of which stored a word of 32-bits. Several new versions were soon released, including the R3000 in 1988. The R3000 was adopted by Silicon Graphics for use in their new SGI high-performance graphics computers and later by DEC for their servers. In 1989, following a growing success, MIPS Computer Systems went public. This soon led to the release of the R6000, which was based on the second release of the MIPS ISA, the one currently in use.

In 1991, MIPS released the R4000 processor, the world's first 64-bit processor. Given the importance of the MIPS processor to their biggest client, Silicon Graphics purchased MIPS and incorporated it as subsidiary under the name MIPS Technologies, Inc. Silicon Graphics soon released a new line of workstations called IRIS, which used the new 64-bit processors, making them the first 64-bit computers ever built. The IRIS workstations were used to generate the computer graphics for the first Jurassic Park movie back in 1993. One of the workstations made a cameo appearance in the movie. Over the following years, new versions of the MIPS processor were released and by the late 1990s, the company had-shipped a record breaking 48 million units. [4] At the beginning and early part of the new century, the MIPS processor was used in a number of game consoles including the PlayStation, PlayStation2, and Nintendo 64. Today, MIPS processors are used in a wide range of home network gateways and routers.

The MIPS architecture has long been used to teach computer organization and architecture. In this text, we use the MIPS II 32-bit architecture and assembly language to explore the various topics of computer organization and architecture. As you will soon see, MIPS has a simple instruction set that is easy to learn and use.