CS 210
Spring 2006

Final Topics

This will be a closed book exam. The exam will cover the topics in chapters 6, 8, and 9 as as detailed below.

1. Assembly Language (Chap 6)
   1. You must know all addressing modes and how to use them including stack-relative (s), indexed (x), indirect (n), stack-relative deferred (sf), stack-indexed (sx), and stack-indexed deferred (sxf).
   2. Indexed addressing, especially with arrays. You must know how to create and use local arrays. You are not responsible for knowing how to implement 2 dimensional arrays.
   3. You must be able to program using pass-by reference. You must be able to pass arrays on the run-time stack and use stack-indexed deferred addressing with them.
   4. Indirect addressing and how to use this addressing mode. You must be able to program pointers.
   5. You must be able to program dynamic memory allocation and must know how the compiler adds code in Pep/8 to allow dynamic memory allocation.
   6. You are not responsible for data types (pages 308-317).
   7. You must be able to use and create jump-tables.

2. Process Management (chapter 8)

   1. Operating system functions:
      • Pep/8's loader. How it works, where it is stored in memory, what it does. You could be asked to trace the code, to modify the code to add functionality, or to explain why the code is written the way it is.

      • Traps. The interrupt mechanism, how state (ie registers) are saved when an interrupt occurs, the RETTR instruction, what a PCB (process control block) is. I could ask you to trace the entry and exit code (figure 8.6), to modify the entry/exit code, or to explain why the code is written the way it is.

      • You are not responsible for the individual interrupt handling routines for DECO, DECI, and HEXO and the Get and Print subroutines. You are responsible for the entry and exit points of the interrupt service routine (i.e., program 8.3).

   2. Concurrent processes:
      • Know the difference between software interrupts (traps or synchronous interrupts) and hardware interrupts (asynchronous interrupts).

      • Know what time slices and I/O interrupts are and how they're used in multiprogramming.

      • Know what a process is, how an OS keeps track of processes, what states a process goes through during its execution (as in figure 8.19).

      • Know what multiprocessing is and how it differs from multiprogramming.

      • Know how to create processes in UNIX using system level calls such as fork( ), the execl, wait( ), etc.

      • You are not responsible for the actual interrupt handlers (for DECI, DECO, STRO, NOP) and their associated routines on pages 399 through 417.

   3. Critical Sections:
      • Know what they are and why they occur.

      • Know the general format of a solution (see page 338).

      • Know why programs 8.2 and 8.3 fail to satisfy the critical section problem.

      • Know what deadlock is and how it occurs.

      • Understand program 8.4 (the correct solution to the critical section problem) and be able to solve similar CS problems.

      • Be able to answer questions like question 18 on page 351.

      • Know what semaphores are and the operations that can be done on semaphores (see page 342).

      • Understand how to solve the CS problem using semaphores (program 8.5).

      • Be able to program Linux semaphores using the binsem.h library of system calls.

      • Be able to answer questions like 22 and 24 on pages 352-352.

   4. You are not responsible for section 8.4 (deadlocks).

3. Storage Management (chapter 9)

   1. Understand and be able to explain how logical addresses can be translated to physical addresses with hardware assist (see figure 9.2 and pages 447-449).

   2. Understand paging very well (pages 453-455):
      • The relationship between pages and frames.

      • How to translate logical addresses into physical addresses. Be able to answer questions like number 4 and 5 on page 482.

      • How page tables are used

   3. Be able to explain and use virtual memory (pages 455-459):

      1. Know how program behavior allows us to use virtual memory

      2. Be able to answer questions about demand paging

      3. Know how to determine virtual memory features as done in problems 4 and 5 on page 482 of Warford.

   4. You are not responsible for page replacement or page replacement algorithms (pages 459-463).

   5. You are not responsible for sections 9.3-9.5 (file management, error detecting, and RAID).

   ---

   Return to John Barr's Home Page

   Last updated on 27 Apr 2006 by John Barr