Arcane  v3.16.2.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
Variable.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/* Variable.cc (C) 2000-2025 */
9/* */
10/* Classe gérant une variable. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13#ifndef ARCANE_VARIABLE_CC
14#define ARCANE_VARIABLE_CC
15/*---------------------------------------------------------------------------*/
16/*---------------------------------------------------------------------------*/
17
18#include "arcane/utils/List.h"
19#include "arcane/utils/FatalErrorException.h"
20#include "arcane/utils/OStringStream.h"
21#include "arcane/utils/Iterator.h"
22#include "arcane/utils/Iostream.h"
23#include "arcane/utils/String.h"
24#include "arcane/utils/ITraceMng.h"
25#include "arcane/utils/PlatformUtils.h"
26#include "arcane/utils/IStackTraceService.h"
27#include "arcane/utils/MemoryAccessInfo.h"
28#include "arcane/utils/NotImplementedException.h"
29#include "arcane/utils/ScopedPtr.h"
30#include "arcane/utils/StringBuilder.h"
31#include "arcane/utils/MemoryView.h"
32
33#include "arcane/core/ItemGroupObserver.h"
34#include "arcane/core/Variable.h"
35#include "arcane/core/VarRefEnumerator.h"
36#include "arcane/core/IVariableAccessor.h"
37#include "arcane/core/ItemGroup.h"
38#include "arcane/core/IMesh.h"
39#include "arcane/core/IItemFamily.h"
40#include "arcane/core/ISubDomain.h"
41#include "arcane/core/VariableInfo.h"
42#include "arcane/core/ISerializer.h"
43#include "arcane/core/VariableBuildInfo.h"
44#include "arcane/core/VariableComputeFunction.h"
45#include "arcane/core/CommonVariables.h"
46#include "arcane/core/Observable.h"
47#include "arcane/core/IVariableMng.h"
48#include "arcane/core/IDataReader.h"
49#include "arcane/core/IDataWriter.h"
50#include "arcane/core/IParallelMng.h"
51#include "arcane/core/VariableDependInfo.h"
52#include "arcane/core/IParallelReplication.h"
53#include "arcane/core/VariableMetaData.h"
54#include "arcane/core/IMeshMng.h"
55#include "arcane/core/MeshHandle.h"
56#include "arcane/core/VariableComparer.h"
57#include "arcane/core/datatype/DataAllocationInfo.h"
58#include "arcane/core/internal/IItemFamilyInternal.h"
59#include "arcane/core/internal/IVariableMngInternal.h"
60#include "arcane/core/internal/IVariableInternal.h"
61#include "arcane/core/internal/IDataInternal.h"
62
63#include <map>
64#include <set>
65#include <atomic>
66
67/*---------------------------------------------------------------------------*/
68/*---------------------------------------------------------------------------*/
69
70namespace Arcane
71{
72
73/*---------------------------------------------------------------------------*/
74/*---------------------------------------------------------------------------*/
75/*
76 * \brief Partie privée d'une variable.
77 */
78class VariablePrivate
79: public IVariableInternal
80{
81 public:
82
83 VariablePrivate(const VariableBuildInfo& v, const VariableInfo& vi, Variable* var);
84
85 public:
86
87 static std::atomic<Int64> modified_time_global_value;
88
89 public:
90
91 ISubDomain* m_sub_domain = nullptr;
92 IDataFactoryMng* m_data_factory_mng = nullptr;
98 int m_property = 0;
99 bool m_is_partial = false;
100 bool m_need_property_update = false;
101 bool m_is_used = false;
102 bool m_has_valid_data = false;
104 VariableRef* m_first_reference = nullptr;
112 std::map<String, String> m_tags;
114 bool m_want_shrink = false;
115 Variable* m_variable = nullptr;
116
117 public:
118
126 {
127 switch (sbuf->mode()) {
128 case ISerializer::ModeReserve:
129 sbuf->reserveSpan(eBasicDataType::Byte, HASHID_SIZE);
130 break;
132 sbuf->putSpan(Span<const Byte>(m_hash_id, HASHID_SIZE));
133 break;
135 Byte read_hash_id_buf[HASHID_SIZE];
136 Span<Byte> read_span(read_hash_id_buf, HASHID_SIZE);
137 sbuf->getSpan(read_span);
138 Span<const Byte> ref_span(m_hash_id, HASHID_SIZE);
139 if (ref_span != Span<const Byte>(read_span))
140 ARCANE_FATAL("Bad hashid for variable name='{0}'\n"
141 " expected_hash_id='{1}'\n"
142 " hash_id ='{2}'\n"
143 " This may be due to incoherence in variable list (order) between ranks"
144 " during serialization",
145 m_infos.fullName(), String(ref_span), String(read_span));
146 } break;
147 }
148 }
149
150 public:
151
153 String computeComparisonHashCollective(IHashAlgorithm* hash_algo, IData* sorted_data) override;
154 void changeAllocator(const MemoryAllocationOptions& alloc_info) override;
155 void resize(const VariableResizeArgs& resize_args) override;
159
160 private:
161
162 static const int HASHID_SIZE = 64;
170 Byte m_hash_id[HASHID_SIZE];
171
172 void _setHashId()
173 {
174 constexpr Int64 hashid_hexa_length = 16;
175 constexpr Int64 name_length = HASHID_SIZE - hashid_hexa_length;
176 Span<Byte> hash_id(m_hash_id, HASHID_SIZE);
177 hash_id.fill('~');
178 const String& full_name = m_infos.fullName();
179 Int64 hash_value = IntegerHashFunctionT<StringView>::hashfunc(full_name.view());
180 Convert::toHexaString(hash_value, hash_id);
181 Span<const Byte> bytes = full_name.bytes();
182 if (bytes.size() > name_length)
183 bytes = bytes.subspan(0, name_length);
184 auto hash_id2 = hash_id.subspan(hashid_hexa_length, name_length);
185 hash_id2.copy(bytes);
186 }
187};
188
189/*---------------------------------------------------------------------------*/
190/*---------------------------------------------------------------------------*/
191
192std::atomic<Int64> VariablePrivate::modified_time_global_value = 1;
193
194/*---------------------------------------------------------------------------*/
195/*---------------------------------------------------------------------------*/
196
199{
200 Int64 v = VariablePrivate::modified_time_global_value;
201 ++VariablePrivate::modified_time_global_value;
202 return v;
203}
204
205/*---------------------------------------------------------------------------*/
206/*---------------------------------------------------------------------------*/
207
208VariablePrivate::
209VariablePrivate(const VariableBuildInfo& v, const VariableInfo& vi, Variable* var)
210: m_sub_domain(v._subDomain())
211, m_data_factory_mng(v.dataFactoryMng())
212, m_mesh_handle(v.meshHandle())
213, m_infos(vi)
214, m_property(v.property())
215, m_is_partial(vi.isPartial())
216, m_variable(var)
217{
218 _setHashId();
219 m_infos.setDefaultItemGroupName();
220
221 // Pour test uniquement
222 if (!platform::getEnvironmentVariable("ARCANE_NO_RECURSIVE_DEPEND").null())
223 m_has_recursive_depend = false;
224
225 // Pour teste de libération mémoire.
226 {
227 String str = platform::getEnvironmentVariable("ARCANE_VARIABLE_SHRINK_MEMORY");
228 if (str == "1")
229 m_want_shrink = true;
230 }
231}
232
233/*---------------------------------------------------------------------------*/
234/*---------------------------------------------------------------------------*/
235
237class ItemGroupPartialVariableObserver
238: public IItemGroupObserver
239{
240 public:
241
242 explicit ItemGroupPartialVariableObserver(IVariable* var)
243 : m_var(var)
244 {
245 ARCANE_ASSERT((m_var), ("Variable pointer null"));
246
247 if (var->itemGroup().isAllItems())
248 ARCANE_FATAL("No observer should be attached on all items group");
249 }
250
251 void executeExtend(const Int32ConstArrayView* info) override
252 {
253 const Int32ConstArrayView& new_ids = *info;
254 if (new_ids.empty())
255 return;
256 ItemGroup group = m_var->itemGroup();
257 SharedPtrT<GroupIndexTable> id_to_index = group.localIdToIndex();
258
259 const Integer old_size = id_to_index->size();
260 const Integer group_size = group.size();
261 if (group_size != (old_size + new_ids.size()))
262 ARCANE_FATAL("Inconsitent extended size");
263 m_var->resizeFromGroup();
264 //id_to_index->update();
265 }
266
267 void executeReduce(const Int32ConstArrayView* info) override
268 {
269 // contient la liste des localids des items supprimés dans l'ancien groupe
270 const Int32ConstArrayView& removed_lids = *info;
271 if (removed_lids.empty())
272 return;
273 ItemGroup group = m_var->itemGroup();
274 SharedPtrT<GroupIndexTable> id_to_index = group.localIdToIndex();
275
276 const Integer old_size = id_to_index->size();
277 const Integer group_size = group.size();
278
279 if (group_size != (old_size - removed_lids.size()))
280 ARCANE_FATAL("Inconsitent reduced size {0} vs {1}", group_size, old_size);
281 [[maybe_unused]] ItemVectorView view = group.view();
282 Int32UniqueArray source;
283 Int32UniqueArray destination;
284 source.reserve(group_size);
285 destination.reserve(group_size);
286 for (Integer i = 0, index = 0, removed_index = 0; i < old_size; ++i) {
287 if (removed_index < removed_lids.size() &&
288 id_to_index->keyLocalId(i) == removed_lids[removed_index]) {
289 ++removed_index;
290 }
291 else {
292 ARCANE_ASSERT((id_to_index->keyLocalId(i) == view[index].localId()),
293 ("Inconsistent key (pos=%d,key=%d) vs (pos=%d,key=%d)",
294 i, id_to_index->keyLocalId(i), index, view[index].localId()));
295 if (i != index) {
296 destination.add(index);
297 source.add(i);
298 }
299 ++index;
300 }
301 }
302 m_var->copyItemsValues(source, destination);
303 m_var->resizeFromGroup();
304 }
305
306 void executeCompact(const Int32ConstArrayView* info) override
307 {
308 const Int32ConstArrayView& ids = *info;
309 if (ids.empty())
310 return;
311 ItemGroup group = m_var->itemGroup();
312 SharedPtrT<GroupIndexTable> id_to_index = group.localIdToIndex();
313 m_var->compact(*info);
314 //id_to_index->compact(info);
315 }
316
317 void executeInvalidate() override
318 {
319 ItemGroup group = m_var->itemGroup();
320 SharedPtrT<GroupIndexTable> id_to_index = group.localIdToIndex();
321 m_var->resizeFromGroup();
322 //id_to_index->update();
323 }
324
325 bool needInfo() const override { return true; }
326
327 private:
328
329 IVariable* m_var = nullptr;
330};
331
332/*---------------------------------------------------------------------------*/
333/*---------------------------------------------------------------------------*/
334
336Variable(const VariableBuildInfo& v, const VariableInfo& vi)
338, m_p(new VariablePrivate(v, vi, this))
339{
340}
341
342/*---------------------------------------------------------------------------*/
343/*---------------------------------------------------------------------------*/
344
346~Variable()
347{
348 //NOTE: si la variable possède un groupe, c'est le IVariableMng
349 // qui supprime la référence de cette variable sur le groupe
350 delete m_p;
351}
352
353/*---------------------------------------------------------------------------*/
354/*---------------------------------------------------------------------------*/
355
356bool Variable::
357_hasReference() const
358{
359 return m_p->m_first_reference;
360}
361
362/*---------------------------------------------------------------------------*/
363/*---------------------------------------------------------------------------*/
364
367{
368 _checkSetProperty(ref);
369 ++m_p->m_nb_reference;
370 ref->setNextReference(m_p->m_first_reference);
371 if (m_p->m_first_reference) {
372 VariableRef* _list = m_p->m_first_reference;
373 if (_list->previousReference())
374 _list->previousReference()->setNextReference(ref);
375 _list->setPreviousReference(ref);
376 }
377 else {
378 ref->setPreviousReference(0);
379 }
380 m_p->m_first_reference = ref;
381}
382
383/*---------------------------------------------------------------------------*/
384/*---------------------------------------------------------------------------*/
385
388{
389 {
390 VariableRef* tmp = ref;
391 if (tmp->previousReference())
393 if (tmp->nextReference())
395 if (m_p->m_first_reference == tmp)
396 m_p->m_first_reference = m_p->m_first_reference->nextReference();
397 }
398 // La référence peut être utilisée par la suite donc il ne faut pas oublier
399 // de supprimer le précédent et le suivant.
400 ref->setNextReference(0);
401 ref->setPreviousReference(0);
402
403 --m_p->m_nb_reference;
404 _checkSetProperty(ref);
405
406 // Lorsqu'il n'y a plus de références sur cette variable, le signale au
407 // gestionnaire de variable, sauf s'il s'agit d'une variable persistante
408 if (!_hasReference()) {
409 bool is_persistant = property() & IVariable::PPersistant;
410 if (!is_persistant) {
411 //m_p->m_trace->info() << " REF PROPERTY name=" << name() << " " << ref->referenceProperty();
412 _removeMeshReference();
413 ISubDomain* sd = m_p->m_sub_domain;
414 IVariableMng* vm = sd->variableMng();
415 vm->_internalApi()->removeVariable(this);
416 }
417 }
418}
419
420/*---------------------------------------------------------------------------*/
421/*---------------------------------------------------------------------------*/
422
424firstReference() const
425{
426 return m_p->m_first_reference;
427}
428
429/*---------------------------------------------------------------------------*/
430/*---------------------------------------------------------------------------*/
431
432void Variable::
433_checkSetProperty(VariableRef* ref)
434{
435 // Garantie que la propriété est correctement mise à jour avec la valeur
436 // de la seule référence.
437 if (!_hasReference()) {
439 m_p->m_need_property_update = false;
440 }
441 else
442 m_p->m_need_property_update = true;
443}
444
445/*---------------------------------------------------------------------------*/
446/*---------------------------------------------------------------------------*/
447
449nbReference() const
450{
451 return m_p->m_nb_reference;
452}
453
454/*---------------------------------------------------------------------------*/
455/*---------------------------------------------------------------------------*/
456
458subDomain()
459{
460 return m_p->m_sub_domain;
461}
462
463/*---------------------------------------------------------------------------*/
464/*---------------------------------------------------------------------------*/
465
467variableMng() const
468{
469 return m_p->m_sub_domain->variableMng();
470}
471
472/*---------------------------------------------------------------------------*/
473/*---------------------------------------------------------------------------*/
474
476name() const
477{
478 return m_p->m_infos.localName();
479}
480
481/*---------------------------------------------------------------------------*/
482/*---------------------------------------------------------------------------*/
483
485fullName() const
486{
487 return m_p->m_infos.fullName();
488}
489
490/*---------------------------------------------------------------------------*/
491/*---------------------------------------------------------------------------*/
492
494itemFamilyName() const
495{
496 return m_p->m_infos.itemFamilyName();
497}
498
499/*---------------------------------------------------------------------------*/
500/*---------------------------------------------------------------------------*/
501
503itemGroupName() const
504{
505 return m_p->m_infos.itemGroupName();
506}
507
508/*---------------------------------------------------------------------------*/
509/*---------------------------------------------------------------------------*/
510
512meshName() const
513{
514 return m_p->m_infos.meshName();
515}
516
517/*---------------------------------------------------------------------------*/
518/*---------------------------------------------------------------------------*/
519
521dataType() const
522{
523 return m_p->m_infos.dataType();
524}
525
526/*---------------------------------------------------------------------------*/
527/*---------------------------------------------------------------------------*/
532property() const
533{
534 if (!m_p->m_need_property_update)
535 return m_p->m_property;
536
537 // Les propriétés de la variable dépendent de ce que chaque
538 // référence souhaite et il faut les remettre à jour lorsque ces
539 // dernières changent.
540 // Par exemple, si toutes les références sont PNoDump et qu'une seule
541 // ne l'est pas, la variable ne doit pas l'être.
542 m_p->m_need_property_update = false;
543
544 bool want_dump = false;
545 bool want_sync = false;
546 bool want_replica_sync = false;
547 bool sub_domain_depend = false;
548 bool execution_depend = false;
549 bool want_private = false;
550 bool want_restore = false;
551 bool want_notemporary = false;
552 bool want_exchange = false;
553 bool want_persistant = false;
554
555 int property = 0;
556 for (VarRefEnumerator i(this); i.hasNext(); ++i) {
557 VariableRef* vref = *i;
558 int p = vref->referenceProperty();
559 if (!(p & IVariable::PNoDump))
560 want_dump = true;
561 if (!(p & IVariable::PNoNeedSync))
562 want_sync = true;
563 if (!(p & IVariable::PNoReplicaSync))
564 want_replica_sync = true;
566 sub_domain_depend = true;
568 execution_depend = true;
569 if ((p & IVariable::PPersistant))
570 want_persistant = true;
571 if ((p & IVariable::PPrivate))
572 want_private = true;
573 if (!(p & IVariable::PNoRestore))
574 want_restore = true;
575 if (!(p & IVariable::PNoExchange))
576 want_exchange = true;
577 if (!(p & IVariable::PTemporary))
578 want_notemporary = true;
579 }
580
581 if (!want_dump)
582 property |= IVariable::PNoDump;
583 if (!want_sync)
584 property |= IVariable::PNoNeedSync;
585 if (!want_replica_sync)
586 property |= IVariable::PNoReplicaSync;
587 if (sub_domain_depend)
588 property |= IVariable::PSubDomainDepend;
589 if (execution_depend)
590 property |= IVariable::PExecutionDepend;
591 if (want_private)
592 property |= IVariable::PPrivate;
593 if (want_persistant)
594 property |= IVariable::PPersistant;
595 if (!want_restore)
596 property |= IVariable::PNoRestore;
597 if (!want_exchange)
598 property |= IVariable::PNoExchange;
599 if (!want_notemporary)
600 property |= IVariable::PTemporary;
601
602 m_p->m_property = property;
603 return m_p->m_property;
604}
605
606/*---------------------------------------------------------------------------*/
607/*---------------------------------------------------------------------------*/
608
611{
612 m_p->m_need_property_update = true;
613}
614
615/*---------------------------------------------------------------------------*/
616/*---------------------------------------------------------------------------*/
617
619setUsed(bool is_used)
620{
621 if (m_p->m_is_used == is_used)
622 return;
623
624 m_p->m_is_used = is_used;
625
626 eItemKind ik = itemKind();
627
628 if (m_p->m_is_used) {
629 if (m_p->m_item_group.null() && ik != IK_Unknown) {
630 _checkSetItemFamily();
631 _checkSetItemGroup();
632 // Attention à ne pas reinitialiser les valeurs lorsque ces dernières
633 // sont valides, ce qui est le cas par exemple après une protection.
634 if (!m_p->m_has_valid_data) {
636 // Historiquement on remplissait dans tous les cas la variable avec le
637 // constructeur par défaut
638 // de la donnée en appelant systématiquement fillDefautt(). Cependant,
639 // ce n'était pas le comportement souhaité qui doit être celui défini par
640 // getGlobalDataInitialisationPolicy() (dans DataTypes.h).
641 // On ne le fait maintenant que si le mode d'initialisation est égal
642 // à DIP_Legacy. Ce mode doit à terme disparaître.
644 m_p->m_data->fillDefault();
645 m_p->m_has_valid_data = true;
646 }
647 }
648 }
649 else {
650 _removeMeshReference();
651 if (ik == IK_Unknown)
652 resize(0);
653 else
655 // Indique que les valeurs ne sont plus valides
656 m_p->m_has_valid_data = false;
657 }
658
659 for (VarRefEnumerator i(this); i.hasNext(); ++i) {
660 VariableRef* ref = *i;
661 ref->internalSetUsed(m_p->m_is_used);
662 }
663}
664
665/*---------------------------------------------------------------------------*/
666/*---------------------------------------------------------------------------*/
667
668void Variable::
669_removeMeshReference()
670{
671 IItemFamily* family = m_p->m_item_family;
672 if (family)
673 family->_internalApi()->removeVariable(this);
674
675 if (isPartial())
677
679 m_p->m_item_family = 0;
680}
681
682/*---------------------------------------------------------------------------*/
683/*---------------------------------------------------------------------------*/
684
686isUsed() const
687{
688 return m_p->m_is_used;
689}
690
691/*---------------------------------------------------------------------------*/
692/*---------------------------------------------------------------------------*/
693
694namespace
695{
696
697 String _buildVariableFullType(const IVariable* var)
698 {
699 StringBuilder full_type_b;
700 full_type_b = dataTypeName(var->dataType());
701 full_type_b += ".";
702 full_type_b += itemKindName(var->itemKind());
703 full_type_b += ".";
704 full_type_b += var->dimension();
705 full_type_b += ".";
706 full_type_b += var->multiTag();
707 if (var->isPartial())
708 full_type_b += ".Partial";
709 return full_type_b.toString();
710 }
711
712}
713
714/*---------------------------------------------------------------------------*/
715/*---------------------------------------------------------------------------*/
716
717VariableMetaData* Variable::
718_createMetaData() const
719{
720 auto vmd = new VariableMetaData(name(), meshName(), itemFamilyName(),
722 vmd->setFullType(_buildVariableFullType(this));
723 vmd->setMultiTag(String::fromNumber(multiTag()));
724 vmd->setProperty(property());
725 return vmd;
726}
727
728/*---------------------------------------------------------------------------*/
729/*---------------------------------------------------------------------------*/
730
732createMetaData() const
733{
734 return _createMetaData();
735}
736
737/*---------------------------------------------------------------------------*/
738/*---------------------------------------------------------------------------*/
739
741createMetaDataRef() const
742{
743 return makeRef(_createMetaData());
744}
745
746/*---------------------------------------------------------------------------*/
747/*---------------------------------------------------------------------------*/
748
751{
752 //cout << "** SYNC REFERENCE N=" << m_p->m_nb_reference << " F=" << m_p->m_first_reference << '\n';
753 for (VarRefEnumerator i(this); i.hasNext(); ++i) {
754 VariableRef* ref = *i;
755 //cout << "** SYNC REFERENCE V=" << ref << '\n';
756 ref->updateFromInternal();
757 }
758 // Il faut le faire après la mise à jour des références
759 // car les observateurs peuvent lire les valeurs via une référence
761}
762
763/*---------------------------------------------------------------------------*/
764/*---------------------------------------------------------------------------*/
765
767checkIfSync(int max_print)
768{
769 VariableComparerArgs compare_args;
770 compare_args.setCompareMode(eVariableComparerCompareMode::Sync);
771 compare_args.setMaxPrint(max_print);
772 compare_args.setCompareGhost(true);
773 VariableComparerResults results = _compareVariable(compare_args);
774 return results.nbDifference();
775}
776
777/*---------------------------------------------------------------------------*/
778/*---------------------------------------------------------------------------*/
779
782{
783 VariableComparerArgs compare_args;
784 compare_args.setCompareMode(eVariableComparerCompareMode::SameOnAllReplica);
785 compare_args.setMaxPrint(max_print);
787 return r.nbDifference();
788}
789
790/*---------------------------------------------------------------------------*/
791/*---------------------------------------------------------------------------*/
792
794checkIfSame(IDataReader* reader, Integer max_print, bool compare_ghost)
795{
796 VariableComparerArgs compare_args;
797 compare_args.setMaxPrint(max_print);
798 compare_args.setCompareGhost(compare_ghost);
799 compare_args.setDataReader(reader);
801 return r.nbDifference();
802}
803
804/*---------------------------------------------------------------------------*/
805/*---------------------------------------------------------------------------*/
806
808mesh() const
809{
810 if (m_p->m_mesh_handle.hasMesh())
811 return m_p->m_mesh_handle.mesh();
812 return nullptr;
813}
814
815/*---------------------------------------------------------------------------*/
816/*---------------------------------------------------------------------------*/
817
819meshHandle() const
820{
821 return m_p->m_mesh_handle;
822}
823
824/*---------------------------------------------------------------------------*/
825/*---------------------------------------------------------------------------*/
826
828itemGroup() const
829{
830 return m_p->m_item_group;
831}
832
833/*---------------------------------------------------------------------------*/
834/*---------------------------------------------------------------------------*/
835
837itemKind() const
838{
839 return m_p->m_infos.itemKind();
840}
841
842/*---------------------------------------------------------------------------*/
843/*---------------------------------------------------------------------------*/
844
846dimension() const
847{
848 return m_p->m_infos.dimension();
849}
850
851/*---------------------------------------------------------------------------*/
852/*---------------------------------------------------------------------------*/
853
855multiTag() const
856{
857 return m_p->m_infos.multiTag();
858}
859
860/*---------------------------------------------------------------------------*/
861/*---------------------------------------------------------------------------*/
862
864isPartial() const
865{
866 return m_p->m_is_partial;
867}
868
869/*---------------------------------------------------------------------------*/
870/*---------------------------------------------------------------------------*/
871
873itemFamily() const
874{
875 return m_p->m_item_family;
876}
877
878/*---------------------------------------------------------------------------*/
879/*---------------------------------------------------------------------------*/
880
883{
884 m_p->m_data = data;
885 if (!data.get()) {
886 ARCANE_FATAL("Invalid data: name={0} datatype={1} dimension={2} multitag={3}",
887 m_p->m_infos.fullName(), m_p->m_infos.dataType(),
888 m_p->m_infos.dimension(), m_p->m_infos.multiTag());
889 }
890 data->setName(m_p->m_infos.fullName());
891}
892
893/*---------------------------------------------------------------------------*/
894/*---------------------------------------------------------------------------*/
895
897_setValidData(bool valid_data)
898{
899 m_p->m_has_valid_data = valid_data;
900}
901
902/*---------------------------------------------------------------------------*/
903/*---------------------------------------------------------------------------*/
904
906_hasValidData() const
907{
908 return m_p->m_has_valid_data;
909}
910
911/*---------------------------------------------------------------------------*/
912/*---------------------------------------------------------------------------*/
913
914void Variable::
915_setProperty(int property)
916{
918}
919
920/*---------------------------------------------------------------------------*/
921/*---------------------------------------------------------------------------*/
922
924dataFactoryMng() const
925{
926 return m_p->m_data_factory_mng;
927}
928
929/*---------------------------------------------------------------------------*/
930/*---------------------------------------------------------------------------*/
931
934{
935 debug(Trace::High) << "Serialize (partial) variable name=" << fullName();
936 m_p->serializeHashId(sbuffer);
937 m_p->m_data->serialize(sbuffer, ids, operation);
938 // En mode lecture, les données sont modifiées
939 if (sbuffer->mode() == ISerializer::ModeGet)
941}
942
943/*---------------------------------------------------------------------------*/
944/*---------------------------------------------------------------------------*/
945
947serialize(ISerializer* sbuffer, IDataOperation* operation)
948{
949 debug(Trace::High) << "Serialize (full) variable name=" << fullName();
950
951 m_p->serializeHashId(sbuffer);
952 m_p->m_data->serialize(sbuffer, operation);
953 // En mode lecture, les données sont modifiées
954 if (sbuffer->mode() == ISerializer::ModeGet)
956}
957
958/*---------------------------------------------------------------------------*/
959/*---------------------------------------------------------------------------*/
960
961void Variable::
962_resize(const VariableResizeArgs& resize_args)
963{
964 eItemKind ik = itemKind();
965 if (ik != IK_Unknown) {
966 ARCANE_FATAL("This call is invalid for item variable. Use resizeFromGroup() instead");
967 }
968 _internalResize(resize_args);
970}
971
972/*---------------------------------------------------------------------------*/
973/*---------------------------------------------------------------------------*/
974
976resize(Integer new_size)
977{
978 _resize(VariableResizeArgs(new_size));
979}
980
981/*---------------------------------------------------------------------------*/
982/*---------------------------------------------------------------------------*/
983
986{
987 eItemKind ik = itemKind();
988 if (ik == IK_Unknown)
989 return;
990 Integer new_size = 0;
991 IItemFamily* family = m_p->m_item_family;
992 if (family) {
993 if (m_p->m_item_group.isAllItems())
994 new_size = m_p->m_item_family->maxLocalId();
995 else
996 new_size = m_p->m_item_group.size();
997 }
998 else {
999 ItemGroup group = m_p->m_item_group;
1000 if (!group.null()) {
1001 ARCANE_FATAL("Variable '{0}' has group but no family", fullName());
1002 }
1003 }
1004 debug(Trace::High) << "Variable::resizeFromGroup() var='" << fullName()
1005 << "' with " << new_size << " items "
1006 << " this=" << this;
1007 _internalResize(VariableResizeArgs(new_size, new_size / 20));
1009}
1010
1011/*---------------------------------------------------------------------------*/
1012/*---------------------------------------------------------------------------*/
1013
1014void Variable::
1015_checkSetItemFamily()
1016{
1018 return;
1019
1020 if (m_p->m_mesh_handle.isNull())
1021 m_p->m_mesh_handle = m_p->m_sub_domain->meshMng()->findMeshHandle(m_p->m_infos.meshName());
1022
1024 if (!mesh)
1025 ARCANE_FATAL("No mesh named '{0}' exists for variable '{1}'", m_p->m_infos.meshName(), name());
1026
1027 eItemKind ik = itemKind();
1028
1029 IItemFamily* family = 0;
1030 const String& family_name = m_p->m_infos.itemFamilyName();
1031 if (ik == IK_Particle || ik == IK_DoF) {
1032 if (family_name.null()) {
1033 ARCANE_FATAL("family name not specified for variable {0}", name());
1034 }
1035 family = mesh->findItemFamily(ik, family_name, true);
1036 }
1037 else {
1038 family = mesh->itemFamily(ik);
1039 }
1040
1041 if (family && family->itemKind() != itemKind())
1042 ARCANE_FATAL("Bad family kind '{0}' '{1}'", family->itemKind(), itemKind());
1043
1044 if (family && family->name() != itemFamilyName())
1045 ARCANE_FATAL("Incoherent family name. var={0} from_type={1} given={2}",
1046 name(), family->name(), itemFamilyName());
1047
1048 if (!family)
1049 ARCANE_FATAL("Family not found");
1050
1051 if (isPartial() && !family->hasUniqueIdMap())
1052 ARCANE_FATAL("Cannot have partial variable for a family without unique id map");
1053
1054 m_p->m_item_family = family;
1055 debug(Trace::High) << "Variable::setItemFamily() name=" << name()
1056 << " family=" << family
1057 << " familyname='" << family_name << "'";
1058 family->_internalApi()->addVariable(this);
1059}
1060
1061/*---------------------------------------------------------------------------*/
1062/*---------------------------------------------------------------------------*/
1063
1064void Variable::
1065_checkSetItemGroup()
1066{
1067 if (!m_p->m_item_group.null())
1068 return;
1069 const String& group_name = m_p->m_infos.itemGroupName();
1070 //info() << " CHECK SET GROUP var=" << name() << " group=" << group_name;
1071 if (group_name.null()) {
1072 m_p->m_item_group = m_p->m_item_family->allItems();
1073 }
1074 else
1075 m_p->m_item_group = m_p->m_item_family->findGroup(group_name, true);
1076
1077 ItemGroupImpl* internal = m_p->m_item_group.internal();
1078 // (HP) TODO: faut il garder ce controle hérité de l'ancienne implémentation de addVariable
1079 if (internal->parent() && (mesh()->parallelMng()->isParallel() && internal->isOwn()))
1080 ARCANE_FATAL("Cannot add variable ({0}) on a own group (name={1})",
1081 fullName(), internal->name());
1082 if (isPartial()) {
1083 if (group_name.empty())
1084 ARCANE_FATAL("Cannot create a partial variable with an empty item_group_name");
1085 debug(Trace::High) << "Attach ItemGroupPartialVariableObserver from " << fullName()
1086 << " to " << m_p->m_item_group.name();
1087 internal->attachObserver(this, new ItemGroupPartialVariableObserver(this));
1088 }
1089}
1090
1091/*---------------------------------------------------------------------------*/
1092/*---------------------------------------------------------------------------*/
1093
1096{
1097 return &(m_p->m_write_observable);
1098}
1099
1100/*---------------------------------------------------------------------------*/
1101/*---------------------------------------------------------------------------*/
1102
1105{
1106 return &(m_p->m_read_observable);
1107}
1108
1109/*---------------------------------------------------------------------------*/
1110/*---------------------------------------------------------------------------*/
1111
1114{
1115 return &(m_p->m_on_size_changed_observable);
1116}
1117
1118/*---------------------------------------------------------------------------*/
1119/*---------------------------------------------------------------------------*/
1120
1121/*---------------------------------------------------------------------------*/
1122/*---------------------------------------------------------------------------*/
1123
1125update()
1126{
1127 update(DPT_PreviousTime);
1128}
1129
1130/*---------------------------------------------------------------------------*/
1131/*---------------------------------------------------------------------------*/
1132
1133void Variable::
1134update(Real wanted_time)
1135{
1136 if (m_p->m_last_update_time < wanted_time) {
1137 for (Integer k = 0, n = m_p->m_depends.size(); k < n; ++k) {
1138 VariableDependInfo& vdi = m_p->m_depends[k];
1139 if (vdi.dependType() == DPT_PreviousTime)
1140 vdi.variable()->update(wanted_time);
1141 }
1142 }
1143
1144 if (m_p->m_has_recursive_depend) {
1145 for (Integer k = 0, n = m_p->m_depends.size(); k < n; ++k) {
1146 VariableDependInfo& vdi = m_p->m_depends[k];
1147 if (vdi.dependType() == DPT_CurrentTime)
1148 vdi.variable()->update(m_p->m_last_update_time);
1149 }
1150 }
1151
1152 bool need_update = false;
1153 Int64 modified_time = m_p->m_modified_time;
1154 for (Integer k = 0, n = m_p->m_depends.size(); k < n; ++k) {
1155 VariableDependInfo& vdi = m_p->m_depends[k];
1156 Int64 mt = vdi.variable()->modifiedTime();
1157 if (mt > modified_time) {
1158 need_update = true;
1159 break;
1160 }
1161 }
1162 if (need_update) {
1163 IVariableComputeFunction* cf = m_p->m_compute_function.get();
1164 //msg->info() << "Need Compute For Variable <" << name() << "> " << cf;
1165 if (cf) {
1166 //msg->info() << "Compute For Variable <" << name() << ">";
1167 cf->execute();
1168 }
1169 else {
1170 ARCANE_FATAL("No compute function for variable '{0}'", fullName());
1171 }
1172 }
1173}
1174
1175/*---------------------------------------------------------------------------*/
1176/*---------------------------------------------------------------------------*/
1177
1180{
1181 m_p->m_last_update_time = subDomain()->commonVariables().globalTime();
1182 m_p->m_modified_time = IVariable::incrementModifiedTime();
1183}
1184
1185/*---------------------------------------------------------------------------*/
1186/*---------------------------------------------------------------------------*/
1187
1190{
1191 return m_p->m_modified_time;
1192}
1193
1194/*---------------------------------------------------------------------------*/
1195/*---------------------------------------------------------------------------*/
1196
1199{
1200 m_p->m_depends.add(VariableDependInfo(var, dt, TraceInfo()));
1201}
1202
1203/*---------------------------------------------------------------------------*/
1204/*---------------------------------------------------------------------------*/
1205
1207addDepend(IVariable* var, eDependType dt, const TraceInfo& tinfo)
1208{
1209 m_p->m_depends.add(VariableDependInfo(var, dt, tinfo));
1210}
1211
1212/*---------------------------------------------------------------------------*/
1213/*---------------------------------------------------------------------------*/
1214
1217{
1218 ARCANE_UNUSED(var);
1219 throw NotImplementedException(A_FUNCINFO);
1220}
1221
1222/*---------------------------------------------------------------------------*/
1223/*---------------------------------------------------------------------------*/
1224
1227{
1228 m_p->m_compute_function = v;
1229}
1230
1231/*---------------------------------------------------------------------------*/
1232/*---------------------------------------------------------------------------*/
1233
1236{
1237 return m_p->m_compute_function.get();
1238}
1239
1240/*---------------------------------------------------------------------------*/
1241/*---------------------------------------------------------------------------*/
1242
1245{
1246 for (Integer k = 0, n = m_p->m_depends.size(); k < n; ++k) {
1247 VariableDependInfo& vdi = m_p->m_depends[k];
1248 infos.add(vdi);
1249 }
1250}
1251
1252/*---------------------------------------------------------------------------*/
1253/*---------------------------------------------------------------------------*/
1254
1255/*---------------------------------------------------------------------------*/
1256/*---------------------------------------------------------------------------*/
1257
1259addTag(const String& tagname, const String& tagvalue)
1260{
1261 m_p->m_tags[tagname] = tagvalue;
1262}
1263
1264/*---------------------------------------------------------------------------*/
1265/*---------------------------------------------------------------------------*/
1266
1268removeTag(const String& tagname)
1269{
1270 m_p->m_tags.erase(tagname);
1271}
1272
1273/*---------------------------------------------------------------------------*/
1274/*---------------------------------------------------------------------------*/
1275
1277hasTag(const String& tagname)
1278{
1279 return m_p->m_tags.find(tagname) != m_p->m_tags.end();
1280}
1281
1282/*---------------------------------------------------------------------------*/
1283/*---------------------------------------------------------------------------*/
1284
1286tagValue(const String& tagname)
1287{
1288 std::map<String, String>::const_iterator i = m_p->m_tags.find(tagname);
1289 if (i == m_p->m_tags.end())
1290 return String();
1291 return i->second;
1292}
1293
1294/*---------------------------------------------------------------------------*/
1295/*---------------------------------------------------------------------------*/
1296
1299{
1300 setUpToDate();
1303 _setValidData(true);
1304}
1305
1306/*---------------------------------------------------------------------------*/
1307/*---------------------------------------------------------------------------*/
1308
1314
1315/*---------------------------------------------------------------------------*/
1316/*---------------------------------------------------------------------------*/
1317
1319read(IDataReader* reader)
1320{
1321 reader->read(this, data());
1322 notifyEndRead();
1323}
1324
1325/*---------------------------------------------------------------------------*/
1326/*---------------------------------------------------------------------------*/
1327
1329write(IDataWriter* writer)
1330{
1332 writer->write(this, data());
1333}
1334
1335/*---------------------------------------------------------------------------*/
1336/*---------------------------------------------------------------------------*/
1337
1339changeGroupIds(Int32ConstArrayView old_to_new_ids)
1340{
1341 ARCANE_UNUSED(old_to_new_ids);
1342 // pH: default implementation since this method is not yet official
1343}
1344
1345/*---------------------------------------------------------------------------*/
1346/*---------------------------------------------------------------------------*/
1360{
1361 if (!m_p->m_is_used)
1362 ARCANE_FATAL("Can not swap variable values for unused variable (instance)");
1363 if (!rhs->m_p->m_is_used)
1364 ARCANE_FATAL("Can not swap variable values for unused variable (argument)");
1365 if (isPartial() || rhs->isPartial())
1366 ARCANE_FATAL("Can not swap variable values for partial variables");
1367 if (itemGroup() != rhs->itemGroup())
1368 ARCANE_FATAL("Can not swap variable values for variables from different groups");
1369}
1370
1371/*---------------------------------------------------------------------------*/
1372/*---------------------------------------------------------------------------*/
1373
1374bool Variable::
1375_wantShrink() const
1376{
1377 return m_p->m_want_shrink;
1378}
1379
1380/*---------------------------------------------------------------------------*/
1381/*---------------------------------------------------------------------------*/
1382
1385{
1386 data()->setAllocationInfo(v);
1387 // Il est possible que le changement d'allocation modifie les données
1388 // allouées. Il faut donc synchroniser les références.
1390}
1391
1392/*---------------------------------------------------------------------------*/
1393/*---------------------------------------------------------------------------*/
1394
1396allocationInfo() const
1397{
1398 return data()->allocationInfo();
1399}
1400
1401/*---------------------------------------------------------------------------*/
1402/*---------------------------------------------------------------------------*/
1403
1406{
1407 return m_p;
1408}
1409
1410/*---------------------------------------------------------------------------*/
1411/*---------------------------------------------------------------------------*/
1412
1413/*---------------------------------------------------------------------------*/
1414/*---------------------------------------------------------------------------*/
1415
1418 IData* sorted_data)
1419{
1420 ARCANE_CHECK_POINTER(hash_algo);
1421 ARCANE_CHECK_POINTER(sorted_data);
1422
1423 INumericDataInternal* num_data = sorted_data->_commonInternal()->numericData();
1424 if (!num_data)
1425 return {};
1426 if (!m_item_family)
1427 return {};
1428
1429 IParallelMng* pm = m_item_family->parallelMng();
1430 Int32 my_rank = pm->commRank();
1431 Int32 master_rank = pm->masterIORank();
1432 ConstMemoryView memory_view = num_data->memoryView();
1433
1434 UniqueArray<Byte> bytes;
1435
1436 pm->gatherVariable(Arccore::asSpan<Byte>(memory_view.bytes()).smallView(), bytes, master_rank);
1437
1438 String hash_string;
1439 if (my_rank == master_rank) {
1440 HashAlgorithmValue hash_value;
1441 hash_algo->computeHash(asBytes(bytes), hash_value);
1442 hash_string = Convert::toHexaString(asBytes(hash_value.bytes()));
1443 }
1444 return hash_string;
1445}
1446
1447/*---------------------------------------------------------------------------*/
1448/*---------------------------------------------------------------------------*/
1449
1451changeAllocator(const MemoryAllocationOptions& mem_options)
1452{
1453 INumericDataInternal* dx = m_data->_commonInternal()->numericData();
1454 if (dx) {
1455 dx->changeAllocator(mem_options);
1456 m_variable->syncReferences();
1457 }
1458}
1459
1460/*---------------------------------------------------------------------------*/
1461/*---------------------------------------------------------------------------*/
1462
1464resize(const VariableResizeArgs& resize_args)
1465{
1466 return m_variable->_resize(resize_args);
1467}
1468
1469/*---------------------------------------------------------------------------*/
1470/*---------------------------------------------------------------------------*/
1471
1473compareVariable(const VariableComparerArgs& compare_args)
1474{
1475 return m_variable->_compareVariable(compare_args);
1476}
1477
1478/*---------------------------------------------------------------------------*/
1479/*---------------------------------------------------------------------------*/
1480
1482replicaParallelMng() const
1483{
1484 //TODO: regarder si la variable est utilisée.
1485 IMesh* mesh = m_variable->mesh();
1486 // TODO: faut-il prendre le sous-domaine dans ce cas ?
1487 IParallelMng* pm = (mesh) ? mesh->parallelMng() : m_variable->subDomain()->parallelMng();
1489 if (!pr->hasReplication())
1490 return nullptr;
1491 return pr->replicaParallelMng();
1492}
1493
1494/*---------------------------------------------------------------------------*/
1495/*---------------------------------------------------------------------------*/
1496
1497} // End namespace Arcane
1498
1499/*---------------------------------------------------------------------------*/
1500/*---------------------------------------------------------------------------*/
1501
1502#endif
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Tableau d'items de types quelconques.
void reserve(Int64 new_capacity)
Réserve le mémoire pour new_capacity éléments.
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
Observable qui appelle automatiquement IObservable::detachAllObservers() dans le destructeur.
Real globalTime() const
Temps courant.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
constexpr bool empty() const noexcept
true si le tableau est vide (size()==0)
Informations sur l'allocation d'une donnée.
Valeur retournée par un algorithme de hashage.
Interface du gestionnaire de fabrique d'une donnée.
virtual INumericDataInternal * numericData()
Interface générique pour les données numériques (nullptr si la donnée n'est pas numérique)
Interface d'une opération sur une donnée.
Interface de lecture des données d'une variable.
Definition IDataReader.h:41
virtual void read(IVariable *var, IData *data)=0
Lit les données data de la variable var.
Interface d'écriture des données d'une variable.
Definition IDataWriter.h:49
virtual void write(IVariable *var, IData *data)=0
Ecrit les données data de la variable var.
Interface d'une donnée.
Definition IData.h:33
virtual DataAllocationInfo allocationInfo() const =0
Informations sur l'allocation.
virtual IDataInternal * _commonInternal()=0
virtual void setAllocationInfo(const DataAllocationInfo &v)=0
Positionne les informations sur l'allocation.
Interface d'un algorithme de hashage.
virtual void computeHash(Span< const std::byte > input, HashAlgorithmValue &value)
Calcule la valeur du hash pour le tableau input.
virtual void addVariable(IVariable *var)=0
Ajoute une variable à cette famille.
virtual void removeVariable(IVariable *var)=0
Supprime une variable à cette famille.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
virtual bool hasUniqueIdMap() const =0
Indique si la famille possède une table de conversion uniqueId vers localId.
virtual String name() const =0
Nom de la famille.
virtual eItemKind itemKind() const =0
Genre des entités.
virtual IItemFamilyInternal * _internalApi()=0
API interne à Arcane.
virtual MeshHandle * findMeshHandle(const String &name, bool throw_exception)=0
Recherche le maillage de nom name.
Interface pour un 'IData' d'un type numérique.
virtual void changeAllocator(const MemoryAllocationOptions &alloc_info)=0
Change l'allocateur de la variable.
virtual MutableMemoryView memoryView()=0
Vue mémoire sur la donnée.
Interface d'un observable.
virtual void notifyAllObservers()=0
Notifie tous les observateurs.
Interface du gestionnaire de parallélisme pour un sous-domaine.
virtual void gatherVariable(ConstArrayView< char > send_buf, Array< char > &recv_buf, Int32 rank)=0
Effectue un regroupement sur tous les processeurs.
virtual Int32 commRank() const =0
Rang de cette instance dans le communicateur.
virtual IParallelReplication * replication() const =0
Informations sur la réplication.
virtual Integer masterIORank() const =0
Rang de l'instance gérant les entrées/sorties (pour laquelle isMasterIO() est vrai)
Informations sur la réplication des sous-domaines en parallèle.
virtual bool hasReplication() const =0
Indique si la réplication est active.
virtual IParallelMng * replicaParallelMng() const =0
Communicateur associé à tous les réplicats représentant un même sous-domaine.
@ ModePut
Le sérialiseur attend des reserve()
virtual void putSpan(Span< const Real > values)
Ajoute le tableau values.
virtual eMode mode() const =0
Mode de fonctionnement actuel.
virtual void getSpan(Span< Real > values)
Récupère le tableau values.
virtual void reserveSpan(eBasicDataType dt, Int64 n)=0
Réserve de la mémoire pour n valeurs de dt.
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
virtual const CommonVariables & commonVariables() const =0
Informations sur les variables standards.
virtual IMeshMng * meshMng() const =0
Retourne le gestionnaire de maillage.
virtual IVariableMng * variableMng()=0
Retourne le gestionnaire de variables.
Interface de la classe fonctor de recalcul d'une variable.
Partie interne de Ivariable.
virtual void removeVariable(IVariable *var)=0
Supprime une variable.
Interface du gestionnaire de variables.
virtual IVariableMngInternal * _internalApi()=0
API interne à Arcane.
Interface d'une variable.
Definition IVariable.h:56
virtual eDataType dataType() const =0
Type de la donnée gérée par la variable (Real, Integer, ...)
eDependType
Type des dépendances.
Definition IVariable.h:61
@ PSubDomainDepend
Indique que la valeur de la variable est dépendante du sous-domaine.
Definition IVariable.h:93
@ PNoExchange
Indique que la variable ne doit pas être échangée.
Definition IVariable.h:145
@ PNoReplicaSync
Indique que la variable n'a pas forcément la même valeur entre les réplicas.
Definition IVariable.h:161
@ PTemporary
Indique que la variable est temporaire.
Definition IVariable.h:128
@ PExecutionDepend
Indique que la valeur de la variable est dépendante de l'exécution.
Definition IVariable.h:108
@ PPrivate
Indique que la variable est privée.
Definition IVariable.h:116
@ PPersistant
Indique que la variable est persistante.
Definition IVariable.h:152
@ PNoRestore
Indique que la variable ne doit pas être restaurée.
Definition IVariable.h:135
@ PNoNeedSync
Indique que la variable n'est pas nécessairement synchronisée.
Definition IVariable.h:82
@ PNoDump
Indique que la variable ne doit pas être sauvegardée.
Definition IVariable.h:74
virtual eItemKind itemKind() const =0
Type des entités du maillage sur lequel repose la variable.
virtual bool isPartial() const =0
Indique si la variable est partielle.
virtual Integer dimension() const =0
Dimension de la variable.
virtual IData * data()=0
Données associées à la variable.
virtual ItemGroup itemGroup() const =0
Groupe du maillage associé.
static Int64 incrementModifiedTime()
Incrémente le compteur de modification et retourne sa valeur avant modification.
Definition Variable.cc:198
virtual Integer multiTag() const =0
Indique si la variable est un tableau à taille multiple.
virtual void update()=0
Recalcule la variable si nécessaire.
Fonctor pour une fonction de hachage.
void detachObserver(const void *ref)
Détache un observer.
void executeExtend(const Int32ConstArrayView *info) override
Execute l'action associée à l'extension.
Definition Variable.cc:251
void executeReduce(const Int32ConstArrayView *info) override
Execute l'action associée à l'extension.
Definition Variable.cc:267
void executeInvalidate() override
Execute l'action associée à l'invalidation.
Definition Variable.cc:317
void executeCompact(const Int32ConstArrayView *info) override
Execute l'action associée au compactage.
Definition Variable.cc:306
bool needInfo() const override
Indique si l'observer aura besoin d'information de transition.
Definition Variable.cc:325
Groupe d'entités de maillage.
Definition ItemGroup.h:49
ItemGroupImpl * internal() const
Retourne l'implémentation du groupe.
Definition ItemGroup.h:120
SharedPtrT< GroupIndexTable > localIdToIndex() const
Table des local ids vers une position pour toutes les entités du groupe.
Definition ItemGroup.h:307
ItemVectorView view() const
Vue sur les entités du groupe.
Definition ItemGroup.cc:583
Integer size() const
Nombre d'éléments du groupe.
Definition ItemGroup.h:88
bool isAllItems() const
Indique si le groupe est celui de toutes les entités.
Definition ItemGroup.cc:610
bool null() const
true is le groupe est le groupe nul
Definition ItemGroup.h:70
Vue sur un vecteur d'entités.
Options pour configurer les allocations.
Handle sur un maillage.
Definition MeshHandle.h:47
bool isNull() const
Indique si le handle est nul (il ne référence aucun maillage existant ou non)
Definition MeshHandle.h:162
IMesh * mesh() const
Maillage associé.
Exception lorsqu'une fonction n'est pas implémentée.
Référence à une instance.
Encapsulation d'un pointeur qui se détruit automatiquement.
Definition ScopedPtr.h:44
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Definition Span.h:212
__host__ __device__ void fill(T o)
Remplit le tableau avec la valeur o.
Definition Span.h:264
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
constexpr __host__ __device__ Span< T, DynExtent > subspan(Int64 abegin, Int64 asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
Definition Span.h:593
Constructeur de chaîne de caractère unicode.
String toString() const
Retourne la chaîne de caractères construite.
Chaîne de caractères unicode.
bool null() const
Retourne true si la chaîne est nulle.
Definition String.cc:304
Span< const Byte > bytes() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:291
StringView view() const
Retourne une vue sur la chaîne actuelle.
Definition String.cc:367
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium) const
Flot pour un message de debug.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
Paramètres nécessaires à la construction d'une variable.
Arguments des méthodes de VariableComparer.
void setMaxPrint(Int32 v)
Positionne le nombre d'erreurs à afficher dans le listing.
void setCompareGhost(bool v)
Indique sur quelles entités on fait la comparaison.
Résultats d'une opération de comparaison.
Informations sur une dépendance de variable.
IVariable::eDependType dependType() const
Type de dépendance.
IVariable * variable() const
Variable.
Infos caractérisant une variable.
const String & itemFamilyName() const
Nom de la famille d'entité à laquelle la variable est associée.
const String & meshName() const
Nom du maillage auquel la variable est associée.
Meta-données sur une variable.
void resize(const VariableResizeArgs &resize_args) override
Redimensionne la variable en ajoutant une capacité additionnelle.
Definition Variable.cc:1464
void changeAllocator(const MemoryAllocationOptions &alloc_info) override
Change l'allocateur de la variable.
Definition Variable.cc:1451
VariableComparerResults compareVariable(const VariableComparerArgs &compare_args) override
Applique la méthode de comparaison spécifiée par compare_args.
Definition Variable.cc:1473
bool m_has_recursive_depend
Vrai si les dépendances sont récursives.
Definition Variable.cc:113
IParallelMng * replicaParallelMng() const
Retourne le IParallelMng du replica du maillage associé à la variable.
Definition Variable.cc:1482
VariableInfo m_infos
Infos caractéristiques de la variable.
Definition Variable.cc:97
IItemFamily * m_item_family
Familly d'entité (peut être nul)
Definition Variable.cc:96
Integer m_nb_reference
Première référence sur la variable.
Definition Variable.cc:105
UniqueArray< VariableDependInfo > m_depends
Liste des dépendances de cette variable.
Definition Variable.cc:106
int m_property
Propriétés de la variable.
Definition Variable.cc:98
AutoDetachObservable m_on_size_changed_observable
Observable en redimensionnement.
Definition Variable.cc:111
Byte m_hash_id[HASHID_SIZE]
hash de la variable pour vérifier la cohérence de la sérialisation.
Definition Variable.cc:170
Real m_last_update_time
Temps physique de la dernière mise à jour.
Definition Variable.cc:103
Int64 m_modified_time
Tag de la dernière modification.
Definition Variable.cc:107
MeshHandle m_mesh_handle
Maillage (peut être nul)
Definition Variable.cc:93
String computeComparisonHashCollective(IHashAlgorithm *hash_algo, IData *sorted_data) override
Calcule de Hash de comparaison pour la variable.
Definition Variable.cc:1417
std::map< String, String > m_tags
Liste des tags.
Definition Variable.cc:112
ItemGroup m_item_group
Groupe d'entité sur lequel est associé la variable.
Definition Variable.cc:95
bool m_is_used
Etat d'utilisation de la variable.
Definition Variable.cc:101
void serializeHashId(ISerializer *sbuf)
Sérialise le hashid.
Definition Variable.cc:125
ScopedPtrT< IVariableComputeFunction > m_compute_function
Fonction de calcul.
Definition Variable.cc:108
AutoDetachObservable m_read_observable
Observable en lecture.
Definition Variable.cc:110
AutoDetachObservable m_write_observable
Observable en écriture.
Definition Variable.cc:109
bool m_has_valid_data
Vrai si les données sont valide.
Definition Variable.cc:102
bool m_is_partial
Vrai si la variable est partielle.
Definition Variable.cc:99
Variable * m_variable
Variable associée.
Definition Variable.cc:115
Ref< IData > m_data
Données de la variable.
Definition Variable.cc:94
Référence à une variable.
Definition VariableRef.h:56
virtual void updateFromInternal()
Mise à jour à partir de la partie interne.
void setPreviousReference(VariableRef *v)
Positionne la référence précédente.
VariableRef * previousReference()
Référence précédente (ou null) sur variable()
virtual int referenceProperty() const
Propriétés de la référence (interne)
void setNextReference(VariableRef *v)
Positionne la référence suivante.
VariableRef * nextReference()
Référence suivante (ou null) sur variable()
Arguments pour redimensionner une variable.
Instance d'une variable.
Definition Variable.h:79
void resizeFromGroup() override
Positionne le nombre d'éléments pour une variable du maillage.
Definition Variable.cc:985
String itemGroupName() const final
Nom du groupe d'entité associée.
Definition Variable.cc:503
IMesh * mesh() const final
Maillage auquel est associé la variable.
Definition Variable.cc:808
void notifyBeginWrite() override
Notifie du début d'écriture de data().
Definition Variable.cc:1310
Integer nbReference() const override
Nombre de références sur cette variable.
Definition Variable.cc:449
void removeVariableRef(VariableRef *ref) override
Supprime une référence à cette variable.
Definition Variable.cc:387
void _checkSwapIsValid(Variable *rhs)
Vérifie qu'il est possible d'échanger les valeurs de l'instance avec celle de rhs.
Definition Variable.cc:1359
bool isUsed() const override
Etat d'utilisation de la variable.
Definition Variable.cc:686
Variable(const VariableBuildInfo &v, const VariableInfo &vi)
Créé une variable lié à la référence v.
Definition Variable.cc:336
void _setData(const Ref< IData > &data)
Positionne la donnée.
Definition Variable.cc:882
void _setValidData(bool valid_data)
Indique si les données de la variable sont valides.
Definition Variable.cc:897
VariableMetaData * createMetaData() const override
Créé une instance contenant les meta-données de la variable.
Definition Variable.cc:732
IVariableComputeFunction * computeFunction() override
Fonction utilisée pour mettre à jour la variable.
Definition Variable.cc:1235
Ref< VariableMetaData > createMetaDataRef() const override
Créé une instance contenant les meta-données de la variable.
Definition Variable.cc:741
bool isPartial() const override
Indique si la variable est partielle.
Definition Variable.cc:864
String tagValue(const String &tagname) override
Valeur du tag tagname. La chaîne est nulle si le tag n'existe pas.
Definition Variable.cc:1286
void notifyReferencePropertyChanged() override
Indique que les propriétés d'une des références à cette variable ont changé (interne)
Definition Variable.cc:610
IVariableMng * variableMng() const override
Gestionnaire de variable associé à la variable.
Definition Variable.cc:467
void removeTag(const String &tagname) override
Supprime le tag tagname.
Definition Variable.cc:1268
void addDepend(IVariable *var, eDependType dt) override
Ajoute var à la liste des dépendances.
Definition Variable.cc:1198
String name() const final
Nom de la variable.
Definition Variable.cc:476
IObservable * readObservable() override
Observable en lecture.
Definition Variable.cc:1104
virtual VariableComparerResults _compareVariable(const VariableComparerArgs &compare_args)=0
Comparaison de valeurs entre variables.
void serialize(ISerializer *sbuffer, IDataOperation *operation) override
Definition Variable.cc:947
ItemGroup itemGroup() const final
Groupe du maillage associé.
Definition Variable.cc:828
IObservable * onSizeChangedObservable() override
Observable en redimensionnement.
Definition Variable.cc:1113
void notifyEndRead() override
Notifie de la modification externe de data().
Definition Variable.cc:1298
void read(IDataReader *d) override
Definition Variable.cc:1319
void syncReferences() override
Synchronise les références.
Definition Variable.cc:750
void setUsed(bool v) override
Positionne l'état d'utilisation de la variable.
Definition Variable.cc:619
VariableRef * firstReference() const override
Première réference (ou null) sur cette variable.
Definition Variable.cc:424
String fullName() const final
Nom complet de la variable (avec le préfixe de la famille)
Definition Variable.cc:485
eItemKind itemKind() const override
Type des entités du maillage sur lequel repose la variable.
Definition Variable.cc:837
ISubDomain * subDomain() override
Sous-domaine associé à la variable (TODO rendre obsolète fin 2023)
Definition Variable.cc:458
void update() override
Recalcule la variable si nécessaire.
Definition Variable.cc:1125
Integer dimension() const override
Dimension de la variable.
Definition Variable.cc:846
Int64 modifiedTime() override
Temps auquel la variable a été mise à jour.
Definition Variable.cc:1189
void setUpToDate() override
Indique que la variable vient d'être mise à jour.
Definition Variable.cc:1179
void addTag(const String &tagname, const String &tagvalue) override
Ajoute le tag tagname avev la valeur tagvalue.
Definition Variable.cc:1259
Int32 checkIfSame(IDataReader *reader, Integer max_print, bool compare_ghost) final
Vérifie que la variable est identique à une valeur de référence.
Definition Variable.cc:794
~Variable() override
Libère les ressources.
Definition Variable.cc:346
bool _hasValidData() const
Indique si les données de la variable sont valides.
Definition Variable.cc:906
IObservable * writeObservable() override
Observable en écriture.
Definition Variable.cc:1095
void addVariableRef(VariableRef *ref) override
Ajoute une référence à cette variable.
Definition Variable.cc:366
Integer multiTag() const override
Indique si la variable est un tableau à taille multiple.
Definition Variable.cc:855
void setComputeFunction(IVariableComputeFunction *v) override
Positionne la fonction de recalcul de la variable.
Definition Variable.cc:1226
void resize(Integer n) override
Positionne le nombre d'éléments pour une variable tableau.
Definition Variable.cc:976
IVariableInternal * _internalApi() override
API interne à Arcane.
Definition Variable.cc:1405
IItemFamily * itemFamily() const final
Famille d'entité associée.
Definition Variable.cc:873
eDataType dataType() const override
Type de la donnée gérée par la variable (Real, Integer, ...)
Definition Variable.cc:521
void write(IDataWriter *d) override
Sauve la variable.
Definition Variable.cc:1329
IDataFactoryMng * dataFactoryMng() const final
Fabrique de données associées à la variable.
Definition Variable.cc:924
void changeGroupIds(Int32ConstArrayView old_to_new_ids) override
pH : EXPERIMENTAL
Definition Variable.cc:1339
void removeDepend(IVariable *var) override
Supprime var de la liste des dépendances.
Definition Variable.cc:1216
VariablePrivate * m_p
Implémentation.
Definition Variable.h:238
String itemFamilyName() const final
Nom de la famille associée (nul si aucune).
Definition Variable.cc:494
Int32 checkIfSync(Integer max_print) final
Vérifie si la variable est bien synchronisée.
Definition Variable.cc:767
DataAllocationInfo allocationInfo() const override
Informations sur l'allocation.
Definition Variable.cc:1396
int property() const override
Definition Variable.cc:532
Int32 checkIfSameOnAllReplica(Integer max_print) final
Vérifie si la variable a les mêmes valeurs sur tous les réplicas.
Definition Variable.cc:781
void dependInfos(Array< VariableDependInfo > &infos) override
Infos de dépendances.
Definition Variable.cc:1244
bool hasTag(const String &tagname) override
true si la variable possède le tag tagname
Definition Variable.cc:1277
void setAllocationInfo(const DataAllocationInfo &v) override
Positionne les informations sur l'allocation.
Definition Variable.cc:1384
MeshHandle meshHandle() const final
Maillage auquel est associé la variable.
Definition Variable.cc:819
String meshName() const final
Nom du maillage associé (nul si aucun).
Definition Variable.cc:512
String toHexaString(ByteConstArrayView input)
Converti un tableau d'octet en sa représentation hexadécimale.
Definition Convert.cc:75
ARCCORE_BASE_EXPORT String getEnvironmentVariable(const String &name)
Variable d'environnement du nom name.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
@ DIP_Legacy
Initialisation en mode historique.
Definition DataTypes.h:161
std::int64_t Int64
Type entier signé sur 64 bits.
eDataInitialisationPolicy getGlobalDataInitialisationPolicy()
Récupère la politique d'initialisation des variables.
Definition DataTypes.cc:162
Int32 Integer
Type représentant un entier.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:428
impl::SpanTypeFromSize< conststd::byte, SizeType >::SpanType asBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets non modifiables.
Definition Span.h:884
@ SameOnAllReplica
Vérifie que les valeurs de la variable sont les même sur tous les replica.
@ Sync
Vérifie que la variable est bien synchronisée.
eItemKind
Genre d'entité de maillage.
@ IK_Particle
Entité de maillage de genre particule.
@ IK_Unknown
Entité de maillage de genre inconnu ou non initialisé
@ IK_DoF
Entité de maillage de genre degre de liberte.
const char * itemKindName(eItemKind kind)
Nom du genre d'entité.
double Real
Type représentant un réel.
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
eDataType
Type d'une donnée.
Definition DataTypes.h:39
const char * dataTypeName(eDataType type)
Nom du type de donnée.
Definition DataTypes.cc:70
std::int32_t Int32
Type entier signé sur 32 bits.
Span< DataType > asSpan(Span< std::byte, Extent > bytes)
Converti un Span<std::byte> en un Span<DataType>.
Definition Span.h:976