CSEN 602-Operating Systems, Spring 2018 Practice Assignment 2 Solutions Discussion:

Transcription

1 CSEN 602-Operating Systems, Spring 2018 Practice Assignment 2 Solutions Discussion: Exercise 2-1: Reading Read sections 2.1 (except 2.1.7), till Exercise 2-2 In Fig.1, three process states are shown. In theory, with three states, there could be six transitions, two out of each state. However, only four transitions are shown. Are there any circumstances in which either or both of the missing transitions might occur? Figure 1: A process can be in running, blocked, or ready state. Transitions between these states are as shown. As far as we can see, there are two state transitions that are not possible and there are valid reasons for why they not maintained. They are: i. blocked running For a blocked process to run, it must be present in the CPU queue first. And since any blocked process is out of the CPU queue, it cannot run unless it is enqueued first i.e. becoming in the ready state. ii. ready blocked No ready process can be blocked since it is not running any of its instructions. It is simply waiting for its turn to be run by the CPU. 1 These sections are according to the fourth edition of the textbook 1

2 Exercise 2-3 Assume that at time 5 no system resources are being used except for the processor and memory. Now consider the following events: At time 5: P1 executes a command to read from disk unit 3. At time 15: P5 s time slice expires. At time 18: P7 executes a command to write to disk unit 3. At time 20: P3 executes a command to read from disk unit 2. At time 24: P5 executes a command to write to disk unit 3. At time 33: An interrupt occurs from disk unit 2: P3 s read is complete. At time 36: An interrupt occurs from disk unit 3: P1 s read is complete. At time 38: P8 terminates. At time 40: An interrupt occurs from disk unit 3: P5 s write is complete. At time 48: An interrupt occurs from disk unit 3: P7 s write is complete. For each time 22, 37, and 47, identify which state each process is in. At time 22: P1: blocked P3: blocked P5: running P7: blocked P8: ready At time 37 P1: ready P3: ready P5: blocked P7: blocked P8: running 2

3 At time 47 P1: ready/running P3: ready/running P5: ready P7: blocked P8: Exercise 2-4 You have executed the following C program: main () int pid; pid = fork (); printf ("%d \n", pid); What are the possible outputs, assuming the fork succeeded? 0 <child pid> or <child pid> 0 Exercise 2-5 In Fig. 2, a multi-threaded Web server is shown. If the only way to read from a file is the normal blocking read system call, do you think user-level threads or kernel-level threads are being used for the Web server? Why? 3

4 Figure 2: A multi-threaded Web server. If the Webserver process is running in user-mode then it will be blocked if one of its threads made the read call. This is due to the fact that the Kernel does not have any access to any information concerning the threads in user-mode. The quick remedy to this problem is to have the thread running in kernel-mode which means that the whole process will be running in the kernel space. However, after deeper delving into the multi-threading models supported by operating systems, it is possible to avoid having the process to run in the kernel space to avoid such a problem. We introduce two models and where we can avoid being forced to support such an approach: Many-to-One Model: This is the classical model where many user-level threads are mapped to one kernel-level thread. It happens to be efficient because all the threads are managed in the user-mode but once a thread makes a blocking call (like the example given in the question statement) the whole process is blocked. One-to-One Model: In this model each user thread is mapped to a single kernel-level thread, and the problem of blocking calls diminishes. The disadvantage of this approach is the overhead introduced to create a kernel-level thread for each user-level thread initiated. Exercise 2-6 Can a thread ever be preempted by a clock interrupt? If so, under what circumstances? If not, why not? 4

