Merge pull request #7521 from nilsvu/upgrade_container

Fix compiling with gcc 15, nvcc 13

Author: nilsvu

cmake/EnableWarnings.cmake

@@ -6,13 +6,15 @@ include(AddCxxFlag)
 # On systems where we can't use -isystem (Cray), we don't want
 # all the warnings enabled because we get flooded with system warnings.
 option(ENABLE_WARNINGS "Enable the default warning level" ON)
+# `-Wdisabled-optimization` is deliberately not enabled. It reports that the
+# compiler gave up on an optimization because a function exceeded an internal
+# size limit, which our template-heavy code hits routinely and cannot act on.
 if(${ENABLE_WARNINGS})
   create_cxx_flags_target(
     "-W;\
 -Wall;\
 -Wcast-align;\
 -Wcast-qual;\
--Wdisabled-optimization;\
 -Wdocumentation;\
 -Wextra;\
 -Wformat-nonliteral;\

cmake/FindCharm.cmake

@@ -358,9 +358,32 @@ execute_process(
   WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/tmp/
   ERROR_VARIABLE CHARM_MODULEINIT_ERROR
   )
+# Append a weak `CkRegisterMainModule`. `libck` expects it from the executable,
+# but only a generated main module defines it, so executables without one (e.g.
+# `ConvertComposeTable`) fail to link. They never call it, hence the abort,
+# which also catches an executable linked without its main module instead of
+# letting Charm++ hang with no main chare. It goes into the generated file
+# because `tools/WrapExecutableLinker.sh` stubs out every `*.cpp.o` on the link
+# line, which would break a source file of its own. Copy it with
+# `configure_file` so its timestamp only changes with its contents: this object
+# file is a link dependency of every executable.
+file(READ ${CMAKE_BINARY_DIR}/tmp/CharmModuleInit.C CHARM_MODULEINIT_CONTENTS)
+file(WRITE ${CMAKE_BINARY_DIR}/tmp/CharmModuleInitWithMainModule.C
+  "${CHARM_MODULEINIT_CONTENTS}"
+  "#include <cstdio>\n"
+  "#include <cstdlib>\n"
+  "extern \"C\" __attribute__((weak)) void CkRegisterMainModule() {\n"
+  "  fprintf(stderr,\n"
+  "          \"No Charm++ main module was registered. This executable was \"\n"
+  "          \"linked without the object file that defines its main \"\n"
+  "          \"module.\\n\");\n"
+  "  abort();\n"
+  "}\n"
+  )
 configure_file(
-  ${CMAKE_BINARY_DIR}/tmp/CharmModuleInit.C
-  ${CMAKE_BINARY_DIR}
+  ${CMAKE_BINARY_DIR}/tmp/CharmModuleInitWithMainModule.C
+  ${CMAKE_BINARY_DIR}/CharmModuleInit.C
+  COPYONLY
   )
 add_library(CharmModuleInit OBJECT ${CMAKE_BINARY_DIR}/CharmModuleInit.C)
 # -w -- suppress all warnings because this is charm-generated source

src/DataStructures/DataBox/DataBox.hpp

@@ -797,6 +797,8 @@ struct tag_and_bases<Tag, Others...>
 
 template <typename... Tags>
 auto DataBox<tmpl::list<Tags...>>::compute_tag_graphs() -> TagGraphs {
+  // The member function pointers below are `static_cast` explicitly because
+  // deducing them makes nvcc name the host-only members in device code.
   TagGraphs result{};
   // Compute graphs for retrieving tags
   const auto process_tag = [&result]<typename ConcreteTag>(
@@ -807,7 +809,8 @@ auto DataBox<tmpl::list<Tags...>>::compute_tag_graphs() -> TagGraphs {
           const std::string tag_name = pretty_type::get_name<Tag>();
           detail::set_or_null_if_ambiguous(
               make_not_null(&result.tag_retrieval_functions), tag_name,
-              &DataBox::template get_item_as_void_pointer<ConcreteTag>);
+              static_cast<const void* (DataBox::*)() const>(
+                  &DataBox::template get_item_as_void_pointer<ConcreteTag>));
           result.tag_aliases[concrete_tag_name].push_back(tag_name);
         });
   };
@@ -852,7 +855,8 @@ auto DataBox<tmpl::list<Tags...>>::compute_tag_graphs() -> TagGraphs {
           result.tags_and_dependents[argument_tag].push_back(tag_name);
         }
         result.tags_and_reset_functions[tag_name] =
-            &DataBox::template reset_compute_item<compute_tag>;
+            static_cast<bool (DataBox::*)()>(
+                &DataBox::template reset_compute_item<compute_tag>);
       });
 
   // Set mutation function
@@ -863,8 +867,9 @@ auto DataBox<tmpl::list<Tags...>>::compute_tag_graphs() -> TagGraphs {
           const std::string tag_name = pretty_type::get_name<Tag>();
           detail::set_or_null_if_ambiguous(
               make_not_null(&result.tag_mutate_functions), tag_name,
-              &DataBox::template get_item_as_void_pointer_for_mutate<
-                  MutableTag>);
+              static_cast<void* (DataBox::*)()>(
+                  &DataBox::template get_item_as_void_pointer_for_mutate<
+                      MutableTag>));
           detail::set_or_null_if_ambiguous(
               make_not_null(&result.mutate_mutable_subitems_functions),
               tag_name,
@@ -873,7 +878,9 @@ auto DataBox<tmpl::list<Tags...>>::compute_tag_graphs() -> TagGraphs {
           detail::set_or_null_if_ambiguous(
               make_not_null(&result.reset_compute_items_after_mutate_functions),
               tag_name,
-              &DataBox::template reset_compute_items_after_mutate<MutableTag>);
+              static_cast<void (DataBox::*)()>(
+                  &DataBox::template reset_compute_items_after_mutate<
+                      MutableTag>));
         });
   });
   return result;

src/DataStructures/TaggedTuple.hpp

