|
In this article:
- What is CISC?
- Development of CISC
- Problems in the CISC
- Difference between CISC and RISC
- CISC today
What is CISC?
A Complex instruction set computer (CISC) is a microprocessor instruction set architecture in which each instruction executes several low-level operations. These operations maybe an arithmetic operation or a memory store or retrieval. The term was coined to differentiate between it and the Reduced Instruction Set Computer (RISC).
Development of CISC
There was no official start of the development of the CISC. It was more of an industry trend that prevailed before the RISC processors were designed. Compilers were not present at that time. This forced the developers to write instruction sets that could support high level languages. This was basically a semantics gap. They made complex addressing modes and clubbed them together to form one single instruction. This clubbing resulted in small programs sizes and reduced the number calls to main memory that caused a tremendous savings on the cost of a computer in the 1960s.
Problems in the CISC
There were certain problems that were later discovered that finally led to the development of RISC. These were:
- CISC allowed high-level languages to express their constructs in a few instructions. This was achieved easily. The problem was that this did not translate into better or improved performance each time. It was found out that it was possible to increase performance by using a series of simple and multiple instructions instead of a single and complex one on some processors.
- The complex instruction also meant greater execution time. The overhead that was the result of the complexity of an instruction took up more and more time and silicon. As a result, even simple instructions were slow to execute due to the presence of the complex ones.
- The CISC architecture resulted in the use of many transistors on the chip. This left very less or no space for other techniques of improving performance.
- Another implication of the CISC was that it took the chip maker a lot of time and effort to develop it.
There are certain examples of CISC processors such as the System/360, VAX, PDP-11, Motorola 68000 range of processors etc.
Difference between CISC and RISC
The differences between CISC and RISC architectures are as follows:
- While CISC gave an emphasis to hardware in order to reduce the complexity of the high level languages, the RISC architecture concentrated on software and kept the hardware as simple as possible.
- The CISC architecture includes multi-clock complex instructions to do the processing while the RISC architecture uses the Single-clock, reduced instruction to do so.
- The CISC architecture used the memory-to-memory way of working. The instructions like LOAD from memory and STORE in memory were kept together other instructions to form a single, complex instruction. RISC, on the other hand, used Register-to-Register and both of the above instructions were independent of each other.
- The CISC architecture was able to achieve small program size due to the clubbing of many instructions into one and had a high number of cycles per second. This lead to high speeds but was not always true. The use of RISC resulted in larger programs and a lower number of cycles in each second.
- The CISC architecture stored the complex instructions that it had in the transistors while the RISC architecture used the transistors to store memory registers.
CISC Today
CISC, as a term is not in accordance with its original meaning. Processors such as the PowerPC released in the 80s have already blurred the line between CISC and RISC. New processors have bridged the gap between CISC and RISC and the border line is too thin. A characteristic of RISC was that it was pipelined to carry data. But the processors in use now, though under CISC, are also pipelined. Intel’s 486 were the first of the lot. They support all instructions of their predecessors and even many others. Today’s desktop PCs use Intel’s x86 architecture based CPUs which attain way higher performance than CISC or RISC. For a basic user though, any difference in performance is not perceptible even among the variations of the same x86 architecture.
|
