Logger.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_COMMON_LOGGER_HPP
#define GEOSX_COMMON_LOGGER_HPP

// Source incldes
#include "common/GeosxConfig.hpp"
#include "LvArray/src/Macros.hpp"

// System includes
#if defined(GEOSX_USE_MPI)
  #include <mpi.h>
#endif

#define GEOSX_LOG( ... ) LVARRAY_LOG( __VA_ARGS__ )

#define GEOSX_LOG_VAR( ... ) LVARRAY_LOG_VAR( __VA_ARGS__ )

#define GEOSX_LOG_RANK_0_IF( EXP, msg ) \
  do { \
    if( ::geosx::logger::internal::rank == 0 && EXP ) \
    { \
      std::ostringstream oss; \
      oss << msg; \
      std::cout << oss.str() << std::endl; \
    } \
  } while( false )

#define GEOSX_LOG_RANK_0( msg ) GEOSX_LOG_RANK_0_IF( true, msg )

#if defined(__CUDA_ARCH__)
#define GEOSX_LOG_RANK_IF( EXP, msg )
#else
#define GEOSX_LOG_RANK_IF( EXP, msg ) \
  do { \
    if( EXP ) \
    { \
      std::ostringstream oss; \
      oss << "Rank " << ::geosx::logger::internal::rankString << ": " << msg; \
      *logger::internal::rankStream << oss.str() << std::endl; \
    } \
  } while( false )
#endif

#define GEOSX_LOG_RANK( msg ) GEOSX_LOG_RANK_IF( true, msg )

#define GEOSX_LOG_RANK_VAR( var ) GEOSX_LOG_RANK( #var " = " << var )

#if defined(__CUDA_ARCH__)
#define GEOSX_ERROR_IF( EXP, msg ) LVARRAY_ERROR_IF( EXP, msg )
#else
#define GEOSX_ERROR_IF( EXP, msg ) LVARRAY_ERROR_IF( EXP, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )
#endif

#define GEOSX_ERROR( msg ) GEOSX_ERROR_IF( true, msg )

#define GEOSX_ASSERT_MSG( EXP, msg ) LVARRAY_ASSERT_MSG( EXP, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ASSERT( EXP ) GEOSX_ASSERT_MSG( EXP, "" )

#define GEOSX_WARNING_IF( EXP, msg ) LVARRAY_WARNING_IF( EXP, msg )

#define GEOSX_WARNING( msg ) LVARRAY_WARNING( msg )

#define GEOSX_INFO_IF( EXP, msg ) LVARRAY_INFO_IF( EXP, msg )

#define GEOSX_INFO( msg ) LVARRAY_INFO( msg )

#define GEOSX_ERROR_IF_EQ_MSG( lhs, rhs, msg ) LVARRAY_ERROR_IF_EQ_MSG( lhs, rhs, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ERROR_IF_EQ( lhs, rhs ) GEOSX_ERROR_IF_EQ_MSG( lhs, rhs, "" )

#define GEOSX_ERROR_IF_NE_MSG( lhs, rhs, msg ) LVARRAY_ERROR_IF_NE_MSG( lhs, rhs, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ERROR_IF_NE( lhs, rhs ) GEOSX_ERROR_IF_NE_MSG( lhs, rhs, "" )

#define GEOSX_ERROR_IF_GT_MSG( lhs, rhs, msg ) LVARRAY_ERROR_IF_GT_MSG( lhs, rhs, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ERROR_IF_GT( lhs, rhs ) GEOSX_ERROR_IF_GT_MSG( lhs, rhs, "" )

#define GEOSX_ERROR_IF_GE_MSG( lhs, rhs, msg ) LVARRAY_ERROR_IF_GE_MSG( lhs, rhs, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ERROR_IF_GE( lhs, rhs ) GEOSX_ERROR_IF_GE_MSG( lhs, rhs, "" )

#define GEOSX_ERROR_IF_LT_MSG( lhs, rhs, msg ) LVARRAY_ERROR_IF_LT_MSG( lhs, rhs, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ERROR_IF_LT( lhs, rhs ) GEOSX_ERROR_IF_LT_MSG( lhs, rhs, "" )

#define GEOSX_ERROR_IF_LE_MSG( lhs, rhs, msg ) LVARRAY_ERROR_IF_LE_MSG( lhs, rhs, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ERROR_IF_LE( lhs, rhs ) GEOSX_ERROR_IF_LE_MSG( lhs, rhs, "" )

#define GEOSX_ASSERT_EQ_MSG( lhs, rhs, msg ) LVARRAY_ASSERT_EQ_MSG( lhs, rhs, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ASSERT_EQ( lhs, rhs ) GEOSX_ASSERT_EQ_MSG( lhs, rhs, "" )

#define GEOSX_ASSERT_NE_MSG( lhs, rhs, msg ) LVARRAY_ASSERT_NE_MSG( lhs, rhs, msg )

#define GEOSX_ASSERT_NE( lhs, rhs ) LVARRAY_ASSERT_NE( lhs, rhs )

#define GEOSX_ASSERT_GT_MSG( lhs, rhs, msg ) LVARRAY_ASSERT_GT_MSG( lhs, rhs, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ASSERT_GT( lhs, rhs ) GEOSX_ASSERT_GT_MSG( lhs, rhs, "" )

#define GEOSX_ASSERT_GE_MSG( lhs, rhs, msg ) LVARRAY_ASSERT_GE_MSG( lhs, rhs, "***** Rank " << ::geosx::logger::internal::rankString << ": " << msg )

#define GEOSX_ASSERT_GE( lhs, rhs ) GEOSX_ASSERT_GE_MSG( lhs, rhs, "" )

#define GEOSX_LOG_LEVEL_FN( minLevel, fn )                                      \
  do {                                                                         \
    if( this->getLogLevel() >= minLevel )                                      \
    {                                                                          \
      fn;                                                                      \
    }                                                                          \
  } while( false )

#define GEOSX_LOG_LEVEL( minLevel, msg ) GEOSX_INFO_IF( this->getLogLevel() >= minLevel, msg );

#define GEOSX_LOG_LEVEL_RANK_0( minLevel, msg ) GEOSX_LOG_RANK_0_IF( this->getLogLevel() >= minLevel, msg )

#define GEOSX_LOG_LEVEL_BY_RANK( minLevel, msg ) GEOSX_LOG_RANK_IF( this->getLogLevel() >= minLevel, msg )


namespace geosx
{

namespace logger
{

namespace internal
{

extern int rank;

extern std::string rankString;

extern int n_ranks;

extern std::ostream * rankStream;

#if defined(GEOSX_USE_MPI)
extern MPI_Comm comm;
#endif
} // namespace internal

#if defined(GEOSX_USE_MPI)

void InitializeLogger( MPI_Comm comm, const std::string & rank_output_dir="" );
#endif

void InitializeLogger( const std::string & rank_output_dir="" );

void FinalizeLogger();

} // namespace logger

} // namespace geosx

#endif /* GEOSX_COMMON_LOGGER_HPP */