Computer Architecture and Assembly Language Quiz

Course Objectives

• Learn how a typical modern computer is structured, i.e., its architecture.
• Focus on CPU architecture.
• Learn computer operation during instruction execution, i.e., the fetch-execute cycle.
• Understand internal data and instruction representation in computers.
• Learn about signed and unsigned integers, characters, strings, and floating-point numbers.
• Learn about machine instructions and assembly language programming for embedded systems, operating systems (OS) kernels, device drivers, and code generators in compilers (though less common today).
• Understand computer architecture and operating systems.
• Learn how to write efficient high-level programs and the connection between high-level and machine-level languages (e.g., C, Assembly).
• Learn to combine assembly and high-level languages.

High-Level Architecture

• A basic computer system comprises a CPU, system clock, and primary memory (RAM).
• Secondary memory (e.g., HDD/SSD) stores data.
• Input/output (I/O) peripherals (e.g., keyboard, monitor) facilitate interaction.
• A bus facilitates communication between components.

CPU

• The CPU is a computer's "brain," executing instructions.
• It manages data transfer through the bus.
• It's usually a microprocessor chip with three main sections: the control unit (CU), arithmetic logic unit (ALU), and registers.
• The CU directs instruction execution.
• The ALU performs arithmetic and logic operations.
• Registers store data during processing.
• Instruction cycles include loading instructions from memory, decoding, acting on appropriate data, storing results.

System Clock

• The system clock is a square wave that synchronizes the CPU and devices.
• It determines a specific speed, and devices time operations based on its frequency (e.g., GHz).

Primary Memory (RAM)

• RAM is used for storing program instructions and data.
• It is accessible by address.
• Data is lost when power is off.
• Usually faster or easier to access data than secondary memory (harddrive, etc.).

Secondary Memory (HDDs/SSDs)

• Used for longer-term storage of computer files (programs and data).
• Data persists even when the power is off.
• Typically slower than primary memory (RAM) but with larger storage capacity.

Buses

• A bus connects components for transferring data.
• Usually divided into address, data, and control buses for addressing locations, sending data, and controlling communications.

Peripheral I/O Devices

• Input devices allow interaction (e.g., keyboard, mouse).
• Output devices present information (e.g., monitor, printer).

Basic CPU Architectures

• SPARC is an example of a load/store machine architecture.
• Typical sequence: Load registers from memory, execute instructions using two registers and store in another, store result in memory.
• Includes RISC and CISC architectures.

RISC (Reduced Instruction Set Computer)

• Uses simple instructions that execute in a single cycle.
• Faster clock rate.
• Larger program size.

CISC (Complex Instruction Set Computer)

• Uses more complex instructions that take multiple cycles.
• Slower clock rate.
• Smaller program size.

Instruction Cycle

• The fetch-decode-execute cycle describes how CPU executes each instruction.

Assembly Language Programs

• A series of statements equivalent to machine instructions.
• An example: add x20, x20, x21.
• Each statement includes an opcode and operands.
• Instructions are stored in sequential memory locations.
• Labels are optional prefixes to statements, representing memory addresses.

Macro Preprocessors

• Used for code reusability, creating macros to replace repetitive blocks of code.
• This makes code more readable and maintainable.

ARM CPU Architectures (Cont.)

• Uses A64 instruction set and 64-bit registers for more common tasks given that it's architecture uses more bits.

ARM Registers

• Usually 64 bit wide, although some are only 32 bits.
• Registers have specific roles (e.g., x0-x7 are used to pass arguments).
• Several special-purpose registers exist (e.g., stack pointer).
• Some registers are "callee-saved" (x19-28). These need to be preserved before call to a function, and restored.

ARM Assembly language

• Instructions for ARM processors.
• Opcodes, operands, and comments are often organized into columns in assembly language programs, along with labels.

Branches and Condition Codes

• A branch instruction changes the flow of instruction execution.
• Instruction result conditions are stored as flags, to make decisions about which instructions to execute.
• Eg, jump if result is equal, else continue.

Loops and Conditional Statements

• Structured code blocks are written using conditional branches using logical conditions to change the code flow..

Basic Arithmetic Instructions

• Addition, Subtraction, Multiplication, Division using register and immediate operands.

Bitwise Operators

• AND, OR, XOR, NOT, shifts
• Manipulate individual bits within registers using operations like NOT or shift left.

Data Structures

• Arrays
  • One-dimensional: elements stored in consecutive addresses
  • Multidimensional: elements stored in memory using a rule-based method
• Structures: collections of fields of different types located contiguously in memory

External Arrays of Pointers

• Pointers to storage structures.
• Useful for storing data with pointers that are easier to manipulate across different locations.

Command Line Arguments

• Arguments passed into a program from the command line.

Separate Compilation and Linking

• Code modules (e.g., .c, .s files) can be separately compiled into object files (e.g., .o files).
• These are linked using ld (or gcc) to create an executable.

File I/O

• Functions for interacting with external devices or files.
• Functions to open, read, write, and close the files.
• File descriptors: indexes referring to the current files.

Floating-Point Numbers

• A floating point representation provides a means of storing fractional amounts of numbers.
• There exist different types of operations, conversion, comparison or other manipulations for floating point-numbers.

Floating-Point Instructions

• Add, subtract, multiply, divide, absolute -use s registers for single precision, d registers for double precision.
• Compare - set condition flags, followed by conditional branches.

Input and Output

• System calls are used for interacting with external devices or files.
• Using system calls open, read, write, to access or create files.
• Using system call close to close files or descriptors.

Subroutines and Stacks

• A subroutine call has special conditions to take into account
  • Callee-saved registers, 8 special registers, these need to be pushed on top of the stack before and popped off after a subroutine call operation.

Pointers

• Pointers take in addresses, not values.
• These address locations for storing data may change or be overwritten across different functions or subroutine tasks.