Skip to content

Commit fe26cae

Browse files
jjallairejjallaire
committed
indent 3 spaces
1 parent e438e05 commit fe26cae

File tree

1 file changed

+128
-129
lines changed

1 file changed

+128
-129
lines changed

‎inst/include/RcppParallel.h‎

Lines changed: 128 additions & 129 deletions
Original file line numberDiff line numberDiff line change
@@ -20,8 +20,8 @@ namespace RcppParallel {
2020
// cast the void* to within the worker thread.
2121

2222
struct Worker {
23-
virtual ~Worker() {}
24-
virtual void operator()(std::size_t begin, std::size_t end) = 0;
23+
virtual ~Worker() {}
24+
virtual void operator()(std::size_t begin, std::size_t end) = 0;
2525
};
2626

2727
} // namespace RcppParallel
@@ -45,134 +45,134 @@ namespace {
4545
class IndexRange {
4646
public:
4747

48-
// Initizlize with a begin and (exclusive) end index
49-
IndexRange(std::size_t begin, std::size_t end)
48+
// Initizlize with a begin and (exclusive) end index
49+
IndexRange(std::size_t begin, std::size_t end)
5050
: begin_(begin), end_(end)
51-
{
52-
}
51+
{
52+
}
5353

54-
// Access begin() and end()
55-
std::size_t begin() const { return begin_; }
56-
std::size_t end() const { return end_; }
54+
// Access begin() and end()
55+
std::size_t begin() const { return begin_; }
56+
std::size_t end() const { return end_; }
5757

5858
private:
59-
std::size_t begin_;
60-
std::size_t end_;
59+
std::size_t begin_;
60+
std::size_t end_;
6161
};
6262

6363

6464
// Because tinythread allows us to pass only a plain C function
6565
// we need to pass our worker and range within a struct that we
6666
// can cast to/from void*
6767
struct Work {
68-
Work(IndexRange range, Worker& worker)
68+
Work(IndexRange range, Worker& worker)
6969
: range(range), worker(worker)
70-
{
71-
}
72-
IndexRange range;
73-
Worker& worker;
70+
{
71+
}
72+
IndexRange range;
73+
Worker& worker;
7474
};
7575

7676
// Thread which performs work (then deletes the work object
7777
// when it's done)
7878
extern "C" inline void workerThread(void* data) {
79-
try
80-
{
81-
Work* pWork = static_cast<Work*>(data);
82-
pWork->worker(pWork->range.begin(), pWork->range.end());
83-
delete pWork;
84-
}
85-
catch(...)
86-
{
87-
}
79+
try
80+
{
81+
Work* pWork = static_cast<Work*>(data);
82+
pWork->worker(pWork->range.begin(), pWork->range.end());
83+
delete pWork;
84+
}
85+
catch(...)
86+
{
87+
}
8888
}
8989

9090
// Function to calculate the ranges for a given input
9191
std::vector<IndexRange> splitInputRange(const IndexRange& range) {
9292

93-
// determine number of threads
94-
std::size_t threads = tthread::thread::hardware_concurrency();
95-
char* numThreads = ::getenv("RCPP_PARALLEL_NUM_THREADS");
96-
if (numThreads != NULL) {
97-
int parsedThreads = ::atoi(numThreads);
98-
if (parsedThreads > 0)
99-
threads = parsedThreads;
100-
}
93+
// determine number of threads
94+
std::size_t threads = tthread::thread::hardware_concurrency();
95+
char* numThreads = ::getenv("RCPP_PARALLEL_NUM_THREADS");
96+
if (numThreads != NULL) {
97+
int parsedThreads = ::atoi(numThreads);
98+
if (parsedThreads > 0)
99+
threads = parsedThreads;
100+
}
101101

102-
// determine the chunk size
103-
std::size_t length = range.end() - range.begin();
104-
std::size_t chunkSize = length / threads;
102+
// determine the chunk size
103+
std::size_t length = range.end() - range.begin();
104+
std::size_t chunkSize = length / threads;
105105

106-
// allocate ranges
107-
std::vector<IndexRange> ranges;
108-
std::size_t nextIndex = range.begin();
109-
for (std::size_t i = 0; i<threads; i++) {
110-
std::size_t begin = nextIndex;
111-
std::size_t end = std::min(begin + chunkSize, range.end());
112-
ranges.push_back(IndexRange(begin, end));
113-
nextIndex = end;
114-
}
115-
116-
// return ranges
117-
return ranges;
106+
// allocate ranges
107+
std::vector<IndexRange> ranges;
108+
std::size_t nextIndex = range.begin();
109+
for (std::size_t i = 0; i<threads; i++) {
110+
std::size_t begin = nextIndex;
111+
std::size_t end = std::min(begin + chunkSize, range.end());
112+
ranges.push_back(IndexRange(begin, end));
113+
nextIndex = end;
114+
}
115+
116+
// return ranges
117+
return ranges;
118118
}
119119

120120
} // anonymous namespace
121121

