Skip to main content

Section 3 What Will I Learn in This Course?

C S 429H is the first course in the systems core sequence required of all computer science majors at UT. It describes computer systems from a programmer's perspective, at a fairly low level of abstraction. It is a prerequisite for C S 439H (Principles of Computer Systems: Honors, aka “OS”: the second systems core course) and C S 331H (Algorithms and Complexity: Honors, aka “Algo”: the second theory core course). It also serves as a foundation for upper-division courses on compilers, networks, operating systems, and computer architecture, where a deeper understanding of systems-level issues is required.

Subsection 3.1 Learning Goals

The following image summarizes the learning goals of the course.

Summary of learning goals

Subsection 3.2 Prerequisites

The following coursework with a grade of at least C- in each.

  • Discrete Math for Computer Science: C S 311 or 311H.
  • Data Structures: C S 314 or 314H.

Subsection 3.3 Textbooks

The following books are recommended but not required.

  • Computer Organization and Design: The Hardware/Software Interface, ARM® Edition, by David A. Patterson and John L. Hennessy. Morgan Kaufmann, 2017. Paperback ISBN: 978-0-12-801733-3. eBook ISBN: 978-0-12-801835-4.
  • Computer Systems, A Programmer's Perspective, Third Edition, by Randal E. Bryant and David O'Hallaron. Pearson, 2016. ISBN 10: 0-13-409266-X. ISBN 13: 978-0-13-409266-9.
  • The C Programming Language, Second Edition by Brian W. Kernighan and Dennis M. Ritchie. Prentice Hall Software Series, 1988. ISBN: 0-13-110326-8.

In addition, we will be referencing official manuals and original papers, soft copies of which will be provided.

Subsection 3.4 Topics

The course is organized into one language module and five additional content modules.

  • Programming in C in a Linux environment. The C programming language. The Linux command-line (shell) environment. Standard libraries. Programming tools: compilers, build systems, debuggers, version control tools. Understanding requirements and exploring design choices. Writing clean code. Students will write three reasonably complex programs in C in a Linux shell environment and integrate them into pre-existing modules such as test harnesses and simulators.
  • Representing and manipulating data. Binary encodings of, and basic operations on, basic data types: integers, floating-point numbers, and characters. Unicode and UTF-8. Derived data types: arrays, structures, unions, functions, pointers. Data alignment.
  • Machine-level representation of programs. Machine-level encoding and execution of programs written in high-level programming languages. The Armv8 A64 instruction set architecture (ISA). Data access instructions, arithmetic and logical operations, non-sequential control transfer, procedure call/return. Stack and heap disciplines for memory management. Code generation for C constructs. Techniques for explicit memory management.
  • Processor architecture and implementation. Basics of logic design. Sequential and pipelined implementations of a representative subset of the A64 ISA. Dependences and hazards. Forwarding, stalling, squashing. Pipeline control. Branch prediction. Pipeline performance equation.
  • Storage system architecture and performance. Volatile and non-volatile storage technologies. Locality of reference. Memory hierarchy. Structure and behavior of caches. Memory performance equation. Secondary storage and I/O. MMIO and DMA.
  • Linking. ELF files: object modules, executables, and shared objects. Techniques for static linking: symbol resolution, relocation, and patching. Techniques for dynamic linking: PIC, shared segments, GOT, PLT, lazy binding. Run-time programmatic linking of libraries.

This is a programming-heavy course, with an emphasis on low-level systems programming. The primary programming language for this course is C. We will also use A64 assembly language extensively throughout the course.