FlatObject.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef ALICEOW_GPUCOMMON_TPCFASTTRANSFORMATION_FLATOBJECT_H
#define ALICEOW_GPUCOMMON_TPCFASTTRANSFORMATION_FLATOBJECT_H
 
#if !defined(GPUCA_GPUCODE_DEVICE)
#include <cstddef>
#include <memory>
#include <cstring>
#include <cassert>
#endif
 
#include "GPUCommonDef.h"
#include "GPUCommonRtypes.h"
#include "GPUCommonLogger.h"
 
// #define GPUCA_GPUCODE // uncomment to test "GPU" mode
 
namespace o2
{
namespace gpu
{
//
 
class FlatObject
{
 public:
 
#ifndef GPUCA_GPUCODE
  FlatObject() = default; // No object derrived from FlatObject should be created on the GPU
  ~FlatObject();
  FlatObject(const FlatObject&) = delete;
  FlatObject& operator=(const FlatObject&) = delete;
#else
  FlatObject() = delete;
#endif
 
#ifndef GPUCA_GPUCODE // code invisible on GPU
  template <typename T>
  T* resizeArray(T*& ptr, int32_t oldSize, int32_t newSize, T* newPtr = nullptr)
  {
    // Resize array pointed by ptr. T must be a POD class.
    // If the non-null newPtr is provided, use it instead of allocating a new one.
    // In this case it is up to the user to ensure that it has at least newSize slots allocated.
    // Return original array pointer, so that the user can manage previously allocate memory
    if (oldSize < 0) {
      oldSize = 0;
    }
    if (newSize > 0) {
      if (!newPtr) {
        newPtr = new T[newSize];
      }
      int32_t mcp = std::min(newSize, oldSize);
      if (mcp) {
        assert(ptr);
        std::memmove(newPtr, ptr, mcp * sizeof(T));
      }
      if (newSize > oldSize) {
        std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T));
      }
    }
    T* oldPtr = ptr;
    ptr = newPtr;
    return oldPtr;
  }
 
  template <typename T>
  T** resizeArray(T**& ptr, int32_t oldSize, int32_t newSize, T** newPtr = nullptr)
  {
    // Resize array of pointers pointed by ptr.
    // If the non-null newPtr is provided, use it instead of allocating a new one.
    // In this case it is up to the user to ensure that it has at least newSize slots allocated.
    // Return original array pointer, so that the user can manage previously allocate memory
    if (oldSize < 0) {
      oldSize = 0;
    }
    if (newSize > 0) {
      if (!newPtr) {
        newPtr = new T*[newSize];
      }
      int32_t mcp = std::min(newSize, oldSize);
      std::memmove(newPtr, ptr, mcp * sizeof(T*));
      if (newSize > oldSize) {
        std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T*));
      }
    }
    T** oldPtr = ptr;
    ptr = newPtr;
    return oldPtr;
  }
#endif 
 
 protected:
 
  static constexpr size_t getClassAlignmentBytes() { return 8; }
 
  static constexpr size_t getBufferAlignmentBytes() { return 8; }
 
 
  void startConstruction();
 
  void finishConstruction(int32_t flatBufferSize);
 
#ifndef GPUCA_GPUCODE
  void cloneFromObject(const FlatObject& obj, char* newFlatBufferPtr);
#endif // !GPUCA_GPUCODE
 
 
  // Returns an unique pointer to the internal buffer with all the rights. Makes the internal container variable empty.
  char* releaseInternalBuffer();
 
#ifndef GPUCA_GPUCODE
  void moveBufferTo(char* newBufferPtr);
#endif // !GPUCA_GPUCODE
 
 
  void setActualBufferAddress(char* actualFlatBufferPtr);
 
  void setFutureBufferAddress(char* futureFlatBufferPtr);
 
 
 public:
  void destroy();
 
  GPUdi() size_t getFlatBufferSize() const { return mFlatBufferSize; }
 
  GPUdi() const char* getFlatBufferPtr() const { return mFlatBufferPtr; }
 
  bool isConstructed() const { return (mConstructionMask & (uint32_t)ConstructionState::Constructed); }
 
  bool isBufferInternal() const { return ((mFlatBufferPtr != nullptr) && (mFlatBufferPtr == mFlatBufferContainer)); }
 
  // Adopt an external pointer as internal buffer
  void adoptInternalBuffer(char* buf);
 
  // Hard reset of internal pointer to nullptr without deleting (needed copying an object without releasing)
  void clearInternalBufferPtr();
 
 
 public:
  static constexpr size_t alignSize(size_t sizeBytes, size_t alignmentBytes)
  {
    auto res = sizeBytes % alignmentBytes;
    return res ? sizeBytes + (alignmentBytes - res) : sizeBytes;
  }
 
  template <class T>
  static T* relocatePointer(const char* oldBase, char* newBase, const T* ptr)
  {
    return (ptr != nullptr) ? reinterpret_cast<T*>(newBase + (reinterpret_cast<const char*>(ptr) - oldBase)) : nullptr;
  }
 
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU
 
  template <class T, class TFile>
  static int32_t writeToFile(T& obj, TFile& outf, const char* name);
 
  template <class T, class TFile>
  static T* readFromFile(TFile& inpf, const char* name);
#endif
 
#if !defined(GPUCA_GPUCODE) // code invisible on GPU
 
  template <class T>
  static std::string stressTest(T& obj);
 
  void printC() const;
 
#endif 
 
 protected:
 
  enum ConstructionState : uint32_t {
    NotConstructed = 0x0, 
    Constructed = 0x1,    
    InProgress = 0x2      
  };
 
  int32_t mFlatBufferSize = 0;                                    
  uint32_t mConstructionMask = ConstructionState::NotConstructed; 
  char* mFlatBufferContainer = nullptr;                           //[mFlatBufferSize]  Optional container for the flat buffer
  char* mFlatBufferPtr = nullptr;                                 
 
  ClassDefNV(FlatObject, 1);
};
 
class NoFlatObject
{
 public:
  int32_t mFlatBufferSize = 0;
  static constexpr size_t getClassAlignmentBytes() { return 8; }
  static constexpr size_t getBufferAlignmentBytes() { return 8; }
  GPUdi() size_t getFlatBufferSize() const { return mFlatBufferSize; }
};
 
 
#ifndef GPUCA_GPUCODE // code invisible on GPU
inline FlatObject::~FlatObject()
{
  destroy();
}
 
inline void FlatObject::startConstruction()
{
  destroy();
  mConstructionMask = ConstructionState::InProgress;
}
 
inline void FlatObject::destroy()
{
  mFlatBufferSize = 0;
  delete[] mFlatBufferContainer;
  mFlatBufferPtr = mFlatBufferContainer = nullptr;
  mConstructionMask = ConstructionState::NotConstructed;
}
 
inline void FlatObject::finishConstruction(int32_t flatBufferSize)
{
 
  assert(mConstructionMask & (uint32_t)ConstructionState::InProgress);
 
  mFlatBufferSize = flatBufferSize;
  mFlatBufferPtr = mFlatBufferContainer = new char[mFlatBufferSize];
 
  memset((void*)mFlatBufferPtr, 0, mFlatBufferSize); // just to avoid random behavior in case of bugs
 
  mConstructionMask = (uint32_t)ConstructionState::Constructed; // clear other possible construction flags
}
 
inline void FlatObject::cloneFromObject(const FlatObject& obj, char* newFlatBufferPtr)
{
  // that we want to relocate the obj to external buffer)
 
  assert(obj.isConstructed());
 
  // providing *this with internal buffer as obj makes sens only if we want to conver it to object with PROVIDED external buffer
  assert(!(!newFlatBufferPtr && obj.mFlatBufferPtr == mFlatBufferPtr && obj.isBufferInternal()));
 
  char* oldPtr = resizeArray(mFlatBufferPtr, mFlatBufferSize, obj.mFlatBufferSize, newFlatBufferPtr);
 
  if (isBufferInternal()) {
    delete[] oldPtr; // delete old buffer if owned
  }
  mFlatBufferSize = obj.mFlatBufferSize;
  mFlatBufferContainer = newFlatBufferPtr ? nullptr : mFlatBufferPtr; // external buffer is not provided, make object to own the buffer
  std::memcpy(mFlatBufferPtr, obj.mFlatBufferPtr, obj.mFlatBufferSize);
  mConstructionMask = (uint32_t)ConstructionState::Constructed;
}
 
inline void FlatObject::moveBufferTo(char* newFlatBufferPtr)
{
  if (newFlatBufferPtr == mFlatBufferContainer) {
    return;
  }
  resizeArray(mFlatBufferPtr, mFlatBufferSize, mFlatBufferSize, newFlatBufferPtr);
  delete[] mFlatBufferContainer;
  mFlatBufferContainer = nullptr;
  if (!newFlatBufferPtr) { // resizeArray has created own array
    mFlatBufferContainer = mFlatBufferPtr;
  }
}
 
