blockData.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2024 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://scicomp.rptu.de
 * Contact:  Prof. Nicolas R. Gauger (codi@scicomp.uni-kl.de)
 *
 * Lead developers: Max Sagebaum, Johannes Blühdorn (SciComp, University of Kaiserslautern-Landau)
 *
 * This file is part of CoDiPack (http://scicomp.rptu.de/software/codi).
 *
 * CoDiPack is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * CoDiPack is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU
 * General Public License along with CoDiPack.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * For other licensing options please contact us.
 *
 * Authors:
 *  - SciComp, University of Kaiserslautern-Landau:
 *    - Max Sagebaum
 *    - Johannes Blühdorn
 *    - Former members:
 *      - Tim Albring
 */
#pragma once
 
#include <vector>
 
#include "../../config.h"
#include "../../misc/macros.hpp"
#include "../../traits/misc/enableIfHelpers.hpp"
#include "chunk.hpp"
#include "dataInterface.hpp"
#include "emptyData.hpp"
#include "pointerStore.hpp"
#include "position.hpp"
 
namespace codi {
 
  template<typename T_Chunk, typename T_NestedData = EmptyData, typename T_PointerInserter = PointerStore<T_Chunk>>
  struct BlockData : public DataInterface<T_NestedData> {
    public:
 
      using Chunk = CODI_DD(T_Chunk, CODI_T(Chunk1<CODI_ANY>));                         
      using NestedData = CODI_DD(T_NestedData, CODI_T(DataInterface<CODI_ANY>));        
      using PointerInserter = CODI_DD(T_PointerInserter, CODI_T(PointerStore<Chunk>));  
 
      using InternalPosHandle = size_t;                      
      using NestedPosition = typename NestedData::Position;  
 
      template<int selectedDepth>
      using NestingDepthPointerInserter =
          typename std::conditional<selectedDepth == 0, TerminatingPointerStore<PointerInserter>,
                                    PointerInserter>::type;
 
      using Position = ArrayPosition<NestedPosition>;  
 
    private:
      Chunk chunk;
 
      NestedData* nested;
 
    public:
 
      BlockData(size_t const& chunkSize, NestedData* nested) : chunk(chunkSize), nested(nullptr) {
        setNested(nested);
      }
 
      BlockData(size_t const& chunkSize) : chunk(chunkSize), nested(nullptr) {}
 
      /*******************************************************************************/
 
      template<typename... Data>
      CODI_INLINE void pushData(Data const&... data) {
        // This method should only be called if reserveItems has been called.
        chunk.pushData(data...);
      }
 
      template<typename... Data>
      CODI_INLINE void getDataPointers(Data*&... pointers) {
        // This method should only be called if reserveItems has been called.
        chunk.dataPointer(chunk.getUsedSize(), pointers...);
      }
 
      CODI_INLINE void addDataSize(size_t size) {
        // This method should only be called if reserveItems has been called.
        chunk.setUsedSize(chunk.getUsedSize() + size);
      }
 
      CODI_INLINE InternalPosHandle reserveItems(size_t const& items) {
        CODI_UNUSED(items);
        codiAssert(chunk.getUsedSize() + items <= chunk.getSize());
 
        return chunk.getUsedSize();
      }
 
      /*******************************************************************************/
 
      void resize(size_t const& totalSize) {
        chunk.resize(totalSize);
      }
 
      void reset() {
        resetTo(getZeroPosition());
      }
 
      void resetHard() {
        chunk.resize(0);
 
        nested->resetHard();
      }
 
      void resetTo(Position const& pos) {
        codiAssert(pos.data <= chunk.getSize());
 
        chunk.setUsedSize(pos.data);
 
        nested->resetTo(pos.inner);
      }
 
      void erase(Position const& start, Position const& end, bool recursive = true) {
        chunk.erase(start.data, end.data);
        if (recursive) {
          nested->erase(start.inner, end.inner);
        }
      }
 
      /*******************************************************************************/
 
      CODI_INLINE size_t getDataSize() const {
        return chunk.getUsedSize();
      }
 
      CODI_INLINE Position getPosition() const {
        return Position(chunk.getUsedSize(), nested->getPosition());
      }
 
      CODI_INLINE size_t getPushedDataCount(InternalPosHandle const& startPos) {
        return chunk.getUsedSize() - startPos;
      }
 
      CODI_INLINE Position getZeroPosition() const {
        return Position(0, nested->getZeroPosition());
      }
 
      /*******************************************************************************/
 
      void addToTapeValues(TapeValues& values) const {
        size_t allocedSize = chunk.getSize();
        size_t dataEntries = getDataSize();
        size_t entrySize = Chunk::EntrySize;
 
        double memoryUsed = (double)dataEntries * (double)entrySize;
        double memoryAlloc = (double)allocedSize * (double)entrySize;
 
        values.addUnsignedLongEntry("Total number", dataEntries);
        values.addDoubleEntry("Memory used", memoryUsed, true, false);
        values.addDoubleEntry("Memory allocated", memoryAlloc, false, true);
      }
 
      template<typename TargetPosition, typename = typename enable_if_not_same<TargetPosition, Position>::type>
      CODI_INLINE TargetPosition extractPosition(Position const& pos) const {
        return nested->template extractPosition<TargetPosition>(pos.inner);
      }
 
      template<typename TargetPosition, typename = typename enable_if_same<TargetPosition, Position>::type>
      CODI_INLINE Position extractPosition(Position const& pos) const {
        return pos;
      }
 
      void setNested(NestedData* v) {
        // Set nested is only called once during the initialization.
        codiAssert(nullptr == this->nested);
        codiAssert(v->getZeroPosition() == v->getPosition());
 
        this->nested = v;
      }
 
      void swap(BlockData<Chunk, NestedData>& other) {
        chunk.swap(other.chunk);
 
        nested->swap(*other.nested);
      }
 
      /*******************************************************************************/
 
      template<int selectedDepth = -1, typename FunctionObject, typename... Args>
      CODI_INLINE void evaluateForward(Position const& start, Position const& end, FunctionObject function,
                                       Args&&... args) {
        NestingDepthPointerInserter<selectedDepth> pHandle;
        pHandle.setPointers(0, &chunk);
 
        size_t dataPos = start.data;
        pHandle.template callNestedForward<selectedDepth - 1>(
            /* arguments for callNestedForward */
            nested, dataPos, end.data,
            /* arguments for nested->evaluateForward */
            start.inner, end.inner, function, std::forward<Args>(args)...);
 
        codiAssert(dataPos == end.data);
      }
 
      template<int selectedDepth = -1, typename FunctionObject, typename... Args>
      CODI_INLINE void evaluateReverse(Position const& start, Position const& end, FunctionObject function,
                                       Args&&... args) {
        NestingDepthPointerInserter<selectedDepth> pHandle;
 
        size_t dataPos = start.data;
        pHandle.setPointers(0, &chunk);
 
        pHandle.template callNestedReverse<selectedDepth - 1>(
            /* arguments for callNestedReverse */
            nested, dataPos, end.data,
            /* arguments for nested->evaluateReverse */
            start.inner, end.inner, function, std::forward<Args>(args)...);
 
        codiAssert(dataPos == end.data);
      }
 
      template<typename FunctionObject, typename... Args>
      CODI_INLINE void forEachChunk(FunctionObject& function, bool recursive, Args&&... args) {
        function(&chunk, std::forward<Args>(args)...);
 
        if (recursive) {
          nested->forEachChunk(function, recursive, std::forward<Args>(args)...);
        }
      }
 
      template<typename FunctionObject, typename... Args>
      CODI_INLINE void forEachForward(Position const& start, Position const& end, FunctionObject function,
                                      Args&&... args) {
        codiAssert(start.data <= end.data);
 
        PointerInserter pHandle;
 
        for (size_t dataPos = start.data; dataPos < end.data; dataPos += 1) {
          pHandle.setPointers(dataPos, &chunk);
          pHandle.call(function, std::forward<Args>(args)...);
        }
      }
 
      template<typename FunctionObject, typename... Args>
      CODI_INLINE void forEachReverse(Position const& start, Position const& end, FunctionObject function,
                                      Args&&... args) {
        codiAssert(start.data >= end.data);
 
        PointerInserter pHandle;
 
        // We do not initialize dataPos with start - 1 since the type can be unsigned.
        for (size_t dataPos = start.data; dataPos > end.data; /* decrement is done inside the loop */) {
          dataPos -= 1;  // Decrement of loop variable.
 
          pHandle.setPointers(dataPos, &chunk);
          pHandle.call(function, std::forward<Args>(args)...);
        }
      }
  };
 
  template<typename Chunk, typename NestedData = EmptyData>
  using DefaultBlockData = BlockData<Chunk, NestedData>;
}