CSCI 346 Final Exam Review Materials

Size: px

Start display at page:

Download "CSCI 346 Final Exam Review Materials"

Blaise Henderson
6 years ago
Views:

1 CSCI 346 Final Exam Review Materials The final will take place during exam week. It should take hours. Format is similar to the midterm. This exam is comprehensive, with material drawn from the midterm and all previous lectures, homework and projects. However, it will be biased heavily towards material covered in the second half of the course. That is, less emphasis on hardware and interrupts, the command shell, process/pcb management, device drivers, and scheduling algorithms, and more emphasis on: IPC: Using MPI and/or shared memory for inter-process or inter-thread communication. Synchronization: interrupts and the scheduler, priority inversion, atomicity and atomic instructions, critical sections, race conditions, busy waiting, bakery algorithm, mutexes, semaphores, Java's wait/notify/notifyall functions (aka condition variables), etc. Monitors? We did not cover monitors in lecture specifically, and you are not responsible for the vocabulary of monitors (e.g. Hoare-style semantics, Mesa semantics). However, if given some context, you should be able to answer questions about how monitors work, the tradeoffs and problems they might introduce or solve, etc., since this only requires an understanding of the synchronization concepts that we did study. Resource allocation: deadlock, resource wait/hold graphs, the banker's algorithm and safe/unsafe states, etc. Memory management: segmentation, allocation, fragmentation, address translation, demand paging and swapping, page replacement algorithms and eviction, memory protection, etc. Filesystems (perhaps just a bit): File allocation tables, free-bitmaps, free-lists, inodes, and performance/reliability considerations. The most relevant assignments are: Project 4 (Banker's), Project 3 (IPC/MPI/shmem), Homework 4 (strace), Homework 3 (Synchronization), and some of Homework 2 (Threads, IPC, Scheduling). You do not need to memorize the details of the posix "pthread" synchronization API described in the book, or the details of specific Java primitives used in the projects, such as posix variable types (pthread_cond_t, pthread_mutex_t, etc.) or posix functions (pthread_mutex_init(&m, NULL), etc.), or the Java "synchronized" keyword or Semaphore class. Instead, you will be expected to understand the various synchronization-related abstractions, like critical section, mutex, lock, semaphore, wait/notify/notifyall (aka condition variable), etc., and be able to read or write plausible pseudo code notation for using these abstractions. Note: The questions below are not comprehensive. They are just a small sampling of the types of question that may appear on the final.

2 From the textbook (9 th edition page and question numbers for the 8 th or 10 th editions vary). Chapter 5 (Synchronization): exercises 5.1-6, , 5.17, 5.20, 5.21, 5.24, 5.28, 5.29, 5.32, 5.41; Projects 1, 2, and 3 (which could be solved using your choice of Java, C/posix, or pseudo-code, and using any of the synchronization approaches we studied). Chapter 7 (Deadlocks): exercises 7.1-4, 7.7-8, , , , Chapter 8 (Main Memory): exercises 8.1, 8.3-5, 8.9, 8.11, 8.20, 8.23 Chapter 9 (Virtual Memory): exercises 9.1-4, 9.8, 9.12, 9.17, 9.21, 9.22, , 9.27, 9.32 Q1: Deadlock (a) A computer has six tape drives, with n processes competing for them. Each process may need up to two drives at a time. For which values of n is the system guaranteed to be deadlock free? Explain. (b) Suppose a system has 10 tape drives and 4 processes. At some time, the system is in this state: Process Maximum Need Current Allocation P0 6 1 P1 4 3 P2 1 0 P3 8 5 Is the system in a safe state? Show how, or explain why not. (c) What is the purpose of determining whether the system is in a safe state? How is this concept useful in terms of resource allocation? Give a specific example.

3 Q2: Virtual Memory Consider a logical address space of 2048 pages, each holding 4096 bytes (4KB). (a) How many bits are required to specify a virtual page number? How many bits are required to specify a page offset? How many bits are required to specify a logical address? (b) Suppose memory has 70 ns latency, and that the virtual memory page table for a process is stored as a simple contiguous array in main memory. Compared to a system without virtual memory, what is the effective access time (EAT) for the process running with virtual memory? Explain, and be sure to state any assumptions you make. Hint: what extra costs will be incurred when performing address translation? (c) Part of the page table for a process running in a system that uses demand paging is given below. The page size is 16 bytes and there are 6 pages in the logical address space of the process. All numbers are in decimal. Page # Frame # Dirty Bit Valid/Invalid bit For each of the logical addresses given below, indicate the frame number and offset of the memory location in physical memory. If the page is not currently residing in main memory, write "Page Fault" instead of the frame number and offset. If an answer can't be determined from the information given, say so. All numbers are given in decimal. Logical Address Frame number Offset (d) Suppose the process in the previous question makes an access that causes a page fault. Assuming a page must be evicted from this process, which page should be chosen? Justify your answer.

4 Q3: Page replacement Suppose a process has been allocated 3 frames of physical memory. The process accesses pages in the following order: 0, 1, 7, 0, 1, 2, 0, 1, 2, 3, 2, 7, 1 For each of the following page replacement methods, describe or diagram the order and position of the page replacements as the pages are swapped into / evicted from memory. Indicate page faults by circling the associated page accesses. For each algorithm, count the total number of page faults for the above sequence of numbers. (a) FIFO Time: Page accessed: Contents of frame 0: Contents of frame 1: Contents of frame 2: Total number of page faults: (b) Same question, but for LRU. (c) Same question, but for Belady's Optimal Algorithm Q4: Synchronization Below is an attempted solution to the "bathroom problem". In this classic problem, the goals are: there should never be more than three people in the bathroom at once there should never be both males and females in the bathroom at once there is no starvation and no deadlock Here is one possible solution, involving several shared variables and concurrent processes: Shared Variables: int num_men = 0, num_women = 0; semaphore male_mutex = 1; semaphore female_mutex = 1; semaphore male_token = 3; semaphore female_token = 3; semaphore no_men = 1; semaphore no_women = 1;

5 Concurrent Processes: male() { while (TRUE) { wait(male_token); wait(male_mutex); num_men = num_men + 1; if (num_men == 1) { wait(no_women); wait(no_men); signal(male_mutex); // use the bathroom wait(male_mutex); num_men = num_men 1; if (num_men == 0) { signal(no_women); signal(no_men); signal(male_mutex); signal(male_token); female() { while (TRUE) { wait(female_token); wait(female_mutex); num_women = num_women + 1; if (num_women == 1) { wait(no_men); wait(no_women); signal(female_mutex); // use the bathroom wait(female_mutex); num_women = num_women 1; if (num_women == 0) { signal(no_men); signal(no_women); signal(female_mutex); signal(female_token); (a) Which semaphore ensures that no more than 3 men are in the bathroom at the same time? (b) Which semaphore ensures that only one process at a time will have access to the shared variable, num_men? (c) no_women and no_men are semaphores that indicate that there are no men (or women) currently in the bathroom (if they are set to 1). What is the purpose of this conditional statement: if (num_men == 1) { wait(no_women); wait(no_men); (d) Does this solution prevent deadlock? If so, show a specific example. Otherwise, justify your answer. (e) Assuming deadlock does not occur, does this solution prevent starvation? Justify your answer.

6 Q5: Synchronization Ten monkeys use a narrow rope bridge to cross a river. On the east side of the river are some banana trees where the monkeys like to eat. On the west side are some shade trees where the monkeys sleep. Each monkey starts under the shade trees on the west side, and repeatedly does the following: first it crosses the bridge to the east side, then it eats some bananas (which takes some random amount of time), then it crosses back to the west side, where it takes a nap (which takes some random amount of time). This is repeated indefinitely. Here is a program that simulates the behavior of one monkey: int id = getpid(); while (true) { printf("leaving west side \n"); sleep(3); printf(" arrived at east side.\n"); printf("banana time \n"); sleep(rand()); printf(" that was delicious!\n"); printf("leaving east side \n"); sleep(3); printf(" arrived at west side.\n"); printf("time for a nap \n"); sleep(rand()); printf(" I'm awake & hungry again!\n"); We will run ten copies of this code concurrently to simulate the ten monkeys. Unfortunately, the bridge is a narrow and the monkeys are stubborn: if two monkeys meet on the bridge going opposite directions, neither will step aside or back up. Your task is to fix the code above so that this situation never occurs. Specifically, fix the code so that: Any number of monkeys can be on the bridge at one time. All monkeys on bridge at one time must be traveling the same direction. If no monkeys are on the bridge, then a monkey should not be prevented from starting across. That last condition ensures the bridge doesn't sit idle while there are monkeys that want to use the bridge. (a) Fix the code to ensure these three conditions hold. You may not remove or reorder the existing code, but you can add any additional code you like. Use semaphores, mutexes, condition variables, or any other scheme you like. Clearly indicate any shared variables and how those variables should be initialized. Your code must prevent deadlock. (b) Does your code prevent starvation? Explain. Be as specific as possible, either providing an example of how starvation can occur, or arguing why it can't occur.

Filesystems (just a bit): File allocation tables, free-bitmaps, free-lists, inodes, and performance considerations.

Filesystems (just a bit): File allocation tables, free-bitmaps, free-lists, inodes, and performance considerations. CSCI 346 Final Exam Review Questions -- Solutions The final exam will be Tuesday, May 17, 11:30-2:00 PM, in Swords 328. If you have not made arrangements with me and confirmed by email, you must take the