OpenMP Glossary

atomic - this mutual exclusion directive can be used with a single assignment statement that updates a scalar variable

barrier - this synchronization directive defines a point where each thread waits for all other threads to arrive

cache miss - required data is not present in the primary cache

chunk - this schedule clause option is a set of contiguous loop iterations

coarse-grained parallelism - parallelism at the highest possible level in the program and associated with message-passing paradigms

conditional compilation - compilation prefix indicates that the statement should be compiled when the -mp option is specified

copyin - this parallel directive clause allows slave threads to access the master thread's copy of threadprivate data

critical - this mutual exclusion directive makes a thread wait until no other thread is executing within a critical section

data independence - no loop iterations can write a value into a memory location that is read or written by any other iteration of that loop

deadlock - a situation where two processes are each waiting on a resource being held by the other process

default - this parallel directive clause specifies the default data scoping rules to be either shared or private

directive - these compiler commands can be applied or ignored depending on compiler options

dynamic - this schedule clause option allows the assignment of threads at runtime to vary from one execution to another using chunks

dynamic extent - extension of a parallel region to include all the code in subprograms that are invoked either directly or indirectly from within the parallel region

dynamic threads - the number of parallel threads executing within the application may be adjusted to match the number of available processors

false sharing - a cache line is being shared among multiple processors even thought the different processors are accessing distinct data

fine-grained parallelism - usually loop-level parallelism but sometimes instruction level parallelism

firstprivate - this parallel directive clause initializes each thread's copy of a private variable to the value of the master's copy

fissioning - splitting a loop into a serial and a parallel portion on account of nonremovable data dependence

flush - this directive causes the present value of a named shared variable to be immediately written back to memory

guided - this schedule clause option uses decreasing sizes of chunks to assigned to threads determined by the implementation

if - this do directive clause controls whether the loop should be executed in parallel or serially based on a user-defined runtime test

incremental parallelism - the ability to parallelize and application a little at a time at a rate where the developer feels additional effort is worthwhile

lastprivate - this parallel directive clause writes back to the master's copy of a private variable the value contained in the private copy belonging to the thread that executed the sequentially last iteration of the loop

lexical scope - determines the availability of storage locations at any point of the program

loop interchange - the practice of swapping and outer loop and an inner loop statement, usually to make memory references more efficient

loop nest – an outer loop and all of the inner loops with it

master - this directive identifies a block of code within the parallel region that must be executed by the master thread of the executing parallel team of threads

master thread - the single thread of control that begins an OpenMP program which is present for the duration of the program

memory fence - a synchronization point inhibits the movement of memory operations across that point

nested parallelism - a parallel region is contained within another parallel region

nowait - this clause used with the do, sections and single directives, causes the implied end barrier to be ignored by each thread as it completes

ordered - this directive identifies a portion of code within each loop iteration that must be executed in the original, sequential order of the loop iterations

orphaned - work-sharing constructs that are no longer enclosed within the lexical scope of the parallel region

oversubscription - when all of the applications running together request more processors than are currently available

parallel region - a block of code defined by a parallel directive that is to be executed concurrently by a team of threads

private - this parallel directive clause designates each thread gets a private copy of the named variable for the duration of the parallel construct

race condition - when multiple processes read and write a storage location in an unpredictable order which can result in different values with each invocation

reduction - a binary operator is applied to a variable and some other value and the result is stored back in the variable

runtime - this schedule clause option checks an environment variable at runtime

schedule - this do directive clause controls how iterations of the parallel loop are distributed across the team of parallel threads

scheduling - the way iterations are assigned to processes

scope - whether a variable is shared between OpenMP threads

sections - this work-sharing directive defines tasks to be executed in parallel

sentinel - a prefix keyword that begins a compiler directive

serialized parallel region - a parallel region that executes serially with a team of one thread

shared - this parallel directive clause specifies that the named variable should be shared by all the threads in the team for the duration of the parallel construct

single – this directive identifies a block of code within the parallel region that must be executed by just one thread of the executing parallel team of threads

speedup - the factor by which the time to solution can be improved compared to using only a single processor

static - this schedule clause option assigns the same chunk size to all threads

static extent - the code that is lexically between the parallel and end parallel directives and also called lexical extent

structured block - single-entry/single-exit block

synchronization - the mechanisms by which a parallel program can coordinate the execution of multiple threads

team - collective name for the master thread and the additional threads created within a parallel region

thread - a process executing on its own processor

threadprivate - this directive is used to identify a Fortran common block or C global variable as being private to each thread

thread-safe - routines that can be safely executed in parallel

trip-count - the number of times a loop body is executed

versioning - splitting a loop into a serial and a parallel portion to avoid slowdowns on low trip-counts

work-sharing - partitioning of work among a team of threads

References

Books

Parallel Programming in OpenMP, Rohit Chandra, Ramesh Menon, Leo

Dagum, David Kohr, Dror Maydan, Jeff McDonald

October 2000, 300 pages, Paper, $39.95, ISBN 1-55860-671-8

MIPSpro Fortran 77 Programmer's Guide

MIPSpro 7 Fortran 90 Commands and Directives Reference Manual

MIPSpro C and C++ Pragmas

Web Sites

http://www.openmp.org/ - OpenMP Architecture Review Board

http://www.cs.uh.edu/~cOMPunity/ - The Community of OpenMP Users, Researchers, Tool Developers and Providers

Workshops

WOMPAT 2001: Workshop on OpenMP Applications and Tools

(http://www.ece.purdue.edu/~eigenman/wompat2001/)

APO

Books

MIPSpro Auto-Parallelizing Option Programmer's Guide

MIPSpro Fortran 77 Programmer's Guide

MIPSpro 7 Fortran 90 Commands and Directives Reference Manual

MIPSpro C and C++ Pragmas

C Language Reference Manual

C++ Programmer's Guide