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

Size: px

Start display at page:

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

Hester Marylou Mathews
6 years ago
Views:

1 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 , you must take the exam during the regularly scheduled time. It should take hours to complete. The format will be similar to the midterm exam. This exam is comprehensive, with material drawn from the midterm exam and all previous 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, and scheduling algorithms, and more emphasis on: IPC and shared memory. Synchronization: interrupts and the scheduler, priority inversion, atomicity and atomic instructions, critical sections, race conditions, busy waiting, bakery algorithm, mutexes, semaphores, monitors (Hoare and mesa semantics), condition variables, etc. 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, memorymapped files, etc. Filesystems (just a bit): File allocation tables, free-bitmaps, free-lists, inodes, and performance considerations. The most relevant assignments are: Project 3 (IPC/Shmem), Project 4 (Banker's), Homework 3 (Synchronization and strace). You do not need to memorize the details of the posix "pthread" synchronization API we used in the latest project, such as the variable types (e.g. pthread_cond_t, pthread_mutex_t, etc.) or specific function names and arguments (e.g. pthread_mutex_init(&m, NULL), etc.). Instead, you will be expected to understand the various synchronization-related abstractions (mutex, semaphore, 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 Q1: Deadlock (a) A computer has six tape drives, with n processes competing for them. Each process may need up to two drives. For which values of n is the system guaranteed to be deadlock free? Explain. If n <= 3, then clearly there can be no deadlock, since even in the worst case, if 3 processes all simultaneously get a tape drive, there is still enough to go around. But note that even for n = 5, there can't be any deadlock. In the worst case scenario with n = 5, all five will get one tape drive, and there is still an extra that can be given to any single process. That process would then finish, freeing up two tape drives for the remaining four, etc. Alternatively, just create a banker's algorithm table with 5 processes, max=2 for each of them, and check that no possible allocations of six tape drives will be unsafe. So n < 6 is our final answer. (b) Suppose a system has 10 tape drives and 4 processes. At time t 0, the state of the system is as follows: Process Maximum Need Current Allocation Might Request P P P P Is the system in a safe state? If so, give a sequence that demonstrates this. If not, explain why not. Yes, it is safe. There are 9 allocated, so 1 tape drive is free, which is enough for either P1 or P2. Let P1 finish, it releases 0. Now let P2 finish, it releases 4. Now 5 tape drives are free. This is enough for either P0 or P3. Let either finish, then the other. (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. This can be used to prevent deadlocks from ever occurring by ensuring that the system is always in a safe state. Before any allocation, check to see if the new state would be safe after the allocation. If so, then go ahead and allow the allocation. Otherwise, if the new state would be unsafe, either deny the allocation, or delay it until some later time when it would be safe. 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? 11 bits (since 2 11 = 2048) How many bits are required to specify a page offset? 12 bits (since 2 12 = 4096) How many bits are required to specify a logical address? 23 (since an address is the combination of page number and offset, i.e Or, because there is 2K*4KB=8MB of memory, and 2 23 = 8M) (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

3 any assumptions you make. Hint: what extra costs will be incurred when performing address translation? On each access, the CPU will first access the page table to obtain the page table entry. Since this is stored in main memory, it will take 70ns, assuming a single access is sufficient (the page table is an array in this question, not a linked list or a tree, so one access should be sufficient). Then, assuming the page table entry is valid, the CPU will translate the address and access the desired physical location in main memory, which takes another 70ns. So a total of 140ns. If it were a miss, we'd have to add in the cost of a page fault, switching to the OS kernel, handling the fault, evicting a page, loading a new page, etc., but no timing information was given for any of those steps. (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 Virt. Page Num. Frame number Offset 14 14/16=0 7 (from page table) 14%16= /16=2 page fault (since valid bit is 0 on that entry)_ 29 29/16= page fault (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. Evict page 0 or 3, since those ones are not dirty, so they won't need to be written to disk. If we had more information, we might be able to select based on frequency or time of access (e.g. LRU, LFU, or other page replacement strategies).

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 [ New pages go into frame 0, 1, 2, 0, 1, 2, 0, 1, 2, etc. I underlined the new pages. ] Time: Page accessed: frame 0: frame 1: frame 2: Total number of page faults: 10 (b) Same question, but for LRU. [ New pages replace whichever page was least recently used, if there are no free frames. ] Time: Page accessed: frame 0: frame 1: frame 2: Total number of page faults: 7 (c) Same question, but for Belady's Optimal Algorithm [ New pages replace whichever page will be accessed the furthest in the future among all current pages. In the last page fault, time=12, page=7, we can't tell if page 3 (frame 0) or page 2 (frame 2) is the better choice. ] Time: Page accessed: frame 0: ? 7? frame 1: frame 2: ? 7? Total number of page faults: 6