122-
// Execute the IWorker over the IndexRange in parallel
122+
// Execute the Worker over the IndexRange in parallel
123123
inline void ttParallelFor(std::size_t begin, std::size_t end, Worker& worker) {
124124

125-
using namespace tthread;
126-
127-
// split the work
128-
std::vector<IndexRange> ranges = splitInputRange(IndexRange(begin, end));
129-
130-
// create threads
131-
std::vector<thread*> threads;
132-
for (std::size_t i = 0; i<ranges.size(); ++i) {
133-
threads.push_back(new thread(workerThread, new Work(ranges[i], worker)));
134-
}
135-
136-
// join and delete them
137-
for (std::size_t i = 0; i<threads.size(); ++i) {
138-
threads[i]->join();
139-
delete threads[i];
140-
}
125+
using namespace tthread;
126+
127+
// split the work
128+
std::vector<IndexRange> ranges = splitInputRange(IndexRange(begin, end));
129+
130+
// create threads
131+
std::vector<thread*> threads;
132+
for (std::size_t i = 0; i<ranges.size(); ++i) {
133+
threads.push_back(new thread(workerThread, new Work(ranges[i], worker)));
134+
}
135+
136+
// join and delete them
137+
for (std::size_t i = 0; i<threads.size(); ++i) {
138+
threads[i]->join();
139+
delete threads[i];
140+
}
141141
}
142142

143143
// Execute the IWorker over the range in parallel then join results
144144
template <typename Reducer>
145145
inline void ttParallelReduce(std::size_t begin, std::size_t end, Reducer& reducer) {
146146

147-
using namespace tthread;
148-
149-
// split the work
150-
std::vector<IndexRange> ranges = splitInputRange(IndexRange(begin, end));
151-
152-
// create threads (split for each thread and track the allocated workers)
153-
std::vector<thread*> threads;
154-
std::vector<Worker*> workers;
155-
for (std::size_t i = 0; i<ranges.size(); ++i) {
156-
Reducer* pReducer = new Reducer();
157-
pReducer->split(static_cast<Reducer&>(reducer));
158-
workers.push_back(pReducer);
159-
threads.push_back(new thread(workerThread, new Work(ranges[i], *pReducer)));
160-
}
161-
162-
// wait for each thread, join it's results, then delete the worker & thread
163-
for (std::size_t i = 0; i<threads.size(); ++i) {
164-
165-
// wait for thread
166-
threads[i]->join();
147+
using namespace tthread;
148+
149+
// split the work
150+
std::vector<IndexRange> ranges = splitInputRange(IndexRange(begin, end));
151+
152+
// create threads (split for each thread and track the allocated workers)
153+
std::vector<thread*> threads;
154+
std::vector<Worker*> workers;
155+
for (std::size_t i = 0; i<ranges.size(); ++i) {
156+
Reducer* pReducer = new Reducer();
157+
pReducer->split(static_cast<Reducer&>(reducer));
158+
workers.push_back(pReducer);
159+
threads.push_back(new thread(workerThread, new Work(ranges[i], *pReducer)));
160+
}
167161

168-
// join the results
169-
reducer.join(static_cast<Reducer&>(*workers[i]));
170-
171-
// delete the worker (which we split above) and the thread
172-
delete workers[i];
173-
delete threads[i];
174-
}
162+
// wait for each thread, join it's results, then delete the worker & thread
163+
for (std::size_t i = 0; i<threads.size(); ++i) {
164+
// wait for thread
165+
threads[i]->join();
166+
167+
// join the results
168+
reducer.join(static_cast<Reducer&>(*workers[i]));
169+
170+
// delete the worker (which we split above) and the thread
171+
delete workers[i];
172+
delete threads[i];
173+
}
175174
}
175+
176176
} // namespace RcppParallel
177177

