EntryPoint.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* EntryPoint.cc                                               (C) 2000-2022 */
/*                                                                           */
/* Entry point of a module.                                                  */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/EntryPoint.h"
 
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/PlatformUtils.h"
#include "arcane/utils/StringBuilder.h"
 
#include "arcane/core/IModule.h"
#include "arcane/core/IEntryPointMng.h"
#include "arcane/core/ISubDomain.h"
#include "arcane/core/Timer.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
const char* const IEntryPoint::WComputeLoop = "ComputeLoop";
const char* const IEntryPoint::WBuild = "Build";
const char* const IEntryPoint::WInit = "Init";
const char* const IEntryPoint::WContinueInit = "ContinueInit";
const char* const IEntryPoint::WStartInit = "StartInit";
const char* const IEntryPoint::WRestore = "Restore";
const char* const IEntryPoint::WOnMeshChanged = "OnMeshChanged";
const char* const IEntryPoint::WOnMeshRefinement = "OnMeshRefinement";
const char* const IEntryPoint::WExit = "Exit";
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
EntryPoint::
EntryPoint(const EntryPointBuildInfo& bi)
: m_sub_domain(bi.module()->subDomain())
, m_caller(bi.caller())
, m_elapsed_timer(new Timer(m_sub_domain, bi.name(), Timer::TimerReal))
, m_name(bi.name())
, m_module(bi.module())
, m_where(bi.where())
, m_property(bi.property())
, m_nb_call(0)
, m_is_destroy_caller(bi.isDestroyCaller())
{
  // Registers with the entry point manager.
  // which will handle the destruction.
  m_sub_domain->entryPointMng()->addEntryPoint(this);
 
  {
    StringBuilder sb;
    sb.append(m_module->name());
    sb.append(".");
    sb.append(m_name);
    sb.append(".");
    sb.append(m_where);
    m_full_name = sb.toString();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
EntryPoint* EntryPoint::
create(const EntryPointBuildInfo& bi)
{
  EntryPoint* x = new EntryPoint(bi);
  return x;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
EntryPoint::
~EntryPoint()
{
  delete m_elapsed_timer;
  //FIXME this must not be destroyed if we go through the C# wrapper
  if (m_is_destroy_caller)
    delete m_caller;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifdef __GNUG__
#pragma GCC optimize "O0"
#endif
void EntryPoint::
_getAddressForHyoda(void* next_entry_point_address)
{
#ifndef ARCANE_OS_WIN32
  if (platform::hasDotNETRuntime())
    return;
  {
    char address[48 + 1];
    snprintf(address, sizeof(address) - 1, "%p", next_entry_point_address);
    //m_sub_domain->traceMng()->debug()<< "\33[7m" << m_where <<"->"<< m_name << "\33[m" << " @"  << address;
  }
#endif
}
#ifdef __GNUG__
#pragma GCC reset_options
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void EntryPoint::
executeEntryPoint()
{
  // Entry points for the compute loop are not
  // called if the module is not active.
  if (m_module->disabled() && m_where == WComputeLoop)
    return;
 
  // In the case of GCC, we will fetch from the module_vtable to retrieve the upcoming address
  // which we will present to Hyoda
  if (!platform::hasDotNETRuntime()) {
#ifdef __GNUG__
    _getAddressForHyoda((static_cast<IFunctorWithAddress*>(m_caller))->functorAddress());
#else
    _getAddressForHyoda();
#endif
  }
 
  Trace::Setter mclass(m_sub_domain->traceMng(), m_module->name());
 
  {
    Timer::Sentry ts_elapsed(m_elapsed_timer);
    Timer::Action ts_action1(m_sub_domain, m_module->name());
    Timer::Phase ts_phase(m_sub_domain, TP_Computation);
    Timer::Action ts_action2(m_sub_domain, m_name);
    m_caller->executeFunctor();
  }
 
  ++m_nb_call;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real EntryPoint::
lastCPUTime() const
{
  return m_elapsed_timer->lastActivationTime();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real EntryPoint::
totalCPUTime() const
{
  return m_elapsed_timer->totalTime();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real EntryPoint::
lastElapsedTime() const
{
  return m_elapsed_timer->lastActivationTime();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real EntryPoint::
totalElapsedTime() const
{
  return m_elapsed_timer->totalTime();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real EntryPoint::
totalTime(Timer::eTimerType) const
{
  return totalElapsedTime();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real EntryPoint::
lastTime(Timer::eTimerType) const
{
  return lastElapsedTime();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/