config.h

Go to the documentation of this file.

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2025 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 <stddef.h>
#include <stdint.h>
 
#include <limits>
 
#include "misc/exceptions.hpp"
#include "tools/cuda/cudaFunctionAttributes.hpp"


namespace codi {
 
#ifndef CODI_IDE
  #define CODI_IDE 0
#endif

  struct Namespace {};

  namespace Config {
 
    /*******************************************************************************/

#define CODI_HasCpp20 __cplusplus >= 202002L
    bool constexpr HasCpp20 = CODI_HasCpp20;

    /*******************************************************************************/
 
#ifndef CODI_ByteDataChunkSize
  #define CODI_ByteDataChunkSize 4194304
#endif
    size_t constexpr ByteDataChunkSize = CODI_ByteDataChunkSize;
#undef CODI_ByteDataChunkSize
 
#ifndef CODI_ChunkSize
  #define CODI_ChunkSize 2097152
#endif
    size_t constexpr ChunkSize = CODI_ChunkSize;
#undef CODI_ChunkSize

    using LowLevelFunctionDataSize = uint16_t;

    size_t constexpr LowLevelFunctionDataSizeMax = std::numeric_limits<LowLevelFunctionDataSize>::max();
 
    static_assert(LowLevelFunctionDataSizeMax <= ByteDataChunkSize,
                  "Low level function data size is larger than the "
                  "maximum size of a byte data chunk. Fix: Increase 'ByteDataChunkSize'.");

    using LowLevelFunctionToken = uint16_t;

    size_t constexpr LowLevelFunctionTokenMaxSize = std::numeric_limits<LowLevelFunctionToken>::max();

    size_t constexpr LowLevelFunctionTokenInvalid = std::numeric_limits<LowLevelFunctionToken>::max();

    using ArgumentSize = uint8_t;

    size_t constexpr MaxArgumentSize = 253;

    size_t constexpr StatementInputTag = 255;

    size_t constexpr StatementLowLevelFunctionTag = 254;
 
#ifndef CODI_SmallChunkSize
  #define CODI_SmallChunkSize 32768
#endif
    size_t constexpr SmallChunkSize = CODI_SmallChunkSize;
#undef CODI_SmallChunkSize

