Pthreads: A shared memory programming model - PowerPoint PPT Presentation

1 / 36
About This Presentation
Title:

Pthreads: A shared memory programming model

Description:

a.out creates a number of threads that can be scheduled and run concurrently. ... Producers and consumers run in separate threads. ... – PowerPoint PPT presentation

Number of Views:185
Avg rating:3.0/5.0
Slides: 37
Provided by: xyu
Category:

less

Transcript and Presenter's Notes

Title: Pthreads: A shared memory programming model


1
Pthreads A shared memory programming model
  • POSIX standard shared memory multithreading
    interface.
  • Not just for parallel programming, but for
    general multithreaded programming
  • Provide primitives for thread management and
    synchronization.
  • Threads are commonly associated with shared
    memory architectures and operating systems.
  • Necessary for unleashing the computing power of
    SMT and CMP processors.
  • Making it easy and efficient is very important at
    this time.

2
Pthreads execution model
  • A single process can have multiple, concurrent
    execution paths.
  • a.out creates a number of threads that can be
    scheduled and run concurrently.
  • Each thread has local data, but also, shares the
    entire resources (global data) of a.out.
  • Any thread can execute any subroutine at the same
    time as other threads.
  • Threads communicate through global memory.

3
Fork-join model for executing threads in an
application
Master thread
Fork
Parallel region
Join
4
What does the developer have to do?
  • Decide how to decompose the computation into
    parallel parts.
  • Create and destroy threads to support the
    decomposition
  • Add synchronization to make sure dependences are
    covered.

5
Creation
  • Thread equivalent of fork()
  • int pthread_create(
  • pthread_t thread,
  • pthread_attr_t attr,
  • void (start_routine)(void ),
  • void arg
  • )
  • Returns 0 if OK, and non-zero (gt 0) if error.
  • Start_routine is what the thread will execute.

6
Termination
  • Thread Termination
  • Return from initial function.
  • void pthread_exit(void status)
  • Process Termination
  • exit() called by any thread
  • main() returns

7
Waiting for child thread
  • int pthread_join( pthread_t tid, void status)
  • Equivalent of waitpid()for processes

8
Detaching a thread
  • The detached thread can act as daemon thread
  • The parent thread doesnt need to wait the tid
    storage is reclaimed when the thread is done.
  • Mainly to save space.
  • int pthread_detach(pthread_t tid)
  • Detaching self
  • pthread_detach(pthread_self())

9
Example of thread creation
10
General pthread structure
  • A thread is a concurrent execution of a function
  • The threaded version of the program must be
    restructured such that the parallel part forms a
    separate function.
  • See example1.c, example2.c

11
Matrix Multiply
  • For (I0 Iltn I)
  • for (j0 jltn j)
  • cIj 0
  • for (k0 kltn k)
  • cIj cIj aIk
    bkj

12
Parallel Matrix Multiply
  • All I- or j-iterations can be run in parallel
  • If we have p processors, n/p rows to each
    processor
  • Corresponds to partitioning I-loop

13
Matrix Multiply parallel part
  • void mmult(void s)
  • int slice (int ) s
  • int from slice n / p
  • int to ((slice 1)n/p)
  • for (Ifrom Iltto I)
  • for (j0 jltn j)
  • cIj 0
  • for (k0 kltn k)
  • cIj aIkbkj
  • In the parallel version
  • We will need to know
  • Number of threads (p)
  • My ID mmult has a parameter for myid.

14
Matrix Multiply Main (See mm_pthread.c)
  • Int main()
  • pthread_t thrdp
  • int parap
  • for (I0 Iltp I)
  • paraI I / why do we need this? /
  • pthread_create(thrdI, NULL, mmult,
    (void )paraI)
  • for (Ifrom Iltto I)
  • pthread_join(thrdI, NULL)

15
General Program Structure
  • Encapsulate parallel parts in functions.
  • Use function arguments to parametrize what a
    particular thread does.
  • Call pthread_create() with the function and
    arguments, save thread identifier returned.
  • Call pthread_join() with that thread identifier

16
Pthreads synchronization
  • Create/exit/join
  • Provides coarse grain synchronizations
  • Requires thread creation/destruction
  • Need for finer-grain synchronization
  • Mutex locks, condition variables, semaphores

17
Pthread synchronization
  • Mutex
  • Conditional variables

18
Thread synchronization
  • Most of threaded programs have threads that
    interact with one another.
  • Interaction in the form of sharing access to
    variables.
  • Multiple concurrent reads (ok)
  • Multiple concurrent writes (not ok, outcome
    non-deterministic)
  • One write, multiple reads (not ok, outcome
    non-deterministic)
  • Needs to make sure that the outcome is
    deterministic.
  • Synchronization allowing concurrent accesses to
    variables, removing non-deterministic outcome by
    enforcing the order of thread execution.

19
Thread synchronization
  • Typical types of synchronizations.
  • Mutual exclusion (mutex in pthread)

