Parallel Programming in Fortran 95 using OpenMP - People

60 4. The OpenMP run-time library
4. Once it has finished its work, it releases the ownership so that another thread can
fetch it.
5. Finally, once the lock is no longer needed, it is necessary to eliminate it and its
associated lock variable.
Two different types of locks exist:
simple locks : these locks cannot be locked if they are already in a locked state.
nestable locks : these locks may be locked multiple times by the same thread before
being unlocked. They have associated a nesting counter which keeps track of the
number of times a nestable lock has been locked and released.
Each run-time library routine, which works with locks, has two different versions: one
whichactsonsimplelocksandanotherwhichactsonnestablelocks.Itisnotallowedto
call one kind of routines with the type of variable of the other kind!
The run-time library routines needed to handle locks are described in the following
subsections.
4.2.1 OMP init lock and OMP init nest lock
These subroutines initialize a lock: a simple one and a nestable one, respectively. It is
necessary to make a call to one of these subroutines before any other of the following
routines can be used. Their interface declarations are:
subroutine OMP_init_lock(svar)
integer(kind = OMP_lock_kind), intent(out) :: svar
end subroutine OMP_init_lock
subroutine OMP_init_nest_lock(nvar)
integer(kind = OMP_nest_lock_kind), intent(out) :: nvar
end subroutine OMP_init_nest_lock
where the passed argument, called lock variable, is associated with a lock. Once a
lock variable has been initialized, it can be used in subsequent calls to routines to refer
to the specified lock. If the lock variable is nestable, its nesting counter is set to zero.
It is not allowed to call these subroutines using a lock variable that has already been
associated to a lock, although it is not specified how an OpenMP-implementation has to
reactinsuchacase.
4.2.2 OMP set lock and OMP set nest lock
When a thread wants to own a specific lock, it calls one of these subroutines. If the
specified lock is not owned by another thread, then it gets the ownership of that lock. If
the specified lock is already owned by another thread, then it has to wait until the other
thread releases its ownership over the lock. The interface declarations of these subroutines
are as follows: