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
|
// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
// .NAME vtkSMPThreadLocal - A simple thread local implementation for sequential operations.
// .SECTION Description
//
// Note that this particular implementation is designed to work in sequential
// mode and supports only 1 thread.
#ifndef SequentialvtkSMPThreadLocalImpl_h
#define SequentialvtkSMPThreadLocalImpl_h
#include "SMP/Common/vtkSMPThreadLocalImplAbstract.h"
#include "vtkSystemIncludes.h"
#include <iterator>
#include <utility> // For std::move
#include <vector>
namespace vtk
{
namespace detail
{
namespace smp
{
VTK_ABI_NAMESPACE_BEGIN
template <typename T>
class vtkSMPThreadLocalImpl<BackendType::Sequential, T> : public vtkSMPThreadLocalImplAbstract<T>
{
typedef std::vector<T> TLS;
typedef typename TLS::iterator TLSIter;
typedef typename vtkSMPThreadLocalImplAbstract<T>::ItImpl ItImplAbstract;
public:
vtkSMPThreadLocalImpl()
: NumInitialized(0)
{
this->Initialize();
}
explicit vtkSMPThreadLocalImpl(const T& exemplar)
: NumInitialized(0)
, Exemplar(exemplar)
{
this->Initialize();
}
T& Local() override
{
int tid = this->GetThreadID();
if (!this->Initialized[tid])
{
this->Internal[tid] = this->Exemplar;
this->Initialized[tid] = true;
++this->NumInitialized;
}
return this->Internal[tid];
}
size_t size() const override { return this->NumInitialized; }
class ItImpl : public vtkSMPThreadLocalImplAbstract<T>::ItImpl
{
public:
void Increment() override
{
this->InitIter++;
this->Iter++;
// Make sure to skip uninitialized
// entries.
while (this->InitIter != this->EndIter)
{
if (*this->InitIter)
{
break;
}
this->InitIter++;
this->Iter++;
}
}
bool Compare(ItImplAbstract* other) override
{
return this->Iter == static_cast<ItImpl*>(other)->Iter;
}
T& GetContent() override { return *this->Iter; }
T* GetContentPtr() override { return &*this->Iter; }
protected:
ItImpl* CloneImpl() const override { return new ItImpl(*this); }
private:
friend class vtkSMPThreadLocalImpl<BackendType::Sequential, T>;
std::vector<bool>::iterator InitIter;
std::vector<bool>::iterator EndIter;
TLSIter Iter;
};
std::unique_ptr<ItImplAbstract> begin() override
{
TLSIter iter = this->Internal.begin();
std::vector<bool>::iterator iter2 = this->Initialized.begin();
std::vector<bool>::iterator enditer = this->Initialized.end();
// fast forward to first initialized
// value
while (iter2 != enditer)
{
if (*iter2)
{
break;
}
iter2++;
iter++;
}
auto retVal = std::make_unique<ItImpl>();
retVal->InitIter = iter2;
retVal->EndIter = enditer;
retVal->Iter = iter;
return retVal;
}
std::unique_ptr<ItImplAbstract> end() override
{
auto retVal = std::make_unique<ItImpl>();
retVal->InitIter = this->Initialized.end();
retVal->EndIter = this->Initialized.end();
retVal->Iter = this->Internal.end();
return retVal;
}
private:
TLS Internal;
std::vector<bool> Initialized;
size_t NumInitialized;
T Exemplar;
void Initialize()
{
this->Internal.resize(this->GetNumberOfThreads());
this->Initialized.resize(this->GetNumberOfThreads());
std::fill(this->Initialized.begin(), this->Initialized.end(), false);
}
int GetNumberOfThreads() { return 1; }
int GetThreadID() { return 0; }
// disable copying
vtkSMPThreadLocalImpl(const vtkSMPThreadLocalImpl&) = delete;
void operator=(const vtkSMPThreadLocalImpl&) = delete;
};
VTK_ABI_NAMESPACE_END
} // namespace smp
} // namespace detail
} // namespace vtk
#endif
/* VTK-HeaderTest-Exclude: vtkSMPThreadLocalImpl.h */
|