Thread 2 insert B to tree
Thread 1 insert A to tree
Thread 2 lock(tree) insert A to tree
unlock(tree)
Thread 1 lock(tree) insert A to tree
unlock(tree)
20
Thread synchronization
  • Signal (ordering the execution of threads,
    condition variable)

Thread 1 Thread 2
Thread 3 for (i0 ilt25
i) for (i25 ilt50 i) for
(i50 ilt75i) a(i1) a(i)1
a(i1) a(i) 1 a(i1)
a(i)1
Thread 1 Thread 2
Thread 3 for (i0 ilt25
i) a(i1) a(i)1
signal a(25) ready
wait for a(25) ready
for(i25ilt50i)
a(i1)
a(i)1
signal a(50) ready

wait for a(50) ready


21
Mutex lock for mutual exclusion
  • int counter 0
  • void thread_func(void arg)
  • int val
  • / unprotected code why? /
  • val counter
  • counter val 1
  • return NULL

22
Mutex locks lock
  • pthread_mutex_lock(pthread_mutex_t mutex)
  • Tries to acquire the lock specified by mutex
  • If mutex is already locked, then the calling
    thread blocks until mutex is unlocked.

23
Mutex locks unlock
  • pthread_mutex_unlock(pthread_mutex_t mutex)
  • If the calling thread has mutex currently locked,
    this will unlock the mutex.
  • If other threads are blocked waiting on this
    mutex, one will unblock and acquire mutex.
  • Which one is determined by the scheduler.

24
Mutex example (See example3.c, example4.c)
  • int counter 0
  • ptread_mutex_t mutex PTHREAD_MUTEX_INITIALIZER
  • void thread_func(void arg)
  • int val
  • / protected by mutex /
  • Pthread_mutex_lock( mutex )
  • val counter
  • counter val 1
  • Pthread_mutex_unlock( mutex )
  • return NULL

25
Condition Variable for signaling
  • Think of Producer consumer problem
  • Producers and consumers run in separate threads.
  • Producer produces data and consumer consumes
    data.
  • Producer has to inform the consumer when data is
    available
  • Consumer has to inform producer when buffer space
    is available

26
Condition variables wait
  • Pthread_cond_wait(pthread_cond_t cond,
    pthread_mutex_t mutex)
  • Blocks the calling thread, waiting on cond.
  • Unlock the mutex
  • Re-acquires the mutex when unblocked.

27
Condition variables signal
  • Pthread_cond_signal(pthread_cond_t cond)
  • Unblocks one thread waiting on cond.
  • The scheduler determines which thread to unblock.
  • If no thread waiting, then signal is a no-op

28
Producer consumer program without condition
variables
29
  • / Globals /
  • int data_avail 0
  • pthread_mutex_t data_mutex PTHREAD_MUTEX_INITIAL
    IZER
  • void producer(void )
  • Pthread_mutex_lock(data_mutex)
  • Produce data
  • Insert data into queue
  • data_avail1
  • Pthread_mutex_unlock(data_mutex)

30
  • void consumer(void )
  • while( !data_avail )
  • / do nothing keep looping!!/
  • Pthread_mutex_lock(data_mutex)
  • Extract data from queue
  • if (queue is empty)
  • data_avail 0
  • Pthread_mutex_unlock(data_mutex)
  • consume_data()

31
Producer consumer with condition variables
32
  • int data_avail 0
  • pthread_mutex_t data_mutex PTHREAD_MUTEX_INITIAL
    IZER
  • pthread_cont_t data_cond PTHREAD_COND_INITIALIZE
    R
  • void producer(void )
  • Pthread_mutex_lock(data_mutex)
  • Produce data
  • Insert data into queue
  • data_avail 1
  • Pthread_cond_signal(data_cond)
  • Pthread_mutex_unlock(data_mutex)

33
  • void consumer(void )
  • Pthread_mutex_lock(data_mutex)
  • while( !data_avail )
  • / sleep on condition variable/
  • Pthread_cond_wait(data_cond, data_mutex)
  • / woken up /
  • Extract data from queue
  • if (queue is empty)
  • data_avail 0
  • Pthread_mutex_unlock(data_mutex)
  • consume_data()

34
A note on condition variables
  • A signal is forgotten if there is no
    corresponding wait that has already occurred.
  • If you want the signal to be remembered, use
    semaphores.

35
Semaphores
  • Counters for resources shared between threads.
  • Sem_wait(sem_t sem)
  • Blocks until the semaphore vale is non-zero
  • Decrements the semaphore value on return.
  • Sem_post(sem_t sem)
  • Unblocks the semaphore and unblocks one waiting
    thread
  • Increments the semaphore value otherwise

36
Pipelined task parallelism with semaphore
  • P1 for (I0 Iltnum_pics, read(in_pic) I)
  • int_pic_1I trans1(in_pic)
  • sem_post(event_1_2I)
  • P2 for (I0 Iltnum_pics I)
  • sem_wait(event_1_2I)
  • int_pic_2I trans2(int_pic_1I)
  • sem_post(event_2_3I)
Write a Comment
User Comments (0)
About PowerShow.com