Complex Instruction Set Computer (CISC)

What is CISC (Complex Instruction Set Computer)?

Complex Instruction Set Computer, or CISC refers to the standard of computers designed to support up to two hundred instructions. Basically, it refers to the classification of a specific design of microprocessor.

Technically, the CISC structure consists of a large number of personal computer instructions including very easy, technical, and intricate ones designed on ‘more than one instruction per cycle execution’ principle.

It can carry out several tasks by using very little code.

Understanding (CISC) Complex Instruction Set Computer

What is CISC (Complex Instruction Set Computer)

In simple words, CISC refers to the approach which completes an entire operation in just a few lines using the assembly language code.

CISC uses instruction formats of variable length. For example, instructions that need register operands to take two bytes only.

However, those specific instructions that need two memory addresses may take up to 5 bytes for a complete code.

Therefore, varying lengths of encoding require a variable number of clock cycles.

There are a few added addressing modes in CISC such as:

With its useful design, CISC offers some specific benefits which include:

However, the CISC architecture does not allow easy instruction pipelining and the complexity of the instructions makes them a bit less efficient due to the large number of clock cycles required to carry out an instruction.

What is the Architecture of CISC?

The CISC architecture helps in using only one machine instruction for one statement. The architecture allows complex decoding of the instructions without needing several general purpose registers for that.

This is typically facilitated by the CISC processor which can manipulate the operands in the memory directly.

The architecture also allows the processor of the computer to perform a specific task using as few codes of the assembly language as possible.

Apart from that, the CISC architecture does not need loading data to the register from the memory in order to function.

Read Also:  What is Hertz (Hz)? (Explained)

This is because it can access and use the data directly in the memory for the specific operations.

The architectural attributes of CISC result in a more complex instruction set with micro commands.

This increases the execution times of the instructions but the accumulated apps occupy less memory space.

However, the architecture supports applications written in assembly language and enables faster operations.

What Are the CISC Architecture Characteristics?

Some of the most significant features or characteristics of the CISC architecture include larger and complex instructions that need more complex decoding. Usually, these instructions take more than one cycle to be executed.

In addition to that, there are also a few specific features of CISC that facilitates its functioning such as:

All these features make CISC quite useful for low-end applications.

How Do CISC Processors Work?

The CISC processors work on a single instruction that does everything from loading the values from the memory, evaluating them and storing the results of the operation back in the memory.

This minimizes the number of instructions required for each program but it increases the number of CPI or Cycles Per Instruction.

There is an entire set of special-function circuits that handles multiple instructions of variable sizes. Ideally, the working process of these processors is as follows:

Ideally, the working process of the CISC processors emphasizes more on the efficient use of Random Access Memory and the hardware rather than software, which makes them different from the RISC processors.

What is an Example of CISC?

Some of the best examples of CISC include simple microcontrollers and complex mainframe computers where the load and store operations of the memory are not distinct from the arithmetic instructions.

There are also a few specific processors that are built on the CISC architecture and are used in quite a few different computers such as VAX and System/360 computers of IBM.

There are also a few AMD and several generations of Intel x86 processors that are built on this architecture. Some of the most prominent examples of processors based on CISC architecture are:

A few other specific microprocessors that are built on the CISC Instruction Set Architecture include:

As for the operations, an example of CISC would be an ADD instruction that uses index addressing for specifying an operand in the memory and for direct addressing of another operand.

Read Also:  What is Coffee Lake Processor? (Explained)

Ideally, the instruction would use a different location altogether to store the result.

This means that the ADD instruction would use as many as three different memory references to get completed.

Does CISC Use Pipelining?

Yes, technically, CISC uses pipelining but it is quite complex and is done entirely at a different level.

First, the complex instructions need to be broken down into simpler and smaller parts before these are pipelined.

However, in reality, these instructions are actually translated into a series of internal RISC instructions and these are then pipelined.

Ideally, in the CISC architecture, the instructions contained are a mixture of simpler ones that take shorter time and complicated ones that take longer time to get executed.

Therefore, there is a high chance of hazards being created in the pipeline that may result in several issues and affect the smooth operation of the pipelining.

