CS 3733 Operating Systems Notes: USP Chapter 12 - Threads

Overview: threads vs. processes (created with fork)

Property	Processes created with fork	Threads of a process	Ordinary function calls
variables	get copies of all variables	share global variables	share global variables
IDs	get new process IDs	share the same process ID but have unique thread ID	share the same process ID (and thread ID)
Communication	Must explicitly communicate, e.g.pipes or use small integer return value	May communicate with return value or shared variables if done carefully	May communicate with return value or shared variables (don't have to be careful)
Parallelism (one CPU)	Concurrent	Concurrent	Sequential
Parallelism (multiple CPUs)	May be executed simultaneously	Kernel threads may be executed simultaneously	Sequential

Look at the programs getsizeschild, getsizesthread and getsizescall.

USP Chapter 12: POSIX Threads:

Motivating problem: monitor multiple file descriptors:

Methods you should know about:

• separate processes
• select

• poll
• nonblocking I/O
• asynchronous I/O
• threads

• address space: code and global variables
• open files
• semaphores
• signals
• timers
• process ID

Consider a function processfd called as an ordinary function and as a created thread.

Figure 12.1 (page 412): Program that makes an ordinary call to processfd has a single thread of execution.

Figure 12.2 (page 412): Program that creates a new thread to execute processfd has two threads of execution.

A function that is used as a thread must have a special format.
It takes a single parameter of type pointer to void and returns a pointer to void.

The parameter type allows any pointer to be passed.
This can point to a structure, so in effect, the function can use any number of parameters.
We will discuss the meaning of the return value later.

The processfd function used above might have prototype:
void *processfd(void *arg);
Instead of passing the file descriptor to be monitored directly, we pass a pointer to it.
The function my access the parameter as follows:
       int fd;
       fd = *((int *)arg);

Creating a thread:

   void *processfd(void *arg);

   int error;
   int fd;
   pthread_t tid;

   if (error = pthread_create(&tid, NULL, processfd, &fd))
      fprintf(stderr, "Failed to create thread: %s\n", strerror(error));

Program 12.2, monitorfd.c is a function that creates threads to monitor an array of open file descriptors.
The function is passed an array of file descriptors and the size of the array.
For each file descriptor it creates a thread and then waits for all of the threads to complete.

12.3 Thread Management

Most POSIX functions return 0 on success and a nonzero error code on failure.
They do not set errno but the value returned when an error occurs has the value that errno would have.
None of the POSIX thread functions ever return the error EINTR.

Most of the pthread functions are declared in pthread.h.

12.3.1 The Thread ID
Each thread has an id of type pthread_t.
On most systems this is just an integer (like a process ID) but it does not have to be.

A thread can get its ID with pthread_self and IDs can be compared with pthread_equal

    pthread_t pthread_self(void);
    int pthread_equal(thread_t t1, pthread_t t2);

12.3.2 Creating a thread
A thread is created with pthread_create

   int pthread_create(pthread_t *restrict thread,
                      const pthread_attr_t *restrict attr,
                      void *(*start_routine)(void *), void *restrict arg);

• The creating process (or thread) must provide a location for storage of the thread id.
• We will discuss thread attributes later.
  For now, pass a null pointer to indicate the default attributes.
• The third parameter is just the name of the program for the thread to run.
• The last parameter is a pointer to the arguments.

12.3.3 Detaching and joining

• A thread exits when its function returns.
  There are other ways for a thread to exit.
• Just like with processes, some of the threads resources stay around until it has been waited for or its process terminates.
• You wait for a thread with pthread_join.
• You can make a thread release its resources when it terminates by making it a detached thread.
• A detached thread cannot be joined.
• One way to make a thread detached is with pthread_detach

   int pthread_detach(pthread_t thread);

   void *processfd(void *arg);

   int error;
   int fd
   pthread_t tid;

   if (error = pthread_create(&tid, NULL, processfd, &fd))
      fprintf(stderr, "Failed to create thread: %s\n", strerror(error));
   else if (error = pthread_detach(tid))
      fprintf(stderr, "Failed to detach thread: %s\n", strerror(error));

   void *detachfun(void *arg) {
      int i = *((int *)(arg));
      if (!pthread_detach(pthread_self())) 
         return NULL;
      fprintf(stderr, "My argument is %d\n", i);
      return NULL;
   }

• A thread can pass a value to another thread through its return value.
• This is something like the return value that a parent gets from its child through its exit status.
• You are not restricted to a small integer as with processes.
• The return value is a pointer to arbitrary data.
• Since the threads all share an address space, this is simple to do.
• However, you must take care. Examples later.
• The pthread_join function suspends the calling function until a specific thread has completed.
• There is no way to join the first of several threads that have completed.

   int pthread_join(pthread_t thread, void **value_ptr);

   int error;
   int *exitcodep;
   pthread_t tid;

   if (error = pthread_join(tid, &exitcodep))
      fprintf(stderr, "Failed to join thread: %s\n", strerror(error));
   else
      fprintf(stderr, "The exit code was %d\n", *exitcodep);

12.3.4 Exiting and Cancellation
A process can terminate when:

• it calls exit directly
• one of its threads calls exit
• it executes return from main
• it receives a signal

When a thread is done, it can call return from its main function (the one used by pthread_create) or it can call pthread_exit

   void pthread_exit(void *value_ptr);

   int pthread_cancel(pthread_t thread);

Stop here for now ...

The result of the request depends on the target thread's type and state.

The possible states are

• PTHREAD_CANCEL_ENABLE
• PTHREAD_CANCEL_DISABLE

A thread can change its state with:

   int pthread_setcancelstate(int state, int *oldstate);

Program 12.3, processfdcancel, goes into the disable state while it is executing docommand.

The possible cancellation types are

• PTHREAD_CANCEL_ASYNCHRONOUS: act on requests at any time
• PTHREAD_CANCEL_DEFERRED: at on request only at cancellation points

   int pthread_setcanceltype(int type, int *oldtype);
   void pthread_testcancel(void);

12.3.5 Passing parameters and returning values
You can pass multiple parameters to a thread by passing a pointer, such as an array, to the thread when it is created.

Care must be taken in receiving return values.

• The terminating thread passes a pointer to the joining thread.
• They share the same address space.
• The return value must exist after the thread terminates.
• You cannot use an automatic variable in the thread for the return value.

• It opens the source and destination.
• It passes the file descriptors in an array of two integers.
• The thread is called copyfilemalloc.
• The return value of the thread is a pointer to an int containing the number of bytes copied.

Where is the number of bytes copied stored?
It cannot be in an automatic variable in copyfilemalloc.
copyfilemalloc calls malloc to create space for the value.
The calling program must free this space if it is going to run for a long time.

Look at Program 12.5, copyfilemalloc

An alternate is for the creating thread to allocate the space for the return value and tell the thread where this is (using the thread parameter).

Program 12.6, callcopypass passes an array of 3 integers to the created thread.
The thread stores the return value in the last entry of the array.

Look at Program 12.6 and Program 12.7, copyfilepass

We could have used an array of size 2.

When creating multiple threads that are to be joined, you must

• Store the thread IDs in different locations
• Not reuse the location used for the parameter until you are sure the thread has copied it.

• Takes two parameters that are strings, infile and outfile and an integer, n.
• Will copy
  infile.1 to outfile.1
  infile.2 to outfile.2
  infile.3 to outfile.3
  etc., for a total of n files.
• A thread is created for each file copy.
• Uses the thread copyfilepass from Program 12.7.
• Look at how this handles errors so that it does not wait for threads that were not created.

Look at program 12.9, badparameters.
This program creates a number of threads, passing a pointer to the loop index as a parameter.

Exercise 12.14: What can you return from this thread:

void *whichexit(void *arg) {
   int n;
   int np1[1];
   int *np2;
   char s1[10];
   char s2[] = "I am done";
   n = 3;
   np1[0] = n;
   np2 = (int *)malloc(sizeof(int));
   *np2 = n;
   strcpy(s1, "Done");
   return(NULL);
} 

1. n
2. &n
3. (int *)n
4. np1
5. np2
6. s1
7. s2
8. "This works"
9. strerror(EINTR)

Cancellation Points

No other POSIX functions are allowed to introduce cancellation points

12.4 Thread Safety

Almost all system functions and library functions are safe to use with threads.

The exceptions are given in the following table.

12.5 User Threads and Kernel Threads

User-level threads run on top of an operating system.

• Threads are invisible to the kernel.
• Link to a special library of system calls that prevent blocking
• Have low overhead
• CPU-bound threads can block other threads
• Can only use one processor at a time.

• Kernel can schedule threads like it does processes.
• Multiple threads of a process can run simultaneously on multiple CPUs.
• Synchronization more efficient than for processes but less than for user=level threads.

Figure 12.3 (page 433) User-level threads.

Figure 12.4 (page 434) Kernel-level threads.

With a hybrid model, the threads of a process can share several kernel entities.

Figure 12.5 (page 435) A hybrid model.

POSIX threads can support any of these models.

A thread has a contentionscope of PTHREAD_SCOPE_PROCESS or PTHREAD_SCOPE_SYSTEM.

One or both can be supported on a given system.

Thread Attributes

Attributes behave like objects that can be created or destroyed.

• Create an attribute object (initialize it with default properties).
• Modify the properties of the attribute object.
• Create a thread using the attribute object.
• The object can be changed or reused without affecting the thread.
• The attribute object affects the thread only at the time of thread creation.

   int pthread_attr_destroy(pthread_attr_t *attr);
   int pthread_attr_init(pthread_attr_t *attr);

12.6.1 The thread state
The state is either PTHREAD_CREATE_JOINABLE (the default) or PTHREAD_CREATE_DETACHED.

  int pthread_attr_getdetachstate(const pthread_attr_t *attr,
                                  int *detachstate);
  int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

   int error, fd;
   pthread_attr_t tattr;
   pthread_t tid;

   if (error = pthread_attr_init(&tattr))
      fprintf(stderr, "Failed to create attribute object: %s\n",
                       strerror(error));
   else if (error = pthread_attr_setdetachstate(&tattr,
                    PTHREAD_CREATE_DETACHED))
      fprintf(stderr, "Failed to set attribute state to detached: %s\n",
              strerror(error));
   else if (error = pthread_create(&tid, &tattr, processfd, &fd))
      fprintf(stderr, "Failed to create thread: %s\n", strerror(error));

The thread stack
You can set a location and size for the thread stack.

  int pthread_attr_getstack(const pthread_attr_t *restrict attr,
           void **restrict stackaddr, size_t *restrict stacksize);
  int pthread_attr_setstack(pthread_attr_t *attr,
           void *stackaddr, size_t stacksize);

  int pthread_attr_getguardsize(const pthread_attr_t *restrict attr,
                            size_t *restrict guardsize);
  int pthread_attr_setguardsize(pthread_attr_t *attr,
                            size_t guardsize);

12.6.3 Thread scheduling
The contentionscope can be PTHREAD_SCOPE_PROCESS or PTHREAD_SCOPE_SYSTEM.

The scope determines whether the thread competes with other threads of the process or with other processes in the system.

  int pthread_attr_getscope(const pthread_attr_t *restrict attr,
                            int *restrict contentionscope);
  int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope);

