ECE 391

• Computer Engineering

Introduction to the concepts and abstractions central to the development of modern computing systems, with an emphasis on the systems software that controls interaction between devices and other hardware and application programs. Material includes input-output semantics, synchronization, interrupts, multitasking, virtualization of abstractions. Emphasis on learning to operate effectively in teams.

• 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

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.

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. (1)

2. Translate C control constructs and basic data structures (structs and arrays) to assembly language. (1)

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

4. Use subroutines to structure programs. (2)

5. Understand the C calling convention and write assembly language subroutines that can interface with C subroutines. (2)

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

7. Use a debugger to identify and repair code defects. (6)

8. Write an interrupt service routine to respond to external input from the keyboard and real-time clock. (2)

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. (1)

10. Write context switching code to virtualize the CPU between multiple threads. (2)

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

12. Understand how to implement a critical section on a uniprocessor by disabling and reenabling interrupts. (2)

13. Understand how to use mutexes and condition variables to solve basic synchronization problems. (1)

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

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

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

16. Write code to interface with an input device connected to the serial port. (2)

17. Test and debug a multi-thousand line program. (1, 6)

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. (1)

19. Understand memory management algorithms. (1)

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. (1)

21. Calculate the average completion times for tasks under nonpreemptive batch scheduling policies like first-in-first-out and shortest-job-first. (1)

22. Understand the advantage of identifying and prioritizing the jobs that initiate the most blocking I/O operations. (1)

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. (2, 6)

24. Find information on techniques needed for the project but not covered in class. (7)

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

design, using appropriate data structures. (2)

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

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. (1)

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