💾Intro to Computer Architecture Unit 3 – Instruction Set Architecture Fundamentals

What's ISA and Why Should I Care?

• ISA stands for Instruction Set Architecture, the interface between hardware and software in a computer system
• Defines the set of instructions a processor can execute, along with data types, registers, memory architecture, and more
• Acts as a contract between software developers and hardware designers, allowing them to work independently
• Enables code portability across different processors implementing the same ISA
• Influences processor design, including pipeline structure, control logic, and memory hierarchy
• Plays a crucial role in determining system performance, power efficiency, and cost
• Understanding ISA is essential for low-level programming, compiler design, and computer architecture research

The Building Blocks: Basic Components of ISA

• Instructions: fundamental operations that the processor can execute (arithmetic, logic, data transfer, control flow)
• Registers: fast, processor-accessible storage locations for operands and temporary results
  • General-purpose registers: used for arithmetic, logic, and data movement
  • Special-purpose registers: program counter, status flags, stack pointer
• Memory: larger, slower storage for instructions and data
  • Byte-addressable: each memory location has a unique address
  • Big-endian or little-endian: determines the order of storing multi-byte data
• Data types: supported by the ISA (integers, floating-point numbers, vectors)
• Addressing modes: methods for specifying the location of operands (immediate, register, memory)
• Control flow instructions: manage the execution order of instructions (branches, jumps, calls)
• Privileged instructions: reserved for the operating system (system calls, interrupt handling)

Types of Instructions: The ISA Toolkit

• Arithmetic instructions: perform mathematical operations (addition, subtraction, multiplication, division)
• Logic instructions: perform bitwise operations (AND, OR, XOR, NOT)
• Data transfer instructions: move data between registers and memory (load, store, move)
• Control flow instructions: alter the execution sequence (branch, jump, call, return)
  • Conditional branches: change execution based on a condition (if-else, loops)
  • Unconditional jumps: change execution unconditionally (goto)
• System instructions: interact with the operating system (system calls, privileged operations)
• Floating-point instructions: perform operations on floating-point numbers (single-precision, double-precision)
• Vector instructions: operate on multiple data elements simultaneously (SIMD - Single Instruction, Multiple Data)
• Specialized instructions: support specific application domains (cryptography, multimedia, machine learning)

Addressing Modes: Finding Your Data

• Immediate addressing: operand is a constant value embedded in the instruction
• Register addressing: operand is stored in a register, specified by the instruction
• Direct memory addressing: instruction contains the memory address of the operand
• Indirect memory addressing: instruction contains a register holding the memory address of the operand
  • Register indirect: address is in a general-purpose register
  • Displacement: address is formed by adding a constant to a register's value (base + offset)
• Indexed addressing: address is formed by adding the values of two registers (base + index)
• Stack addressing: operand is located on the stack, referenced by the stack pointer
• PC-relative addressing: address is formed by adding a constant to the program counter (used for position-independent code)

Instruction Formats: How Commands Are Packaged

• Instruction format: the layout of an instruction in memory, including opcode and operand fields
• Fixed-length instruction format: all instructions have the same size (RISC architectures)
  • Simplifies instruction decoding and pipeline design
  • May waste memory space for instructions with fewer operands
• Variable-length instruction format: instructions can have different sizes (CISC architectures)
  • Allows for more compact code and a larger number of instructions
  • Complicates instruction decoding and pipeline design
• Opcode field: specifies the operation to be performed
• Operand fields: specify the locations of input and output data (registers, memory addresses, immediate values)
• Instruction size: measured in bytes, determines the maximum number of instructions and addressable memory

RISC vs. CISC: The Great Debate

• RISC (Reduced Instruction Set Computing): design philosophy emphasizing simple, fixed-length instructions
  • Fewer instructions, each executing in a single cycle
  • More general-purpose registers to reduce memory accesses
  • Simplified instruction decoding and pipeline design
  • Examples: ARM, MIPS, RISC-V
• CISC (Complex Instruction Set Computing): design philosophy emphasizing complex, variable-length instructions
  • More instructions, each executing in multiple cycles
  • Fewer general-purpose registers, more emphasis on memory accesses
  • Complex instruction decoding and pipeline design
  • Examples: x86, 68000
• Trade-offs: RISC aims for higher performance through simpler hardware, while CISC aims for code density and backward compatibility
• Modern architectures: blur the lines between RISC and CISC by using techniques like microcode and out-of-order execution

Real-World Examples: Popular ISAs in Action

• x86: dominant ISA for personal computers and servers, known for its backward compatibility and CISC design
  • Extensions: MMX, SSE, AVX for vector processing
  • 64-bit version: x86-64 or AMD64
• ARM: widely used in mobile devices and embedded systems, known for its low power consumption and RISC design
  • Versions: ARMv6, ARMv7, ARMv8 (64-bit)
  • Licensing model: allows for custom extensions and implementations
• MIPS: used in embedded systems and game consoles, known for its simplicity and RISC design
  • Versions: MIPS I, MIPS II, MIPS III, MIPS IV, MIPS32, MIPS64
  • Open-source version: MIPS Open
• RISC-V: an open-source ISA designed for flexibility and extensibility, gaining popularity in academia and industry
  • Base integer ISA: RV32I, RV64I
  • Extensions: M (multiply/divide), A (atomic), F (single-precision floating-point), D (double-precision floating-point)
  • Open-source implementations: Rocket, BOOM, Shakti

Putting It All Together: Designing a Simple ISA

• Define the goals and constraints: performance, power, cost, application domain
• Choose the basic building blocks: instruction types, registers, memory architecture, data types
• Determine the addressing modes: immediate, register, memory (direct, indirect)
• Design the instruction formats: fixed-length or variable-length, field sizes
• Select the control flow instructions: branches (conditional, unconditional), jumps, calls
• Consider specialized instructions: floating-point, vector, domain-specific
• Evaluate trade-offs: RISC vs. CISC, code density vs. performance
• Simulate and refine: use ISA simulators to test and optimize the design
• Document the ISA: create a comprehensive reference manual for software developers and hardware designers