1. PThreads

2. Shared Memory Model
The logical machine model of a thread-based programming paradigm.

3. POSIX Threads Programming
What is a Thread?
Difference between thread and a process
Why Pthreads?
Shared Memory Model

4. Example programs Example: Pthread Creation and Termination
pthread_create
pthread_exit
Passing Arguments to Threads
use struct
Joining Threads –
pthread_join (threadid, status)

5. Thread Basics: Creation and Termination
Pthreads provides two basic functions for specifying concurrency in a program:
#include <pthread.h>
int pthread_create (
pthread_t *thread_handle,
const pthread_attr_t *attribute,
void * (*thread_function)(void *), void *arg);
The function pthread_create invokes function thread_function as a thread
int pthread_join (pthread_t thread, void **ptr);

6. Thread Termination
There are several ways in which a thread may be terminated:
The thread makes a call to the pthread_exit subroutine.
The entire process is terminated due to making a call to exit()
If main() finishes first, without calling pthread_exit itself
All of the above

7. Synchronization Primitives in Pthreads
When multiple threads attempt to manipulate the same data item, the results can often be incoherent if proper care is not taken to synchronize them.
Consider:
/* each thread tries to update variable best_cost as follows */
if (my_cost < best_cost)
best_cost = my_cost;
Assume that there are two threads, the initial value of best_cost is 100, and the values of my_cost are 50 and 75 at threads t1 and t2.
Depending on the schedule of the threads, the value of best_cost could be 50 or 75!
The value 75 does not correspond to any serialization of the threads.

8. Mutual Exclusion
The code in the previous example corresponds to a critical segment; i.e., a segment that must be executed by only one thread at any time.
Critical segments in Pthreads are implemented using mutex locks.
Mutex-locks have two states: locked and unlocked. At any point of time, only one thread can lock a mutex lock. A lock is an atomic operation.
A thread entering a critical segment first tries to get a lock. It goes ahead when the lock is granted.

9. Mutual Exclusion
The Pthreads API provides the following functions for handling mutex-locks:
int pthread_mutex_lock (
pthread_mutex_t *mutex_lock);
int pthread_mutex_unlock (
int pthread_mutex_init (
pthread_mutex_t *mutex_lock,
const pthread_mutexattr_t *lock_attr);

10. Mutual Exclusion
We can now write our previously incorrect code segment as:
pthread_mutex_t minimum_value_lock;
...
main() {
....
pthread_mutex_init(&minimum_value_lock, NULL); }
void *find_min(void *list_ptr) {
pthread_mutex_lock(&minimum_value_lock);
if (my_min < minimum_value)
minimum_value = my_min;
/* and unlock the mutex */
pthread_mutex_unlock(&minimum_value_lock);

11. Producer-Consumer Using Locks
The producer-consumer scenario imposes the following constraints:
The producer thread must not overwrite the shared buffer when the previous task has not been picked up by a consumer thread.
The consumer threads must not pick up tasks until there is something present in the shared data structure.
Individual consumer threads should pick up tasks one at a time.

12. Producer-Consumer Using Locks
pthread_mutex_t task_queue_lock;
int task_available;
...
main() {
....
task_available = 0;
pthread_mutex_init(&task_queue_lock, NULL); }
void *producer(void *producer_thread_data) {
while (!done()) {
inserted = 0;
create_task(&my_task);
while (inserted == 0) {
pthread_mutex_lock(&task_queue_lock);
if (task_available == 0) {
insert_into_queue(my_task);
task_available = 1;
inserted = 1;
pthread_mutex_unlock(&task_queue_lock);

13. Producer-Consumer Using Locks
void *consumer(void *consumer_thread_data) {
int extracted;
struct task my_task;
/* local data structure declarations */
while (!done()) {
extracted = 0;
while (extracted == 0) {
pthread_mutex_lock(&task_queue_lock);
if (task_available == 1) {
extract_from_queue(&my_task);
task_available = 0;
extracted = 1; }
pthread_mutex_unlock(&task_queue_lock);
process_task(my_task);

14. Deadlock
When two trains approach each other at a crossing, both shall come to a full stop and neither shall start up again until the other has gone.

16. The Deadlock Problem
A deadlock consists of a set of blocked processes, each holding a resource and waiting to acquire a resource held by another process in the set
Example #2
A system has 2 disk drives
P1 and P2 each hold one disk drive and each needs the other one

17. Deadlocks Shared variables: A, B Processor Po Processor P1
// some computation
lock (A)
lock (B)
...

18. Deadlock
Situation where a thread is waiting for an object lock that another thread holds, and
this second thread is waiting for an object lock that the first thread holds
Since each thread is waiting for the other thread to relinquish a lock, they remain waiting forever.

19. Deadlock in Distributed programs
Processor Po
Processor P1
// some computation
get X from P1
get Y from Po
send Y to P1
send X to Po
...

20. Causes of deadlocks Mutual exclusion of shared resources Hold and wait
No preemption
Cyclic wait
For a deadlock, all conditions should be met.

21. Causes of deadlocks
Mutual exclusion of shared resources - Only one process can access a resource at a given time.
Hold and wait - Process already holding a resource can request additional resources, without relinquishing their current resources.
No preemption – One process cannot forcibly remove another process’ resource.
Cyclic wait- Two or more processes form a circular chain where each process is waiting on another resource in the chain.

22. Circular wait There exists a set {P0, P1, …, P0} of waiting
processes such that
P0 is waiting for a resource held by P1,
P1 is waiting for a resource held by P2,
… ,
Pn–1 is waiting for a resource held by Pn,
and Pn is waiting for a resource held by P0

23. Methods for Handling Deadlocks
Prevention - Ensure that the system will never enter a deadlock state
Avoidance- Ensure that the system will never enter an unsafe state
Detection - Allow the system to enter a deadlock state and then recover
Do Nothing Ignore the problem and let the user or system administrator respond to the problem; used by most operating systems, including Windows and UNIX

24. Circular Wait elimination
Impose a total ordering of all resource types, and require that each process requests resources in an increasing order of enumeration.
1 - Card reader; 2 - Printer; 3 - Plotter
4 - Tape drive; 5 ≡ Card punch
Request resource 2 and 4 = valid
Request resource 3 and 2 = invalid