Merge branch 'master' into hide-non-working-widgets

Conflicts:
	src/Interface/Modules/Visualization/ShowFieldDialog.cc

Author: cbrightsci

README.md

@@ -25,7 +25,7 @@ https://github.com/SCIInstitute/SCIRun
 |:--------:|:-------------------------------------------------------------------------------------:|
 
 ###Goals
-SCIRun 5 is a complete rewrite of the GUI front end and graphical components of SCIRun 4, including a more stable and 
+SCIRun 5 is a complete rewrite of the GUI front end and graphical components of SCIRun 4, including a more stable and
 efficient middle layer, with support for Python scripting.
 
 ### Documentation
@@ -39,11 +39,11 @@ For documentation, please see: http://sciinstitute.github.io/SCIRun/
     + Download from http://releases.qt-project.org/qt4/source/qt-mac-opensource-4.8.4.dmg.
 * Windows (tested on Windows 7, 8)
   - Visual Studio 2013
-  - Qt 4.8 
+  - Qt 4.8
     + Build from source (see http://scirundocwiki.sci.utah.edu/SCIRunDocs/index.php/CIBC:Seg3D2:Building_Releases#Installing_Qt_on_your_system_and_building_from_scratch for instructions), but be sure to download http://releases.qt-project.org/qt4/source/qt-everywhere-opensource-src-4.8.4.tar.gz.
 * Linux (tested on Ubuntu 12.10)
   - gcc 4.6, 4.7
-  - Qt 4.8 
+  - Qt 4.8
     + Build from source (http://releases.qt-project.org/qt4/source/qt-everywhere-opensource-src-4.8.4.tar.gz), or use system libraries if available.
 * All platforms
   - CMake 2.8
@@ -56,8 +56,8 @@ For documentation, please see: http://sciinstitute.github.io/SCIRun/
 * Windows
   - Visual Studio 2013
 * OS X (tested on 10.7 and 10.8 and 10.10)
-  - Unix Makefiles 
-  - Xcode 
+  - Unix Makefiles
+  - Xcode
 * Linux (tested on Ubuntu 12.10)
   - Unix Makefiles
 
@@ -71,23 +71,23 @@ For help, email the testing mailing list at [email protected].
 
 ### License and Credits
   For more information, please see: http://software.sci.utah.edu
- 
+
   The MIT License
- 
-  Copyright (c) 2013 Scientific Computing and Imaging Institute,
+
+  Copyright (c) 2015 Scientific Computing and Imaging Institute,
   University of Utah.
- 
-  
+
+
   Permission is hereby granted, free of charge, to any person obtaining a
   copy of this software and associated documentation files (the "Software"),
   to deal in the Software without restriction, including without limitation
   the rights to use, copy, modify, merge, publish, distribute, sublicense,
   and/or sell copies of the Software, and to permit persons to whom the
   Software is furnished to do so, subject to the following conditions:
- 
+
   The above copyright notice and this permission notice shall be included
   in all copies or substantial portions of the Software.
- 
+
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

src/Core/Algorithms/Math/GetMatrixSliceAlgo.cc

@@ -43,13 +43,20 @@ using namespace SCIRun::Core::Algorithms::Math;
 ALGORITHM_PARAMETER_DEF(Math, IsSliceColumn);
 ALGORITHM_PARAMETER_DEF(Math, SliceIndex);
 ALGORITHM_PARAMETER_DEF(Math, MaxIndex);
-ALGORITHM_PARAMETER_DEF(Math, PlayMode);
+ALGORITHM_PARAMETER_DEF(Math, PlayModeActive);
+ALGORITHM_PARAMETER_DEF(Math, PlayModeType);
+ALGORITHM_PARAMETER_DEF(Math, SliceIncrement);
+ALGORITHM_PARAMETER_DEF(Math, PlayModeDelay);
 
 GetMatrixSliceAlgo::GetMatrixSliceAlgo()
 {
   addParameter(Parameters::IsSliceColumn, true);
   addParameter(Parameters::SliceIndex, 0);
-  addParameter(Parameters::PlayMode, false);
+  addParameter(Parameters::PlayModeActive, false);
+  //TODO DAN: make overload to handle const char*
+  add_option(Parameters::PlayModeType, "looponce", "looponce|loopforever"); //TODO add more play options
+  addParameter(Parameters::SliceIncrement, 1);
+  addParameter(Parameters::PlayModeDelay, 0);
 }
 
 AlgorithmOutput GetMatrixSliceAlgo::run_generic(const AlgorithmInput& input) const

src/Core/Algorithms/Math/GetMatrixSliceAlgo.h

@@ -42,7 +42,10 @@ namespace SCIRun {
         ALGORITHM_PARAMETER_DECL(IsSliceColumn);
         ALGORITHM_PARAMETER_DECL(SliceIndex);
         ALGORITHM_PARAMETER_DECL(MaxIndex);
-				ALGORITHM_PARAMETER_DECL(PlayMode);
+				ALGORITHM_PARAMETER_DECL(PlayModeActive);
+        ALGORITHM_PARAMETER_DECL(PlayModeType);
+        ALGORITHM_PARAMETER_DECL(SliceIncrement);
+        ALGORITHM_PARAMETER_DECL(PlayModeDelay);
 
         class SCISHARE GetMatrixSliceAlgo : public AlgorithmBase
         {

src/Dataflow/Engine/Controller/NetworkEditorController.cc

@@ -335,8 +335,8 @@ void NetworkEditorController::clear()
 
 // TODO:
 // - [X] refactor duplication
-// - [ ] set up execution context queue
-// - [ ] separate threads for looping through queue: another producer/consumer pair
+// - [X] set up execution context queue
+// - [X] separate threads for looping through queue: another producer/consumer pair
 
 void NetworkEditorController::executeAll(const ExecutableLookup* lookup)
 {
@@ -356,7 +356,6 @@ void NetworkEditorController::initExecutor()
 
 ExecutionContextHandle NetworkEditorController::createExecutionContext(const ExecutableLookup* lookup, ModuleFilter filter)
 {
-  theNetwork_->setModuleExecutionState(ModuleInterface::Waiting, filter);
   return boost::make_shared<ExecutionContext>(*theNetwork_, lookup ? *lookup : *theNetwork_, filter);
 }
 

src/Dataflow/Engine/Scheduler/BasicMultithreadedNetworkExecutor.cc

@@ -42,12 +42,14 @@ namespace
 {
   struct ParallelExecution : public WaitsForStartupInitialization
   {
-    ParallelExecution(const ExecutableLookup* lookup, const ParallelModuleExecutionOrder& order, const ExecutionBounds& bounds) : lookup_(lookup), order_(order), bounds_(bounds)
+    ParallelExecution(const ExecutableLookup* lookup, const ParallelModuleExecutionOrder& order, const ExecutionBounds& bounds, Mutex* executionLock) 
+      : lookup_(lookup), order_(order), bounds_(bounds), executionLock_(executionLock)
     {}
 
     void operator()() const
     {
       waitForStartupInit(*lookup_);
+      Guard g(executionLock_->get());
       /// @todo ESSENTIAL: scoped start/finish signaling
       bounds_.executeStarts_();
       for (int group = order_.minGroup(); group <= order_.maxGroup(); ++group)
@@ -70,12 +72,13 @@ namespace
     const ExecutableLookup* lookup_;
     ParallelModuleExecutionOrder order_;
     const ExecutionBounds& bounds_;
+    Mutex* executionLock_;
   };
 
 }
 
-void BasicMultithreadedNetworkExecutor::execute(const ExecutionContext& context, ParallelModuleExecutionOrder order)
+void BasicMultithreadedNetworkExecutor::execute(const ExecutionContext& context, ParallelModuleExecutionOrder order, Mutex& executionLock)
 {
-  ParallelExecution runner(&context.lookup, order, context.bounds());
+  ParallelExecution runner(&context.lookup, order, context.bounds(), &executionLock);
   boost::thread execution(runner);
 }

src/Dataflow/Engine/Scheduler/BasicMultithreadedNetworkExecutor.h

@@ -42,7 +42,7 @@ namespace Engine {
   class SCISHARE BasicMultithreadedNetworkExecutor : public NetworkExecutor<ParallelModuleExecutionOrder>
   {
   public:
-    virtual void execute(const ExecutionContext& context, ParallelModuleExecutionOrder order) override;
+    virtual void execute(const ExecutionContext& context, ParallelModuleExecutionOrder order, Core::Thread::Mutex& executionLock) override;
   };
 
 }}}

src/Dataflow/Engine/Scheduler/BasicParallelExecutionStrategy.cc

@@ -34,11 +34,12 @@
 
 using namespace SCIRun::Dataflow::Engine;
 using namespace SCIRun::Dataflow::Networks;
+using namespace SCIRun::Core::Thread;
 
-void BasicParallelExecutionStrategy::execute(const ExecutionContext& context)
+void BasicParallelExecutionStrategy::execute(const ExecutionContext& context, Mutex& executionLock)
 {
   auto filter = context.addAdditionalFilter(ExecuteAllModules::Instance());
   BoostGraphParallelScheduler scheduler(filter);
   BasicMultithreadedNetworkExecutor executor;
-  executeWithCycleCheck(scheduler, executor, context);
+  executeWithCycleCheck(scheduler, executor, context, executionLock);
 }

src/Dataflow/Engine/Scheduler/BasicParallelExecutionStrategy.h

@@ -40,7 +40,7 @@ namespace SCIRun {
       class SCISHARE BasicParallelExecutionStrategy : public ExecutionStrategy
       {
       public:
-        virtual void execute(const ExecutionContext& context) override;
+        virtual void execute(const ExecutionContext& context, Core::Thread::Mutex& executionLock) override;
       };
 
     }

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

@@ -49,15 +49,16 @@ namespace SCIRun {
         public:
           ModuleProducer(const Networks::ModuleFilter& filter,
             const Networks::NetworkInterface* network, Core::Thread::Mutex* lock, ModuleWorkQueuePtr work, size_t numModules) :
-            scheduler_(filter), network_(network), lock_(lock),
-            work_(work), doneCount_(0), shouldLog_(SCIRun::Core::Logging::Log::get().verbose()), numModules_(numModules)
+            scheduler_(filter), network_(network), enqueueLock_(lock),
+            work_(work), doneCount_(0), badGroup_(false),
+            shouldLog_(SCIRun::Core::Logging::Log::get().verbose()), numModules_(numModules)
           {
             log_.setVerbose(shouldLog_);
           }
 
           virtual void enqueueReadyModules() const
           {
-            Core::Thread::Guard g(lock_->get());
+            Core::Thread::Guard g(enqueueLock_->get());
             if (!isDone())
             {
               auto order = scheduler_.schedule(*network_);
@@ -68,6 +69,10 @@ namespace SCIRun {
                 log_ << Core::Logging::DEBUG_LOG << ostr.str() << std::endl;
                 log_ << Core::Logging::DEBUG_LOG << "Producer processing min group " << order.minGroup();
               }
+              if (order.minGroup() < 0)
+              {
+                badGroup_ = true;
+              }
               auto groupIter = order.getGroup(order.minGroup());
               BOOST_FOREACH(const ParallelModuleExecutionOrder::ModulesByGroup::value_type& mod, groupIter)
               {
@@ -81,7 +86,7 @@ namespace SCIRun {
                   if (doneIds_.find(mod.second) != doneIds_.end())
                   {
                     if (shouldLog_)
-                      SCIRun::Core::Logging::Log::get() << SCIRun::Core::Logging::INFO << "Module producer: wants to enqueue module " << mod.second << " a second time." << std::endl;
+                      SCIRun::Core::Logging::Log::get() << SCIRun::Core::Logging::INFO << "Module producer: wants to enqueue module " << mod.second << " a second time." << id_ << " " << std::endl;
                   }
                   else
                   {
@@ -90,7 +95,7 @@ namespace SCIRun {
                     doneCount_.fetch_add(1);
 
                     if (shouldLog_)
-                      log_ << Core::Logging::DEBUG_LOG << "Producer status: " << doneCount_ << " out of " << numModules_ << std::endl;
+                      log_ << Core::Logging::DEBUG_LOG << "Producer status: " << id_ << " " << doneCount_ << " out of " << numModules_ << std::endl;
                   }
                 }
               }
@@ -99,16 +104,23 @@ namespace SCIRun {
 
           void operator()() const
           {
+            id_ = boost::this_thread::get_id();
             if (shouldLog_)
-              log_ << Core::Logging::DEBUG_LOG << "Producer started" << std::endl;
+              log_ << Core::Logging::DEBUG_LOG << "Producer started " << id_ << std::endl;
 
             enqueueReadyModules();
 
-            while (!isDone())
-              boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
+            while (!badGroup_ && !isDone())
+            {
+              boost::this_thread::sleep(boost::posix_time::milliseconds(100));
+              //std::cout << "producer thread waiting " << id_ << std::endl;
+            }
+
+            if (badGroup_)
+              std::cerr << "producer is done with bad group, something went wrong. probably a race condition..." << std::endl;
 
             if (shouldLog_)
-              log_ << Core::Logging::DEBUG_LOG << "Producer is done." << std::endl;
+              log_ << Core::Logging::DEBUG_LOG << "Producer is done. " << id_ << std::endl;
           }
 
           bool isDone() const
@@ -118,13 +130,15 @@ namespace SCIRun {
         private:
           BoostGraphParallelScheduler scheduler_;
           const Networks::NetworkInterface* network_;
-          Core::Thread::Mutex* lock_;
+          Core::Thread::Mutex* enqueueLock_;
           ModuleWorkQueuePtr work_;
           mutable boost::atomic<int> doneCount_;
+          mutable bool badGroup_;
           mutable std::set<Networks::ModuleId> doneIds_;
           static Core::Logging::Log& log_;
           bool shouldLog_;
           size_t numModules_;
+          mutable boost::thread::id id_;
         };
 
         typedef boost::shared_ptr<ModuleProducer> ModuleProducerPtr;

src/Dataflow/Engine/Scheduler/DynamicMultithreadedNetworkExecutor.cc

@@ -51,19 +51,21 @@ namespace SCIRun {
       class DynamicMultithreadedNetworkExecutorImpl : public WaitsForStartupInitialization
       {
       public:
-        DynamicMultithreadedNetworkExecutorImpl(const ExecutionContext& context, const NetworkInterface* network, Mutex* lock, size_t numModules) :
+        DynamicMultithreadedNetworkExecutorImpl(const ExecutionContext& context, const NetworkInterface* network, Mutex* lock, size_t numModules, Mutex* executionLock) :
           executeThreads_(new boost::thread_group),
           lookup_(&context.lookup),
           bounds_(&context.bounds()),
           work_(new DynamicExecutor::ModuleWorkQueue(numModules)),
           producer_(new DynamicExecutor::ModuleProducer(context.addAdditionalFilter(ModuleWaitingFilter::Instance()),
             network, lock, work_, numModules)),
             consumer_(new DynamicExecutor::ModuleConsumer(work_, lookup_, producer_, *executeThreads_)),
-          network_(network)
+          network_(network),
+          executionLock_(executionLock)
         {
         }
         void operator()() const
         {
+          Guard g(executionLock_->get());
           ScopedExecutionBoundsSignaller signaller(bounds_, [=]() { return lookup_->errorCode(); });
 
           waitForStartupInit(*network_);
@@ -82,19 +84,20 @@ namespace SCIRun {
         DynamicExecutor::ModuleProducerPtr producer_;
         DynamicExecutor::ModuleConsumerPtr consumer_;
         const NetworkInterface* network_;
+        Mutex* executionLock_;
       };
 }}}
 
 DynamicMultithreadedNetworkExecutor::DynamicMultithreadedNetworkExecutor(const NetworkInterface& network) : network_(network) {}
 
-void DynamicMultithreadedNetworkExecutor::execute(const ExecutionContext& context, ParallelModuleExecutionOrder order)
+void DynamicMultithreadedNetworkExecutor::execute(const ExecutionContext& context, ParallelModuleExecutionOrder order, Mutex& executionLock)
 {
   static Mutex lock("live-scheduler");
 
   if (Log::get().verbose())
     LOG_DEBUG("DMTNE::executeAll order received: " << order << std::endl);
 
-  DynamicMultithreadedNetworkExecutorImpl runner(context, &network_, &lock, order.size());
+  DynamicMultithreadedNetworkExecutorImpl runner(context, &network_, &lock, order.size(), &executionLock);
   boost::thread execution(runner);
 }