Systems Architecture

1. Intro: Laws of Computing

2. Digital Logic

   • Boolean Algebra
     • Representation of data (algebra, truth tables)
     • Logic function synthesis
     • Minimisation using Karnaugh maps
   • Logic gates
     • Basic (AND, OR, NOT, XOR)
     • Universal (NAND, NOR)
   • Combinatorial circuits (output depends only on current input)
     • Decoders
     • Multiplexers
   • Sequential circuits (output also depends on previous inputs - system state)
     • Flip-flops
       • SR Latch
       • Gated SR Latch
       • Gated D latch
       • T flip-flop
       • Master-slave flip-flop
     • Registers, shift registers
     • Counters

3. Digital Data

   • Positional numbering system
   • Conversion between bases
   • Numeric representations of data types
     • Integers arithmetic
       • Addition & subtraction with signed integers
       • Addition/subtraction logic unit
       • Multiplication of signed integers
     • Floating point arithmetic
       • Adding/subtracting floating point values.
       • Multiplying/dividing floating point values.

4. ISAs

   1. Memory locations & addresses

   2. Memory operations & instructions

   3. Addressing modes

   4. Subroutines & the Stack

5. Basic processing unit

   1. Instruction execution

   2. Hardware components

   3. Data path & instructions

6. Pipelining

   1. The Basic Concept

   2. Hazards

      1. Data dependencies

      2. Memory delays

      3. Branch delays

   3. Superscalar operation

7. IO

   1. Buses

   2. Accessing I/O devices

   3. Basic approaches:

      • Program-controlled
      • Interrupts

8. Memory

   1. Basic concepts

   2. Internal organisation of memory chips

   3. Memory types

   4. Direct Memory Access (DMA)

   5. Memory Hierarchy

   6. Cache memory

   7. Mapping functions

   8. Performance considerations

9. Large-scale systems (parallel processing & performance)

   1. Multithreading

   2. Vector (SIMD) processing & GPUs

   3. Shared-memory multiprocessors

   4. Cache coherence

   5. Parallel programming