Jukka Julku Multicore programming: Low-level libraries. Outline. Processes and threads TBB MPI UPC. Examples

Transcription

1 Multicore Jukka Julku

2

3 Disclaimer There are several low-level, languages and directive based approaches But no silver bullets This presentation only covers some examples of them is today's main subject!

4 Lowest of the low Threads POSIX threads, etc. Basically The assembly language of parallel computing But there are also advanced threading like Boost C++ threading library

5 Intel's Threading Building Blocks () C++ Library Abstracts low-level threading detail Concept of tasks Uses C++ templates Resembles STL Designed for portability and scalability Includes Task manager to schedule tasks Concurrent data structures Concurrent algorithms Synchronization primitives and memory allocators

6 Message-passing interface () The de-facto standard in distributed memory computing Huge number of existing parallel applications already run over!, point-to-point and collective communications, topologies, etc. Multicores? Depends on the library implementation Hybrid model

7 Unied parallel C C extension Full language SPMD Shared or distributed memory Single logically partitioned address space Threads have shared and private data Work distribution upc_forall() Synchronization barriers, locks

8 Portable programming interface for shared-memory parallel computers Compiler assisted parallel programming Compiler directives, library routines and environmental variables Provides means to Create teams of threads Share work between the threads Declare private or shared data Synchronization and exclusive access

9 The basic idea Write (sequential) code Identify parallel regions The main eort of parallelization Use directives to express parallelism Compile and run

10 Motivation Simple idea Easy to learn syntax Parallelize (old) sequential code Standard technique Portable Incremental parallelization C/C++ and Fortran support

11 Execution model Fork and join model Based on blocks of parallel computation Thread team is formed at entry Barrier at exit Nested blocks

12 Memory model Shared-memory Threads also have private memory Data transfer is controlled by directives Relaxed memory consistency Threads may have their own view of the world between certain synchronization points The memory is automatically synchronized at barriers, entry and exit to critical sections and lock routines Flush -operation for the programmer Motivation: Flexibility of implementation

13 Core elements 0 Source: Wikipedia

14 : C-language #pragma omp d i r e c t i v e name [ c l a u s e [ [, ] c l a u s e ]... ] Clauses control how the directives are compiled and executed

15 Parallel constructs #pragma omp p a r a l l e l [ c l a u s e [ [, ] c l a u s e ]... ] s t r u c t u r e d b l o c k The most important construct Denes a parallel section Everything not inside a parallel construct is sequential Best practice: Maximize parallel regions Spawns a team of threads Does not do any work sharing! Implicit barrier at the end

16 Example #i n c l u d e <omp. h> #i n c l u d e <s t d i o. h> i n t main ( ) { #pragma omp p a r a l l e l { p r i n t f (" Thread %d\n ", omp_get_thread_num ( ) ) ; } } r e t u r n 0 ;

17 Work-sharing constructs Specify how to share work between the thread team Restrictions Each thread at the team must encounter or non at all Sequence of work-sharing constructs and barriers must be the same Barriers at exit by default Can be removed with nowait -clause Orphaning

18 Loop construct #pragma omp f o r [ c l a u s e [ [, ] c l a u s e ]... ] f o r l o o p The most common work-sharing construct Distributes loop iterations among the threads Limited to loops whose iterations can be counted i.e. for(init-expr; var relop b; incr-expr )

19 Example #pragma omp p a r a l l e l s h a r e d (A, B, C, n ) p r i v a t e ( i ) { #pragma omp f o r s c h e d u l e ( dynamic, 100) f o r ( i =0; i <n ; i ++) { A [ i ] = B [ i ] + C [ i ] ; } }

20 Sections and single constructs #pragma omp s e c t i o n s [ c l a u s e [ [, ] c l a u s e ]... ] { [#pragma omp s e c t i o n s t r u c t u r e d b l o c k ] [#pragma omp s e c t i o n s t r u c t u r e d b l o c k ]... } Distribute independent units of work Each section is executed exactly once #pragma omp s i n g l e [ c l a u s e [ [, ] c l a u s e ]... ] s t r u c t u r e d b l o c k Block is executed by only one thread For example: Initialization tasks between two loops

21 Example #pragma omp p a r a l l e l p r i v a t e ( i, j ) { } #pragma omp s e c t i o n s { #pragma omp s e c t i o n { f o r ( i =0; i <n ; i ++) { C [ i ] = A [ i ] + B [ i ] ; } #pragma omp s e c t i o n { // m!= n f o r ( j =0; j <m; j ++) { F [ j ] = D[ j ] E [ j ] ; }

22 Task construct #pragma omp t a s k [ c l a u s e [ [, ] c l a u s e ]... ] s t r u c t u r e d b l o c k #pragma omp t a s k w a i t New in 3.0 When the directive is encountered a new task is created from the block The task can be executed by any thread of the team Taskwait construct species a wait on the completion of child tasks generated since the beginning of the current task. Where to use: While-loops and recursive code

23 Example v o i d q u i c k s o r t ( i n t a r r a y, i n t l e f t, i n t r i g h t ) { i n t i ; i f ( l e f t >= r i g h t ) { r e t u r n ; } i = p a r t i t i o n ( a r r a y, l e f t, r i g h t ) ; #pragma omp t a s k q u i c k s o r t ( a r r a y, l e f t, i 1 ) ; q u i c k s o r t ( a r r a y, i n d e x + 1, r i g h t ) ; #pragma omp } t a s k w a i t

24 Some memory clauses shared(list) Shared by all threads private(list) Private copy for each thread rstprivate(list) Private, initialized with variable of the same name lastprivate(list) Private, last value is accessible after the section Last: last iteration in sequential order, last section default(none shared private) Used to state default sharing attribute

25 Synchronization 1/2 Implicit barrier is not always enough denes set of other synchronization mechanisms for dierent kinds of critical sections Lock routines

26 Synchronization 2/2 #pragma omp b a r r i e r #pragma omp o r d e r e d s t r u c t u r e d b l o c k #pragma omp c r i t i c a l [ ( name ) ] s t r u c t u r e d b l o c k #pragma omp atomic s t a t e m e n t #pragma omp master s t r u c t u r e d b l o c k

27 Flush #pragma omp f l u s h [ ( l i s t ) ] Relaxed memory consistency Synchronized at synchronization points Barriers, entry and exit to critical section and lock routines Threads may need to have consistent view between the synchronization points Flush can be used to synchronize memory in these situations Granularity: Variables

28 Example i n t x, y ; #pragma omp p a r a l l e l s h a r e d ( x ) p r i v a t e ( y ) { #pragma omp master { x = 1 ; } y = x ; } Its not guaranteed that x is 1 as there's no barrier! Flush(x) is needed before the assignment

29 Simple, but... Cannot prevent: Data races Thread-safety problems Deadlocks Memory consistency problems Programmer must ensure that the values are the same between the synchronization points Compiler can rearrange code, even ush! This may lead to hard to nd problems But still, removes lot of work and in most cases is quite simple approach!

30 Performance Just parallelizing the code with directives doesn't necessarily bring the expected benets Especially with large number of threads ne-tuning may be required Parallelization overhead Thread management Waiting at barriers Etc.

31 Code examples If there is still time left, some more examples

32 The end Any questions?

33 Sources 1 Chapman, B., Jost, G. and Van Der Pas, R: Using - Portable shared memory parallel programming Very good introduction to and parallel programming in general 2 specication : 4 standard Leiserson, C. Mirman, I.: How to survive the multicore software revolution. 6 Krawezik, G. and Capello, F.: Performance comparison of and three programming styles on shared memory multiprocessors.