Serializer.h

Go to the documentation of this file.

//===-- serialbox/core/frontend/gridtools/Serializer.h ------------------------------*- C++ -*-===//
//
//                                    S E R I A L B O X
//
// This file is distributed under terms of BSD license.
// See LICENSE.txt for more information
//
//===------------------------------------------------------------------------------------------===//
//
//===------------------------------------------------------------------------------------------===//

#ifndef SERIALBOX_CORE_FRONTEND_GRIDTOOLS_SERIALIZER_H
#define SERIALBOX_CORE_FRONTEND_GRIDTOOLS_SERIALIZER_H

#include "serialbox/core/SerializerImpl.h"
#include "serialbox/core/archive/ArchiveFactory.h"
#include "serialbox/core/frontend/gridtools/Exception.h"
#include "serialbox/core/frontend/gridtools/FieldMetainfo.h"
#include "serialbox/core/frontend/gridtools/MetainfoMap.h"
#include "serialbox/core/frontend/gridtools/Savepoint.h"
#include "serialbox/core/frontend/gridtools/Slice.h"
#include "serialbox/core/frontend/gridtools/StorageViewHelper.h"
#include "serialbox/core/frontend/gridtools/Type.h"
#include <memory>

namespace serialbox {

namespace gridtools {

class serializer {
public:
  using savepoint_t = serialbox::gridtools::savepoint;
  using meta_info_map_t = serialbox::gridtools::meta_info_map;
  using field_meta_info_t = serialbox::gridtools::field_meta_info;

  static int serializationStatus() noexcept { return SerializerImpl::serializationStatus(); }

  static void enableSerialization() noexcept { SerializerImpl::enableSerialization(); }

  static void disableSerialization() noexcept { SerializerImpl::disableSerialization(); }

  serializer(open_mode mode, const std::string& directory, const std::string& prefix,
             std::string archive_name = "Binary")
      : serializerImpl_(std::make_shared<SerializerImpl>(mode, directory, prefix, archive_name)) {}

  serializer(const serializer&) = default;

  serializer(serializer&&) = default;

  serializer& operator=(const serializer&) = delete;

  serializer& operator=(serializer&&) = default;

  open_mode mode() const noexcept { return serializerImpl_->mode(); }

  std::string directory() const noexcept { return serializerImpl_->directory().string(); }

  std::string prefix() const noexcept { return serializerImpl_->prefix(); }

  std::string meta_data_file() const noexcept { return serializerImpl_->metaDataFile().string(); }

  std::string archive_name() const noexcept { return serializerImpl_->archiveName(); }

  void clear() noexcept { serializerImpl_->clear(); }

  void update_meta_data() { serializerImpl_->updateMetaData(); }

  //===----------------------------------------------------------------------------------------===//
  //     Global Meta-Information
  //===----------------------------------------------------------------------------------------===//

  template <class StringType, class ValueType>
  void add_global_meta_info(StringType&& key, ValueType&& value) {
    serializerImpl_->addGlobalMetainfo(std::forward<StringType>(key),
                                       std::forward<ValueType>(value));
  }

  template <class T, class StringType>
  T get_global_meta_info_as(StringType&& key) const {
    return serializerImpl_->getGlobalMetainfoAs<T>(std::forward<StringType>(key));
  }

  meta_info_map global_meta_info() noexcept {
    return meta_info_map(serializerImpl_->globalMetainfoPtr());
  }

  //===----------------------------------------------------------------------------------------===//
  //     Register and Query Fields
  //===----------------------------------------------------------------------------------------===//

  template <class StringType, typename... Args>
  void register_field(StringType&& name, Args&&... args) {
    serializerImpl_->registerField(std::forward<StringType>(name),
                                   *field_meta_info(std::forward<Args>(args)...).impl());
  }

  template <class StringType>
  bool has_field(StringType&& name) const noexcept {
    return serializerImpl_->hasField(std::forward<StringType>(name));
  }

  template <class StringType, class KeyType, class ValueType>
  bool add_meta_info_to_field(StringType&& name, KeyType&& key, ValueType&& value) {
    return serializerImpl_->addFieldMetainfoImpl(
        std::forward<StringType>(name), std::forward<KeyType>(key), std::forward<ValueType>(value));
  }

  template <class StringType>
  field_meta_info get_field_meta_info(StringType&& name) const {
    return field_meta_info(
        serializerImpl_->fieldMap().getFieldMetainfoImplPtrOf(std::forward<StringType>(name)));
  }

  std::vector<std::string> fieldnames() const { return serializerImpl_->fieldnames(); }

