Topics:

• review of computer organization and representations
• x86 assembly: review of basic constructs and structures, interfacing C to assembly, macros, stack frame and calling convention
• simple data structures: queues, heaps, stacks, lists
• synchronization: primitives, memory semantics, mutual exclusion, semaphores, scheduling, and race conditions
• interrupts: controlling generation and handling, chaining, cleanup code, interactions with device functionality
• resource management: virtualization and protection, virtual memory and hardware support
• exceptions and signals: exceptions due to instructions, memory accesses, and floating-point operations; signal semantics and delivery
• device programming: basic abstractions, character and block devices
• file system abstractions: disk layout, access control lists and capabilities, log-structured and traditional filesystems as design problem
• I/O interface: file descriptors, buffering, control operations, memory mapping
• networking programming: socket abstractions, basics of low-level network protocols, relationship to kernel I/O abstractions

ECE 391 is required for Computer Engineering majors and is also one of the five Advanced Core electives for Electrical Engineering majors. The course is a prerequisite for a dozen advanced undergraduate courses in ECE and CS that serve as technical electives. The goal of the course is to develop the programming and problem solving skills required for further study in computer systems engineering. By the end of the course students should have a solid understanding of how a computer system works and what it does, and the skills necessary to analyze, design, test and debug effective computer software. The course is laboratory based and includes both individual and team projects.

Specific topics include assembly language programming, interrupts and exceptions, the connection between assembly language and high-level programming languages, resource management, virtualization of CPU and memory, and asynchronous and synchronous interactions. The course covers the programming interface provided by modern operating systems, including device, file system, process, memory management, thread and signal abstractions.

(The letters (a) through (n) refer to the ABET "Attributes of an Engineer" used during the 2007/2008 ABET review cycle).

A. In the first machine problem (after approximately 6 seventy-five minute lectures) the student should be able to:

1. Analyze and implement control constructs (conditionals, cases and

loops) in assembly language. (a)

2. Translate C control constructs and basic data structures (structs

and arrays) to assembly language. (a)

3. Reverse engineer an assembly lanuage program into a corresponding C

program. (a)

4. Use subroutines to structure programs. (c)

5. Understand the C calling convention and write assembly language

subroutines that can interface with C subroutines. (c)

6. Understand the memory layout of a program. (a)

7. Use a debugger to identify and repair code defects. (b,k)

8. Write an interrupt service routine to respond to external input

from the keyboard and real-time clock. (c)

B. By the first examination (after approximately 12 seventy-five minute lectures) the student should be able to:

9. Follow the code path of a system call. (a)

10. Write context switching code to virtualize the CPU between multiple

threads. (c)

11. Identify state shared between multiple threads. (b)

12. Understand how to implement a critical section on a uniprocessor

by disabling and reenabling interrupts. (c)

13. Understand how to use mutexes and condition variables to solve

basic synchronization problems. (e)

C. By the second machine problem (after approximately 14 lectures) the student should be able to:

14. Read system and device interface documentation. (i)

15. Write code to interface with a graphical output device. (c)

16. Write code to interface with an input device connected to the

serial port. (c)

17. Test and debug a multi-thousand line program. (e,k)

D. By the third machine problem (after approximately 20 lectures) the student should be able to:

18. Understand the rationale for virtual memory and demand paging. (a)

19. Understand memory management algorithms. (a)

E. By the second exam (after approximately 22 lectures) the student should be able to:

20. Calculate the worst-case completion times for tasks in real-time

systems under preemptive and nonpreemptive scheduling policies. (a)

21. Calculate the average completion times for tasks under

nonpreemptive batch scheduling policies like first-in-first-out

and shortest-job-first. (a)

22. Understand the advantage of identifying and prioritizing the jobs

that initiate the most blocking I/O operations. (a)

F. By the end of the final project (after approximately 28 lectures the student should be able to:

23. Develop a simple operating system that includes support for

non-preemptive context switching, segmented memory protection, a

simple file system, and drivers for keyboard input, text output

and clock. (c,k)

24. Find information on techniques needed for the project but not

covered in class. (i)

25. Design and develop a large, complex program through modular

design, using appropriate data structures. (c)

26. Participate effectively as a member of a team. (d)

G. By the final exam (after approximately 30 lectures) the student should be able to:

27. Calculate access times of a file given information about its

position on a disk and the starting state of the disk. (a)

28. Identify reasons for using signals in user level programs. (a)