Arcane  v3.16.2.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
SubDomain.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2024 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/* SubDomain.cc (C) 2000-2024 */
9/* */
10/* Gestionnaire du sous-domaine. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/StdHeader.h"
15#include "arcane/utils/PlatformUtils.h"
16#include "arcane/utils/Iostream.h"
17#include "arcane/utils/ScopedPtr.h"
18#include "arcane/utils/VersionInfo.h"
19#include "arcane/utils/StringBuilder.h"
20#include "arcane/utils/ITraceMng.h"
21#include "arcane/utils/TraceAccessor.h"
22#include "arcane/utils/MemoryInfo.h"
23#include "arcane/utils/List.h"
24#include "arcane/utils/Property.h"
25#include "arcane/utils/TraceAccessor2.h"
26#include "arcane/utils/ValueConvert.h"
27#include "arcane/utils/IProcessorAffinityService.h"
28#include "arcane/utils/IProfilingService.h"
29
30#include "arcane/core/ISubDomain.h"
31#include "arcane/core/IVariableMng.h"
32#include "arcane/core/IModuleMng.h"
33#include "arcane/core/IServiceMng.h"
34#include "arcane/core/IModule.h"
35#include "arcane/core/IModuleMaster.h"
36#include "arcane/core/IEntryPointMng.h"
37#include "arcane/core/IEntryPoint.h"
38#include "arcane/core/IMeshReader.h"
39#include "arcane/core/ITimerMng.h"
40#include "arcane/core/IApplication.h"
41#include "arcane/core/IGhostLayerMng.h"
42#include "arcane/core/ArcaneException.h"
43#include "arcane/core/CaseOptionsMain.h"
44#include "arcane/core/IMesh.h"
45#include "arcane/core/IMeshModifier.h"
46#include "arcane/core/IMeshSubMeshTransition.h"
47#include "arcane/core/Properties.h"
48#include "arcane/core/IParallelMng.h"
49#include "arcane/core/Directory.h"
50#include "arcane/core/ITimeHistoryMng.h"
51#include "arcane/core/ICaseMng.h"
52#include "arcane/core/ICheckpointMng.h"
53#include "arcane/core/IPropertyMng.h"
54#include "arcane/core/ITimeStats.h"
55#include "arcane/core/ITimeLoop.h"
56#include "arcane/core/ITimeLoopMng.h"
57#include "arcane/core/IIOMng.h"
58#include "arcane/core/IMainFactory.h"
59#include "arcane/core/Timer.h"
60#include "arcane/core/CommonVariables.h"
61#include "arcane/core/XmlNode.h"
62#include "arcane/core/ICaseDocument.h"
63#include "arcane/core/IPhysicalUnitSystem.h"
64#include "arcane/core/IPhysicalUnitSystemService.h"
65#include "arcane/core/IService.h"
66#include "arcane/core/IServiceInfo.h"
67#include "arcane/core/ServiceUtils.h"
68#include "arcane/core/IRessourceMng.h"
69#include "arcane/core/ISession.h"
70#include "arcane/core/IMeshStats.h"
71#include "arcane/core/IParallelSuperMng.h"
72#include "arcane/core/IParallelReplication.h"
73#include "arcane/core/IServiceLoader.h"
74#include "arcane/core/ICheckpointReader.h"
75#include "arcane/core/IMeshPartitioner.h"
76#include "arcane/core/ICaseMeshMasterService.h"
77#include "arcane/core/ILoadBalanceMng.h"
78#include "arcane/core/CaseNodeNames.h"
79#include "arcane/core/ModuleBuildInfo.h"
80#include "arcane/core/Observable.h"
81#include "arcane/core/VariableCollection.h"
82#include "arcane/core/SubDomainBuildInfo.h"
83#include "arcane/core/ServiceBuilder.h"
84#include "arcane/core/IMeshUtilities.h"
85#include "arcane/core/IMeshMng.h"
86#include "arcane/core/MeshHandle.h"
87#include "arcane/core/ObserverPool.h"
88#include "arcane/core/ConfigurationPropertyReader.h"
89#include "arcane/core/parallel/IStat.h"
90
91#include "arcane/core/internal/IDataInternal.h"
92#include "arcane/core/internal/ICaseMngInternal.h"
93#include "arcane/core/internal/IParallelMngInternal.h"
94#include "arcane/core/internal/IVariableMngInternal.h"
95
96#include "arcane/impl/ConfigurationReader.h"
97#include "arcane/impl/internal/MeshMng.h"
98#include "arcane/impl/internal/LegacyMeshBuilder.h"
99
100#include "arcane/CaseOptionService.h"
101#include "arcane/CaseOptionBuildInfo.h"
102
103#include "arcane/accelerator/core/IAcceleratorMng.h"
104#include "arcane/accelerator/core/DeviceInfo.h"
105#include "arcane/accelerator/core/Runner.h"
106#include "arcane/accelerator/core/AcceleratorRuntimeInitialisationInfo.h"
107#include "arcane/accelerator/core/IDeviceInfoList.h"
108
109/*---------------------------------------------------------------------------*/
110/*---------------------------------------------------------------------------*/
111
112namespace Arcane
113{
114
115/*---------------------------------------------------------------------------*/
116/*---------------------------------------------------------------------------*/
117
118class MeshBuilderMaster
119{
120 public:
121 MeshBuilderMaster(ICaseMng* cm,const String& default_name)
122 : m_case_options(new Arcane::CaseOptions(cm,".")),
123 m_mesh_service(CaseOptionBuildInfo(_configList(),"meshes", XmlNode(), default_name, 1, 1), false, false)
124 {
125 m_mesh_service.addAlternativeNodeName("fr","maillages");
126 }
127 private:
128 Arcane::ICaseOptionList* _configList() const
129 {
130 return m_case_options->configList();
131 }
132 public:
133 ICaseOptions* options() const { return m_case_options.get(); }
134 public:
135 void createMeshes()
136 {
137 m_mesh_service.instance()->createMeshes();
138 }
139 private:
140 ReferenceCounter<ICaseOptions> m_case_options;
141 CaseOptionServiceT<ICaseMeshMasterService> m_mesh_service;
142};
143
144/*---------------------------------------------------------------------------*/
145/*---------------------------------------------------------------------------*/
151class SubDomain
152: public ISubDomain
153, public internal::TraceAccessor2
154{
155 ARCANE_DECLARE_PROPERTY_CLASS(SubDomain);
156
157 public:
158
160 class PropertyMngCheckpoint
161 : public TraceAccessor
162 {
163 public:
164 explicit PropertyMngCheckpoint(ISubDomain* sd)
165 : TraceAccessor(sd->traceMng()), m_sub_domain(sd),
166 m_property_values(VariableBuildInfo(sd,"ArcaneProperties",IVariable::PPrivate))
167 {
168 init();
169 }
170 public:
171 void init()
172 {
173 m_observers.addObserver(this,
174 &PropertyMngCheckpoint::_notifyWrite,
175 m_property_values.variable()->writeObservable());
176 m_observers.addObserver(this,
177 &PropertyMngCheckpoint::_notifyRead,
178 m_property_values.variable()->readObservable());
179 }
180 private:
181 void _notifyRead()
182 {
183 info(4) << "PropertyMngCheckpoint: READ";
184 m_sub_domain->propertyMng()->readFrom(m_property_values);
185 }
186 void _notifyWrite()
187 {
188 info(4) << "PropertyMngCheckpoint: WRITE";
189 m_sub_domain->propertyMng()->writeTo(m_property_values._internalTrueData()->_internalDeprecatedValue());
190 m_property_values.variable()->syncReferences();
191 }
192 private:
193 ISubDomain* m_sub_domain;
194 ObserverPool m_observers;
195 VariableArrayByte m_property_values;
196 };
197
198 public:
199
200 SubDomain(ISession*,Ref<IParallelMng>,Ref<IParallelMng>,const String& filename,ByteConstArrayView bytes);
201
202 public:
203
204 void build() override;
205 void initialize() override;
206 void destroy() override;
207
208 public:
209
210 IBase* objectParent() const override { return m_application; }
211 String objectNamespaceURI() const override { return m_namespace_uri; }
212 String objectLocalName() const override { return m_local_name; }
213 VersionInfo objectVersion() const override { return VersionInfo(1,0,0); }
214
215 public:
216
217 IMainFactory* mainFactory() override { return m_application->mainFactory(); }
218 ISession* session() const override { return m_session; }
219 IServiceMng* serviceMng() const override { return m_service_mng.get(); }
220 ITimeLoopMng* timeLoopMng() override { return m_time_loop_mng.get(); }
221 IIOMng* ioMng() override { return m_io_mng.get(); }
222 IVariableMng* variableMng() override { return m_variable_mng.get(); }
223 IModuleMng* moduleMng() override { return m_module_mng.get(); }
224 IEntryPointMng* entryPointMng() override { return m_entry_point_mng.get(); }
225 ICaseMng* caseMng() override { return m_case_mng.get(); }
226 ITimerMng* timerMng() const override { return m_timer_mng; }
227 ICheckpointMng* checkpointMng() const override { return m_checkpoint_mng.get(); }
228 IPropertyMng* propertyMng() const override { return m_property_mng.get(); }
229 ITimeStats* timeStats() const override { return m_time_stats; }
230 IRessourceMng* ressourceMng() const override { return m_application->ressourceMng(); }
231 ITraceMng* traceMng() const override { return TraceAccessor::traceMng(); }
232 IMemoryInfo* memoryInfo() const override { return m_memory_info.get(); }
233 IPhysicalUnitSystem* physicalUnitSystem() override { return m_physical_unit_system.get(); }
234 ILoadBalanceMng* loadBalanceMng() override { return m_lb_mng.get(); }
235 IMeshMng* meshMng() const override { return m_mesh_mng.get(); }
236 IModuleMaster* moduleMaster() const override { return m_module_master; }
237 const IConfiguration* configuration() const override { return m_configuration.get(); }
238 IConfiguration* configuration() override { return m_configuration.get(); }
239 IAcceleratorMng* acceleratorMng() override { return m_accelerator_mng.get(); }
240
241 Int32 subDomainId() const override { return m_parallel_mng->commRank(); }
242 Int32 nbSubDomain() const override { return m_parallel_mng->commSize(); }
243 void setIsContinue() override { m_is_continue = true; }
244 bool isContinue() const override { return m_is_continue; }
245 void dumpInfo(std::ostream&) override;
246 void doInitModules() override;
247 void doExitModules() override;
248 IMesh* defaultMesh() override { return m_default_mesh_handle.mesh(); }
249 const MeshHandle& defaultMeshHandle() override { return m_default_mesh_handle; }
250 IMesh* mesh() override { return m_default_mesh_handle.mesh(); }
251 IMesh* findMesh(const String& name,bool throw_exception) override;
252 bool isInitialized() const override { return m_is_initialized; }
253 void setIsInitialized() override;
254 const ApplicationInfo& applicationInfo() const override { return m_application->applicationInfo(); }
255 ICaseDocument* caseDocument() override { return m_case_mng->caseDocument(); }
256 IApplication* application() override { return m_application; }
257 void checkId(const String& where,const String& id) override;
258 const String& caseFullFileName() const override { return m_case_full_file_name; }
259 void setCaseFullFileName(const String& file_name) { m_case_full_file_name = file_name; }
260 const String& caseName() const override { return m_case_name; }
261 void fillCaseBytes(ByteArray& bytes) const override { bytes.copy(m_case_bytes); }
262 void setCaseName(const String& case_name) override { m_case_name = case_name; }
263 void setInitialPartitioner(IInitialPartitioner* partitioner) override
264 {
265 m_legacy_mesh_builder->m_initial_partitioner = partitioner;
266 }
267 void readCaseMeshes() override;
268 void allocateMeshes() override;
269 void readOrReloadMeshes() override;
270 void initializeMeshVariablesFromCaseFile() override;
271 void doInitMeshPartition() override;
272 void addMesh(IMesh* mesh) override;
273 ConstArrayView<IMesh*> meshes() const override;
274 const CaseOptionsMain* caseOptionsMain() const override { return m_case_config; }
275 IParallelMng* parallelMng() override { return m_parallel_mng.get(); }
276 IParallelMng* allReplicaParallelMng() const override { return m_all_replica_parallel_mng.get(); }
277 IThreadMng* threadMng() override { return m_parallel_mng->threadMng(); }
278 const IDirectory& exportDirectory() const override { return m_export_directory; }
279 void setExportDirectory(const IDirectory& dir) override { m_export_directory = dir; }
280 const IDirectory& storageDirectory() const override { return m_storage_directory; }
281 void setStorageDirectory(const IDirectory& dir) override { m_storage_directory = dir; }
282 const IDirectory& listingDirectory() const override { return m_listing_directory; }
283 void setListingDirectory(const IDirectory& dir) override { m_listing_directory = dir; }
284 ITimeHistoryMng* timeHistoryMng() override { return m_time_history_mng.get(); }
285 const CommonVariables& variablesCommon() const { return commonVariables(); }
286 const CommonVariables& commonVariables() const override;
287 void dumpInternalInfos(XmlNode& root) override;
288 Integer meshDimension() const override;
289 IObservable* onDestroyObservable() override { return &m_on_destroy_observable; }
290 IDirectExecution* directExecution() const override { return m_direct_execution; }
291 void setDirectExecution(IDirectExecution* v) override { m_direct_execution = v; }
292
293 public:
294
295 void _setLegacyMeshCreation(bool v){ m_is_create_default_mesh_v2 = !v; }
296 bool isLegacyMeshCreation() const { return !m_is_create_default_mesh_v2; }
297
298 public:
299
300 protected:
301
302 const char* _msgClassName() const { return "Init"; }
303
304 private:
305
306 ISession* m_session;
307 IApplication* m_application;
308 Ref<IParallelMng> m_parallel_mng;
309 Ref<IParallelMng> m_all_replica_parallel_mng;
310 ScopedPtrT<IIOMng> m_io_mng;
311 ScopedPtrT<IMemoryInfo> m_memory_info;
312 ScopedPtrT<IVariableMng> m_variable_mng;
313 ScopedPtrT<IModuleMng> m_module_mng;
314 ScopedPtrT<IEntryPointMng> m_entry_point_mng;
315 Ref<ICaseMng> m_case_mng;
316 ITimerMng* m_timer_mng;
317 ScopedPtrT<ICheckpointMng> m_checkpoint_mng;
318 Ref<IPropertyMng> m_property_mng;
319 ITimeStats* m_time_stats;
320 ScopedPtrT<ITimeLoopMng> m_time_loop_mng;
321 ScopedPtrT<IServiceMng> m_service_mng;
322 ScopedPtrT<IPhysicalUnitSystem> m_physical_unit_system;
323 String m_namespace_uri;
324 String m_local_name;
325 IModuleMaster* m_module_master;
326 ScopedPtrT<ITimeHistoryMng> m_time_history_mng;
327 ScopedPtrT<MeshMng> m_mesh_mng;
328 MeshHandle m_default_mesh_handle;
329 bool m_is_initialized;
330 String m_case_full_file_name;
331 String m_case_name;
332 ByteUniqueArray m_case_bytes;
333 CaseOptionsMain* m_case_config;
334 Directory m_export_directory;
335 Directory m_storage_directory;
336 Directory m_listing_directory;
337 Observable m_on_destroy_observable;
338 bool m_is_continue;
339 IDirectExecution* m_direct_execution;
340 ScopedPtrT<ILoadBalanceMng> m_lb_mng;
341 ScopedPtrT<IConfiguration> m_configuration;
342 bool m_is_create_default_mesh_v2;
343 ScopedPtrT<PropertyMngCheckpoint> m_property_mng_checkpoint;
344 ScopedPtrT<LegacyMeshBuilder> m_legacy_mesh_builder;
346 bool m_has_mesh_service = false;
347 Ref<ICaseMeshMasterService> m_case_mesh_master_service;
348 ObserverPool m_observers;
349 Ref<IAcceleratorMng> m_accelerator_mng;
350
351 private:
352
353 void _doInitialPartition();
354 void _doInitialPartitionForMesh(IMesh* mesh, const String& service_name);
355 void _notifyWriteCheckpoint();
356 void _printCPUAffinity();
357 void _setDefaultAcceleratorDevice(Accelerator::AcceleratorRuntimeInitialisationInfo& config);
358};
359
360/*---------------------------------------------------------------------------*/
361/*---------------------------------------------------------------------------*/
362
363static ISubDomain* global_sub_domain = nullptr;
364
365/* HP: ARCANE_IMPL_EXPORT en attendant de trouver une solution
366 * pour accéder aux traces hors d'un service ou module */
367extern "C" ARCANE_IMPL_EXPORT ISubDomain* _arcaneGetDefaultSubDomain()
368{
369 return global_sub_domain;
370}
371
372/*---------------------------------------------------------------------------*/
373/*---------------------------------------------------------------------------*/
374
375extern "C++" ISubDomain*
376arcaneCreateSubDomain(ISession* session,const SubDomainBuildInfo& sdbi)
377{
378 Ref<IParallelMng> pm = sdbi.parallelMng();
379 Ref<IParallelMng> all_replica_pm = sdbi.allReplicaParallelMng();
380 String case_file_name = sdbi.caseFileName();
381 ByteConstArrayView bytes = sdbi.caseBytes();
382
383 ITraceMng* tm = pm->traceMng();
384 StringBuilder trace_id;
385 trace_id += String::fromNumber(pm->commRank());
386 if (all_replica_pm!=pm){
387 trace_id += ",r";
388 trace_id += pm->replication()->replicationRank();
389 }
390 trace_id += ",";
391 trace_id += platform::getHostName();
392 tm->setTraceId(trace_id.toString());
393
394 auto* sd = new SubDomain(session,pm,all_replica_pm,case_file_name,bytes);
395 sd->build();
396 //GG: l'init se fait par l'appelant
397 //mng->initialize();
398 global_sub_domain = sd;
399 return sd;
400}
401
402/*---------------------------------------------------------------------------*/
403/*---------------------------------------------------------------------------*/
404
405SubDomain::
406SubDomain(ISession* session,Ref<IParallelMng> pm,Ref<IParallelMng> all_replica_pm,
407 const String& case_file_name,ByteConstArrayView bytes)
408: TraceAccessor2(pm->traceMng())
409, m_session(session)
410, m_application(session->application())
411, m_parallel_mng(pm)
412, m_all_replica_parallel_mng(all_replica_pm)
413, m_timer_mng(nullptr)
414, m_time_stats(nullptr)
415, m_namespace_uri(arcaneNamespaceURI())
416, m_module_master(nullptr)
417, m_time_history_mng(nullptr)
418, m_is_initialized(false)
419, m_case_full_file_name(case_file_name)
420, m_case_name("unknown")
421, m_case_bytes(bytes)
422, m_case_config(nullptr)
423, m_storage_directory(".")
424, m_is_continue(false)
425, m_direct_execution(nullptr)
426, m_is_create_default_mesh_v2(false)
427{
428 m_local_name = "SubDomain";
429 m_memory_info = new MemoryInfo();
430}
431
432/*---------------------------------------------------------------------------*/
433/*---------------------------------------------------------------------------*/
434// Cet appel doit être fait depuis une section critique.
435void SubDomain::
436build()
437{
438 IMainFactory* mf = m_application->mainFactory();
439 m_physical_unit_system = m_application->getPhysicalUnitSystemService()->createStandardUnitSystem();
440 m_configuration = m_application->configurationMng()->defaultConfiguration()->clone();
441
442 m_accelerator_mng = mf->createAcceleratorMngRef(traceMng());
443 m_property_mng = mf->createPropertyMngReference(this);
444 m_io_mng = mf->createIOMng(parallelMng());
445 m_variable_mng = mf->createVariableMng(this);
446 m_mesh_mng = new MeshMng(m_application,m_variable_mng.get());
447 m_default_mesh_handle = m_mesh_mng->createDefaultMeshHandle("Mesh0");
448 m_service_mng = mf->createServiceMng(this);
449 m_checkpoint_mng = mf->createCheckpointMng(this);
450 m_module_mng = mf->createModuleMng(this);
451 m_entry_point_mng = mf->createEntryPointMng(this);
452 m_case_mng = mf->createCaseMng(this)->toReference();
453 m_timer_mng = m_parallel_mng->timerMng();
454 m_time_stats = m_parallel_mng->timeStats();
455 m_time_loop_mng = mf->createTimeLoopMng(this);
456 m_legacy_mesh_builder = new LegacyMeshBuilder(this,m_default_mesh_handle);
457}
458
459/*---------------------------------------------------------------------------*/
460/*---------------------------------------------------------------------------*/
461
462void SubDomain::
463initialize()
464{
465 namespace ax = Arcane::Accelerator;
466 // Initialisation du module parallèle
467 // TODO: a supprimer car plus utile
468 m_parallel_mng->initialize();
469
470 {
471 // Initialise le runner par défaut en fonction des paramètres
472 // donnés par l'utilisateur.
473 IApplication* app = application();
474 ax::AcceleratorRuntimeInitialisationInfo config = app->acceleratorRuntimeInitialisationInfo();
475 _setDefaultAcceleratorDevice(config);
476
477 m_accelerator_mng->initialize(config);
478 Runner runner = m_accelerator_mng->runner();
479 const auto& device_info = runner.deviceInfo();
480 info() << "DeviceInfo: name=" << device_info.name();
481 info() << "DeviceInfo: description=" << device_info.description();
482
483 if (Accelerator::impl::isAcceleratorPolicy(runner.executionPolicy())){
484 m_parallel_mng->_internalApi()->setDefaultRunner(runner);
485 m_all_replica_parallel_mng->_internalApi()->setDefaultRunner(runner);
486 }
487 m_variable_mng->_internalApi()->setAcceleratorMng(m_accelerator_mng);
488 }
489
490 _printCPUAffinity();
491
492 IMainFactory* mf = m_application->mainFactory();
493
494 m_time_loop_mng->build();
495
496 m_has_mesh_service = false;
497
498 // Lit le jeu de données.
499 // Il s'agit uniquement de s'assurer de la validité syntaxique
500 // du jeu de données. Les options ne sont pas lues.
501 // Cela doit être fait avant la création du maillage
502 // car l'instance du maillage dépend du jeu de données
503 ICaseDocument* case_document = nullptr;
504 if (!m_case_bytes.empty()){
505 case_document = m_case_mng->readCaseDocument(m_case_full_file_name,m_case_bytes);
506 if (!case_document)
507 ARCANE_FATAL("Can not read case options");
508 // Ajoute à la configuration celle présente dans le jeu de données.
509 {
510 ConfigurationReader cr(traceMng(),m_configuration.get());
511 cr.addValuesFromXmlNode(case_document->configurationElement(),ConfigurationReader::P_CaseDocument);
512 }
513 }
514
515 properties::readFromConfiguration(m_configuration.get(),*this);
516
517 if (case_document){
518 // Regarde s'il y a un tag <meshes> indiquant que la création et
519 // la lecture du maillage sera gérée par un service
520 XmlNode meshes_elem = case_document->meshesElement();
521 if (!meshes_elem.null()){
522 info() << "Using mesh service to create and allocate meshes";
523 m_has_mesh_service = true;
524 }
525 // TODO: dans ce cas vérifier qu'on n'a pas l'élément 'maillage' historique.
526 }
527 // Créé le maillage par défaut. Il faut le faire avant la création
528 // des services, car ces derniers peuvent en avoir besoin.
529 if (!m_has_mesh_service)
530 if (!m_is_create_default_mesh_v2)
531 m_legacy_mesh_builder->createDefaultMesh();
532
533 ScopedPtrT<IServiceLoader> service_loader(mf->createServiceLoader());
534 service_loader->loadSubDomainServices(this);
535
536 // Le module maître doit toujours être créé avant les autres pour que
537 // ses points d'entrées soient appelés en premier et dernier
538 m_module_master = mf->createModuleMaster(this);
539 m_time_history_mng = mf->createTimeHistoryMng(this);
540
541 service_loader->initializeModuleFactories(this);
542 m_lb_mng = mf->createLoadBalanceMng(this);
543
544 m_property_mng_checkpoint = new PropertyMngCheckpoint(this);
545
546 m_observers.addObserver(this,
547 &SubDomain::_notifyWriteCheckpoint,
548 m_checkpoint_mng->writeObservable());
549}
550
551/*---------------------------------------------------------------------------*/
552/*---------------------------------------------------------------------------*/
553
554void SubDomain::
555_setDefaultAcceleratorDevice(Accelerator::AcceleratorRuntimeInitialisationInfo& config)
556{
557 // Choix de l'accélérateur à utiliser
558 // Si plusieurs accélérateurs sont disponibles, il faut en choisir un par défaut.
559 // On considère que tous les noeuds ont le même nombre d'accélérateur.
560 // Dans ce cas, on prend comme accélérateur par défaut le i-ème accélérateur disponible,
561 // avec \a i choisi comme étant notre rang modulo le nombre d'accélérateur disponible sur
562 // le noeud.
563 // NOTE: cela fonctionne bien si on utilise un seul processus par accélérateur.
564 // Si on en utilise plus, il faudrait plutôt prendre les rangs consécutifs pour
565 // le même accélérateur.
566 // TODO: Regarder aussi pour voir comment utiliser plutôt l'accélérateur le plus proche
567 // de notre rang. Pour cela il faudrait utiliser des bibliothèque comme HWLOC
568 //
569 auto* device_list = Runner::deviceInfoList(config.executionPolicy());
570
571 Int32 modulo_device = 0;
572 if (device_list){
573 Int32 nb_device = device_list->nbDevice();
574 info() << "DeviceInfo: nb_device=" << nb_device;
575 modulo_device = nb_device;
576 }
577
578 // TODO: faire cela ailleurs
579 if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_ACCELERATOR_PARALLELMNG_RANK_FOR_DEVICE",true)){
580 Int32 modulo = v.value();
581 if (modulo==0)
582 modulo = 1;
583 modulo_device = modulo;
584 info() << "Use commRank() to choose accelerator device with modulo=" << modulo;
585 }
586 if (modulo_device!=0){
587 Int32 device_rank = m_parallel_mng->commRank() % modulo_device;
588 info() << "Using device number=" << device_rank;
589 config.setDeviceId(Accelerator::DeviceId(device_rank));
590 }
591}
592
593/*---------------------------------------------------------------------------*/
594/*---------------------------------------------------------------------------*/
595
596void SubDomain::
597destroy()
598{
599 m_case_mesh_master_service.reset();
600
601 m_property_mng_checkpoint = nullptr;
602
603 m_on_destroy_observable.notifyAllObservers();
604 m_on_destroy_observable.detachAllObservers();
605
606 platform::callDotNETGarbageCollector();
607
608 // Normalement on devrait pouvoir supprimer ce test car il ne devrait plus
609 // rester de références sur des services ou module. Cela est le cas
610 // avec l'implémentation 'coreclr' mais pas avec 'mono'. Du coup on
611 // laisse pour l'instant ce test.
612 // A partir de la version 3.7.8, la plupart des problèmes potentiels dus au GC sont
613 // réglés donc il n'est pas nécessaire de retourner directement. Néanmmoins
614 // il reste encore des problèmes avec l'utilisation des 'ICaseFunction'.
615 // On garde donc la possibilité de changer le comportement si une variable
616 // d'environnement est positionnée.
617 if (m_application->hasGarbageCollector()){
618 bool do_return = true;
619 String x = platform::getEnvironmentVariable("ARCANE_DOTNET_USE_LEGACY_DESTROY");
620 if (x=="1")
621 do_return = true;
622 if (x=="0")
623 do_return = false;
624 if (do_return)
625 return;
626 }
627
628 m_module_master = nullptr;
629
630 m_module_mng->removeAllModules();
631 m_service_mng = nullptr;
632 m_time_history_mng = nullptr;
633 m_mesh_mng->destroyMeshes();
634
635 m_time_loop_mng = nullptr;
636 m_case_mng.reset();
637 m_entry_point_mng = nullptr;
638 m_module_mng = nullptr;
639 m_io_mng = nullptr;
640
641 m_lb_mng = nullptr;
642 m_property_mng.reset();
643
644 // Comme tous les objets peuvent contenir des variables, il faut être
645 // certain de détruire le gestionnaire de variables en dernier.
646 m_variable_mng->_internalApi()->removeAllVariables();
647 m_variable_mng = nullptr;
648
649 delete this;
650}
651
652/*---------------------------------------------------------------------------*/
653/*---------------------------------------------------------------------------*/
654
655void SubDomain::
656dumpInfo(std::ostream& o)
657{
658 m_module_mng->dumpList(o);
659}
660
661/*---------------------------------------------------------------------------*/
662/*---------------------------------------------------------------------------*/
663
664
665/*---------------------------------------------------------------------------*/
666/*---------------------------------------------------------------------------*/
673void SubDomain::
674allocateMeshes()
675{
676 info() << "SubDomain: Allocating meshes";
677 MessagePassing::dumpDateAndMemoryUsage(parallelMng(), traceMng());
678
679 Timer::Action ts_action2(this,"AllocateMesh");
680 Trace::Setter mci(traceMng(),_msgClassName());
681
682 if (m_has_mesh_service){
683 info() << "** Reading mesh from mesh service";
684 const CaseNodeNames* cnn = caseMng()->caseDocument()->caseNodeNames();
685 String default_service_name = "ArcaneCaseMeshMasterService";
686
687 // NOTE: cet objet sera détruit par caseMng()
688 ICaseOptions* opt = new CaseOptions(caseMng(),cnn->meshes);
689 ServiceBuilder<ICaseMeshMasterService> sb(application(),opt);
690 Ref<ICaseMeshMasterService> mbm = sb.createReference(default_service_name);
691 m_case_mesh_master_service = mbm;
692 m_case_mng->_internalImpl()->internalReadOneOption(mbm->_options(),true);
693 mbm->createMeshes();
694 }
695 else{
696 if (m_is_create_default_mesh_v2)
697 m_legacy_mesh_builder->createDefaultMesh();
698
699 m_legacy_mesh_builder->allocateMeshes();
700 }
701}
702
703/*---------------------------------------------------------------------------*/
704/*---------------------------------------------------------------------------*/
705
706void SubDomain::
707readOrReloadMeshes()
708{
709 info() << "SubDomain: read or reload meshes";
710 MessagePassing::dumpDateAndMemoryUsage(parallelMng(), traceMng());
711 logdate() << "Initialisation du code.";
712
713 Integer nb_mesh = m_mesh_mng->meshes().size();
714 info() << " nb_mesh_created=" << nb_mesh
715 << " is_continue?=" << m_is_continue;
716
717 A_INFO("Test: {1}",A_TR2("nb_mesh_created",nb_mesh),A_TR(m_is_continue));
718
719 //info() << format4("Test: {1}",{A_PR2("nb_mesh_created",nb_mesh),A_PR(m_is_continue)});
720 //info() << format5(A_PR2("nb_mesh_created",nb_mesh),A_PR(m_is_continue));
721
722 // Regarde si on active le profiling lors de l'initialisation
723 IProfilingService* ps = nullptr;
724 if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_PROFILE_CREATE_MESH", true))
725 if (v.value()!=0)
726 ps = platform::getProfilingService();
727
728 {
729 ProfilingSentryWithInitialize ps_sentry(ps);
730 ps_sentry.setPrintAtEnd(true);
731
732 if (m_is_continue){
733 for( Integer z=0; z<nb_mesh; ++z ){
734 IPrimaryMesh* mesh = m_mesh_mng->getPrimaryMesh(z);
735 mesh->reloadMesh();
736 }
737 }
738 else{
739 if (m_has_mesh_service){
740 m_case_mesh_master_service->allocateMeshes();
741 }
742 else
743 m_legacy_mesh_builder->readMeshes();
744 }
745 }
746
747 //warning() << "CODE CHANGED IN DEV-X10. NEED TEST";
748 //mesh->computeTiedInterfaces(mbi.m_xml_node);
750 // mesh->readAmrActivator(mbi.m_xml_node);
751
752 // Vérifie la cohérence du maillage
753 for( Integer z=0; z<nb_mesh; ++z ){
754 IMesh* mesh = m_mesh_mng->getMesh(z);
755 mesh->checkValidMesh();
756 mesh->nodesCoordinates().setUpToDate();
757 }
758}
759
760/*---------------------------------------------------------------------------*/
761/*---------------------------------------------------------------------------*/
762
763void SubDomain::
764addMesh(IMesh* mesh)
765{
766 m_mesh_mng->addMesh(mesh);
767}
768
769/*---------------------------------------------------------------------------*/
770/*---------------------------------------------------------------------------*/
771
772ConstArrayView<IMesh*> SubDomain::
773meshes() const
774{
775 return m_mesh_mng->meshes();
776}
777
778/*---------------------------------------------------------------------------*/
779/*---------------------------------------------------------------------------*/
780
781void SubDomain::
782initializeMeshVariablesFromCaseFile()
783{
784 if (!m_has_mesh_service)
785 m_legacy_mesh_builder->initializeMeshVariablesFromCaseFile();
786}
787
788/*---------------------------------------------------------------------------*/
789/*---------------------------------------------------------------------------*/
790
791void SubDomain::
792doInitMeshPartition()
793{
794 if (!m_is_continue){
795 IInitialPartitioner* init_part = m_legacy_mesh_builder->m_initial_partitioner.get();
796 if (init_part){
797 info() << "Using custom initial partitioner";
798 init_part->partitionAndDistributeMeshes(m_mesh_mng->meshes());
799 }
800 else{
801 if (m_case_mesh_master_service.get()){
802 m_case_mesh_master_service->partitionMeshes();
803 m_case_mesh_master_service->applyAdditionalOperationsOnMeshes();
804 }
805 else
806 if (m_legacy_mesh_builder->m_use_internal_mesh_partitioner)
807 _doInitialPartition();
808 }
809 }
810
811 // Affichage des informations du maillage
812 for( IMesh* mesh : m_mesh_mng->meshes() ){
813 ScopedPtrT<IMeshStats> mh(IMeshStats::create(traceMng(),mesh,parallelMng()));
814 mh->dumpStats();
815 }
816}
817
818/*---------------------------------------------------------------------------*/
819/*---------------------------------------------------------------------------*/
823void SubDomain::
824doInitModules()
825{
826}
827
828/*---------------------------------------------------------------------------*/
829/*---------------------------------------------------------------------------*/
830
831void SubDomain::
832_doInitialPartition()
833{
834 // NOTE: Ce code n'est utilisé que par le mécanisme historique de création
835 // de maillage. Lorsqu'on utilise les maillages pour les services, le code
836 // correspondant est dans ArcaneCaseMeshService.
837
838 String test_service = "MeshPartitionerTester";
839
840 for( IMesh* mesh : m_mesh_mng->meshes() ){
841 bool is_mesh_allocated = mesh->isAllocated();
842 info() << "InitialPartitioning mesh=" << mesh->name() << " is_allocated?=" << is_mesh_allocated;
843 if (!is_mesh_allocated)
844 continue;
845 // Comme 'parmetis' n'aime pas repartitionner un maillage si un des sous-domaines
846 // est vide (ce qui est le cas si un seul processeur créé les mailles), il
847 // faut d'abord utiliser le partitionneur basique qui répartit les mailles
848 // entre les sous-domaines, puis 'parmetis' s'il est présent
849 if (m_legacy_mesh_builder->m_use_partitioner_tester) {
850 Int64 nb_cell = mesh->nbCell();
851 Int64 min_nb_cell = parallelMng()->reduce(Parallel::ReduceMin,nb_cell);
852 info() << "Min nb cell=" << min_nb_cell;
853 if (min_nb_cell==0)
854 _doInitialPartitionForMesh(mesh, test_service);
855 else
856 info() << "Mesh name=" << mesh->name() << " have cells. Do not use " << test_service;
857 }
858 else
859 info() << "No basic partition first needed";
860 _doInitialPartitionForMesh(mesh, m_legacy_mesh_builder->m_internal_partitioner_name);
861 }
862}
863
864/*---------------------------------------------------------------------------*/
865/*---------------------------------------------------------------------------*/
866
867void SubDomain::
868_doInitialPartitionForMesh(IMesh* mesh, const String& service_name)
869{
870 info() << "DoInitialPartition. mesh=" << mesh->name() << " service=" << service_name;
871
872 String lib_name = service_name;
873 IMeshPartitionerBase* mesh_partitioner_base = nullptr;
874 Ref<IMeshPartitionerBase> mesh_partitioner_base_ref;
875 Ref<IMeshPartitioner> mesh_partitioner_ref;
876
877 ServiceBuilder<IMeshPartitionerBase> sbuilder(this);
878 mesh_partitioner_base_ref = sbuilder.createReference(service_name,mesh,SB_AllowNull);
879 mesh_partitioner_base = mesh_partitioner_base_ref.get();
880
881 if (!mesh_partitioner_base){
882 // Si pas trouvé, recherche avec l'ancienne interface 'IMeshPartitioner' pour des
883 // raisons de compatibilité
884 pwarning() << "No implementation for 'IMeshPartitionerBase' interface found. "
885 << "Searching implementation for legacy 'IMeshPartitioner' interface";
886 ServiceBuilder<IMeshPartitioner> sbuilder_legacy(this);
887 mesh_partitioner_ref = sbuilder_legacy.createReference(service_name,mesh,SB_AllowNull);
888 if (mesh_partitioner_ref.get())
889 mesh_partitioner_base = mesh_partitioner_ref.get();
890 }
891
892 if (!mesh_partitioner_base){
893 // Si pas trouvé, récupère la liste des valeurs possibles et les affiche.
894 StringUniqueArray valid_names;
895 sbuilder.getServicesNames(valid_names);
896 String valid_values = String::join(", ",valid_names);
897 String msg = String::format("The specified service for the initial mesh partitionment ({0}) "
898 "is not available (valid_values={1}). This service has to implement "
899 "interface Arcane::IMeshPartitionerBase",
900 lib_name,valid_values);
901 ARCANE_THROW(ParallelFatalErrorException, msg);
902 }
903
904 bool is_dynamic = mesh->isDynamic();
905 mesh->modifier()->setDynamic(true);
906 mesh->utilities()->partitionAndExchangeMeshWithReplication(mesh_partitioner_base,true);
907 mesh->modifier()->setDynamic(is_dynamic);
908}
909
910/*---------------------------------------------------------------------------*/
911/*---------------------------------------------------------------------------*/
912
913void SubDomain::
914doExitModules()
915{
916 if (!m_is_initialized)
917 ARCANE_FATAL("Uninitialized session");
918
919 logdate() << "Execution of the end of compute entry points";
920
921 // Sauve les données du gestionnaire d'historique si demandé
922 if (caseOptionsMain()->doTimeHistory())
923 m_time_history_mng->dumpHistory(true);
924
925 m_time_loop_mng->execExitEntryPoints();
926
927 m_parallel_mng->printStats();
928
929 traceMng()->flush();
930}
931
932/*---------------------------------------------------------------------------*/
933/*---------------------------------------------------------------------------*/
934
935void SubDomain::
936checkId(const String& where,const String& id)
937{
938 Int64 len = id.length();
939 const char* str = id.localstr();
940 if (len==0 || !str)
941 throw BadIDException(where,id);
942
943 if (!isalpha(str[0]))
944 throw BadIDException(where,id);
945 for( Int64 i=1; i<len; ++i )
946 if (!isalpha(str[i]) && !isdigit(str[i]) && str[i]!='_' && str[i]!='.')
947 throw BadIDException(where,id);
948}
949
950/*---------------------------------------------------------------------------*/
951/*---------------------------------------------------------------------------*/
952
953void SubDomain::
954readCaseMeshes()
955{
956 Trace::Setter mci(traceMng(),_msgClassName());
957
958 info() << "Reading the case `" << m_case_full_file_name << "'";
959
960 ICaseDocument* case_doc = caseDocument();
961 if (!case_doc)
962 ARCANE_FATAL("No input data");
963
964 m_legacy_mesh_builder->readCaseMeshes();
965 m_case_config = m_module_master->caseoptions();
966}
967
968/*---------------------------------------------------------------------------*/
969/*---------------------------------------------------------------------------*/
970
971const CommonVariables& SubDomain::
972commonVariables() const
973{
974 if (!m_module_master)
975 throw BadReferenceException("module master in SubDomain::variablesCommon()");
976 return *m_module_master->commonVariables();
977}
978
979/*---------------------------------------------------------------------------*/
980/*---------------------------------------------------------------------------*/
981
982void SubDomain::
983dumpInternalInfos(XmlNode& root)
984{
985 // Info sur la boucle en temps utilisée.
986 {
987 ITimeLoopMng* tlm = timeLoopMng();
988 ITimeLoop* time_loop = tlm->usedTimeLoop();
989 XmlElement time_loop_elem(root,"timeloopinfo");
990 XmlElement title(time_loop_elem,"title",time_loop->title());
991 XmlElement description(time_loop_elem,"description",time_loop->description());
992
993 String ustr_userclass("userclass");
994 for( StringCollection::Enumerator j(time_loop->userClasses()); ++j; )
995 XmlElement elem(time_loop_elem,ustr_userclass,*j);
996 }
997
998 VariableRefList var_ref_list;
999 XmlElement modules(root,"modules");
1000
1001 String ustr_module("module");
1002 String ustr_name("name");
1003 String ustr_activated("activated");
1004 String ustr_true("true");
1005 String ustr_false("false");
1006 String ustr_variable("variable");
1007 String ustr_variable_ref("variable-ref");
1008 String ustr_ref("ref");
1009 String ustr_datatype("datatype");
1010 String ustr_dimension("dimension");
1011 String ustr_kind("kind");
1012 String ustr_caseblock("caseblock");
1013 String ustr_tagname("tagname");
1014
1015 // Liste des modules avec les variables qu'ils utilisent.
1016 for( ModuleCollection::Enumerator i(moduleMng()->modules()); ++i; ){
1017 XmlElement module_element(modules,ustr_module);
1018 module_element.setAttrValue(ustr_name,(*i)->name());
1019 bool is_activated = (*i)->used();
1020 module_element.setAttrValue(ustr_activated,is_activated ? ustr_true : ustr_false);
1021 var_ref_list.clear();
1022 variableMng()->variables(var_ref_list,*i);
1023 for( VariableRefList::Enumerator j(var_ref_list); ++j; ){
1024 XmlElement variable_element(module_element,ustr_variable_ref);
1025 variable_element.setAttrValue(ustr_ref,(*j)->name());
1026 }
1027 }
1028
1029 // Liste des variables.
1030 XmlElement variables(root,"variables");
1031 VariableCollection var_prv_list = variableMng()->variables();
1032 for( VariableCollection::Enumerator j(var_prv_list); ++j; ){
1033 XmlElement elem(variables,ustr_variable);
1034 IVariable* var = *j;
1035 String dim = String::fromNumber(var->dimension());
1036 elem.setAttrValue(ustr_name,var->name());
1037 elem.setAttrValue(ustr_datatype,dataTypeName(var->dataType()));
1038 elem.setAttrValue(ustr_dimension,dim);
1039 elem.setAttrValue(ustr_kind,itemKindName(var->itemKind()));
1040 }
1041
1042 // Liste des blocs d'options
1043 const ICaseMng* cm = caseMng();
1044 CaseOptionsCollection blocks = cm->blocks();
1045 XmlElement blocks_elem(root,"caseblocks");
1046 for( CaseOptionsCollection::Enumerator i(blocks); ++i; ){
1047 const ICaseOptions* block = *i;
1048 XmlElement block_elem(blocks_elem,ustr_caseblock);
1049 block_elem.setAttrValue(ustr_tagname,block->rootTagName());
1050 const IModule* block_module = block->caseModule();
1051 if (block_module)
1052 block_elem.setAttrValue(ustr_module,block_module->name());
1053 }
1054}
1055
1056/*---------------------------------------------------------------------------*/
1057/*---------------------------------------------------------------------------*/
1058
1059Integer SubDomain::
1060meshDimension() const
1061{
1062 return m_default_mesh_handle.mesh()->dimension();
1063}
1064
1065/*---------------------------------------------------------------------------*/
1066/*---------------------------------------------------------------------------*/
1067
1068IMesh* SubDomain::
1069findMesh(const String& name,bool throw_exception)
1070{
1071 return m_mesh_mng->findMesh(name,throw_exception);
1072}
1073
1074/*---------------------------------------------------------------------------*/
1075/*---------------------------------------------------------------------------*/
1076
1077void SubDomain::
1078_notifyWriteCheckpoint()
1079{
1080 info(4) << "SubDomain::_notifyWriteCheckpoint()";
1081 {
1082 Properties time_stats_properties(propertyMng(),"TimeStats");
1083 timeStats()->saveTimeValues(&time_stats_properties);
1084 }
1085 {
1086 Properties p(propertyMng(),"MessagePassingStats");
1087 parallelMng()->stat()->saveValues(traceMng(),&p);
1088 }
1089}
1090
1091/*---------------------------------------------------------------------------*/
1092/*---------------------------------------------------------------------------*/
1093
1094void SubDomain::
1095setIsInitialized()
1096{
1097 m_is_initialized = true;
1098 info(4) << "SubDomain::setIsInitialized()";
1099 {
1100 Properties time_stats_properties(propertyMng(),"TimeStats");
1101 timeStats()->mergeTimeValues(&time_stats_properties);
1102 }
1103 {
1104 Properties p(propertyMng(),"MessagePassingStats");
1105 parallelMng()->stat()->mergeValues(traceMng(),&p);
1106 }
1107}
1108
1109/*---------------------------------------------------------------------------*/
1110/*---------------------------------------------------------------------------*/
1116void SubDomain::
1117_printCPUAffinity()
1118{
1119 bool do_print_affinity = false;
1120 if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_PRINT_CPUAFFINITY", true))
1121 do_print_affinity = (v.value()>0);
1122 if (!do_print_affinity)
1123 return;
1124 info() << "PrintCPUAffinity";
1125 IProcessorAffinityService* pas = platform::getProcessorAffinityService();
1126
1127 // Il est possible que certains sous-domaines n'aient pas d'instance
1128 // de 'IProcessorAffinityService'. Dans ce cas on n'affichera que des '0'.
1129
1130 UniqueArray<Byte> cpuset_bytes;
1131 const Int32 nb_byte = 48;
1132 if (pas){
1133 String cpuset = pas->cpuSetString();
1134 cpuset_bytes = cpuset.bytes();
1135 }
1136 cpuset_bytes.resize(nb_byte,Byte{0});
1137 cpuset_bytes[nb_byte-1] = Byte{0};
1138
1139 IParallelMng* pm = parallelMng();
1140 const Int32 nb_rank = pm->commSize();
1141 bool is_master = pm->isMasterIO();
1142
1143 UniqueArray2<Byte> all_cpuset_bytes;
1144 if (is_master)
1145 all_cpuset_bytes.resize(nb_rank,nb_byte);
1146 pm->gather(cpuset_bytes,all_cpuset_bytes.viewAsArray(),pm->masterIORank());
1147 if (is_master)
1148 for( Int32 i=0; i<nb_rank; ++i ){
1149 info() << "CPUAffinity " << Trace::Width(5) << i << " = " << all_cpuset_bytes[i].data();
1150 }
1151}
1152
1153/*---------------------------------------------------------------------------*/
1154/*---------------------------------------------------------------------------*/
1155
1156/*---------------------------------------------------------------------------*/
1157/*---------------------------------------------------------------------------*/
1158
1159template<typename V> void SubDomain::
1160_applyPropertyVisitor(V& p)
1161{
1162 auto b = p.builder();
1163
1164 p << b.addBool("LegacyMeshCreation")
1165 .addDescription("Using legacy mesh creation")
1166 .addGetter([](auto a) { return a.x.isLegacyMeshCreation(); })
1167 .addSetter([](auto a) { a.x._setLegacyMeshCreation(a.v); });
1168}
1169
1170/*---------------------------------------------------------------------------*/
1171/*---------------------------------------------------------------------------*/
1172
1173ARCANE_REGISTER_PROPERTY_CLASS(SubDomain,());
1174
1175/*---------------------------------------------------------------------------*/
1176/*---------------------------------------------------------------------------*/
1177
1178} // End namespace Arcane
1179
1180/*---------------------------------------------------------------------------*/
1181/*---------------------------------------------------------------------------*/
Arcane::Accelerator::impl::isAcceleratorPolicy
bool isAcceleratorPolicy(eExecutionPolicy exec_policy)
Indique si exec_policy correspond à un accélérateur.
Definition AcceleratorCoreGlobal.h:187
ARCANE_THROW
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
Definition ArcaneGlobal.h:753
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:764
Arcane::Accelerator::AcceleratorRuntimeInitialisationInfo::executionPolicy
eExecutionPolicy executionPolicy() const
Politique d'exécution associée à acceleratorRuntime()
Definition AcceleratorRuntimeInitialisationInfo.cc:155
Arcane::Accelerator::AcceleratorRuntimeInitialisationInfo::setDeviceId
void setDeviceId(DeviceId name)
Positionne le device associé au Runner associé.
Definition AcceleratorRuntimeInitialisationInfo.cc:146
Arcane::Accelerator::IAcceleratorMng
Interface du gestionnaire des accélérateurs.
Definition IAcceleratorMng.h:38
Arcane::Accelerator::Runner
Gestionnaire d'exécution pour accélérateur.
Definition core/Runner.h:68
Arcane::Accelerator::Runner::deviceInfo
const DeviceInfo & deviceInfo() const
Information sur le device associé à cette instance.
Definition Runner.cc:433
Arcane::Accelerator::Runner::executionPolicy
eExecutionPolicy executionPolicy() const
Politique d'exécution associée.
Definition Runner.cc:302
Arcane::ApplicationInfo
Informations sur une application.
Definition ApplicationInfo.h:39
Arcane::Array2::viewAsArray
ArrayView< DataType > viewAsArray()
Vue du tableau sous forme de tableau 1D.
Definition arccore/src/collections/arccore/collections/Array2.h:244
Arcane::Array2::resize
void resize(Integer size)
Redimensionnement de la deuxième dimension du tableau.
Definition AnyItemArray2.h:73
Arcane::Array::resize
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
Definition arccore/src/collections/arccore/collections/Array.h:1213
Arcane::Array::copy
void copy(Span< const T > rhs)
Copie les valeurs de rhs dans l'instance.
Definition arccore/src/collections/arccore/collections/Array.h:1390
Arcane::BadIDException
Exception sur un identifiant non valide.
Definition ArcaneException.h:48
Arcane::BadReferenceException
Exception lorsqu'on essaie de déréférencer un pointer nul.
Definition ArcaneException.h:219
Arcane::CaseNodeNames
Noms des noeuds XML d'un jeu de données Arcane.
Definition CaseNodeNames.h:33
Arcane::CaseOptionBuildInfo
Informations pour construire une option de jeu de données.
Definition CaseOptionBuildInfo.h:40
Arcane::CaseOptions
Classe de base d'une liste d'options du jeu de données.
Definition CaseOptions.h:57
Arcane::CollectionBase::clear
void clear()
Supprime tous les éléments de la collection.
Definition Collection.h:68
Arcane::Collection< String >::Enumerator
EnumeratorT< String > Enumerator
Definition Collection.h:129
Arcane::CommonVariables
Variables communes d'un cas.
Definition CommonVariables.h:39
Arcane::ConfigurationReader
Lecteurs de fichiers de configuration.
Definition ConfigurationReader.h:38
Arcane::ConfigurationReader::addValuesFromXmlNode
void addValuesFromXmlNode(const XmlNode &element, Integer priority)
Ajoute des valeurs à la configuration.
Definition ConfigurationReader.cc:30
Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arcane::Convert::ScalarType< Int32 >::tryParseFromEnvironment
static std::optional< Int32 > tryParseFromEnvironment(StringView s, bool throw_if_invalid)
Definition Convert.cc:122
Arcane::Directory
Classe gérant un répertoire.
Definition Directory.h:33
Arcane::IApplication
Interface de l'application.
Definition IApplication.h:57
Arcane::IApplication::acceleratorRuntimeInitialisationInfo
virtual const AcceleratorRuntimeInitialisationInfo & acceleratorRuntimeInitialisationInfo() const =0
Informations d'initialisation du runtime pour les accélérateurs.
Arcane::IBase
Interface de la classe de base des objets principaux arcane.
Definition IBase.h:38
Arcane::IBase::traceMng
virtual ITraceMng * traceMng() const =0
Gestionnaire de traces.
Arcane::ICaseDocument
Interface d'une classe gérant un document XML du jeu de données.
Definition ICaseDocument.h:102
Arcane::ICaseDocument::configurationElement
virtual XmlNode configurationElement()=0
Retourne l'élément des informations de configuration.
Arcane::ICaseDocument::meshesElement
virtual XmlNode meshesElement()=0
Elément contenant la liste des maillages (nouveau mécanisme) (peut être nul)
Arcane::ICaseDocument::caseNodeNames
virtual CaseNodeNames * caseNodeNames()=0
Retourne l'instance contenant les noms des noeuds XML par langage.
Arcane::ICaseMng
Interface du gestionnaire de cas.
Definition ICaseMng.h:56
Arcane::ICaseMng::blocks
virtual CaseOptionsCollection blocks() const =0
Collection des blocs d'options.
Arcane::ICaseMng::caseDocument
virtual ICaseDocument * caseDocument()=0
Document XML du jeu de données (peut être nul si pas de jeu de donneés)
Arcane::ICaseOptionList
Interface d'une liste d'options du jeu de données.
Definition ICaseOptionList.h:38
Arcane::ICaseOptions
Interface d'une liste d'options du jeu de données.
Definition ICaseOptions.h:35
Arcane::ICaseOptions::caseModule
virtual IModule * caseModule() const =0
Retourne le module associé ou nullptr s'il n'y en a pas.
Arcane::ICaseOptions::rootTagName
virtual String rootTagName() const =0
Nom de l'élément dans le langage du jeu de données.
Arcane::ICheckpointMng
Interface du gestionnaire des informations des protections.
Definition ICheckpointMng.h:46
Arcane::IConfiguration
Interface d'une configuration.
Definition Configuration.h:62
Arcane::IDirectExecution
Interface d'un service d'exécution direct.
Definition IDirectExecution.h:47
Arcane::IDirectory
Interface d'une classe gérant un répertoire.
Definition IDirectory.h:31
Arcane::IEntryPointMng
Interface du gestionnaire de point d'entrée.
Definition IEntryPointMng.h:32
Arcane::IIOMng
Interface du gestionnaire des entrées sorties.
Definition IIOMng.h:42
Arcane::IInitialPartitioner
Interface d'un partitionneur initial.
Definition IInitialPartitioner.h:40
Arcane::IInitialPartitioner::partitionAndDistributeMeshes
virtual void partitionAndDistributeMeshes(ConstArrayView< IMesh * > meshes)=0
Partitionne les maillages.
Arcane::ILoadBalanceMng
Interface d'enregistrement des variables pour l'equilibrage de charge.
Definition ILoadBalanceMng.h:35
Arcane::IMainFactory
Manufacture des classes d'Arcane.
Definition IMainFactory.h:93
Arcane::IMainFactory::createPropertyMngReference
virtual Ref< IPropertyMng > createPropertyMngReference(ISubDomain *)=0
Crée une instance du gestionnaire de propriétés.
Arcane::IMainFactory::createServiceMng
virtual IServiceMng * createServiceMng(IBase *)=0
Crée une instance du gestionnaire de services.
Arcane::IMainFactory::createEntryPointMng
virtual IEntryPointMng * createEntryPointMng(ISubDomain *)=0
Crée une instance du gestionnaire des points d'entrée.
Arcane::IMainFactory::createCheckpointMng
virtual ICheckpointMng * createCheckpointMng(ISubDomain *)=0
Crée une instance du gestionnaire de protections.
Arcane::IMainFactory::createTimeLoopMng
virtual ITimeLoopMng * createTimeLoopMng(ISubDomain *)=0
Crée une instance du gestionnaire de la boucle en temps.
Arcane::IMainFactory::createTimeHistoryMng
virtual ITimeHistoryMng * createTimeHistoryMng(ISubDomain *)=0
Crée une instance du gestionnaire d'historique en temps.
Arcane::IMainFactory::createServiceLoader
virtual IServiceLoader * createServiceLoader()=0
Crée une instance du chargeur de services.
Arcane::IMainFactory::createLoadBalanceMng
virtual ILoadBalanceMng * createLoadBalanceMng(ISubDomain *sd)=0
Cree un gestionnaire de description pour l'equilibrage.
Arcane::IMainFactory::createCaseMng
virtual ICaseMng * createCaseMng(ISubDomain *)=0
Crée une instance du gestionnaire du jeu de données.
Arcane::IMainFactory::createModuleMng
virtual IModuleMng * createModuleMng(ISubDomain *)=0
Crée une instance du gestionnaire de module.
Arcane::IMainFactory::createVariableMng
virtual IVariableMng * createVariableMng(ISubDomain *)=0
Crée une instance du gestionnaire de variable.
Arcane::IMainFactory::createModuleMaster
virtual IModuleMaster * createModuleMaster(ISubDomain *sd)=0
Créé le module maitre pour le sous-domaine sd.
Arcane::IMainFactory::createAcceleratorMngRef
virtual Ref< IAcceleratorMng > createAcceleratorMngRef(ITraceMng *tm)=0
Créé un gestionnaire pour les accélérateurs.
Arcane::IMainFactory::createIOMng
virtual IIOMng * createIOMng(IApplication *)=0
Crée une instance du gestionnaire d'entrée/sortie.
Arcane::IMemoryInfo
Interface d'un collecteur d'informations sur l'usage mémoire.
Definition IMemoryInfo.h:60
Arcane::IMeshMng
Interface du gestionnaire des maillages.
Definition IMeshMng.h:40
Arcane::IMeshStats::create
static IMeshStats * create(ITraceMng *trace, IMesh *mesh, IParallelMng *pm)
Création d'une instance par défaut.
Definition MeshStats.cc:42
Arcane::IMesh::checkValidMesh
virtual void checkValidMesh()=0
Vérification de la validité des structues internes de maillage (interne)
Arcane::IModuleMaster
Interface du module principal.
Definition IModuleMaster.h:44
Arcane::IModuleMng
Interface du gestionnaire de modules.
Definition IModuleMng.h:39
Arcane::IModule
Interface d'un module.
Definition IModule.h:39
Arcane::IModule::name
virtual String name() const =0
Nom du module.
Arcane::IObservable
Interface d'un observable.
Definition utils/IObservable.h:53
Arcane::IParallelMng
Interface du gestionnaire de parallélisme pour un sous-domaine.
Definition IParallelMng.h:52
Arcane::IParallelMng::stat
virtual IStat * stat()=0
Gestionnaire des statistiques.
Arcane::IParallelMng::isMasterIO
virtual bool isMasterIO() const =0
true si l'instance est un gestionnaire maître des entrées/sorties.
Arcane::IParallelMng::commSize
virtual Int32 commSize() const =0
Nombre d'instance dans le communicateur.
Arcane::IParallelMng::gather
virtual void gather(ConstArrayView< char > send_buf, ArrayView< char > recv_buf, Int32 rank)=0
Effectue un regroupement sur un processeurs. Il s'agit d'une opération collective....
Arcane::IParallelMng::masterIORank
virtual Integer masterIORank() const =0
Rang de l'instance gérant les entrées/sorties (pour laquelle isMasterIO() est vrai)
Arcane::IParallelMng::reduce
virtual char reduce(eReduceType rt, char v)=0
Effectue la réduction de type rt sur le réel v et retourne la valeur.
Arcane::IPhysicalUnitSystem
Interface d'un système d'unité.
Definition IPhysicalUnitSystem.h:37
Arcane::IPrimaryMesh::reloadMesh
virtual void reloadMesh()=0
Recharge le maillage à partir des variables protégées.
Arcane::IProcessorAffinityService
Interface d'un service de de trace des appels de fonctions.
Definition IProcessorAffinityService.h:36
Arcane::IProfilingService
Interface d'un service de profiling.
Definition IProfilingService.h:45
Arcane::IPropertyMng
Interface du gestionnaire des propriétés.
Definition IPropertyMng.h:38
Arcane::IRessourceMng
Interface d'un gestionnaire de ressource.
Definition IRessourceMng.h:37
Arcane::IServiceMng
Interface du gestionnaire de services.
Definition IServiceMng.h:31
Arcane::ISession
Interface d'une session d'exécution d'un cas.
Definition ISession.h:44
Arcane::ISubDomain
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
Arcane::ISubDomain::parallelMng
virtual IParallelMng * parallelMng()=0
Retourne le gestionnaire de parallélisme.
Arcane::IThreadMng
Interface d'un gestionnaire de thread.
Definition IThreadMng.h:30
Arcane::ITimeHistoryMng
Classe gérant un historique de valeurs.
Definition ITimeHistoryMng.h:133
Arcane::ITimeLoopMng
Interface du gestionnaire de la boucle en temps.
Definition ITimeLoopMng.h:69
Arcane::ITimeLoopMng::usedTimeLoop
virtual ITimeLoop * usedTimeLoop() const =0
Retourne la boucle en temps utilisée.
Arcane::ITimeLoop
Interface d'une boucle en temps.
Definition ITimeLoop.h:41
Arcane::ITimeLoop::title
virtual String title() const =0
Titre de la boucle en temps.
Arcane::ITimeLoop::description
virtual String description() const =0
Description de la boucle en temps.
Arcane::ITimeLoop::userClasses
virtual StringCollection userClasses() const =0
Liste des classes utilisateurs associées à la boucle en temps.
Arcane::ITimeStats
Interface gérant les statistiques sur les temps d'exécution.
Definition ITimeStats.h:43
Arcane::ITimerMng
Interface d'un gestionnaire de timer.
Definition ITimerMng.h:53
Arcane::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arcane::ITraceMng::flush
virtual void flush()=0
Flush tous les flots.
Arcane::IVariableMng
Interface du gestionnaire de variables.
Definition IVariableMng.h:57
Arcane::IVariableMng::variables
virtual void variables(VariableRefCollection v, IModule *i)=0
Donne l'ensemble des variables du module i.
Arcane::IVariable
Interface d'une variable.
Definition IVariable.h:56
Arcane::IVariable::dataType
virtual eDataType dataType() const =0
Type de la donnée gérée par la variable (Real, Integer, ...)
Arcane::IVariable::PPrivate
@ PPrivate
Indique que la variable est privée.
Definition IVariable.h:116
Arcane::IVariable::itemKind
virtual eItemKind itemKind() const =0
Type des entités du maillage sur lequel repose la variable.
Arcane::IVariable::dimension
virtual Integer dimension() const =0
Dimension de la variable.
Arcane::IVariable::name
virtual String name() const =0
Nom de la variable.
Arcane::LegacyMeshBuilder
Construction du maillage via la méthode "historique".
Definition LegacyMeshBuilder.h:44
Arcane::List< VariableRef * >::Enumerator
ListEnumeratorT< VariableRef * > Enumerator
Definition List.h:243
Arcane::MeshHandle
Handle sur un maillage.
Definition MeshHandle.h:47
Arcane::MeshHandle::mesh
IMesh * mesh() const
Maillage associé.
Definition MeshHandle.cc:133
Arcane::Observable
Classe de base d'un observable.
Definition utils/Observable.h:37
Arcane::ObserverPool
Liste d'observateurs.
Definition ObserverPool.h:41
Arcane::Parallel::IStat::saveValues
virtual void saveValues(ITraceMng *tm, Properties *p)=0
Sauve les valeurs actuelles dans p.
Arcane::Parallel::IStat::mergeValues
virtual void mergeValues(ITraceMng *tm, Properties *p)=0
Fusionne les valeurs actuelles avec celles sauvées dans p.
Arcane::ProfilingSentryWithInitialize
Classe permettant de démarrer et arrêter automatiquement un service.
Definition IProfilingService.h:133
Arcane::ProfilingSentryWithInitialize::setPrintAtEnd
void setPrintAtEnd(bool v)
Indique si on imprime les résultats à la fin du profiling.
Definition IProfilingService.h:164
Arcane::Properties
Liste de propriétés.
Definition Properties.h:64
Arcane::Ref
Référence à une instance.
Definition arccore/src/base/arccore/base/Ref.h:143
Arcane::ReferenceCounter
Encapsulation d'un pointeur avec compteur de référence.
Definition ReferenceCounter.h:45
Arcane::Runner::deviceInfoList
static const IDeviceInfoList * deviceInfoList(eExecutionPolicy policy)
Liste des devices pour la politique d'exécution policy.
Definition Runner.cc:450
Arcane::ScopedPtrT
Encapsulation d'un pointeur qui se détruit automatiquement.
Definition ScopedPtr.h:44
Arcane::ServiceBuilder
Classe utilitaire pour instantier un service d'une interface donnée.
Definition ServiceBuilder.h:100
Arcane::ServiceBuilder::createReference
Ref< InterfaceType > createReference(const String &name, eServiceBuilderProperties properties=SB_None)
Créé une instance implémentant l'interface InterfaceType.
Definition ServiceBuilder.h:138
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::String::bytes
Span< const Byte > bytes() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:291
Arcane::SubDomain::PropertyMngCheckpoint
Classe pour gérer la lecture/écriture des propriétés dans les protections/reprises.
Definition SubDomain.cc:162
Arcane::SubDomain
Implémentation d'un gestionnaire de sous-domaine.
Definition SubDomain.cc:154
Arcane::SubDomain::readOrReloadMeshes
void readOrReloadMeshes() override
Lit ou relit les maillages.
Definition SubDomain.cc:707
Arcane::SubDomain::allReplicaParallelMng
IParallelMng * allReplicaParallelMng() const override
Retourne le gestionnaire de parallélisme pour tous les réplicats.
Definition SubDomain.cc:276
Arcane::SubDomain::objectLocalName
String objectLocalName() const override
Nom local de l'objet.
Definition SubDomain.cc:212
Arcane::SubDomain::physicalUnitSystem
IPhysicalUnitSystem * physicalUnitSystem() override
Système d'unité du sous-domaine.
Definition SubDomain.cc:233
Arcane::SubDomain::m_case_name
String m_case_name
Nom du cas.
Definition SubDomain.cc:331
Arcane::SubDomain::moduleMng
IModuleMng * moduleMng() override
Retourne le gestionnaire de modules.
Definition SubDomain.cc:223
Arcane::SubDomain::threadMng
IThreadMng * threadMng() override
Retourne le gestionnaire de thread.
Definition SubDomain.cc:277
Arcane::SubDomain::parallelMng
IParallelMng * parallelMng() override
Retourne le gestionnaire de parallélisme.
Definition SubDomain.cc:275
Arcane::SubDomain::m_on_destroy_observable
Observable m_on_destroy_observable
Observable lors d'une destruction.
Definition SubDomain.cc:337
Arcane::SubDomain::caseName
const String & caseName() const override
Nom du cas.
Definition SubDomain.cc:260
Arcane::SubDomain::setListingDirectory
void setListingDirectory(const IDirectory &dir) override
Positionne le chemin de sortie des infos listing.
Definition SubDomain.cc:283
Arcane::SubDomain::m_case_mng
Ref< ICaseMng > m_case_mng
Gestionnaire du jeu de données.
Definition SubDomain.cc:315
Arcane::SubDomain::entryPointMng
IEntryPointMng * entryPointMng() override
Retourne le gestionnaire de points d'entrée.
Definition SubDomain.cc:224
Arcane::SubDomain::loadBalanceMng
ILoadBalanceMng * loadBalanceMng() override
Retourne le gestionnaire d'équilibrage de charge.
Definition SubDomain.cc:234
Arcane::SubDomain::m_session
ISession * m_session
Session.
Definition SubDomain.cc:306
Arcane::SubDomain::objectParent
IBase * objectParent() const override
Parent de cet objet.
Definition SubDomain.cc:210
Arcane::SubDomain::setIsContinue
void setIsContinue() override
Positionne un flag indiquant qu'on effectue une reprise.
Definition SubDomain.cc:243
Arcane::SubDomain::caseFullFileName
const String & caseFullFileName() const override
Chemin complet du fichier contenant le jeu de données.
Definition SubDomain.cc:258
Arcane::SubDomain::doInitModules
void doInitModules() override
Appelle les points d'entrée d'initialisation du module.
Definition SubDomain.cc:824
Arcane::SubDomain::configuration
IConfiguration * configuration() override
Configuration associée.
Definition SubDomain.cc:238
Arcane::SubDomain::caseDocument
ICaseDocument * caseDocument() override
Document XML du cas.
Definition SubDomain.cc:255
Arcane::SubDomain::serviceMng
IServiceMng * serviceMng() const override
Gestionnaire de services.
Definition SubDomain.cc:219
Arcane::SubDomain::m_all_replica_parallel_mng
Ref< IParallelMng > m_all_replica_parallel_mng
Gestionnaire du parallélisme pour tous les réplicats.
Definition SubDomain.cc:309
Arcane::SubDomain::ioMng
IIOMng * ioMng() override
Retourne le gestionnaire des entrées/sorties.
Definition SubDomain.cc:221
Arcane::SubDomain::setInitialPartitioner
void setInitialPartitioner(IInitialPartitioner *partitioner) override
Positionne le partitionneur initial.
Definition SubDomain.cc:263
Arcane::SubDomain::commonVariables
const CommonVariables & commonVariables() const override
Informations sur les variables standards.
Definition SubDomain.cc:972
Arcane::SubDomain::setStorageDirectory
void setStorageDirectory(const IDirectory &dir) override
Positionne le chemin de sortie des exportations nécessitant un archivage.
Definition SubDomain.cc:281
Arcane::SubDomain::build
void build() override
Construit les membres de l'instance. L'instance n'est pas utilisable tant que cette méthode n'a pas é...
Definition SubDomain.cc:436
Arcane::SubDomain::m_has_mesh_service
bool m_has_mesh_service
Indique si on utilise le mécanisme de service pour lire le maillage.
Definition SubDomain.cc:346
Arcane::SubDomain::timeHistoryMng
ITimeHistoryMng * timeHistoryMng() override
Retourne le gestionnaire d'historique.
Definition SubDomain.cc:284
Arcane::SubDomain::memoryInfo
IMemoryInfo * memoryInfo() const override
Gestionnaire d'informations mémoire.
Definition SubDomain.cc:232
Arcane::SubDomain::m_is_initialized
bool m_is_initialized
true si initialisé
Definition SubDomain.cc:329
Arcane::SubDomain::m_case_full_file_name
String m_case_full_file_name
Chemin d'accès du cas.
Definition SubDomain.cc:330
Arcane::SubDomain::exportDirectory
const IDirectory & exportDirectory() const override
Répertoire de base des exportations.
Definition SubDomain.cc:278
Arcane::SubDomain::dumpInfo
void dumpInfo(std::ostream &) override
Affiche des informations sur l'instance.
Definition SubDomain.cc:656
Arcane::SubDomain::fillCaseBytes
void fillCaseBytes(ByteArray &bytes) const override
Remplit bytes avec le contenue du jeu de données.
Definition SubDomain.cc:261
Arcane::SubDomain::moduleMaster
IModuleMaster * moduleMaster() const override
Interface du module maître.
Definition SubDomain.cc:236
Arcane::SubDomain::m_lb_mng
ScopedPtrT< ILoadBalanceMng > m_lb_mng
Gestionnaire de caracteristiques pour l'equilibrage.
Definition SubDomain.cc:340
Arcane::SubDomain::variableMng
IVariableMng * variableMng() override
Retourne le gestionnaire de variables.
Definition SubDomain.cc:222
Arcane::SubDomain::m_module_mng
ScopedPtrT< IModuleMng > m_module_mng
Gestionnaire des modules.
Definition SubDomain.cc:313
Arcane::SubDomain::storageDirectory
const IDirectory & storageDirectory() const override
Répertoire de base des exportations nécessitant un archivage.
Definition SubDomain.cc:280
Arcane::SubDomain::subDomainId
Int32 subDomainId() const override
Numéro du sous-domaine associé à ce gestionnaire.
Definition SubDomain.cc:241
Arcane::SubDomain::m_property_mng
Ref< IPropertyMng > m_property_mng
Gestionnaire de propriétés.
Definition SubDomain.cc:318
Arcane::SubDomain::meshMng
IMeshMng * meshMng() const override
Retourne le gestionnaire de maillage.
Definition SubDomain.cc:235
Arcane::SubDomain::addMesh
void addMesh(IMesh *mesh) override
Ajoute un maillage au sous-domaine.
Definition SubDomain.cc:764
Arcane::SubDomain::_printCPUAffinity
void _printCPUAffinity()
Affiche l'affinité CPU de tous les rangs.
Definition SubDomain.cc:1117
Arcane::SubDomain::m_case_config
CaseOptionsMain * m_case_config
Config du cas.
Definition SubDomain.cc:333
Arcane::SubDomain::dumpInternalInfos
void dumpInternalInfos(XmlNode &root) override
Sort les informations internes de l'architecture. Les informations sont stockées dans un arbre XML ay...
Definition SubDomain.cc:983
Arcane::SubDomain::m_application
IApplication * m_application
Gestionnaire principal.
Definition SubDomain.cc:307
Arcane::SubDomain::allocateMeshes
void allocateMeshes() override
Allocation des maillages.
Definition SubDomain.cc:674
Arcane::SubDomain::onDestroyObservable
IObservable * onDestroyObservable() override
Notification avant destruction du sous-domaine.
Definition SubDomain.cc:289
Arcane::SubDomain::m_case_bytes
ByteUniqueArray m_case_bytes
Données du cas.
Definition SubDomain.cc:332
Arcane::SubDomain::doInitMeshPartition
void doInitMeshPartition() override
Applique le partitionnement de maillage de l'initialisation.
Definition SubDomain.cc:792
Arcane::SubDomain::timerMng
ITimerMng * timerMng() const override
Retourne le gestionnaire de timers.
Definition SubDomain.cc:226
Arcane::SubDomain::objectVersion
VersionInfo objectVersion() const override
Numéro de version du service.
Definition SubDomain.cc:213
Arcane::SubDomain::caseMng
ICaseMng * caseMng() override
Retourne le gestionnaire du jeu de données.
Definition SubDomain.cc:225
Arcane::SubDomain::m_parallel_mng
Ref< IParallelMng > m_parallel_mng
Gestionnaire du parallélisme.
Definition SubDomain.cc:308
Arcane::SubDomain::meshes
ConstArrayView< IMesh * > meshes() const override
Listes des maillages du sous-domaine.
Definition SubDomain.cc:773
Arcane::SubDomain::m_physical_unit_system
ScopedPtrT< IPhysicalUnitSystem > m_physical_unit_system
Système d'unité physique.
Definition SubDomain.cc:322
Arcane::SubDomain::listingDirectory
const IDirectory & listingDirectory() const override
Répertoire de base des listings (logs, info exécution).
Definition SubDomain.cc:282
Arcane::SubDomain::setExportDirectory
void setExportDirectory(const IDirectory &dir) override
Positionne le chemin de sortie des exportations (protections et reprises)
Definition SubDomain.cc:279
Arcane::SubDomain::setIsInitialized
void setIsInitialized() override
Indique que le sous-domaine est initialié.
Definition SubDomain.cc:1095
Arcane::SubDomain::m_entry_point_mng
ScopedPtrT< IEntryPointMng > m_entry_point_mng
Gestionnaire des points d'entrée.
Definition SubDomain.cc:314
Arcane::SubDomain::configuration
const IConfiguration * configuration() const override
Configuration associée.
Definition SubDomain.cc:237
Arcane::SubDomain::m_service_mng
ScopedPtrT< IServiceMng > m_service_mng
Gestionnaire des services.
Definition SubDomain.cc:321
Arcane::SubDomain::m_module_master
IModuleMaster * m_module_master
Module maitre.
Definition SubDomain.cc:325
Arcane::SubDomain::m_time_history_mng
ScopedPtrT< ITimeHistoryMng > m_time_history_mng
Gestionnaire d'historique.
Definition SubDomain.cc:326
Arcane::SubDomain::directExecution
IDirectExecution * directExecution() const override
Service d'exécution directe (ou null)
Definition SubDomain.cc:290
Arcane::SubDomain::defaultMeshHandle
const MeshHandle & defaultMeshHandle() override
Handle sur le maillage par défaut.
Definition SubDomain.cc:249
Arcane::SubDomain::m_variable_mng
ScopedPtrT< IVariableMng > m_variable_mng
Gestionnaire des variables.
Definition SubDomain.cc:312
Arcane::SubDomain::readCaseMeshes
void readCaseMeshes() override
Lit les informations de maillage du jeu de données.
Definition SubDomain.cc:954
Arcane::SubDomain::m_checkpoint_mng
ScopedPtrT< ICheckpointMng > m_checkpoint_mng
Gestionnaire de protections.
Definition SubDomain.cc:317
Arcane::SubDomain::meshDimension
Integer meshDimension() const override
Dimension du maillage (1D, 2D ou 3D).
Definition SubDomain.cc:1060
Arcane::SubDomain::initialize
void initialize() override
Initialise l'instance. L'instance n'est pas utilisable tant que cette méthode n'a pas été appelée.
Definition SubDomain.cc:463
Arcane::SubDomain::doExitModules
void doExitModules() override
Exécution des modules de fin d'exécution.
Definition SubDomain.cc:914
Arcane::SubDomain::m_export_directory
Directory m_export_directory
Répertoire d'exportation.
Definition SubDomain.cc:334
Arcane::SubDomain::caseOptionsMain
const CaseOptionsMain * caseOptionsMain() const override
Options générales du jeu de donnée.
Definition SubDomain.cc:274
Arcane::SubDomain::m_time_stats
ITimeStats * m_time_stats
Statistiques sur les temps d'exécution.
Definition SubDomain.cc:319
Arcane::SubDomain::session
ISession * session() const override
Session.
Definition SubDomain.cc:218
Arcane::SubDomain::objectNamespaceURI
String objectNamespaceURI() const override
Namespace de l'objet.
Definition SubDomain.cc:211
Arcane::SubDomain::m_memory_info
ScopedPtrT< IMemoryInfo > m_memory_info
Informations sur l'utilisation mémoire.
Definition SubDomain.cc:311
Arcane::SubDomain::setCaseName
void setCaseName(const String &case_name) override
Positionne le nom du cas.
Definition SubDomain.cc:262
Arcane::SubDomain::isContinue
bool isContinue() const override
Vrai si on effectue une reprise, faux sinon.
Definition SubDomain.cc:244
Arcane::SubDomain::mainFactory
IMainFactory * mainFactory() override
Manufacture principale.
Definition SubDomain.cc:217
Arcane::SubDomain::checkpointMng
ICheckpointMng * checkpointMng() const override
Gestionnaire de protections.
Definition SubDomain.cc:227
Arcane::SubDomain::ressourceMng
IRessourceMng * ressourceMng() const override
Gestionnaire de ressources.
Definition SubDomain.cc:230
Arcane::SubDomain::propertyMng
IPropertyMng * propertyMng() const override
Gestionnaire de propriétés.
Definition SubDomain.cc:228
Arcane::SubDomain::m_configuration
ScopedPtrT< IConfiguration > m_configuration
Configuration.
Definition SubDomain.cc:341
Arcane::SubDomain::timeLoopMng
ITimeLoopMng * timeLoopMng() override
Retourne le gestionnaire de la boucle en temps.
Definition SubDomain.cc:220
Arcane::SubDomain::checkId
void checkId(const String &where, const String &id) override
Vérifie qu'un identifiant est valide.
Definition SubDomain.cc:936
Arcane::SubDomain::m_listing_directory
Directory m_listing_directory
Répertoire des listings.
Definition SubDomain.cc:336
Arcane::SubDomain::application
IApplication * application() override
Application.
Definition SubDomain.cc:256
Arcane::SubDomain::m_time_loop_mng
ScopedPtrT< ITimeLoopMng > m_time_loop_mng
Gestionnaire de la boucle en temps.
Definition SubDomain.cc:320
Arcane::SubDomain::m_storage_directory
Directory m_storage_directory
Répertoire d'archivage.
Definition SubDomain.cc:335
Arcane::SubDomain::m_timer_mng
ITimerMng * m_timer_mng
Gestionnaire des timers.
Definition SubDomain.cc:316
Arcane::SubDomain::traceMng
ITraceMng * traceMng() const override
Gestionnaire de traces.
Definition SubDomain.cc:231
Arcane::SubDomain::timeStats
ITimeStats * timeStats() const override
Statistiques des temps d'exécution.
Definition SubDomain.cc:229
Arcane::SubDomain::defaultMesh
IMesh * defaultMesh() override
Maillage par défaut.
Definition SubDomain.cc:248
Arcane::SubDomain::initializeMeshVariablesFromCaseFile
void initializeMeshVariablesFromCaseFile() override
Initialise les variables dont les valeurs sont spécifiées dans le jeu de données.
Definition SubDomain.cc:782
Arcane::SubDomain::setDirectExecution
void setDirectExecution(IDirectExecution *v) override
Positionne le service d'exécution directe.
Definition SubDomain.cc:291
Arcane::SubDomain::isInitialized
bool isInitialized() const override
Indique si la session a été initialisée.
Definition SubDomain.cc:252
Arcane::SubDomain::nbSubDomain
Int32 nbSubDomain() const override
Nombre total de sous-domaines.
Definition SubDomain.cc:242
Arcane::SubDomain::acceleratorMng
IAcceleratorMng * acceleratorMng() override
Gestionnaire de l'accélérateur associé
Definition SubDomain.cc:239
Arcane::SubDomain::findMesh
IMesh * findMesh(const String &name, bool throw_exception) override
Recherche le maillage de nom name.
Definition SubDomain.cc:1069
Arcane::SubDomain::applicationInfo
const ApplicationInfo & applicationInfo() const override
Informations sur l'exécutable.
Definition SubDomain.cc:254
Arcane::SubDomain::m_io_mng
ScopedPtrT< IIOMng > m_io_mng
Gestionnaire des entrées/sorties.
Definition SubDomain.cc:310
Arcane::Timer::Action
Postionne le nom de l'action en cours d'exécution.
Definition Timer.h:110
Arcane::TraceAccessor::TraceAccessor
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
Definition TraceAccessor.cc:27
Arcane::TraceAccessor::logdate
TraceMessage logdate() const
Flot pour un message de log précédé de la date.
Definition TraceAccessor.cc:156
Arcane::TraceAccessor::info
TraceMessage info() const
Flot pour un message d'information.
Definition TraceAccessor.cc:101
Arcane::TraceAccessor::traceMng
ITraceMng * traceMng() const
Gestionnaire de trace.
Definition TraceAccessor.cc:72
Arcane::TraceAccessor::pwarning
TraceMessage pwarning() const
Definition TraceAccessor.cc:192
Arcane::Trace::Setter
Positionne une classe de message.
Definition arccore/src/trace/arccore/trace/Trace.h:153
Arcane::Trace::Width
Formattage du flot en longueur.
Definition arccore/src/trace/arccore/trace/Trace.h:77
Arcane::UniqueArray2
Vecteur de données 2D avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array2.h:714
Arcane::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array.h:1844
Arcane::VariableBuildInfo
Paramètres nécessaires à la construction d'une variable.
Definition VariableBuildInfo.h:43
Arcane::VariableCollection
Collection de variables.
Definition VariableCollection.h:81
Arcane::VersionInfo
Informations sur une version.
Definition VersionInfo.h:46
Arcane::XmlElement
Elément d'un arbre DOM.
Definition XmlNode.h:396
Arcane::XmlNode
Noeud d'un arbre DOM.
Definition XmlNode.h:51
Arcane::XmlNode::null
bool null() const
Vrai si le noeud est nul.
Definition XmlNode.h:294
Arcane::XmlNode::setAttrValue
void setAttrValue(const String &name, const String &value)
Positionne l'attribut name à la valeur value.
Definition XmlNode.cc:239
Arcane::internal::TraceAccessor2
API EN COURS DE CONCEPTION. NE PAS UTILISER.
Definition TraceAccessor2.h:33
Arcane::VariableArrayByte
VariableRefArrayT< Byte > VariableArrayByte
Variable tableau de type byte.
Definition VariableTypedef.h:128
Arcane::Accelerator
Espace de nom pour l'utilisation des accélérateurs.
Definition AcceleratorGlobal.h:36
Arcane::MessagePassing::dumpDateAndMemoryUsage
void dumpDateAndMemoryUsage(IParallelMng *pm, ITraceMng *tm)
Écrit dans tm la date et la mémoire consommée.
Definition Parallel.cc:163
Arcane::MessagePassing::ReduceMin
@ ReduceMin
Minimum des valeurs.
Definition MessagePassingGlobal.h:100
Arcane::platform::getHostName
ARCCORE_BASE_EXPORT String getHostName()
Nom de la machine sur lequel tourne le processus.
Definition arccore/src/base/arccore/base/PlatformUtils.cc:141
Arcane::platform::callDotNETGarbageCollector
void callDotNETGarbageCollector()
Appelle le Garbage Collector de '.Net' s'il est disponible.
Definition arcane/src/arcane/utils/PlatformUtils.cc:604
Arcane::platform::getProfilingService
IProfilingService * getProfilingService()
Service utilisé pour obtenir pour obtenir des informations de profiling.
Definition arcane/src/arcane/utils/PlatformUtils.cc:143
Arcane::platform::getEnvironmentVariable
ARCCORE_BASE_EXPORT String getEnvironmentVariable(const String &name)
Variable d'environnement du nom name.
Definition arccore/src/base/arccore/base/PlatformUtils.cc:251
Arcane::platform::getProcessorAffinityService
IProcessorAffinityService * getProcessorAffinityService()
Service utilisé pour la gestion de l'affinité des processeurs.
Definition arcane/src/arcane/utils/PlatformUtils.cc:183
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::SB_AllowNull
@ SB_AllowNull
Autorise l'absence du service.
Definition ServiceBuilder.h:52
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:186
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arcane::ByteArray
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:208
Arcane::ByteUniqueArray
UniqueArray< Byte > ByteUniqueArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:422
Arcane::CaseOptionsCollection
Collection< ICaseOptions * > CaseOptionsCollection
Collection d'options du jeu de données.
Definition ArcaneTypes.h:490
Arcane::itemKindName
const char * itemKindName(eItemKind kind)
Nom du genre d'entité.
Definition ArcaneTypes.cc:37
Arcane::ByteConstArrayView
ConstArrayView< Byte > ByteConstArrayView
Equivalent C d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:563
Arcane::Byte
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43
Arcane::StringUniqueArray
UniqueArray< String > StringUniqueArray
Tableau dynamique à une dimension de chaînes de caractères.
Definition UtilsTypes.h:446
Arcane::VariableRefList
List< VariableRef * > VariableRefList
Tableau de références de variables.
Definition ArcaneTypes.h:511
Arcane::dataTypeName
const char * dataTypeName(eDataType type)
Nom du type de donnée.
Definition DataTypes.cc:70
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184