_spin(SYNCH)
_spin: _spin_init, _spin_lock, _spin_trylock, _spin_unlock, _spin_destroy --
overview of spin lock routines
Synopsis
cc [options] -Kthread file
#include <synch.h>
int _spin_init(spin_t *lock, void *arg);
void _spin_lock(spin_t *lock);
int _spin_trylock(spin_t *lock);
void _spin_unlock(spin_t *lock);
int _spin_destroy(spin_t *lock);
Description
Spin locks, a type of mutual exclusion lock (mutex),
are used to serialize the execution of threads.
They are typically used to ensure
that only one thread at a time accesses shared data.
Note that these locks protect data only when the convention
of acquiring the lock is faithfully followed before any access
of the data.
The difference between spin locks and ordinary mutex locks
is in their locking routines.
When a mutex is already locked,
the locking routine (mutex_lock(SYNCH))
will block the caller until the lock is available.
When a ``spin'' lock is already locked,
the locking routine (_spin_lock)
will busy-wait, or ``spin'',
in a loop, testing if the lock has become available.
Such spinning wastes processor cycles
and can slow processors doing useful work,
including the processor holding the lock,
by consuming communication bandwidth.
The Threads Library provides five routines
to manipulate spin locks;
these are outlined below
and described in more detail on individual manual pages.
Parameters
lock-
pointer to spin lock to be initialized, locked, unlocked, or destroyed
arg-
NULL (reserved for future use)
_spin_init(3synch)
_spin_init initializes the spin lock pointed to by lock
to the unlocked state.
_spin_lock(3synch)
_spin_lock locks the spin lock pointed to by lock.
If lock is locked,
the calling thread will busy-wait, or ``spin'',
until lock is available.
When _spin_lock returns,
the caller has acquired lock.
_spin_trylock(3synch)
_spin_trylock attempts once to lock
the spin lock pointed to by lock.
If lock is available,
_spin_trylock will return successfully
with lock locked.
If lock is already locked,
_spin_trylock immediately returns EBUSY to the caller
without acquiring lock or spinning.
_spin_unlock(3synch)
_spin_unlock unlocks the spin lock pointed to by lock.
If one or more threads are waiting for the lock
when _spin_unlock is called,
one of the waiting threads will acquire the lock.
_spin_destroy(3synch)
_spin_destroy destroys the spin lock pointed to by lock.
This includes invalidating lock and freeing any
associated implementation-allocated dynamic resources.
Usage
Because spin locks waste system resources,
most applications should use mutexes instead of spin locks
for mutual exclusion.
However, spin locks are useful when:
-
sleep is not permitted
-
the critical section is small,
so that the expected spin is less costly
than blocking and resuming the thread
-
no other work is available
Spin locks should only be used when there is a guarantee
that the thread will not be preempted or blocked
while holding a spin lock.
It is the responsibility of each application
to unlock all spin locks
before calling sleep or blocking routines.
Warnings
Spin locks must not be used on a single processor system.
In the best case, a spin lock on a single processor system will waste resources,
slowing down the owner of the lock;
in the worst case, it will deadlock the processor.
Operations on spin locks
are not recursive--a thread can deadlock if
it attempts to relock a spin lock that it already has locked.
References
Intro(SYNCH),
mutex(SYNCH),
_spin_destroy(SYNCH),
_spin_init(SYNCH),
_spin_lock(SYNCH),
_spin_trylock(SYNCH),
_spin_unlock(SYNCH)
© 2005 The SCO Group, Inc. All rights reserved.
SCO OpenServer Release 6.0.0 - 01 June 2005