SoATupleHelper.h

Go to the documentation of this file.

#ifndef FWCore_Utilities_SoATupleHelper_h
#define FWCore_Utilities_SoATupleHelper_h
// -*- C++ -*-
//
// Package:     Package
// Class  :     SoATupleHelper
//
//
// Original Author:  Chris Jones
//         Created:  Tue, 16 Apr 2013 21:06:08 GMT
//

// system include files
#include <tuple>
#include <algorithm>

// user include files

// forward declarations
namespace edm {
  namespace soahelper {

    constexpr unsigned int padding_needed(size_t iSizeSoFar, unsigned int iBoundary) {
      return (iBoundary - iSizeSoFar % iBoundary) % iBoundary;
    }

    template <unsigned int I, unsigned int J, typename Ret, typename... Args>
    struct arg_puller;

    template <unsigned int I, unsigned int J, typename Ret, typename F, typename... Args>
    struct arg_puller<I, J, Ret, F, Args...> {
      static Ret pull(F const&, const Args&... args) { return arg_puller<I + 1, J, Ret, Args...>::pull(args...); }
    };

    template <unsigned int I, typename Ret, typename F, typename... Args>
    struct arg_puller<I, I, Ret, F, Args...> {
      static Ret pull(F const& iV, const Args&...) { return iV; }
    };

    template <typename T, unsigned int ALIGNMENT>
    struct Aligned {
      static const unsigned int kAlignment = ALIGNMENT;
      typedef T Type;
    };

    template <typename T>
    struct AlignmentHelper {
      static const std::size_t kAlignment = alignof(T);
      typedef T Type;
    };

    template <typename T, unsigned int ALIGNMENT>
    struct AlignmentHelper<Aligned<T, ALIGNMENT>> {
      static const std::size_t kAlignment = ALIGNMENT;
      typedef T Type;
    };

    template <unsigned int I, typename... Args>
    struct SoATupleHelper {
      typedef AlignmentHelper<typename std::tuple_element<I - 1, std::tuple<Args...>>::type> AlignmentInfo;
      typedef typename AlignmentInfo::Type Type;
      typedef SoATupleHelper<I - 1, Args...> NextHelper;

      static const std::size_t max_alignment =
          AlignmentInfo::kAlignment > NextHelper::max_alignment ? AlignmentInfo::kAlignment : NextHelper::max_alignment;

      // ---------- static member functions --------------------
      static size_t moveToNew(char* iNewMemory, size_t iSize, size_t iReserve, void** oToSet);
      static size_t copyToNew(char* iNewMemory, size_t iSize, size_t iReserve, void* const* iFrom, void** oToSet);
      static size_t spaceNeededFor(unsigned int iNElements);
      static void push_back(void** iToSet, size_t iSize, std::tuple<Args...> const& iValues);
      template <typename... FArgs>
      static void emplace_back(void** iToSet, size_t iSize, FArgs... iValues);
      static void destroy(void** iToSet, size_t iSize);

      // ---------- member functions ---------------------------
      SoATupleHelper(const SoATupleHelper&) = delete;  // stop default

      const SoATupleHelper& operator=(const SoATupleHelper&) = delete;  // stop default
    };

    //Specialization used to stop recursion
    template <typename... Args>
    struct SoATupleHelper<0, Args...> {
      static const std::size_t max_alignment = 0;
      static void destroy(void** /*iToSet*/, size_t /*iSize*/) {}

      static void push_back(void** /*iToSet*/, size_t /*iSize*/, std::tuple<Args...> const& /*values*/) {}

      template <typename... FArgs>
      static void emplace_back(void** iToSet, size_t iSize, FArgs... iValues) {}

      static size_t spaceNeededFor(unsigned int /*iNElements*/) { return 0; }

      static size_t moveToNew(char* /*iNewMemory*/, size_t /*iSize*/, size_t /*iReserve*/, void** /*oToSet*/) {
        return 0;
      }

      static size_t copyToNew(
          char* /*iNewMemory*/, size_t /*iSize*/, size_t /*iReserve*/, void* const* /*iFrom*/, void** /*oToSet*/) {
        return 0;
      }
    };

