Subversion Repositories openrisc_2011-10-31

\input texinfo @c -*-texinfo-*-

@c %**start of header

@setfilename libgomp.info

@settitle GNU libgomp

@c %**end of header

@copying

Copyright @copyright{} 2006, 2007, 2008 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document

under the terms of the GNU Free Documentation License, Version 1.2 or

any later version published by the Free Software Foundation; with the

Invariant Sections being ``Funding Free Software'', the Front-Cover

texts being (a) (see below), and with the Back-Cover Texts being (b)

(see below).  A copy of the license is included in the section entitled

``GNU Free Documentation License''.

(a) The FSF's Front-Cover Text is:

     A GNU Manual

(b) The FSF's Back-Cover Text is:

     You have freedom to copy and modify this GNU Manual, like GNU

     software.  Copies published by the Free Software Foundation raise

     funds for GNU development.

@end copying

@ifinfo

@dircategory GNU Libraries

@direntry

* libgomp: (libgomp).                    GNU OpenMP runtime library

@end direntry

This manual documents the GNU implementation of the OpenMP API for

multi-platform shared-memory parallel programming in C/C++ and Fortran.

Published by the Free Software Foundation

51 Franklin Street, Fifth Floor

Boston, MA 02110-1301 USA

@insertcopying

@end ifinfo

@setchapternewpage odd

@titlepage

@title The GNU OpenMP Implementation

@page

@vskip 0pt plus 1filll

@comment For the @value{version-GCC} Version*

@sp 1

Published by the Free Software Foundation @*

51 Franklin Street, Fifth Floor@*

Boston, MA 02110-1301, USA@*

@sp 1

@insertcopying

@end titlepage

@summarycontents

@contents

@page

@node Top

@top Introduction

@cindex Introduction

This manual documents the usage of libgomp, the GNU implementation of the

