Use thread group

Author: dcwhite

src/Core/Thread/Parallel.cc

@@ -36,7 +36,7 @@ using namespace SCIRun::Core::Thread;
 void Parallel::RunTasks(IndexedTask task, int numProcs)
 {
   boost::thread_group threads;
-  
+
   for (int i = 0; i < numProcs; ++i)
   {
     threads.create_thread(boost::bind(task, i));

src/Dataflow/Engine/Scheduler/DynamicExecutor/WorkUnitConsumer.h

@@ -34,7 +34,7 @@
 #include <Dataflow/Engine/Scheduler/DynamicExecutor/WorkUnitExecutor.h>
 #include <Dataflow/Network/NetworkInterface.h>
 #include <Core/Logging/Log.h>
-#include <boost/thread.hpp>
+#include <boost/thread/thread.hpp>
 
 #include <Dataflow/Engine/Scheduler/share.h>
 
@@ -86,7 +86,7 @@ namespace DynamicExecutor {
 
             ModuleExecutor executor(unit, lookup_, producer_);
             /// @todo: thread pool
-            boost::thread t(boost::bind(&ModuleExecutor::run, executor));
+            threads_.create_thread(boost::bind(&ModuleExecutor::run, executor));
           }
           else
           {
@@ -107,6 +107,8 @@ namespace DynamicExecutor {
     ModuleWorkQueuePtr work_;
     ProducerInterfacePtr producer_;
     const Networks::ExecutableLookup* lookup_;
+    mutable boost::thread_group threads_;
+
     static Core::Logging::Log& log_;
     bool shouldLog_;
   };
@@ -116,4 +118,4 @@ namespace DynamicExecutor {
 }}
 }}
 
-#endif
+#endif

src/Dataflow/Engine/Scheduler/DynamicExecutor/WorkUnitProducer.h

@@ -48,10 +48,8 @@ namespace SCIRun {
         {
         public:
           ModuleProducer(const Networks::ModuleFilter& filter,
-            const Networks::ExecutableLookup* lookup, const ExecutionBounds& bounds, 
             const Networks::NetworkInterface* network, Core::Thread::Mutex* lock, ModuleWorkQueuePtr work, size_t numModules) :
-          scheduler_(filter),
-          lookup_(lookup), bounds_(bounds), network_(network), lock_(lock),
+            scheduler_(filter), network_(network), lock_(lock),
             work_(work), doneCount_(0), shouldLog_(SCIRun::Core::Logging::Log::get().verbose()), numModules_(numModules)
           {
             log_.setVerbose(shouldLog_);
@@ -79,7 +77,7 @@ namespace SCIRun {
                 {
                   if (shouldLog_)
                     log_ << Core::Logging::DEBUG_LOG << "Producer pushing module " << mod.second << std::endl;
-                  
+
                   if (doneIds_.find(mod.second) != doneIds_.end())
                   {
                     if (shouldLog_)
@@ -113,14 +111,12 @@ namespace SCIRun {
               log_ << Core::Logging::DEBUG_LOG << "Producer is done." << std::endl;
           }
 
-          bool isDone() const 
+          bool isDone() const
           {
             return doneCount_ >= numModules_;
           }
         private:
           BoostGraphParallelScheduler scheduler_;
-          const Networks::ExecutableLookup* lookup_;
-          const ExecutionBounds& bounds_;
           const Networks::NetworkInterface* network_;
           Core::Thread::Mutex* lock_;
           ModuleWorkQueuePtr work_;
@@ -137,4 +133,4 @@ namespace SCIRun {
 
   }}
 
-#endif
+#endif

src/Dataflow/Engine/Scheduler/DynamicMultithreadedNetworkExecutor.cc

@@ -56,7 +56,7 @@ namespace SCIRun {
           bounds_(&context.bounds()),
           work_(new DynamicExecutor::ModuleWorkQueue(numModules)),
           producer_(new DynamicExecutor::ModuleProducer(context.addAdditionalFilter(ModuleWaitingFilter::Instance()),
-            lookup_, context.bounds(), network, lock, work_, numModules)),
+            network, lock, work_, numModules)),
             consumer_(new DynamicExecutor::ModuleConsumer(work_, lookup_, producer_)),
           network_(network)
         {