CSE351 Goals & Syllabus

Catalog Data

CSE351 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.

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 O/S 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 & 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 would depend 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: Twos complement, signed vs. unsigned, floating point (1 week)
• Assembly (2 weeks)
  • Memory vs. registers
  • Instruction format
  • Control structures in assembly (loops, procedure call)
• C (2 weeks)
  • Pointers, arrays, strings
  • Memory management, malloc/free, stack vs. heap
  • structs
• Compilation, linking, libraries (code across multiple files) (< 1 week)
• The process model (what the O/S provides, not how it provides it) (1 week)
  • Virtualization and isolation (including virtual memory)
  • Components of a process state / notion of a context switch
  • System calls for accessing shared resources / communication channels
  • Asynchronous signals
• High-level machine architecture (1 week)
• Register file
• Instruction cycle
• Caching / 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, they would be fine additions.

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

Background / Correspondence to Old Curriculum

The material on assembly, machine language, and CPU organization is currently in 378. The material on number representation is currently in 370. This course would be many students’ first exposure to C, where 303 currently has that distinction. However, 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. The role of an operating system is perhaps touched on in 378, but is otherwise currently seen only in 451.