    template <unsigned int I, typename... Args>
    size_t SoATupleHelper<I, Args...>::moveToNew(char* iNewMemory, size_t iSize, size_t iReserve, void** oToSet) {
      size_t usedSoFar = NextHelper::moveToNew(iNewMemory, iSize, iReserve, oToSet);

      //find new start
      const unsigned int boundary = AlignmentInfo::kAlignment;

      Type* newStart = reinterpret_cast<Type*>(iNewMemory + usedSoFar + padding_needed(usedSoFar, boundary));

      void** oldStart = oToSet + I - 1;

      Type* oldValues = static_cast<Type*>(*oldStart);
      if (oldValues != nullptr) {
        auto ptr = newStart;
        for (auto it = oldValues; it != oldValues + iSize; ++it, ++ptr) {
          new (ptr) Type(std::move(*it));
        }
        for (auto it = oldValues; it != oldValues + iSize; ++it) {
          it->~Type();
        }
      }
      *oldStart = newStart;
      unsigned int additionalSize = padding_needed(usedSoFar, boundary) + iReserve * sizeof(Type);
      return usedSoFar + additionalSize;
    }

    template <unsigned int I, typename... Args>
    size_t SoATupleHelper<I, Args...>::copyToNew(
        char* iNewMemory, size_t iSize, size_t iReserve, void* const* iFrom, void** oToSet) {
      size_t usedSoFar = NextHelper::copyToNew(iNewMemory, iSize, iReserve, iFrom, oToSet);

      //find new start
      const unsigned int boundary = AlignmentInfo::kAlignment;

      Type* newStart = reinterpret_cast<Type*>(iNewMemory + usedSoFar + padding_needed(usedSoFar, boundary));

      void* const* oldStart = iFrom + I - 1;

      Type* oldValues = static_cast<Type*>(*oldStart);
      if (oldValues != nullptr) {
        auto ptr = newStart;
        for (auto it = oldValues; it != oldValues + iSize; ++it, ++ptr) {
          new (ptr) Type(*it);
        }
      }
      *(oToSet + I - 1) = newStart;
      unsigned int additionalSize = padding_needed(usedSoFar, boundary) + iReserve * sizeof(Type);
      return usedSoFar + additionalSize;
    }

    template <unsigned int I, typename... Args>
    size_t SoATupleHelper<I, Args...>::spaceNeededFor(unsigned int iNElements) {
      size_t usedSoFar = NextHelper::spaceNeededFor(iNElements);
      const unsigned int boundary = AlignmentInfo::kAlignment;
      unsigned int additionalSize = padding_needed(usedSoFar, boundary) + iNElements * sizeof(Type);
      return usedSoFar + additionalSize;
    }

    template <unsigned int I, typename... Args>
    void SoATupleHelper<I, Args...>::push_back(void** iToSet, size_t iSize, std::tuple<Args...> const& iValues) {
      new (static_cast<Type*>(*(iToSet + I - 1)) + iSize) Type(std::get<I - 1>(iValues));

      NextHelper::push_back(iToSet, iSize, iValues);
    }

    template <unsigned int I, typename... Args>
    template <typename... FArgs>
    void SoATupleHelper<I, Args...>::emplace_back(void** iToSet, size_t iSize, FArgs... iValues) {
      new (static_cast<Type*>(*(iToSet + I - 1)) + iSize)
          Type(arg_puller<0, I - 1, Type const&, FArgs...>::pull(std::forward<FArgs>(iValues)...));

      NextHelper::emplace_back(iToSet, iSize, std::forward<FArgs>(iValues)...);
    }

    template <unsigned int I, typename... Args>
    void SoATupleHelper<I, Args...>::destroy(void** iToSet, size_t iSize) {
      void** start = iToSet + I - 1;
      Type* values = static_cast<Type*>(*start);

      for (auto it = values; it != values + iSize; ++it) {
        it->~Type();
      }

      NextHelper::destroy(iToSet, iSize);
    }

  }  // namespace soahelper
}  // namespace edm

#endif