Computer Science 400
Parallel Processing and High Performance Computing

Fall 2017, Siena College

Lab 10: Introduction to pthreads
Due: 11:59 PM, Friday, October 20, 2017

In this lab, we will begin to consider another major paradigm for parallelism: multithreading. So far, we have been working with message passing. In that case, each process has its own private address space. That is, each process has its own variables and any information to be exchanged among processes needs to be done with explicit message passing. Multithreading usually allows for the use of shared memory. Many operating systems provide support for threads, and a standard interface has been developed: POSIX Threads or pthreads.

You may work alone or with a partner on this lab.

Getting Set Up

You will receive an email with the link to follow to set up your GitHub repository pthreads-yourgitname for this Lab. One member of the group should follow the link to set up the repository on GitHub, then that person should email the instructor with the other group members' GitHub usernames so they can be granted access. This will allow all members of the group to clone the repository and commit and push changes to the origin on GitHub. At least one group member should make a clone of the repository to begin work.


Before starting, read through Pacheco Sections 4.1 and 4.2.

pthreads Basics

The basic idea is that we can create and destroy threads of execution in a program, on the fly, during its execution. These threads can then be executed in parallel by the operating system scheduler. If we have multiple processors, we should be able to achieve a speedup over the single-threaded equivalent.

We start with a look at a pthreads "Hello, world" program, which is in the pthreadhello directory of your repository for this lab.

The most basic functionality involves the creation and destruction of threads:

Prototypes for pthread functions are in pthread.h and programs need to link with libpthread.a (use -lpthread at link time).

Any global variables in your program are accessible to all threads. Local variables are directly accessible only to the thread in which they were created, though the memory can be shared by passing a pointer as part of the last argument to pthread_create().

Practice Program: Create a new version of the pthreadhello.c program in a file pthreadhello-more.c that takes a command-line parameter that specifies the number of threads to create. This is very similar to what you see in Pacheco Program 4.1, except we will pass pointers to an array of numbers 1 through n as the thread parameter as is done in the 2-thread version. (10 points)

A slightly more interesting example is in proctree_threads.

This example builds a "tree" of threads to a depth given on the command line. It includes calls to pthread_self(). This function returns the thread identifier of the calling thread.

Try it out and study the code to make sure you understand how it works.

Question 1: What is the output when you run the program for a tree of depth 3 on noreaster? (1 points)

Question 2: How many calls are made to the split_proc function for a tree of depth n? (3 points)

Question 3: What is the largest tree you can create on noreaster before you start to get thread creation errors? (1 point)

Multithreaded Pi

Practice Program: Write a pthread version of the Monte Carlo approximation of pi. Call your program pthread_pi.c. See below for some tips. (20 points)


Your submission requires that all required deliverables are committed and pushed to the master for your repository on GitHub.


This assignment is worth 35 points, which are distributed as follows:

> FeatureValueScore
pthreadhello-more.c 10
Lab Question 1 1
Lab Question 2 3
Lab Question 3 1
pthread-pi.c 20
Total 35