@uref{http://www.openmp.org, OpenMP} Application Programming Interface (API)

for multi-platform shared-memory parallel programming in C/C++ and Fortran.

@comment

@comment  When you add a new menu item, please keep the right hand

@comment  aligned to the same column.  Do not use tabs.  This provides

@comment  better formatting.

@comment

@menu

* Enabling OpenMP::            How to enable OpenMP for your applications.

* Runtime Library Routines::   The OpenMP runtime application programming

                               interface.

* Environment Variables::      Influencing runtime behavior with environment

                               variables.

* The libgomp ABI::            Notes on the external ABI presented by libgomp.

* Reporting Bugs::             How to report bugs in GNU OpenMP.

* Copying::                    GNU general public license says

                               how you can copy and share libgomp.

* GNU Free Documentation License::

                               How you can copy and share this manual.

* Funding::                    How to help assure continued work for free

                               software.

* Index::                      Index of this documentation.

@end menu

@c ---------------------------------------------------------------------

@c Enabling OpenMP

@c ---------------------------------------------------------------------

@node Enabling OpenMP

@chapter Enabling OpenMP

To activate the OpenMP extensions for C/C++ and Fortran, the compile-time

flag @command{-fopenmp} must be specified. This enables the OpenMP directive

@code{#pragma omp} in C/C++ and @code{!$omp} directives in free form,

@code{c$omp}, @code{*$omp} and @code{!$omp} directives in fixed form,

@code{!$} conditional compilation sentinels in free form and @code{c$},

@code{*$} and @code{!$} sentinels in fixed form, for Fortran. The flag also

arranges for automatic linking of the OpenMP runtime library

(@ref{Runtime Library Routines}).

A complete description of all OpenMP directives accepted may be found in

the @uref{http://www.openmp.org, OpenMP Application Program Interface} manual,

version 3.0.

@c ---------------------------------------------------------------------

@c Runtime Library Routines

@c ---------------------------------------------------------------------

@node Runtime Library Routines

@chapter Runtime Library Routines

The runtime routines described here are defined by section 3 of the OpenMP

specifications in version 3.0. The routines are structured in following

three parts:

Control threads, processors and the parallel environment.

@menu

* omp_get_active_level::        Number of active parallel regions

* omp_get_ancestor_thread_num:: Ancestor thread ID

* omp_get_dynamic::             Dynamic teams setting

* omp_get_level::               Number of parallel regions

* omp_get_max_active_levels::   Maximal number of active regions

* omp_get_max_threads::         Maximal number of threads of parallel region

* omp_get_nested::              Nested parallel regions

* omp_get_num_procs::           Number of processors online

* omp_get_num_threads::         Size of the active team

* omp_get_schedule::            Obtain the runtime scheduling method

* omp_get_team_size::           Number of threads in a team

* omp_get_thread_limit::        Maximal number of threads

* omp_get_thread_num::          Current thread ID

* omp_in_parallel::             Whether a parallel region is active

* omp_set_dynamic::             Enable/disable dynamic teams

* omp_set_max_active_levels::   Limits the number of active parallel regions

* omp_set_nested::              Enable/disable nested parallel regions

* omp_set_num_threads::         Set upper team size limit

* omp_set_schedule::            Set the runtime scheduling method

@end menu

Initialize, set, test, unset and destroy simple and nested locks.

@menu

* omp_init_lock::            Initialize simple lock

* omp_set_lock::             Wait for and set simple lock

* omp_test_lock::            Test and set simple lock if available

* omp_unset_lock::           Unset simple lock

* omp_destroy_lock::         Destroy simple lock

* omp_init_nest_lock::       Initialize nested lock

* omp_set_nest_lock::        Wait for and set simple lock

* omp_test_nest_lock::       Test and set nested lock if available

* omp_unset_nest_lock::      Unset nested lock

* omp_destroy_nest_lock::    Destroy nested lock

@end menu

Portable, thread-based, wall clock timer.

@menu

* omp_get_wtick::            Get timer precision.

* omp_get_wtime::            Elapsed wall clock time.

@end menu

@node omp_get_active_level

@section @code{omp_get_active_level} -- Number of parallel regions

@table @asis

@item @emph{Description}:

This function returns the nesting level for the active parallel blocks,

which enclose the calling call.

@item @emph{C/C++}

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_active_level();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer omp_get_active_level()}

@end multitable

@item @emph{See also}:

@ref{omp_get_level}, @ref{omp_get_max_active_levels}, @ref{omp_set_max_active_levels}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.19.

@end table

@node omp_get_ancestor_thread_num

@section @code{omp_get_ancestor_thread_num} -- Ancestor thread ID

@table @asis

@item @emph{Description}:

This function returns the thread identification number for the given

nesting level of the current thread. For values of @var{level} outside

zero to @code{omp_get_level} -1 is returned; if @var{level} is

@code{omp_get_level} the result is identical to @code{omp_get_thread_num}.

@item @emph{C/C++}

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_ancestor_thread_num(int level);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer omp_ancestor_thread_num(level)}

@item                   @tab @code{integer level}

@end multitable

@item @emph{See also}:

@ref{omp_get_level}, @ref{omp_get_thread_num}, @ref{omp_get_team_size}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.17.

@end table

@node omp_get_dynamic

@section @code{omp_get_dynamic} -- Dynamic teams setting

@table @asis

@item @emph{Description}:

This function returns @code{true} if enabled, @code{false} otherwise.

Here, @code{true} and @code{false} represent their language-specific

counterparts.

The dynamic team setting may be initialized at startup by the

@code{OMP_DYNAMIC} environment variable or at runtime using

@code{omp_set_dynamic}. If undefined, dynamic adjustment is

disabled by default.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_dynamic();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{logical function omp_get_dynamic()}

@end multitable

@item @emph{See also}:

@ref{omp_set_dynamic}, @ref{OMP_DYNAMIC}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.8.

@end table

@node omp_get_level

@section @code{omp_get_level} -- Obtain the current nesting level

@table @asis

@item @emph{Description}:

This function returns the nesting level for the parallel blocks,

which enclose the calling call.

@item @emph{C/C++}

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get level();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer omp_level()}

@end multitable

@item @emph{See also}:

@ref{omp_get_active_level}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.16.

@end table

@node omp_get_max_active_levels

@section @code{omp_set_max_active_levels} -- Maximal number of active regions

@table @asis

@item @emph{Description}:

This function obtains the maximally allowed number of nested, active parallel regions.

@item @emph{C/C++}

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_max_active_levels();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{int omp_get_max_active_levels()}

@end multitable

@item @emph{See also}:

@ref{omp_set_max_active_levels}, @ref{omp_get_active_level}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.14.

@end table

@node omp_get_max_threads

@section @code{omp_get_max_threads} -- Maximal number of threads of parallel region

@table @asis

@item @emph{Description}:

Return the maximal number of threads used for the current parallel region

that does not use the clause @code{num_threads}.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_max_threads();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer function omp_get_max_threads()}

@end multitable

@item @emph{See also}:

@ref{omp_set_num_threads}, @ref{omp_set_dynamic}, @ref{omp_get_thread_limit}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.3.

@end table

@node omp_get_nested

@section @code{omp_get_nested} -- Nested parallel regions

