Merge pull request #1654 from SCIInstitute/more-subnets

More subnets

Author: dcwhite

src/Core/Application/Application.cc

@@ -297,6 +297,23 @@ std::string Application::moduleList()
   return ostr.str();
 }
 
+bool Application::moduleNameExists(const std::string& name)
+{
+  auto map = controller()->getAllAvailableModuleDescriptions();
+  for (const auto& p1 : map)
+  {
+    for (const auto& p2 : p1.second)
+    {
+      for (const auto& p3 : p2.second)
+      {
+        if (boost::iequals(name, p3.first))
+          return true;
+      }
+    }
+  }
+  return false;
+}
+
 boost::filesystem::path Application::configDirectory() const
 {
   return applicationHelper.configDirectory();

src/Core/Application/Application.h

@@ -83,6 +83,7 @@ class SCISHARE Application : boost::noncopyable //: public EventHandler, public
   std::string applicationName() const;
   std::string version() const;
   std::string moduleList();
+  bool moduleNameExists(const std::string& name);
 
   void shutdown();
 

src/Dataflow/Engine/Controller/NetworkEditorController.cc

@@ -607,8 +607,17 @@ boost::shared_ptr<boost::thread> NetworkEditorController::executeAll(const Execu
 
 void NetworkEditorController::executeModule(const ModuleHandle& module, const ExecutableLookup* lookup, bool executeUpstream)
 {
-  ExecuteSingleModule filter(module, *theNetwork_, executeUpstream);
-  executeGeneric(lookup, filter);
+  try
+  {
+    ExecuteSingleModule filter(module, *theNetwork_, executeUpstream);
+    executeGeneric(lookup, filter);
+  }
+  catch (NetworkHasCyclesException&)
+  {
+    SCIRun::Core::Logging::Log::get() << SCIRun::Core::Logging::ERROR_LOG << "Cannot schedule execution: network has cycles. Please break all cycles and try again." << std::endl;
+    ExecutionContext::executionBounds_.executeFinishes_(-1);
+    return;
+  }
 }
 
 void NetworkEditorController::initExecutor()
@@ -624,6 +633,10 @@ ExecutionContextHandle NetworkEditorController::createExecutionContext(const Exe
 boost::shared_ptr<boost::thread> NetworkEditorController::executeGeneric(const ExecutableLookup* lookup, ModuleFilter filter)
 {
   initExecutor();
+
+
+
+
   auto context = createExecutionContext(lookup, filter);
 
   return executionManager_.enqueueContext(context);

src/Dataflow/Engine/Scheduler/GraphNetworkAnalyzer.cc

@@ -137,13 +137,40 @@ ComponentMap NetworkGraphAnalyzer::connectedComponents()
   return componentMap;
 }
 
+namespace SCIRun
+{
+  namespace Dataflow
+  {
+    namespace Engine
+    {
+      class ExecuteSingleModuleImpl
+      {
+      public:
+        ParallelModuleExecutionOrder order_;
+        bool isDownstreamFrom(const ModuleId& toCheckId, const ModuleId& rootId) const
+        {
+          return order_.groupOf(toCheckId) >= order_.groupOf(rootId);
+        }
+      };
+    }
+  }
+}
+
 ExecuteSingleModule::ExecuteSingleModule(SCIRun::Dataflow::Networks::ModuleHandle mod,
   const SCIRun::Dataflow::Networks::NetworkInterface& network,
   bool executeUpstream) : module_(mod), network_(network), executeUpstream_(executeUpstream)
 {
   //TODO: composite with which filter?
   NetworkGraphAnalyzer analyze(network, ExecuteAllModules::Instance(), false);
   components_ = analyze.connectedComponents();
+
+  if (!executeUpstream_)
+  {
+    orderImpl_.reset(new ExecuteSingleModuleImpl);
+    auto all = boost::lambda::constant(true);
+    BoostGraphParallelScheduler scheduleAll(all);
+    orderImpl_->order_ = scheduleAll.schedule(network_);
+  }
 }
 
 bool ExecuteSingleModule::operator()(SCIRun::Dataflow::Networks::ModuleHandle mod) const
@@ -167,11 +194,8 @@ bool ExecuteSingleModule::operator()(SCIRun::Dataflow::Networks::ModuleHandle mo
   }
   else
   {
-    auto all = boost::lambda::constant(true);
-    BoostGraphParallelScheduler scheduleAll(all);
-    auto order = scheduleAll.schedule(network_);
-
     // should execute if in same connected component, and downstream only
-    return modIdIter->second == rootIdIter->second && order.groupOf(toCheckId) >= order.groupOf(rootId);
+    return modIdIter->second == rootIdIter->second
+      && orderImpl_->isDownstreamFrom(toCheckId, rootId);
   }
 }

src/Dataflow/Engine/Scheduler/SchedulerInterfaces.h

@@ -137,6 +137,8 @@ namespace Engine {
     static const ModuleWaitingFilter& Instance();
   };
 
+  class ExecuteSingleModuleImpl;
+
   struct SCISHARE ExecuteSingleModule
   {
     ExecuteSingleModule(SCIRun::Dataflow::Networks::ModuleHandle mod,
@@ -147,6 +149,7 @@ namespace Engine {
     const SCIRun::Dataflow::Networks::NetworkInterface& network_;
     std::map<std::string, int> components_;
     bool executeUpstream_;
+    boost::shared_ptr<ExecuteSingleModuleImpl> orderImpl_;
   };
 
   class SCISHARE WaitsForStartupInitialization