purge Cereal-related code+mentions

CMakeLists.txt

@@ -94,8 +94,6 @@ endif (BUILD_TESTING)
 ###########################
 # Boost
 include("${PROJECT_SOURCE_DIR}/cmake/modules/FindOrFetchBoost.cmake")
-# Cereal
-#include(FindOrFetchCereal)
 # C++ coroutines
 find_package(CXXStdCoroutine MODULE REQUIRED COMPONENTS Final Experimental)
 

cmake/modules/ExternalDependenciesVersions.cmake

@@ -3,7 +3,6 @@
 
 set(TTG_TRACKED_VG_CMAKE_KIT_TAG 7ea2d4d3f8854b9e417f297fd74d6fc49aa13fd5)  # used to provide "real" FindOrFetchBoost
 set(TTG_TRACKED_CATCH2_VERSION 3.5.0)
-set(TTG_TRACKED_CEREAL_VERSION 1.3.0)
 set(TTG_TRACKED_MADNESS_TAG 2eb3bcf0138127ee2dbc651f1aabd3e9b0def4e3)
 set(TTG_TRACKED_PARSEC_TAG 0b3140f58ad9dc78a3d64da9fd73ecc7f443ece7)
 set(TTG_TRACKED_BTAS_TAG 4e8f5233aa7881dccdfcc37ce07128833926d3c2)

tests/unit/CMakeLists.txt

@@ -21,7 +21,7 @@ list(APPEND ut_libs std::coroutine)
 
 add_ttg_executable(core-unittests-ttg "${ut_src}" LINK_LIBRARIES "${ut_libs}" COMPILE_DEFINITIONS "CATCH_CONFIG_NO_POSIX_SIGNALS=1" )
 
-# serialization test: probes serialization via all supported serialization methods (MADNESS, Boost::serialization, cereal) that are available
+# serialization test: probes serialization via all supported serialization methods (MADNESS, Boost::serialization) that are available
 add_ttg_executable(serialization serialization.cc unit_main.cpp
                    LINK_LIBRARIES Catch2::Catch2 ttg-serialization  $<TARGET_NAME_IF_EXISTS:BTAS::BTAS>
                    COMPILE_DEFINITIONS $<$<TARGET_EXISTS:BTAS::BTAS>:TTG_HAS_BTAS=1>)

tests/unit/serialization.cc

@@ -42,24 +42,14 @@ class POD {
 static_assert(std::is_trivially_copyable_v<POD>);
 static_assert(ttg::detail::is_memcpyable_v<POD>);
 
-#ifdef TTG_SERIALIZATION_SUPPORTS_CEREAL
-// WTF?! std::array of non-Serializable is Serializable
-static_assert(!cereal::traits::is_input_serializable<POD, cereal::BinaryInputArchive>::value);
-static_assert(!cereal::traits::is_output_serializable<POD, cereal::BinaryOutputArchive>::value);
-static_assert(!cereal::traits::is_input_serializable<std::array<POD, 3>, cereal::BinaryInputArchive>::value);
-static_assert(!cereal::traits::is_output_serializable<std::array<POD, 3>, cereal::BinaryOutputArchive>::value);
-#endif  // TTG_SERIALIZATION_SUPPORTS_CEREAL
-
 static_assert(!ttg::detail::is_madness_user_buffer_serializable_v<POD>);
 #ifdef TTG_SERIALIZATION_SUPPORTS_BOOST
 static_assert(!ttg::detail::is_boost_serializable_v<boost::archive::binary_oarchive, POD>);
 static_assert(ttg::detail::has_freestanding_boost_serialize_with_version_v<POD, boost::archive::binary_oarchive>);
 #endif  // TTG_SERIALIZATION_SUPPORTS_BOOST
 static_assert(!ttg::detail::is_boost_user_buffer_serializable_v<POD>);
-static_assert(!ttg::detail::is_cereal_user_buffer_serializable_v<POD>);
 static_assert(!ttg::detail::is_madness_user_buffer_serializable_v<std::array<POD, 3>>);
 static_assert(!ttg::detail::is_boost_user_buffer_serializable_v<std::array<POD, 3>>);
-static_assert(!ttg::detail::is_cereal_user_buffer_serializable_v<std::array<POD, 3>>);
 
 std::ostream& operator<<(std::ostream& s, const POD& f) {
   s << "POD(" << f.get() << ")";
@@ -161,7 +151,7 @@ namespace intrusive::symmetric::bc_v {
 
     int get() const { return value; }
 
-    // boost uses `unsigned int` for version, cereal uses `std::uint32_t`
+    // boost uses `unsigned int` for version
     template <typename Archive>
     void serialize(Archive& ar, const unsigned int version) {
       ar& value;
@@ -180,9 +170,6 @@ namespace intrusive_private::symmetric::bc_v {
 #ifdef TTG_SERIALIZATION_SUPPORTS_BOOST
     friend class boost::serialization::access;
 #endif
-#ifdef TTG_SERIALIZATION_SUPPORTS_CEREAL
-    friend class cereal::access;  // befriend the cereal version of access
-#endif
 
     template <typename Archive>
     void serialize(Archive& ar, const unsigned int version) {
@@ -201,72 +188,6 @@ namespace intrusive_private::symmetric::bc_v {
   static_assert(!std::is_trivially_copyable_v<NonPOD>);
 }  // namespace intrusive_private::symmetric::bc_v
 
-#ifdef TTG_SERIALIZATION_SUPPORTS_CEREAL
-namespace intrusive::symmetric::c {
-
-  class NonPOD {
-    int value;
-
-   public:
-    NonPOD() = default;
-    NonPOD(int value) : value(value) {}
-    NonPOD(const NonPOD& other) : value(other.value) {}
-
-    int get() const { return value; }
-
-    // versioned
-    template <class Archive>
-    std::enable_if_t<std::is_base_of_v<cereal::detail::InputArchiveBase, Archive> ||
-                     std::is_base_of_v<cereal::detail::OutputArchiveBase, Archive>>
-    serialize(Archive& ar) {
-      ar(value);
-    }
-  };
-  static_assert(!std::is_trivially_copyable_v<NonPOD>);
-
-  static_assert(ttg::detail::is_cereal_buffer_serializable_v<NonPOD>);
-  static_assert(!ttg::detail::is_boost_buffer_serializable_v<NonPOD>);
-  static_assert(!ttg::detail::is_madness_buffer_serializable_v<NonPOD>);
-  static_assert(ttg::detail::is_cereal_user_buffer_serializable_v<NonPOD>);
-  static_assert(!ttg::detail::is_boost_user_buffer_serializable_v<NonPOD>);
-  static_assert(!ttg::detail::is_madness_user_buffer_serializable_v<NonPOD>);
-
-}  // namespace intrusive::symmetric::c
-
-namespace intrusive::symmetric::c_v {
-
-  class NonPOD {
-    int value;
-
-   public:
-    NonPOD() = default;
-    NonPOD(int value) : value(value) {}
-    NonPOD(const NonPOD& other) : value(other.value) {}
-
-    int get() const { return value; }
-
-    // versioned
-    template <class Archive>
-    std::enable_if_t<std::is_base_of_v<cereal::detail::InputArchiveBase, Archive> ||
-                     std::is_base_of_v<cereal::detail::OutputArchiveBase, Archive>>
-    serialize(Archive& ar, std::uint32_t const version) {
-      ar(value);
-    }
-  };
-  static_assert(!std::is_trivially_copyable_v<NonPOD>);
-
-  static_assert(ttg::detail::is_cereal_buffer_serializable_v<NonPOD>);
-  static_assert(!ttg::detail::is_boost_serializable_v<boost::archive::binary_iarchive, NonPOD>);
-  static_assert(!ttg::detail::is_boost_buffer_serializable_v<NonPOD>);
-  static_assert(!ttg::detail::is_madness_buffer_serializable_v<NonPOD>);
-  static_assert(ttg::detail::is_cereal_user_buffer_serializable_v<NonPOD>);
-  static_assert(!ttg::detail::is_boost_user_buffer_serializable_v<NonPOD>);
-  static_assert(!ttg::detail::is_madness_user_buffer_serializable_v<NonPOD>);
-
-}  // namespace intrusive::symmetric::c_v
-
-#endif  // TTG_SERIALIZATION_SUPPORTS_CEREAL
-
 #ifdef TTG_SERIALIZATION_SUPPORTS_BOOST
 
 // boost serialization, with version (and object) tracking
@@ -372,10 +293,6 @@ static_assert(std::is_same_v<typex<boost::archive::binary_oarchive, intrusive::a
 
 #endif  // TTG_SERIALIZATION_SUPPORTS_BOOST
 
-#ifdef TTG_SERIALIZATION_SUPPORTS_CEREAL
-CEREAL_CLASS_VERSION(intrusive::symmetric::c_v::NonPOD, 17);
-#endif
-
 namespace nonintrusive::symmetric::m {
 
   class NonPOD {
@@ -468,17 +385,14 @@ namespace freestanding::symmetric::bc_v {
 static_assert(ttg::detail::is_madness_buffer_serializable_v<int>);
 static_assert(!ttg::detail::is_madness_user_buffer_serializable_v<int>);
 static_assert(!ttg::detail::is_boost_user_buffer_serializable_v<int>);
-static_assert(!ttg::detail::is_cereal_user_buffer_serializable_v<int>);
 static_assert(!ttg::detail::is_user_buffer_serializable_v<int>);
 static_assert(ttg::detail::is_madness_buffer_serializable_v<const int>);
 static_assert(!ttg::detail::is_madness_user_buffer_serializable_v<const int>);
 static_assert(!ttg::detail::is_boost_user_buffer_serializable_v<const int>);
-static_assert(!ttg::detail::is_cereal_user_buffer_serializable_v<const int>);
 static_assert(!ttg::detail::is_user_buffer_serializable_v<const int>);
 static_assert(ttg::detail::is_madness_buffer_serializable_v<int[4]>);
 static_assert(!ttg::detail::is_madness_user_buffer_serializable_v<int[4]>);
 static_assert(!ttg::detail::is_boost_user_buffer_serializable_v<int[4]>);
-static_assert(!ttg::detail::is_cereal_user_buffer_serializable_v<int[4]>);
 static_assert(!ttg::detail::is_user_buffer_serializable_v<int[4]>);
 static_assert(!ttg::detail::is_user_buffer_serializable_v<std::array<int, 4>>);
 
@@ -819,20 +733,6 @@ TEST_CASE("Boost Serialization", "[serialization]") {
 }
 #endif  // TTG_SERIALIZATION_SUPPORTS_BOOST
 
-#ifdef TTG_SERIALIZATION_SUPPORTS_CEREAL
-TEST_CASE("Cereal Serialization", "[serialization]") {
-  auto test = [](const auto& t) {
-    using T = std::remove_reference_t<decltype(t)>;
-    CHECK(ttg::detail::is_cereal_serializable_v<cereal::BinaryOutputArchive, T>);
-    using Tnc = std::remove_const_t<T>;
-    CHECK(ttg::detail::is_cereal_serializable_v<cereal::BinaryInputArchive, Tnc>);
-  };
-
-  test(intrusive::symmetric::bc_v::NonPOD{17});
-  test(freestanding::symmetric::bc_v::NonPOD{18});
-}
-#endif  // TTG_SERIALIZATION_SUPPORTS_CEREAL
-
 #if defined(TTG_SERIALIZATION_SUPPORTS_MADNESS) && defined(TTG_SERIALIZATION_SUPPORTS_BOOST)
 TEST_CASE("TTG Serialization", "[serialization]") {
   // Test code written as if calling from C
@@ -888,10 +788,6 @@ TEST_CASE("TTG Serialization", "[serialization]") {
   test_struct(intrusive::symmetric::bc_v::NonPOD{20});     // Boost
   test_struct(freestanding::symmetric::bc_v::NonPOD{21});  // Boost
 #endif
-#ifdef TTG_SERIALIZATION_SUPPORTS_CEREAL
-  test_struct(intrusive::symmetric::c::NonPOD{22});    // Cereal
-  test_struct(intrusive::symmetric::c_v::NonPOD{23});  // Cereal
-#endif
 
 #ifdef TTG_SERIALIZATION_SUPPORTS_BOOST
   // verify that turning off version and object tracking for Boost produces same archive since the TTG boost archives

ttg/CMakeLists.txt

@@ -153,7 +153,6 @@ set(ttg-serialization-headers
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/serialization/traits.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/serialization/backends/boost.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/serialization/backends/boost/archive.h
-        ${CMAKE_CURRENT_SOURCE_DIR}/ttg/serialization/backends/cereal.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/serialization/backends/madness.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/serialization/std/allocator.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/serialization/std/array.h
@@ -180,10 +179,6 @@ if (TARGET Boost::serialization)
   endif()
   list(APPEND ttg-serialization-compile-definitions TTG_SERIALIZATION_SUPPORTS_BOOST=1)
 endif (TARGET Boost::serialization)
-if (TARGET cereal::cereal)
-  list(APPEND ttg-serialization-deps cereal::cereal)
-  list(APPEND ttg-serialization-compile-definitions TTG_SERIALIZATION_SUPPORTS_CEREAL=1)
-endif (TARGET cereal::cereal)
 
 add_ttg_library(ttg-serialization
                 "${ttg-serialization-sources}"
@@ -206,14 +201,6 @@ if (TARGET Boost::serialization)
           LINK_LIBRARIES "${ttg-serialization-boost-deps}"
           COMPILE_DEFINITIONS "TTG_SERIALIZATION_SUPPORTS_BOOST=1")
 endif(TARGET Boost::serialization)
-# make cereal-only serialization target
-if (TARGET cereal::cereal)
-  add_ttg_library(ttg-serialization-cereal
-          "${ttg-serialization-sources}"
-          PUBLIC_HEADER "${ttg-serialization-headers}"
-          LINK_LIBRARIES "cereal::cereal"
-          COMPILE_DEFINITIONS "TTG_SERIALIZATION_SUPPORTS_CEREAL=1")
-endif(TARGET cereal::cereal)
 
 #########################
 ####### MADNESS-specific

ttg/ttg/madness/buffer.h

@@ -273,25 +273,6 @@ struct Buffer : private Allocator {
   }
 #endif // TTG_SERIALIZATION_SUPPORTS_BOOST
 
-#if defined(TTG_SERIALIZATION_SUPPORTS_CEREAL) && 0
-  template <class Archive>
-  std::enable_if_t<std::is_base_of_v<cereal::detail::InputArchiveBase, Archive> ||
-                    std::is_base_of_v<cereal::detail::OutputArchiveBase, Archive>>
-  serialize(Archive& ar) {
-    if constexpr (ttg::detail::is_output_archive_v<Archive>)
-      std::size_t s = size();
-      ar(s);
-      /* TODO: how to serialize the array? */
-    else {
-      std::size_t s;
-      ar(s);
-      reset(s);
-      /* TODO: how to deserialize the array? */
-    }
-    ar(value);
-  }
-#endif // TTG_SERIALIZATION_SUPPORTS_CEREAL
-
 #if defined(TTG_SERIALIZATION_SUPPORTS_MADNESS)
   template <typename Archive>
   std::enable_if_t<std::is_base_of_v<madness::archive::BufferInputArchive, Archive> ||

ttg/ttg/parsec/buffer.h

@@ -350,27 +350,6 @@ struct Buffer : public detail::ttg_parsec_data_wrapper_t
   }
 #endif // TTG_SERIALIZATION_SUPPORTS_BOOST
 
-#ifdef TTG_SERIALIZATION_SUPPORTS_CEREAL
-  template <class Archive>
-  std::enable_if_t<std::is_base_of_v<cereal::detail::InputArchiveBase, Archive> ||
-                    std::is_base_of_v<cereal::detail::OutputArchiveBase, Archive>>
-  serialize(Archive& ar) {
-    if constexpr (ttg::detail::is_output_archive_v<Archive>)
-      std::size_t s = size();
-      assert(m_ttg_copy != nullptr); // only tracked objects allowed
-      m_ttg_copy->iovec_add(ttg::iovec{s*sizeof(T), current_device_ptr()});
-      ar(s);
-    else {
-      std::size_t s;
-      ar(s);
-      reset(s);
-      assert(m_ttg_copy != nullptr); // only tracked objects allowed
-      m_ttg_copy->iovec_add(ttg::iovec{s*sizeof(T), current_device_ptr()});
-    }
-    ar(value);
-  }
-#endif // TTG_SERIALIZATION_SUPPORTS_CEREAL
-
 #ifdef TTG_SERIALIZATION_SUPPORTS_MADNESS
   template <typename Archive>
   std::enable_if_t<std::is_base_of_v<madness::archive::BufferInputArchive, Archive> ||

ttg/ttg/serialization/backends.h

@@ -6,7 +6,6 @@
 #define TTG_SERIALIZATION_BACKENDS_H
 
 #include "ttg/serialization/backends/boost.h"
-#include "ttg/serialization/backends/cereal.h"
 #include "ttg/serialization/backends/madness.h"
 
 #endif  // TTG_SERIALIZATION_ALL_H