@table @asis

@item @emph{Description}:

This function returns @code{true} if nested parallel regions are

enabled, @code{false} otherwise. Here, @code{true} and @code{false}

represent their language-specific counterparts.

Nested parallel regions may be initialized at startup by the

@code{OMP_NESTED} environment variable or at runtime using

@code{omp_set_nested}. If undefined, nested parallel regions are

disabled by default.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_nested();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer function omp_get_nested()}

@end multitable

@item @emph{See also}:

@ref{omp_set_nested}, @ref{OMP_NESTED}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.10.

@end table

@node omp_get_num_procs

@section @code{omp_get_num_procs} -- Number of processors online

@table @asis

@item @emph{Description}:

Returns the number of processors online.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_num_procs();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer function omp_get_num_procs()}

@end multitable

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.5.

@end table

@node omp_get_num_threads

@section @code{omp_get_num_threads} -- Size of the active team

@table @asis

@item @emph{Description}:

The number of threads in the current team. In a sequential section of

the program @code{omp_get_num_threads} returns 1.

The default team size may be initialized at startup by the

@code{OMP_NUM_THREADS} environment variable. At runtime, the size

of the current team may be set either by the @code{NUM_THREADS}

clause or by @code{omp_set_num_threads}. If none of the above were

used to define a specific value and @code{OMP_DYNAMIC} is disabled,

one thread per CPU online is used.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_num_threads();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer function omp_get_num_threads()}

@end multitable

@item @emph{See also}:

@ref{omp_get_max_threads}, @ref{omp_set_num_threads}, @ref{OMP_NUM_THREADS}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.2.

@end table

@node omp_get_schedule

@section @code{omp_get_schedule} -- Obtain the runtime scheduling method

@table @asis

@item @emph{Description}:

Obtain runtime the scheduling method. The @var{kind} argument will be

set to the value @code{omp_sched_static}, @code{omp_sched_dynamic},

@code{opm_sched_guided} or @code{auto}. The second argument, @var{modifier},

is set to the chunk size.

@item @emph{C/C++}

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{omp_schedule(omp_sched_t * kind, int *modifier);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_schedule(kind, modifier)}

@item                   @tab @code{integer(kind=omp_sched_kind) kind}

@item                   @tab @code{integer modifier}

@end multitable

@item @emph{See also}:

@ref{omp_set_schedule}, @ref{OMP_SCHEDULE}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.12.

@end table

@node omp_get_team_size

@section @code{omp_get_team_size} -- Number of threads in a team

@table @asis

@item @emph{Description}:

This function returns the number of threads in a thread team to which

either the current thread or its ancestor belongs. For values of @var{level}

outside zero to @code{omp_get_level} -1 is returned; if @var{level} is zero

1 is returned and for @code{omp_get_level} the result is identical

to @code{omp_get_num_threads}.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_time_size(int level);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer function omp_get_team_size(level)}

@item                   @tab @code{integer level}

@end multitable

@item @emph{See also}:

@ref{omp_get_num_threads}, @ref{omp_get_level}, @ref{omp_get_ancestor_thread_num}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.18.

@end table

@node omp_get_thread_limit

@section @code{omp_get_thread_limit} -- Maximal number of threads

@table @asis

@item @emph{Description}:

Return the maximal number of threads of the program.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_thread_limit();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer function omp_get_thread_limit()}

@end multitable

@item @emph{See also}:

@ref{omp_get_max_threads}, @ref{OMP_THREAD_LIMIT}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.13.

@end table

@node omp_get_thread_num

@section @code{omp_get_thread_num} -- Current thread ID

@table @asis

@item @emph{Description}:

Unique thread identification number within the current team.

In a sequential parts of the program, @code{omp_get_thread_num}

always returns 0. In parallel regions the return value varies

from 0 to @code{omp_get_num_threads}-1 inclusive. The return

value of the master thread of a team is always 0.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_get_thread_num();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer function omp_get_thread_num()}

@end multitable

@item @emph{See also}:

@ref{omp_get_num_threads}, @ref{omp_get_ancestor_thread_num}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.4.

@end table

@node omp_in_parallel

@section @code{omp_in_parallel} -- Whether a parallel region is active

@table @asis

@item @emph{Description}:

This function returns @code{true} if currently running in parallel,

@code{false} otherwise. Here, @code{true} and @code{false} represent

their language-specific counterparts.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_in_parallel();}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{logical function omp_in_parallel()}

@end multitable

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.6.

@end table

@node omp_set_dynamic