template <class T>
inline std::string FlatObject::stressTest(T& obj)
{
  std::string err;
 
  if (!obj.isConstructed()) {
    return "tested object is not constructed!";
  }
 
  T tst;
  tst.cloneFromObject(obj, nullptr);
  if (!tst.isConstructed() || !tst.isBufferInternal()) {
    return "error at cloneFromObject()!";
  }
 
  obj.destroy();
 
  char* buf0 = tst.releaseInternalBuffer();
  char* buf1 = new char[tst.getFlatBufferSize()];
  char* buf2 = new char[tst.getFlatBufferSize()];
  std::memcpy(buf1, tst.getFlatBufferPtr(), tst.getFlatBufferSize());
  tst.setActualBufferAddress(buf1);
  delete[] buf0;
 
  tst.setFutureBufferAddress(buf2);
  std::memcpy(buf2, buf1, tst.getFlatBufferSize());
  delete[] buf1;
 
  if (tst.isBufferInternal()) {
    return err = "error, buffer should be external!";
  }
 
  tst.adoptInternalBuffer(buf2);
  if (!tst.isBufferInternal()) {
    return err = "error, buffer should be internal!";
  }
 
  obj.cloneFromObject(tst, nullptr);
  if (!obj.isBufferInternal()) {
    return err = "error, buffer should be internal!";
  }
 
  return err;
}
 
inline void FlatObject::printC() const
{
  bool lfdone = false;
  for (int32_t i = 0; i < mFlatBufferSize; i++) {
    uint8_t v = mFlatBufferPtr[i];
    lfdone = false;
    printf("0x%02x ", v);
    if (i && ((i + 1) % 20) == 0) {
      printf("\n");
      lfdone = true;
    }
  }
  if (!lfdone) {
    printf("\n");
  }
}
 
#endif // GPUCA_GPUCODE
 
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU
template <class T, class TFile>
inline int32_t FlatObject::writeToFile(T& obj, TFile& outf, const char* name)
{
  assert(obj.isConstructed());
 
  if (outf.IsZombie()) {
    LOG(error) << "Failed to write to file " << outf.GetName();
    return -1;
  }
 
  bool isBufferExternal = !obj.isBufferInternal();
  if (isBufferExternal) {
    obj.adoptInternalBuffer(obj.mFlatBufferPtr);
  }
  outf.WriteObjectAny(&obj, T::Class(), name);
  if (isBufferExternal) {
    obj.clearInternalBufferPtr();
  }
  return 0;
}
 
template <class T, class TFile>
inline T* FlatObject::readFromFile(TFile& inpf, const char* name)
{
 
  if (inpf.IsZombie()) {
    LOG(error) << "Failed to read from file " << inpf.GetName();
    return nullptr;
  }
  T* pobj = reinterpret_cast<T*>(inpf.GetObjectChecked(name, T::Class()));
  if (!pobj) {
    LOG(error) << "Failed to load " << name << " from " << inpf.GetName();
    return nullptr;
  }
  if (pobj->mFlatBufferSize > 0 && pobj->mFlatBufferContainer == nullptr) {
    LOG(error) << "Failed to load " << name << " from " << inpf.GetName() << ": empty flat buffer container";
    return nullptr;
  }
  pobj->setActualBufferAddress(pobj->mFlatBufferContainer);
  return pobj;
}
#endif // GPUCA_GPUCODE || GPUCA_STANDALONE
 
#ifndef GPUCA_GPUCODE_DEVICE
 
inline char* FlatObject::releaseInternalBuffer()
{
  // returns an pointer to the internal buffer. Makes the internal container variable empty.
  char* contPtr = mFlatBufferContainer;
  mFlatBufferContainer = nullptr;
  return contPtr;
}
 
inline void FlatObject::adoptInternalBuffer(char* buf)
{
  // buf becomes the new internal buffer, after it was already set as new setActualBufferAddress
  assert((mFlatBufferPtr == buf));
  mFlatBufferContainer = buf;
}
 
inline void FlatObject::clearInternalBufferPtr()
{
  // we just release the internal buffer ressetting it to nullptr
  mFlatBufferContainer = nullptr;
}
 
inline void FlatObject::setActualBufferAddress(char* actualFlatBufferPtr)
{
 
  mFlatBufferPtr = actualFlatBufferPtr;
}
 
inline void FlatObject::setFutureBufferAddress(char* futureFlatBufferPtr)
{
 
  assert(!isBufferInternal());
  mFlatBufferPtr = futureFlatBufferPtr;
#ifndef GPUCA_GPUCODE            // code invisible on GPU
  delete[] mFlatBufferContainer; // for a case..
#endif                           // !GPUCA_GPUCODE
  mFlatBufferContainer = nullptr;
}
 
#endif // GPUCA_GPUCODE_DEVICE
 
} // namespace gpu
} // namespace o2
 
#endif