commonTapeImplementation.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2024 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://www.scicomp.uni-kl.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://www.scicomp.uni-kl.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 <algorithm>
#include <type_traits>
 
#include "../config.h"
#include "../misc/byteDataView.hpp"
#include "../misc/eventSystem.hpp"
#include "../misc/fileIo.hpp"
#include "../misc/macros.hpp"
#include "../misc/temporaryMemory.hpp"
#include "data/dataInterface.hpp"
#include "data/position.hpp"
#include "indices/indexManagerInterface.hpp"
#include "interfaces/fullTapeInterface.hpp"
#include "misc/externalFunction.hpp"
#include "misc/lowLevelFunctionEntry.hpp"
#include "misc/vectorAccessInterface.hpp"
 
namespace codi {
 
  struct TapeTypesInterface {
    public:
 
      using Real = CODI_ANY;        
      using Gradient = CODI_ANY;    
      using Identifier = CODI_ANY;  
 
      template<typename Chunk, typename Nested>
      using Data = DataInterface<Nested>;
 
      using NestedData = DataInterface<>;  
  };
 
  template<typename T_TapeTypes>
  struct CommonTapeTypes {
    public:
 
      using TapeTypes = CODI_DD(T_TapeTypes, TapeTypesInterface);  
 
      template<typename Chunk, typename Nested>
      using Data = typename TapeTypes::template Data<Chunk, Nested>;  
 
      using NestedData = typename TapeTypes::NestedData;  
 
      using LowLevelFunctionInfoChunk = Chunk2<Config::LowLevelFunctionToken, Config::LowLevelFunctionDataSize>;
      using LowLevelFunctionInfoData = Data<LowLevelFunctionInfoChunk, NestedData>;
 
      using LowLevelFunctionByteChunk = Chunk1<char>;
      using LowLevelFunctionByteData = Data<LowLevelFunctionByteChunk, LowLevelFunctionInfoData>;
 
      using Position = typename LowLevelFunctionByteData::Position;  
  };
 
  template<typename T_ImplTapeTypes, typename T_Impl>
  struct CommonTapeImplementation
      : public FullTapeInterface<typename T_ImplTapeTypes::Real, typename T_ImplTapeTypes::Gradient,
                                 typename T_ImplTapeTypes::Identifier,
                                 typename CommonTapeTypes<T_ImplTapeTypes>::Position> {
    public:
 
      using ImplTapeTypes = CODI_DD(T_ImplTapeTypes, TapeTypesInterface);  
      using Impl = CODI_DD(T_Impl, CommonTapeImplementation);              
 
      using Real = typename ImplTapeTypes::Real;              
      using Gradient = typename ImplTapeTypes::Gradient;      
      using Identifier = typename ImplTapeTypes::Identifier;  
 
      using LowLevelFunctionInfoData = typename CommonTapeTypes<ImplTapeTypes>::LowLevelFunctionInfoData;
      using LowLevelFunctionByteData = typename CommonTapeTypes<ImplTapeTypes>::LowLevelFunctionByteData;
      using Position = typename CommonTapeTypes<ImplTapeTypes>::Position;  
 
      using NestedData = LowLevelFunctionByteData;                         
      using NestedPosition = typename LowLevelFunctionByteData::Position;  
 
    protected:
 
      bool active;                       
      std::set<TapeParameters> options;  
 
      LowLevelFunctionInfoData llfInfoData;  
      LowLevelFunctionByteData llfByteData;  
 
      Real manualPushLhsValue;             
      Identifier manualPushLhsIdentifier;  
      size_t manualPushGoal;               
      size_t manualPushCounter;            
 
      TemporaryMemory allocator;  
 
      static std::vector<LowLevelFunctionEntry<Impl, Real, Identifier>>* lowLevelFunctionLookup;
 
    private:
 
      static Config::LowLevelFunctionToken constexpr EXTERNAL_FUNCTION_TOKEN = 0;
 
      CODI_INLINE Impl const& cast() const {
        return static_cast<Impl const&>(*this);
      }
 
      CODI_INLINE Impl& cast() {
        return static_cast<Impl&>(*this);
      }
 
      CODI_INLINE void resetInternal(bool resetAdjoints, AdjointsManagement adjointsManagement,
                                     EventHints::Reset kind) {
        EventSystem<Impl>::notifyTapeResetListeners(cast(), this->getZeroPosition(), kind, resetAdjoints);
 
        if (resetAdjoints) {
          cast().clearAdjoints(adjointsManagement);
        }
 
        deleteLowLevelFunctionData(cast().getZeroPosition());
 
        llfByteData.reset();
 
        // Requires extra reset since the default vector implementation forwards to resetTo
        cast().indexManager.get().reset();
      }
 
    protected:
 
      CODI_INLINE void initializeManualPushData(Real const& lhsValue, Identifier const& lhsIndex, size_t size) {
        codiAssert(this->manualPushGoal == this->manualPushCounter);
        if (Config::StatementEvents || Config::EnableAssert) {
          this->manualPushLhsValue = lhsValue;
          this->manualPushLhsIdentifier = lhsIndex;
          this->manualPushCounter = 0;
          this->manualPushGoal = size;
        }
      }
 
      CODI_INLINE void incrementManualPushCounter() {
        codiAssert(this->manualPushCounter < this->manualPushGoal);
 
        if (Config::StatementEvents || Config::EnableAssert) {
          this->manualPushCounter += 1;
        }
      }
 
    protected:
 
      /*******************************************************************************/
 
      TapeValues internalGetTapeValues() const;  
 
 
    public:
 
      CommonTapeImplementation()
          : active(false),
            options(),
            llfInfoData(Config::SmallChunkSize),
            llfByteData(Config::ByteDataChunkSize),
            manualPushLhsValue(),
            manualPushLhsIdentifier(),
            manualPushGoal(),
            manualPushCounter(),
            allocator() {
        options.insert(TapeParameters::LLFByteDataSize);
        options.insert(TapeParameters::LLFInfoDataSize);
 
        if (nullptr == lowLevelFunctionLookup) {
          lowLevelFunctionLookup = new std::vector<LowLevelFunctionEntry<Impl, Real, Identifier>>();
 
          // Add external function token. So EXTERNAL_FUNCTION_TOKEN is always zero.
          Config::LowLevelFunctionToken token =
              registerLowLevelFunction(ExternalFunctionLowLevelEntryMapper<Impl, Real, Identifier>::create());
          if (token != EXTERNAL_FUNCTION_TOKEN) {
            CODI_EXCEPTION("External function token is not zero.");
          }
        }
      }
 
      CommonTapeImplementation(CommonTapeImplementation const&) = delete;
 
      CommonTapeImplementation& operator=(CommonTapeImplementation const&) = delete;
 
      CommonTapeImplementation(CommonTapeImplementation&&) = delete;
 
      CommonTapeImplementation& operator=(CommonTapeImplementation&&) = delete;
 
      /*******************************************************************************/
 
      void setGradient(Identifier const& identifier, Gradient const& gradient,
                       AdjointsManagement adjointsManagement = AdjointsManagement::Automatic) {
        cast().gradient(identifier, adjointsManagement) = gradient;
      }
 
      Gradient const& getGradient(Identifier const& identifier,
                                  AdjointsManagement adjointsManagement = AdjointsManagement::Automatic) const {
        return cast().gradient(identifier, adjointsManagement);
      }
 
      // Gradient functions are not implemented.
 
      /*******************************************************************************/
 
      void evaluate(AdjointsManagement adjointsManagement = AdjointsManagement::Automatic) {
        Impl& impl = cast();
 
        impl.evaluate(impl.getPosition(), impl.getZeroPosition(), adjointsManagement);
      }
 
      template<typename Lhs>
      void registerOutput(LhsExpressionInterface<Real, Gradient, Impl, Lhs>& value) {
        cast().template store<Lhs, Lhs>(value, static_cast<ExpressionInterface<Real, Lhs> const&>(value));
        EventSystem<Impl>::notifyTapeRegisterOutputListeners(cast(), value.cast().value(),
                                                             value.cast().getIdentifier());
      }
 
      void setActive() {
        EventSystem<Impl>::notifyTapeStartRecordingListeners(cast());
        active = true;
      }
 
      void setPassive() {
        EventSystem<Impl>::notifyTapeStopRecordingListeners(cast());
        active = false;
      }
 
      bool isActive() const {
        return active;
      }
 
      template<typename Stream = std::ostream>
      void printStatistics(Stream& out = std::cout) const {
        cast().getTapeValues().formatDefault(out);
      }
 
      template<typename Stream = std::ostream>
      void printTableHeader(Stream& out = std::cout) const {
        cast().getTapeValues().formatHeader(out);
      }
 
      template<typename Stream = std::ostream>
      void printTableRow(Stream& out = std::cout) const {
        cast().getTapeValues().formatRow(out);
      }
 
      TapeValues getTapeValues() const {
        TapeValues values = cast().internalGetTapeValues();
 
        values.addSection("Low level function info data entries");
        llfInfoData.addToTapeValues(values);
        values.addSection("Low level function byte data entries");
        llfByteData.addToTapeValues(values);
 
        return values;
      }
 
      CODI_INLINE void reset(bool resetAdjoints = true,
                             AdjointsManagement adjointsManagement = AdjointsManagement::Automatic) {
        resetInternal(resetAdjoints, adjointsManagement, EventHints::Reset::Full);
      }
 
      // clearAdjoints and reset(Position) are not implemented.
 
      /*******************************************************************************/
 
      void swap(Impl& other) {
        std::swap(active, other.active);
 
        llfByteData.swap(other.llfByteData);
      }
 
      void resetHard() {
        Impl& impl = cast();
 
        // First perform a regular reset.
        resetInternal(false, AdjointsManagement::Automatic, EventHints::Reset::Hard);
 
        // Then perform the hard resets.
        impl.deleteAdjointVector();
 
        llfByteData.resetHard();
      }
 
 
    private:
      static void writeFunction(const ChunkBase* chunk, FileIo& handle) {
        chunk->writeData(handle);
      }
 
      static void readFunction(ChunkBase* chunk, FileIo& handle) {
        chunk->readData(handle);
      }
 
      static void deleteFunction(ChunkBase* chunk) {
        chunk->deleteData();
      }
 
    public:
 
      void writeToFile(const std::string& filename) {
        FileIo io(filename, true);
 
        llfByteData.forEachChunk(writeFunction, true, io);
      }
 
      void readFromFile(const std::string& filename) {
        FileIo io(filename, false);
 
        llfByteData.forEachChunk(readFunction, true, io);
      }
 
      void deleteData() {
        llfByteData.forEachChunk(deleteFunction, true);
      }
 
      std::set<TapeParameters> const& getAvailableParameters() const {
        return options;
      }
 
      size_t getParameter(TapeParameters parameter) const {
        switch (parameter) {
          case TapeParameters::LLFByteDataSize:
            return llfByteData.getDataSize();
            break;
          case TapeParameters::LLFInfoDataSize:
            return llfInfoData.getDataSize();
            break;
          case TapeParameters::ExternalFunctionsSize:
            CODI_WARNING(
                "Tape parameter 'ExternalFunctionsSize' no longer supported. Use 'LLFInfoDataSize' and "
                "'LLFByteDataSize' instead.");
            return 0;
            break;
          default:
            CODI_EXCEPTION("Tried to get undefined parameter for tape.");
            return 0;
            break;
        }
      }
 
      bool hasParameter(TapeParameters parameter) const {
        return options.cend() != options.find(parameter);
      }
 
      void setParameter(TapeParameters parameter, size_t value) {
        switch (parameter) {
          case TapeParameters::LLFByteDataSize:
            llfByteData.resize(value);
            break;
          case TapeParameters::LLFInfoDataSize:
            llfInfoData.resize(value);
            break;
          case TapeParameters::ExternalFunctionsSize:
            CODI_WARNING(
                "Tape parameter 'ExternalFunctionsSize' is no longer supported. Use 'LLFInfoDataSize' and "
                "'LLFByteDataSize' instead.");
            break;
          default:
            CODI_EXCEPTION("Tried to set undefined parameter for tape.");
            break;
        }
      }
 
      // createVectorAccess is not implemented.
      // createVectorAccessCustomAdjoints is not implemented.
      // resizeAdjointVector is not implemented.
      // deleteAdjointVector is not implemented.
      // beginUseAdjointVector is not implemented.
      // endUseAdjointVector is not implemented.
 
      /*******************************************************************************/
 
    protected:
 
      CODI_INLINE void internalStoreLowLevelFunction(Config::LowLevelFunctionToken token, size_t size,
                                                     ByteDataView& dataView) {
        codiAssert((size_t)token < lowLevelFunctionLookup->size());
        if (size >= Config::LowLevelFunctionDataSizeMax) {
          CODI_EXCEPTION(
              "Requested size for low level function is to big. Increase "
              "codi::Config::LowLevelFunctionDataSize or perform a dynamic memory allocation.");
        }
 
        llfInfoData.reserveItems(1);
        llfByteData.reserveItems(size);
 
        llfInfoData.pushData(token, size);
 
        char* dataPointer = nullptr;
        llfByteData.getDataPointers(dataPointer);
        dataView.init(dataPointer, 0, size);
        llfByteData.addDataSize(size);
      }
 
      template<LowLevelFunctionEntryCallKind callType, typename... Args>
      CODI_INLINE static void callLowLevelFunction(Impl& impl, bool forward,
                                                   /* data from low level function byte data vector */
                                                   size_t& curLLFByteDataPos, char* dataPtr,
                                                   /* data from low level function info data vector */
                                                   size_t& curLLFTInfoDataPos,
                                                   Config::LowLevelFunctionToken* const tokenPtr,
                                                   Config::LowLevelFunctionDataSize* const dataSizePtr,
                                                   Args&&... args) {
        if (!forward) {
          curLLFTInfoDataPos -= 1;
          curLLFByteDataPos -= dataSizePtr[curLLFTInfoDataPos];
        }
 
        size_t endPos = curLLFByteDataPos + dataSizePtr[curLLFTInfoDataPos];
        ByteDataView dataView(dataPtr, curLLFByteDataPos, endPos);
 
        Config::LowLevelFunctionToken id = tokenPtr[curLLFTInfoDataPos];
        LowLevelFunctionEntry<Impl, Real, Identifier> const& func = (*lowLevelFunctionLookup)[id];
        if (func.template has<callType>()) CODI_Likely {
          func.template call<callType>(&impl, dataView, std::forward<Args>(args)...);
 
          codiAssert(endPos == dataView.getPosition());
        } else if (LowLevelFunctionEntryCallKind::Delete == callType) CODI_Unlikely {
          // No delete registered. Data is skiped by the curLLFByteDataPos update.
        } else CODI_Unlikely {
          CODI_EXCEPTION("Requested call is not supported for low level function with token '%d'.", (int)id);
        }
 
        if (forward) {
          curLLFByteDataPos += dataSizePtr[curLLFTInfoDataPos];
          curLLFTInfoDataPos += 1;
        }
      }
 
    public:
 
      CODI_INLINE TemporaryMemory& getTemporaryMemory() {
        return allocator;
      }
 
      CODI_INLINE Config::LowLevelFunctionToken registerLowLevelFunction(
          LowLevelFunctionEntry<Impl, Real, Identifier> const& entry) {
        codiAssert(lowLevelFunctionLookup->size() < Config::LowLevelFunctionTokenMaxSize);
 
        Config::LowLevelFunctionToken token =
            static_cast<Config::LowLevelFunctionToken>(lowLevelFunctionLookup->size());
        lowLevelFunctionLookup->push_back(entry);
 
        return token;
      }
 
      // pushLowLevelFunction is not implemented.
 
      /*******************************************************************************/
 
      void pushExternalFunction(ExternalFunction<Impl> const& extFunc) {
        if (CODI_ENABLE_CHECK(Config::CheckTapeActivity, cast().isActive())) {
          ExternalFunctionLowLevelEntryMapper<Impl, Real, Identifier>::store(cast(), EXTERNAL_FUNCTION_TOKEN, extFunc);
        }
      }
 
      // registerExternalFunctionOutput is not implemented.
 
      /*******************************************************************************/
 
      void evaluateForward(AdjointsManagement adjointsManagement = AdjointsManagement::Automatic) {
        Impl& impl = cast();
 
        impl.evaluateForward(impl.getZeroPosition(), impl.getPosition(), adjointsManagement);
      }
 
      /*******************************************************************************/
 
      Identifier getPassiveIndex() const {
        return IndexManagerInterface<Identifier>::InactiveIndex;
      }
 
      Identifier getInvalidIndex() const {
        return IndexManagerInterface<Identifier>::InvalidIndex;
      }
 
      bool isIdentifierActive(Identifier const& index) const {
        return index != cast().getPassiveIndex();
      }
 
      template<typename Lhs>
      void deactivateValue(LhsExpressionInterface<Real, Gradient, Impl, Lhs>& value) {
        value = value.getValue();
      }
 
      /*******************************************************************************/
 
      Position getPosition() const {
        return llfByteData.getPosition();
      }
 
      Position getZeroPosition() const {
        return llfByteData.getZeroPosition();
      }
 
 
    protected:
 
      void deleteLowLevelFunctionData(Position const& pos) {
        // Clear external function data.
        auto deleteFunc = [this](
                              /* data from low level function byte data vector */
                              size_t& curLLFByteDataPos, size_t const& endLLFByteDataPos, char* dataPtr,
                              /* data from low level function info data vector */
                              size_t& curLLFInfoDataPos, size_t const& endLLFInfoDataPos,
                              Config::LowLevelFunctionToken* const tokenPtr,
                              Config::LowLevelFunctionDataSize* const dataSizePtr) {
          CODI_UNUSED(endLLFByteDataPos);
 
          while (curLLFInfoDataPos > endLLFInfoDataPos) {
            callLowLevelFunction<LowLevelFunctionEntryCallKind::Delete>(cast(), false, curLLFByteDataPos, dataPtr,
                                                                        curLLFInfoDataPos, tokenPtr, dataSizePtr);
          }
        };
 
        llfByteData.template evaluateReverse<1>(cast().getPosition(), pos, deleteFunc);
      }
 
    public:
 
 
      CODI_INLINE void resetTo(Position const& pos, bool resetAdjoints = true,
                               AdjointsManagement adjointsManagement = AdjointsManagement::Automatic) {
        EventSystem<Impl>::notifyTapeResetListeners(cast(), pos, EventHints::Reset::To, resetAdjoints);
 
        if (resetAdjoints) {
          Impl& impl = cast();
          impl.clearAdjoints(impl.getPosition(), pos, adjointsManagement);
        }
 
        deleteLowLevelFunctionData(pos);
 
        llfByteData.resetTo(pos);
      }
 
      // clearAdjoints and evaluate are not implemented.
 
      /*******************************************************************************/
 
      void evaluatePrimal() {
        Impl& impl = cast();
 
        impl.evaluatePrimal(impl.getZeroPosition(), impl.getPosition());
      }
 
      void setPrimal(Identifier const& identifier, Real const& primal) {
        cast().primal(identifier) = primal;
      }
 
      Real const& getPrimal(Identifier const& identifier) const {
        return cast().primal(identifier);
      }
 
 
    protected:
 
      /*******************************************************************************/
 
      void init(typename ImplTapeTypes::NestedData* nested) {
        llfInfoData.setNested(nested);
        llfByteData.setNested(&llfInfoData);
      }
 
  };
 
  template<typename ImplTapeTypes, typename Impl>
  std::vector<LowLevelFunctionEntry<Impl, typename ImplTapeTypes::Real, typename ImplTapeTypes::Identifier>>*
      CommonTapeImplementation<ImplTapeTypes, Impl>::lowLevelFunctionLookup = nullptr;
}