Serializer.h

Go to the documentation of this file.

//===-- serialbox/core/frontend/stella/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_STELLA_SERIALIZER_H
#define SERIALBOX_CORE_FRONTEND_STELLA_SERIALIZER_H

#ifdef SERIALBOX_HAS_STELLA
#include "DataFieldStorageFormat.h"
#include "DataFieldStorageStrides.h"
#endif

#include "serialbox/core/frontend/stella/DataFieldInfo.h"
#include "serialbox/core/frontend/stella/ForwardDecl.h"
#include "serialbox/core/frontend/stella/KBoundary.h"
#include "serialbox/core/frontend/stella/MetainfoSet.h"
#include "serialbox/core/frontend/stella/Savepoint.h"
#include "serialbox/core/frontend/stella/SerializationException.h"
#include <boost/shared_ptr.hpp>
#include <map>
#include <sstream>
#include <string>
#include <vector>

namespace serialbox {

namespace stella {

enum SerializerOpenMode {
  SerializerOpenModeRead,
  SerializerOpenModeWrite,
  SerializerOpenModeAppend
};

class Serializer {
public:
  Serializer();

  static void EnableSerialization();

  static void DisableSerialization();

  SerializerOpenMode mode() const;

  std::string directory() const;

  std::string prefix() const;

  void Init(const std::string& directory, const std::string& prefix, SerializerOpenMode mode);

  //===----------------------------------------------------------------------------------------===//
  //     Global meta-information
  //===----------------------------------------------------------------------------------------===//

  const MetainfoSet& globalMetainfo() const { return globalMetainfo_; }

  template <typename ValueType>
  void AddMetainfo(const std::string& key, ValueType value) {
    globalMetainfo_.AddMetainfo(key, value);
  }

  //===----------------------------------------------------------------------------------------===//
  //     Register fields
  //===----------------------------------------------------------------------------------------===//

  bool RegisterField(const std::string& name, std::string type, int bytesPerElement, int iSize,
                     int jSize, int kSize, int lSize, int iMinusHalo, int iPlusHalo, int jMinusHalo,
                     int jPlusHalo, int kMinusHalo, int kPlusHalo, int lMinusHalo, int lPlusHalo);

  const DataFieldInfo& FindField(const std::string& fieldname) const;

  void AddFieldMetainfo(const std::string& fieldname, const std::string& key, bool value);
  void AddFieldMetainfo(const std::string& fieldname, const std::string& key, int value);
  void AddFieldMetainfo(const std::string& fieldname, const std::string& key, float value);
  void AddFieldMetainfo(const std::string& fieldname, const std::string& key, double value);
  void AddFieldMetainfo(const std::string& fieldname, const std::string& key, std::string value);
  void AddFieldMetainfo(const std::string& fieldname, const std::string& key, const char* value) {
    AddFieldMetainfo(fieldname, key, std::string(value));
  }

  std::vector<std::string> fieldnames() const;

  const std::vector<Savepoint>& savepoints() const { return savepoints_; }

  std::vector<std::string> FieldsAtSavepoint(const Savepoint& savepoint) const;

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

  void WriteField(const std::string& fieldName, const Savepoint& savepoint, const void* pData,
                  int iStride, int jStride, int kStride, int lStride);

#ifdef SERIALBOX_HAS_STELLA
  template <typename TDataField>
  void WriteField(std::string name, const TDataField& field, const Savepoint& savepoint);
#endif

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

  void ReadField(const std::string& fieldName, const Savepoint& savepoint, void* pData, int iStride,
                 int jStride, int kStride, int lStride, bool alsoPrevious = false) const;

#ifdef SERIALBOX_HAS_STELLA
  template <typename TDataField>
  void ReadField(std::string name, TDataField& field, const Savepoint& savepoint,
                 bool alsoPrevious = false) const;
#endif

  std::string ToString() const;

  boost::shared_ptr<SerializerImpl>& getImpl() { return serializerImpl_; }
  const boost::shared_ptr<SerializerImpl>& getImpl() const { return serializerImpl_; }

private:
  // Implementation pointer
  boost::shared_ptr<SerializerImpl> serializerImpl_;

  // These data-strucures allow to return refrences but do not actually own any data but they need
  // to be kept in sync with the data from serializerImpl!
  MetainfoSet globalMetainfo_;
  std::vector<Savepoint> savepoints_;
  std::map<std::string, DataFieldInfo> datafieldInfos_;

