data_descriptor.h

Go to the documentation of this file.

#ifndef TTG_SERIALIZATION_DATA_DESCRIPTOR_H
#define TTG_SERIALIZATION_DATA_DESCRIPTOR_H
 
#include <cstdint>
 
#ifdef TTG_SERIALIZATION_SUPPORTS_MADNESS
#include <madness/world/buffer_archive.h>
#endif
 
#include "ttg/serialization/traits.h"
 
#include "ttg/serialization/stream.h"
 
#include <cstring>  // for std::memcpy
 
#include "ttg/serialization/splitmd_data_descriptor.h"
 
extern "C" struct ttg_data_descriptor {
  const char *name;
 
  uint64_t (*payload_size)(const void *object);
 
  uint64_t (*pack_payload)(const void *object, uint64_t max_nbytes_to_write, uint64_t offset, void *buf);
 
  uint64_t (*unpack_payload)(void *object, uint64_t max_nbytes_to_read, uint64_t offset, const void *buf);
 
  void (*print)(const void *object);
};
 
namespace ttg {
 
  template <typename T, typename Enabler = void>
  struct default_data_descriptor;
 
  template <typename T>
  struct default_data_descriptor<
      T, std::enable_if_t<detail::is_memcpyable_v<T> && !detail::is_user_buffer_serializable_v<T> &&
                          !ttg::has_split_metadata<T>::value>> {
    static constexpr const bool serialize_size_is_const = true;
 
    static uint64_t payload_size(const void *object) { return static_cast<uint64_t>(sizeof(T)); }
 
    static uint64_t pack_payload(const void *object, uint64_t max_nbytes_to_write, uint64_t begin, void *buf) {
      unsigned char *char_buf = reinterpret_cast<unsigned char *>(buf);
      assert(sizeof(T)<=max_nbytes_to_write);
      std::memcpy(&char_buf[begin], object, sizeof(T));
      return begin + sizeof(T);
    }
 
    static uint64_t unpack_payload(void *object, uint64_t max_nbytes_to_read, uint64_t begin, const void *buf) {
      const unsigned char *char_buf = reinterpret_cast<const unsigned char *>(buf);
      assert(sizeof(T)<=max_nbytes_to_read);
      std::memcpy(object, &char_buf[begin], sizeof(T));
      return begin + sizeof(T);
    }
  };
 
  template <typename T>
  struct default_data_descriptor<T, std::enable_if_t<ttg::has_split_metadata<T>::value>> {
    static constexpr const bool serialize_size_is_const = false;
 
    static uint64_t payload_size(const void *object) {
      SplitMetadataDescriptor<T> smd;
      const T *t = reinterpret_cast<T *>(object);
      auto metadata = smd.get_metadata(t);
      size_t size = sizeof(metadata);
      for (auto &&iovec : smd.get_data(t)) {
        size += iovec.num_bytes;
      }
 
      return static_cast<uint64_t>(size);
    }
 
    static uint64_t pack_payload(const void *object, uint64_t max_nbytes_to_write, uint64_t begin, void *buf) {
      SplitMetadataDescriptor<T> smd;
      const T *t = reinterpret_cast<T *>(object);
 
      unsigned char *char_buf = reinterpret_cast<unsigned char *>(buf);
      auto metadata = smd.get_metadata(t);
      assert(sizeof(metadata) <= max_nbytes_to_write);
      std::memcpy(&char_buf[begin], metadata, sizeof(metadata));
      size_t pos = sizeof(metadata);
      for (auto &&iovec : smd.get_data(t)) {
        std::memcpy(&char_buf[begin + pos], iovec.data, iovec.num_bytes);
        pos += iovec.num_bytes;
        assert(pos <= max_nbytes_to_write);
      }
      return begin + pos;
    }
 
    static uint64_t unpack_payload(void *object, uint64_t max_nbytes_to_read, uint64_t begin, const void *buf) {
      SplitMetadataDescriptor<T> smd;
      T *t = reinterpret_cast<T *>(object);
 
      using metadata_t = decltype(smd.get_metadata(t));
      assert(sizeof(metadata_t) <= max_nbytes_to_read);
      const unsigned char *char_buf = reinterpret_cast<const unsigned char *>(buf);
      const metadata_t *metadata = reinterpret_cast<const metadata_t *>(char_buf + begin);
      T t_created = smd.create_from_metadata();
      size_t pos = sizeof(metadata);
      *t = t_created;
      for (auto &&iovec : smd.get_data(t)) {
        std::memcpy(iovec.data, &char_buf[begin + pos], iovec.num_bytes);
        pos += iovec.num_bytes;
        assert(pos <= max_nbytes_to_read);
      }
      return begin + pos;
    }
  };
 
}  // namespace ttg
 
