ENCM 501 Winter 2019 Assignment 9

Transcription

1 page 1 of 6 ENCM 501 Winter 2019 Assignment 9 Steve Norman Department of Electrical & Computer Engineering University of Calgary April 2019 Assignment instructions and other documents for ENCM 501 can be found at This assignment is important, but won t be marked There will be a final exam problem about simple use of the Pthreads library. This assignment is designed to give you an introduction to that library. Solutions will be posted so that you can check your work. Exercise A: Pointers to Functions in C Read This First This exercise doesn t have anything to do with threads. It just provides an overview of the concepts and syntax related to pointers to functions in C. Concepts The key concepts should be simple to anybody who knows at least two assembly languages. A normal function call, not using a pointer-to-function as the function address, looks like this example in C: k += foo(i); The RISC-V assembly language for that looks something like this: [Copy i to argument register.] JAL foo # call foo, putting return address in x1 [Add return value from foo to k.] In generating an executable, the linker will determine the address of the first instruction of foo, and copy an appropriate offset into the machine code for the JAL instruction. Essentially, the target address of the jump is decided permanently at link time, before the program ever runs. In contrast, here s a sketch of C code that makes a call based on p, a pointer to a function: p = &bar; // make p point to function bar //... more C statements... k += (*p)(i);

2 ENCM 501 Winter 2019 Assignment 9 page 2 of 6 Here the target address of the jump is whatever address is sitting in the register or memory location allocated for p that decision is made at run time. Suppose a RISC-V compiler chose to use x5 for p. RISC-V assembly language for the C code would look like this: LA x5, bar # pseudoinstruction copies &bar into x5 #... more instructions... [Copy i to argument register.] JALR x5 # call whatever x5 points to, put ret. addr. in x1 [Add return value from whatever we just called to k.] Syntax C syntax related to pointers to functions is notoriously difficult: First, there s the problem of how to declare that a variable or function argument is of some specific pointer-to-function-type. A good way to work around that is with appropriate typedefs for function types. See Part I of this exercise for details. Second, and connected in a way to the first point, is operator precedence in C. The function call operator () has higher precedence than the pointer dereference operator *. Consider this statement: y = *f(x); f is called with argument x. The return value of f is some kind of data address whatever data is at that address gets read and copied into y. Now consider this statement, similar but with a crucial pair of parentheses: w = (*p)(z); Whatever function p points to is called with argument z; the return value is directly copied into variable w. Third, there is the optional use of the & operator. If quux is a function, then &quux and quux mean the same thing in many C expressions! That s quite different from the story for simple data objects if i is an int, the meaning of i is never the same as the meaning of &i! Fourth, there is the optional use of the * operator. If pf is a pointer to a function of the appropriate type, then pf(arguments) means the same thing as (*pf)(arguments). That s also very different from the story for simple data objects if pi is of type pointer-to-int, the meaning of pi is never the same as the meaning of *pi! What to Do, Part I Make copies of the files ptr2func-1.c and ptr2func-2.c. Study them carefully. A C compiler will generate identical instructions from both files, for reasons explained in Read This First and/or comments in the two.c files. Build executables with the commands and gcc -Wall ptr2func-1.c -o p2f1.exe gcc -Wall ptr2func-2.c -o p2f2.exe

3 ENCM 501 Winter 2019 Assignment 9 page 3 of 6 (Use of the -Wall ( warn all ) option asks the compiler to generate warnings for questionable use of C features. You should see that neither command generates any warnings.) Run both executables to confirm that they produce identical outputs. What to Do, Part II Make a copy of the file ptr2func-3.c. Read the file. In its original state, the C code does not make use of pointers to functions it just prints some values of f1(x, y) = 2.5 x 2 y 2 for various values of x and y. Modify the C code so that the program, as before, prints the values of f1 for the given x and y values, but then goes on to make another table of values for f2, defined as follows: f2(x, y) = (2 x y)(x y) + x, for the same pairs of (x, y) values that were used to make the table of f1 values. Do this: by writing an appropriate definition for f2; by modifying make_table to have a seventh argument of an appropriate pointer-to-function type; by calling make_table twice from main. Part I: Nothing. Part II: A listing of the modified C source code. Exercise B: Introduction to Pthreads Read This First Important: In ENCM 501, the goal related to the POSIX Threads ( Pthreads ) library is to learn the interfaces to a few important functions in the library, and to understand some of the things that can happen when a process has multiple threads. It is not a goal to gain enough expertise with this complex library to be proficient at writing correct and efficient threaded applications! The function to start a thread is pthread_create: int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); Here are some notes: pthread_t is some kind of integer type used to give each active thread a unique ID number. pthread_create uses its first argument to communicate the ID number of the newly created thread. The second argument can be used to customize the attributes of the new thread. We ll just pass NULL, to get default attributes.

