lowLevelFunctionCreationUtilities.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 <tuple>
 
#include "../../config.h"
#include "../../misc/byteDataView.hpp"
#include "../../misc/macros.hpp"
#include "storeAndRestoreActions.hpp"
#include "traits/activeArgumentStoreTraits.hpp"
#include "traits/passiveArgumentStoreTraits.hpp"
 
namespace codi {
 
  template<size_t T_ActiveArguments>
  struct LowLevelFunctionCreationUtilities {
      static size_t constexpr ActiveArguments =
          CODI_DD(T_ActiveArguments, 1);  
 
      static_assert(ActiveArguments <= 64, "More than 64 active arguments are currently not supported.");
 
      // clang-format off
      using ActivityStoreType =
          typename std::conditional<ActiveArguments <= 8, uint8_t,
          typename std::conditional<ActiveArguments <= 16, uint16_t,
          typename std::conditional<ActiveArguments <= 32, uint32_t,
          typename std::conditional<ActiveArguments <= 64, uint64_t,
            void>::type>::type>::type>::type;
      // clang-format on
 
      template<typename T>
      using ActiveStoreTrait = ActiveArgumentStoreTraits<T>;
 
      template<typename T, typename S = T>
      using PassiveStoreTrait = PassiveArgumentStoreTraits<T, S>;
 
      static size_t constexpr TokenSize = sizeof(codi::Config::LowLevelFunctionToken);
 
      /*******************************************************************************/
 
      CODI_INLINE static RestoreActions createRestoreActions(bool isInput, bool isOutput, bool isInputActive,
                                                             bool primalRequired) {
        RestoreActions actions = {};
 
        if (isInput && primalRequired) {
          actions |= RestoreAction::PrimalRestore;
        } else if (isOutput) {
          actions |= RestoreAction::PrimalCreate;
        }
 
        if (isInput && isInputActive) {
          actions |= RestoreAction::InputIdentifierRestore | RestoreAction::InputGradientCreate;
        }
        if (isOutput) {
          actions |= RestoreAction::OutputIdentifierRestore | RestoreAction::OutputGradientCreate;
        }
 
        return actions;
      }
 
      CODI_INLINE static StoreActions createStoreActions(bool tapeActive, bool isInput, bool isOutput,
                                                         bool isInputActive, bool primalRequired) {
        StoreActions actions = {};
 
        if (tapeActive && isInput && primalRequired) {
          actions |= StoreAction::PrimalCreateOnTape;
        }
 
        if (isInput) {
          actions |= StoreAction::PrimalExtract;
        }
 
        if (tapeActive) {
          if (isInput && isInputActive) {
            actions |= StoreAction::InputIdentifierCreateAndStore;
          }
          if (isOutput) {
            actions |= StoreAction::OutputIdentifierCreate;
          }
        }
 
        return actions;
      }
 
      /*******************************************************************************/
 
      CODI_INLINE static size_t countActivitySize() {
        return sizeof(ActivityStoreType);
      }
 
      CODI_INLINE static bool getActivity(ActivityStoreType const& activity, size_t arg) {
        return 0 != (activity & ((ActivityStoreType)1) << arg);
      }
 
      CODI_INLINE static void restoreActivity(ByteDataView* fixedStore, ActivityStoreType& activity) {
        activity = fixedStore->read<ActivityStoreType>();
      }
 
      CODI_INLINE static void setActivity(ActivityStoreType& activity, size_t arg, bool active) {
        activity |= ((ActivityStoreType)active) << arg;
      }
 
      CODI_INLINE static void storeActivity(ByteDataView* fixedStore, ActivityStoreType const& activity) {
        fixedStore->write(activity);
      }
 
  };
}