    /*******************************************************************************/
 
#ifndef CODI_CheckExpressionArguments
  #define CODI_CheckExpressionArguments false
#endif
    bool constexpr CheckExpressionArguments = CODI_CheckExpressionArguments;
#undef CODI_CheckExpressionArguments
 
#ifndef CODI_CheckEmptyStatements
  #define CODI_CheckEmptyStatements true
#endif
    const bool CheckEmptyStatements = CODI_CheckEmptyStatements;
#undef CODI_CheckEmptyStatements
 
#ifndef CODI_CheckJacobianIsZero
  #define CODI_CheckJacobianIsZero true
#endif
    bool constexpr CheckJacobianIsZero = CODI_CheckJacobianIsZero;
#undef CODI_CheckJacobianIsZero
 
#ifndef CODI_CheckTapeActivity
  #define CODI_CheckTapeActivity true
#endif
    bool constexpr CheckTapeActivity = CODI_CheckTapeActivity;
#undef CODI_CheckTapeActivity
 
#ifndef CODI_CheckZeroIndex
  #define CODI_CheckZeroIndex true
#endif
    bool constexpr CheckZeroIndex = CODI_CheckZeroIndex;
#undef CODI_CheckZeroIndex
 
#ifndef CODI_CopyOptimization
  #define CODI_CopyOptimization true
#endif
    bool constexpr CopyOptimization = CODI_CopyOptimization;
#undef CODI_CopyOptimization
 
#ifndef CODI_ImplicitConversion
  #define CODI_ImplicitConversion false
#endif
    bool constexpr ImplicitConversion = CODI_ImplicitConversion;
    // Do not undefine.
 
#ifndef CODI_ImplicitConversionWarning
  #define CODI_ImplicitConversionWarning true
#endif
    bool constexpr ImplicitConversionWarning = CODI_ImplicitConversionWarning;
#undef CODI_ImplicitConversionWarning
 
#ifndef CODI_ImplicitTagConversion
  #define CODI_ImplicitTagConversion false
#endif
    bool constexpr ImplicitTagConversion = CODI_ImplicitTagConversion;
    // Do not undefine.
 
#ifndef CODI_IgnoreIntelNoInlineWarning
  #define CODI_IgnoreIntelNoInlineWarning false
#endif
    bool constexpr IgnoreIntelNoInlineWarning = CODI_IgnoreIntelNoInlineWarning;
#if CODI_IgnoreIntelNoInlineWarning
  #ifdef __INTEL_COMPILER
    #pragma warning disable 2196
  #endif
#endif
 
#ifndef CODI_RemoveDuplicateJacobianArguments
  #define CODI_RemoveDuplicateJacobianArguments 0
#endif
    bool constexpr RemoveDuplicateJacobianArguments = CODI_RemoveDuplicateJacobianArguments;
    // Do not undefine.
 
#ifndef CODI_IgnoreInvalidJacobians
  #define CODI_IgnoreInvalidJacobians false
#endif
    bool constexpr IgnoreInvalidJacobians = CODI_IgnoreInvalidJacobians;
#undef CODI_IgnoreInvalidJacobians
 
#ifndef CODI_OverflowCheck
  #define CODI_OverflowCheck true
#endif
    bool constexpr OverflowCheck = CODI_OverflowCheck;
#undef CODI_OverflowCheck
 
#ifndef CODI_SkipZeroAdjointEvaluation
  #define CODI_SkipZeroAdjointEvaluation true
#endif
    bool constexpr SkipZeroAdjointEvaluation = CODI_SkipZeroAdjointEvaluation;
#undef CODI_SkipZeroAdjointEvaluation
 
#ifndef CODI_SpecializeStdComplex
  #define CODI_SpecializeStdComplex 1
#endif
    bool constexpr SpecializeStdComplex = CODI_SpecializeStdComplex;
    // Do not undefine.
 
#ifndef CODI_SortIndicesOnReset
  #define CODI_SortIndicesOnReset true
#endif
    bool constexpr SortIndicesOnReset = CODI_SortIndicesOnReset;
#undef CODI_SortIndicesOnReset
 
#ifndef CODI_VariableAdjointInterfaceInPrimalTapes
  #define CODI_VariableAdjointInterfaceInPrimalTapes 0
#endif
    bool constexpr VariableAdjointInterfaceInPrimalTapes = CODI_VariableAdjointInterfaceInPrimalTapes;
#if CODI_VariableAdjointInterfaceInPrimalTapes
  #define ADJOINT_VECTOR_TYPE VectorAccessInterface<Real, Identifier>
#else
  #define ADJOINT_VECTOR_TYPE Gradient
#endif
    // Do not undefine.
 
#ifndef CODI_ReversalZeroesAdjoints
  #define CODI_ReversalZeroesAdjoints true
#endif
#if CODI_VariableAdjointInterfaceInPrimalTapes && !CODI_ReversalZeroesAdjoints
  #warning CODI_ReversalZeroesAdjoints == false is incompatible with CODI_VariableAdjointInterfaceInPrimalTapes == true.
#endif
    bool constexpr ReversalZeroesAdjoints = CODI_ReversalZeroesAdjoints;
#undef CODI_ReversalZeroesAdjoints

    /*******************************************************************************/
 
#ifndef CODI_ADWorkflowEvents
  #define CODI_ADWorkflowEvents true
#endif
    bool constexpr ADWorkflowEvents = CODI_ADWorkflowEvents;
#undef CODI_ADWorkflowEvents
 
#ifndef CODI_PreaccEvents
  #define CODI_PreaccEvents false
#endif
    bool constexpr PreaccEvents = CODI_PreaccEvents;
#undef CODI_PreaccEvents
 
#ifndef CODI_StatementEvents
  #define CODI_StatementEvents false
#endif
    bool constexpr StatementEvents = CODI_StatementEvents;
#undef CODI_StatementEvents
 
#ifndef CODI_IndexEvents
  #define CODI_IndexEvents false
#endif
    bool constexpr IndexEvents = CODI_IndexEvents;
#undef CODI_IndexEvents

