Maurice's Notes
Blog
Low Level Computing
Low Level Computing
  • Operating Systems
    • General Operating Systems
      • OS Structure
      • Main Memory
        • Basic Hardware
        • Address Binding
        • Memory Address Register
      • Booting
        • MBR (Master Boot Record)
        • Global Descriptor Table
      • Direct Memory Access (DMA)
        • DMA
      • Processes
        • Basics
        • Process Scheduling
    • Linux Operating System
      • Linker Scripts
      • Position Independent Code/Executable
      • Relocation
      • Understanding PLT and GOT
    • Windows Operating System
      • Page 1
    • Real-Time Embedded Systems
      • Real-Time Scheduling
        • Cyclic Executive
  • Computer Architecture
    • Architecture Fundamentals
      • Introduction
      • Cache Basics
      • Cache Memory
      • A Few CPU Formulas
    • RISC Architectures
      • ARM
        • ARM Design Philosophy
        • RISC Review
        • Exceptions, Interrupts, & Vector Table
        • ARM Pipelines
        • ARM Registers
        • ARM Branch Instructions
        • ARM CSPR (Instructions)
        • ARM Data Processing Instructions
        • Load/Store Instructions
        • Profiling Cycle Counter
        • Compiler Optimizations
      • RISCV
    • CISC Architectures
    • Cache Coherency
      • Basic Introduction
      • Memory Sequential Consistency
  • Exploits
    • Walkthrough: Return-to-Libc
    • Access Physical Memory
  • Compilers & Runtime Systems
    • Introduction
      • Programming Language Basics
      • Static Scope
    • Syntax Translation
      • Syntax Defined
      • Parsing
    • Algorithms
      • FIRST FOLLOW (Top-Down) Parsing
      • Building a Recursive Descent Parser
      • Construction: Regular Expression -> NFA
Powered by GitBook
On this page

Was this helpful?

  1. Computer Architecture
  2. RISC Architectures
  3. ARM

RISC Review

RISC Design Philosophy

  • RISC's design philosophy is aimed at delivering simple but powerful instructions that execute within a single cycle @high clock speed

    • Reduce complexity of instructions, places greater demand on the compiler (software) rather than hardware

      • software has more flexibility

  • Instructions

    • Fixed-length instructions, allowing future instructions to be executed before decoding current instructions

      • CISC instructions are variable-length

    • RISC has a reduced number of instruction classes, each class proivded simple instructions that exec in 1 cycle

      • Complex instructions are broken up in to simple ones

        • i.e. divide

  • Pipelines

    • Uses a pipline for parallel execution. Instructions can be executed in the pipeline

      • CISC requires the use of a miniprogram called microcode to execute instructions

    • Registers

      • RISC uses large general-purpose register set

        • each register can hold an address or data

        • registers are fast local stores

  • Load-Store (register-to-register) Arch

    • operations are only performed on data in registers

    • Load and store instructions are used to move data into registers

    • Separate Load and store instructions are used to move data from register bank to external mem

      • separating memory access from data processing provides an advantage

        • data items are held in the register bank and can be used multiple times. No need to for multiple memory accesses

        • Memory access can be costly

          • Remember hierarchy and cycle latency, hit miss, invalidation, coherency, etc.

RISC -> greater complexity on the compiler, less on the hardware CISC -> greater complexity on the hardware, less on the compiler

PreviousARM Design PhilosophyNextExceptions, Interrupts, & Vector Table

Was this helpful?