5 Q4: Synchronization Bathrooms have been in the news a lot lately. Below is an attempted solution to the unisex 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; 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? male_token. This is the one that was initialized to 3.

6 (b) Which semaphore ensures that only one process at a time will have access to the shared variable, num_men? male_mutex. This is the one that was initialized to 1, and its acquired right before each access to num_mem, then released again soon after the access to num_mem. (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); The first man attempting to enter has to do two things: (1) wait until there are no women, by doing wait(no_women). The last woman out will signal that same semaphore, which is what would let that first man in. (2) prevent any new woman from entering simultaneously, which is accomplished by calling wait(no_man). The new woman would be the first woman, and would also call wait(no_man), and only one of these would succeed without blocking. (d) Does this solution prevent deadlock? If not, show a specific example (of deadlock). Otherwise, justify your answer. No, it does not prevent deadlock. Suppose there are no men and no women in the bathroom. All semaphores will have the same value they started with. Suppose a man and a women both try to enter. Both execute the first five lines of their loops (in any order). At this point, the man has just called wait(no_women) and it succeeded. The woman has called wait(no_man) and it succeeded. Both of those semaphores are now at 0. Now the man calls wait(no_man) and blocks. The woman calls wait(no_woman) and blocks. But also, the man is still holding male_mutex, and the woman is holding female_mutex. So no other man or woman can make any progress either they will block at the first line of the loop. All processes are blocked forever. This is deadlock. (e) Assuming deadlock does not occur, does this solution prevent starvation? Justify your answer. Ignoring the deadlock we found above, there are a few possible answers here. Obviously, if a man stays in the bathroom indefinitely, no woman can ever enter, so all women "starve" (or vice versa). That's not a very interesting case, so lets assume each person stays in the bathroom for some limited amount of time. Even so, if there is a steady stream of men entering/exiting, women will never get to enter. So let's further assume that the distribution of arrivals is such that there are times when the bathroom will become empty. If there is a steady stream of men entering, each will call wait(male_mutex) near the top. If that mutex implementation doesn't have fairness guarantees, there could be some unlucky male who gets stuck waiting at that mutex, while other men enter and/or exit. If we instead assume the underlying mutex is fair, then we need to consider the case where a man is forever starved by women entering/exiting. The first man will reach wait(no_women). If that mutex is fair, it will eventually succeed (because we assumed there would be times when the bathroom is empty). At this point, women won't be able to enter any more, so either the men will now be able to enter or we end up in the deadlock situation from before. So the only way we avoid starvation is by making a lot of assumptions, and we still have a chance of deadlock even then.

7 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. One solution is to use the male/female bathroom solution, above, where "in the bathroom" becomes "on the bridge", "man" becomes "eastbound monkey", and "woman" becomes "westbound monkey. To fix the starvation issue, change the ordering of the wait's within the if-statements, so they are the same order. That is, the eastbound should do this: if (num_eastbound == 1) { wait(no_eastbound); // always do east wait before west wait wait(no_westbound); And the westbound should do this: if (num_westbound == 1) { wait(no_eastbound); // always do east wait before west wait wait(no_westbound); The order of the signal() calls does not matter. There are many other solutions. (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. Only if we make a lot of assumptions about the fairness of the underlying mutexes.

CSCI 346 Final Exam Review Materials

CSCI 346 Final Exam Review Materials The final will take place during exam week. It should take 2-2.5 hours. Format is similar to the midterm. This exam is comprehensive, with material drawn from the midterm