ArcaneMain.h

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ArcaneMain.h                                                (C) 2000-2025 */
/*                                                                           */
/* Class managing execution.                                                 */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_IMPL_ARCANEMAIN_H
#define ARCANE_IMPL_ARCANEMAIN_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/List.h"
#include "arcane/utils/IFunctor.h"
#include "arcane/core/IArcaneMain.h"
 
#include <atomic>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ApplicationInfo;
class IMainFactory;
class IApplication;
class ICodeService;
class ServiceFactoryInfo;
class ArcaneMainExecInfo;
class DotNetRuntimeInitialisationInfo;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ARCANE_IMPL_EXPORT ArcaneMainExecutionOverrideFunctor
{
  friend class ArcaneMain;
  friend class ArcaneMainExecInfo;
 
 public:
 
  explicit ArcaneMainExecutionOverrideFunctor(IFunctor* functor)
  : m_functor(functor)
  , m_application(nullptr)
  {}
  IFunctor* functor() { return m_functor; }
  IApplication* application() { return m_application; }
 
 private:
 
  IFunctor* m_functor;
  IApplication* m_application;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ARCANE_IMPL_EXPORT IApplicationBuildInfoVisitor
{
 public:
 
  virtual ~IApplicationBuildInfoVisitor() {}
 
 public:
 
  virtual void visit(ApplicationBuildInfo& app_build_info) = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_IMPL_EXPORT ArcaneMain
: public IArcaneMain
{
  friend class ArcaneMainExecInfo;
  friend class ArcaneLauncher;
  friend class ArcaneMainAutoDetectRuntimeHelper;
  class Impl;
 
 public:
 
  // TODO: to be removed.
  ArcaneMain(const ApplicationInfo& infos, IMainFactory* factory);
 
 public:
 
  ArcaneMain(const ApplicationInfo& app_info, IMainFactory* factory,
             const ApplicationBuildInfo& app_build_info,
             const DotNetRuntimeInitialisationInfo& dotnet_init_info,
             const AcceleratorRuntimeInitialisationInfo& accelerator_init_info);
  ~ArcaneMain() override;
 
 public:

  static int arcaneMain(const ApplicationInfo& app_info, IMainFactory* factory = nullptr);

  static int run();

  static void arcaneInitialize();

  static void arcaneFinalize();

  static void setHasGarbageCollector();

  static void setHasDotNETRuntime();

  static void setDefaultMainFactory(IMainFactory* mf);

  static ApplicationInfo& defaultApplicationInfo();

  static DotNetRuntimeInitialisationInfo& defaultDotNetRuntimeInitialisationInfo();

  static AcceleratorRuntimeInitialisationInfo& defaultAcceleratorRuntimeInitialisationInfo();

  static ApplicationBuildInfo& defaultApplicationBuildInfo();

 
  static int callFunctorWithCatchedException(IFunctor* functor, IArcaneMain* amain,
                                             bool* clean_abort,
                                             bool is_print = true);

  static void setExecuteOverrideFunctor(ArcaneMainExecutionOverrideFunctor* functor);

  static bool hasDotNetWrapper();

  static Real initializationTimeForAccelerator();
 
 public:

  static void addServiceFactoryInfo(IServiceFactoryInfo* factory);

  static void addModuleFactoryInfo(IModuleFactoryInfo* factory);
 
 public:

  static void addApplicationBuildInfoVisitor(IApplicationBuildInfoVisitor* visitor);
 
 public:
 
  static void redirectSignals();
  static bool isMasterIO() { return m_is_master_io; }
  static void setUseTestLogger(bool v);
 
 public:
 
  void build() override;
  void initialize() override;
  bool parseArgs(StringList args) override;
  int execute() override;
  void doAbort() override;
  void setErrorCode(int errcode) override;
  int errorCode() const override { return m_error_code; }
  void finalize() override {}
 
 public:
 
  const ApplicationInfo& applicationInfo() const override;
  const ApplicationBuildInfo& applicationBuildInfo() const override;
  const DotNetRuntimeInitialisationInfo& dotnetRuntimeInitialisationInfo() const override;
  const AcceleratorRuntimeInitialisationInfo& acceleratorRuntimeInitialisationInfo() const override;
  IMainFactory* mainFactory() const override { return m_main_factory; }
  IApplication* application() const override { return m_application; }
  ServiceFactoryInfoCollection registeredServiceFactoryInfos() override;
  ModuleFactoryInfoCollection registeredModuleFactoryInfos() override;
  bool hasGarbageCollector() const override { return m_has_garbage_collector; }
  void setDirectExecuteFunctor(IDirectSubDomainExecuteFunctor* f) override { m_direct_sub_domain_execute_functor = f; }
  IDirectSubDomainExecuteFunctor* _directExecuteFunctor() const { return m_direct_sub_domain_execute_functor; }
 
 protected:
 
  IApplication* _application() { return m_application; }
  ApplicationBuildInfo& _applicationBuildInfo();
  static int _internalRun(IDirectSubDomainExecuteFunctor* func);
 
 private:
 
  Impl* m_p;
  IMainFactory* m_main_factory = nullptr;
  IApplication* m_application = nullptr;
  int m_error_code = 0;
  IDirectSubDomainExecuteFunctor* m_direct_sub_domain_execute_functor = nullptr;
  static bool m_has_garbage_collector;
  static bool m_is_master_io;
  static bool m_is_use_test_logger;
  static IMainFactory* m_default_main_factory;
  static ArcaneMainExecutionOverrideFunctor* m_exec_override_functor;
 
 private:
 
  static int _arcaneMain(const ApplicationInfo&, IMainFactory*);
  void _dumpHelp();
  void _parseApplicationBuildInfoArgs();
  static std::atomic<Int32> m_nb_arcane_init;
  static std::atomic<Int32> m_is_init_done;
  static void _launchMissingInitException();
  static void _checkHasInit();
  static int _runDotNet();
  static void _checkAutoDetectMPI();
  static int _checkAutoDetectAccelerator(bool& has_accelerator);
  static void _setArcaneLibraryPath();
  static int _initRuntimes();
  static int _checkTestLoggerResult();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif