Programming with pthreads

You may work alone or with one other classmate on this assignment.

Goals

Get a little experience with a common threaded program architecture
Learn the basics of pthreads

Rubric

Maximum score: 12 points

6 - UI handles input and spawns worker threads as specified 2 - worker threads correctly do their computations, print, and quit 2 - all workers report and quit before the program terminates 2 - code quality

Background

Earlier this term, you learned to use fork() to create new processes. Though it was possible to get those processes to communicate with each other using pipes, Unix signals and shared memory, those techniques can be quite awkward to manage.

Another common technique for causing different pieces of code to execute simultaneously (or at least to simulate simultaneity by taking turns) is called threading. A single process can have multiple threads, each of which is performing different computations. The threads within a single process can communicate via global variables, which tends to make inter-thread communication a lot simpler than inter-process communication.

In C, a very common way to use threads is via the pthreads library. For this exercise, you are going to write a simple multi-threaded program using pthreads.

One common use of threads is to have one thread communicate with the user (sometimes called a UI thread or interface thread), and another thread (a worker thread) perform some intensive computation. Sometimes, the worker thread will occasionally report back to the UI thread so the user can receive some feedback. This example pthreads_test.c, for example, uses a UI thread to wait for the user to hit Enter, while the worker thread does the all-important work of counting as high as possible as fast as possible. By separating these two jobs (taking input from the user and doing something computationally intensive), the resulting code is often simpler than it would be if you tried to do these separate operations in a single thread.

A more realistic version of this separation between UI threads and worker threads is to enable a program to accept and process a sequence of user requests, even if some of the requests take a long time to execute. In this scenario, the program might have a UI thread to accept user input, and then each time the user makes a request, the program spawns a new thread to handle the request, allowing the UI thread to wait for another request. Web servers work a lot like this: (1) listen for queries; (2) receive a query; (3) spawn a thread to handle the query; (4) go to step 1. Again, by separating the UI from the other computations, the overall structure of the code is (or can be) simpler, and thus easier to debug and maintain.

Your job

For this exercise, you're going to write a threaded program that does the following:

Either spawn a UI thread or do the UI work in the main thread. Either way, the relevant thread should:
- Print a prompt along the lines of "Type a positive integer:"
- Read a line of user input using fgets(..., stdin).
- If the user typed:
  - q or Q or end-of-input (Ctrl-D), exit the program
  - an integer N, spawn a worker thread, passing N as an argument to the thread
  - anything else, do nothing
- Repeat
For each worker thread:
- Count the number of prime numbers <= N
- Do the counting using a crappy algorithm so it takes plenty of time. Here's a particularly bad function you could use to ensure inefficiency:
  
  // returns 1 if n is prime, 0 otherwise. int is_prime(int n) { if (n <= 1) { return 0; } for (int k = 2; k < n; k++) { if (n % k == 0) { return 0; } } return 1; }
- Done counting? Print a message to stdout reporting the number of primes <= N.
- End this thread's execution by returning from the thread's main function.
Resolve the problem of the user quitting before all the worker threads are done. We want to allow all threads to complete their work before the main thread exits (either via the exit function or by returning from main()), even after the user has entered Q or q or Ctrl-D.
Don't let Ctrl-C kill the program. Require the user to quit by typing Q or q or Ctrl-D.

NOTE: because the worker threads and the UI thread are all printing to stdout, some users may become confused. For today, we're not going to worry about that.

What to hand in