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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
/*=========================================================================
Program: Visualization Toolkit
Module: vtkSMPToolsImpl.txx
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/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 notice for more information.
=========================================================================*/
#ifndef OpenMPvtkSMPToolsImpl_txx
#define OpenMPvtkSMPToolsImpl_txx
#include <algorithm> // For std::sort
#include "SMP/Common/vtkSMPToolsImpl.h"
#include "SMP/Common/vtkSMPToolsInternal.h" // For common vtk smp class
#include "vtkCommonCoreModule.h" // For export macro
namespace vtk
{
namespace detail
{
namespace smp
{
VTK_ABI_NAMESPACE_BEGIN
int VTKCOMMONCORE_EXPORT GetNumberOfThreadsOpenMP();
bool VTKCOMMONCORE_EXPORT GetSingleThreadOpenMP();
void VTKCOMMONCORE_EXPORT vtkSMPToolsImplForOpenMP(vtkIdType first, vtkIdType last, vtkIdType grain,
ExecuteFunctorPtrType functorExecuter, void* functor, bool nestedActivated);
//--------------------------------------------------------------------------------
template <typename FunctorInternal>
void ExecuteFunctorOpenMP(void* functor, vtkIdType from, vtkIdType grain, vtkIdType last)
{
const vtkIdType to = std::min(from + grain, last);
FunctorInternal& fi = *reinterpret_cast<FunctorInternal*>(functor);
fi.Execute(from, to);
}
//--------------------------------------------------------------------------------
template <>
template <typename FunctorInternal>
void vtkSMPToolsImpl<BackendType::OpenMP>::For(
vtkIdType first, vtkIdType last, vtkIdType grain, FunctorInternal& fi)
{
vtkIdType n = last - first;
if (n <= 0)
{
return;
}
if (grain >= n)
{
fi.Execute(first, last);
}
else
{
// /!\ This behaviour should be changed if we want more control on nested
// (e.g only the 2 first nested For are in parallel)
bool fromParallelCode = this->IsParallel.exchange(true);
vtkSMPToolsImplForOpenMP(
first, last, grain, ExecuteFunctorOpenMP<FunctorInternal>, &fi, this->NestedActivated);
// Atomic contortion to achieve this->IsParallel &= fromParallelCode.
// This compare&exchange basically boils down to:
// if (IsParallel == trueFlag)
// IsParallel = fromParallelCode;
// else
// trueFlag = IsParallel;
// Which either leaves IsParallel as false or sets it to fromParallelCode (i.e. &=).
// Note that the return value of compare_exchange_weak() is not needed,
// and that no looping is necessary.
bool trueFlag = true;
this->IsParallel.compare_exchange_weak(trueFlag, fromParallelCode);
}
}
//--------------------------------------------------------------------------------
template <>
template <typename InputIt, typename OutputIt, typename Functor>
void vtkSMPToolsImpl<BackendType::OpenMP>::Transform(
InputIt inBegin, InputIt inEnd, OutputIt outBegin, Functor transform)
{
auto size = std::distance(inBegin, inEnd);
UnaryTransformCall<InputIt, OutputIt, Functor> exec(inBegin, outBegin, transform);
this->For(0, size, 0, exec);
}
//--------------------------------------------------------------------------------
template <>
template <typename InputIt1, typename InputIt2, typename OutputIt, typename Functor>
void vtkSMPToolsImpl<BackendType::OpenMP>::Transform(
InputIt1 inBegin1, InputIt1 inEnd, InputIt2 inBegin2, OutputIt outBegin, Functor transform)
{
auto size = std::distance(inBegin1, inEnd);
BinaryTransformCall<InputIt1, InputIt2, OutputIt, Functor> exec(
inBegin1, inBegin2, outBegin, transform);
this->For(0, size, 0, exec);
}
//--------------------------------------------------------------------------------
template <>
template <typename Iterator, typename T>
void vtkSMPToolsImpl<BackendType::OpenMP>::Fill(Iterator begin, Iterator end, const T& value)
{
auto size = std::distance(begin, end);
FillFunctor<T> fill(value);
UnaryTransformCall<Iterator, Iterator, FillFunctor<T>> exec(begin, begin, fill);
this->For(0, size, 0, exec);
}
//--------------------------------------------------------------------------------
template <>
template <typename RandomAccessIterator>
void vtkSMPToolsImpl<BackendType::OpenMP>::Sort(
RandomAccessIterator begin, RandomAccessIterator end)
{
std::sort(begin, end);
}
//--------------------------------------------------------------------------------
template <>
template <typename RandomAccessIterator, typename Compare>
void vtkSMPToolsImpl<BackendType::OpenMP>::Sort(
RandomAccessIterator begin, RandomAccessIterator end, Compare comp)
{
std::sort(begin, end, comp);
}
//--------------------------------------------------------------------------------
template <>
void vtkSMPToolsImpl<BackendType::OpenMP>::Initialize(int);
//--------------------------------------------------------------------------------
template <>
int vtkSMPToolsImpl<BackendType::OpenMP>::GetEstimatedNumberOfThreads();
//--------------------------------------------------------------------------------
template <>
bool vtkSMPToolsImpl<BackendType::OpenMP>::GetSingleThread();
VTK_ABI_NAMESPACE_END
} // namespace smp
} // namespace detail
} // namespace vtk
#endif
|