5 Preemption is the process of interrupting a process with the possibility of having it resume again. User-level threads cannot be preempted by the clock unless the whole process quantum has been used up. Kernel-level threads can be preempted individually. In the latter case, if a thread runs too long, the clock will interrupt the current process and thus the current thread. The kernel is free to pick a different thread from the same process to run next if it so desires. Exercise 2-7 Many current language specifications, such as for C and C++, are inadequate for multithreaded programs. This can have an impact on compilers and the correctness of code, as this problem illustrates. Consider the following declarations and function definition: int global_positives = 0; typedef struct list struct list *next; double val; * list; void count_positives(list l) list p; for (p = l; p; p = p -> next) if (p -> val > 0.0) ++global_positives; a) Now consider the case in which thread A performs count_positives(<list containing only negative values>); while thread B performs ++global_positives; The C language only addresses single-threaded execution. Does the use of two parallel threads create any problems or potential problems? This should work correctly, because count_positives in this specific case does 5

6 not update global_positives, and hence the two threads operate on distinct global data and require no locking This should work correctly, because count_positives in this specific case does not update global_positives, and hence the two threads operate on distinct global data and require no locking. b) Some existing optimizing compilers (including gcc, which tends to be relatively conservative) will "optimize" count_positives to something similar to void count_positives(list l) list p; register int r; r = global_positives; for (p = l; p; p = p -> next) if (p -> val > 0.0) ++r; global_positives = r; What problem or potential problem occurs with this compiled version of the program if threads A and B are executed concurrently? This transformation is clearly consistent with the C language specification, which addresses only single-threaded execution. In a single-threaded environment, it is indistinguishable from the original. The pthread specification also contains no clear prohibition against this kind of transformation. And since it is a library and not a language specification, it is not clear that it could. However, in a multithreaded environment, the transformed version is quite different, in that it assigns to global_positives, even if the list contains only negative elements. The original program is now broken, because the update of global_positives by thread B may be lost, as a result of thread A writing back an earlier value of global_positives. By pthread rules, a thread-unaware compiler has turned a perfectly legitimate program into one with undefined semantics. Exercise 2-8 Consider the following code using the POSIX Pthreads API: thread2.c #include <pthread.h> 6

7 #include <stdlib.h> #include <unistd.h> #include <stdio.h> int myglobal; void *thread_function(void *arg) int i,j; for ( i=0; i<20; i++ ) j=myglobal; j=j+1; printf("."); fflush(stdout); sleep(1); myglobal=j; return NULL; int main(void) pthread_t mythread; int i; if ( pthread_create( &mythread, NULL, thread_function, NULL) ) printf("error creating thread."); abort(); for ( i=0; i<20; i++) myglobal=myglobal+1; printf("o"); fflush(stdout); sleep(1); if ( pthread_join ( mythread, NULL ) ) printf("error joining thread."); 7

8 abort(); printf("\nmyglobal equals %d\n",myglobal); exit(0); In main() we first declare a variable called mythread, which has a type of pthread_t. This is essentially an ID for a thread. Next, the if statement creates a thread associated with mythread. The call pthread_create() returns zero on success and a nonzero value on failure. The third argument of pthread_create() is the name of a function that the new thread will execute when it starts. When this thread_function() returns, the thread terminates. Meanwhile, the main program itself defines a thread, so that there are two threads executing. The pthread_join function enables the main thread to wait until the new thread completes. a) What does this program accomplish? This program creates a new thread. Both the main thread and the new thread then increment the global variable myglobal 20 times. b) Here is the output from the executed program:..o.o.o.o.oo.o.o.o.o.o.o.o.o.o..o.o.o.o.o myglobal equals 21 Is this the output you would expect? If not, what has gone wrong? 8

9 Quite unexpected! Because myglobal starts at zero, and both the main thread and the new thread each increment it by 20, we should see myglobal equaling 40 at the end of the program. But myglobal equals 21, so we know that something fishy is going on here. In thread_function(), notice that we copy myglobal into a local variable called j. The program increments j, then sleeps for one second, and only then copies the new j value into myglobal. That s the key. Imagine what happens if our main thread increments myglobal just after our new thread copies the value of myglobal into j. When thread_function() writes the value of j back to myglobal, it will overwrite the modification that the main thread made. 9