  // This variable can take three values:
  //
  //  0: the variable is not yet initialized -> the serialization is enabled if the environment
  //     variable STELLA_SERIALIZATION_DISABLE is not set to  a positive value. The first
  //     serializer which is initialized has to set this value either to +1 or to -1 according to
  //     the environment.
  // +1: the serialization is enabled, independently of the environment
  // -1: the serialization is disabled, independently of the environment
  //
  // The value is initialized to 0
  static int enabled_;
};

//===------------------------------------------------------------------------------------------===//
//     Implementation of template methods
//===------------------------------------------------------------------------------------------===//

#ifdef SERIALBOX_HAS_STELLA
template <typename TDataField>
void Serializer::WriteField(std::string name, const TDataField& field, const Savepoint& savepoint) {

  if(name.empty())
    name = field.name();

  // Retrieve size, boundaries and strides
  IJKSize size;
  size.Init(field.storage().allocatedSize().iSize(), field.storage().allocatedSize().jSize(),
            field.storage().allocatedSize().kSize());

  IJKBoundary boundary;
  boundary.Init(field.boundary().iMinusOffset(), field.boundary().iPlusOffset(),
                field.boundary().jMinusOffset(), field.boundary().jPlusOffset(),
                field.boundary().kMinusOffset(), field.boundary().kPlusOffset());

  const int bytesPerElement = sizeof(typename TDataField::ValueType);

  DataFieldStorageStrides<typename TDataField::StorageFormat::StorageOrder> strides;
  strides.Init(field.storage().paddedSize());
  const int iStride = strides.ComputeStride(1, 0, 0) * bytesPerElement;
  const int jStride = strides.ComputeStride(0, 1, 0) * bytesPerElement;
  const int kStride = strides.ComputeStride(0, 0, 1) * bytesPerElement;

  // Register field
  this->RegisterField(name, type_name<typename TDataField::ValueType>(), bytesPerElement,
                      size.iSize(), size.jSize(), size.kSize(), 1, -boundary.iMinusOffset(),
                      boundary.iPlusOffset(), -boundary.jMinusOffset(), boundary.jPlusOffset(),
                      -boundary.kMinusOffset(), boundary.kPlusOffset(), 0, 0);

  this->WriteField(name, savepoint, field.storage().pStorageBase(), iStride, jStride, kStride, 0);
}

template <typename TDataField>
void Serializer::ReadField(std::string name, TDataField& field, const Savepoint& savepoint,
                           bool alsoPrevious) const {
  typedef typename TDataField::ValueType ValueType;

  if(name.empty())
    name = field.name();

  // Get info of serialized field
  const DataFieldInfo& info = FindField(name);
  const int bytesPerElement = sizeof(typename TDataField::ValueType);

  // Get strides according to STELLA
  DataFieldStorageStrides<typename TDataField::StorageFormat::StorageOrder> stridesSTELLA;
  stridesSTELLA.Init(field.storage().paddedSize());

  // Get rid of degenerated dimensions and fix strides
  std::vector<int> allSizes, size, allStrides, strides;
  allSizes.push_back(field.storage().allocatedSize().iSize());
  allSizes.push_back(field.storage().allocatedSize().jSize());
  allSizes.push_back(field.storage().allocatedSize().kSize());
  allSizes.push_back(0);
  allStrides.push_back(stridesSTELLA.ComputeStride(1, 0, 0) * bytesPerElement);
  allStrides.push_back(stridesSTELLA.ComputeStride(0, 1, 0) * bytesPerElement);
  allStrides.push_back(stridesSTELLA.ComputeStride(0, 0, 1) * bytesPerElement);
  for (int i = 0; i < 4; ++i) {
      if (allSizes[i] > 1)
      {
          size.push_back(allSizes[i]);
          strides.push_back(allStrides[i]);
      }
  }
  size.resize(4, 0);

  IJKBoundary boundary;
  boundary.Init(field.boundary().iMinusOffset(), field.boundary().iPlusOffset(),
                field.boundary().jMinusOffset(), field.boundary().jPlusOffset(),
                field.boundary().kMinusOffset(), field.boundary().kPlusOffset());


  if((info.iSize() != size[0]) || (info.jSize() != size[1]) ||
     (info.kSize() != size[2]) || (info.lSize() != 0)) {
    // Throw exception
    std::ostringstream errorstr;
    errorstr << "Error: the requested field " << name << " has a different size than"
             << " the provided data field.\n";
    errorstr << "Registerd as: " << info.iSize() << "x" << info.jSize() << "x" << info.kSize()
             << "x" << info.lSize() << "\n";
    errorstr << "Given       : " << size[0] << "x" << size[1] << "x" << size[2]
             << "x" << size[3] << "x0" << "\n";
    SerializationException exception;
    exception.Init(errorstr.str());
    throw exception;
  }

  // Check data type
  if(info.type() != type_name<ValueType>()) {
    // Throw exception
    std::ostringstream errorstr;
    errorstr << "Error: the requested field " << name << " has different type than"
             << " the provided data field (expected " << info.type() << ", got "
             << type_name<ValueType>() << ")";
    SerializationException exception;
    exception.Init(errorstr.str());
    throw exception;
  }

  // This hack is used to retrieve the storage pointer for the host memory in case of GPU fields
  // This will synchronize the host storage
  ValueType* data =
      &field(boundary.iMinusOffset(), boundary.jMinusOffset(), boundary.kMinusOffset());

  // Perform the read
  this->ReadField(name, savepoint, data, strides[0], strides[1], strides[2], 0, alsoPrevious);
}
#endif

} // namespace stella

} // namespace serialbox

#endif