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
|
/*=========================================================================
*
* Copyright NumFOCUS
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef itkThreadedIteratorRangePartitioner_h
#define itkThreadedIteratorRangePartitioner_h
#include "itkThreadedDomainPartitioner.h"
#include "itkObjectFactory.h"
namespace itk
{
// Forward reference because of circular dependencies
template <typename TIterator>
class ITK_TEMPLATE_EXPORT ThreadedIteratorRangePartitioner;
/** \class ThreadedIteratorRangePartitionerDomain
* \brief Domain type for the ThreadedIteratorRangePartitioner.
*
* Contains a Begin and End iterator.
*
* \ingroup ITKCommon
*/
template <typename TIterator>
class ITK_TEMPLATE_EXPORT ThreadedIteratorRangePartitionerDomain
{
public:
using IteratorType = TIterator;
using Self = ThreadedIteratorRangePartitionerDomain;
ThreadedIteratorRangePartitionerDomain() = default;
ThreadedIteratorRangePartitionerDomain(const IteratorType & begin, const IteratorType & end)
{
this->m_Begin = begin;
this->m_End = end;
}
ThreadedIteratorRangePartitionerDomain(const Self & rhs)
{
this->m_Begin = rhs.m_Begin;
this->m_End = rhs.m_End;
}
void
operator=(const Self & rhs)
{
if (this == &rhs)
{
return;
}
this->m_Begin = rhs.m_Begin;
this->m_End = rhs.m_End;
}
const IteratorType &
Begin() const
{
return this->m_Begin;
}
const IteratorType &
End() const
{
return this->m_End;
}
private:
friend class ThreadedIteratorRangePartitioner<IteratorType>;
IteratorType m_Begin;
IteratorType m_End;
};
/** \class ThreadedIteratorRangePartitioner
* \brief Partitions an iterator range for threading.
*
* \tparam TIterator The type of the iterator.
*
* The \c DomainType is defined to be an itk::ThreadedIteratorRangePartitionerDomain,
* a two component struct of iterators: the first iterator, \c Begin, defines
* the start of the domain, and the second iterator, \c End, defines one element
* past the end of the domain.
*
* The class assumes that iterating through the domain will be a repeatable
* process.
*
* While this class will work for most containers that use iterators, indexed
* containers such as std::vector or Array will be partitioned much more efficiently
* with a ThreadedIndexedContainerPartitioner.
*
* This class is typically used as a template argument to a DomainThreader.
*
* \sa ThreadedDomainPartitioner
* \sa DomainThreader
* \sa ThreadedIndexedContainerPartitioner
* \ingroup ITKCommon
*/
template <typename TIterator>
class ITK_TEMPLATE_EXPORT ThreadedIteratorRangePartitioner
: public ThreadedDomainPartitioner<ThreadedIteratorRangePartitionerDomain<TIterator>>
{
public:
ITK_DISALLOW_COPY_AND_MOVE(ThreadedIteratorRangePartitioner);
/** Standard class type aliases. */
using Self = ThreadedIteratorRangePartitioner;
using Superclass = ThreadedDomainPartitioner<ThreadedIteratorRangePartitionerDomain<TIterator>>;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(ThreadedIteratorRangePartitioner);
/** Type for convenience of base class methods */
using typename Superclass::DomainType;
using IteratorType = TIterator;
/** Split the domain \c completeDomain into up to \c requestedTotal
* non-overlapping subdomains, setting subdomain number \c threadId as
* \c subDomain and returning the total number of subdomains actually available.
*
* This method should be called repeatedly for each value of \c threadId, from 0 up
* to the return value (which is always less than or equal to \c requestedTotal).
*
* It is an error for \c completeDomain to be zero-length.
* If \c threadId is greater than the return value, the contents of
* \c subDomain are undefined.
*/
ThreadIdType
PartitionDomain(const ThreadIdType threadId,
const ThreadIdType requestedTotal,
const DomainType & completeDomain,
DomainType & subDomain) const override;
protected:
ThreadedIteratorRangePartitioner() = default;
~ThreadedIteratorRangePartitioner() override = default;
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkThreadedIteratorRangePartitioner.hxx"
#endif
#endif
|
