Fix python test and contention in module state map

src/Core/Python/PythonInterpreter.cc

@@ -607,6 +607,9 @@ void PythonInterpreter::set_python_argv(const std::vector<std::string>& argv)
 
 void PythonInterpreter::initialize(bool needProgramName, const std::string& commandLine, const boost::filesystem::path& libPath)
 {
+  if (this->private_->initialized_)
+    return;
+
   const auto argv = argvFromFullString(commandLine);
 
   if (needProgramName)

src/Dataflow/State/SimpleMapModuleState.cc

@@ -55,9 +55,10 @@ SimpleMapModuleState::SimpleMapModuleState(SimpleMapModuleState&& rhs)
 
 SimpleMapModuleState::SimpleMapModuleState(const SimpleMapModuleState& rhs)
   : stateMap_(rhs.stateMap_),
-  transientStateMap_(rhs.transientStateMap_), /// @todo: I think this is wrong, transient shouldn't be copied
   name_(rhs.name_)
 {
+  std::lock_guard<std::mutex> lock(rhs.transientMutex_);
+  transientStateMap_ = rhs.transientStateMap_; /// @todo: I think this is wrong, transient shouldn't be copied
   //std::cout << "SMMS copy ctor " << name_ << std::endl;
 }
 
@@ -66,7 +67,10 @@ SimpleMapModuleState& SimpleMapModuleState::operator=(const SimpleMapModuleState
   if (&rhs != this)
   {
     stateMap_ = rhs.stateMap_;
-    transientStateMap_ = rhs.transientStateMap_;  /// @todo: I think this is wrong, transient shouldn't be copied
+    {
+      std::lock_guard<std::mutex> lock(rhs.transientMutex_);
+      transientStateMap_ = rhs.transientStateMap_;  /// @todo: I think this is wrong, transient shouldn't be copied
+    }
     name_ = rhs.name_;
     //std::cout << "SMMS copy assign " << name_<< std::endl;
     /// @todo??
@@ -151,6 +155,7 @@ ModuleStateInterface::Keys SimpleMapModuleState::getKeys() const
 
 void SimpleMapModuleState::print() const
 {
+  std::lock_guard<std::mutex> lock(transientMutex_);
   std::cout << "Printing transient map: " << this << " name: " << name_ << std::endl;
   for (auto q = transientStateMap_.begin(); q != transientStateMap_.end(); ++q)
   {
@@ -161,16 +166,22 @@ void SimpleMapModuleState::print() const
 
 SimpleMapModuleState::TransientValueOption SimpleMapModuleState::getTransientValue(const Name& name) const
 {
+  std::lock_guard<std::mutex> lock(transientMutex_);
   //print();
   auto i = transientStateMap_.find(name.name());
   return i != transientStateMap_.end() && !i->second.empty() ? std::optional(i->second) : TransientValueOption();
 }
 
 void SimpleMapModuleState::setTransientValue(const Name& name, const TransientValue& value, bool fireSignal)
 {
-  transientStateMap_[name.name()] = value;
+  {
+    std::lock_guard<std::mutex> lock(transientMutex_);
+    transientStateMap_[name.name()] = value;
+  }
   //print();
 
+  // Fire signals outside the lock to avoid re-entrancy through signal handlers
+  // that call back into get/setTransientValue.
   if (fireSignal)
   {
     fireTransientStateChangeSignal();

src/Dataflow/State/SimpleMapModuleState.h

@@ -31,6 +31,7 @@
 #define DATAFLOW_STATE_SIMPLEMAPMODULESTATE_H
 
 #include <map>
+#include <mutex>
 #include <Dataflow/Network/ModuleStateInterface.h>
 #include <Dataflow/State/share.h>
 
@@ -64,6 +65,7 @@ namespace State {
     StateMap stateMap_;
     typedef std::map<std::string, TransientValue> TransientStateMap;
     TransientStateMap transientStateMap_;
+    mutable std::mutex transientMutex_;
     state_changed_sig_t stateChangedSignal_;
     provenance_state_changed_sig_t provenanceStateChangedSignal_;
     std::map<Name, state_changed_sig_t> specificStateChangeSignalMap_;