Title: COMP309/509 - Lecture 8 class: middle, center, inverse

COMP309/509 - Parallel and Distributed Computing

Lecture 8 - Multi-Threaded Programming

By Mitchell Welch

University of New England

Reading

Chapters 11 and 12 (section 12.2) from Advanced Programming in the UNIX environment
Assignment 1 Description

Summary

pthread Primatives
pthead Parameter Passing
Thread Models

pthread Primitives

#include <pthread.h>
int  pthread_create(pthread_t  *thread, 
                    pthread_attr_t * attr, 
                    void * (*start_routine)(void *), 
                    void * arg);

Creates a new thread of control that executes concurrently with the calling thread.
- thread is where the TID of the new thread is stored.
- attr is the new thread’s attributes. if you specify NULL the default attributes are used.

pthread Primitives

Continued from last slide:
- start_routine applied to arg is the new thread’s execution sequence.
  - It has type (void )(start_routine)(void *)
  - It is a function that takes a pointer and returns a pointer.
- arg is the address value copied and passed to the thread’s start routine.
  - Its type is (void *) i.e. a pointer to anything.

pthread Primitives

#include <pthread.h>
int pthread_join(pthread_t thread, void *value);

Causes the calling thread to wait for the termination of a specified thread.
Thus it is akin to waitpid().
pthread_join(t,r) suspends the calling thread until the thread identified by t terminates.

pthread Primitives

If r is not NULL, then return value of t is stored in the location pointed to by r.
The return value of t is either:
- the argument it gave to pthread_exit, or
- PTHREAD_CANCELEDif t was cancelled.
At most one thread can wait for the termination of a given thread.

pthread Primitives

#include <pthread.h>
void pthread_exit(void *value);

Makes a return value available to any thread that calls pthread_join and specifies the terminating thread.
Calls some clean-up handlers, and finalisation routines.
Terminates the calling thread.
Note that calling exit is very different from calling pthread_exit!

pthread Primitives

Thread termination does not release any application visible process resources, including, but not limited to, mutexes and file descriptors etc.
pthread_exit does not perform any process level cleanup actions, including, but not limited to, calling atexit() routines that may exist.
An implicit call to pthread_exit() is made when a thread other than the thread in which main() was first invoked returns from the start routine that was used to create it.
The function’s return value serves as the thread’s exit status.

pthread Primitives

Hello World in the World of Threads
OK, let the threading begin, lets do hello world in the world of threads

#include "process.h"
#include "headers.h"
int main(void){
  pthread_t thread_1, thread_2;
  char *msg_1 = "Hello", *msg_2 = "World";
  /* error checking left out for legibility */
  pthread_create(&thread_1, NULL, pr_msg_fn, (void *)msg_1);
  pthread_create(&thread_2, NULL, pr_msg_fn, (void *)msg_2);
  return 0;
}

pthread Primitives

A few points…
- In POSIX threads, the main thread is all important.
- When it exits so does the process, along with any threads that may still be chugging away!
If we run this program, we may actually not see any output. Why?
Well the explanation is simple, exit is a process primitive.
It kills the process, and consequently the threads inside.

pthread Primitives

So will a return from the main thread.
We could try replacing the exit with a sleep.
This wouldn’t necessarily work!
- In some Unixes sleep is process primitive!!
- It would merely make the whole process, including the threads inside, sleep for a while.
In some Unixes it isn’t clear!
Do man 3 sleep on a Linux machine, and then look at sleep in the standard.

pthread Primitives

We can use pthread_join to sort this out:

#include "process.h"
#include "headers.h"
int main(void){
  pthread_t thread_1, thread_2;
  char *msg_1 = "Hello", *msg_2 = "World";
  /* error checking left out for legibility */
  pthread_create(&thread_1, NULL, pr_msg_fn, (void *)msg_1);
  pthread_create(&thread_2, NULL, pr_msg_fn, (void *)msg_2);
  pthread_join(thread_1,NULL);
  pthread_join(thread_2,NULL);
  fprintf(stderr, "\n");
  return 0; 
}

pthread Primitives

Making and managing a number of threads:

#include "process.h"
#include "headers.h"
int main(void){
  int i;
  pthread_t threads[2];
  char *msgs[] = {"Hello", "World"};
  /* error checking left out for legibility */
  for(i = 0; i < 2 ; i++)
    pthread_create(&threads[i], NULL, pr_msg_fn, (void *)msgs[i]);
  for(i = 0; i < 2 ; i++)
    pthread_join(threads[i],NULL);
  fprintf(stderr, "\n");
  return 0; 
}

pthread Parameter Passing

In the following example we show:
- How to create a thread
- How to pass complex stuff in (In general the struct could be huge)
- How threads can share variables and update them (local)
- How to wait for the thread
- How to get stuff back out from the thread using the pthread_join’s second argument.

pthread Parameter Passing

For starters we need some structs to store things:

#include "headers.h"
/* error checking left out for legibility */
/* stuff to pass into thread */
typedef struct thread_arg {
  int* id;
  char* str;
  float cost; } arg_t;
/* stuff thread returns      */
typedef struct thread_val {
  int id;
  float cost; } val_t;

pthread Parameter Passing

A thread entry point function that processes something:

void *entry_point(void *arg){
  arg_t input;
  val_t *output;
  input = *((arg_t *)arg);
  output = (val_t *)malloc(sizeof(val_t));
  fprintf(stderr, input.str, *input.id, input.cost);
  (*input.id)++;
  output->id   = *input.id;
  output->cost = input.cost * (*input.id);
  pthread_exit(output); 
}

pthread Parameter Passing

…And, of course, a main function:

int main(int argc,  char *argv[]){
  pthread_t thread_id;
  arg_t     thread_arg;
  val_t     *thread_val;
  int       local = 7;
  char str[] = "Me be threaded: %d %f!!\n";
  fprintf(stderr, "local is now = %d\n", local);
  thread_arg.id = &local;
  thread_arg.str = str;
  thread_arg.cost = 3.14;
  pthread_create(&thread_id,NULL,entry_point, &thread_arg);
  pthread_join(thread_id,(void **)&thread_val);
  fprintf(stderr,
          "the thread produced: %d  %f\n", 
          thread_val->id,
          thread_val->cost);
  fprintf(stderr, "local is now = %d\n", local);
  exit(EXIT_SUCCESS); 
}

pthread Parameter Passing

So now we have created a single thread and passed in/out some data for processing in entry_point
Lets elaborate and create a program that uses a fixed (known) number of threads.

pthread Parameter Passing

Define our number of threads and some structs to store things.

#include "headers.h"
/* error checking left out for legibility */
/* size of thread bevy       */
#define TH_NO  10
/* stuff to pass into thread */
typedef struct thread_arg {
  int id;
  float cost; } arg_t;
/* stuff thread returns      */
typedef struct thread_val {
  int id;
  float cost; } val_t;

pthread Parameter Passing

Our thread entry point (And supporting function):

void *entry_point(void *arg){
  arg_t input;
  val_t *output;
  announce();
  input = *((arg_t *)arg);
  output = (val_t *)malloc(sizeof(val_t));
  output->id   = input.id;
  output->cost = input.cost * input.id;
  pthread_exit(output); }

void announce(void){
  fprintf(stderr, 
      "Thread %lu of Process %ld with Parent  %ld\n", 
      (unsigned long int)pthread_self(), (long)getpid(), (long)getppid());
}

pthread Parameter Passing

…And, of course, a main function:

int main(int argc,  char *argv[]){
  int i;
  pthread_t thread_ids[TH_NO];
  arg_t     thread_args[TH_NO];
  val_t     *thread_vals[TH_NO];
  announce();
  for(i = 0; i < TH_NO; i++){
    thread_args[i].id = i;
    thread_args[i].cost = 3.14;
  }
  ...

pthread Parameter Passing

...
  for(i = 0; i < TH_NO; i++){
    pthread_create(&thread_ids[i], NULL, entry_point, &thread_args[i]);
  }
  for(i = 0; i < TH_NO; i++)
    pthread_join(thread_ids[i],(void **)&thread_vals[i]);
  for(i = 0; i < TH_NO; i++)
    fprintf(stderr,
            "Thread %d produced: %d  %f\n", 
            i,
            thread_vals[i]->id,
            thread_vals[i]->cost);
  exit(EXIT_SUCCESS); 
}

pthread Parameter Passing

Some pitfalls:

for(i = 0; i < TH_NO; i++)
    pthread_create(&thread_ids[i],NULL,entry_point,(void *)&i);

This will cause you quite a bit of grief.Why??
The motto is be careful with what you pass into and out of a thread. (i is changing in the loop)
Make sure that it:
- Will live long enough(i.e. not be created on the stack of a function that is about to exit)
- Stay what you want it to be long enough (i.e see the first point.)

Thread Models

There are three recognised models for implementing at the processor level:
1:1 - kernel-level threading: In this apprach, each thread to a single shedulable entity in the kernel (one thread per kernel-level process)
N:1 - user-level threading: In this approach, all threads map to a single entity in the kernel.
M:N - hybrid threading : In this appraoch, M threads map to N processes.
The basic distiction is The basic distinction is who schedules the thread, and who does it compete with for other resources.

Thread Models

How many threads can we make in Linux Threads?
Each thread is a process (Due to the kernel-level threading), hence 2048 is a hard limit.
Though half that is probably the default.
Try the limit command (tcsh) or ulimit (bash).

Thread Models

Linux Threads contains a table of all active threads.
This table has room for 1024 threads at most.
To increase this limit, you must change PTHREAD_THREADS_MAX in the Linux Threads/glibc sources and recompile.
Finally, the Linux kernel contains many algorithms that run in time proportional to the number of process table entries.
Increasing this number drastically will slow down the kernel operations noticeably.

Thread Models

How man threads can we make in NPTL?
NPTL has no hard coded thread limits!
PTHREAD_THREADS_MAX is not defined - it’s not a POSIX requirement.
There are however other limiting factors.
The stack size can be a limiting factor.
Changing the stack size will change the number of threads that can be created.

Summary

pthread Primatives
pthead Parameter Passing
Thread Models

class: middle, center, inverse

Questions?

Reading

Chapters 11 and 12 (section 12.2) from Advanced Programming in the UNIX environment
Assignment 1 Description