Add SynchronizerManager repository

This singleton stores Synchronizer's associated to a given Connectivity. This
allows a lazy built of synchronization info.

Stored Synchronizer's are deleted when Connectivity's destructor is called

src/main.cpp

@@ -22,6 +22,8 @@
 
 #include <GmshReader.hpp>
 
+#include <SynchronizerManager.hpp>
+
 #include <limits>
 #include <map>
 
@@ -30,6 +32,8 @@ int main(int argc, char *argv[])
   std::string filename = initialize(argc, argv);
   std::map<std::string, double> method_cost_map;
 
+  SynchronizerManager::create();
+
   if (filename != "") {
     pout() << "Reading (gmsh) " << rang::style::underline << filename << rang::style::reset << " ...\n";
     Timer gmsh_timer;
@@ -373,6 +377,8 @@ int main(int argc, char *argv[])
     std::exit(0);
   }
 
+  SynchronizerManager::destroy();
+
   finalize();
 
   std::string::size_type size=0;

src/mesh/CMakeLists.txt

@@ -7,7 +7,8 @@ add_library(
   PastisMesh
   Connectivity.cpp
   ConnectivityComputer.cpp
-  GmshReader.cpp)
+  GmshReader.cpp
+  SynchronizerManager.cpp)
 
 include_directories(${PASTIS_BINARY_DIR}/src/utils)
 

src/mesh/Connectivity.hpp

@@ -31,6 +31,8 @@
 #include <RefNodeList.hpp>
 #include <RefFaceList.hpp>
 
+#include <SynchronizerManager.hpp>
+
 #include <tuple>
 #include <algorithm>
 #include <set>
@@ -635,7 +637,8 @@ class Connectivity final
  public:
   ~Connectivity()
   {
-    ;
+    auto& manager = SynchronizerManager::instance();
+    manager.deleteConnectivitySynchronizer(this);
   }
 };
 

src/mesh/ItemValueUtils.hpp

@@ -6,6 +6,7 @@
 
 #include <Connectivity.hpp>
 
+#include <SynchronizerManager.hpp>
 #include <Synchronizer.hpp>
 
 template <typename DataType,
@@ -300,7 +301,9 @@ void synchronize(ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
 {
   static_assert(not std::is_const_v<DataType>, "cannot synchronize ItemValue of const data");
   if (parallel::size() > 1) {
-    static Synchronizer synchronizer;
+    auto& manager = SynchronizerManager::instance();
+    const IConnectivity* connectivity = item_value.connectivity_ptr().get();
+    Synchronizer& synchronizer = manager.getConnectivitySynchronizer(connectivity);
     synchronizer.synchronize(item_value);
   }
 }

src/mesh/Synchronizer.hpp

@@ -61,8 +61,6 @@ class Synchronizer
     using ItemId = ItemIdT<item_type>;
 
     auto& requested_item_info = this->_getRequestedItemInfo<item_type>();
-
-    pout() << "... building synchronization info\n";
     requested_item_info
         = [&] () {
             std::vector<std::vector<ItemId>> requested_item_vector_info(parallel::size());

src/mesh/SynchronizerManager.cpp

+#include <SynchronizerManager.hpp>
+#include <PastisAssert.hpp>
+
+#include <Messenger.hpp>
+#include <Synchronizer.hpp>
+
+SynchronizerManager*
+SynchronizerManager::m_instance{nullptr};
+
+SynchronizerManager::
+~SynchronizerManager()
+{
+  if (m_connectivity_synchronizer_map.size() > 0)
+  {
+    perr() << __FILE__ << ':' << __LINE__
+           << ": warning: some connectivities are still registered\n";;
+  }
+}
+
+void SynchronizerManager::create()
+{
+  Assert(m_instance == nullptr, "SynchronizerManager is already created");
+  m_instance = new SynchronizerManager;
+}
+
+void SynchronizerManager::destroy()
+{
+  Assert(m_instance != nullptr, "SynchronizerManager was not created!");
+  delete m_instance;
+  m_instance = nullptr;
+}
+
+
+void
+SynchronizerManager::
+deleteConnectivitySynchronizer(const IConnectivity* connectivity)
+{
+  m_connectivity_synchronizer_map.erase(connectivity);
+}
+
+Synchronizer&
+SynchronizerManager::
+getConnectivitySynchronizer(const IConnectivity* connectivity)
+{
+  if (auto connectivity_synchronizer = m_connectivity_synchronizer_map.find(connectivity);
+      connectivity_synchronizer != m_connectivity_synchronizer_map.end()) {
+    return (*connectivity_synchronizer->second);
+  } else {
+    std::shared_ptr synchronizer = std::make_shared<Synchronizer>();
+    m_connectivity_synchronizer_map[connectivity] = synchronizer;
+    return *synchronizer;
+  }
+}

src/mesh/SynchronizerManager.hpp

+#ifndef SYNCHRONIZER_MANAGER_HPP
+#define SYNCHRONIZER_MANAGER_HPP
+
+#include <PastisMacros.hpp>
+#include <PastisAssert.hpp>
+
+#include <memory>
+#include <map>
+
+class IConnectivity;
+class Synchronizer;
+
+class SynchronizerManager
+{
+ private:
+  std::map<const IConnectivity*, std::shared_ptr<Synchronizer>> m_connectivity_synchronizer_map;
+
+  static SynchronizerManager* m_instance;
+  SynchronizerManager() = default;
+  ~SynchronizerManager();
+
+ public:
+  static void create();
+  static void destroy();
+
+  PASTIS_INLINE
+  static SynchronizerManager& instance()
+  {
+    Assert(m_instance != nullptr, "SynchronizerManager was not created!");
+    return *m_instance;
+  }
+
+  void deleteConnectivitySynchronizer(const IConnectivity*);
+  Synchronizer& getConnectivitySynchronizer(const IConnectivity*);
+};
+
+#endif // SYNCHRONIZER_MANAGER_HPP