15.1 Processors, Parallel Processing and Virtual Machines

---

Main Content

---

1.1 CISC — Complex Instruction Set Computer

The CISC design philosophy says: give the processor a large set of powerful, complex instructions so that programmers can write programs using as few lines of code as possible.

In a CISC processor, a single instruction can do many things at once. For example, a single ADD x, y instruction might automatically fetch the value from memory location x, fetch the value from memory location y, add them together, and store the result — all in one instruction. The processor has to break this complex instruction down into several smaller sub-instructions internally before it can carry it out.

Because of this, CISC instructions often take multiple clock cycles (a clock cycle is one "tick" of the processor's internal timer). The instructions can also be variable in length — some are short, some are long, depending on how complex they are.

Key features of CISC:

• Large instruction set with many different instructions
• Instructions are complex and can perform multiple operations
• Instructions take multiple clock cycles to complete
• Variable-length instructions (different instructions use different amounts of memory)
• Many different addressing modes (ways of finding where data is stored)
• Fewer general-purpose registers (temporary storage spaces inside the processor)
• Uses a microprogrammed control unit — the processor uses a small program stored internally to figure out how to execute each complex instruction
• Harder to use pipelining (explained later)
• Emphasis on hardware doing the hard work

CISC processors are commonly found in desktop computers and laptops.

1.2 RISC — Reduced Instruction Set Computer

The RISC design philosophy takes the opposite approach: give the processor a small set of simple, fast instructions. Each instruction does only one small thing, but it does it very quickly — in exactly one clock cycle.

Because instructions are simpler, the processor does not need to break them down. This makes execution faster and more predictable. If a RISC processor needs to add two numbers, it uses multiple separate instructions:

LOAD A, x     → Load the value from memory location x into register A
LOAD B, y     → Load the value from memory location y into register B
ADD A, B      → Add the values in A and B
STORE z       → Store the result in memory location z

Each of these four instructions takes exactly one clock cycle. Although you need more instructions to do the same task compared to CISC, each one runs so quickly that overall performance is better.

Key features of RISC:

• Smaller instruction set with fewer, simpler instructions
• Each instruction takes exactly one clock cycle
• Fixed-length instructions (every instruction uses the same amount of memory, making them easier to process)
• Fewer addressing modes
• Many general-purpose registers (the processor stores more data inside itself, reducing the need to fetch things from memory)
• Uses a hardwired control unit — the processor uses fixed electronic circuits to control instruction execution, which is faster than microprogramming
• Much easier to use pipelining
• Emphasis on software (compilers) doing the hard work
• Requires fewer transistors (the tiny electronic switches that make up a chip)

RISC processors are commonly found in smartphones and tablets (for example, ARM processors use RISC principles).

1.3 RISC vs CISC — Comparison Table