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









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 - OpenMP Architecture Review Board - The Community of OpenMP Users, Researchers, Tool Developers and Providers



WOMPAT 2001: Workshop on OpenMP Applications and Tools








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