@section @code{omp_set_dynamic} -- Enable/disable dynamic teams

@table @asis

@item @emph{Description}:

Enable or disable the dynamic adjustment of the number of threads

within a team. The function takes the language-specific equivalent

of @code{true} and @code{false}, where @code{true} enables dynamic

adjustment of team sizes and @code{false} disables it.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{void omp_set_dynamic(int);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_set_dynamic(set)}

@item                   @tab @code{integer, intent(in) :: set}

@end multitable

@item @emph{See also}:

@ref{OMP_DYNAMIC}, @ref{omp_get_dynamic}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.7.

@end table

@node omp_set_max_active_levels

@section @code{omp_set_max_active_levels} -- Limits the number of active parallel regions

@table @asis

@item @emph{Description}:

This function limits the maximally allowed number of nested, active parallel regions.

@item @emph{C/C++}

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{omp_set_max_active_levels(int max_levels);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{omp_max_active_levels(max_levels)}

@item                   @tab @code{integer max_levels}

@end multitable

@item @emph{See also}:

@ref{omp_get_max_active_levels}, @ref{omp_get_active_level}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.14.

@end table

@node omp_set_nested

@section @code{omp_set_nested} -- Enable/disable nested parallel regions

@table @asis

@item @emph{Description}:

Enable or disable nested parallel regions, i.e., whether team members

are allowed to create new teams. The function takes the language-specific

equivalent of @code{true} and @code{false}, where @code{true} enables

dynamic adjustment of team sizes and @code{false} disables it.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{void omp_set_dynamic(int);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_set_dynamic(set)}

@item                   @tab @code{integer, intent(in) :: set}

@end multitable

@item @emph{See also}:

@ref{OMP_NESTED}, @ref{omp_get_nested}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.9.

@end table

@node omp_set_num_threads

@section @code{omp_set_num_threads} -- Set upper team size limit

@table @asis

@item @emph{Description}:

Specifies the number of threads used by default in subsequent parallel

sections, if those do not specify a @code{num_threads} clause. The

argument of @code{omp_set_num_threads} shall be a positive integer.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{void omp_set_num_threads(int);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_set_num_threads(set)}

@item                   @tab @code{integer, intent(in) :: set}

@end multitable

@item @emph{See also}:

@ref{OMP_NUM_THREADS}, @ref{omp_get_num_threads}, @ref{omp_get_max_threads}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.1.

@end table

@node omp_set_schedule

@section @code{omp_set_schedule} -- Set the runtime scheduling method

@table @asis

@item @emph{Description}:

Sets the runtime scheduling method. The @var{kind} argument can have the

value @code{omp_sched_static}, @code{omp_sched_dynamic},

@code{opm_sched_guided} or @code{omp_sched_auto}. Except for

@code{omp_sched_auto}, the chunk size is set to the value of

@var{modifier} if positive or to the default value if zero or negative.

For @code{omp_sched_auto} the @var{modifier} argument is ignored.

@item @emph{C/C++}

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_schedule(omp_sched_t * kind, int *modifier);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_schedule(kind, modifier)}

@item                   @tab @code{integer(kind=omp_sched_kind) kind}

@item                   @tab @code{integer modifier}

@end multitable

@item @emph{See also}:

@ref{omp_get_schedule}

@ref{OMP_SCHEDULE}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.2.11.

@end table

@node omp_init_lock

@section @code{omp_init_lock} -- Initialize simple lock

@table @asis

@item @emph{Description}:

Initialize a simple lock. After initialization, the lock is in

an unlocked state.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{void omp_init_lock(omp_lock_t *lock);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_init_lock(lock)}

@item                   @tab @code{integer(omp_lock_kind), intent(out) :: lock}

@end multitable

@item @emph{See also}:

@ref{omp_destroy_lock}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.3.1.

@end table

@node omp_set_lock

@section @code{omp_set_lock} -- Wait for and set simple lock

@table @asis

@item @emph{Description}:

Before setting a simple lock, the lock variable must be initialized by

@code{omp_init_lock}. The calling thread is blocked until the lock

is available. If the lock is already held by the current thread,

a deadlock occurs.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{void omp_set_lock(omp_lock_t *lock);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_set_lock(lock)}

@item                   @tab @code{integer(omp_lock_kind), intent(out) :: lock}

@end multitable

@item @emph{See also}:

@ref{omp_init_lock}, @ref{omp_test_lock}, @ref{omp_unset_lock}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.3.3.

@end table

@node omp_test_lock

@section @code{omp_test_lock} -- Test and set simple lock if available

@table @asis

@item @emph{Description}:

