Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
Application.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* Application.cc (C) 2000-2025 */
9/* */
10/* Superviseur. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/Iostream.h"
15#include "arcane/utils/Iterator.h"
16#include "arcane/utils/List.h"
17#include "arcane/utils/ScopedPtr.h"
18#include "arcane/utils/Deleter.h"
19#include "arcane/utils/PlatformUtils.h"
20#include "arcane/utils/ValueConvert.h"
21#include "arcane/utils/OStringStream.h"
22#include "arcane/utils/ITraceMng.h"
23#include "arcane/utils/TraceClassConfig.h"
24#include "arcane/utils/IMemoryInfo.h"
25#include "arcane/utils/IStackTraceService.h"
26#include "arcane/utils/ISymbolizerService.h"
27#include "arcane/utils/IProcessorAffinityService.h"
28#include "arcane/utils/IOnlineDebuggerService.h"
29#include "arcane/utils/StringBuilder.h"
30#include "arcane/utils/IProfilingService.h"
31#include "arcane/utils/IThreadImplementationService.h"
32#include "arcane/utils/IDynamicLibraryLoader.h"
33#include "arcane/utils/IPerformanceCounterService.h"
34#include "arcane/utils/ITraceMngPolicy.h"
35#include "arcane/utils/JSONReader.h"
36#include "arcane/utils/Profiling.h"
37#include "arcane/utils/internal/TaskFactoryInternal.h"
38#include "arcane/utils/internal/DependencyInjection.h"
39
40#include "arcane/core/ArcaneVersion.h"
41#include "arcane/core/ISubDomain.h"
42#include "arcane/core/IIOMng.h"
43#include "arcane/core/IXmlDocumentHolder.h"
44#include "arcane/core/IParallelSuperMng.h"
45#include "arcane/core/IMainFactory.h"
46#include "arcane/core/IArcaneMain.h"
47#include "arcane/core/IRessourceMng.h"
48#include "arcane/core/IServiceLoader.h"
49#include "arcane/core/IServiceMng.h"
50#include "arcane/core/ICodeService.h"
51#include "arcane/core/ISession.h"
52#include "arcane/core/IDataFactory.h"
53#include "arcane/core/IDataFactoryMng.h"
54#include "arcane/core/IXmlDocumentHolder.h"
55#include "arcane/core/XmlNode.h"
56#include "arcane/core/XmlNodeList.h"
57#include "arcane/core/ItemTypeMng.h"
59#include "arcane/core/IPhysicalUnitSystemService.h"
60#include "arcane/core/ServiceBuilder.h"
61#include "arcane/core/Configuration.h"
62#include "arcane/core/Directory.h"
63#include "arcane/core/IServiceAndModuleFactoryMng.h"
64#include "arcane/core/ApplicationBuildInfo.h"
65
66#include "arcane/core/IItemEnumeratorTracer.h"
67#include "arcane/impl/Application.h"
68#include "arcane/impl/ConfigurationReader.h"
69#include "arcane/impl/ArcaneMain.h"
70
71// Ces fichiers ne sont utilisés que pour afficher des tailles
72// des classes définies dans ces fichiers
74#include "arcane/core/Item.h"
75#include "arcane/core/IndexedItemConnectivityView.h"
76#include "arcane/core/UnstructuredMeshConnectivity.h"
77
78#include "arccore_version.h"
79
80#ifdef ARCANE_OS_WIN32
81#include <windows.h>
82#endif
83
84#include <vector>
85#include <set>
86
87/*---------------------------------------------------------------------------*/
88/*---------------------------------------------------------------------------*/
89
90namespace Arcane
91{
92
93/*---------------------------------------------------------------------------*/
94/*---------------------------------------------------------------------------*/
95
97createNullPhysicalUnitSystemService();
98extern "C++" IConfigurationMng*
99arcaneCreateConfigurationMng(ITraceMng* tm);
100extern "C++" ARCANE_IMPL_EXPORT IServiceAndModuleFactoryMng*
101arcaneCreateServiceAndModuleFactoryMng(ITraceMng* tm);
102extern "C++" ARCANE_IMPL_EXPORT Ref<IItemEnumeratorTracer>
103arcaneCreateItemEnumeratorTracer(ITraceMng* tm,Ref<IPerformanceCounterService> perf_counter);
104extern "C++" ARCANE_IMPL_EXPORT Ref<ICodeService>
105createArcaneCodeService(IApplication* app);
106extern "C++" ARCANE_CORE_EXPORT void
107arcaneSetSingletonItemEnumeratorTracer(Ref<IItemEnumeratorTracer> tracer);
108
109/*---------------------------------------------------------------------------*/
110/*---------------------------------------------------------------------------*/
111
112/*---------------------------------------------------------------------------*/
113/*---------------------------------------------------------------------------*/
114
115extern "C++" IApplication*
116arcaneCreateApplication(IArcaneMain* am)
117{
118 IApplication* sm = new Application(am);
119 sm->build();
120 return sm;
121}
122
123/*---------------------------------------------------------------------------*/
124/*---------------------------------------------------------------------------*/
132, m_namespace_uri(arcaneNamespaceURI())
133, m_local_name("Application")
134, m_arcane_main(am)
136, m_service_mng(nullptr)
138, m_trace(nullptr)
139, m_ressource_mng(nullptr)
140, m_io_mng(nullptr)
141, m_configuration_mng(nullptr)
142, m_main_service_factory_infos(am->registeredServiceFactoryInfos())
143, m_main_module_factory_infos(am->registeredModuleFactoryInfos())
144, m_has_garbage_collector(am->hasGarbageCollector())
145, m_trace_policy(nullptr)
146, m_is_init(false)
147, m_is_master(false)
148, m_service_and_module_factory_mng(nullptr)
149{
150 // Initialise les threads avec un service qui ne fait rien.
151 platform::setThreadImplementationService(&m_null_thread_implementation);
152}
153
154/*---------------------------------------------------------------------------*/
155/*---------------------------------------------------------------------------*/
163{
165 m_task_implementation.reset();
166
167 // Supprime les services que l'instance a positionné
168 if (platform::getProcessorAffinityService()==m_processor_affinity_service.get())
170
171 if (platform::getStackTraceService()==m_stack_trace_service.get())
173
174 if (platform::getSymbolizerService()==m_symbolizer_service.get())
176
177 if (platform::getProfilingService()==m_profiling_service.get())
179
180 if (platform::getPerformanceCounterService()==m_performance_counter_service.get())
182
183 delete m_service_and_module_factory_mng;
184
185 m_sessions.each(Deleter());
186
187 delete m_configuration_mng;
188 delete m_ressource_mng;
189
190 m_owned_sequential_parallel_super_mng.reset();
191 m_parallel_super_mng.reset();
192
193 m_data_factory_mng.reset();
194 delete m_io_mng;
195 delete m_service_mng;
196
197 m_trace = nullptr;
198 // Il faut détruire le m_trace_policy après m_trace car ce dernier peut
199 // l'utiliser.
200 delete m_trace_policy;
201
202 // Supprime la référence au gestionnaire de thread. Il faut le faire en dernier car
203 // les autres gestionnaires peuvent l'utiliser.
204 if (platform::getThreadImplementationService()==m_thread_implementation.get())
206}
207
208/*---------------------------------------------------------------------------*/
209/*---------------------------------------------------------------------------*/
210
211UniqueArray<String> Application::
212_stringListToArray(const StringList& slist) const
213{
215 for( const String& s : slist )
216 a.add(s);
217 return a;
218}
219
220/*---------------------------------------------------------------------------*/
221/*---------------------------------------------------------------------------*/
232template<typename InterfaceType> Ref<InterfaceType> Application::
233_tryCreateService(const StringList& names,String* found_name)
234{
235 if (found_name)
236 (*found_name) = String();
238 for( String s : names ){
239 auto t = sf.createReference(s,SB_AllowNull);
240 if (t.get()){
241 if (found_name)
242 (*found_name) = s;
243 return t;
244 }
245 }
246 return {};
247}
248
249/*---------------------------------------------------------------------------*/
250/*---------------------------------------------------------------------------*/
258template<typename InterfaceType> Ref<InterfaceType> Application::
259_tryCreateServiceUsingInjector(const StringList& names,String* found_name)
260{
261 DependencyInjection::Injector injector;
262 injector.fillWithGlobalFactories();
263
264 if (found_name)
265 (*found_name) = String();
266 for( String s : names ){
267 auto t = injector.createInstance<InterfaceType>(s,true);
268 if (t.get()){
269 if (found_name)
270 (*found_name) = s;
271 return t;
272 }
273 }
274 return {};
275}
276
277/*---------------------------------------------------------------------------*/
278/*---------------------------------------------------------------------------*/
279
280extern "C++" ARCANE_UTILS_EXPORT void
281arcaneSetPauseOnError(bool v);
282
284build()
285{
286 const ApplicationBuildInfo& build_info = applicationBuildInfo();
287
288 // Création du TraceMngPolicy. L'initialisation complète se fera plus tard
289 // car on a besoin d'informations supplémentaires comme le rang MPI et
290 // d'avoir lu des fichiers de configuration.
291 m_trace_policy = m_main_factory->createTraceMngPolicy(this);
292
293 // Toujours le premier après TraceMngPolicy
294 m_trace = m_main_factory->createTraceMng();
295
296 {
297 // TODO: positionner ces informations dans ApplicationBuildInfo.
298 Int32 output_level = build_info.outputLevel();
299 if (output_level!=Trace::UNSPECIFIED_VERBOSITY_LEVEL){
300 m_trace_policy->setVerbosityLevel(output_level);
301 m_trace_policy->setStandardOutputVerbosityLevel(output_level);
302 }
303 Int32 verbosity_level = build_info.verbosityLevel();
304 if (verbosity_level!=Trace::UNSPECIFIED_VERBOSITY_LEVEL){
305 m_trace_policy->setVerbosityLevel(verbosity_level);
306 }
307
308 bool has_output_file = build_info.isMasterHasOutputFile();
309 m_trace_policy->setIsMasterHasOutputFile(has_output_file);
310
311 // Positionne le niveau de verbosité en laissant au minimum le niveau
312 // par défaut. Sans cela, certains messages d'initialisation peuvent ne
313 // pas s'afficher ce qui peut être génant en cas de problèmes ou de plantage.
314 Int32 minimal_verbosity_level = build_info.minimalVerbosityLevel();
315 if (minimal_verbosity_level==Trace::UNSPECIFIED_VERBOSITY_LEVEL)
316 minimal_verbosity_level = Trace::DEFAULT_VERBOSITY_LEVEL;
317 m_trace_policy->setDefaultVerboseLevel(m_trace.get(),minimal_verbosity_level);
318 }
319
320 arcaneGlobalMemoryInfo()->setTraceMng(traceMng());
321
322 {
323 // Affiche quelques informations à l'initialisation dès le niveau 4
324 m_trace->info(4) << "*** Initialization informations:";
325 m_trace->info(4) << "*** PID: " << platform::getProcessId();
326 m_trace->info(4) << "*** Host: " << platform::getHostName();
327
328 // TODO: Avec MPC, cette séquence ne doit être appelée qu'une seule fois.
330 if (dynamic_library_loader){
331 String os_dir(m_exe_info.dataOsDir());
332 for( StringCollection::Enumerator i(m_exe_info.dynamicLibrariesName()); ++i; ){
333 String name = *i;
334 m_trace->info(4) << "*** Trying to load dynamic library: " << name;
335 IDynamicLibrary* dl = dynamic_library_loader->open(os_dir,name);
336 if (!dl)
337 m_trace->info(4) << "WARNING: Can not load library '" << name << "'";
338 }
339 }
340
341#ifdef ARCANE_OS_WIN32
342 if (dynamic_library_loader){
343 String os_dir(m_exe_info.dataOsDir());
344 String dyn_lib_names[5] = { "arcane_mpi", "arcane_std", "arcane_mesh",
345 "arcane_thread", "arcane_mpithread",
346 };
347 for( Integer i=0; i<5; ++i )
348 dynamic_library_loader->open(os_dir,dyn_lib_names[i]);
349 }
350#endif
351
352 m_configuration_mng = arcaneCreateConfigurationMng(traceMng());
353
354 {
355 m_service_and_module_factory_mng = arcaneCreateServiceAndModuleFactoryMng(traceMng());
357 m_service_and_module_factory_mng->addGlobalFactory(*i);
359 m_service_and_module_factory_mng->addGlobalFactory(*i);
360
361 m_service_and_module_factory_mng->createAllServiceRegistererFactories();
362 }
363
364 m_service_mng = m_main_factory->createServiceMng(this);
365
366 String pause_on_error = platform::getEnvironmentVariable("ARCANE_PAUSE_ON_ERROR");
367 if (!pause_on_error.null()){
368 arcaneSetPauseOnError(true);
369 }
370
371 // Recherche le service utilisé pour connaitre la pile d'appel
372 bool has_dbghelp = false;
373 {
376 if (!sv.get()){
377 sv = sf.createReference("DbgHelpStackTraceService", SB_AllowNull);
378 if (sv.get())
379 has_dbghelp = true;
380 }
381 if (sv.get()) {
382 m_stack_trace_service = sv;
384 }
385 }
386
387 // Recherche le service utilisé pour connaitre les infos sur les symboles
388 // du code source. Pour l'instant on ne supporte que LLVM et on n'active ce service
389 // que si la variable d'environnement ARCANE_LLVMSYMBOLIZER_PATH est définie.
390 {
393 if (!platform::getEnvironmentVariable("ARCANE_LLVMSYMBOLIZER_PATH").null()){
394 s = sf.createReference("LLVMSymbolizer", SB_AllowNull);
395 }
396 if (!s.get() && has_dbghelp){
397 s = sf.createReference("DbgHelpSymbolizerService", SB_AllowNull);
398 }
399 if (s.get()) {
400 m_symbolizer_service = s;
402 }
403 }
404
405 if (arcaneHasThread()){
406 StringList names = build_info.threadImplementationServices();
407 String found_name;
409 if (sv.get()){
410 m_thread_implementation_service = sv;
411 m_thread_implementation = sv->createImplementation();
412 platform::setThreadImplementationService(m_thread_implementation.get());
413 m_thread_implementation->initialize();
414 m_used_thread_service_name = found_name;
415 }
416 else{
417 m_trace->info() << "Can not find thread implementation service "
418 << "(names=" << _stringListToArray(names) << "). Threads are disabled.";
419 arcaneSetHasThread(false);
420 }
421 }
422
423 // Le gestionnaire de thread a pu changer et il faut donc
424 // reinitialiser le gestionnaire de trace.
425 m_trace->resetThreadStatus();
426
427 // Recherche le service utilisé pour gérer les tâches
428 if (arcaneHasThread()){
429 Integer nb_task_thread = build_info.nbTaskThread();
430 if (nb_task_thread>=0){
431
432 StringList names = build_info.taskImplementationServices();
433 String found_name;
434 auto sv = _tryCreateServiceUsingInjector<ITaskImplementation>(names,&found_name);
435 if (sv.get()){
436 TaskFactoryInternal::setImplementation(sv.get());
437 //m_trace->info() << "Initialize task with nb_thread=" << nb_thread;
438 sv->initialize(nb_task_thread);
439 m_used_task_service_name = found_name;
440 m_task_implementation = sv;
441 }
442 else
443 ARCANE_FATAL("Can not find task implementation service (names='{0}')."
444 " Please check if Arcane is configured with Intel TBB library",
445 _stringListToArray(names));
446 }
447
448 if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_TASK_VERBOSE_LEVEL",true))
450 }
451
452 if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_LOOP_PROFILING_LEVEL",true))
454
455 // Recherche le service utilisé pour le profiling
456 {
457 String profile_str = platform::getEnvironmentVariable("ARCANE_PROFILING");
458 if (!profile_str.null()){
460 auto sv = sf.createReference(profile_str+"ProfilingService",SB_AllowNull);
461 if (sv.get()){
462 m_profiling_service = sv;
464 }
465 else
466 ARCANE_FATAL("Can not find profiling service (name='{0}')",profile_str);
467 }
468 }
469
470 // Par défaut, on accroche le service Hyoda
471 {
473 auto sv = sf.createReference("Hyoda",SB_AllowNull);
474 if (sv.get()){
475 m_online_debugger = sv;
477 }
478 }
479
480 // Recherche le service utilisé pour la gestion de l'affinité processeur
481 {
483 auto sv = sf.createReference("HWLoc",SB_AllowNull);
484 if (sv.get()){
485 m_processor_affinity_service = sv;
487 }
488 }
489
490 // Recherche le service utilisé pour le parallélisme
491 String message_passing_service = build_info.messagePassingService();
492 if (message_passing_service.null())
493 message_passing_service = build_info.internalDefaultMessagePassingService();
495 auto sm = sf.createReference(message_passing_service,SB_AllowNull);
496 if (!sm)
497 ARCANE_FATAL("Can not find message passing service '{0}'",message_passing_service);
498
500 m_parallel_super_mng->initialize();
501
502 IParallelSuperMng* seq_sm = nullptr;
503 if (sm->isParallel()){
504 m_owned_sequential_parallel_super_mng = sf.createReference("SequentialParallelSuperMng",SB_AllowNull);
505 seq_sm = m_owned_sequential_parallel_super_mng.get();
506 if (!seq_sm)
507 ARCANE_FATAL("Can not find service 'SequentialParallelSuperMng'");
508 seq_sm->initialize();
509 }
510 else
511 seq_sm = m_parallel_super_mng.get();
512
514
516 m_io_mng = m_main_factory->createIOMng(this);
517 m_data_factory_mng = m_main_factory->createDataFactoryMngRef(this);
518 }
519
520 {
521 VersionInfo version_info = m_exe_info.codeVersion();
522 int vmajor = version_info.versionMajor();
523 int vminor = version_info.versionMinor();
524 int vpatch = version_info.versionPatch();
525 m_main_version_str = String::format("{0}.{1}.{2}",vmajor,vminor,vpatch);
526 m_major_and_minor_version_str = String::format("{0}.{1}",vmajor,vminor);
528 if (vpatch!=0)
530 }
531
532 m_targetinfo_str = m_exe_info.targetFullName();
533 m_application_name = m_exe_info.applicationName();
534 m_code_name = m_exe_info.codeName();
535
536 // Récupère le nom de l'utilisateur
538
539 // Récupère le chemin du répertoire de la configuration utilisateur
540 // TODO: il faut changer car dans les nouvelles recommandations POSIX,
541 // le répertoire de configuration est '.config/arcane'.
543 if (m_user_config_path.null()) {
544 Directory user_home_env(platform::getHomeDirectory());
545 m_user_config_path = Directory(user_home_env, ".arcane").path();
546 }
547
548 {
549 bool is_parallel = parallelSuperMng()->isParallel();
550 bool is_debug = applicationInfo().isDebug();
551 // Création et initialisation du TraceMngPolicy.
552 m_trace_policy->setIsParallel(is_parallel);
553 m_trace_policy->setIsDebug(is_debug);
554 bool is_parallel_output = is_parallel && is_debug;
555 // Permet de forcer les sorties meme en mode optimisé
556 {
557 String s = platform::getEnvironmentVariable("ARCANE_PARALLEL_OUTPUT");
558 if (!s.null())
559 is_parallel_output = true;
560 if (s=="0")
561 is_parallel_output = false;
562 }
563 m_trace_policy->setIsParallelOutput(is_parallel_output);
564 }
565
566 m_is_master = m_parallel_super_mng->commRank() == 0;
567
568 m_trace->info(4) << "*** UserName: " << m_user_name;
569 m_trace->info(4) << "*** HomeDirectory: " << platform::getHomeDirectory();
570
571#ifdef ARCANE_CHECK_MEMORY
572 arcaneGlobalMemoryInfo()->setTraceMng(m_trace);
573#endif
574}
575
576/*---------------------------------------------------------------------------*/
577/*---------------------------------------------------------------------------*/
578
581{
582 if (m_is_init){
583 m_trace->warning() << "Application is already initialised";
584 return;
585 }
586
587 bool is_debug = m_exe_info.isDebug();
588
589 // Analyse le fichier de configuration de l'utilisateur
591
592 //m_trace->info() << "Application init trace mng rank=" << m_parallel_super_mng->traceRank();
593 m_trace_policy->setDefaultClassConfigXmlBuffer(userConfigBuffer());
594 m_trace_policy->initializeTraceMng(m_trace.get(),m_parallel_super_mng->traceRank());
595
596 m_trace->logdate() << "Begin execution.";
597
598 if (is_debug)
599 m_trace->info() << "WARNING: Execution in DEBUG mode!";
600
601#ifdef ARCANE_CHECK
602 m_trace->info() << "WARNING: Compilation in CHECK mode !";
603#endif
604
605 // Active ou désactive un mode vérification partiel si la variable d'environnement
606 // correspondante est positionnée.
607 String check_str = platform::getEnvironmentVariable("ARCANE_CHECK");
608 if (!check_str.null()){
609 bool is_check = check_str != "0";
610 m_trace->info() << "WARNING: Setting CHECK mode to " << is_check;
611 arcaneSetCheck(is_check);
612 }
613 if (arcaneIsCheck()){
614 m_trace->info() << "WARNING: Execution in CHECK mode!";
615 }
616
617#ifdef ARCANE_TRACE
618 m_trace->info() << "WARNING: Execution in TRACE mode !";
619#endif
620#ifdef ARCANE_64BIT
621 m_trace->info() << "Using 64bits version!";
622#endif
623
624 m_trace->info() << "** -- ** -- ** -- ** -- ** -- ** -- ** -- ** -- ** -- **";
625 m_trace->info() << "** -- ** -- ** -- ** -- ** -- ** -- ** -- ** -- ** -- **";
626 m_trace->info() << " ";
627 m_trace->info() << " "
628 << m_exe_info.applicationName();
629 m_trace->info() << " ";
630 VersionInfo version_info = m_exe_info.codeVersion();
631 m_trace->info() << " Version "
632 << version_info.versionMajor() << "."
633 << version_info.versionMinor() << "."
634 << version_info.versionPatch();
635
636 m_trace->info() << " ";
637 m_trace->info() << "** -- ** -- ** -- ** -- ** -- ** -- ** -- ** -- ** -- **";
638 m_trace->info() << "** -- ** -- ** -- ** -- ** -- ** -- ** -- ** -- ** -- **";
639 m_trace->info() << "Date: " << platform::getCurrentDateTime();
640 m_trace->info() << "MemoryUsage: " << static_cast<Int64>(platform::getMemoryUsed() / 1.0e6) << " (MegaBytes)";
641 m_trace->info() << "ArccoreVersion: " << ARCCORE_VERSION_STR_FULL;
642 m_trace->info() << "ArcaneVersion: " << ARCANE_VERSION_STR_FULL
643 << " (Compiler: " << platform::getCompilerId() << ")";
644 m_trace->info() << "Current process pid=" << platform::getProcessId()
645 << " machine=" << platform::getHostName();
646 m_trace->info() << "MessagePassing service=" << applicationBuildInfo().messagePassingService();
647
649 m_trace->info() << "Stack trace service is available";
650 }
652 m_trace->info() << "Symbolizer service is available";
653 }
654
655#ifdef ARCANE_USE_LIBXML2
656 m_trace->info() << "Using 'libxml2' for XML parsing";
657#endif
658
659 // Affiche les infos sur les processeurs
660 {
662 if (pas){
663 pas->printInfos();
664 }
665 }
666
667 // Affiche si l'on a un service de debug
669 m_trace->info() << "Hyoda service is now hooked";
670 }
671 else{
672 m_trace->info() << "Unknown online debugger service";
673 }
674
675 m_is_init = true;
676
677 // Analyse le fichier de configuration du code.
678 _readCodeConfigurationFile();
679
680 {
681 // Construction des types internes
683 }
684
685 {
686 ByteConstSpan runtime_config = m_exe_info.runtimeConfigFileContent();
687 if (!runtime_config.empty()){
688 m_trace->info() << "Reading configuration parameters from runtime config file";
689 JSONDocument jdoc;
690 jdoc.parse(runtime_config);
691 JSONValue config = jdoc.root().child("configuration");
692 ConfigurationReader cr(m_trace.get(),m_configuration_mng->defaultConfiguration());
693 cr.addValuesFromJSON(config,ConfigurationReader::P_GlobalRuntime);
694 }
695 }
696 {
697 if (!m_config_root_element.null()){
698 XmlNode configuration_elem = m_config_root_element.child("configuration");
699 if (!configuration_elem.null()){
700 m_trace->info() << "Reading configuration parameters from code config file";
701 ConfigurationReader cr(m_trace.get(),m_configuration_mng->defaultConfiguration());
702 cr.addValuesFromXmlNode(configuration_elem,ConfigurationReader::P_Global);
703 }
704 }
705 }
706
707 _initDataInitialisationPolicy();
708
709 {
710 if (!m_used_thread_service_name.null())
711 m_trace->info() << "Service used for thread management : '" << m_used_thread_service_name << "'";
712 else
713 m_trace->info() << "No thread management active";
714
715 if (!m_used_task_service_name.null()){
716 m_trace->info() << "Service used for task management : '" << m_used_task_service_name
717 << "' (max_task_thread=" << TaskFactory::nbAllowedThread() << ")";
718 std::ostringstream ostr;
720 m_trace->info() << "TaskManagement infos:" << ostr.str();
721 }
722 else
723 m_trace->info() << "No task management active";
724 }
725
726 // Recherche le service utilisé pour gérer le système d'unité.
727 {
729 String service_name = "Udunits";
730 auto sv = sf.createReference(service_name,SB_AllowNull);
731 if (sv.get()){
732 m_trace->info() << "UnitSystem service found name=" << service_name;
733 }
734 else{
735 m_trace->info() << "No unit system service found";
736 sv = makeRef(createNullPhysicalUnitSystemService());
737 }
738 m_physical_unit_system_service = sv;
739 }
740
741 // Recherche le service utilisé pour gérer les compteurs de performance.
742 {
743 String service_name = "LinuxPerfPerformanceCounterService";
744 String env_service_name = platform::getEnvironmentVariable("ARCANE_PERFORMANCE_COUNTER_SERVICE");
745 if (!env_service_name.null())
746 service_name = env_service_name + "PerformanceCounterService";
748 auto p = sbuilder.createReference(service_name,SB_AllowNull);
749 m_performance_counter_service = p;
750 if (p.get()){
751 m_trace->info() << "PerformanceCounterService found name=" << service_name;
752 }
753 else{
754 m_trace->info() << "No performance counter service found";
755 }
756 }
757
758 // Initialise le traceur des énumérateurs.
759 {
760 bool force_tracer = false;
761 String trace_str = platform::getEnvironmentVariable("ARCANE_TRACE_ENUMERATOR");
762 if (!trace_str.null() || ProfilingRegistry::profilingLevel()>=1 || force_tracer){
763 if (!TaskFactory::isActive()){
765 auto p = m_performance_counter_service;
766 if (p.get()){
767 m_trace->info() << "Enumerator tracing is enabled";
768 Ref<IItemEnumeratorTracer> tracer(arcaneCreateItemEnumeratorTracer(traceMng(),p));
769 arcaneSetSingletonItemEnumeratorTracer(tracer);
770 p->initialize();
771 p->start();
772 }
773 else
774 m_trace->info() << "WARNING: enumerator tracing is not available because no performance counter service is available.";
775 }
776 else
777 m_trace->info() << "WARNING: enumerator tracing is not available when using multi-tasking.";
778 }
779 }
780
781 m_trace->info() << "sizeof(ItemInternal)=" << sizeof(ItemInternal)
782 << " sizeof(ItemInternalConnectivityList)=" << sizeof(ItemInternalConnectivityList)
783 << " sizeof(ItemSharedInfo)=" << sizeof(ItemSharedInfo);
784 m_trace->info() << "sizeof(ItemLocalId)=" << sizeof(ItemLocalId)
785 << " sizeof(ItemConnectivityContainerView)=" << sizeof(ItemConnectivityContainerView)
786 << " sizeof(UnstructuredMeshConnectivityView)=" << sizeof(UnstructuredMeshConnectivityView);
787 m_trace->info() << "sizeof(Item)=" << sizeof(Item)
788 << " sizeof(ItemEnumerator)=" << sizeof(ItemEnumerator)
789 << " sizeof(ItemVectorView)=" << sizeof(ItemVectorView)
790 << " sizeof(ItemVectorViewConstIterator)=" << sizeof(ItemVectorViewConstIterator)
791 << " ItemEnumeratorVersion=" << ItemEnumerator::version();
792 m_trace->info() << "sizeof(eItemKind)=" << sizeof(eItemKind)
793 << " sizeof(IndexedItemConnectivityViewBase)=" << sizeof(IndexedItemConnectivityViewBase);
794
795 {
796 Real init_time_accelerator = ArcaneMain::initializationTimeForAccelerator() * 1000.0;
797 if (init_time_accelerator!=0.0)
798 m_trace->info() << "Time (in ms) to initialize Accelerators = " << init_time_accelerator;
799 }
800}
801
802/*---------------------------------------------------------------------------*/
803/*---------------------------------------------------------------------------*/
804
805void Application::
806_readCodeConfigurationFile()
807{
808 // Analyse le fichier de configuration du code.
809 const ApplicationBuildInfo& build_info = applicationBuildInfo();
810
811 // Récupère le nom du fichier de configuration.
812 // Si nul, cela indique qu'il n'y a pas de fichier de configure.
813 // Si vide (le défaut), on récupère le nom à partir du nom du code.
814 // Sinon, on utilise le nom spécifié dans la configuration.
815
816 // A noter que cette valeur doit être la même pour tous les PE sinon cela
817 // va bloquer (TODO: faire une éventuellem réduction)
818 String config_file_name = build_info.configFileName();
819
820 bool use_config_file = true;
821 if (config_file_name.null()){
822 use_config_file = false;
823 }
824 else if (config_file_name.empty()){
825 // Regarde d'abord dans le répertoire courant, sinon dans le répertoire
826 // des données partagées (share).
827 // Pour des raisons de performances en parallèle, seul le processeur maitre
828 // fait le test.
829 StringBuilder buf;
830 if (m_is_master){
831 buf = m_exe_info.codeName();
832 buf += ".config";
833 if (!platform::isFileReadable(buf.toString())){
834 buf = m_exe_info.dataDir();
835 buf += "/";
836 buf += m_exe_info.codeName();
837 buf += ".config";
838 }
839 else{
840 m_trace->info() << "Using configuration file in current directory.";
841 }
842 }
843 config_file_name = buf.toString();
844 }
845 m_trace->info() << "Using configuration file: '" << config_file_name << "'";
846
847 if (use_config_file){
848 bool bad_file = m_io_mng->collectiveRead(config_file_name,m_config_bytes);
849 if (bad_file)
850 ARCANE_FATAL("Can not read configuration file '{0}'",config_file_name);
851 m_config_document = m_io_mng->parseXmlBuffer(m_config_bytes,config_file_name);
852 if (!m_config_document.get())
853 ARCANE_FATAL("Can not parse configuration file '{0}'",config_file_name);
854 m_config_root_element = m_config_document->documentNode().documentElement();
855 }
856}
857
858/*---------------------------------------------------------------------------*/
859/*---------------------------------------------------------------------------*/
865{
866 Directory user_config_dir(m_user_config_path);
867 String buf = user_config_dir.file("config.xml");
868
869 //ByteUniqueArray bytes;
870 bool bad_file = m_io_mng->collectiveRead(buf,m_user_config_bytes);
871 if (bad_file){
872 if (m_is_master)
873 m_trace->log() << "No user configuration file '" << buf << "'";
874 return;
875 }
876
877 IXmlDocumentHolder* doc = m_io_mng->parseXmlBuffer(m_user_config_bytes,buf);
878 if (!doc){
879 if (m_is_master)
880 m_trace->log() << "Can not parse user configuration file '" << buf << "'";
881 return;
882 }
883
886}
887
888/*---------------------------------------------------------------------------*/
889/*---------------------------------------------------------------------------*/
890
891namespace
892{
893bool _hasExtension(ICodeService* service,const String& extension)
894{
895 StringCollection extensions = service->validExtensions();
896 for( StringCollection::Enumerator j(extensions); ++j; ){
897 if ((*j)==extension)
898 return true;
899 }
900 return false;
901}
902}
903
904/*---------------------------------------------------------------------------*/
905/*---------------------------------------------------------------------------*/
906
908getCodeService(const String& u_file_name)
909{
910 ServiceBuilder<ICodeService> builder(this);
911 auto services = builder.createAllInstances();
912
913 // Regarde si un service gere l'extension '.arc'.
914 // S'il n'y en a pas, utilise ArcaneCodeService pour
915 // cette extension.
916 {
917 bool has_arc_extension = false;
918 for( Integer i=0, n=services.size(); i<n; ++i ){
919 ICodeService* code_service = services[i].get();
920 if (_hasExtension(code_service,"arc")){
921 has_arc_extension = true;
922 break;
923 }
924 }
925 if (!has_arc_extension){
926 services.add(createArcaneCodeService(this));
927 }
928 }
929
930 // Cherche l'extension du fichier et la conserve dans \a case_ext
931 std::string_view fview = u_file_name.toStdStringView();
932 std::size_t extension_pos = fview.find_last_of('.');
933 if (extension_pos==std::string_view::npos)
934 return {};
935 fview.remove_prefix(extension_pos+1);
936 String case_ext(fview);
937
938 Ref<ICodeService> found_service;
939 for( const auto& code_service : services ){
940 StringCollection extensions = code_service->validExtensions();
941 for( StringCollection::Enumerator j(extensions); ++j; ){
942 if (case_ext==(*j)){
943 found_service = code_service;
944 break;
945 }
946 }
947 if (found_service.get())
948 break;
949 }
950 // TODO: retourner une référence.
951 return found_service;
952}
953
954/*---------------------------------------------------------------------------*/
955/*---------------------------------------------------------------------------*/
956
958addSession(ISession* session)
959{
960 m_sessions.add(session);
961}
962
963/*---------------------------------------------------------------------------*/
964/*---------------------------------------------------------------------------*/
965
967removeSession(ISession* session)
968{
969 m_sessions.remove(session);
970}
971
972/*---------------------------------------------------------------------------*/
973/*---------------------------------------------------------------------------*/
974
977{
978 return m_service_and_module_factory_mng->serviceFactories2();
979}
980
981/*---------------------------------------------------------------------------*/
982/*---------------------------------------------------------------------------*/
983
986{
987 return m_service_and_module_factory_mng->moduleFactoryInfos();
988}
989
990/*---------------------------------------------------------------------------*/
991/*---------------------------------------------------------------------------*/
992
993void Application::
994_initDataInitialisationPolicy()
995{
996 String data_init_policy = platform::getEnvironmentVariable("ARCANE_DATA_INIT_POLICY");
998 bool is_changed = false;
999 if (data_init_policy=="DEFAULT"){
1000 init_policy = DIP_InitWithDefault;
1001 is_changed = true;
1002 }
1003 else if (data_init_policy=="NAN"){
1004 init_policy = DIP_InitWithNan;
1005 is_changed = true;
1006 }
1007 else if (data_init_policy=="NONE"){
1008 init_policy = DIP_None;
1009 is_changed = true;
1010 }
1011 else if (data_init_policy=="LEGACY"){
1012 init_policy = DIP_Legacy;
1013 is_changed = true;
1014 }
1015 else if (data_init_policy=="NAN_AND_DEFAULT"){
1017 is_changed = true;
1018 }
1019 if (is_changed){
1021 init_policy = getGlobalDataInitialisationPolicy();
1022 m_trace->info() << "Change data initialisation policy: " << data_init_policy
1023 << " (" << (int)init_policy << ")";
1024 }
1025 m_trace->info() << "Data initialisation policy is : " << (int)init_policy;
1026}
1027
1028/*---------------------------------------------------------------------------*/
1029/*---------------------------------------------------------------------------*/
1030
1033{
1034 return m_arcane_main->applicationBuildInfo();
1035}
1036
1037/*---------------------------------------------------------------------------*/
1038/*---------------------------------------------------------------------------*/
1039
1042{
1043 return m_arcane_main->dotnetRuntimeInitialisationInfo();
1044}
1045
1046/*---------------------------------------------------------------------------*/
1047/*---------------------------------------------------------------------------*/
1048
1051{
1052 return m_arcane_main->acceleratorRuntimeInitialisationInfo();
1053}
1054
1055/*---------------------------------------------------------------------------*/
1056/*---------------------------------------------------------------------------*/
1057
1059createAndInitializeTraceMng(ITraceMng* parent_trace,const String& file_suffix)
1060{
1063 tmp->initializeTraceMng(tm,parent_trace,file_suffix);
1064 return tm;
1065}
1066
1067/*---------------------------------------------------------------------------*/
1068/*---------------------------------------------------------------------------*/
1069
1072{
1073 return m_data_factory_mng->deprecatedOldFactory();
1074}
1075
1076/*---------------------------------------------------------------------------*/
1077/*---------------------------------------------------------------------------*/
1078
1080dataFactoryMng() const
1081{
1082 return m_data_factory_mng.get();
1083}
1084
1085/*---------------------------------------------------------------------------*/
1086/*---------------------------------------------------------------------------*/
1087
1088} // End namespace Arcane
1089
1090/*---------------------------------------------------------------------------*/
1091/*---------------------------------------------------------------------------*/
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Classes, Types et macros pour gérer la concurrence.
Types et macros pour itérer sur les entités du maillage.
Informations pour construire une instance de IApplication.
String configFileName() const
Nom du fichier de configuration du code.
const String & dataDir() const
Retourne le chemin où se trouve les fichiers de données.
const String & codeName() const
Retourne le nom du code de calcul lié l'application.
bool isDebug() const
Retourne true si on s'exécute en mode debug.
String m_user_config_path
Répertoire de configuration utilisateur.
void _openUserConfig()
Analyse le fichier de configuration de l'utilisateur.
ReferenceCounter< ITraceMng > m_trace
Gestionnaire de traces.
~Application() override
Détruit le gestionnaire.
ModuleFactoryInfoCollection m_main_module_factory_infos
Tableau des fabriques de module.
IDataFactory * dataFactory() override
Fabrique de donnée.
ScopedPtrT< IXmlDocumentHolder > m_config_document
Arbre DOM de la configuration.
const ApplicationBuildInfo & applicationBuildInfo() const override
Informations sur les paramètres de construction de l'instance.
ApplicationInfo m_exe_info
Informations sur l'exécutable.
String m_major_and_minor_version_str
Version M.m.
ITraceMngPolicy * getTraceMngPolicy() override
Politique de configuration d'un gestionnaire de trace.
String m_version_str
Infos sur la configuration.
String m_used_task_service_name
Nom du service utilisé pour gérer les tâches.
ITraceMng * createAndInitializeTraceMng(ITraceMng *parent_trace, const String &file_suffix) override
Créé et initialise une instance de ITraceMng.
IMainFactory * m_main_factory
Manufacture principale.
const DotNetRuntimeInitialisationInfo & dotnetRuntimeInitialisationInfo() const override
Informations d'initialisation du runtime '.Net'.
IMainFactory * mainFactory() const override
Manufacture principale.
Definition Application.h:94
SessionList m_sessions
Liste des sessions.
Ref< InterfaceType > _tryCreateServiceUsingInjector(const StringList &names, String *found_name)
Ref< InterfaceType > _tryCreateService(const StringList &names, String *found_name)
const AcceleratorRuntimeInitialisationInfo & acceleratorRuntimeInitialisationInfo() const override
Informations d'initialisation du runtime pour les accélérateurs.
String m_user_name
Nom de l'utilisateur.
IRessourceMng * m_ressource_mng
Gestionnaire de ressources.
const ApplicationInfo & applicationInfo() const override
Informations sur l'exécutable.
Definition Application.h:82
IDataFactoryMng * dataFactoryMng() const override
Fabrique de donnée.
String m_used_thread_service_name
Nom du service utilisé pour gérer les threads.
XmlNode m_user_config_root_element
Elément racine de la configuration utilisateur.
String m_main_version_str
Version sous la forme Majeur.mineur.beta.
void initialize() override
Initialise l'instance. L'instance n'est pas utilisable tant que cette méthode n'a pas été appelée.
ModuleFactoryInfoCollection moduleFactoryInfos() override
Liste des informations sur les fabriques des modules.
UniqueArray< Byte > m_user_config_bytes
Fichier contenant la configuration utilisateur.
bool m_is_init
true si déjà initialisé
void build() override
Construit les membres de l'instance. L'instance n'est pas utilisable tant que cette méthode n'a pas é...
ITraceMng * traceMng() const override
Gestionnaire de traces.
Definition Application.h:69
XmlNode m_config_root_element
Elément racine de la configuration.
String m_application_name
Nom de l'application.
String m_targetinfo_str
Infos sur la configuration.
ScopedPtrT< IXmlDocumentHolder > m_user_config_document
Arbre DOM de la configuration utilisateur.
ServiceFactoryInfoCollection m_main_service_factory_infos
Tableau des fabriques de service.
ServiceFactory2Collection serviceFactories2() override
Liste des fabriques de service.
bool hasGarbageCollector() const override
Indique que certains objets sont gérés via un ramasse miette.
Ref< ICodeService > getCodeService(const String &file_name) override
Retourne le chargeur de cas correspondant au fichier donné par file_name.
Ref< IParallelSuperMng > m_parallel_super_mng
Gestionnaire du parallélisme.
IServiceMng * m_service_mng
Gestionnaire des services.
void removeSession(ISession *s) override
Supprime la session session.
IIOMng * m_io_mng
Gestionnaire des entrées/sorties.
UniqueArray< Byte > m_config_bytes
Fichier contenant la configuration.
void addSession(ISession *s) override
Ajoute la session session.
Ref< IDataFactoryMng > m_data_factory_mng
Fabrique des données.
IParallelSuperMng * m_sequential_parallel_super_mng
Gestionnaire du parallélisme séquentiel.
Application(IArcaneMain *)
Construit un superviseur avec les informations d'exécution ex.
IParallelSuperMng * parallelSuperMng() override
Gestionnaire superviseur du parallélisme.
Definition Application.h:73
static Real initializationTimeForAccelerator()
Retourne le temps (en seconde) pour l'initialisation des runtimes accélérateurs pour ce processus.
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
EnumeratorT< String > Enumerator
Definition Collection.h:129
Lecteurs de fichiers de configuration.
void addValuesFromXmlNode(const XmlNode &element, Integer priority)
Ajoute des valeurs à la configuration.
void addValuesFromJSON(const JSONValue &jv, Integer priority)
Ajoute des valeurs à la configuration.
Classe utilitaire pour la destruction des objets alloués par new.
Definition Deleter.h:31
Classe gérant un répertoire.
Definition Directory.h:33
virtual String file(const String &file_name) const
Retourne le chemin complet du fichier file_name dans le répertoire.
Definition Directory.cc:138
virtual String path() const
Retourne le chemin du répertoire.
Definition Directory.cc:129
Informations pour l'initialisation du runtime '.Net'.
Interface de l'application.
Interface de la classe de gestion du code.
Definition IArcaneMain.h:54
Interface d'un chargeur de cas.
virtual StringCollection validExtensions() const =0
Retourne la liste des extensions de fichier traitées par l'instance. L'extension ne comprend pas le '...
Gestionnaire de configuration.
Interface du gestionnaire de fabrique d'une donnée.
Interface d'une fabrique d'une donnée.
Interface d'une chargeur dynamique de bibliothèque.
virtual IDynamicLibrary * open(const String &directory, const String &name)=0
Charge une bibliothèque dynamique.
Interface d'une bibliothèque dynamique.
virtual ITraceMng * createTraceMng()=0
Créé un gestionnaire de trace.
Classe abstraite du superviseur de parallélisme.
virtual bool isParallel() const =0
Retourne true si l'exécution est parallèle.
virtual void initialize()=0
Initialise l'instance.
Interface d'un service gérant un système d'unité.
Interface d'un service de de trace des appels de fonctions.
static IRessourceMng * createDefault(IApplication *)
Création d'un gestionnaire d'historique par défaut.
Interface d'un gestionnaire de fabriques de services et modules.
Interface d'une session d'exécution d'un cas.
Definition ISession.h:44
Interface du gestionnaire de configuration d'un gestionnnaire de trace.
virtual void initializeTraceMng(ITraceMng *trace, Int32 rank)=0
Initialise trace.
Interface du gestionnaire de traces.
Gestionnaire d'un document DOM.
virtual XmlNode documentNode()=0
Noeud document. Ce noeud est nul si le document n'existe pas.
Classe de base d'une vue sur une connectivité non structurée.
Vues sur les conteneurs contenant les connectivités. Cette classe permet de rendre opaque en dehors d...
Enumérateur sur une liste d'entités.
Informations de connectivité, pour une famille d'entité, permettant la transition entre les anciennes...
Structure interne d'une entité de maillage.
Index d'un Item dans une variable.
Definition ItemLocalId.h:41
Structure interne partagée d'une entité de maillage.
void build(IParallelSuperMng *parallel_mng, ITraceMng *trace)
Constructeur effectif.
static ItemTypeMng * _singleton()
Instance singleton du type.
Itérateur pour la classe ItemVectorView.
Vue sur un vecteur d'entités.
Classe de base d'un élément de maillage.
Definition Item.h:83
Gestion d'un document JSON.
Definition JSONReader.h:230
void parse(Span< const Byte > bytes)
Lit le fichier au format UTF-8.
JSONValue root() const
Elément racine.
Représente une valeur JSON.
Definition JSONReader.h:43
JSONValue child(StringView name) const
Valeur fille de nom name. Retourne une valeur nulle si non trouvé.
static void setProfilingLevel(Int32 level)
Positionne le niveau de profilage.
Definition Profiling.cc:230
static Int32 profilingLevel()
Niveau de profilage.
Definition Profiling.h:170
Référence à une instance.
InstanceType * get() const
Instance associée ou nullptr si aucune.
Classe utilitaire pour instantier un service d'une interface donnée.
UniqueArray< Ref< InterfaceType > > createAllInstances()
Créé une instance de chaque service qui implémente InterfaceType.
Ref< InterfaceType > createReference(const String &name, eServiceBuilderProperties properties=SB_None)
Créé une instance implémentant l'interface InterfaceType.
Chaîne de caractères unicode.
bool null() const
Retourne true si la chaîne est nulle.
Definition String.cc:304
bool empty() const
Vrai si la chaîne est vide (nulle ou "")
Definition String.cc:315
std::string_view toStdStringView() const
Retourne une vue de la STL sur la chaîne actuelle.
Definition String.cc:348
static void setVerboseLevel(Integer v)
Positionne le niveau de verbosité (0 pour pas d'affichage qui est le défaut)
static Int32 nbAllowedThread()
Nombre de threads utilisés au maximum pour gérer les tâches.
static void terminate()
Indique qu'on n'utilisera plus les threads. Cette méthode ne doit pas être appelée lorsque des tâches...
static bool isActive()
Indique si les tâches sont actives. Les tâches sont actives si une implémentation est disponible et s...
static void printInfos(std::ostream &o)
Affiche les informations sur l'implémentation.
Vecteur 1D de données avec sémantique par valeur (style STL).
Vue sur les connectivités standards d'un maillage non structuré.
Informations sur une version.
Definition VersionInfo.h:46
int versionMajor() const
Retourne le numéro de version majeur.
Definition VersionInfo.h:64
int versionMinor() const
Retourne le numéro de version mineur.
Definition VersionInfo.h:66
int versionPatch() const
Retourne le numéro de version patch.
Definition VersionInfo.h:68
Noeud d'un arbre DOM.
Definition XmlNode.h:51
XmlNode documentElement() const
Retourne le noeud élément du document.
Definition XmlNode.cc:556
bool null() const
Vrai si le noeud est nul.
Definition XmlNode.h:294
ARCCORE_BASE_EXPORT String getHostName()
Nom de la machine sur lequel tourne le processus.
ARCCORE_BASE_EXPORT bool isFileReadable(const String &file_name)
Vérifie que le fichier file_name est accessible et lisible.
IPerformanceCounterService * setPerformanceCounterService(IPerformanceCounterService *service)
Positionne le service utilisé pour gérer les compteurs interne du processeur.
ARCCORE_BASE_EXPORT String getCompilerId()
Chaîne de caractère permettant d'identifier le compilateur utilisé pour compiler Arccore.
ARCCORE_BASE_EXPORT IStackTraceService * getStackTraceService()
Service utilisé pour obtenir la pile d'appel.
ISymbolizerService * setSymbolizerService(ISymbolizerService *service)
Positionne le service pour obtenir des informations sur les symboles du code source.
IDynamicLibraryLoader * getDynamicLibraryLoader()
Service utilisé pour charger dynamiquement des bibliothèques.
ARCCORE_BASE_EXPORT String getCurrentDateTime()
Date et l'heure courante sous la forme ISO 8601.
ARCCORE_BASE_EXPORT double getMemoryUsed()
Mémoire utilisée em octets.
IOnlineDebuggerService * setOnlineDebuggerService(IOnlineDebuggerService *service)
Positionne le service a utiliser pour l'architecture en ligne de debug.
ISymbolizerService * getSymbolizerService()
Service utilisé pour obtenir des informations sur les symboles du code source.
ARCCORE_BASE_EXPORT String getHomeDirectory()
Répertoire contenant les documents utilisateurs.
IProfilingService * getProfilingService()
Service utilisé pour obtenir pour obtenir des informations de profiling.
IProfilingService * setProfilingService(IProfilingService *service)
Positionne le service utilisé pour obtenir des informations de profiling.
ARCCORE_BASE_EXPORT String getEnvironmentVariable(const String &name)
Variable d'environnement du nom name.
ARCCORE_BASE_EXPORT String getUserName()
Nom de l'utilisateur.
IProcessorAffinityService * setProcessorAffinityService(IProcessorAffinityService *service)
Positionne le service utilisé pour la gestion de l'affinité des processeurs.
IProcessorAffinityService * getProcessorAffinityService()
Service utilisé pour la gestion de l'affinité des processeurs.
ARCCORE_BASE_EXPORT IStackTraceService * setStackTraceService(IStackTraceService *service)
Positionne le service utilisé pour obtenir la pile d'appel.
IThreadImplementation * getThreadImplementationService()
Service utilisé pour gérer les threads.
IPerformanceCounterService * getPerformanceCounterService()
Service utilisé pour obtenir pour obtenir les compteurs interne du processeur.
ARCCORE_BASE_EXPORT int getProcessId()
Numéro du processus.
IThreadImplementation * setThreadImplementationService(IThreadImplementation *service)
Positionne le service utilisé pour gérer les threads.
IOnlineDebuggerService * getOnlineDebuggerService()
Service utilisé pour obtenir la mise en place d'une architecture en ligne de debug.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
void setGlobalDataInitialisationPolicy(eDataInitialisationPolicy init_policy)
Positionne la politique d'initialisation des variables.
Definition DataTypes.cc:156
@ SB_AllowNull
Autorise l'absence du service.
bool arcaneIsCheck()
Vrai si on est en mode vérification.
Definition Misc.cc:68
eDataInitialisationPolicy
Type de politique d'initialisation possible pour une donnée.
Definition DataTypes.h:131
@ DIP_InitInitialWithNanResizeWithDefault
Initialisation avec des NaN pour à la création et le constructeur par défaut ensuite.
Definition DataTypes.h:170
@ DIP_Legacy
Initialisation en mode historique.
Definition DataTypes.h:161
@ DIP_None
Pas d'initialisation forcée.
Definition DataTypes.h:133
@ DIP_InitWithNan
Initialisation avec des NaN (Not a Number)
Definition DataTypes.h:148
@ DIP_InitWithDefault
Initialisation avec le constructeur par défaut.
Definition DataTypes.h:140
bool arcaneHasThread()
Vrai si arcane est compilé avec le support des threads ET qu'ils sont actifs.
Definition Misc.cc:99
std::int64_t Int64
Type entier signé sur 64 bits.
void arcaneSetHasThread(bool v)
Active ou désactive le support des threads.
Definition Misc.cc:105
eDataInitialisationPolicy getGlobalDataInitialisationPolicy()
Récupère la politique d'initialisation des variables.
Definition DataTypes.cc:162
Int32 Integer
Type représentant un entier.
Collection< String > StringCollection
Collection de chaînes de caractères.
Definition UtilsTypes.h:593
Collection< Internal::IServiceFactory2 * > ServiceFactory2Collection
Collection de fabriques de service.
Collection< IModuleFactoryInfo * > ModuleFactoryInfoCollection
Collection d'informations sur les fabriques de module.
List< String > StringList
Tableau de chaînes de caractères unicode.
Definition UtilsTypes.h:596
void arcaneSetCheck(bool v)
Active ou désactive le mode vérification.
Definition Misc.cc:74
eItemKind
Genre d'entité de maillage.
double Real
Type représentant un réel.
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
std::int32_t Int32
Type entier signé sur 32 bits.