Goals and Syllabus

Course Description

From the course catalogue:

CSE 351: The Hardware/Software Interface (4) - Examines key computational abstraction levels below modern high-level languages; number representation, assembly language, introduction to C, memory management, the operating-system process model, high-level machine architecture including the memory hierarchy, and how high-level languages are implemented. Prerequisite: CSE 143.

Course Goals

This course should develop students’ sense of “what really happens” when software runs — and that this question can be answered at several levels of abstraction, including the hardware architecture level, the assembly level, the C programming level and the Java programming level. The core around which the course is built is C, assembly, and low-level data representation, but this is connected to higher levels (roughly how basic Java could be implemented), lower levels (the general structure of a processor), and the role of the operating system (but not how the operating system is implemented).

For (computer science) students wanting to specialize at higher levels of abstraction, this could in the extreme be the only course they take that considers the “C level” and below. However, most will take a subset of Systems Programming, Hardware Design and Implementation, Operating Systems, Compilers, etc.

For students interested in hardware, embedded systems, computer engineering, computer architecture, etc., this course is the introductory course after which other courses will delve both deeper (into specific topics) and lower (into hardware implementation, circuit design, etc.).

Course Syllabus

Approximate Topic List

Note that even more important than the topics at various levels of abstraction is the connection between them: students should get an informal sense of how Java could be translated to C, C to assembly, and assembly to binary.

Weeks are approximate; they are particularly useful for identifying topics that are essential for “connecting the pieces” yet which do not command a large portion of the class (e.g., Java-to-C). The order of presentation depends on instructor preference. There are arguments for “top down” (they already know Java), for “bottom up” (understand what’s going on below), or starting with C (useful for homeworks).

• Number representation: Two’s complement, signed vs. unsigned, floating point (1 week)
• Assembly (2 weeks)
  • Memory vs. registers
  • Instruction format
  • Control structures in assembly (loops, procedure calls)
• C (2 weeks)
  • Pointers, arrays, strings
  • Memory management, malloc/free, stack vs. heap
  • structs
• Compilation, linking, libraries (code across multiple files) (less than 1 week)
• The process model (what the operating system provides, not how it provides it) (1 week)
  • Virtualization and isolation (including virtual memory)
  • Components of a process state and notion of a context switch
  • System calls for accessing shared resources and communication channels
  • Asynchronous signals
• High-level machine architecture (1 week)
  • Register file
  • Instruction cycle
  • Caching and the memory hierarchy
• The Java-to-C connection (1 week)
  • Representing an object as pointer to struct with pointer to method-table; performing a method call
  • Constructors as malloc-then-initialize
  • Garbage collection via reachability from the stack
  • Java array-bounds-checking via array-size fields
• Parallelism/multicore/pthreads (1 week)

Approximate Non-Topic List

These are topics we feel are “close” to the course, but which there is likely not time for. If our time estimates are wrong or some topics above are deemed unimportant, these topics will be covered:

• Instruction cycle details (fetch, decode, ...)
• Pipelining

Background/Correspondence to Old Curriculum

The material on assembly, machine language, and CPU organization was previously taught in CSE 378. The material on number representation was taught in CSE 370. This course will be many students’ first exposure to C, where CSE 303 once held that distinction. Competent C programming is covered in a separate course: Systems Programming. The connection up to higher-level languages like Java is often lacking in our current curriculum. In the old curriculum, the role of an operating system was briefly touched on in CSE 378, but was otherwise seen only in CSE 451.