Add isSynchronized functions

src/mesh/ItemArrayUtils.hpp

@@ -23,4 +23,27 @@ synchronize(ItemArray<DataType, item_type, ConnectivityPtr>& item_array)
   }
 }
 
+template <typename DataType, ItemType item_type, typename ConnectivityPtr>
+bool
+isSynchronized(ItemArray<const DataType, item_type, ConnectivityPtr> item_array)
+{
+  bool is_synchronized = true;
+
+  if (parallel::size() > 1) {
+    ItemArray<std::remove_const_t<DataType>, item_type> item_array_copy = copy(item_array);
+    synchronize(item_array_copy);
+    for (ItemIdT<item_type> item_id = 0; item_id < item_array_copy.numberOfItems(); ++item_id) {
+      for (size_t i = 0; i < item_array.sizeOfArrays(); ++i) {
+        if (item_array_copy[item_id][i] != item_array[item_id][i]) {
+          is_synchronized = false;
+        }
+      }
+    }
+
+    is_synchronized = parallel::allReduceAnd(is_synchronized);
+  }
+
+  return is_synchronized;
+}
+
 #endif   // ITEM_ARRAY_UTILS_HPP

src/mesh/ItemValueUtils.hpp

@@ -304,4 +304,26 @@ synchronize(ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
   }
 }
 
+template <typename DataType, ItemType item_type, typename ConnectivityPtr>
+bool
+isSynchronized(const ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
+{
+  bool is_synchronized = true;
+
+  if (parallel::size() > 1) {
+    ItemValue<std::remove_const_t<DataType>, item_type> item_value_copy = copy(item_value);
+    synchronize(item_value_copy);
+    for (ItemIdT<item_type> item_id = 0; item_id < item_value_copy.numberOfItems(); ++item_id) {
+      if (item_value_copy[item_id] != item_value[item_id]) {
+        is_synchronized = false;
+        break;
+      }
+    }
+
+    is_synchronized = parallel::allReduceAnd(is_synchronized);
+  }
+
+  return is_synchronized;
+}
+
 #endif   // ITEM_VALUE_UTILS_HPP

src/utils/RandomEngine.cpp

@@ -4,6 +4,29 @@
 
 std::unique_ptr<RandomEngine> RandomEngine::m_instance;
 
+bool
+isSynchronized(const RandomEngine& random_engine)
+{
+  const uint64_t current_seed      = random_engine.getCurrentSeed();
+  const uint64_t parallel_max_seed = parallel::allReduceMax(current_seed);
+
+  return parallel::allReduceAnd(current_seed == parallel_max_seed);
+}
+
+uint64_t
+RandomEngine::getCurrentSeed() const
+{
+  std::ostringstream ostr;
+  ostr << m_random_engine;
+
+  std::istringstream istr(ostr.str());
+
+  uint64_t current_seed;
+  istr >> current_seed;
+
+  return current_seed;
+}
+
 void
 RandomEngine::create()
 {
@@ -18,23 +41,22 @@ RandomEngine::destroy()
 
 RandomEngine::RandomEngine()
 {
-  m_initial_seed = std::random_device{}();
-  parallel::broadcast(m_initial_seed, 0);
+  uint64_t random_seed = std::random_device{}();
+  parallel::broadcast(random_seed, 0);
 
-  m_random_engine = std::default_random_engine(m_initial_seed);
+  m_random_engine = std::default_random_engine(random_seed);
 
   std::cout << " * setting " << rang::fgB::green << "random seed" << rang::style::reset << " to " << rang::fgB::yellow
-            << m_initial_seed << rang::style::reset << '\n';
+            << random_seed << rang::style::reset << '\n';
 }
 
 void
 RandomEngine::setRandomSeed(const uint64_t random_seed)
 {
-  m_initial_seed  = random_seed;
-  m_random_engine = std::default_random_engine(m_initial_seed);
+  m_random_engine = std::default_random_engine(random_seed);
 
   std::cout << " * setting " << rang::fgB::green << "random seed" << rang::style::reset << " to " << rang::fgB::yellow
-            << m_initial_seed << rang::style::reset << '\n';
+            << random_seed << rang::style::reset << '\n';
 }
 
 void

src/utils/RandomEngine.hpp

@@ -12,7 +12,6 @@ class RandomEngine
  private:
   static std::unique_ptr<RandomEngine> m_instance;
 
-  uint64_t m_initial_seed;
   std::default_random_engine m_random_engine;
 
   RandomEngine();
@@ -21,8 +20,12 @@ class RandomEngine
   void setRandomSeed(const uint64_t random_seed);
   void resetRandomSeed();
 
+  friend bool isSynchronized(const RandomEngine& random_engine);
+
   static void create();
 
+  uint64_t getCurrentSeed() const;
+
   PUGS_INLINE
   std::default_random_engine&
   engine()