    /*******************************************************************************/
 
#ifndef CODI_EnableEigen
  #define CODI_EnableEigen 0
#endif
    bool constexpr EnableEigen = CODI_EnableEigen;
    // Do not undefine
 
#ifndef CODI_EnableEnzyme
  #define CODI_EnableEnzyme false
#endif
    bool constexpr EnableEnzyme = CODI_EnableEnzyme;
    // Do not undefine.
 
#ifndef CODI_EnableMPI
  #define CODI_EnableMPI false
#endif
    bool constexpr EnableMPI = CODI_EnableMPI;
    // Do not undefine.
 
#ifndef CODI_EnableOpenMP
  #define CODI_EnableOpenMP false
#endif
    bool constexpr EnableOpenMP = CODI_EnableOpenMP;
    // Do not undefine.
 
#ifndef CODI_EnableOpDiLib
  #define CODI_EnableOpDiLib false
#endif
#if CODI_EnableOpDiLib && !CODI_EnableOpenMP
  #error CODI_EnableOpDiLib == true is incompatible with CODI_EnableOpenMP == false.
#endif
    bool constexpr EnableOpDiLib = CODI_EnableOpDiLib;
    // Do not undefine.

    /*******************************************************************************/

#define CODI_FunctionAttributes CODI_CUDAFunctionAttributes
 
#ifndef CODI_AnnotateBranchLikelihood
  #define CODI_AnnotateBranchLikelihood CODI_HasCpp20
#endif
#if CODI_AnnotateBranchLikelihood
  #define CODI_Likely [[likely]]
  #define CODI_Unlikely [[unlikely]]
#else
  #define CODI_Likely   /* empty */
  #define CODI_Unlikely /* empty */
#endif
    bool constexpr AnnotateBranchLikelihood = CODI_AnnotateBranchLikelihood;
#undef CODI_AnnotateBranchLikelihood
 
#ifndef CODI_AvoidedInlines
  #define CODI_AvoidedInlines 1
#endif
#if CODI_AvoidedInlines
  #if defined(_MSC_VER)
    #define CODI_NO_INLINE __declspec(noinline)
  #else
    #define CODI_NO_INLINE __attribute__((noinline))
  #endif
#else
  #define CODI_NO_INLINE /* no avoiding of inline defined */
#endif
    bool constexpr AvoidedInlines = CODI_AvoidedInlines;
#undef CODI_AvoidedInlines
 
#ifndef CODI_EnableAssert
  #define CODI_EnableAssert false
#endif
#ifndef codiAssert  // Can also be defined by the user before including codi.hpp.
  #if CODI_EnableAssert
    #define codiAssert(x) ::codi::checkAndOutputAssert(x, CODI_TO_STRING(x), __PRETTY_FUNCTION__, __FILE__, __LINE__)
  #else
    #define codiAssert(x) /* disabled by CODI_EnableAssert */
  #endif
#endif
    bool constexpr EnableAssert = CODI_EnableAssert;
#undef CODI_EnableAssert
 
#ifndef CODI_ForcedInlines
  #define CODI_ForcedInlines 0
#endif
#if CODI_ForcedInlines
  #if defined(__INTEL_COMPILER) | defined(_MSC_VER)
    #define CODI_INLINE CODI_FunctionAttributes __forceinline
    #define CODI_INLINE_NO_FA __forceinline
    #define CODI_LAMBDA_INLINE CODI_FunctionAttributes /*__forceinline*/
  #elif defined(__GNUC__)
    #define CODI_INLINE CODI_FunctionAttributes inline __attribute__((always_inline))
    #define CODI_INLINE_NO_FA inline __attribute__((always_inline))
    #define CODI_LAMBDA_INLINE CODI_FunctionAttributes __attribute__((always_inline))
  #else
    #warning Could not determine compiler for forced inline definitions. Using inline.
    #define CODI_INLINE CODI_FunctionAttributes inline
    #define CODI_INLINE_NO_FA inline
    #define CODI_LAMBDA_INLINE CODI_FunctionAttributes /*inline*/
  #endif
#else
  #define CODI_INLINE CODI_FunctionAttributes inline
  #define CODI_INLINE_NO_FA inline
  #define CODI_LAMBDA_INLINE /* inline */
#endif
    bool constexpr ForcedInlines = CODI_ForcedInlines;
#undef CODI_ForcedInlines
 
#ifndef CODI_Restrict
  #define CODI_Restrict 1
#endif
#if CODI_Restrict
  #if defined(__INTEL_COMPILER) | defined(_MSC_VER)
    #define CODI_RESTRICT __restrict
  #elif defined(__GNUC__)
    #define CODI_RESTRICT __restrict__
  #else
    #warning Could not determine compiler for restrict definitions. Using nothing.
    #define CODI_RESTRICT /* no restrict */
  #endif
#else
  #define CODI_RESTRICT /* no restrict */
#endif
    bool constexpr Restrict = CODI_Restrict;
#undef CODI_Restrict

  }
}