profiling.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2024, Lawrence Livermore National Security, LLC and
// other Serac Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include <string>
#include <sstream>
 
#include "serac/serac_config.hpp"
 
#ifdef SERAC_USE_ADIAK
#include "adiak.hpp"
#endif
 
#ifdef SERAC_USE_CALIPER
#include "caliper/cali-manager.h"
#include "caliper/cali.h"
#endif
 
#include "mpi.h"
 
#ifdef SERAC_USE_ADIAK
#define SERAC_SET_METADATA(name, data) adiak::value(name, data)
#else
#define SERAC_SET_METADATA(name, data)
#endif
 
#ifdef SERAC_USE_CALIPER
 
#define SERAC_MARK_FUNCTION CALI_CXX_MARK_FUNCTION
#define SERAC_MARK_LOOP_BEGIN(id, name) CALI_CXX_MARK_LOOP_BEGIN(id, name)
#define SERAC_MARK_LOOP_ITER(id, i) CALI_CXX_MARK_LOOP_ITERATION(id, i)
#define SERAC_MARK_LOOP_END(id) CALI_CXX_MARK_LOOP_END(id)
#define SERAC_MARK_BEGIN(name) serac::profiling::detail::startCaliperRegion(name)
#define SERAC_MARK_END(name) serac::profiling::detail::endCaliperRegion(name)
 
#define SERAC_CONCAT_(a, b) a##b
#define SERAC_CONCAT(a, b) SERAC_CONCAT_(a, b)
 
namespace serac::profiling::detail {
 
inline const char* make_cstr(const char* str) { return str; }
 
inline const char* make_cstr(const std::string& str) { return str.c_str(); }
 
}  // namespace serac::profiling::detail
 
#define SERAC_PROFILE_SCOPE(name) \
  cali::ScopeAnnotation SERAC_CONCAT(region, __LINE__)(serac::profiling::detail::make_cstr(name))
 
// We use decltype(auto) here instead of the default auto for a different set of type deduction rules -
// the latter uses template type deduction rules but the former uses those for decltype, which we need
// in order for the return type to take into account the value category (rvalue, lvalue) of the expression
// We have to return (expr) instead of expr to ensure that reference-ness is propagated through correctly
// in Clang - GCC handles this correctly without the parentheses as expected
#define SERAC_PROFILE_EXPR(name, expr)                                                                     \
  [&]() -> decltype(auto) {                                                                                \
    const cali::ScopeAnnotation SERAC_CONCAT(region, __LINE__)(serac::profiling::detail::make_cstr(name)); \
    return (expr);                                                                                         \
  }()
 
#define SERAC_PROFILE_EXPR_LOOP(name, expr, ntest)                                                                  \
  (                                                                                                                 \
      [&]() {                                                                                                       \
        for (int SERAC_CONCAT(i, __LINE__) = 0; SERAC_CONCAT(i, __LINE__) < ntest - 1; SERAC_CONCAT(i, __LINE__)++) \
          SERAC_PROFILE_EXPR(serac::profiling::detail::make_cstr(name), expr);                                      \
      }(),                                                                                                          \
      SERAC_PROFILE_EXPR(serac::profiling::detail::make_cstr(name), expr))
 
#else  // SERAC_USE_CALIPER not defined
 
// Define all these as nothing so annotated code will still compile
#define SERAC_MARK_FUNCTION
#define SERAC_MARK_LOOP_BEGIN(id, name)
#define SERAC_MARK_LOOP_ITER(id, i)
#define SERAC_MARK_LOOP_END(id)
#define SERAC_MARK_BEGIN(name)
#define SERAC_MARK_END(name)
#define SERAC_PROFILE_SCOPE(name)
#define SERAC_PROFILE_EXPR(name, expr) expr
#define SERAC_PROFILE_EXPR_LOOP(name, expr, ntest) expr
 
#endif
 
namespace serac::profiling {
 
void initialize([[maybe_unused]] MPI_Comm comm = MPI_COMM_WORLD, [[maybe_unused]] std::string options = "");
 
void finalize();
 
namespace detail {
 
void startCaliperRegion(const char* name);
 
void endCaliperRegion(const char* name);
 
}  // namespace detail
 
template <typename... T>
std::string concat(T... args)
{
  std::stringstream ss;
  // this fold expression is a more elegant way to implement the concatenation,
  // but nvcc incorrectly generates warning "warning: expression has no effect"
  // when using the fold expression version
  // (ss << ... << args);
  ((ss << args), ...);
  return ss.str();
}
 
}  // namespace serac::profiling