CHAPTER 2

2.2. THREAD
1 Provide two programming examples in which multithreading provides better performance
than a single-threaded solution.

2 What are two differences between user-level threads and kernel-level threads? Under
what circumstances is one type better than the other?

3 Describe the actions taken by a kernel to context-switch between kernel- level threads.

4 What resources are used when a thread is created? How do they differ from those used
when a process is created?

5 Assume that an operating system maps user-level threads to the kernel using the many-
to-many model and that the mapping is done through LWPs. Furthermore, the system
allows developers to create real-time threads for use in real-time systems. Is it necessary
to bind a real-time thread to an LWP? Explain.

6 Provide two programming examples in which multithreading does not provide better
performance than a single-threaded solution.

7 Under what circumstances does a multithreaded solution using multi-ple kernel threads
provide better performance than a single-threadedsolution on a single-processor system?

8 Which of the following components of program state are shared across threads in a
multithreaded process?
a. Register values
b. Heap memory
c. Global variables
d. Stack memory

9 Can a multithreaded solution using multiple user-level threads achieve better

performance on a multiprocessor system than on a single-processor system?

10 In Chapter 3, we discussed Google’s Chrome browser and its practice of opening each
new website in a separate process. Would the same benefits have been achieved if instead
Chrome had been designed to open each new website in a separate thread? Explain.

11 Is it possible to have concurrency but not parallelism? Explain.

12 Using Amdahl’s Law, calculate the speedup gain of an application that has a 60 percent
parallel component for (a) two processing cores and (b) four processing cores.

13 Determine if the following problems exhibit task or data parallelism:

• The multithreaded statistical program described in Exercise 21
• The multithreaded Sudoku validator described in Project 1 in this chapter
• The multithreaded sorting program described in Project 2 in this chapter
• The multithreaded web server described in Section 1

14 A system with two dual-core processors has four processors available for scheduling. A
CPU-intensive application is running on this system.
All input is performed at program start-up, when a single file must be opened. Similarly, all
output is performed just before the program terminates, when the program results must be
written to a single file. Between startup and termination, the program is entirely CPU-
bound. Your task is to improve the performance of this application by multithreading it. The
application runs on a system that uses the one-to-one threading model (each user thread
maps to a kernel thread).
• How many threadswill you create to performthe input and output?
Explain.
• How many threads will you create for the CPU-intensive portion of the application?
Explain.

15 Consider the following code segment:

pid t pid;
pid = fork();
if (pid == 0) { /* child process */
fork();
thread create( . . .);
}
fork();
a. How many unique processes are created?
b. How many unique threads are created?

16 As described in Section 7.2, Linux does not distinguish between processes and threads.
Instead, Linux treats both in the same way, allowing a task to bemore akin to a process or a
thread depending on the set of flags passed to the clone() systemcall. However, other
operating systems, such as Windows, treat processes and threads differently.
Typically, such systems use a notation in which the data structure for a process contains
pointers to the separate threads belonging to the process. Contrast these two approaches
for modeling processes and threads within the kernel.

17 The program shown in Figure 16 uses the Pthreads [Link] be the output from
the program at LINE C and LINE P?

18 Consider a multicore system and a multithreaded program written using the many-to-
many threading model. Let the number of user-level threads in the program be greater than
the number of processing cores in the system. Discuss the performance implications of the
following scenarios.
a. The number of kernel threads allocated to the program is less than the number of
processing cores.
b. The number of kernel threads allocated to the program is equal to the number of
processing cores.
c. The number of kernel threads allocated to the program is greater than the number of
processing cores but less than the number of user-level threads.

Programming Problems
1. Write a multithreaded program that calculates various statistical values for a list of
numbers. This programwill be passed a series of numbers on the command line and will
then create three separate worker threads. One thread will determine the average of the
numbers, the second will determine the maximum value, and the third will determine the
minimum value.
For example, suppose your program is passed the integers
90 81 78 95 79 72 85
The program will report
The average value is 82
The minimum value is 72
The maximum value is 95
The variables representing the average,minimum, and maximumvalues will be stored
globally. The worker threads will set these values, and the parent thread will output the
values once the workers have exited. (We could obviously expand this program by creating
additional threads that determine other statistical values, such as median and standard
deviation.)

2. The Fibonacci sequence is the series of numbers 0, 1, 1, 2, 3, 5, 8, ....

Formally, it can be expressed as:
fib0 = 0
fib1 = 1
fibn = fibn−1 + fibn−2
Write a multithreaded program that generates the Fibonacci sequence. This program
should work as follows: On the command line, the user will enter the number of Fibonacci
numbers that the program is to generate. The program will then create a separate thread
that will generate the Fibonacci numbers, placing the sequence in data that can be shared
by the threads (an array is probably the most convenient data structure). When the thread
finishes execution, the parent thread will output the sequence generated by the child
thread. Because the parent thread cannot begin outputting the Fibonacci sequence until the
child thread finishes, the parent thread will have to wait for the child thread to finish. Use
the techniques described in Section 4.4 to meet this requirement

3. Write a multithreaded program that outputs prime numbers. This program should work as
follows: The user will run the program and will enter a number on the command line. The
program will then create a separate thread that outputs all the prime numbers less than or
equal to the number entered by the user.