TimeLoopMng.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* TimeLoopMng.cc                                              (C) 2000-2025 */
/*                                                                           */
/* Time loop manager.                                                        */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Iterator.h"
#include "arcane/utils/List.h"
#include "arcane/utils/ScopedPtr.h"
#include "arcane/utils/PlatformUtils.h"
#include "arcane/utils/StringBuilder.h"
#include "arcane/utils/IMemoryInfo.h"
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/IProfilingService.h"
#include "arcane/utils/IMessagePassingProfilingService.h"
#include "arcane/utils/ValueConvert.h"
#include "arcane/utils/TimeoutException.h"
#include "arcane/utils/GoBackwardException.h"
#include "arcane/utils/OStringStream.h"
#include "arcane/utils/FloatingPointExceptionSentry.h"
#include "arcane/utils/JSONWriter.h"
 
#include "arcane/core/IApplication.h"
#include "arcane/core/IServiceLoader.h"
#include "arcane/core/ISubDomain.h"
#include "arcane/core/CommonVariables.h"
#include "arcane/core/IVariableMng.h"
#include "arcane/core/IEntryPoint.h"
#include "arcane/core/IEntryPointMng.h"
#include "arcane/core/IMesh.h"
#include "arcane/core/IMeshSubMeshTransition.h"
#include "arcane/core/IModule.h"
#include "arcane/core/Directory.h"
#include "arcane/core/IModuleMng.h"
#include "arcane/core/Timer.h"
#include "arcane/core/ITimeLoop.h"
#include "arcane/core/ITimeLoopMng.h"
#include "arcane/core/TimeLoopEntryPointInfo.h"
#include "arcane/core/TimeLoopSingletonServiceInfo.h"
#include "arcane/core/IParallelMng.h"
#include "arcane/core/IMainFactory.h"
#include "arcane/core/ICaseMng.h"
#include "arcane/core/ICaseFunction.h"
#include "arcane/core/IServiceFactory.h"
#include "arcane/core/IModuleFactory.h"
#include "arcane/core/ServiceBuilder.h"
#include "arcane/core/ServiceInfo.h"
#include "arcane/core/ServiceUtils.h"
#include "arcane/core/CaseOptions.h"
#include "arcane/core/ICaseDocument.h"
#include "arcane/core/IVerifierService.h"
#include "arcane/core/IMeshPartitioner.h"
#include "arcane/core/IVariableFilter.h"
#include "arcane/core/ITimeStats.h"
#include "arcane/core/XmlNodeIterator.h"
#include "arcane/core/ServiceFinder2.h"
#include "arcane/core/VariableCollection.h"
#include "arcane/core/Observable.h"
#include "arcane/core/IParallelReplication.h"
#include "arcane/core/IItemFamily.h"
#include "arcane/core/IConfiguration.h"
#include "arcane/core/IMeshUtilities.h"
#include "arcane/core/IVariableUtilities.h"
#include "arcane/core/IItemEnumeratorTracer.h"
#include "arcane/core/ObservablePool.h"
#include "arcane/core/parallel/IStat.h"
#include "arcane/core/IVariableSynchronizer.h"
#include "arcane/core/IVariableSynchronizerMng.h"
#include "arcane/core/VariableComparer.h"
 
#include "arcane/accelerator/core/IAcceleratorMng.h"
#include "arcane/accelerator/core/Runner.h"
 
#include "arcane/impl/DefaultBackwardMng.h"
 