#if defined(TTG_SERIALIZATION_SUPPORTS_MADNESS)
 
namespace ttg {
 
  template <typename T>
  struct default_data_descriptor<
      T, std::enable_if_t<((!detail::is_memcpyable_v<T> && detail::is_madness_buffer_serializable_v<T>) ||
                           detail::is_madness_user_buffer_serializable_v<T>)&&!ttg::has_split_metadata<T>::value>> {
    static constexpr const bool serialize_size_is_const = false;
 
    static uint64_t payload_size(const void *object) {
      madness::archive::BufferOutputArchive ar;
      ar & (*static_cast<std::add_pointer_t<std::add_const_t<T>>>(object));
      return static_cast<uint64_t>(ar.size());
    }
 
    static uint64_t pack_payload(const void *object, uint64_t max_nbytes_to_write, uint64_t pos, void *_buf) {
      unsigned char *buf = reinterpret_cast<unsigned char *>(_buf);
      madness::archive::BufferOutputArchive ar(&buf[pos], max_nbytes_to_write);
      ar & (*static_cast<std::add_pointer_t<std::add_const_t<T>>>(object));
      return pos + ar.size();
    }
 
    static uint64_t unpack_payload(void *object, uint64_t max_nbytes_to_read, uint64_t pos, const void *_buf) {
      const unsigned char *buf = reinterpret_cast<const unsigned char *>(_buf);
      madness::archive::BufferInputArchive ar(&buf[pos], max_nbytes_to_read);
      ar & (*static_cast<std::add_pointer_t<T>>(object));
      return pos + (max_nbytes_to_read - ar.nbyte_avail());
    }
  };
 
}  // namespace ttg
 
#endif  // has MADNESS serialization
 
#if defined(TTG_SERIALIZATION_SUPPORTS_BOOST)
 
#include "ttg/serialization/backends/boost/archive.h"
 
namespace ttg {
 
  template <typename T>
  struct default_data_descriptor<
      T, std::enable_if_t<(!detail::is_memcpyable_v<T> && !detail::is_madness_buffer_serializable_v<T> &&
                           detail::is_boost_buffer_serializable_v<T>) ||
                          (!detail::is_madness_user_buffer_serializable_v<T> &&
                           detail::is_boost_user_buffer_serializable_v<T>)>> {
    static constexpr const bool serialize_size_is_const = false;
 
    static uint64_t payload_size(const void *object) {
      ttg::detail::boost_counting_oarchive oa;
      oa << (*static_cast<std::add_pointer_t<std::add_const_t<T>>>(object));
      return oa.streambuf().size();
    }
 
    static uint64_t pack_payload(const void *object, uint64_t max_nbytes_to_write, uint64_t pos, void *buf) {
      auto oa = ttg::detail::make_boost_buffer_oarchive(buf, pos + max_nbytes_to_write, pos);
      oa << (*static_cast<std::add_pointer_t<std::add_const_t<T>>>(object));
      assert(oa.streambuf().size() <= max_nbytes_to_write);
      return pos + oa.streambuf().size();
    }
 
    static uint64_t unpack_payload(void *object, uint64_t max_nbytes_to_read, uint64_t pos, const void *buf) {
      auto ia = ttg::detail::make_boost_buffer_iarchive(buf, pos + max_nbytes_to_read, pos);
      ia >> (*static_cast<std::add_pointer_t<T>>(object));
      assert(ia.streambuf().size() <= max_nbytes_to_read);
      return pos + ia.streambuf().size();
    }
  };
 
}  // namespace ttg
 
#endif  // has Boost serialization
 
namespace ttg {
 
  // Returns a pointer to a constant static instance initialized
  // once at run time.
  template <typename T>
  const ttg_data_descriptor *get_data_descriptor() {
    static const ttg_data_descriptor d = {
        typeid(T).name(), &default_data_descriptor<T>::payload_size, &default_data_descriptor<T>::pack_payload,
        &default_data_descriptor<T>::unpack_payload, &detail::printer_helper<T>::print};
    return &d;
  }
 
}  // namespace ttg
 
#endif  // TTG_SERIALIZATION_DATA_DESCRIPTOR_H