Presentation on

Multi-Threading & POSIX Thread APIs

By DIPAK K. SINGH
dipak123@gmail.com / dipak123@yahoo.com

 
Version 1.0 dated 18 January 2013.

Navigation

Use mouse click, keyboard and swipe ( in touch device) to navigate.

Slides have been arranged horizontally. Use left and right to navigate.
Few slides have additional slides arranged vertically. Use up and down to navigate them. Up/Down arrow of navigate icon gets highlighted for those slides.

Contents

Section A

Multi-Threading

Life Cycle of Thread

Life cycle of a thread is very similar to sequencial application (single threaded application). Fundamental states of a thread is same as single threaded application.

Resource Sharing

All threads of an application see same memory image. Therefore, context switch between threads of the application is very fast. All other resources of application such as open file, socket etc. are also visible to all threads.

Though, all threads see entire memory of the application but some memory is made local to a thread in cooperative manner to enable independent stream of execution. Such data are Thread Id, Stack, Signal mask etc.

Synchronisation

Synchronisation enables multiple thread to coordinate their activities. Synchronisation is required for

   1. Data access and
   2. Thread synchronisation

Synchronisation

pthread part of presentation contains examples of mutex ( synchronised access of data using API pthread_mutex) and join ( thread joining using API pthread_join).

Operating System Aware Threads

Programmers creates threads in an application. Threads can be implemented in library such that operating system is unaware of threads. In such a situation, multiple cores/CPUs cannot be used by the application.

Trend now a days is to map programmers' thread to kernel level threads. Operating system allocates one or more kernel threads to an application depending on active threads created by the programmer.

Kernel level threads are scheduled on CPUs/cores to run the application. Parallel processing is possible in this model.

Operating System Aware Threads - Mapping

Mapping between Programmer's Thread and Kernel Level Threads can take place in 1x1 , MxN or any other manner. 1x1 mapping is the most common as shown in first and second processes from left in the diagram below..

Section B

POSIX Thread APIs

POSIX Thread

POSIX Thread, commonly known as pthread, is a very popular C library which provides thread support to programming languages C and C++.

C++ programmers prefer boost::thread which is mainly a C++ wrapper over pthreads.

C++11 supports thread as part of standard library (std::thread). C++11 thread is gaining popularity but still quite less in installed base compared to pthread being very new (released in 2011). Boost and C++11 are out of scope of this presentation.

POSIX Thread

pthread refers to thread section of POSIX ( Portable Operating System Interface) Specification by http://opengroup.org . It has been accepted by IEEE as 1003.1 2013 specification. pthread does not include implementation. Platform vendors and third party are free to implement pthread specification.

pthread is an C library code.

Thread Start and End

A thread is created by pthread_create() . A function is associated to pthread_create() to act as start routine (starting point) for the thread.

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

Thread ends when it returns from start_routine, calls pthread_exit() to terminate itself or cancelled by other thread.

A thread can wait for another thread to end by calling pthread_join().

Thread Termination

A thread terminates in any one of three ways

When process starts, a thread is automatically created for main(). This thread is called Main Thread. Main thread can also be terminated by pthread_exit() or cancelled. However, return from main() terminates process not main thread.

Exit status of thread can be captured by pthread_join(pthread_t thread, void **exit_status_ptr).

It is possible to register cleanup functions to thread. Those registered functions are called as part of thread termination.

Process Termination

A multi-threaded process terminates in any one of four ways

Point 3 is a case added by pthread. Other three cases are pthread independent and applicable to both sequential and multi-threaded application in exactly same manner.

Thread Cancellation

A thread can be cancelled by another thread of the same process. The recipient thread is cancellation immediately or at Cancellation Point as per setup.

int pthread_setcancelstate(int state, int *oldstate); 
					

Values of state are:
     PTHREAD_CANCEL_DEFERRED ( cancel at cancellation point) and
     PTHREAD_CANCEL_ASYNCHRONOUS ( cancel immediately).

Cancellation can be disabled too.

int pthread_setcanceltype(int type, int *oldtype);
					

Values of type are:
     PTHREAD_CANCEL_DISABLE and
     PTHREAD_CANCEL_ENABLE .
In PTHREAD_CANCEL_DISABLE mode, cancellation request received is deferred till cancelability is enabled.

Thread Cancellation Points

Cancellation Points are points in code where cancellation can take place. They are:

1. Some of standard library calls, not all. Example is fopen()
2. Some of pthread library calls, not all. Example is pthread_join()
3. Explicit call of pthread_cancell()

Cancellation point ensures that thread does not get abruptly terminated. When a thread is cancelled, all regular cleanups are performed as if thread terminated normally.

Thread Specific Data

Thread specific data (TSD) is a global data for the thread. Values changed in TSD by one thread does not impact TSD of other threads.

How to use?

A variable of pthread data type pthread_key_t is created. This variable is a regular data type which must be visible to all threads. TSD is associated to variable of pthread_key_t . Look at the example below.

pthread_key_t thSpecificGlobal;

void setValue(char *str) {
	// Each thread associates its value
	pthread_set_specific(thSpecificGlobal, str);
}

char* getValue() {
	// Value saved by this thread is returned.
	return (char*)pthread_get_specific(thSpecificGlobal);
}					

Usually variable of pthread_key_t is global but not mandatory.

pthread mutex

pthread mutex can be used for synchronised access of shared data. Only one thread operates on protected data at a time.

Initialisation of mutex

pthread_mutex_t mutex_obj;
int main() {
	pthread_mutex_init(&mutex_obj);   // One time init
	... // use mutex
	pthread_mutex_destroy(&mutex_obj); // Destroy at end
}
					

Use of mutex for synchronised access

int update_record() {
	pthread_mutex_lock(&mutex_obj);     // Request mutex
	/* Only one threads runs at a time
	 * in this part of the code */
	pthread_mutex_unlock(&mutex_obj); // Release mutex
}
					

Linux top

Kernel level threads created for the multi-threaded process can be seen in Linux. Specify option '-L' to UNIX command 'top' .

$ ps -Lf -u dipak
UID    PID PPID  LWP  C NLWP STIME TTY     CMD
dipak  190  189  190  0    1 Apr20 pts/5   /bin/bash
dipak  757  615  757  0    3 13:36 pts/7   simple_example
dipak  757  615  758  0    3 13:36 pts/7   simple_example
dipak  757  615  759  0    3 13:36 pts/7   simple_example
dipak  760  477  760  1    1 13:36 pts/4   ps -fL -u
$
					

For process 757, three kernel level threads were created . Ids are 757, 758 and 759 shown in LWP column.

LWP stands for light weight process which can be considered exactly similar to kernel level thread in context of multi-threaded applications.

LWP details are available at /proc<LWP Id>/ .

References

1. The Open Group Base Specifications Issue 7 / IEEE Std 1003.1, 2013 Edition at pubs.opengroup.org . Login required.

2. Multithreaded Programming Guide. Primarily for Solaris but useful on others platforms too. It covers both pthread and native Solaris thread docs.oracle.com .

3. PThreads Primer - A Guide to Multithreaded Programmig. PDF book by Bil Lewis & Daniel J. Berg. Published long back but still quite useful. POSIXMultithreadProgrammingPrimer.pdf

4. Tutorial on Java - Multithreading www.tutorialspoint.com .

5. C++11 Concurrency, Part 1 www.youtube.com/watch?v=80ifzK3b8QQ ( 1st of series of 9 videos. 20-30 minutes each video ).

End of the Presentation
on
Multi-Threading

For any feedback or clarification, contact dipak123@gmail.com or dipak123@yahoo.com .