  //===----------------------------------------------------------------------------------------===//
  //     Register and Query Savepoints
  //===----------------------------------------------------------------------------------------===//

  template <typename... Args>
  bool register_savepoint(Args&&... args) noexcept {
    return serializerImpl_->registerSavepoint(*savepoint(std::forward<Args>(args)...).impl());
  }

  template <typename... Args>
  bool has_savepoint(const savepoint sp) const noexcept {
    return serializerImpl_->savepointVector().exists(*sp.impl());
  }

  const std::vector<savepoint>& savepoints() {
    const auto& savepoints = serializerImpl_->savepointVector().savepoints();
    if(!savepoints_ || (savepoints.size() != savepoints_->size())) {
      savepoints_ = std::make_shared<std::vector<savepoint>>();
      for(std::size_t i = 0; i < savepoints.size(); ++i)
        savepoints_->emplace_back(savepoints[i]);
    }
    return *savepoints_;
  }

  //===----------------------------------------------------------------------------------------===//
  //     Writing
  //===----------------------------------------------------------------------------------------===//

  template <class StorageType>
  void write(const std::string& name, const savepoint& sp, const StorageType& storage,
             bool register_field = true) {
    if(register_field && !serializerImpl_->fieldMap().hasField(name))
      this->register_field(name, storage);

    StorageView storageView(
        internal::get_origin_ptr(storage, 0), ToTypeID<typename StorageType::data_t>::value,
        std::move(internal::get_dims(storage)), std::move(internal::get_strides(storage)));
    serializerImpl_->write(name, *sp.impl(), storageView);
  }

  template <class T>
  void write(const std::string& name, const savepoint& sp, T* origin_ptr,
             const std::vector<int>& strides) {
    const auto& dims = get_field_meta_info(name).dims();
    StorageView storageView(origin_ptr, ToTypeID<T>::value, dims, strides);
    serializerImpl_->write(name, *sp.impl(), storageView);
  }

  template <class StorageType>
  static void to_file(std::string file, const StorageType& storage, std::string archive_name = "") {
    StorageView storageView(
        internal::get_origin_ptr(storage, 0), ToTypeID<typename StorageType::data_t>::value,
        std::move(internal::get_dims(storage)), std::move(internal::get_strides(storage)));

    if(archive_name.empty())
      archive_name = ArchiveFactory::archiveFromExtension(file);

    ArchiveFactory::writeToFile(file, storageView, archive_name, storage.name());
  }

  //===----------------------------------------------------------------------------------------===//
  //     Reading
  //===----------------------------------------------------------------------------------------===//

  template <class StorageType>
  void read(const std::string& name, const savepoint& sp, StorageType& storage) {
    StorageView storageView(
        internal::get_origin_ptr(storage, 0), ToTypeID<typename StorageType::data_t>::value,
        std::move(internal::get_dims(storage)), std::move(internal::get_strides(storage)));

    serializerImpl_->read(name, *sp.impl(), storageView);
  }

  template <class StorageType>
  void read_slice(const std::string& name, const savepoint& sp, StorageType& storage, Slice slice) {
    StorageView storageView(
        internal::get_origin_ptr(storage, 0), ToTypeID<typename StorageType::data_t>::value,
        std::move(internal::get_dims(storage)), std::move(internal::get_strides(storage)));
    storageView.setSlice(slice);
    serializerImpl_->read(name, *sp.impl(), storageView);
  }

  template <class T>
  void read(const std::string& name, const savepoint& sp, T* origin_ptr,
            const std::vector<int>& strides) {
    const auto& dims = get_field_meta_info(name).dims();
    StorageView storageView(origin_ptr, ToTypeID<T>::value, dims, strides);
    serializerImpl_->read(name, *sp.impl(), storageView);
  }

  template <class StorageType>
  static void from_file(std::string file, StorageType& storage, std::string archive_name = "") {
    StorageView storageView(
        internal::get_origin_ptr(storage, 0), ToTypeID<typename StorageType::data_t>::value,
        std::move(internal::get_dims(storage)), std::move(internal::get_strides(storage)));

    if(archive_name.empty())
      archive_name = ArchiveFactory::archiveFromExtension(file);

    ArchiveFactory::readFromFile(file, storageView, archive_name, storage.name());
  }

  std::string to_string() const { return serializerImpl_->toString(); }

  friend std::ostream& operator<<(std::ostream& stream, const serializer& s) {
    return (stream << *s.serializerImpl_);
  }

private:
  std::shared_ptr<SerializerImpl> serializerImpl_;
  std::shared_ptr<std::vector<savepoint>> savepoints_;
};

} // namespace gridtools

} // namespace serialbox

#endif