Example 12.16: create a thread that contends with other processes

   int error;
   int fd;
   pthread_attr_t tattr;
   pthread_t tid;

   if (error = pthread_attr_init(&tattr))
      fprintf(stderr, "Failed to create an attribute object:%s\n",
              strerror(error));
   else if (error = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM))
      fprintf(stderr, "Failed to set scope to system:%s\n",
              strerror(error));
   else if (error = pthread_create(&tid, &tattr, processfd, &fd))
      fprintf(stderr, "Failed to create a thread:%s\n", strerror(error));

Inheritance of scheduling policy:
With PTHREAD_INHERIT_SCHED the scheduling attributes of the attribute object are ignored and the created thread has the same scheduling attributes of the creating thread.
With PTHREAD_EXPLICIT_SCHED the scheduling is taken from the attribute.

  int pthread_attr_getinheritsched(const pthread_attr_t *restrict attr,
                            int *restrict inheritsched);
  int pthread_attr_setinheritsched(pthread_attr_t *attr,
                            int inheritsched);

Scheduling parameters and policy. Typical scheduling policies are SCHED_FIFO, SCHED_RR> and SCHED_OTHER.
What is supported is system dependent.
Each policy is modified by scheduling parameters stored in a struct sched_param
This may contain a priority or a quantum value.

  int pthread_attr_getschedparam(const pthread_attr_t *restrict attr,
                            struct sched_param *restrict param);
  int pthread_attr_setschedparam(pthread_attr_t *restrict attr,
                            const struct sched_param *restrict param);
  int pthread_attr_getschedpolicy(const pthread_attr_t *restrict attr,
                                 int *restrict policy);
  int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);