ArcaneMain.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2023 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-2023 */
/*                                                                           */
/* Classe gérant l'exécution.                                                */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_IMPL_ARCANEMAIN_H
#define ARCANE_IMPL_ARCANEMAIN_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/List.h"
#include "arcane/utils/IFunctor.h"
#include "arcane/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: a supprimer.
  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 void _checkCreateDynamicLibraryLoader();
  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