⭐ RISC vs. CISC Architectures

1. Introduction

Processors can be broadly classified into two instruction set philosophies:

• RISC (Reduced Instruction Set Computer)
• CISC (Complex Instruction Set Computer)

These represent two different approaches to designing CPU instruction sets and hardware complexity.

---

⭐ Definition: RISC

RISC (Reduced Instruction Set Computer) is a CPU architecture that uses a small, simple, and highly optimized set of instructions. Each instruction is designed to execute in one clock cycle (ideally).

Key idea:

Simplicity + speed = high performance

Examples:

• ARM
• MIPS
• RISC-V
• SPARC
• PowerPC

---

⭐ Definition: CISC

CISC (Complex Instruction Set Computer) is a CPU architecture that uses a large and complex instruction set. Many instructions can perform multiple operations in a single instruction.

Key idea:

Complexity + rich instructions = compact programs

Examples:

• x86 / Intel / AMD architectures
• VAX
• IBM System/360

---

⭐ Core Differences Between RISC and CISC

The table below summarizes the most important exam-ready differences:

Feature	RISC	CISC
Instruction Count	Few, simple instructions	Many, complex instructions
Instruction Length	Fixed-length	Variable-length
Execution Time	Usually 1 cycle per instruction	Multiple cycles per instruction
Addressing Modes	Few addressing modes	Many addressing modes
Operations	Simple operations	Complex operations (e.g., string move)
Registers	Large number of general-purpose registers	Less registers
Memory Access	Load/store architecture (only load & store access memory)	Many instructions access memory
Hardware Complexity	Simple hardware, more dependent on compiler	More complex hardware (microcode)
Pipeline Efficiency	Easy to pipeline due to fixed instruction size	Harder to pipeline because of variable size
Program Size	Larger programs (needs more instructions)	Smaller programs
Power Consumption	Lower	Higher
Examples	ARM, RISC-V, MIPS	x86, Intel 8086, VAX

---

⭐ Characteristics of RISC Architecture

1. Load/Store architecture

   • Only LOAD and STORE instructions access memory
   • All other operations occur in registers

2. Simple and fixed-format instructions

   • Easier to decode
   • Ideal for pipelining

3. Large register file

   • Reduces memory accesses
   • Speeds up execution

4. Simple addressing modes

   • Typically 3–5 modes only

5. Hardwired control unit

   • Faster execution
   • No microcoded instructions

---

⭐ Characteristics of CISC Architecture

1. Many complex instructions

   • Can execute multi-step operations from a single instruction Example: MUL [MEM], R1

2. Variable length instructions

   • Some 1 byte, some 15 bytes (like x86)
   • Harder to pipeline

3. Fewer registers

   • More operations directly on memory

4. Rich addressing modes

   • e.g., auto-increment, base+index+offset

5. Microprogrammed control unit

   • Instructions broken into micro-operations
   • Flexible but slower

---

⭐ Advantages and Disadvantages

✔ Advantages of RISC

• Faster execution (single-cycle instructions)
• Easier pipelining and parallelism
• Lower power consumption
• Simpler hardware → cheaper to produce
• Ideal for mobile and embedded systems (ARM processors)

✘ Disadvantages of RISC

• Larger program size
• More pressure on the compiler
• More registers needed

---

✔ Advantages of CISC

• Smaller programs (shorter code)
• High-level operations done by single instructions
• Legacy support (e.g., x86 supports decades of code)

✘ Disadvantages of CISC

• Slower due to microcoded instructions
• Hard to pipeline
• Higher power consumption
• Complex hardware → expensive

---

⭐ Examples to Understand the Difference

Example Task: A = B + C

RISC Approach

LOAD R1, B
LOAD R2, C
ADD R3, R1, R2
STORE A, R3

→ Simple instructions (each does one task)

---

CISC Approach

ADD A, B, C       ; May load B, add C to it, and store in A

→ A single complex instruction replaces multiple simpler ones

---

⭐ Modern Trend: RISC vs CISC Today

Modern architectures are a blend:

• x86 (CISC) internally converts instructions into RISC-like micro-operations
• ARM and RISC-V dominate mobile and embedded markets
• Simplicity and power efficiency favor RISC philosophy

---

⭐ Exam-Focused Summary

1. RISC → Simple instructions, fixed length, load/store, many registers, fast pipelining.
2. CISC → Complex instructions, variable length, many addressing modes, fewer registers.
3. RISC leads to higher performance and lower power, while CISC leads to smaller code size.
4. Examples: RISC → ARM, RISC-V; CISC → x86.

---