Skip to content

riscvbasics.md

Latest commit

 

History

History
99 lines (73 loc) · 6.64 KB

riscvbasics.md

File metadata and controls

99 lines (73 loc) · 6.64 KB

Notes on the Course Introduction:

  1. Section Overview:

    • This section is an introduction to how computers communicate using Instruction Set Architecture (ISA), which is the language computers understand.

  2. Key Concepts:

    • C Program to Hardware Execution:
      • A C program is first compiled into an assembly language program.
      • The assembly language is then converted into machine language (binary code of 1s and 0s), which is interpreted by the hardware (CPU).
      • The machine language is executed in the chip embedded in your device, such as a laptop, resulting in the required output.

  3. Program Flow:

    • C Program → Assembly Language → Machine Code (Binary) → Execution on Chip → Output.
    • This process converts high-level instructions into low-level instructions that are understood by the computer hardware.

  4. Role of Hardware Description Language (HDL):

    • HDL (Hardware Description Language) is crucial for defining and implementing tasks at the hardware level.
    • HDL helps translate architectural designs into logic gates and RTL (Register Transfer Level).
    • For instance, tasks like swapping numbers would be implemented using specific HDL actions, which the RTL processes to create the necessary output.

  5. Real-World Implementation:

    • The architecture of the chip is designed with HDL and transformed into a layout.
    • The user's program interacts with this architecture, and the chip executes the program, resulting in the output.

System Software, ISA, and Application Interaction:

  1. Application and System Software Overview:

    • Application software refers to apps used in daily life, such as on laptops. These applications interact with system software to function properly.
    • System software includes major components like the Operating System (OS), Compiler, and Assembler.
    • The system software manages the flow of operations between the application and the hardware.

  2. Role of the Operating System:

    • The OS handles tasks such as memory management and other core functions.
    • A critical job of the OS is to convert application code into machine-understandable language, through processes like compilation and assembly.

  3. Compiler and Instruction Set Architecture (ISA):

    • The compiler converts high-level programming languages (like C) into instructions specific to the hardware, which are governed by the Instruction Set Architecture (ISA).
    • The syntax of the instructions generated by the compiler depends on the hardware's architecture (e.g., RISC-V vs. x86).

  4. Assembler and Machine Language:

    • The assembler takes the instructions from the compiler and converts them into binary machine language (1s and 0s), which is the language that the hardware understands.
    • Binary machine code corresponds to electronic signals (logic 0 and 1), which interact with hardware components like flip-flops and logic gates.

  5. Example of Stopwatch App:

    • A simple C function for a stopwatch is compiled into ISA instructions, which are then assembled into binary numbers.
    • The binary instructions interact with the chip in the hardware, executing the functionality of the stopwatch.

  6. ISA as an Interface:

    • Instruction Set Architecture (ISA) is the interface between the software (C program) and the hardware.
    • ISA abstracts the complexity of the hardware and provides a set of instructions that are executed by the machine.

  7. High-Level Design to Physical Design:

    • The ISA is described using a Hardware Description Language (HDL).
    • The HDL specifies the architecture and is synthesized into actual hardware components like flip-flops.
    • This process moves from high-level design (ISA and HDL) to the physical implementation (chip design).

  8. Three Stages of Implementation:

    • The process of converting an application to hardware execution involves three stages:
      1. ISA and Architecture: Describing what the hardware needs to do.
      2. HDL Implementation: Writing the instructions in a hardware-specific language.
      3. Physical Design: Converting HDL to a physical form like flip-flops and gates in the hardware.

Course content

  1. Basic Operations:

    • The course begins with basic arithmetic operations like addition, multiplication, and division, which are foundational for building apps like a scientific calculator.
    • These operations are processed by the compiler, generating instructions that the hardware can execute.

  2. Instruction Sets:

    • Different instruction sets are implemented based on the hardware architecture. For example:
      • ARM-based systems may use ARM 64-bit instructions.
      • RISC systems follow the corresponding instruction sets for their architecture.
    • The ARM 64 instructions operate on 64-bit data, with specific instructions for digital numbers called "ARM 64 integer instructions."

  3. Instruction Extensions:

    • Beyond basic instructions, advanced operations like multiplication and division are categorized under instruction extensions.
    • These extensions are called ARM 64 MCP (Multiplication and Control Program) instructions, which add functionality to the base set.

  4. Floating-Point Instructions:

    • Instructions handling floating-point numbers are implemented through "Floating Point Extensions," such as single and double precision.
    • Instructions like DFAW and F indicate floating-point operations and extend the ARM 64 instruction set with these capabilities.

  5. Application Binary Interface (ABI):

    • The ABI defines how application programs interact with the hardware using a standard interface.
    • It provides a uniform way for applications to access system resources and functions.

  6. Memory Allocation and Stack:

    • The course also explores memory allocation concepts, particularly how data is managed between the memory and the stack.
    • Understanding memory allocation and stack management is crucial for effective instruction handling and execution.

  7. Signed vs. Unsigned Data:

    • Instructions can work with both signed and unsigned data, and the course will focus on understanding how signed and unsigned integers are represented and processed in the instruction set.

  8. Compiler to Machine Language Flow:

    • The basic flow of data from source code to machine execution is covered:
      • Source Code (e.g., C program) → Compiler → Instruction Set (architecture-specific) → Assembler → Machine Code (binary).