use more specific tag for Reducer generic

jjallaire · jjallaire · commit 342efce1159c · 2014-07-07T15:04:13.000-04:00
diff --git a/inst/include/RcppParallel.h b/inst/include/RcppParallel.h
@@ -133,8 +133,8 @@ inline void ttParallelFor(std::size_t begin, std::size_t end, Worker& worker) {
 }
 
 // Execute the IWorker over the range in parallel then join results
-template <typename T>
-inline void ttParallelReduce(std::size_t begin, std::size_t end, T& worker) {
+template <typename Reducer>
+inline void ttParallelReduce(std::size_t begin, std::size_t end, Reducer& reducer) {
   
   using namespace tthread;
   
@@ -145,10 +145,10 @@ inline void ttParallelReduce(std::size_t begin, std::size_t end, T& worker) {
   std::vector<thread*> threads;
   std::vector<Worker*> workers;
   for (std::size_t i = 0; i<ranges.size(); ++i) {
-    T* pWorker = new T();
-    pWorker->split(static_cast<T&>(worker));
-    workers.push_back(pWorker);
-    threads.push_back(new thread(workerThread, new Work(ranges[i], *pWorker)));  
+    Reducer* pReducer = new Reducer();
+    pReducer->split(static_cast<Reducer&>(reducer));
+    workers.push_back(pReducer);
+    threads.push_back(new thread(workerThread, new Work(ranges[i], *pReducer)));  
   }
   
   // wait for each thread, join it's results, then delete the worker & thread
@@ -158,14 +158,13 @@ inline void ttParallelReduce(std::size_t begin, std::size_t end, T& worker) {
     threads[i]->join();
    
     // join the results
-    worker.join(static_cast<T&>(*workers[i]));
+    reducer.join(static_cast<Reducer&>(*workers[i]));
     
     // delete the worker (which we split above) and the thread
     delete workers[i];
     delete threads[i];
   }
 }
-
 } // namespace RcppParallel
 
 ////// TBB Implementation /////////////////////////////////////////////
@@ -193,49 +192,49 @@ inline void tbbParallelFor(std::size_t begin, std::size_t end, Worker& worker) {
    tbb::parallel_for(tbb::blocked_range<size_t>(begin, end), tbbWorker);
 }
 
-template <typename T>
-struct TBBReduce 
+template <typename Reducer>
+struct TBBReducer 
 {  
-  explicit TBBReduce(T& reduce) 
-    : pReduce_(&reduce), wasSplit_(false)
+  explicit TBBReducer(Reducer& reducer) 
+    : pReducer_(&reducer), wasSplit_(false)
   {
   }
    
-  virtual ~TBBReduce() {
+  virtual ~TBBReducer() {
     try
     {
       if (wasSplit_)
-        delete pReduce_;
+        delete pReducer_;
     }
     catch(...)
     {
     }
   }
    
   void operator()(const tbb::blocked_range<size_t>& r) {
-    pReduce_->operator()(r.begin(), r.end());
+    pReducer_->operator()(r.begin(), r.end());
   }
    
-  TBBReduce(TBBReduce& reduce, tbb::split) 
-    : pReduce_(new T()), wasSplit_(true) 
+  TBBReducer(TBBReducer& reducer, tbb::split) 
+    : pReducer_(new Reducer()), wasSplit_(true) 
   {  
-    pReduce_->split(*reduce.pReduce_);   
+    pReducer_->split(*reducer.pReducer_);   
   }
   
-  void join(const TBBReduce& reduce) { 
-    pReduce_->join(*reduce.pReduce_); 
+  void join(const TBBReducer& reducer) { 
+    pReducer_->join(*reducer.pReducer_); 
   }
    
 private:
-   T* pReduce_;
+   Reducer* pReducer_;
    bool wasSplit_;
 };
 
-template <typename T>
-inline void tbbParallelReduce(std::size_t begin, std::size_t end, T& worker) {
+template <typename Reducer>
+inline void tbbParallelReduce(std::size_t begin, std::size_t end, Reducer& reducer) {
     
-   TBBReduce<T> tbbReduce(worker);
-   tbb::parallel_reduce(tbb::blocked_range<size_t>(begin, end), tbbReduce);
+   TBBReducer<Reducer> tbbReducer(reducer);
+   tbb::parallel_reduce(tbb::blocked_range<size_t>(begin, end), tbbReducer);
 }
 
 } // namespace RcppParallel
@@ -256,13 +255,13 @@ inline void parallelFor(std::size_t begin, std::size_t end, Worker& worker) {
 
 }
 
-template <typename T>
-inline void parallelReduce(std::size_t begin, std::size_t end, T& worker) {
+template <typename Reducer>
+inline void parallelReduce(std::size_t begin, std::size_t end, Reducer& reducer) {
 
 #if RCPP_PARALLEL_USE_TBB
-  tbbParallelReduce(begin, end, worker);
+  tbbParallelReduce(begin, end, reducer);
 #else
-  ttParallelReduce(begin, end, worker);
+  ttParallelReduce(begin, end, reducer);
 #endif
 
 }

Original file line number	Diff line number	Diff line change
`@@ -133,8 +133,8 @@ inline void ttParallelFor(std::size_t begin, std::size_t end, Worker& worker) {`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`// Execute the IWorker over the range in parallel then join results`
`136`		`-template <typename T>`
`137`		`-inline void ttParallelReduce(std::size_t begin, std::size_t end, T& worker) {`
	`136`	`+template <typename Reducer>`
	`137`	`+inline void ttParallelReduce(std::size_t begin, std::size_t end, Reducer& reducer) {`
`138`	`138`
`139`	`139`	`using namespace tthread;`
`140`	`140`
`@@ -145,10 +145,10 @@ inline void ttParallelReduce(std::size_t begin, std::size_t end, T& worker) {`
`145`	`145`	`std::vector<thread*> threads;`
`146`	`146`	`std::vector<Worker*> workers;`
`147`	`147`	`for (std::size_t i = 0; i<ranges.size(); ++i) {`
`148`		`- T* pWorker = new T();`
`149`		`- pWorker->split(static_cast<T&>(worker));`
`150`		`- workers.push_back(pWorker);`
`151`		`- threads.push_back(new thread(workerThread, new Work(ranges[i], *pWorker)));`
	`148`	`+ Reducer* pReducer = new Reducer();`
	`149`	`+ pReducer->split(static_cast<Reducer&>(reducer));`
	`150`	`+ workers.push_back(pReducer);`
	`151`	`+ threads.push_back(new thread(workerThread, new Work(ranges[i], *pReducer)));`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`// wait for each thread, join it's results, then delete the worker & thread`
`@@ -158,14 +158,13 @@ inline void ttParallelReduce(std::size_t begin, std::size_t end, T& worker) {`
`158`	`158`	`threads[i]->join();`
`159`	`159`
`160`	`160`	`// join the results`
`161`		`- worker.join(static_cast<T&>(*workers[i]));`
	`161`	`+ reducer.join(static_cast<Reducer&>(*workers[i]));`
`162`	`162`
`163`	`163`	`// delete the worker (which we split above) and the thread`
`164`	`164`	`delete workers[i];`
`165`	`165`	`delete threads[i];`
`166`	`166`	`}`
`167`	`167`	`}`
`168`		`-`
`169`	`168`	`} // namespace RcppParallel`
`170`	`169`
`171`	`170`	`////// TBB Implementation /////////////////////////////////////////////`
`@@ -193,49 +192,49 @@ inline void tbbParallelFor(std::size_t begin, std::size_t end, Worker& worker) {`
`193`	`192`	`tbb::parallel_for(tbb::blocked_range<size_t>(begin, end), tbbWorker);`
`194`	`193`	`}`
`195`	`194`
`196`		`-template <typename T>`
`197`		`-struct TBBReduce`
	`195`	`+template <typename Reducer>`
	`196`	`+struct TBBReducer`
`198`	`197`	`{`
`199`		`- explicit TBBReduce(T& reduce)`
`200`		`- : pReduce_(&reduce), wasSplit_(false)`
	`198`	`+ explicit TBBReducer(Reducer& reducer)`
	`199`	`+ : pReducer_(&reducer), wasSplit_(false)`
`201`	`200`	`{`
`202`	`201`	`}`
`203`	`202`
`204`		`- virtual ~TBBReduce() {`
	`203`	`+ virtual ~TBBReducer() {`
`205`	`204`	`try`
`206`	`205`	`{`
`207`	`206`	`if (wasSplit_)`
`208`		`- delete pReduce_;`
	`207`	`+ delete pReducer_;`
`209`	`208`	`}`
`210`	`209`	`catch(...)`
`211`	`210`	`{`
`212`	`211`	`}`
`213`	`212`	`}`
`214`	`213`
`215`	`214`	`void operator()(const tbb::blocked_range<size_t>& r) {`
`216`		`- pReduce_->operator()(r.begin(), r.end());`
	`215`	`+ pReducer_->operator()(r.begin(), r.end());`
`217`	`216`	`}`
`218`	`217`
`219`		`- TBBReduce(TBBReduce& reduce, tbb::split)`
`220`		`- : pReduce_(new T()), wasSplit_(true)`
	`218`	`+ TBBReducer(TBBReducer& reducer, tbb::split)`
	`219`	`+ : pReducer_(new Reducer()), wasSplit_(true)`
`221`	`220`	`{`
`222`		`- pReduce_->split(*reduce.pReduce_);`
	`221`	`+ pReducer_->split(*reducer.pReducer_);`
`223`	`222`	`}`
`224`	`223`
`225`		`- void join(const TBBReduce& reduce) {`
`226`		`- pReduce_->join(*reduce.pReduce_);`
	`224`	`+ void join(const TBBReducer& reducer) {`
	`225`	`+ pReducer_->join(*reducer.pReducer_);`
`227`	`226`	`}`
`228`	`227`
`229`	`228`	`private:`
`230`		`- T* pReduce_;`
	`229`	`+ Reducer* pReducer_;`
`231`	`230`	`bool wasSplit_;`
`232`	`231`	`};`
`233`	`232`
`234`		`-template <typename T>`
`235`		`-inline void tbbParallelReduce(std::size_t begin, std::size_t end, T& worker) {`
	`233`	`+template <typename Reducer>`
	`234`	`+inline void tbbParallelReduce(std::size_t begin, std::size_t end, Reducer& reducer) {`
`236`	`235`
`237`		`- TBBReduce<T> tbbReduce(worker);`
`238`		`- tbb::parallel_reduce(tbb::blocked_range<size_t>(begin, end), tbbReduce);`
	`236`	`+ TBBReducer<Reducer> tbbReducer(reducer);`
	`237`	`+ tbb::parallel_reduce(tbb::blocked_range<size_t>(begin, end), tbbReducer);`
`239`	`238`	`}`
`240`	`239`
`241`	`240`	`} // namespace RcppParallel`
`@@ -256,13 +255,13 @@ inline void parallelFor(std::size_t begin, std::size_t end, Worker& worker) {`
`256`	`255`
`257`	`256`	`}`
`258`	`257`
`259`		`-template <typename T>`
`260`		`-inline void parallelReduce(std::size_t begin, std::size_t end, T& worker) {`
	`258`	`+template <typename Reducer>`
	`259`	`+inline void parallelReduce(std::size_t begin, std::size_t end, Reducer& reducer) {`
`261`	`260`
`262`	`261`	`#if RCPP_PARALLEL_USE_TBB`
`263`		`- tbbParallelReduce(begin, end, worker);`
	`262`	`+ tbbParallelReduce(begin, end, reducer);`
`264`	`263`	`#else`
`265`		`- ttParallelReduce(begin, end, worker);`
	`264`	`+ ttParallelReduce(begin, end, reducer);`
`266`	`265`	`#endif`
`267`	`266`
`268`	`267`	`}`