4 ENCM 501 Winter 2019 Assignment 9 page 4 of 6 The third argument, start_routine, is a pointer to a function. The function pointed to must take one argument of type void* (generic pointer to data) and must return a value of type void*. The fourth argument allows the creating thread and the created thread to have a private communication channel for data. arg can be NULL, if no such communication is needed. arg can point to a complicated struct object, if many data items of various types need to be communicated. The return value from pthread_create is 0 for success, and nonzero for failure, which could happen, for example, if creating a new thread would violate some limit on the number of active threads. For this assignment, we ll live dangerously and assume success you don t want to do that in production code. If Thread A creates Thread B, Thread A can wait for Thread B to finish by calling pthread_join: int pthread_join(pthread_t thread, void **retval); In our example, thread must be the ID number of Thread B, which Thread A would have obtained when it created Thread B. Don t worry about the details of retval for now. retval can be used by Thread A to obtain the return value of Thread B s start routine, or an address sent by Thread B via the pthread_exit function. If Thread A doesn t need that information, it can use NULL for retval. What to Do, Part I Do this part in ICT 320 the computers there seem to do a nice job of generating many different output sequences from the program you ll run here. Copy the file thread9b.c Read the file carefully; make sure you understand the calls to pthread_create and pthread_join. gcc -O2 thread9b.c -lpthread -o thread9b.exe Run the program several times, to see that two threads run concurrently, and in unpredictable order, writing characters to stdout. What to Do, Part II Do this part in ICT 320 so that your timing data will be consistent with the posted solutions. Copy the file bad-shared-mem.c, and read it carefully. In the program, two threads will each increment the variable counter 50,000,000 times, without any attempt to ensure mutually exclusive access. If, by extremely improbable luck, each counter++ operation were to read counter, add 1, then write counter, without interference from the other thread, you would expect the final value of counter to be 100,000,000. gcc -O2 bad-shared-mem.c -lpthread -o bad-shared-mem.exe Run the program ten times, by using this command ten times: time./bad-shared-mem.exe

5 ENCM 501 Winter 2019 Assignment 9 page 5 of 6 The output labeled real is how much time elapses from the moment the process starts to the moment it terminates, the output labeled user is how much CPU time was spent running the process s instructions, and the output labeled sys is how much CPU time was spent by the OS kernel in support of the process. You should notice that the sum user of sys is often greater than real. Answer this question: Why does it make sense that this sum is greater than real how is it possible to use, say, seconds of CPU time in only seconds of real time? Write down all of the final values of counter from all ten program runs. Do you ever get the same value twice? Are any of the values close to 100,000,000? Part I: Nothing. Part II: Answer to questions, and list of final values of counter. Exercise C: Pthread mutexes Read This First One way to prevent the nasty unpredictability seen in Exercise B is to use mutexes to guard the updates to global variables like counter. Mutex is short for mutual exclusion. The simplest form of mutex is essentially a lock that only one thread can possess at any given moment. The program you ll look at in this exercise demonstrates simple use of a mutex to manage access by two threads to a single global variable. An important point about Pthreads mutexes is that calling either pthread_mutex_lock or pthread_mutex_unlock (or many but not all other Pthreads functions) will synchronize memory. In the code you ll look at in this exercise, a call to pthread_mutex_lock will ensure that the subsequent read of counter can never be a read of a stale value from a cache block that appears to be valid but is in fact about to invalidated. What to Do Attention: Cygwin is terrible for this exercise! On Cygwin the overhead of calls to pthread_mutex_lock or pthread_mutex_unlock is orders of magnitudes greater than on Linux on the same hardware. This is what I would have had you do on Linux: Do this part on a computer in ICT 320, so that you can compare your results fairly with your Exercise B, Part II results. Copy the file better-shared-mem-linux.c, and read it carefully. gcc -O2 better-shared-mem-linux.c -lpthread -o bslm.exe Run the program ten times, by using this command ten times: time./better-shared-mem-linux.exe Does the program always increment counter exactly 100,000,000 times? Calculate the average real time per program run. You should notice that it is much higher than the typical real time for a program run in Exercise B, Part II!

6 ENCM 501 Winter 2019 Assignment 9 page 6 of 6 On Cygwin a single run of the executable may take several minutes. Doing that ten times is not a good use of your time! To get a more reasonable sense of the overhead of using a lock to avoid a race condition, follow the above instructions, but use the file better-shared-mem-win32.c instead. Answer to question, data for and calculation of average real time. Exercise D: Threads that report some facts about themselves What to Do Do this part on any machine in ICT 320. Copy the file thread-report.c, and read it carefully. gcc -O2 thread-report.c -lpthread -o thread-report.exe Run the program ten times, by using this command ten times:./thread-report.exe For each run: Write down the addresses of each of the eight variables called local. (The different addresses confirm that each thread gets its own stack.) Use the output to determine the order in which the four threads get the lock. For example, if the threads get the lock in the same order in which they were created, list the order as 0, 1, 2, 3, 4, 5, 6, 7 Also, explain briefly how the output tells the the order in which the threads get the lock. Data and explanation requested in What To Do.