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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
/*=========================================================================
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 STDThreadvtkSMPToolsImpl_txx
#define STDThreadvtkSMPToolsImpl_txx
#include <algorithm> // For std::sort
#include <functional> // For std::bind
#include "SMP/Common/vtkSMPToolsImpl.h"
#include "SMP/Common/vtkSMPToolsInternal.h" // For common vtk smp class
#include "SMP/STDThread/vtkSMPThreadPool.h" // For vtkSMPThreadPool
#include "vtkCommonCoreModule.h" // For export macro
namespace vtk
{
namespace detail
{
namespace smp
{
VTK_ABI_NAMESPACE_BEGIN
int VTKCOMMONCORE_EXPORT GetNumberOfThreadsSTDThread();
bool VTKCOMMONCORE_EXPORT GetSingleThreadSTDThread();
void VTKCOMMONCORE_EXPORT PushThreadId(std::thread::id id);
void VTKCOMMONCORE_EXPORT PopThreadId();
//--------------------------------------------------------------------------------
template <typename FunctorInternal>
void ExecuteFunctorSTDThread(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::STDThread>::For(
vtkIdType first, vtkIdType last, vtkIdType grain, FunctorInternal& fi)
{
vtkIdType n = last - first;
if (n <= 0)
{
return;
}
if (grain >= n || (!this->NestedActivated && this->IsParallel))
{
fi.Execute(first, last);
}
else
{
int threadNumber = GetNumberOfThreadsSTDThread();
if (grain <= 0)
{
vtkIdType estimateGrain = (last - first) / (threadNumber * 4);
grain = (estimateGrain > 0) ? estimateGrain : 1;
}
// /!\ 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);
vtkSMPThreadPool pool(threadNumber);
PushThreadId((pool.GetThreads())->at(0).get_id());
for (vtkIdType from = first; from < last; from += grain)
{
auto job = std::bind(ExecuteFunctorSTDThread<FunctorInternal>, &fi, from, grain, last);
pool.DoJob(job);
}
pool.Join();
PopThreadId();
// 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::STDThread>::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::STDThread>::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::STDThread>::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::STDThread>::Sort(
RandomAccessIterator begin, RandomAccessIterator end)
{
std::sort(begin, end);
}
//--------------------------------------------------------------------------------
template <>
template <typename RandomAccessIterator, typename Compare>
void vtkSMPToolsImpl<BackendType::STDThread>::Sort(
RandomAccessIterator begin, RandomAccessIterator end, Compare comp)
{
std::sort(begin, end, comp);
}
//--------------------------------------------------------------------------------
template <>
void vtkSMPToolsImpl<BackendType::STDThread>::Initialize(int);
//--------------------------------------------------------------------------------
template <>
int vtkSMPToolsImpl<BackendType::STDThread>::GetEstimatedNumberOfThreads();
//--------------------------------------------------------------------------------
template <>
bool vtkSMPToolsImpl<BackendType::STDThread>::GetSingleThread();
VTK_ABI_NAMESPACE_END
} // namespace smp
} // namespace detail
} // namespace vtk
#endif
|