Before setting a simple lock, the lock variable must be initialized by

@code{omp_init_lock}. Contrary to @code{omp_set_lock}, @code{omp_test_lock}

does not block if the lock is not available. This function returns

@code{true} upon success, @code{false} otherwise. Here, @code{true} and

@code{false} represent their language-specific counterparts.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_test_lock(omp_lock_t *lock);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_test_lock(lock)}

@item                   @tab @code{logical(omp_logical_kind) :: omp_test_lock}

@item                   @tab @code{integer(omp_lock_kind), intent(out) :: lock}

@end multitable

@item @emph{See also}:

@ref{omp_init_lock}, @ref{omp_set_lock}, @ref{omp_set_lock}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.3.5.

@end table

@node omp_unset_lock

@section @code{omp_unset_lock} -- Unset simple lock

@table @asis

@item @emph{Description}:

A simple lock about to be unset must have been locked by @code{omp_set_lock}

or @code{omp_test_lock} before. In addition, the lock must be held by the

thread calling @code{omp_unset_lock}. Then, the lock becomes unlocked. If one

ore more threads attempted to set the lock before, one of them is chosen to,

again, set the lock for itself.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{void omp_unset_lock(omp_lock_t *lock);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_unset_lock(lock)}

@item                   @tab @code{integer(omp_lock_kind), intent(out) :: lock}

@end multitable

@item @emph{See also}:

@ref{omp_set_lock}, @ref{omp_test_lock}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.3.4.

@end table

@node omp_destroy_lock

@section @code{omp_destroy_lock} -- Destroy simple lock

@table @asis

@item @emph{Description}:

Destroy a simple lock. In order to be destroyed, a simple lock must be

in the unlocked state.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{void omp_destroy_lock(omp_lock_t *);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_destroy_lock(lock)}

@item                   @tab @code{integer(omp_lock_kind), intent(inout) :: lock}

@end multitable

@item @emph{See also}:

@ref{omp_init_lock}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.3.2.

@end table

@node omp_init_nest_lock

@section @code{omp_init_nest_lock} -- Initialize nested lock

@table @asis

@item @emph{Description}:

Initialize a nested lock. After initialization, the lock is in

an unlocked state and the nesting count is set to zero.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{void omp_init_nest_lock(omp_nest_lock_t *lock);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_init_nest_lock(lock)}

@item                   @tab @code{integer(omp_nest_lock_kind), intent(out) :: lock}

@end multitable

@item @emph{See also}:

@ref{omp_destroy_nest_lock}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.3.1.

@end table

@node omp_set_nest_lock

@section @code{omp_set_nest_lock} -- Wait for and set simple lock

@table @asis

@item @emph{Description}:

Before setting a nested lock, the lock variable must be initialized by

@code{omp_init_nest_lock}. The calling thread is blocked until the lock

is available. If the lock is already held by the current thread, the

nesting count for the lock in incremented.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{void omp_set_nest_lock(omp_nest_lock_t *lock);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{subroutine omp_set_nest_lock(lock)}

@item                   @tab @code{integer(omp_nest_lock_kind), intent(out) :: lock}

@end multitable

@item @emph{See also}:

@ref{omp_init_nest_lock}, @ref{omp_unset_nest_lock}

@item @emph{Reference}:

@uref{http://www.openmp.org/, OpenMP specifications v3.0}, section 3.3.3.

@end table

@node omp_test_nest_lock

@section @code{omp_test_nest_lock} -- Test and set nested lock if available

@table @asis

@item @emph{Description}:

Before setting a nested lock, the lock variable must be initialized by

@code{omp_init_nest_lock}. Contrary to @code{omp_set_nest_lock},

@code{omp_test_nest_lock} does not block if the lock is not available.

If the lock is already held by the current thread, the new nesting count

is returned. Otherwise, the return value equals zero.

@item @emph{C/C++}:

@multitable @columnfractions .20 .80

@item @emph{Prototype}: @tab @code{int omp_test_nest_lock(omp_nest_lock_t *lock);}

@end multitable

@item @emph{Fortran}:

@multitable @columnfractions .20 .80

@item @emph{Interface}: @tab @code{integer function omp_test_nest_lock(lock)}

@item                   @tab @code{integer(omp_integer_kind) :: omp_test_nest_lock}

@item                   @tab @code{integer(omp_nest_lock_kind), intent(inout) :: lock}

@end multitable

@item @emph{See also}:

@ref{omp_init_lock}, @ref{omp_set_lock}, @ref{omp_set_lock}

@item @emph{Reference}: