1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkBarrier.h,v $
Language: C++
Date: $Date: 2007-01-25 23:18:04 $
Version: $Revision: 1.10 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef __itkBarrier_h
#define __itkBarrier_h
#include "itkLightObject.h"
#include "itkConditionVariable.h"
#include "itkMutexLock.h"
#ifdef ITK_USE_FETCHOP_BARRIERS
extern "C" {
#include <sys/pmo.h>
#include <fetchop.h>
}
#endif
#ifdef ITK_USE_SPROC
extern "C" {
#include <ulocks.h>
}
#endif
namespace itk {
/**
* \class Barrier
* \brief Standard barrier class implementation for synchronizing the execution
* of threads.
*
* A barrier class is used to synchronize threaded execution by allowing
* threads to block until each has reached a desired state. As each thread
* enters the barrier it blocks. When all threads have entered the barrier,
* all released and continue to execute.
*
* A thread enters the barrier by calling Wait() on the barrier class.
* To set up a barrier class, call Initialize(n) where n is the number of
* waiting threads that will trigger a release of the barrier.
*
* \par NOTE FOR SGI USERS. You may optionally enable a fetchop library
* implementation of barriers that will give significantly faster performance
* over the sproc barrier class. With the fetchop implementation, you are
* limited to Barrier::m_MaxBarriers separate barrier instantiations, although
* this limit can be safely raised if necessary. To enable the fetchop
* implementation, set ITK_USE_FETCHOP_BARRIERS and link applications against
* -lfetchop.
*/
class ITKCommon_EXPORT Barrier : public LightObject
{
public:
/** Standard class typedefs. */
typedef Barrier Self;
typedef LightObject Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(Barrier, Object);
/** Creates a new system variable used to implement the barrier. The
argument to this method is the number of threads that must Wait() on the
barrier before it is cleared. */
void Initialize(unsigned int);
/** A thread calling this method waits until m_NumberOfThreads have called
* Wait() on the barrier. When the final expected thread calls Wait(), all
* threads are released. */
void Wait();
private:
Barrier();
~Barrier();
#if defined ITK_USE_FETCHOP_BARRIERS
static bool m_ReservoirInitialized;
static atomic_reservoir_t m_Reservoir;
static int m_MaxBarriers;
atomic_var_t * m_Pvar;
char pad1[128]; // Attempt to put
volatile int m_FetchopFlag; // m_Fetchop on its
char pad2[128]; // own cache line.
#elif defined ITK_USE_SPROC
barrier_t *m_Barrier;
#else
ConditionVariable::Pointer m_ConditionVariable;
unsigned int m_NumberArrived;
SimpleMutexLock m_Mutex;
#endif
unsigned int m_NumberExpected;
};
} // end namespace itk
#endif
|