@@ -31,12 +31,6 @@ class er;
  */
 namespace tuples {
 
-#if __cplusplus >= 201402L
-#define TUPLES_LIB_CONSTEXPR_CXX_14 constexpr
-#else
-#define TUPLES_LIB_CONSTEXPR_CXX_14
-#endif
-
 namespace tuples_detail {
 
 template <class T>
@@ -167,11 +161,7 @@ class TaggedTupleLeaf<Tag, false> {
   ~TaggedTupleLeaf() = default;
 
   // Note: name get_data instead of get to enable structured binding support.
-#if __cplusplus < 201402L
-  value_type& get_data() { return value_; }
-#else
   constexpr value_type& get_data() { return value_; }
-#endif
   constexpr const value_type& get_data() const { return value_; }
 
   bool swap(TaggedTupleLeaf& t) {
@@ -208,11 +198,7 @@ class TaggedTupleLeaf<Tag, true> : private Tag::type {
   ~TaggedTupleLeaf() = default;
 
   // Note: name get_data instead of get to enable structured binding support.
-#if __cplusplus < 201402L
-  value_type& get_data() { return static_cast<value_type&>(*this); }
-#else
   constexpr value_type& get_data() { return static_cast<value_type&>(*this); }
-#endif
 
   constexpr const value_type& get_data() const {
     return static_cast<const value_type&>(*this);
@@ -549,15 +535,14 @@ inline constexpr typename tmpl::at_c<tmpl::list<Tags...>, I>::type& get(
 namespace tuples_detail {
 struct equal {
   template <class T, class U>
-  static TUPLES_LIB_CONSTEXPR_CXX_14 void apply(T const& lhs, U const& rhs,
-                                                bool* result) {
+  static constexpr void apply(T const& lhs, U const& rhs, bool* result) {
     *result = *result and lhs == rhs;
   }
 };
 
 template <class... LTags, class... RTags>
-TUPLES_LIB_CONSTEXPR_CXX_14 bool tuple_equal_impl(
-    TaggedTuple<LTags...> const& lhs, TaggedTuple<RTags...> const& rhs) {
+constexpr bool tuple_equal_impl(TaggedTuple<LTags...> const& lhs,
+                                TaggedTuple<RTags...> const& rhs) {
   bool equal = true;
   // This short circuits in the sense that the operator== is only evaluated if
   // the result thus far is true
@@ -570,25 +555,24 @@ TUPLES_LIB_CONSTEXPR_CXX_14 bool tuple_equal_impl(
 template <class... LTags, class... RTags,
           typename std::enable_if<sizeof...(LTags) == sizeof...(RTags)>::type* =
               nullptr>
-TUPLES_LIB_CONSTEXPR_CXX_14 bool operator==(TaggedTuple<LTags...> const& lhs,
-                                            TaggedTuple<RTags...> const& rhs) {
+constexpr bool operator==(TaggedTuple<LTags...> const& lhs,
+                          TaggedTuple<RTags...> const& rhs) {
   return tuples_detail::tuple_equal_impl(lhs, rhs);
 }
 
 template <class... LTags, class... RTags,
           typename std::enable_if<sizeof...(LTags) == sizeof...(RTags)>::type* =
               nullptr>
-TUPLES_LIB_CONSTEXPR_CXX_14 bool operator!=(TaggedTuple<LTags...> const& lhs,
-                                            TaggedTuple<RTags...> const& rhs) {
+constexpr bool operator!=(TaggedTuple<LTags...> const& lhs,
+                          TaggedTuple<RTags...> const& rhs) {
   return not(lhs == rhs);
 }
 
 namespace tuples_detail {
 struct less {
   template <class T, class U>
-  static TUPLES_LIB_CONSTEXPR_CXX_14 void apply(T const& lhs, U const& rhs,
-                                                bool* last_rhs_less_lhs,
-                                                bool* result) {
+  static constexpr void apply(T const& lhs, U const& rhs,
+                              bool* last_rhs_less_lhs, bool* result) {
     if (*result or *last_rhs_less_lhs) {
       return;
     }
@@ -601,8 +585,8 @@ struct less {
 };
 
 template <class... LTags, class... RTags>
-TUPLES_LIB_CONSTEXPR_CXX_14 bool tuple_less_impl(
-    TaggedTuple<LTags...> const& lhs, TaggedTuple<RTags...> const& rhs) {
+constexpr bool tuple_less_impl(TaggedTuple<LTags...> const& lhs,
+                               TaggedTuple<RTags...> const& rhs) {
   bool result = false;
   bool last_rhs_less_lhs = false;
   static_cast<void>(
@@ -616,32 +600,32 @@ TUPLES_LIB_CONSTEXPR_CXX_14 bool tuple_less_impl(
 template <class... LTags, class... RTags,
           typename std::enable_if<sizeof...(LTags) == sizeof...(RTags)>::type* =
               nullptr>
-TUPLES_LIB_CONSTEXPR_CXX_14 bool operator<(TaggedTuple<LTags...> const& lhs,
-                                           TaggedTuple<RTags...> const& rhs) {
+constexpr bool operator<(TaggedTuple<LTags...> const& lhs,
+                         TaggedTuple<RTags...> const& rhs) {
   return tuples_detail::tuple_less_impl(lhs, rhs);
 }
 
 template <class... LTags, class... RTags,
           typename std::enable_if<sizeof...(LTags) == sizeof...(RTags)>::type* =
               nullptr>
-TUPLES_LIB_CONSTEXPR_CXX_14 bool operator>(TaggedTuple<LTags...> const& lhs,
-                                           TaggedTuple<RTags...> const& rhs) {
+constexpr bool operator>(TaggedTuple<LTags...> const& lhs,
+                         TaggedTuple<RTags...> const& rhs) {
   return rhs < lhs;
 }
 
 template <class... LTags, class... RTags,
           typename std::enable_if<sizeof...(LTags) == sizeof...(RTags)>::type* =
               nullptr>
-TUPLES_LIB_CONSTEXPR_CXX_14 bool operator<=(TaggedTuple<LTags...> const& lhs,
-                                            TaggedTuple<RTags...> const& rhs) {
+constexpr bool operator<=(TaggedTuple<LTags...> const& lhs,
+                          TaggedTuple<RTags...> const& rhs) {
   return not(rhs < lhs);
 }
 
 template <class... LTags, class... RTags,
           typename std::enable_if<sizeof...(LTags) == sizeof...(RTags)>::type* =
               nullptr>
-TUPLES_LIB_CONSTEXPR_CXX_14 bool operator>=(TaggedTuple<LTags...> const& lhs,
-                                            TaggedTuple<RTags...> const& rhs) {
+constexpr bool operator>=(TaggedTuple<LTags...> const& lhs,
+                          TaggedTuple<RTags...> const& rhs) {
   return not(lhs < rhs);
 }
 

src/Parallel/StaticSpscQueue.hpp

@@ -106,6 +106,8 @@ class StaticSpscQueue {
     while (next_write_index == read_index_cache_) {
       read_index_cache_ = read_index_.load(std::memory_order_acquire);
     }
+    // Destroy the object this slot already holds (see `data_`).
+    data_[write_index + padding_].~T();
     new (&data_[write_index + padding_]) T(std::forward<Args>(args)...);
     write_index_.store(next_write_index, std::memory_order_release);
   }
@@ -132,6 +134,8 @@ class StaticSpscQueue {
         return false;
       }
     }
+    // Destroy the object this slot already holds (see `data_`).
+    data_[write_index + padding_].~T();
     new (&data_[write_index + padding_]) T(std::forward<Args>(args)...);
     write_index_.store(next_write_index, std::memory_order_release);
     return true;
@@ -206,7 +210,9 @@ class StaticSpscQueue {
            "Can't pop an element from an empty queue. read_index: "
                << read_index << " write_index " << write_index);
 #endif  // SPECTRE_DEBUG
+    // Leave a live object behind (see `data_`).
     data_[read_index + padding_].~T();
+    new (&data_[read_index + padding_]) T{};
     auto next_read_index = read_index + 1;
     if (next_read_index == capacity_) {
       next_read_index = 0;
@@ -248,6 +254,8 @@ class StaticSpscQueue {
 
  private:
   static constexpr size_t capacity_ = Capacity + 1;
+  // Every slot holds a live object, so the array's destructor destroys each
+  // element exactly once. `emplace` and `pop` maintain this.
   std::array<T, capacity_ + 2 * padding_> data_{};
 
   // Align to cache line size in order to avoid false sharing

tests/Unit/DataStructures/Test_TaggedTuple.cpp

@@ -604,7 +604,6 @@ void test_equivalence() {
   CHECK(NotNoExceptCompare{1} != NotNoExceptCompare{0});
   CHECK_FALSE(NotNoExceptCompare{1} != NotNoExceptCompare{1});
 
-#if __cplusplus >= 201402L
   {
     constexpr tuples::TaggedTuple<relational_tags::Int0, relational_tags::Int1,
                                   relational_tags::Int2>
@@ -636,7 +635,6 @@ void test_equivalence() {
     static_assert(t0 != t4,
                   "Failed testing Unit.Utilities.TaggedTuple.relational");
   }
-#endif
 }
 
 struct lex_time_compared {
@@ -770,7 +768,6 @@ void test_relational() {
     CHECK(t0 <= t2);
     CHECK(global_time_mock == 28);
   }
-#if __cplusplus >= 201402L
   {
     // Check constexpr lexicographical comparison
     constexpr tuples::TaggedTuple<
@@ -793,7 +790,6 @@ void test_relational() {
     static_assert(t0 >= t2, "Failed testing relational operators");
     static_assert(t0 >= t3, "Failed testing relational operators");
   }
-#endif
 }
 
 static_assert(

tests/Unit/PointwiseFunctions/GeneralRelativity/Test_GeodesicAcceleration.cpp

@@ -145,7 +145,7 @@ void test_conserved_quantities_kerr_schild() {
   std::vector<std::array<double, 6>> states{};
   std::vector<double> times{};
   BoostObserver observer{states, times};
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 13
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 13
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wuninitialized"
 #endif
@@ -156,7 +156,7 @@ void test_conserved_quantities_kerr_schild() {
               std::array<double, 6>>()),
       BoostGeodesicIntegrator{kerr_schild}, initial_state, 0.0, t_max, 1e-5,
       observer);
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 13
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 13
 #pragma GCC diagnostic pop
 #endif