SoATuple.h

Go to the documentation of this file.

#ifndef FWCore_Utilities_SoATuple_h
#define FWCore_Utilities_SoATuple_h
// -*- C++ -*-
//
// Package:     FWCore/Utilities
// Class  :     SoATuple
// 
//
// Original Author:  Chris Jones
//         Created:  Tue, 16 Apr 2013 20:34:31 GMT
// $Id: SoATuple.h,v 1.4 2013/04/23 20:07:48 chrjones Exp $
//

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

// user include files
#include "FWCore/Utilities/interface/SoATupleHelper.h"
#include "FWCore/Utilities/interface/GCCPrerequisite.h"


// forward declarations

namespace edm {

  //The class Aligned is used to specify a non-default alignment for a class
  using edm::soahelper::Aligned;
  
  //Proper alignment for doing vectorized operations on CPU
  template<typename T> using AlignedVec = Aligned<T,16>;
  
  template <typename... Args>
  class SoATuple
  {
    
  public:
    typedef typename std::tuple<Args...> element;

    SoATuple(): m_size(0),m_reserved(0){
      for(auto& v : m_values) {
        v = nullptr;
      }
    }
    SoATuple(const SoATuple<Args...>& iOther):m_size(0),m_reserved(0) {
      for(auto& v : m_values) {
        v = nullptr;
      }
      reserve(iOther.m_size);
      soahelper::SoATupleHelper<sizeof...(Args),Args...>::copyToNew(static_cast<char*>(m_values[0]),iOther.m_size,m_reserved,iOther.m_values,m_values);
      m_size = iOther.m_size;
    }

    SoATuple(SoATuple<Args...>&& iOther):m_size(0),m_reserved(0) {
      for(auto& v : m_values) {
        v = nullptr;
      }
      this->swap(iOther);
    }

    const SoATuple<Args...>& operator=(const SoATuple<Args...>& iRHS) {
      SoATuple<Args...> temp(iRHS);
      this->swap(temp);
      return *this;
    }

    ~SoATuple() {
      soahelper::SoATupleHelper<sizeof...(Args),Args...>::destroy(m_values,m_size);
      typedef std::aligned_storage<soahelper::SoATupleHelper<sizeof...(Args),Args...>::max_alignment,
      soahelper::SoATupleHelper<sizeof...(Args),Args...>::max_alignment> AlignedType;

      delete [] static_cast<AlignedType*>(m_values[0]);
    }
    
    // ---------- const member functions ---------------------
    size_t size() const { return m_size;}
    size_t capacity() const {return m_reserved;}

    template<unsigned int I>
    typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type const& get(unsigned int iIndex) const {
      typedef typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type ReturnType;
      return *(static_cast<ReturnType const*>(m_values[I])+iIndex);
    }

    template<unsigned int I>
    typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type const* begin() const {
      typedef soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type> Helper;
      typedef typename Helper::Type ReturnType;
#if GCC_PREREQUISITE(4,7,0)
      return static_cast<ReturnType const*>(__builtin_assume_aligned(m_values[I],Helper::kAlignment));
#else
      return static_cast<ReturnType const*>(m_values[I]);
#endif
    }
    template<unsigned int I>
    typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type const* end() const {
      typedef typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type ReturnType;
      return static_cast<ReturnType const*>(m_values[I])+m_size;
    }

    // ---------- member functions ---------------------------
    void reserve(unsigned int iToSize) {
      if(iToSize > m_reserved) {
        changeSize(iToSize);
      }
    }
    
    void shrink_to_fit() {
      if(m_reserved > m_size) {
        changeSize(m_size);
      }
    }

    void push_back(element const& values) {
      if(size()+1>capacity()) {
        reserve(size()*2+1);
      }
      soahelper::SoATupleHelper<sizeof...(Args),Args...>::push_back(m_values,m_size,values);
      ++m_size;
    }

    template< typename... FArgs>
    void emplace_back(FArgs&&... values) {
      if(size()+1>capacity()) {
        reserve(size()*2+1);
      }
      soahelper::SoATupleHelper<sizeof...(Args),Args...>::emplace_back(m_values,m_size,std::forward<FArgs>(values)...);
      ++m_size;
    }

    template<unsigned int I>
    typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type& get(unsigned int iIndex) {
      typedef typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type ReturnType;
      return *(static_cast<ReturnType*>(m_values[I])+iIndex);
    }
    
    template<unsigned int I>
    typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type* begin() {
      typedef soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type> Helper;
      typedef typename Helper::Type ReturnType;
#if GCC_PREREQUISITE(4,7,0)
      return static_cast<ReturnType*>(__builtin_assume_aligned(m_values[I],Helper::kAlignment));
#else
      return static_cast<ReturnType*>(m_values[I]);
#endif
    }
    template<unsigned int I>
    typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type* end() {
      typedef typename soahelper::AlignmentHelper<typename std::tuple_element<I, std::tuple<Args...>>::type>::Type ReturnType;
      return static_cast<ReturnType*>(m_values[I])+m_size;
    }
    
    void swap(SoATuple<Args...>& iOther) {
      std::swap(m_size,iOther.m_size);
      std::swap(m_reserved,iOther.m_reserved);
      for(unsigned int i=0; i<sizeof...(Args);++i) {
        std::swap(m_values[i],iOther.m_values[i]);
      }
    }
  private:
        
    void changeSize(unsigned int iToSize) {
      assert(m_size<=iToSize);
      const size_t memoryNeededInBytes = soahelper::SoATupleHelper<sizeof...(Args),Args...>::spaceNeededFor(iToSize);
      //align memory of the array to be on the strictest alignment boundary for any type in the Tuple
      // This is done by creating an array of a type that has that same alignment restriction and minimum size.
      // This has the draw back of possibly padding the array by one extra element if the memoryNeededInBytes is not
      // a strict multiple of max_alignment.
      // NOTE: using new char[...] would likely cause more padding based on C++11 5.3.4 paragraph 10 where it
      // says the alignment will be for the strictest requirement for an object whose size < size of array. So
      // if the array were for 64 bytes and the strictest requirement of any object was 8 bytes then the entire
      // char array would be aligned on an 8 byte boundary. However, if the SoATuple<char,char> only 1 byte alignment
      // is needed. The following algorithm would require only 1 byte alignment
      const std::size_t max_alignment = soahelper::SoATupleHelper<sizeof...(Args),Args...>::max_alignment;
      typedef std::aligned_storage<soahelper::SoATupleHelper<sizeof...(Args),Args...>::max_alignment,
                                   soahelper::SoATupleHelper<sizeof...(Args),Args...>::max_alignment> AlignedType;
      //If needed, pad the number of items by 1
      const size_t itemsNeeded = (memoryNeededInBytes+max_alignment-1)/sizeof(AlignedType);
      char * newMemory = static_cast<char*>(static_cast<void*>(new AlignedType[itemsNeeded]));
      void * oldMemory =m_values[0];
      soahelper::SoATupleHelper<sizeof...(Args),Args...>::moveToNew(newMemory,m_size, iToSize, m_values);
      m_reserved = iToSize;
      delete [] static_cast<AlignedType*>(oldMemory);
    }
    // ---------- member data --------------------------------
    //Pointers to where each column starts in the shared memory array
    //m_values[0] also points to the beginning of the shared memory area
    void* m_values[sizeof...(Args)];
    size_t m_size;
    size_t m_reserved;
  };
}


#endif