MCS-378 Homework Part 1 (Fall 2002)

When turning in a homework problem, if it is one from the book, you should indicate the exercise number. If it is not from the book, you should indicate the number I give with an x in it, as in 4.x1 below. These will be the reference numbers I use in reporting back your standing on the homework.

Chapter 4

Problem 4.x1: The file forker.c which is linked to the web version of this homework contains a simple program that loops three times, each time calling the fork system call described in section 4.3.1 of the textbook. Afterward it sleeps (does nothing) for 30 seconds. Download this file, compile it using the command
```
cc -o forker forker.c
```
and then run it using the command
```
./forker
```
While the program is in its 30 second sleep, in a second terminal window do the command
```
ps x
```
to get a listing of processes. How many processes are shown running the ./forker command? Explain by drawing a "family tree" of the processes, with one box for each process and a line connecting each (except the first one) to its parent.
Problem 4.x2: Consider two variants of the program given in the textbook's Figure 4.8. In variant1, the line
```
printf("Child Complete");
```
has been removed. In variant2, both that line and also the preceding line
```
wait(NULL);
```
have been removed. Each of these variant programs is compiled and run in a shell terminal window. What difference might be observed between variant1's behavior and variant2's behavior? Explain. You are welcome to try the experiment if you would like. If you do so, be sure to look carefully at the output.

Chapter 5

Problem 5.x1: Section 5.2 lists four benefits of multithreaded programming. Two of these are relative to the alternative of using a single process containing a single thread, whereas the other two are relative to the alternative of using multiple processes, each containing a single thread.
1. Which are which?
2. Of course, multithreaded programming has disadvantages as well as benefits. Use the web to find the slides from John Ousterhout's talk on "Why Threads Are A Bad Idea (for most purposes)" and write a short paragraph summarizing its main point.

Chapter 6

Do exercise 6.4 from page 169.

Chapter 7

Problem 7.x1: Consider the code in Figures 7.35-7.37, pages 213-215.
1. Explain how this code can be changed to eliminate the dbReading instance variable.
2. How can Figure 7.36, page 214, be changed to do the notifyAll operation less often, without affecting its correctness?
3. Explain why that notifyAll can be safely changed to notify

Chapter 8

Do exercise 8.9 from page 249. (If you are having difficulty with this, you may find the more concrete exercise 8.8 to be a useful warmup.)

Chapter 9

Problem 9.x1: Consider parallel parking along downtown streets. In some parts of town, there are white lines painted on the pavement, perpendicular to the curb and spaced at regular intervals. Each pair of consecutive lines marks one parking space. In other parts of town, there are no painted lines, and so each driver simply parks wherever there is room. Assume, however, that drivers are reasonably polite about how they park. For example, if cars AA and BB are parked as follows
```
AA    BB
```
and car CC arrives, it will park in one of the following two ways
```
AACC  BB                            AA  CCBB
```
rather than
```
AA CC BB
```
Which kind of fragmentation is each part of town subject to? Explain, being sure to take into account what happens as parked cars leave and others take their place.

Chapter 10

Do exercise 10.9 from page 341. For part b, remember that a "bigger disk" doesn't normally mean a physically larger disk platter (e.g., a 5 inch platter instead of a 3 inch one). Instead, it means a larger capacity disk drive, which is often achieved by stacking more disk platters on the drive's spindle.
Do exercise 10.11 from page 342. If you find this tedious to do by hand, you might want to consider the alternative of writing a program.

Instructor: Max Hailperin