178178
////// TBB Implementation /////////////////////////////////////////////
@@ -185,14 +185,14 @@ namespace RcppParallel {
185185

186186
struct TBBWorker
187187
{
188-
explicit TBBWorker(Worker& worker) : worker_(worker) {}
189-
190-
void operator()(const tbb::blocked_range<size_t>& r) const {
191-
worker_(r.begin(), r.end());
192-
}
193-
188+
explicit TBBWorker(Worker& worker) : worker_(worker) {}
189+
190+
void operator()(const tbb::blocked_range<size_t>& r) const {
191+
worker_(r.begin(), r.end());
192+
}
193+
194194
private:
195-
Worker& worker_;
195+
Worker& worker_;
196196
};
197197

198198
inline void tbbParallelFor(std::size_t begin, std::size_t end, Worker& worker) {
@@ -203,35 +203,35 @@ inline void tbbParallelFor(std::size_t begin, std::size_t end, Worker& worker) {
203203
template <typename Reducer>
204204
struct TBBReducer
205205
{
206-
explicit TBBReducer(Reducer& reducer)
206+
explicit TBBReducer(Reducer& reducer)
207207
: pReducer_(&reducer), wasSplit_(false)
208-
{
209-
}
208+
{
209+
}
210210

211-
virtual ~TBBReducer() {
212-
try
213-
{
214-
if (wasSplit_)
215-
delete pReducer_;
216-
}
217-
catch(...)
218-
{
219-
}
220-
}
211+
virtual ~TBBReducer() {
212+
try
213+
{
214+
if (wasSplit_)
215+
delete pReducer_;
216+
}
217+
catch(...)
218+
{
219+
}
220+
}
221221

222-
void operator()(const tbb::blocked_range<size_t>& r) {
223-
pReducer_->operator()(r.begin(), r.end());
224-
}
222+
void operator()(const tbb::blocked_range<size_t>& r) {
223+
pReducer_->operator()(r.begin(), r.end());
224+
}
225225

226-
TBBReducer(TBBReducer& reducer, tbb::split)
227-
: pReducer_(new Reducer()), wasSplit_(true)
228-
{
229-
pReducer_->split(*reducer.pReducer_);
230-
}
231-
232-
void join(const TBBReducer& reducer) {
233-
pReducer_->join(*reducer.pReducer_);
234-
}
226+
TBBReducer(TBBReducer& reducer, tbb::split)
227+
: pReducer_(new Reducer()), wasSplit_(true)
228+
{
229+
pReducer_->split(*reducer.pReducer_);
230+
}
231+
232+
void join(const TBBReducer& reducer) {
233+
pReducer_->join(*reducer.pReducer_);
234+
}
235235

236236
private:
237237
Reducer* pReducer_;
@@ -240,7 +240,6 @@ struct TBBReducer
240240

241241
template <typename Reducer>
242242
inline void tbbParallelReduce(std::size_t begin, std::size_t end, Reducer& reducer) {
243-
244243
TBBReducer<Reducer> tbbReducer(reducer);
245244
tbb::parallel_reduce(tbb::blocked_range<size_t>(begin, end), tbbReducer);
246245
}
@@ -256,9 +255,9 @@ namespace RcppParallel {
256255
inline void parallelFor(std::size_t begin, std::size_t end, Worker& worker) {
257256

258257
#if RCPP_PARALLEL_USE_TBB
259-
tbbParallelFor(begin, end, worker);
258+
tbbParallelFor(begin, end, worker);
260259
#else
261-
ttParallelFor(begin, end, worker);
260+
ttParallelFor(begin, end, worker);
262261
#endif
263262

264263
}
@@ -267,9 +266,9 @@ template <typename Reducer>
267266
inline void parallelReduce(std::size_t begin, std::size_t end, Reducer& reducer) {
268267

269268
#if RCPP_PARALLEL_USE_TBB
270-
tbbParallelReduce(begin, end, reducer);
269+
tbbParallelReduce(begin, end, reducer);
271270
#else
272-
ttParallelReduce(begin, end, reducer);
271+
ttParallelReduce(begin, end, reducer);
273272
#endif
274273

275274
}

0 commit comments

Comments
 (0)