In fact, it is mainly due to the complexity of the CISC instruction that makes them harder, if not unsuitable, and less beneficial to pipelining as compared to RISC.

Also, the varied length of the CISC instructions as opposed to the RISC instructions makes it difficult to fetch them all in one single operation.

That is the main reason that the majority of the CISC processors available these days are typically pipelined in out-of-order superscalar designs.

Does CISC Have Fixed Length?

Technically, no, and ideally, the length of CISC instructions of x86 in particular may be anywhere between 1 and 15 bytes. Considering the override bytes and the multiple instruction prefixes especially, exactly how far the length of the instructions could go is really not known.

In the cases of redundant repetitions of a few specific types of prefixes, there can be no limit at all.

Ideally, to a large extent, CISC is considered to be a design philosophy rather than architecture and therefore there is nothing as such called the ‘length’ of the instructions.

Therefore, theoretically it can be said that the instruction length in CISC may be infinite.

This is due to the reason that the prefixes can be repetitive. And, this particular aspect makes things complicated for the instruction decoder.

However, in practice, the instruction length has been limited to 15 bytes by the x86-64 AMD processors.

If it exceeds this limit then there is an error signal displayed by the instruction decoder stating that it has given up.

On the other hand, Intel started to limit the instructions up to 10 bytes in and from their 80286 and 15 bytes in their later ISA versions.

Why Does Intel Still Use CISC?

The main reason for Intel to continue using CISC is to blur the boundary that separates it from RISC and make it both hardware and software compatible.

It also offers speed enhancement than RISC. And, it is certainly and entirely not related to backward compatibility.

Considering the caches, CISC is also much better to use than RISC. If the same size of cache is used in both these architectures then that in CISC will have a much more effect in the operation.

This is primarily due to two specific reasons such as:

These reasons are quite strong enough to stick with CISC. It is also sensible because moving to RISC now, when the boundaries between RISC and CISC are almost eliminated, will be a grave mistake.

Moreover, there are a few specific sets of tradeoffs represented by the RISC architecture.

Considering the present realities and usability, these tradeoffs may cause significant issues that will be far more difficult and costlier to fix.

However, industry experts think that Intel viewed it in a different way and backed their intent with two-fold reasons. These are:

Read Also:  SPARC (Scalable Processor Architecture) Explained

The CISC architecture allowed them to easily hard-code the logic instead of micro-coding for every instruction.

This further helped in encoding the instructions in a much simpler way possible which helped in reducing the chip area because it did not need to be dedicated for decoding instructions.

In fact, this was simply a waste of space that did not actually help in any way in getting the job done.

By sticking to the CISC architecture, Intel has been able to do away with all these issues to a large extent successfully.

What is the Need for CISC Architecture?

The most basic need for the CISC architecture is to use one machine instruction for multiple low-level operations and for every statement written in a high-level language and to perform different addressing modes or multi-step operations.

The architecture allows doing all these in several clock cycles.

In addition to that, the other specific needs for CISC are as follows:

Therefore, as said earlier, moving from CISC to RISC today will be a big mistake and there are several reasons for it, apart from the above.

So, there is nothing that will make things simpler which is why CISC is still needed today since there is a technical parity between RISC and CISC.

Where is CISC Architecture Used?

The microcontrollers and microprocessors that were first introduced used the CISC architecture. In addition to that, it is also used in low-end and real-time applications, such as home automation devices, security systems, and more.

When it comes to processors, CISC processors are used in:

It is also used in enterprise servers. This is because these CPUs can process more complex instructions such as loading two values from the memory and adding them as well as storing the results back in it, all in one instruction.

Is CISC Hardware or Software?

CISC typically is more focused on hardware design as opposed to RISC which is more of a software design. Since CISC is a hardware design, it is more difficult and needs a considerable investment.


A Complex Instruction Set Computer may be complex and difficult to improve but is quite useful in carrying out multiple operations by using one machine instruction.

Over the years, with advanced resources and development in technology, major roadblocks are removed to blur the boundary existing between CISC and RISC.