#include <algorithm>
#include <map>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class TimeLoopMng
: public TraceAccessor
, public ITimeLoopMng
{
 public:
 
  struct ModuleState
  {
    ModuleState(bool is_optional, const String& alias)
    : m_is_active(false)
    , m_is_optional(is_optional)
    , m_alias(alias)
    {}
 
    bool m_is_active;
    bool m_is_optional;
    String m_alias;
  };
  enum eVerifType
  {
    VerifNone, 
    VerifWrite, 
    VerifRead, 
    VerifSync, 
    VerifSameReplica 
  };

  typedef std::map<String, ModuleState> ModuleStateMap;
  typedef std::map<String, ITimeLoop*> TimeLoopMap;
  typedef std::map<String, IModuleFactoryInfo*> ModuleFactoryMap;
 
 public:
 
  explicit TimeLoopMng(ISubDomain* sd);
  ~TimeLoopMng() override;
 
 public:
 
  void build() override;
 
  ISubDomain* subDomain() const override { return m_sub_domain; }
 
  void execExitEntryPoints() override;
  void execBuildEntryPoints() override;
  void execInitEntryPoints(bool is_continue) override;
  void stopComputeLoop(bool is_final_time, bool has_error) override;
  bool finalTimeReached() const override { return m_final_time_reached; }
  Real cpuTimeUsed() const override;
 
  EntryPointCollection loopEntryPoints() override { return m_loop_entry_points; }
  EntryPointCollection usedTimeLoopEntryPoints() override { return m_used_time_loop_entry_points; }
 
  void registerTimeLoop(ITimeLoop* timeloop) override;
  void setUsedTimeLoop(const String& name) override;
 
  ITimeLoop* usedTimeLoop() const override { return m_used_time_loop; }
 
  void doExecNextEntryPoint(bool& is_last) override;
  IEntryPoint* nextEntryPoint() override;
 
  IEntryPoint* currentEntryPoint() override { return m_current_entry_point_ptr; }
 
  int doOneIteration() override;
 
  void setBackwardMng(IBackwardMng* backward_mng) override;
  // Attention, may return NULL
  IBackwardMng* getBackwardMng() const override { return m_backward_mng; }
 
  void goBackward() override;
  bool isDoingBackward() override;
  void setBackwardSavePeriod(Integer n) override
  {
    if (!m_backward_mng)
      _createOwnDefaultBackwardMng();
    m_backward_mng->setSavePeriod(n);
  }
 
  void setVerificationActive(bool is_active) override { m_verification_active = is_active; }
  void doVerification(const String& name) override;
 
  void registerActionMeshPartition(IMeshPartitionerBase* mesh_partitioner) override;
 
  void timeLoopsName(StringCollection& names) const override;
  void timeLoops(TimeLoopCollection& time_loops) const override;
  ITimeLoop* createTimeLoop(const String& name) override;
 
  int doComputeLoop(Integer max_loop) override;
  Integer nbLoop() const override { return m_nb_loop; }
 
  void setStopReason(eTimeLoopStopReason reason) override;
  eTimeLoopStopReason stopReason() const override { return m_stop_reason; }
 
 public:
 
  void execRestoreEntryPoints();
  void execOnMeshChangedEntryPoints() override;
  void execOnMeshRefinementEntryPoints() override;
 
  ITraceMng* traceMng() { return m_sub_domain->traceMng(); }
 
  IObservable* observable(eTimeLoopEventType type) override
  {
    return m_observables[type];
  }
 
 protected:

  void _addExecuteEntryPoint(IEntryPoint*);
  bool _createModule(const String& module_name);

  void _processEntryPoints(EntryPointList& entry_points,
                           const TimeLoopEntryPointInfoCollection& entry_points_info,
                           const char* where);
  void _fillModuleStateMap(ITimeLoop* time_loop);

  static void _extractModuleAndEntryPointName(const String& timeloop_call_name,
                                              String& module_name, String& entry_point_name);
 
 private:

  ISubDomain* m_sub_domain;

  IEntryPointMng* m_entry_point_mng;

  ModuleList m_list_execute_module;

  EntryPointList m_build_entry_points;

  EntryPointList m_loop_entry_points;

  EntryPointList m_init_entry_points;

  EntryPointList m_exit_entry_points;

  EntryPointList m_restore_entry_points;

  EntryPointList m_on_mesh_changed_entry_points;

  EntryPointList m_on_mesh_refinement_entry_points;

  EntryPointList m_used_time_loop_entry_points;

  TimeLoopMap m_time_loop_list;
 
  ITimeLoop* m_default_time_loop; 
 
  ITimeLoop* m_used_time_loop; 
 
  IEntryPoint* m_current_entry_point_ptr; 
 
  bool m_stop_time_loop;
  bool m_stop_has_error;
  bool m_final_time_reached;
 
  Integer m_current_entry_point; 
 
  eVerifType m_verif_type; 
  bool m_verif_same_parallel;
  String m_verif_path; 
  bool m_verification_active;
  bool m_verification_at_entry_point;
  bool m_verification_only_at_exit = false;
  eVariableComparerComputeDifferenceMethod m_compute_diff_method = eVariableComparerComputeDifferenceMethod::Relative;
 
  IBackwardMng* m_backward_mng; 
  bool m_my_own_backward_mng;
 
  ModuleStateMap m_module_state_list; 
 
  ModuleFactoryMap m_module_factory_map; 
  ModuleFactoryMap m_lang_module_factory_map; 
 
  Ref<IVerifierService> m_verifier_service;
  UniqueArray<IMeshPartitionerBase*> m_mesh_partitioner;
  String m_message_class_name;
  Integer m_alarm_timer_value;
  Integer m_nb_loop;
 
  ObservablePool<eTimeLoopEventType> m_observables;
 
  eTimeLoopStopReason m_stop_reason;
 
  // Message passing profiling service
  Ref<IMessagePassingProfilingService> m_msg_pass_prof_srv;

  String m_specific_entry_point_name;
 
 private:
 
  void _execOneEntryPoint(IEntryPoint* ic, Integer index_value = 0, bool do_verif = false);
  void _dumpTimeInfos(JSONWriter& json_writer);
  void _resetTimer() const;
  void _checkVerif(const String& entry_point_name, Integer index, bool do_verif);
  void _checkVerifSameOnAllReplica(const String& entry_point_name);
  void _createOwnDefaultBackwardMng();
  void _doMeshPartition();
  void _fillModuleFactoryMap();
  void _createSingletonServices(IServiceLoader* service_loader);
  void _callSpecificEntryPoint();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
extern "C++" ITimeLoopMng*
arcaneCreateTimeLoopMng(ISubDomain* mng)
{
  auto* tm = new TimeLoopMng(mng);
  return tm;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
TimeLoopMng::
TimeLoopMng(ISubDomain* sd)
: TraceAccessor(sd->traceMng())
, m_sub_domain(sd)
, m_entry_point_mng(m_sub_domain->entryPointMng())
, m_default_time_loop(nullptr)
, m_used_time_loop(nullptr)
, m_current_entry_point_ptr(nullptr)
, m_stop_time_loop(false)
, m_stop_has_error(false)
, m_final_time_reached(false)
, m_current_entry_point(0)
, m_verif_type(VerifNone)
, m_verif_same_parallel(false)
, m_verif_path(".")
, m_verification_active(false)
, m_verification_at_entry_point(false)
, m_backward_mng(nullptr)
, m_my_own_backward_mng(false)
, m_message_class_name("TimeLoopMng")
, m_alarm_timer_value(0)
, m_nb_loop(0)
, m_stop_reason(eTimeLoopStopReason::NoStop)
{
  {
    String s = platform::getEnvironmentVariable("ARCANE_LISTENER_TIMEOUT");
    if (!s.null()) {
      Integer v = 0;
      if (!builtInGetValue(v, s))
        if (v > 0)
          m_alarm_timer_value = v;
    }
  }
  {
    String s = platform::getEnvironmentVariable("ARCANE_VERIF_PARALLEL");
    if (!s.null())
      m_verif_same_parallel = true;
  }
 
  m_observables.add(eTimeLoopEventType::BeginEntryPoint);
  m_observables.add(eTimeLoopEventType::EndEntryPoint);
  m_observables.add(eTimeLoopEventType::BeginIteration);
  m_observables.add(eTimeLoopEventType::EndIteration);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
TimeLoopMng::
~TimeLoopMng()
{
  for (ConstIterT<TimeLoopMap> i(m_time_loop_list); i(); ++i) {
    ITimeLoop* tm = i->second;
    delete tm;
  }
 
  if (m_my_own_backward_mng)
    delete m_backward_mng;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
build()
{
  // Creates and registers a default loop.
  ITimeLoop* tm = createTimeLoop(String("ArcaneEmptyLoop"));
  m_default_time_loop = tm;
  registerTimeLoop(tm);
 
  {
    String verif_env = platform::getEnvironmentVariable("STDENV_VERIF");
    if (verif_env == "READ") {
      m_verif_type = VerifRead;
      info() << "Checking in read mode";
    }
    if (verif_env == "WRITE") {
      m_verif_type = VerifWrite;
      info() << "Checking in write mode";
    }
    if (verif_env == "CHECKSYNC") {
      m_verif_type = VerifSync;
      info() << "Checking synchronizations";
    }
    if (verif_env == "CHECKREPLICA") {
      m_verif_type = VerifSameReplica;
      info() << "Checking variables values between replica";
    }
    if (m_verif_type != VerifNone)
      m_verification_active = true;
  }
 
  {
    String s = platform::getEnvironmentVariable("STDENV_VERIF_DIFF_METHOD");
    if (!s.null()) {
      if (s == "RELATIVE") {
        m_compute_diff_method = eVariableComparerComputeDifferenceMethod::Relative;
        info() << "Using 'Relative' method to compute difference of variable values";
      }
      if (s == "LOCALNORMMAX") {
        m_compute_diff_method = eVariableComparerComputeDifferenceMethod::LocalNormMax;
        info() << "Using 'LocalNormMax' method to compute difference of variable values";
      }
    }
  }
  {
    String s = platform::getEnvironmentVariable("STDENV_VERIF_ENTRYPOINT");
    if (!s.null()) {
      m_verification_at_entry_point = true;
      info() << "Do verification at each entry point";
    }
  }
  {
    String s = platform::getEnvironmentVariable("STDENV_VERIF_ONLY_AT_EXIT");
    if (s == "1" || s == "true" || s == "TRUE") {
      m_verification_only_at_exit = true;
      info() << "Do verification only at exit";
    }
  }
  // Checks if only a single entry point is executed instead of the time loop.
  // This is used only for tests
  {
    String s = platform::getEnvironmentVariable("ARCANE_CALL_SPECIFIC_ENTRY_POINT");
    if (!s.null()) {
      m_specific_entry_point_name = s;
      info() << "Use specific entry point: " << s;
    }
  }
 
  //
  if (m_verification_active) {
    m_verif_path = platform::getEnvironmentVariable("STDENV_VERIF_PATH");
    if (m_verif_path.null()) {
      String user_name = subDomain()->application()->userName();
      m_verif_path = "/tmp/" + user_name + "/verif";
      //m_verif_path += user_name;
      //m_verif_path += "/verif";
    }
  }
  if (m_verif_type == VerifWrite) {
    if (subDomain()->parallelMng()->isMasterIO()) {
      info() << "Creating directory '" << m_verif_path << "' for checking";
      platform::recursiveCreateDirectory(m_verif_path);
    }
  }
 
  // Creation of the "message passing profiling" service if necessary
  {
    String msg_pass_prof_str = platform::getEnvironmentVariable("ARCANE_MESSAGE_PASSING_PROFILING");
    if (!msg_pass_prof_str.null()) {
      String service_name;
      // TODO: do not use if statements but use the name specified by the
      // environment variable directly.
      if (msg_pass_prof_str == "JSON") {
        service_name = "JsonMessagePassingProfiling";
      }
      else if (msg_pass_prof_str == "OTF2") {
        service_name = "Otf2MessagePassingProfiling";
      }
      ServiceBuilder<IMessagePassingProfilingService> srv(this->subDomain());
      m_msg_pass_prof_srv = srv.createReference(service_name, SB_AllowNull);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_createOwnDefaultBackwardMng()
{
  m_backward_mng = new DefaultBackwardMng(traceMng(), subDomain());
  m_backward_mng->init();
  m_my_own_backward_mng = true;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
setBackwardMng(IBackwardMng* backward_mng)
{
  ARCANE_ASSERT((backward_mng), ("IBackwardMng pointer null"));
 
  if (m_backward_mng) {
    // Destroys the old manager if we created it.
    if (m_my_own_backward_mng)
      delete m_backward_mng;
    ARCANE_FATAL("Backward manager already set");
  }
 
  m_backward_mng = backward_mng;
  m_my_own_backward_mng = false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
execInitEntryPoints(bool is_continue)
{
  Timer::Action ts_action(m_sub_domain, "InitEntryPoints");
  info() << "-- Executing init entry points";
 
  String where = (is_continue) ? IEntryPoint::WContinueInit : IEntryPoint::WStartInit;
 
  for (EntryPointList::Enumerator i(m_init_entry_points); ++i;) {
    IEntryPoint* ic = *i;
    if (ic->where() == IEntryPoint::WInit || ic->where() == where)
      _execOneEntryPoint(ic);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
execBuildEntryPoints()
{
  Timer::Action ts_action(m_sub_domain, "BuildtEntryPoints");
  info() << "-- Executing build entry points";
 
  for (EntryPointList::Enumerator i(m_build_entry_points); ++i;) {
    IEntryPoint* ic = *i;
    if (ic->where() == IEntryPoint::WBuild)
      _execOneEntryPoint(ic);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
execRestoreEntryPoints()
{
  Timer::Action ts_action(m_sub_domain, "RestoreEntryPoints");
  info() << "-- Executing restore entry points";
 
  for (EntryPointList::Enumerator i(m_restore_entry_points); ++i;) {
    IEntryPoint* ic = *i;
    _execOneEntryPoint(ic);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
execOnMeshChangedEntryPoints()
{
  Timer::Action ts_action(m_sub_domain, "OnMeshChangedEntryPoints");
  info() << "-- Executing entry points after mesh change";
 
  for (EntryPointList::Enumerator i(m_on_mesh_changed_entry_points); ++i;) {
    IEntryPoint* ic = *i;
    info() << "Execute: " << ic->name();
    _execOneEntryPoint(ic);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
execOnMeshRefinementEntryPoints()
{
  Timer::Action ts_action(m_sub_domain, "OnMeshRefinementEntryPoints");
  info() << "-- Executing entry points after mesh refinement";
 
  for (EntryPointList::Enumerator i(m_on_mesh_refinement_entry_points); ++i;) {
    IEntryPoint* ic = *i;
    info() << "Execute: " << ic->name();
    _execOneEntryPoint(ic);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
execExitEntryPoints()
{
  Timer::Action ts_action(m_sub_domain, "ExitEntryPoints");
  info() << "-- Executing terminal entry points";
 
  for (EntryPointList::Enumerator i(m_exit_entry_points); ++i;) {
    IEntryPoint* ic = *i;
    _execOneEntryPoint(ic);
  }
 
  // Display execution statistics
  {
    JSONWriter json_writer(JSONWriter::FormatFlags::None);
    json_writer.beginObject();
    _dumpTimeInfos(json_writer);
    json_writer.endObject();
    traceMng()->plog() << "TimeStats:" << json_writer.getBuffer();
    traceMng()->flush();
  }
 
  // Displays message passing profiling in a file for JSON traces
  if (m_msg_pass_prof_srv.get() && m_msg_pass_prof_srv->implName() == "JsonMessagePassingProfiling") {
    String fullname(subDomain()->listingDirectory().file("message_passing_logs.") + String(std::to_string(subDomain()->subDomainId())) + String(".json"));
    std::ofstream file(fullname.localstr());
    m_msg_pass_prof_srv->printInfos(file);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_execOneEntryPoint(IEntryPoint* ic, Integer index, bool do_verif)
{
  m_current_entry_point_ptr = ic;
  m_observables[eTimeLoopEventType::BeginEntryPoint]->notifyAllObservers();
  ic->executeEntryPoint();
  m_observables[eTimeLoopEventType::EndEntryPoint]->notifyAllObservers();
  m_current_entry_point_ptr = nullptr;
  if (m_verification_at_entry_point && !m_verification_only_at_exit)
    _checkVerif(ic->name(), index, do_verif);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
doVerification(const String& name)
{
  _checkVerif(name, 0, true);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_checkVerif(const String& entry_point_name, Integer index, bool do_verif)
{
  IParallelMng* pm = subDomain()->parallelMng();
 
  ISubDomain* sd = subDomain();
  IApplication* app = sd->application();
  VariableComparer variable_comparer;
  VariableComparerArgs sync_compare_args = variable_comparer.buildForCheckIfSync();
  sync_compare_args.setMaxPrint(5);
 
  if ((m_verif_type == VerifRead || m_verif_type == VerifWrite) && !m_verifier_service.get()) {
    String service_name1 = platform::getEnvironmentVariable("STDENV_VERIF_SERVICE");
    if (service_name1.empty())
      service_name1 = "ArcaneBasicVerifier2";
 
    ServiceFinder2T<IVerifierService, ISubDomain> sf(app, sd);
    m_verifier_service = sf.createReference(service_name1);
    if (!m_verifier_service.get()) {
      warning() << "No verification service is available."
                << " No verification will be performed";
      m_verif_type = VerifNone;
    }
    if (m_verifier_service.get()) {
      info() << "Use the service <" << service_name1
             << "> for verification";
    }
  }
 
  if (pm->isParallel()) {
    if (m_verif_type == VerifSync) {
      Integer nb_error = 0;
      VariableCollection variables(subDomain()->variableMng()->usedVariables());
      for (VariableCollection::Enumerator i(variables); ++i;) {
        IVariable* var = *i;
        if (var->property() & IVariable::PNoNeedSync)
          continue;
        if (var->isPartial())
          continue;
        VariableComparerResults r = variable_comparer.apply(var, sync_compare_args);
        nb_error += r.nbDifference();
      }
      if (nb_error != 0)
        info() << "Error in synchronization nb_error=" << nb_error
               << " entry_point=" << entry_point_name;
    }
  }
 
  if (m_verif_type == VerifSameReplica && pm->replication()->hasReplication()) {
    _checkVerifSameOnAllReplica(entry_point_name);
  }
 
  if ((m_verif_type == VerifRead || m_verif_type == VerifWrite) && do_verif) {
    Integer current_iter = subDomain()->commonVariables().globalIteration();
    if (current_iter >= 0) {
      {
        StringBuilder path = Directory(m_verif_path).file("verif_file");
        if (m_verif_same_parallel) {
          path += "_";
          path += pm->commRank();
        }
 
        StringBuilder sub_dir;
        sub_dir += "iter";
        sub_dir += current_iter;
        sub_dir += "/";
        sub_dir += entry_point_name;
        sub_dir += index;
 
        m_verifier_service->setFileName(path.toString());
        m_verifier_service->setSubDir(sub_dir.toString());
        m_verifier_service->setComputeDifferenceMethod(m_compute_diff_method);
      }
      bool parallel_sequential = pm->isParallel();
      if (m_verif_same_parallel)
        parallel_sequential = false;
      if (m_verif_type == VerifRead) {
 
        // Activate this part if we want to save the current values
#if 0
        {
          ServiceFinder2T<IVerifierService,ISubDomain> sf(app,sd);
          ScopedPtrT<IVerifierService> current_save(sf.find(service_name1));
          if (current_save.get()){
            current_save->setFileName(m_verifier_service->fileName()+"_current");
            current_save->setSubDir(m_verifier_service->subDir());
            current_save->writeReferenceFile();
          }
        }
#endif
 
        // In read mode, disable floating point exceptions to avoid
        // errors when comparing uninitialized variables
        {
          FloatingPointExceptionSentry fpes(false);
          m_verifier_service->doVerifFromReferenceFile(parallel_sequential,
                                                       platform::getEnvironmentVariable("STDENV_VERIF_SKIP_GHOSTS").null());
        }
      }
      if (m_verif_type == VerifWrite)
        m_verifier_service->writeReferenceFile();
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_checkVerifSameOnAllReplica(const String& entry_point_name)
{
  info() << "CHECK: comparing variables values on all replica"
         << " entry_point_name=" << entry_point_name;
  ISubDomain* sd = subDomain();
  IParallelMng* replica_pm = sd->parallelMng()->replication()->replicaParallelMng();
  IVariableMng* vm = sd->variableMng();
  VariableCollection variables(vm->usedVariables());
  VariableList vars_to_check;
  for (VariableCollection::Enumerator i(variables); ++i;) {
    IVariable* var = *i;
    if (var->property() & IVariable::PNoReplicaSync)
      continue;
    if (var->isPartial())
      continue;
    // For now, we do not support comparison between replicas
    // of 'String' type variables.
    if (var->dataType() == DT_String)
      continue;
    vars_to_check.add(var);
  }
  VariableCollection common_vars = vm->utilities()->filterCommonVariables(replica_pm, vars_to_check, true);
 
  Integer nb_error = 0;
  VariableComparer variable_comparer;
  {
    VariableComparerArgs compare_args = variable_comparer.buildForCheckIfSameOnAllReplica();
    compare_args.setMaxPrint(10);
    FloatingPointExceptionSentry fpes(false);
    for (VariableCollection::Enumerator ivar(common_vars); ++ivar;) {
      IVariable* var = *ivar;
      VariableComparerResults r = variable_comparer.apply(var, compare_args);
      nb_error += r.nbDifference();
    }
  }
 
  if (nb_error != 0)
    info() << "Errors in comparing values between replica nb_error=" << nb_error
           << " entry_point=" << entry_point_name;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void TimeLoopMng::
doExecNextEntryPoint(bool& is_last)
{
  if (!m_used_time_loop)
    ARCANE_FATAL("No time loop");
 
  is_last = true;
 
  const EntryPointList& cl = m_loop_entry_points;
 
  if (cl.empty())
    return;
 
  if (m_current_entry_point >= cl.count())
    m_current_entry_point = 0;
 
  _execOneEntryPoint(cl[m_current_entry_point]);
 
  ++m_current_entry_point;
 
  is_last = (m_current_entry_point >= cl.count());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

IEntryPoint* TimeLoopMng::
nextEntryPoint()
{
  //return m_loop_entry_points->EntryPointList()[m_current_entry_point];
  const EntryPointList& cl = m_loop_entry_points;
  if (m_current_entry_point >= cl.count())
    return nullptr;
  return cl[m_current_entry_point];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
int TimeLoopMng::
doOneIteration()
{
  ITraceMng* msg = traceMng();
  ISubDomain* sd = subDomain();
  Trace::Setter mci(msg, m_message_class_name);
 
  if (!m_used_time_loop)
    ARCANE_FATAL("No time loop");
 
  Integer current_iteration = sd->commonVariables().globalIteration();
  // Iteration number 0 corresponds to initialization. The first
  // iteration of the time loop is number 1.
  if (current_iteration == 0) {
    VariableScalarInteger global_iteration(sd->commonVariables().m_global_iteration);
    global_iteration = 1;
    current_iteration = 1;
  }
 
  _resetTimer();
 
  if (m_stop_time_loop) {
    if (m_stop_has_error)
      return (-1);
    return (+1);
  }
 
  m_backward_mng->beginAction();
 
  // Restoration action
  if (m_backward_mng->checkAndApplyRestore()) {
 
    execRestoreEntryPoints();
 
    // Unnecessary partitioning if going backward
    m_mesh_partitioner.clear();
  }
 
  // Requested partitioning
  bool mesh_partition_done = false;
  if (!m_mesh_partitioner.empty()) {
    _doMeshPartition();
    mesh_partition_done = true;
  }
 
  // Saving action
  m_backward_mng->checkAndApplySave(mesh_partition_done);
 
  m_backward_mng->endAction();
 
  {
    // Checks modules that are inactive over time
    Real global_time = sd->commonVariables().globalTime();
    CaseOptionsCollection blocks(sd->caseMng()->blocks());
    for (CaseOptionsCollection::Enumerator i(blocks); ++i;) {
      ICaseOptions* opt = *i;
      IModule* mod = opt->caseModule();
      ICaseFunction* f = opt->activateFunction();
      if (mod && f) {
        bool is_active = true;
        f->value(global_time, is_active);
        bool mod_disabled = mod->disabled();
        bool mod_new_disabled = !is_active;
        if (mod_new_disabled != mod_disabled) {
          if (mod_new_disabled)
            info() << "The module " << mod->name() << " is desactivated";
          else
            info() << "The module " << mod->name() << " is activated";
          mod->setDisabled(mod_new_disabled);
        }
      }
    }
  }
 
  m_observables[eTimeLoopEventType::BeginIteration]->notifyAllObservers();
 
  // Executes each iteration entry point
  {
    Integer index = 0;
    sd->timeStats()->notifyNewIterationLoop();
    Timer::Action ts_action(sd, "LoopEntryPoints");
    for (EntryPointList::Enumerator i(m_loop_entry_points); ++i; ++index) {
      IEntryPoint* ep = *i;
      IModule* mod = ep->module();
      if (mod && mod->disabled()) {
        continue;
        //warning() << "MODULE " << mod->name() << " is disabled";
      }
      try {
        _execOneEntryPoint(*i, index, true);
      }
      catch (const GoBackwardException&) {
        m_backward_mng->goBackward();
      }
      catch (...) { // Catch any other exception
        throw;
      }
      if (m_backward_mng->isBackwardEnabled()) {
        break;
      }
    }
    if (!m_verification_at_entry_point && !m_verification_only_at_exit)
      _checkVerif("_EndLoop", 0, true);
  }
  m_observables[eTimeLoopEventType::EndIteration]->notifyAllObservers();
 
  {
    bool force_prepare_dump = false;
    if (m_verification_active && m_verif_type == VerifWrite) {
      if (!m_verif_same_parallel)
        force_prepare_dump = true;
    }
    else {
      String force_prepare_dump_str = platform::getEnvironmentVariable("ARCANE_FORCE_PREPARE_DUMP");
      if (force_prepare_dump_str == "TRUE" || force_prepare_dump_str == "1" || force_prepare_dump_str == "true")
        force_prepare_dump = true;
    }
    if (force_prepare_dump) {
      info() << "TimeLoopMng::doOneIteration(): Force prepareDump()";
      // TODO: check if necessary and if so, do it for all sub-domains.
      sd->defaultMesh()->prepareForDump();
    }
  }
 
  if (m_stop_time_loop) {
    if (m_stop_has_error)
      return (-1);
    return (+1);
  }
  return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void TimeLoopMng::
_doMeshPartition()
{
  ISubDomain* sd = subDomain();
 
  // Destroys the backward manager to save memory.
  // It will be reconstructed after partitioning.
  m_backward_mng->clear();
 
  Timer timer(sd, "TimeLoopMng::partitionMesh", Timer::TimerReal);
  Timer::Action ts_action(sd, "MeshesLoadBalance", true);
 
  for (IMeshPartitionerBase* mesh_partitioner : m_mesh_partitioner) {
    IMesh* mesh = mesh_partitioner->primaryMesh();
    Timer::Action ts_action2(sd, mesh->name(), true);
    {
      Timer::Sentry sentry(&timer);
      mesh->utilities()->partitionAndExchangeMeshWithReplication(mesh_partitioner, false);
    }
    info() << "Time spent to repartition the mesh (unit: second): "
           << timer.lastActivationTime();
 
    // Writes to logs in the infos about neighborhood distribution
    // TODO: ability to configure this and possibly add more information
    {
      IItemFamily* cell_family = mesh->cellFamily();
      IVariableSynchronizer* sync_info = cell_family->allItemsSynchronizer();
      auto communicating_ranks = sync_info->communicatingRanks();
      Int64 current_iteration = subDomain()->commonVariables().globalIteration();
      {
        JSONWriter json_writer(JSONWriter::FormatFlags::None);
        json_writer.beginObject();
        json_writer.write("Mesh", mesh->name());
        json_writer.write("Iteration", current_iteration);
        json_writer.write("CommunicatingRanks", communicating_ranks);
        json_writer.endObject();
        plog() << "MeshPartitionCommunicatingInfos:" << json_writer.getBuffer();
      }
    }
  }
 
  {
    Timer::Action ts_action1(sd, "OnMeshChangeEntryPoints", true);
    execOnMeshChangedEntryPoints();
  }
 
  m_mesh_partitioner.clear();
 
  // Displays execution statistics
  sd->timeStats()->dumpCurrentStats("MeshesLoadBalance");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_callSpecificEntryPoint()
{
  IEntryPoint* ep = m_entry_point_mng->findEntryPoint(m_specific_entry_point_name);
  info() << "Calling specific entry point: " << m_specific_entry_point_name;
  if (!ep)
    ARCANE_FATAL("No entry point named '{0}' found", m_specific_entry_point_name);
  ep->executeEntryPoint();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
registerTimeLoop(ITimeLoop* timeloop)
{
  ITraceMng* msg = traceMng();
  Trace::Setter mci(msg, m_message_class_name);
 
  const String& name = timeloop->name();
 
  log() << "Registering the time loop " << name;
 
  auto tl = m_time_loop_list.find(name);
  if (tl != m_time_loop_list.end())
    ARCANE_FATAL("The time loop '{0}' is defined twice", name);
 
  m_time_loop_list.insert(TimeLoopMap::value_type(name, timeloop));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
setUsedTimeLoop(const String& name)
{
  ITraceMng* msg = traceMng();
  Trace::Setter mci(msg, m_message_class_name);
 
  m_used_time_loop = nullptr;
  if (name.null())
    m_used_time_loop = m_default_time_loop;
  else {
    auto tl = m_time_loop_list.find(name);
    if (tl != m_time_loop_list.end())
      m_used_time_loop = tl->second;
  }
 
  if (!m_used_time_loop) {
    info() << "Available time loops: ";
    for (const auto& tl : m_time_loop_list) {
      info() << "Time loop <" << tl.second->name() << ">";
    }
    ARCANE_FATAL("Unknown time loop '{0}'", name);
  }
 
  logdate() << "Using time loop " << name;
 
  ISubDomain* sd = m_sub_domain;
  // Merges the sub-domain configuration with that of the time loop.
  sd->configuration()->merge(m_used_time_loop->configuration());
 
  ScopedPtrT<IServiceLoader> service_loader(sd->mainFactory()->createServiceLoader());
 
  service_loader->loadModules(sd, false);
 
  _fillModuleFactoryMap();
 
  // Loading modules of the time loop
  _fillModuleStateMap(m_used_time_loop);
 
  for (const auto& it : m_module_state_list) {
    const ModuleState& module_state = it.second;
 
    if (!module_state.m_is_optional || module_state.m_is_active) {
      // creation of the module
      if (!_createModule(module_state.m_alias))
        ARCANE_FATAL("The module \"{0}\" was not created.", module_state.m_alias);
    }
    else {
      info() << "The entry points of the module \""
             << module_state.m_alias << "\" won't be executed (inactive module).";
    }
  }
 
  _createSingletonServices(service_loader.get());
 
  m_used_time_loop_entry_points.clear();
 
  // Iterates over entry points explicitly referenced in the time loop
  // (m_used_time_loop) to search for those that correspond to entry points
  // registered in the modules
  // Entry points that are not auto-loaded and not referenced are therefore not supported.
  // Note: in the time loop entry points are referenced
  // by module_name.entry_point_name while in the data file
  // they are referenced by alias_module.entry_point_name
  EntryPointList timeloop_entry_points;
  _processEntryPoints(timeloop_entry_points,
                      m_used_time_loop->entryPoints(ITimeLoop::WBuild),
                      ITimeLoop::WBuild);
  _processEntryPoints(timeloop_entry_points,
                      m_used_time_loop->entryPoints(ITimeLoop::WComputeLoop),
                      ITimeLoop::WComputeLoop);
  _processEntryPoints(timeloop_entry_points,
                      m_used_time_loop->entryPoints(ITimeLoop::WRestore),
                      ITimeLoop::WRestore);
  _processEntryPoints(timeloop_entry_points,
                      m_used_time_loop->entryPoints(ITimeLoop::WOnMeshChanged),
                      ITimeLoop::WOnMeshChanged);
  _processEntryPoints(timeloop_entry_points,
                      m_used_time_loop->entryPoints(ITimeLoop::WOnMeshRefinement),
                      ITimeLoop::WOnMeshRefinement);
  _processEntryPoints(timeloop_entry_points,
                      m_used_time_loop->entryPoints(ITimeLoop::WInit),
                      ITimeLoop::WInit);
  _processEntryPoints(timeloop_entry_points,
                      m_used_time_loop->entryPoints(ITimeLoop::WExit),
                      ITimeLoop::WExit);
 
  // Adds autoloads at the beginning.
  EntryPointList entry_points(m_entry_point_mng->entryPoints());
  for (EntryPointCollection::Enumerator i(entry_points); ++i;) {
    IEntryPoint* ic = *i;
    if (ic->property() & IEntryPoint::PAutoLoadBegin)
      _addExecuteEntryPoint(ic);
  }
 
  // Adds compute loop entry points.
  for (EntryPointCollection::Enumerator i(timeloop_entry_points); ++i;)
    _addExecuteEntryPoint(*i);
 
  { // Adds autoloads at the end in reverse order of declaration
    EntryPointList auto_load_ends;
    for (EntryPointCollection::Enumerator i(entry_points); ++i;) {
      IEntryPoint* ic = *i;
      if (ic->property() & IEntryPoint::PAutoLoadEnd) {
        auto_load_ends.add(ic);
      }
    }
    for (Integer i = 0, s = auto_load_ends.count(); i < s; ++i) {
      IEntryPoint* ic = auto_load_ends[s - 1 - i];
      _addExecuteEntryPoint(ic);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_createSingletonServices(IServiceLoader* service_loader)
{
  ISubDomain* sd = m_sub_domain;
  for (TimeLoopSingletonServiceInfoCollection::Enumerator i(m_used_time_loop->singletonServices()); ++i;) {
    const TimeLoopSingletonServiceInfo& ti = *i;
    String name = ti.name();
    bool is_found = service_loader->loadSingletonService(sd, name);
    if (!is_found) {
      if (ti.isRequired())
        ARCANE_FATAL("Unable to find a singleton service named '{0}'", name);
      info() << "The optional singleton service named '" << name << "' was not found";
    }
    info() << "Loading singleton service '" << name << "'";
  }
 
  // Reading services specified in the data set.
  ICaseMng* cm = m_sub_domain->caseMng();
  ICaseDocument* doc = cm->caseDocument();
  if (doc) {
    XmlNode services_element = doc->servicesElement();
    String ustr_name("name");
    String ustr_active("active");
    XmlNodeList services = services_element.children("service");
    for (XmlNode x : services) {
      String name = x.attrValue(ustr_name);
      XmlNode active_node = x.attr(ustr_active);
      bool is_active = true;
      if (!active_node.null())
        is_active = active_node.valueAsBoolean(true);
      if (is_active)
        service_loader->loadSingletonService(sd, name);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_processEntryPoints(EntryPointList& entry_points,
                    const TimeLoopEntryPointInfoCollection& entry_points_info,
                    const char* where)
{
  //TODO: Verify that the module name specified in the list of modules to
  //activate actually exists.
  for (TimeLoopEntryPointInfoCollection::Enumerator i(entry_points_info); ++i;) {
    const TimeLoopEntryPointInfo& entry_point_info = *i;
    const String& timeloop_call_name = entry_point_info.name();
    String entry_point_name;
    String module_name;
    _extractModuleAndEntryPointName(timeloop_call_name, module_name, entry_point_name);
 
    auto it = m_module_state_list.find(module_name);
    if (it == m_module_state_list.end())
      ARCANE_FATAL("No module named '{0}' is referenced", module_name);
 
    const ModuleState& module_state = it->second;
    if (!module_state.m_is_optional || module_state.m_is_active) {
      if (!module_state.m_alias.null())
        module_name = module_state.m_alias;
      StringBuilder call_alias(module_name);
      call_alias += ".";
      call_alias += entry_point_name;
 
      IEntryPoint* entry_point = m_entry_point_mng->findEntryPoint(module_name, entry_point_name);
      log() << "Looking for entry point '" << call_alias << "'";
      if (!entry_point)
        ARCANE_FATAL("No entry point named '{0}' is referenced", call_alias);
 
      // it is necessary to verify that the "where" property of the entry point is
      // compatible with the "where" attribute given in the time loop
      String ep_where = entry_point->where();
      OStringStream msg;
      msg() << "The entry point '" << call_alias << "' declared \"" << ep_where
            << "\" can't be in the entry point list \""
            << where << "\" of the time loop";
 
      if (ep_where == IEntryPoint::WComputeLoop && where != ITimeLoop::WComputeLoop)
        ARCANE_FATAL(msg.str());
      if (ep_where == IEntryPoint::WRestore && where != ITimeLoop::WRestore)
        ARCANE_FATAL(msg.str());
      if (ep_where == IEntryPoint::WExit && where != ITimeLoop::WExit)
        ARCANE_FATAL(msg.str());
      if ((ep_where == IEntryPoint::WInit ||
           ep_where == IEntryPoint::WContinueInit ||
           ep_where == IEntryPoint::WStartInit) &&
          where != ITimeLoop::WInit)
        ARCANE_FATAL(msg.str());
 
      entry_points.add(entry_point);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_fillModuleStateMap(ITimeLoop* time_loop)
{
  // Analyzes the time loop information
  //   1. list of required modules
  for (StringCollection::Enumerator i(time_loop->requiredModulesName()); ++i;) {
    const String& module_name = *i;
    ModuleState ms(false, module_name);
    m_module_state_list.insert(ModuleStateMap::value_type(module_name, ms));
  }
 
  //   2. list of optional modules
  for (StringCollection::Enumerator i(time_loop->optionalModulesName()); ++i;) {
    const String& module_name = *i;
    ModuleState ms(true, module_name);
    m_module_state_list.insert(ModuleStateMap::value_type(module_name, ms));
  }
 
  ICaseMng* cm = m_sub_domain->caseMng();
  // Filling the module state list from
  // the data file information if it exists
  // (There is no data set for example when generating internal infos
  // of the code via the option 'arcane_all_internal').
  ICaseDocument* doc = cm->caseDocument();
  if (!doc)
    return;
 
  XmlNode modules_node = doc->modulesElement();
  String ustr_module("module");
  String ustr_false("false");
  String ustr_name("name");
  String ustr_alias("alias");
  String ustr_active("active");
  for (XmlNode::const_iter i(modules_node); i(); ++i) {
    if (i->name() != ustr_module)
      continue;
    XmlNode module_node = *i;
    String name = module_node.attrValue(ustr_name);
    String alias = module_node.attrValue(ustr_alias);
 
    // Checks if the module is active.
    XmlNode active_node = module_node.attr(ustr_active);
    bool active = true;
    if (!active_node.null())
      active = active_node.valueAsBoolean(true);
 
    // Completes the module state list information
 
    // First checks if 'name' corresponds to a module name
    // in the language of the data file.
    auto ilang = m_lang_module_factory_map.find(name);
    if (ilang != m_lang_module_factory_map.end())
      name = ilang->second->moduleName();
 
    auto it = m_module_state_list.find(name);
    if (it == m_module_state_list.end())
      // Raises an exception if the module name specified in the data file
      // does not correspond to any registered module.
      ARCANE_FATAL("Error in configuring active modules: no module named '{0}' is registered.",
                   name);
 
    ModuleState& ms = it->second;
    ms.m_is_active = active;
    if (!alias.null())
      ms.m_alias = alias;
 
    if (!ms.m_is_optional && !ms.m_is_active) {
      pwarning() << "The module \"" << ms.m_alias
                 << "\" can't be declared mandatory in the time loop"
                 << " while being inactive in the input data."
                 << " Its activity is therefore forced. ";
      ms.m_is_active = true;
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_extractModuleAndEntryPointName(const String& timeloop_call_name,
                                String& module_name,
                                String& entry_point_name)
{
  std::string std_timeloop_call_name(timeloop_call_name.localstr());
  size_t index = std_timeloop_call_name.find_first_of('.');
  if (index == std::string::npos) {
    ARCANE_FATAL("The string '{0}' is not a valid reference to an entry point (has to be of type "
                 "'module_name.entry_point_name)",
                 timeloop_call_name);
  }
  std::string std_module_name = std_timeloop_call_name.substr(0, index);
  std::string std_entry_point_name = std_timeloop_call_name.substr(index + 1);
  module_name = std_module_name;
  entry_point_name = std_entry_point_name;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void TimeLoopMng::
_fillModuleFactoryMap()
{
  String lang;
  ICaseDocumentFragment* doc = m_sub_domain->caseMng()->caseDocumentFragment();
  if (doc)
    lang = doc->language();
  ModuleFactoryInfoCollection module_factories(subDomain()->application()->moduleFactoryInfos());
  m_module_factory_map.clear();
  m_lang_module_factory_map.clear();
  for (ModuleFactoryInfoCollection::Enumerator i(module_factories); ++i;) {
    IModuleFactoryInfo* mfi = *i;
 
    const String& module_name = mfi->moduleName();
    if (m_module_factory_map.find(module_name) != m_module_factory_map.end())
      ARCANE_FATAL("Two modules with same name '{0}'", module_name);
    m_module_factory_map.insert(std::make_pair(module_name, mfi));
    info(5) << "Registering module in factory map name=" << module_name;
 
    if (!lang.null()) {
      const IServiceInfo* si = mfi->serviceInfo();
      String translated_name = si->tagName(lang);
      if (m_lang_module_factory_map.find(module_name) != m_lang_module_factory_map.end()) {
        // Just sends a warning because it will not necessarily cause a problem.
        warning() << "Two modules with same translated name=" << translated_name
                  << " ignoring name=" << module_name;
      }
      else {
        m_lang_module_factory_map.insert(std::make_pair(translated_name, mfi));
        info(5) << "Registering module in lang factory map name=" << translated_name;
      }
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool TimeLoopMng::
_createModule(const String& module_name)
{
  auto x = m_module_factory_map.find(module_name);
  if (x != m_module_factory_map.end()) {
    IModuleFactoryInfo* mfi = x->second;
    Ref<IModule> module = mfi->createModule(m_sub_domain, m_sub_domain->defaultMeshHandle());
    if (module.get()) {
      info() << "Loading module " << module->name()
             << " (Version " << module->versionInfo() << ")";
      return true;
    }
  }
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void TimeLoopMng::
_addExecuteEntryPoint(IEntryPoint* entry_point)
{
  log() << "Adding the entry point `" << entry_point->module()->name() << "::" << entry_point->name() << "' to the execution";
 
  String where = entry_point->where();
  if (where == IEntryPoint::WInit || where == IEntryPoint::WContinueInit || where == IEntryPoint::WStartInit) {
    m_init_entry_points.add(entry_point);
  }
  else if (where == IEntryPoint::WBuild) {
    m_build_entry_points.add(entry_point);
  }
  else if (where == IEntryPoint::WExit) {
    m_exit_entry_points.add(entry_point);
  }
  else if (where == IEntryPoint::WRestore) {
    m_restore_entry_points.add(entry_point);
  }
  else if (where == IEntryPoint::WOnMeshChanged) {
    m_on_mesh_changed_entry_points.add(entry_point);
  }
  else if (where == IEntryPoint::WOnMeshRefinement) {
    m_on_mesh_refinement_entry_points.add(entry_point);
  }
  else if (IEntryPoint::WComputeLoop) {
    m_loop_entry_points.add(entry_point);
    m_current_entry_point = m_loop_entry_points.count();
  }
  m_used_time_loop_entry_points.add(entry_point);
 
  // Since the module has a used entry point, it is activated.
  IModule* c = entry_point->module();
  c->setUsed(true);
  {
    if (std::find(m_list_execute_module.begin(), m_list_execute_module.end(), c) == m_list_execute_module.end()) {
      debug() << "Adding the module  `" << c->name() << "' to the execution";
      m_list_execute_module.add(c);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_dumpTimeInfos(JSONWriter& json_writer)
{
  IModuleMng* module_mng = subDomain()->moduleMng();
 
  EntryPointCollection entry_points = m_entry_point_mng->entryPoints();
 
  Real total_exec_time = cpuTimeUsed();
 
  {
    Real total_real_time = 0.0;
    Real compute_real_time = 0.0;
    json_writer.writeKey("EntryPoints");
    json_writer.beginArray();
    for (EntryPointCollection::Enumerator i(entry_points); ++i;) {
      IEntryPoint* ep = *i;
      Real s2 = ep->totalElapsedTime();
      {
        JSONWriter::Object jo(json_writer);
        json_writer.write("Name", ep->name());
        json_writer.write("TotalCpuTime", s2);
        json_writer.write("TotalElapsedTime", s2);
        json_writer.write("NbCall", (Int64)ep->nbCall());
        json_writer.write("Where", ep->where());
      }
      info(5) << "CPU_TIME where=" << ep->where() << " name=" << ep->name() << " S=" << s2;
      total_real_time += s2;
      if (ep->where() == IEntryPoint::WComputeLoop) {
        compute_real_time += s2;
      }
    }
    json_writer.endArray();
    info(4) << "TOTAL_REAL_TIME COMPUTE=" << compute_real_time << " TOTAL=" << total_real_time;
  }
 
  const CommonVariables& scv = subDomain()->commonVariables();
  info() << "Information on the execution time";
  {
    Accelerator::IAcceleratorMng* acc_mng = m_sub_domain->acceleratorMng();
    if (acc_mng->isInitialized()) {
      Accelerator::Runner* runner = acc_mng->defaultRunner();
      info() << " TotalRunner (" << runner->executionPolicy() << ") = "
             << runner->cumulativeCommandTime() << " seconds";
    }
  }
  info() << " TotalElapsed  = " << total_exec_time << " seconds";
  info() << " CumulativeElapsed = " << scv.globalElapsedTime()
         << " seconds (" << platform::timeToHourMinuteSecond(scv.globalElapsedTime()) << ")";
  info() << " T   = Total time spent in the function or in the module (s)";
  info() << " TC  = Total time spend per call (ms)";
  info() << " TCC = Total time spent per call and per cell (ns)";
  info() << " N   = Number of time the function was called";
 
  info() << " Use the clock time (elapsed) for the statistics";
 
  std::ostringstream o;
  std::ios_base::fmtflags f = o.flags(std::ios::right);
  Integer nb_cell = 0;
  IMesh* mesh = subDomain()->defaultMesh();
  if (mesh)
    nb_cell = mesh->nbCell();
  if (nb_cell == 0)
    nb_cell = 1;
 
  o << "\n              Name                            T        TC       TCC    %         N\n";
 
  for (ModuleCollection::Enumerator j(module_mng->modules()); ++j;) {
    IModule* module = *j;
    Real total_time_module = 0.;
    Real total_time_module_entry_point = 0.;
    for (EntryPointCollection::Enumerator i(entry_points); ++i;) {
      IEntryPoint* ic = *i;
      if (ic->module() != module)
        continue;
      Integer nb_call = ic->nbCall();
      if (nb_call == 0)
        continue;
      Real total_time = ic->totalElapsedTime();
      //if (math::isZero(total_time))
      //continue;
      const String& ep_name = ic->name();
      {
        Int64 l = ep_name.length();
        if (l > 36) {
          o.write(ep_name.localstr(), 34);
          o << "...";
        }
        else {
          o.width(37);
          o << ep_name;
        }
      }
      o.width(10);
      Int64 z = Convert::toInt64(total_time);
      o << z;
      Real r = (1e3 * total_time) / nb_call;
      if (ic->where() == IEntryPoint::WComputeLoop) {
        total_time_module += r;
        total_time_module_entry_point += total_time;
      }
      z = Convert::toInt64(r);
      o.width(10);
      o << z;
      r = (r * 1e6) / nb_cell;
      z = Convert::toInt64(r);
      o.width(10);
      o << z;
      //Problem on certain machines: total_exec_time = 0
      if (total_exec_time > 0)
        z = Convert::toInt64((100.0 * total_time) / total_exec_time);
      else
        z = Convert::toInt64((100.0 * total_time));
      o.width(5);
      o << z;
      o.width(12);
      o << nb_call;
      o << '\n';
    }
    o << "--";
    o.width(33);
    o << module->name();
    o << "--";
    o.width(10);
    Int64 z = Convert::toInt64(total_time_module_entry_point * 1e-3);
    o << z;
    o.width(10);
    z = Convert::toInt64(total_time_module);
    o << z;
    Real r = (total_time_module * 1e6) / nb_cell;
    z = Convert::toInt64(r);
    o.width(10);
    o << z;
    o << '\n';
  }
  o.flags(f);
 
  info() << o.str();
 
  {
    IParallelMng* pm = m_sub_domain->parallelMng();
    if (pm->isParallel()) {
      JSONWriter::Object jo(json_writer, "MessagePassingStats");
      Parallel::IStat* s = pm->stat();
      if (s) {
        s->printCollective(pm);
        s->dumpJSON(json_writer);
      }
    }
  }
  {
    JSONWriter::Object jo(json_writer, "VariablesStats");
    m_sub_domain->variableMng()->dumpStatsJSON(json_writer);
  }
  {
    JSONWriter::Object jo(json_writer, "TimeStats");
    m_sub_domain->timeStats()->dumpStatsJSON(json_writer);
  }
  {
    IProfilingService* ps = platform::getProfilingService();
    if (ps) {
      JSONWriter::Object jo(json_writer, "Profiling");
      ps->dumpJSON(json_writer);
    }
  }
 
  Item::dumpStats(traceMng());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real TimeLoopMng::
cpuTimeUsed() const
{
  EntryPointCollection entry_points = m_entry_point_mng->entryPoints();
  Real total_elapsed_time = 0.0;
  for (EntryPointCollection::Enumerator i(entry_points); ++i;) {
    Real s1 = (*i)->totalElapsedTime();
    total_elapsed_time += s1;
  }
  return total_elapsed_time;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool TimeLoopMng::
isDoingBackward()
{
  if (!m_backward_mng)
    _createOwnDefaultBackwardMng();
  return m_backward_mng->isLocked();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
goBackward()
{
  ITraceMng* msg = traceMng();
  Trace::Setter mci(msg, m_message_class_name);
 
  if (!m_backward_mng)
    _createOwnDefaultBackwardMng();
 
  m_backward_mng->goBackward();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
timeLoopsName(StringCollection& names) const
{
  for (ConstIterT<TimeLoopMap> i(m_time_loop_list); i(); ++i)
    names.add(i->first);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
timeLoops(TimeLoopCollection& time_loops) const
{
  for (ConstIterT<TimeLoopMap> i(m_time_loop_list); i(); ++i)
    time_loops.add(i->second);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ITimeLoop* TimeLoopMng::
createTimeLoop(const String& name)
{
  IApplication* sm = m_sub_domain->application();
  return sm->mainFactory()->createTimeLoop(sm, name);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
setStopReason(eTimeLoopStopReason reason)
{
  m_stop_reason = reason;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
stopComputeLoop(bool is_final_time, bool has_error)
{
  m_stop_time_loop = true;
  m_stop_has_error = has_error;
  if (is_final_time)
    m_final_time_reached = true;
  if (has_error)
    m_stop_reason = eTimeLoopStopReason::Error;
  else if (is_final_time)
    m_stop_reason = eTimeLoopStopReason::FinalTimeReached;
  // If m_stop_reason has not yet been specified, indicate that there is no
  // special reason
  if (m_stop_reason == eTimeLoopStopReason::NoStop)
    m_stop_reason = eTimeLoopStopReason::NoReason;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
registerActionMeshPartition(IMeshPartitionerBase* mesh_partitioner)
{
  if (!m_backward_mng)
    _createOwnDefaultBackwardMng();
 
  if (m_backward_mng->isLocked() || m_backward_mng->isBackwardEnabled()) {
    info() << "Repartioning required but inactive due to a backward process active";
    return;
  }
  m_mesh_partitioner.add(mesh_partitioner);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
int TimeLoopMng::
doComputeLoop(Integer max_loop)
{
  m_nb_loop = 0;
  bool is_end = false;
  bool is_end_by_max_loop = false;
  int ret_val = 0;
  //m_alarm_timer_value = 0;
  //pwarning() << "Force the alarm_timer_value to zero";
  if (m_alarm_timer_value > 0) {
    info() << "Set the timeout before alarm at " << m_alarm_timer_value << " seconds";
  }
 
  // Allocation of a default backward manager
  if (!m_backward_mng)
    _createOwnDefaultBackwardMng();
 
  IProfilingService* ps = platform::getProfilingService();
  bool want_specific_profiling = false;
  // Checks if specific profiling is requested. In this case,
  // modules and services manage the profiling themselves, and therefore
  // profiling is not automatically started at the beginning of the
  // computation loop
  if (!platform::getEnvironmentVariable("ARCANE_SPECIFIC_PROFILING").null()) {
    info() << "Specific profiling activated";
    want_specific_profiling = true;
  }
 
  {
    // NOTE: arcaneGlobalMemoryInfo() can change during computation,
    // so it must be retrieved every time it is needed.
    IMemoryInfo* mem_info = arcaneGlobalMemoryInfo();
    String s = platform::getEnvironmentVariable("ARCANE_CHECK_MEMORY_BLOCK_SIZE_ITERATION");
    if (!s.null()) {
      Int64 block_size = 0;
      bool is_bad = builtInGetValue(block_size, s);
      if (!is_bad && block_size > 2) {
        info() << "Set Memory StackTraceMinAllocSize to " << block_size;
        mem_info->setStackTraceMinAllocSize(block_size);
      }
    }
  }
 
  // Start message passing profiling if applicable
  if (m_msg_pass_prof_srv.get())
    m_msg_pass_prof_srv->startProfiling();
 
  try {
    if (ps) {
      if (!ps->isInitialized())
        ps->initialize();
      ps->reset();
    }
    Item::resetStats();
    // Deactivate profiling if specific request
    if (want_specific_profiling)
      ps = nullptr;
    ProfilingSentryWithInitialize ps_sentry(ps);
    if (!m_specific_entry_point_name.null()) {
      _callSpecificEntryPoint();
      is_end = true;
    }
    while (!is_end) {
      if (max_loop != 0 && m_nb_loop >= max_loop) {
        info() << "===================================================";
        info() << "====== MAXIMUM NUMBER OF ITERATION REACHED  =======";
        info() << "===================================================";
        is_end_by_max_loop = true;
        m_stop_reason = eTimeLoopStopReason::MaxIterationReached;
        stopComputeLoop(false, false);
        break;
      }
      // Indicate that we will stop by maximum number of iterations
      if (max_loop != 0 && (1 + m_nb_loop) >= max_loop) {
        m_stop_reason = eTimeLoopStopReason::MaxIterationReached;
      }
      ret_val = doOneIteration();
      IMemoryInfo* mem_info = arcaneGlobalMemoryInfo();
      if (mem_info && mem_info->isCollecting()) {
        mem_info->endCollect();
        Integer iteration = subDomain()->commonVariables().globalIteration();
        mem_info->setIteration(iteration);
 
        std::ostringstream ostr;
        if (iteration > 0)
          mem_info->printAllocatedMemory(ostr, iteration - 1);
        if (iteration > 1)
          mem_info->printAllocatedMemory(ostr, iteration - 2);
        if (iteration > 4)
          mem_info->printAllocatedMemory(ostr, iteration - 5);
        info() << "ITERATION_MemoryInfo: " << ostr.str();
        mem_info->beginCollect();
      }
      subDomain()->variableMng()->synchronizerMng()->flushPendingStats();
      if (ret_val != 0)
        is_end = true;
      ++m_nb_loop;
    }
  }
  catch (const TimeoutException& ex) {
    if (m_msg_pass_prof_srv.get())
      m_msg_pass_prof_srv->stopProfiling();
    IParallelMng* pm = subDomain()->parallelMng();
    pinfo() << "TIMEOUT " << Trace::Width(8) << pm->commRank() << "_RANK Infos:" << ex.additionalInfo();
    traceMng()->flush();
    // Wait for all processors to send the signal and display the
    // previous message
    platform::sleep(40);
    throw;
  }
  if (m_verification_only_at_exit) {
    info() << "Doing verification at exit";
    doVerification("AtExit");
  }
  {
    IProfilingService* ps2 = platform::getProfilingService();
    if (ps2)
      ps2->printInfos(true);
  }
  if (m_msg_pass_prof_srv.get())
    m_msg_pass_prof_srv->stopProfiling();
  if (IItemEnumeratorTracer::singleton())
    IItemEnumeratorTracer::singleton()->dumpStats();
  info() << "End of compute loop: reason=" << (int)m_stop_reason;
  if (is_end_by_max_loop)
    return 2;
  if (m_final_time_reached)
    return 1;
  if (ret_val < 0) {
    return ret_val;
  }
  return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TimeLoopMng::
_resetTimer() const
{
  if (m_alarm_timer_value > 0)
    platform::resetAlarmTimer(m_alarm_timer_value);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/