A Complex Instruction Set Computer (CISC) supplies a large number of complex instructions at the assembly language level. Assembly language is a low-level computer programming language in which each statement corresponds to a single machine instruction. CISC instructions facilitate the extensive manipulation of low-level computational elements and events such as memory, binary arithmetic, and addressing. This particular architectural methodology requires smaller binary files (because each CISC command accomplishes so much, relatively speaking) but involves relatively slow execution of each individual instruction (because the processor must perform more binary manipulations to fulfill each instruction). The goal of the CISC architectural philosophy is to make microprocessors easy and flexible to program and to provide for more efficient memory use.
The CISC philosophy was unquestioned during the 1960s when the early computing machines such as the popular Digital Equipment Corporation PDP 11 family of minicomputers were being programmed in assembly language and memory was slow and expensive. CISC machines merely used then-available technologies to optimize computer performance. Their advantages included the following: (1) A new processor design could incorporate the instruction set of its predecessor as a subset of an ever-growing language--no need to reinvent the wheel, code-wise, with each design cycle. (2) Fewer instructions were needed to implement a particular computing task, which led to lower memory use for program storage and fewer time-consuming instruction fetches from memory. (3) Simpler compilers sufficed, as complex CISC instructions could be written that closely resembled the instructions of high-level languages. In effect, CISC made a computer's assembly language more like a high-level language to begin with, leaving the compiler less to do.
Some disadvantages of the CISC design philosophy are as follows: (1) The first advantage listed above could be viewed as a disadvantage. That is, the incorporation of older instruction sets into new generations of processors tended to force growing complexity. (3) Many specialized CISC instructions were not used frequently enough to justify their existence. The existence of each instruction needed to be justified because each one requires the storage of more microcode at in the central processing unit (the final and lowest layer of code translation), which must be built in at some cost. (4) Because each CISC command must be translated by the processor into tens or even hundreds of lines of microcode, it tends to run slower than an equivalent series of simpler commands that do not require so much translation. All translation requires time. (4) Because a CISC machine builds complexity into the processor, where all its various commands must be translated into microcode for actual execution, the design of CISC hardware is more difficult and the CISC design cycle correspondingly long; this means delay in getting to market with a new chip.
The idea that fundamentally non-CISC architectures were possible and desirable received confirmation in the mid-1970s, when John Cocke and his colleagues at IBM Research Labs discovered that by reducing the full set of instructions available on an existing machine to the most frequently used instructions, code could be made to run two or three times faster. Cocke's group simply avoided using certain inefficient instructions in the CISC instruction set; they used a reduced set. The terms CISC and RISC (Reduced Instruction Set Computer) were coined at this time to reflect the widening split in computer-architectural philosophy.
Until the mid-1980s, however, the trend among computer manufacturers was still to build more complex microprocessors that possessed ever-larger sets of instructions. It was easier to keep the familiar design cycle going, utilizing existing skills and styles of design. At that time, however, a few computer manufacturers decided to reverse this trend by building microprocessors capable of executing only a limited set of instructions--RISC microprocessors. RISC microprocessors were designed for the execution of a relatively small number of simple instructions rather than for the execution of a large variety of complex instructions, as in a CISC microprocessor. RISC designers translated many of the longer, more complex instructions used in CISC machines into multiple instructions that were each shorter and faster to process. Because there were fewer and simpler instructions, microcode and hardware in the processor could be simplified; because these simpler operations were invoked individually, rather than in large predefined packages (which was the effect of invoking complex CISC instructions), only those operations strictly necessary need be executed. Programs for RISC microprocessors produced larger binary files when compiled, but memory was already cheaper than in previous decades; furthermore, overall RISC program execution was faster and RISC microprocessors less expensive to design and produce.
RISC concepts have been promoted, at times, with so much zeal as to seem more like articles of faith than principles of engineering. In fact, there has been no simplistic victory of RISC over CISC. Both CISC and RISC chips continue to this day to do a good business. CISC microprocessors have dominated in the PC market, while RISC microprocessors have traditionally been used in workstations and other high-end computer systems. Examples of CISC microprocessors include Motorola's 68000 series and the family of Intel 80x86 and Pentium microprocessors that are commonly used in many IBM-compatible PCs. Examples of RISC microprocessors include the PowerPC microprocessor that is used inside Apple Corporation's Macintosh computers, and the microprocessors used in IBM's RISC System/6000 workstations and Sun Microsystems's SPARC (Scalar Processor ARChitecture).
The issue of whether CISC or RISC is "better" is becoming increasingly moot, as the two philosophies evolve and converge. Many of today's RISC microprocessors support as many instructions as yesterday's CISC microprocessors, and today's CISC microprocessors use many techniques normally associated with RISC microprocessors. Intel's Pentium chip is sometimes held up as an example of a compromise architecture: CRISC, for Complex/Reduced Instruction Set Computer. Adding to the complexity of the picture, EPIC (Explicitly Parallel Instruction Computing) has been developed by Intel Corporation for the server market, and will eventually, most likely, appear in the personal computer market as well. The great advantage of the RISC/CISC debate has been to focus intense and agitated attention on the most fundamental questions of programming: what is it absolutely necessary that a processor do, and what is the fastest possible way it can be made to do it?
This is the complete article, containing 1,023 words
(approx. 3 pages at 300 words per page).
