CPU Architectures: CISC and RISC Overview

Study Notes

CISC (Complex Instruction Set Computer)
- Features a large instruction set (~200-300 instructions) with specialized, complex instructions.
- Supports many addressing modes and employs variable-length instruction formats.
- Allows memory-to-memory instructions, exemplified by architectures like 68000 and 80x86.
RISC (Reduced Instruction Set Computer)
- Utilizes a smaller set of instructions (~50), focusing on basic operations.
- Fewer addressing modes and fixed-length instruction formats enhance simplicity.
- Only load/store instructions access memory; designed with a large number of registers.
- Employs hardwired control instead of micro-program control, with examples like MIPS, Alpha, and ARM.

CISC
- Offers high code density, requiring fewer instructions for algorithms.
- Advantages include lower costs due to microcode use, upward compatibility, memory efficiency, and a simpler compiler.
- Disadvantages involve increased complexity in instruction sets, variable execution times, and infrequent usage of many instructions (approx. 20% in typical programs).
RISC
- Prioritizes speed and simple hardware design, resulting in shorter design cycles and improved performance.
- Disadvantages include challenges in instruction scheduling, debugging difficulties, and reliance on fast memory systems.
- Many modern microprocessors are superscalar, optimizing instruction execution.

Each microprocessor family has its machine language instructions, which are low-level binary codes.
Assembly language translates these instructions into symbolic code, simplifying software development.
Machine Language: Binary codes, processor-dependent, requires less memory but is not user-friendly.
Assembly Language: Uses mnemonics, still processor-dependent but simpler than machine language.
High-Level Language: More user-friendly with English-like statements, independent of processor type but requires more memory.

Divided into three main sections:
- Data Section: Declares initialized data/constants; syntax: section.data.
- BSS Section: Declares variables; syntax: section.bss.
- Text Section: Contains actual code; begins with global _start to indicate execution start; syntax: section.text.

Comments begin with a semicolon (;) for clarity and documentation.
Assembly programs consist of:
- Executable Instructions: Directly tell the processor what to do, generating machine language instructions.
- Assembler Directives (Pseudo-Ops): Provide instructions for the assembler itself.
- Macros: Help automate repetitive tasks, defined with %macro and %endmacro.

Linker: Combines several object files into one, producing a link file with binary codes and an address map; generates relocatable programs.
Loader: Part of the operating system that loads executable files into memory; can be absolute (fixed loading) or relocating (dynamic offsets).

Locator: Assigns specific addresses for object code segments; can convert .EXE files to .BIN files for physical address storage.

Reentrant Procedures: Can be interrupted and called again without losing information, maintaining separate states.
Recursive Procedures: Call themselves, managing multiple active instances in the program stack.

Designed to reduce repetitive coding, minimize errors, and enhance readability.
Macros execute faster as they eliminate the need for CALL and RETURN instructions.