ProfilingInfo.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ProfilingInfo.cc                                            (C) 2000-2026 */
/*                                                                           */
/* Informations de profiling.                                                */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArcaneGlobal.h"
 
#include "arcane/utils/Array.h"
#include "arcane/utils/String.h"
#include "arcane/utils/StringBuilder.h"
#include "arcane/utils/PlatformUtils.h"
#include "arcane/utils/JSONWriter.h"
 
#include "arcane/std/ProfilingInfo.h"
 
#include <set>
#include <array>
#include <fstream>
 
#include "arcane_packages.h"
 
//#undef ARCANE_HAS_PACKAGE_LIBUNWIND
 
#ifdef ARCANE_HAS_PACKAGE_LIBUNWIND
#define UNW_LOCAL_ONLY
#include <libunwind.h>
#include <stdio.h>
#endif
#ifdef __GNUG__
#include <cxxabi.h>
#endif
 
#if defined(ARCANE_OS_LINUX)
#include <execinfo.h>
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
#endif
 
#if defined(ARCANE_OS_LINUX)
#define ARCANE_HAS_GLIBC_BACKTRACE
#endif
 
#ifdef ARCANE_USE_MALLOC_HOOK
#include <malloc.h>
#endif
 
#include <atomic>
#include <algorithm>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ProfInfos::IStackInfoProvider
{
 public:
 
  virtual ~IStackInfoProvider() {}
  virtual Integer nbIndex() const = 0;
  virtual intptr_t functionStartAddress(Int32 stack_index) = 0;
  virtual void fillStack(Integer function_depth) = 0;
  virtual void setFunc(Int32 func_index, Int32 stack_index) = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ProfInfos::IFuncInfoProvider
{
 public:
 
  virtual ~IFuncInfoProvider() {}
  virtual void fillFuncName(ProfFuncInfo& pfi) = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ProfInfos::NullFuncInfoProvider
: public IFuncInfoProvider
{
 public:
 
  virtual ~NullFuncInfoProvider() {}
  virtual void fillFuncName(ProfFuncInfo& pfi) override
  {
    pfi.m_func_name[0] = '\0';
    pfi.setHasFuncName(true);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifdef ARCANE_HAS_PACKAGE_LIBUNWIND
class ProfInfos::LibUnwindFuncInfos
: public IFuncInfoProvider
{
 public:
 
  void fillFuncName(ProfFuncInfo& pfi) override
  {
    Int32 func_index = pfi.index();
    unw_cursor_t* cursor = &func_cursor[func_index];
    unw_word_t offset;
    unw_get_proc_name(cursor, pfi.m_func_name, MAX_FUNC_LEN, &offset);
    pfi.setHasFuncName(true);
  }
  void setFunc(Int32 func_index, const unw_cursor_t& cursor)
  {
    func_cursor[func_index] = cursor;
  }
 
 private:
 
  unw_cursor_t func_cursor[MAX_FUNC];
};
 
class ProfInfos::LibUnwindStackInfo
: public IStackInfoProvider
{
 public:
 
  LibUnwindStackInfo(LibUnwindFuncInfos* func_infos)
  : m_nb_index(0)
  , m_func_infos(func_infos)
  {}
 
 public:
 
  void fillStack(Integer function_depth) override
  {
    Integer index = 0;
    unw_context_t uc;
    unw_cursor_t cursor;
    unw_getcontext(&uc);
    unw_init_local(&cursor, &uc);
    unw_proc_info_t proc_info;
    while (unw_step(&cursor) > 0 && index < (MAX_STACK + function_depth)) {
      unw_get_proc_info(&cursor, &proc_info);
      m_cursors[index] = cursor;
      m_proc_start[index] = proc_info.start_ip;
      ++index;
    }
    m_nb_index = index;
  }
  void setFunc(Int32 func_index, Int32 stack_index) override
  {
    m_func_infos->setFunc(func_index, m_cursors[stack_index]);
  }
 
 public:
 
  Integer nbIndex() const override { return m_nb_index; }
  intptr_t functionStartAddress(Int32 stack_index) override
  {
    return (intptr_t)m_proc_start[stack_index];
  }
 
 private:
 
  // TODO: vérifier taille
  unw_cursor_t m_cursors[256];
  unw_word_t m_proc_start[256];
  Integer m_nb_index;
  LibUnwindFuncInfos* m_func_infos;
};
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifdef ARCANE_HAS_GLIBC_BACKTRACE
class ProfInfos::BacktraceFuncInfos
: public IFuncInfoProvider
{
 public:
 
  void fillFuncName(ProfFuncInfo& pfi) override
  {
    Int32 func_index = pfi.index();
    int copy_index = 0;
    const char* func_name = func_dl_info[func_index].dli_sname;
    if (func_name) {
      for (; copy_index < MAX_FUNC_LEN; ++copy_index) {
        char c = func_name[copy_index];
        pfi.m_func_name[copy_index] = c;
        if (c == '\0')
          break;
      }
    }
    pfi.m_func_name[copy_index] = '\0';
    pfi.setHasFuncName(true);
  }
  void setFunc(Int32 func_index, const Dl_info& dl_info)
  {
    func_dl_info[func_index] = dl_info;
  }
 
 private:
 
  Dl_info func_dl_info[MAX_FUNC];
};
class ProfInfos::BacktraceStackInfo
: public IStackInfoProvider
{
 public:
 
  BacktraceStackInfo(BacktraceFuncInfos* func_infos)
  : m_nb_index(0)
  , m_func_infos(func_infos)
  {}
 
 public:
 
  void fillStack(Integer function_depth) override
  {
    ARCANE_UNUSED(function_depth);
    void* addrs[64];
    m_nb_index = backtrace(addrs, 64);
    for (Integer index = 0; index < m_nb_index; ++index) {
      int err_code = dladdr(addrs[index], &m_dl_infos[index]);
      if (err_code != 0)
        m_proc_start[index] = (intptr_t)m_dl_infos[index].dli_saddr;
      else
        m_proc_start[index] = 0;
    }
  }
  void setFunc(Int32 func_index, Int32 stack_index) override
  {
    m_func_infos->setFunc(func_index, m_dl_infos[stack_index]);
  }
 
 public:
 
  Integer nbIndex() const override { return m_nb_index; }
  intptr_t functionStartAddress(Int32 stack_index) override
  {
    return (intptr_t)m_proc_start[stack_index];
  }
 
 private:
 
  // TODO: vérifier taille
  std::array<Dl_info, 256> m_dl_infos = {};
  std::array<intptr_t, 256> m_proc_start = {};
  Integer m_nb_index;
  BacktraceFuncInfos* m_func_infos;
};
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class MonoFuncAddrGetter
{
 private:
 
  struct _MonoJitInfo;
  struct _MonoDomain;
  struct _MonoMethod;
 
  typedef void* (*mono_jit_info_get_code_start_func)(_MonoJitInfo* ji);
  typedef _MonoDomain* (*mono_domain_get_func)();
  typedef _MonoJitInfo* (*mono_jit_info_table_find_func)(_MonoDomain*, void* ip);
  typedef char* (*mono_pmip_func)(void* ip);
  typedef _MonoMethod* (*mono_jit_info_get_method_func)(_MonoJitInfo* ji);
  typedef char* (*mono_method_full_name_func)(_MonoMethod* method, bool full);
 
 public:
 
  MonoFuncAddrGetter()
  : m_is_valid(false)
  , m_handle(0)
  {
    empty_func_name[0] = '\0';
#if defined(ARCANE_OS_LINUX)
    void* handle = dlopen(0, RTLD_LAZY);
    if (!handle)
      return;
    m_handle = handle;
    m_mono_jit_info_get_code_start_ptr = (mono_jit_info_get_code_start_func)(dlsym(handle, "mono_jit_info_get_code_start"));
    m_mono_domain_get_ptr = (mono_domain_get_func)(dlsym(handle, "mono_domain_get"));
    m_mono_jit_info_table_find_ptr = (mono_jit_info_table_find_func)(dlsym(handle, "mono_jit_info_table_find"));
    m_mono_pmip_ptr = (mono_pmip_func)(dlsym(handle, "mono_pmip"));
    m_mono_jit_info_get_method_ptr = (mono_jit_info_get_method_func)(dlsym(handle, "mono_jit_info_get_method"));
    m_mono_method_full_name_ptr = (mono_method_full_name_func)(dlsym(handle, "mono_method_full_name"));
 
    if (!m_mono_jit_info_get_code_start_ptr)
      return;
    if (!m_mono_domain_get_ptr)
      return;
    if (!m_mono_jit_info_table_find_ptr)
      return;
    if (!m_mono_pmip_ptr)
      return;
    if (!m_mono_jit_info_get_method_ptr)
      return;
    if (!m_mono_method_full_name_ptr)
      return;
    m_is_valid = true;
#endif
  }
  ~MonoFuncAddrGetter()
  {
#if defined(ARCANE_OS_LINUX)
    dlclose(m_handle);
#endif
  }
 
  bool isValid() const
  {
    return m_is_valid;
  }
  char empty_func_name[1];
  char* getInfo(void* ip, void** _start_addr)
  {
    if (!m_is_valid)
      return 0;
    char* func_name = empty_func_name; //(*m_mono_pmip_ptr)(ip);
    _MonoDomain* d = (*m_mono_domain_get_ptr)();
    _MonoJitInfo* ji = (*m_mono_jit_info_table_find_ptr)(d, ip);
    *_start_addr = 0;
    void* start_addr = 0;
    if (ji) {
      start_addr = (*m_mono_jit_info_get_code_start_ptr)(ji);
      _MonoMethod* method = (*m_mono_jit_info_get_method_ptr)(ji);
      func_name = (*m_mono_method_full_name_ptr)(method, true);
    }
    //cout << "** START ADDR=" << start_addr << " func_name=" << (void*)func_name << " IP=" << ip << '\n';
    //if (func_name)
    //cout << "** FUNC=" << func_name << '\n';
    *_start_addr = start_addr;
    return func_name;
  }
 
 private:
 
  bool m_is_valid = false;
  mono_jit_info_get_code_start_func m_mono_jit_info_get_code_start_ptr = nullptr;
  mono_domain_get_func m_mono_domain_get_ptr = nullptr;
  mono_jit_info_table_find_func m_mono_jit_info_table_find_ptr = nullptr;
  mono_pmip_func m_mono_pmip_ptr = nullptr;
  mono_jit_info_get_method_func m_mono_jit_info_get_method_ptr = nullptr;
  mono_method_full_name_func m_mono_method_full_name_ptr = nullptr;
  void* m_handle = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
static std::atomic<Int32> global_in_malloc;
 
#ifdef ARCANE_USE_MALLOC_HOOK
 
namespace
{
  void* (*my_old_malloc_hook)(size_t, const void*);
  void (*my_old_free_hook)(void*, const void*);
  void* (*my_old_realloc_hook)(void* __ptr, size_t __size, __const void*);
 
} // namespace
 
//static Arcane::Int64 global_nb_malloc = 1;
extern void* prof_malloc_hook(size_t size, const void* caller);
extern void prof_free_hook(void* ptr, const void* caller);
extern void* prof_realloc_hook(void* __ptr, size_t __size, __const void*);
 
// Ces fonctions ne doivent pas être statiques pour éviter une optimisation
// de GCC 4.7.1 qui fait une boucle infinie dans prof_malloc_hook
// (Note: clang 3.4 a le meme comportement)
extern ARCANE_STD_EXPORT void _pushHook()
{
  __malloc_hook = my_old_malloc_hook;
  __free_hook = my_old_free_hook;
  __realloc_hook = my_old_realloc_hook;
}
 
extern ARCANE_STD_EXPORT void _popHook()
{
  __malloc_hook = prof_malloc_hook;
  __free_hook = prof_free_hook;
  __realloc_hook = prof_realloc_hook;
}
 
void* prof_malloc_hook(size_t size, const void* /*caller*/)
{
  ++global_in_malloc;
  _pushHook();
  void* r = malloc(size);
  _popHook();
  --global_in_malloc;
  return r;
}
 
void prof_free_hook(void* ptr, const void* /*caller*/)
{
  _pushHook();
  free(ptr);
  _popHook();
}
 
void* prof_realloc_hook(void* ptr, size_t size, const void* /*caller*/)
{
  ++global_in_malloc;
  _pushHook();
  void* r = realloc(ptr, size);
  _popHook();
  --global_in_malloc;
  return r;
}
 
void _profInitMallocHook()
{
  global_in_malloc = 0;
  my_old_malloc_hook = __malloc_hook;
  __malloc_hook = prof_malloc_hook;
  my_old_free_hook = __free_hook;
  __free_hook = prof_free_hook;
  my_old_realloc_hook = __realloc_hook;
  __realloc_hook = prof_realloc_hook;
}
 
void _profRestoreMallocHook()
{
  __free_hook = my_old_free_hook;
  __malloc_hook = my_old_malloc_hook;
  __realloc_hook = my_old_realloc_hook;
}
#else
void _profInitMallocHook()
{
}
void _profRestoreMallocHook()
{
}
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace
{
  const char*
  _getDemangledName(const char* true_func_name, char* demangled_buf, size_t demangled_buf_len)
  {
    if (demangled_buf_len <= 1)
      return true_func_name;
    size_t len = demangled_buf_len - 1;
    int dstatus = 0;
    const char* buf = nullptr;
#ifdef __GNUG__
    buf = abi::__cxa_demangle(true_func_name, demangled_buf, &len, &dstatus);
#endif
    if (!buf)
      buf = true_func_name;
    return buf;
  }
} // End anonymous namespace
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ProfInfos::
ProfInfos(ITraceMng* tm)
: TraceAccessor(tm)
, m_default_func_info_provider(new NullFuncInfoProvider())
, m_func_info_provider(m_default_func_info_provider)
{
  for (Integer i = 0; i < MAX_COUNTER; ++i)
    m_counters[i] = 0;
  if (platform::hasDotNETRuntime()) {
    // Pour l'instant, active uniquement si variable d'environnement
    // positionnée.
    if (!platform::getEnvironmentVariable("ARCANE_DOTNET_BACKTRACE").null()) {
      m_mono_func_getter = new MonoFuncAddrGetter();
      if (!m_mono_func_getter->isValid()) {
        delete m_mono_func_getter;
        m_mono_func_getter = 0;
      }
    }
  }
#ifdef ARCANE_HAS_PACKAGE_LIBUNWIND
  m_libunwind_func_info_provider = new LibUnwindFuncInfos();
  m_use_libunwind = true;
#endif
#ifdef ARCANE_HAS_GLIBC_BACKTRACE
  m_backtrace_func_info_provider = new BacktraceFuncInfos();
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ProfInfos::
~ProfInfos()
{
  delete m_default_func_info_provider;
  delete m_backtrace_func_info_provider;
  delete m_libunwind_func_info_provider;
  delete m_mono_func_getter;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ProfFuncInfo* ProfInfos::
_getNextFuncInfo()
{
  // TODO: utiliser un atomic pour m_current_func_info lorsqu'il faudra le
  // rendre thread-safe.
  ProfFuncInfo* fi = &m_func_info_buffer[m_current_func_info];
  fi->setIndex(m_current_func_info);
  ++m_current_func_info;
  return fi;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
startProfiling()
{
  _checkNotStarted();
  m_is_started = true;
  info() << "DÉBUT DU PROFILAGE";
#ifndef __clang__
  //GG Si on utilise ces hook avec clang il part en boucle infini.
  // Pour éviter cela, on le désactive et cela semble fonctionner.
  // De toute facon ces hook sont obsolètes et il faudra penser à faire
  // autrement.
  _profInitMallocHook();
#endif
 
  String stack_unwinder_str = platform::getEnvironmentVariable("ARCANE_PROFILING_STACKUNWINDING");
  info() << "STACK_UNWIND=" << stack_unwinder_str;
  if (stack_unwinder_str == "backtrace") {
    m_use_backtrace = true;
    m_use_libunwind = false;
  }
  m_func_info_provider = m_default_func_info_provider;
  if (m_use_backtrace)
    m_func_info_provider = m_backtrace_func_info_provider;
  else if (m_use_libunwind)
    m_func_info_provider = m_libunwind_func_info_provider;
  info() << "Démarrage du profilage : use_backtrace=" << m_use_backtrace
         << " use_libunwind=" << m_use_libunwind
         << " has_mono=" << m_mono_func_getter;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
stopProfiling()
{
  m_is_started = false;
  _profRestoreMallocHook();
 
  // TODO: comme on incrémente, ne faire que à partir de la dernière méthode
  // dont le nom est inconnu.
  ARCANE_CHECK_POINTER(m_func_info_provider);
  for (Int32 i = 0, n = m_current_func_info; i < n; ++i) {
    ProfFuncInfo& pfi = m_func_info_buffer[i];
    if (!pfi.hasFuncName())
      m_func_info_provider->fillFuncName(pfi);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
_checkNotStarted()
{
  if (m_is_started)
    ARCANE_FATAL("Invalid call when profiling is active");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
setFunctionDepth(int v)
{
  _checkNotStarted();
  m_function_depth = v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
setPeriod(int v)
{
  _checkNotStarted();
  m_period = v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
namespace
{
  int global_nb_in_handler = 0;
}
 
void ProfInfos::
addEvent(void* address, int overflow_event[MAX_COUNTER], int nb_overflow_event)
{
  static bool is_in_handler = false;
 
  if (is_in_handler) {
    ++global_nb_in_handler;
    return;
  }
  is_in_handler = true;
  if (m_use_backtrace) {
    //_addEventBacktrace(address,overflow_event,nb_overflow_event);
#ifdef ARCANE_HAS_GLIBC_BACKTRACE
    BacktraceStackInfo stack_info((BacktraceFuncInfos*)m_backtrace_func_info_provider);
    _addEvent(address, overflow_event, nb_overflow_event, stack_info, m_function_depth + 2);
#endif
  }
  else if (m_use_libunwind) {
#ifdef ARCANE_HAS_PACKAGE_LIBUNWIND
    LibUnwindStackInfo stack_info((LibUnwindFuncInfos*)m_libunwind_func_info_provider);
    _addEvent(address, overflow_event, nb_overflow_event, stack_info, m_function_depth + 1);
#endif
  }
  is_in_handler = false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
_sortFunctions(std::set<ProfFuncInfo*, ProfFuncComparer>& sorted_func)
{
  for (const auto& x : m_func_map)
    if (x.second)
      sorted_func.insert(x.second);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
_storeAddress(void* address, bool is_counter0, int overflow_event[MAX_COUNTER], int nb_overflow_event,
              bool* do_add, bool* do_stack, bool* func_already_added)
{
  ++m_total_event;
  ProfInfos::AddrMap::iterator v = m_addr_map.find(address);
  if (v != m_addr_map.end()) {
    ProfAddrInfo& ai = v->second;
    for (int i = 0; i < nb_overflow_event; ++i)
      ++ai.m_counters[overflow_event[i]];
    if (ai.m_func_info) {
      for (int i = 0; i < nb_overflow_event; ++i)
        ++ai.m_func_info->m_counters[overflow_event[i]];
      *func_already_added = true;
      // Si on a déjà suffisamment d'évènements et que notre méthode
      // dépasse les 1% du temps passé, conserve la pile associée.
      if (m_total_event > m_nb_event_before_getting_stack) {
        if ((ai.m_func_info->m_counters[0] * 100) > m_total_event) {
          ai.m_func_info->m_do_stack = true;
          if (is_counter0)
            *do_stack = true;
        }
      }
    }
  }
  else
    *do_add = true;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
_addEvent(void* address, int overflow_event[MAX_COUNTER], int nb_overflow_event,
          IStackInfoProvider& stack_info, Integer function_depth)
{
  // Si on est dans un malloc, ne fait rien.
  // TODO: il faudrait quand meme incrementer le compteur correspondant
  // car dans ce cas le temps passé dans les malloc/realloc/free n'est pas pris en compte
  // TODO: faire test atomic
  if (global_in_malloc != 0) {
    //cout << "V=" <<global_in_malloc << '\n';
    return;
  }
 
  bool is_counter0 = false;
 
  for (int i = 0; i < nb_overflow_event; ++i) {
    if (overflow_event[i] == 0)
      is_counter0 = true;
    if (overflow_event[i] < 0 || overflow_event[i] >= MAX_COUNTER)
      std::cerr << "arcane_papi_handler: EVENT ERROR n=" << overflow_event[i] << '\n';
  }
 
  bool do_stack = false;
  bool do_add = false;
  bool func_already_added = false;
  _storeAddress(address, is_counter0, overflow_event, nb_overflow_event,
                &do_add, &do_stack, &func_already_added);
 
  if (do_add || do_stack) {
    ProfAddrInfo papi_address_info;
    ProfStackInfo papi_stack_info;
    for (int i = 0; i < nb_overflow_event; ++i)
      ++papi_address_info.m_counters[overflow_event[i]];
 
    stack_info.fillStack(function_depth);
 
    for (Integer index = function_depth, nb_index = stack_info.nbIndex(); index < nb_index; ++index) {
      intptr_t proc_start = stack_info.functionStartAddress(index);
 
      ProfInfos::FuncMap::iterator func = m_func_map.find(proc_start);
      ProfFuncInfo* papi_func_info = nullptr;
      if (func == m_func_map.end()) {
        if (m_current_func_info >= MAX_FUNC) {
          std::cerr << "arcane_papi_handler: MAX_FUNC atteint !\n";
          break;
        }
        papi_func_info = _getNextFuncInfo();
        papi_address_info.m_func_info = papi_func_info;
        Int32 func_index = papi_func_info->index();
        stack_info.setFunc(func_index, index);
        m_func_map.insert(ProfInfos::FuncMap::value_type(proc_start, papi_func_info));
      }
      else {
        papi_func_info = func->second;
      }
 
      if (index < (MAX_STACK + function_depth))
        papi_stack_info.m_funcs_info_indexes[index - function_depth] = papi_func_info->index();
      if (index == function_depth) {
        papi_address_info.m_func_info = papi_func_info;
        if (!func_already_added)
          for (int i = 0; i < nb_overflow_event; ++i)
            ++papi_func_info->m_counters[overflow_event[i]];
        if (!papi_func_info->m_do_stack || !is_counter0)
          break;
        else
          do_stack = true;
      }
    }
    if (do_stack) {
      ++m_total_stack;
      ProfInfos::StackMap::iterator st = m_stack_map.find(papi_stack_info);
      if (st != m_stack_map.end()) {
        ++st->second;
      }
      else
        m_stack_map.insert(ProfInfos::StackMap::value_type(papi_stack_info, 1));
    }
    if (do_add)
      m_addr_map.insert(ProfInfos::AddrMap::value_type(address, papi_address_info));
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
// NOTE: cette méthode n'est plus utilisée mais le mécanisme d'accès via mono
// doit être intégré au code de libunwind ou backtrace.
bool ProfInfos::
_getFunc(void* addr, FuncAddrInfo& info)
{
#ifdef ARCANE_OS_LINUX
  Dl_info dl_info;
  int r = dladdr(addr, &dl_info);
  info.func_name = "unknown";
  info.start_addr = 0;
  if (r != 0) {
    // Il est possible que dladdr ne retourne pas d'erreur mais ne trouve pas
    // le symbole. Dans ce cas, essayer de voir s'il s'agit d'un
    // symbole C#.
    info.start_addr = dl_info.dli_saddr;
    if (dl_info.dli_sname) {
      info.func_name = dl_info.dli_sname;
      return false;
    }
  }
  if (m_mono_func_getter) {
    void* start_addr = 0;
    char* func_name = m_mono_func_getter->getInfo(addr, &start_addr);
    if (func_name && start_addr) {
      info.start_addr = start_addr;
      info.func_name = func_name;
      return false;
    }
  }
#endif
  return true;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
reset()
{
  ProfInfos* global_infos = this;
  {
    ProfInfos::AddrMap::iterator begin = global_infos->m_addr_map.begin();
    for (; begin != global_infos->m_addr_map.end(); ++begin) {
      for (Integer i = 0; i < MAX_COUNTER; ++i)
        begin->second.m_counters[i] = 0;
    }
  }
  {
    ProfInfos::FuncMap::iterator begin = global_infos->m_func_map.begin();
    for (; begin != global_infos->m_func_map.end(); ++begin) {
      ProfFuncInfo* pf = begin->second;
      for (Integer i = 0; i < MAX_COUNTER; ++i)
        pf->m_counters[i] = 0;
    }
  }
  m_total_event = 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
printInfos(bool dump_file)
{
  ProfInfos* global_infos = this;
 
  Int64 total_event = 1;
  Int64 total_fp = 1;
  int process_id = platform::getProcessId();
  {
    info() << " PROCESS_ID = " << process_id;
    info() << " NB ADDRESS MAP = " << global_infos->m_addr_map.size();
    info() << " NB FUNC MAP = " << global_infos->m_func_map.size();
    info() << " NB STACK MAP = " << global_infos->m_stack_map.size();
    info() << " TOTAL STACK = " << global_infos->m_total_stack;
    {
      ProfInfos::AddrMap::const_iterator begin = global_infos->m_addr_map.begin();
      for (; begin != global_infos->m_addr_map.end(); ++begin) {
        Int64 nb_event = begin->second.m_counters[0];
        total_event += nb_event;
        Int64 nb_fp = begin->second.m_counters[2];
        total_fp += nb_fp;
      }
    }
    {
      ProfInfos::FuncMap::const_iterator begin = global_infos->m_func_map.begin();
      Int64 total_func_event = 0;
      Int64 total_func_fp = 0;
      for (; begin != global_infos->m_func_map.end(); ++begin) {
        ProfFuncInfo* pf = begin->second;
        Int64 nb_event = pf->m_counters[0];
        total_func_event += nb_event;
        Int64 nb_fp = pf->m_counters[2];
        total_func_fp += nb_fp;
      }
      info() << " FUNC EVENT=" << total_func_event;
      info() << " FUNC FP=" << total_func_fp;
    }
 
    if (dump_file) {
      StringBuilder sfile_name = "profiling.addr";
      sfile_name += process_id;
      sfile_name += ".xml";
      String file_name = sfile_name;
      std::ofstream ofile(file_name.localstr());
      ofile << "<?xml version='1.0'?>\n";
      ofile << "<addresses>\n";
      ProfInfos::AddrMap::const_iterator begin = global_infos->m_addr_map.begin();
      for (; begin != global_infos->m_addr_map.end(); ++begin) {
        void* addr = begin->first;
        const ProfAddrInfo& pa = begin->second;
        ProfFuncInfo* fi = pa.m_func_info;
        if (fi) {
          ofile << "<addr addr='" << addr << "'"
                << " count='" << pa.m_counters[0] << "'"
                << " fi='" << fi << "'"
                << " fi_count='" << fi->m_counters[0] << "'"
                << " func='" << fi->m_func_name << "'"
                << ">\n";
        }
      }
      ofile << "/<addresses>\n";
    }
  }
 
  std::set<ProfFuncInfo*, ProfFuncComparer> sorted_func;
  _sortFunctions(sorted_func);
 
  const size_t NAME_BUF_SIZE = 8120;
  char demangled_func_name[NAME_BUF_SIZE];
  {
    info() << " TOTAL EVENT  = " << total_event;
    info() << " TOTAL NB_IN_HANDLER  = " << global_nb_in_handler;
    Real nb_gflop = ((Real)total_fp * (Real)m_period) * 1e-09;
    info() << " TOTAL FP     = " << total_fp << " (nb_giga_flip=" << nb_gflop << ")";
    info() << " RATIO FP/CYC = " << ((Real)total_fp / (Real)total_event);
    info() << "  " << Trace::Width(10) << "nb_event"
           << "  " << Trace::Width(5) << "%"
           << "  " << Trace::Width(5) << "cum%"
           << " " << Trace::Width(12) << "event1"
           << " " << Trace::Width(12) << "event2"
           << " " << Trace::Width(12) << "event3"
           << " " << " "
           << "  " << "function";
    Integer index = 0;
    Int64 cumulative_nb_event = 0;
    for (ProfFuncInfo* pfi : sorted_func) {
      const char* func_name = pfi->m_func_name;
      const char* buf = _getDemangledName(func_name, demangled_func_name, NAME_BUF_SIZE);
      Int64 nb_event = pfi->m_counters[0];
      cumulative_nb_event += nb_event;
      Int64 cumulative_total_percent = (cumulative_nb_event * 1000) / total_event;
      Int64 total_percent = (nb_event * 1000) / total_event;
      Int64 cumulative_percent = (cumulative_total_percent / 10);
      Int64 percent = (total_percent / 10);
      info() << "  " << Trace::Width(10) << nb_event
             << "  " << Trace::Width(3) << percent << "." << (total_percent % 10)
             << "  " << Trace::Width(3) << cumulative_percent << "." << (cumulative_total_percent % 10)
             << " " << Trace::Width(12) << pfi->m_counters[0]
             << " " << Trace::Width(12) << pfi->m_counters[1]
             << " " << Trace::Width(12) << pfi->m_counters[2]
             << " " << pfi->m_do_stack
             << "  " << buf;
      if (total_percent < 5 && index > 20)
        break;
      ++index;
    }
  }
  // TODO: Calculer ces informations lors de l'arrêt du profiling.
  if (dump_file) {
    // Créée une liste des piles triée par nombre d'évènements décroissant.
    UniqueArray<SortedProfStackInfo> sorted_stacks;
    for (const auto& x : global_infos->m_stack_map) {
      const ProfStackInfo& psi = x.first;
      Int64 nb_stack = x.second;
      sorted_stacks.add(SortedProfStackInfo(psi, nb_stack));
    }
    std::sort(std::begin(sorted_stacks), std::end(sorted_stacks));
 
    String file_name = String("profiling.callstack") + platform::getProcessId();
    std::ofstream ofile;
    ofile.open(file_name.localstr());
 
    for (const auto& x : sorted_stacks) {
      const ProfStackInfo& psi = x.stackInfo();
      Int64 nb_stack = x.nbCount();
      if (nb_stack < 2)
        continue;
      ofile << " Stack nb=" << nb_stack << '\n';
      for (Integer z = 0; z < MAX_STACK; ++z) {
        Int32 fidx = psi.m_funcs_info_indexes[z];
        if (fidx >= 0) {
          ProfFuncInfo& pfi = _funcInfoFromIndex(fidx);
          const char* func_name = pfi.m_func_name;
          const char* buf = _getDemangledName(func_name, demangled_func_name, NAME_BUF_SIZE);
          ofile << "  " << buf << '\n';
        }
      }
    }
    ofile.close();
  }
}
 
// ****************************************************************************
// * getInfos pour quelqu'un d'autre
// *  [0] 0xb80dd1a3ul
// *  [1] Taille
// *  [2] total_event
// *  [3] total_fp
// *  [4] (Int64) int m_period
// *  [5] (Int64) Integer index;
// *     nb_event
// *     total_percent
// *     m_counters[0]: PAPI_TOT_CYC Cycles totaux
// *     m_counters[1]: PAPI_RES_STL Cycles bloqués sur n'importe quelle ressource
// *     m_counters[2]: PAPI_FP_INS Instructions en virgule flottante
// *     strlen(func_name)
// *
// *
// ****************************************************************************
void ProfInfos::
getInfos(Int64Array& pkt)
{
  const size_t NAME_BUF_SIZE = 8192;
  char demangled_func_name[NAME_BUF_SIZE];
  ProfInfos* global_infos = this;
  Int64 total_event = 1;
  Int64 total_fp = 1;
  Integer index = 0;
 
  {
    ProfInfos::AddrMap::const_iterator begin = global_infos->m_addr_map.begin();
    for (; begin != global_infos->m_addr_map.end(); ++begin) {
      Int64 nb_event = begin->second.m_counters[0];
      total_event += nb_event;
      Int64 nb_fp = begin->second.m_counters[2];
      total_fp += nb_fp;
    }
  }
  //Real nb_gflop = ((Real)total_fp*(Real)m_period) * 1e-09;
  pkt.add(total_event);
  pkt.add(total_fp);
  pkt.add((Int64)m_period);
  info() << "[ProfInfos::getInfos] total_event=" << total_event << ", total_fp=" << total_fp << ", m_period=" << m_period;
 
  std::set<ProfFuncInfo*, ProfFuncComparer> sorted_func;
  _sortFunctions(sorted_func);
 
  // On pousse l'index qui vaut zero
  pkt.add((Int64)index);
 
  // Et on continue à remplir l'array
  for (ProfFuncInfo* pfi : sorted_func) {
    const char* func_name = pfi->m_func_name;
    const char* buf = _getDemangledName(func_name, demangled_func_name, NAME_BUF_SIZE);
    Int64 nb_event = pfi->m_counters[0];
    pkt.add(nb_event);
    Int64 total_percent = (nb_event * 1000) / total_event;
    pkt.add(total_percent);
    pkt.add(pfi->m_counters[0]);
    pkt.add(pfi->m_counters[1]);
    pkt.add(pfi->m_counters[2]);
 
    Int64 mx = strlen(buf);
    pkt.add(mx);
    for (Int64 i = 0; i < mx; i += 8)
      pkt.add(*(Int64*)&buf[i]);
 
    if (total_percent < 1 && index > 16)
      break;
    ++index;
  }
  pkt[5] = (Int64)(index);
  info() << "[ProfInfos::getInfos] index @[4] =" << pkt[5];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ProfInfos::
dumpJSON(JSONWriter& writer)
{
  // TODO: utiliser un identifiant pour les noms de fonction au lieu de
  // mettre directement le nom de la méthode.
 
  ProfInfos* global_infos = this;
 
  Int64 total_event = 1;
  for (const auto& x : global_infos->m_addr_map) {
    Int64 nb_event = x.second.m_counters[0];
    total_event += nb_event;
  }
 
  {
    int process_id = platform::getProcessId();
    writer.write("ProcessId", (Int64)process_id);
    writer.write("NbAddressMap", global_infos->m_addr_map.size());
    writer.write("NbFuncMap", global_infos->m_func_map.size());
    writer.write("NbStackMap", global_infos->m_stack_map.size());
    writer.write("TotalStack", global_infos->m_total_stack);
    writer.write("TotalEvent", total_event);
  }
 
  std::set<ProfFuncInfo*, ProfFuncComparer> sorted_func;
  _sortFunctions(sorted_func);
 
  const size_t NAME_BUF_SIZE = 8192;
  char demangled_func_name[NAME_BUF_SIZE];
 
  // Écrit la liste des méthodes référencées et leurs noms manglés et démanglés
  {
    writer.writeKey("Functions");
    writer.beginArray();
    for (Int32 i = 0, n = m_current_func_info; i < n; ++i) {
      const ProfFuncInfo& pfi = m_func_info_buffer[i];
      const char* func_name = pfi.m_func_name;
      const char* buf = _getDemangledName(func_name, demangled_func_name, NAME_BUF_SIZE);
 
      {
        JSONWriter::Object o(writer);
        writer.write("Index", (Int64)pfi.index());
        writer.write("Name", func_name);
        writer.write("DemangledName", buf);
      }
    }
    writer.endArray();
  }
 
  // Écrit la liste des méthodes triées par ordre décroissant des valeurs
  // des compteurs.
  {
    Integer index = 0;
    writer.writeKey("SortedFuncTimes");
    writer.beginArray();
    for (ProfFuncInfo* pfi : sorted_func) {
      const char* func_name = pfi->m_func_name;
      const char* buf = _getDemangledName(func_name, demangled_func_name, NAME_BUF_SIZE);
      {
        JSONWriter::Object o(writer);
        writer.write("Index", (Int64)(pfi->index()));
        writer.write("Name", buf);
        writer.write("Events", Int64ConstArrayView(3, pfi->m_counters));
      }
      if (index > 100)
        break;
      ++index;
    }
    writer.endArray();
  }
 
  {
    // Crée une liste de piles triées par nombre d'événements décroissant.
    UniqueArray<SortedProfStackInfo> sorted_stacks;
    for (const auto& x : global_infos->m_stack_map) {
      const ProfStackInfo& psi = x.first;
      Int64 nb_stack = x.second;
      sorted_stacks.add(SortedProfStackInfo(psi, nb_stack));
    }
    std::sort(std::begin(sorted_stacks), std::end(sorted_stacks));
 
    writer.writeKey("StackMap");
    writer.beginArray();
    for (const auto& x : sorted_stacks) {
      const ProfStackInfo& psi = x.stackInfo();
      Int64 nb_stack = x.nbCount();
      if (nb_stack < 2)
        continue;
      {
        JSONWriter::Object o(writer);
        writer.write("Count", nb_stack);
        writer.write("Stacks", Int32ConstArrayView(MAX_STACK, psi.m_funcs_info_indexes));
 
        writer.writeKey("StackNames");
        writer.beginArray();
        for (Integer z = 0; z < MAX_STACK; ++z) {
          Int32 fidx = psi.m_funcs_info_indexes[z];
          if (fidx >= 0) {
            ProfFuncInfo& pfi = _funcInfoFromIndex(fidx);
            const char* func_name = pfi.m_func_name;
            const char* buf = _getDemangledName(func_name, demangled_func_name, NAME_BUF_SIZE);
            writer.writeValue(buf);
          }
          else
            writer.writeValue(String());
        }
        writer.endArray();
      }
    }
    writer.endArray();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/