Complex instruction-set computing or Complex Instruction-Set Computer (CISC); “Complex instruction set computing”) is an instruction set architecture in which each instruction will perform several low-level operations, such as fetching from memory, arithmetic operations, and storing into memory, all at once in just one instruction. The characteristics of CISC can be said to be the opposite of RISC.
Before the RISC process was first designed, many computer architects tried to bridge the semantic gap, namely how to create instruction sets to facilitate high-level programming by providing "high-level" instructions such as procedure calls, looping processes and complex addressing modes so that data structures and array access can be combined with a single instruction. The "information-rich" characteristics of CISC provide the advantage that the size of the resulting programs will be relatively smaller, and memory usage will be reduced. Because of this CISC, the cost of making computers at that time (1960) became much more economical.
It is true that many designs do provide better results at lower cost, and also result in simpler high-level programming, but this is not always the case. For example, a poorly designed complex architecture (which uses microcode to access hardware functions) will find itself in a situation where it would be easier to improve performance by not using complex instructions (such as procedure calls) but by using a sequence of simpler instructions.
One reason for this is that high-level instruction sets, often encoded (for complex codes), would be quite difficult to translate back and execute effectively with a limited number of transistors. Therefore, these architectures require more focused handling in processor design. At that time, where the number of transistors was quite limited, it resulted in increasingly narrow opportunities to find alternative ways to optimize processor development. Therefore, the idea of using RISC design emerged in the mid-1970s (IBM Watson Research Center 801 - IBMs).
Examples of CISC processors include the System/360, VAX, PDP-11, variants of the Motorola 68000, and AMD and Intel x86 CPUs. The terms RISC and CISC are less commonly used today, having seen further developments in both RISC and CISC design and implementation. The first parallel CISC implementations, such as the 486 from Intel, AMD, Cyrix, and IBM, supported every instruction used by earlier processors, although their efficiency was only achieved on a simple subset of x86 (similar to the RISC instruction set, but without the RISC store/fetch limitations). Modern x86 processors have also decoded and broken down more complex instructions into smaller internal "micro-operations" so that they can be executed in parallel, achieving high performance on a larger subset of instructions.