Arcane  v3.14.10.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
NumArrayData.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/* NumArrayData.cc (C) 2000-2024 */
9/* */
10/* Donnée de type 'NumArray'. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arccore/base/ReferenceCounterImpl.h"
15#include "arccore/base/Ref.h"
16
17#include "arcane/utils/NumArray.h"
18#include "arcane/utils/NotSupportedException.h"
19#include "arcane/utils/Real2.h"
20#include "arcane/utils/Real2x2.h"
21#include "arcane/utils/Real3.h"
22#include "arcane/utils/Real3x3.h"
23#include "arcane/utils/IHashAlgorithm.h"
24#include "arcane/utils/NotImplementedException.h"
25#include "arcane/utils/ArgumentException.h"
26#include "arcane/utils/FatalErrorException.h"
27#include "arcane/utils/ITraceMng.h"
28#include "arcane/utils/CheckedConvert.h"
29#include "arcane/utils/ArrayShape.h"
30
31#include "arccore/base/Span2.h"
32
33#include "arcane/core/datatype/DataAllocationInfo.h"
34#include "arcane/core/datatype/IDataOperation.h"
35#include "arcane/core/datatype/DataStorageTypeInfo.h"
36#include "arcane/core/datatype/DataStorageBuildInfo.h"
37#include "arcane/core/datatype/DataTypeTraits.h"
38
39#include "arcane/core/ISerializer.h"
40#include "arcane/core/IData.h"
41#include "arcane/core/IDataVisitor.h"
42
43#include "arcane/core/internal/IDataInternal.h"
44
45#include "arcane/impl/SerializedData.h"
46#include "arcane/impl/DataStorageFactory.h"
47
48/*---------------------------------------------------------------------------*/
49/*---------------------------------------------------------------------------*/
50
51namespace Arcane
52{
53
54namespace
55{
56 const Int64 SERIALIZE2_MAGIC_NUMBER = 0x923abd20;
57}
61template <class DataType,int RankValue>
62class INumArrayDataT
63: public IData
64{
65 public:
66
67 typedef INumArrayDataT<DataType,RankValue> ThatClass;
68 using ExtentType = typename MDDimType<RankValue>::DimType;
69
70 public:
71
73 virtual MDSpan<const DataType,ExtentType> view() const = 0;
74
76 virtual MDSpan<DataType,ExtentType> view() = 0;
77
79 virtual Ref<ThatClass> cloneTrueRef() = 0;
80
82 virtual Ref<ThatClass> cloneTrueEmptyRef() = 0;
83};
84
85/*---------------------------------------------------------------------------*/
86/*---------------------------------------------------------------------------*/
90template <class DataType,int RankValue>
91class NumArrayDataT
92: public ReferenceCounterImpl
93, public INumArrayDataT<DataType,RankValue>
94{
95 ARCCORE_DEFINE_REFERENCE_COUNTED_INCLASS_METHODS();
96 class Impl;
97 friend Impl;
98
99 public:
100
101 typedef NumArrayDataT<DataType,RankValue> ThatClass;
102 typedef INumArrayDataT<DataType,RankValue> DataInterfaceType;
103 using ExtentType = typename MDDimType<RankValue>::DimType;
104
105 public:
106
107 class Internal
108 : public IDataInternal
109 {
110 public:
111
112 void computeHash(DataHashInfo&) override
113 {
114 ARCANE_THROW(NotImplementedException,"computeHash");
115 }
116 };
117
118 public:
119
120 explicit NumArrayDataT(ITraceMng* trace);
121 explicit NumArrayDataT(const DataStorageBuildInfo& dsbi);
122 NumArrayDataT(const NumArrayDataT<DataType,RankValue>& rhs);
123 ~NumArrayDataT() override;
124
125 public:
126
127 Integer dimension() const override { return 2; }
128 Integer multiTag() const override { return 0; }
129 eDataType dataType() const override { return DataTypeTraitsT<DataType>::type(); }
130 void serialize(ISerializer* sbuf, IDataOperation* operation) override;
131 void serialize(ISerializer* sbuf, Int32ConstArrayView ids, IDataOperation* operation) override;
132 MDSpan<DataType,ExtentType> view() override { return m_value.mdspan(); }
133 MDSpan<const DataType,ExtentType> view() const override { return m_value.mdspan(); }
134 void resize(Integer new_size) override;
135 IData* clone() override { return _cloneTrue(); }
136 IData* cloneEmpty() override { return _cloneTrueEmpty(); };
137 Ref<IData> cloneRef() override { return makeRef(_cloneTrue()); }
138 Ref<IData> cloneEmptyRef() override { return makeRef(_cloneTrueEmpty()); }
139 DataStorageTypeInfo storageTypeInfo() const override;
140 Ref<DataInterfaceType> cloneTrueRef() override { auto* d = _cloneTrue(); return makeRef(d); }
141 Ref<DataInterfaceType> cloneTrueEmptyRef() override { auto* d = _cloneTrueEmpty(); return makeRef(d); }
142 void fillDefault() override;
143 void setName(const String& name) override;
144 Ref<ISerializedData> createSerializedDataRef(bool use_basic_type) const override;
145 void allocateBufferForSerializedData(ISerializedData* sdata) override;
146 void assignSerializedData(const ISerializedData* sdata) override;
147 void copy(const IData* data) override;
148 void swapValues(IData* data) override;
149 void computeHash(IHashAlgorithm* algo, ByteArray& output) const override;
150 ArrayShape shape() const override { return m_shape; }
151 void setShape(const ArrayShape& new_shape) override { m_shape = new_shape; }
152 void setAllocationInfo(const DataAllocationInfo& v) override { m_allocation_info = v; }
153 DataAllocationInfo allocationInfo() const override { return m_allocation_info; }
154 void visit(IArray2DataVisitor*)
155 {
156 ARCANE_THROW(NotSupportedException, "Can not visit array2 data with NumArray data");
157 }
158 void visit(IDataVisitor* visitor) override
159 {
160 ARCANE_UNUSED(visitor);
161 ARCANE_THROW(NotImplementedException,"visit(IDataVisitor*)");
162 }
163 void visitScalar(IScalarDataVisitor*) override
164 {
165 ARCANE_THROW(NotSupportedException, "Can not visit scalar data with NumArray data");
166 }
167 void visitArray(IArrayDataVisitor*) override
168 {
169 ARCANE_THROW(NotSupportedException, "Can not visit array data with NumArray data");
170 }
171 void visitArray2(IArray2DataVisitor*) override
172 {
173 ARCANE_THROW(NotSupportedException, "Can not visit array2 data with NumArray data");
174 }
175 IDataInternal* _commonInternal() override { return &m_internal; }
176
177 public:
178
179 void swapValuesDirect(ThatClass* true_data);
180
181 public:
182
183 static DataStorageTypeInfo staticStorageTypeInfo();
184
185 private:
186
187 NumArray<DataType,ExtentType> m_value;
188 ITraceMng* m_trace;
189 ArrayShape m_shape;
190 Internal m_internal;
191 DataAllocationInfo m_allocation_info;
192
193 private:
194
195 INumArrayDataT<DataType,RankValue>* _cloneTrue() const { return new ThatClass(*this); }
196 INumArrayDataT<DataType,RankValue>* _cloneTrueEmpty() const { return new ThatClass(m_trace); }
197 void _resizeDim1(Int32 dim1_size);
198 Int64 _getDim2Size() const;
199 Span2<DataType> _valueAsSpan2();
200 Span2<const DataType> _valueAsConstSpan2();
201};
202
203/*---------------------------------------------------------------------------*/
204/*---------------------------------------------------------------------------*/
205
206template<typename DataType,int RankValue> NumArrayDataT<DataType,RankValue>::
207NumArrayDataT(ITraceMng* trace)
208: m_trace(trace)
209{
210}
211
212/*---------------------------------------------------------------------------*/
213/*---------------------------------------------------------------------------*/
214
215template<typename DataType,int RankValue> NumArrayDataT<DataType,RankValue>::
216NumArrayDataT(const NumArrayDataT<DataType,RankValue>& rhs)
217: m_value(rhs.m_value)
218, m_trace(rhs.m_trace)
219, m_allocation_info(rhs.m_allocation_info)
220{
221}
222
223/*---------------------------------------------------------------------------*/
224/*---------------------------------------------------------------------------*/
225
226template<typename DataType,int RankValue> NumArrayDataT<DataType,RankValue>::
227NumArrayDataT(const DataStorageBuildInfo& dsbi)
228: m_trace(dsbi.traceMng())
229{
230}
231
232/*---------------------------------------------------------------------------*/
233/*---------------------------------------------------------------------------*/
234
235template<typename DataType,int RankValue> NumArrayDataT<DataType,RankValue>::
236~NumArrayDataT()
237{
238}
239
240/*---------------------------------------------------------------------------*/
241/*---------------------------------------------------------------------------*/
242
243/*---------------------------------------------------------------------------*/
244/*---------------------------------------------------------------------------*/
245
246template<typename DataType,int RankValue> DataStorageTypeInfo NumArrayDataT<DataType,RankValue>::
247staticStorageTypeInfo()
248{
249 typedef DataTypeTraitsT<DataType> TraitsType;
250 eBasicDataType bdt = TraitsType::basicDataType();
251 Int32 nb_basic_type = TraitsType::nbBasicType();
252 Int32 dimension = RankValue;
253 Int32 multi_tag = 0;
254 String impl_name = "NumArray";
255 return DataStorageTypeInfo(bdt,nb_basic_type,dimension,multi_tag,impl_name);
256}
257
258/*---------------------------------------------------------------------------*/
259/*---------------------------------------------------------------------------*/
260
261template<typename DataType,int RankValue> DataStorageTypeInfo NumArrayDataT<DataType,RankValue>::
262storageTypeInfo() const
263{
264 return staticStorageTypeInfo();
265}
266
267/*---------------------------------------------------------------------------*/
268/*---------------------------------------------------------------------------*/
269
270template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
271_resizeDim1(Int32 dim1_size)
272{
273 // Récupère les dimensions du 'NumArray' et ne modifie que la première
274 auto extents = m_value.extents();
275 extents.setExtent0(dim1_size);
276 m_value.resize(extents.dynamicExtents());
277}
278
279/*---------------------------------------------------------------------------*/
280/*---------------------------------------------------------------------------*/
281
282template<typename DataType,int RankValue> Int64
283NumArrayDataT<DataType,RankValue>::
284_getDim2Size() const
285{
286 // Récupère les dimensions du 'NumArray' et considère que 'dim2_size' est
287 // le produits du nombre d'éléments des dimensions après la première.
288 auto extents = m_value.extents();
289 auto std_extents = extents.asStdArray();
290 Int64 dim2_size = 1;
291 for( Integer i=0; i<RankValue; ++i )
292 dim2_size *= std_extents[i];
293 return dim2_size;
294}
295
296/*---------------------------------------------------------------------------*/
297/*---------------------------------------------------------------------------*/
298
299// ATTENTION: Ne fonctionnera pas s'il y a des 'strides'
300template<typename DataType,int RankValue> Span2<DataType>
301NumArrayDataT<DataType,RankValue>::
302_valueAsSpan2()
303{
304 Int64 dim1_size = m_value.dim1Size();
305 Int64 dim2_size = _getDim2Size();
306 Span2<DataType> value_as_span2(m_value.to1DSpan().data(),dim1_size,dim2_size);
307 return value_as_span2;
308}
309
310/*---------------------------------------------------------------------------*/
311/*---------------------------------------------------------------------------*/
312
313// ATTENTION: Ne fonctionnera pas s'il y a des 'strides'
314// TODO: a supprimer mais pour cela il faut pouvoir convertir un Span<T> en
315// un Span<const T> et cela n'est pas encore possible avec arccore.
316template<typename DataType,int RankValue> Span2<const DataType>
317NumArrayDataT<DataType,RankValue>::
318_valueAsConstSpan2()
319{
320 Int64 dim1_size = m_value.dim1Size();
321 Int64 dim2_size = _getDim2Size();
322 Span2<const DataType> value_as_span2(m_value.to1DSpan().data(),dim1_size,dim2_size);
323 return value_as_span2;
324}
325
326/*---------------------------------------------------------------------------*/
327/*---------------------------------------------------------------------------*/
328
329template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
330resize(Integer new_size)
331{
332 _resizeDim1(new_size);
333}
334
335/*---------------------------------------------------------------------------*/
336/*---------------------------------------------------------------------------*/
337
338template<typename DataType,int RankValue> Ref<ISerializedData>
339NumArrayDataT<DataType,RankValue>::
340createSerializedDataRef(bool use_basic_type) const
341{
342 using BasicType = typename DataTypeTraitsT<DataType>::BasicType;
343
344 Int64 nb_count = 1;
345 eDataType data_type = dataType();
346 Int64 type_size = sizeof(DataType);
347
348 if (use_basic_type){
349 nb_count = 1; //DataTypeTraitsT<DataType>::nbBasicType();
350 data_type = DataTypeTraitsT<BasicType>::type();
351 type_size = sizeof(BasicType);
352 }
353
354 Int64 nb_element = m_value.totalNbElement();
355 Int64 nb_base_element = nb_element * nb_count;
356 Int64 full_size = nb_base_element * type_size;
357 const Byte* bt = reinterpret_cast<const Byte*>(m_value.to1DSpan().data());
358 Span<const Byte> base_values(bt,full_size);
359 auto extents = m_value.extents();
360 auto std_extents = extents.asStdArray();
361 const Int32 nb_extent = CheckedConvert::toInt32(std_extents.size());
362 UniqueArray<Int64> dimensions(nb_extent);
363 for ( Int32 i=0; i<nb_extent; ++i )
364 dimensions[i] = std_extents[i];
365 auto sd = arcaneCreateSerializedDataRef(data_type,base_values.size(),RankValue,nb_element,
366 nb_base_element,false,dimensions,shape());
367 sd->setConstBytes(base_values);
368 return sd;
369}
370
371/*---------------------------------------------------------------------------*/
372/*---------------------------------------------------------------------------*/
373
374template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
375allocateBufferForSerializedData(ISerializedData* sdata)
376{
377 using BasicType = typename DataTypeTraitsT<DataType>::BasicType;
378
379 eDataType data_type = sdata->baseDataType();
380 eDataType base_data_type = DataTypeTraitsT<BasicType>::type();
381
382 if (data_type!=dataType() && data_type==base_data_type)
383 ARCANE_FATAL("Bad serialized type");
384
385 bool is_multi_size = sdata->isMultiSize();
386 if (is_multi_size)
387 ARCANE_FATAL("Can not allocate multi-size array");
388
389 // Converti en Int32
390 Int64ConstArrayView sdata_extents = sdata->extents();
391 std::array<Int32,RankValue> numarray_extents;
392 for( Int32 i=0; i<RankValue; ++i )
393 numarray_extents[i] = CheckedConvert::toInt32(sdata_extents[i]);
394 auto extents = ArrayExtents<ExtentType>::fromSpan(numarray_extents);
395 m_value.resize(extents.dynamicExtents());
396
397 Byte* byte_data = reinterpret_cast<Byte*>(m_value.to1DSpan().data());
398 Span<Byte> bytes_view(byte_data,sdata->memorySize());
399 sdata->setWritableBytes(bytes_view);
400}
401
402/*---------------------------------------------------------------------------*/
403/*---------------------------------------------------------------------------*/
404
405template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
406assignSerializedData(const ISerializedData* sdata)
407{
408 ARCANE_UNUSED(sdata);
409 // Rien à faire car \a sdata pointe directement vers m_value
410}
411
412/*---------------------------------------------------------------------------*/
413/*---------------------------------------------------------------------------*/
414
415template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
416serialize(ISerializer* sbuf,IDataOperation* operation)
417{
418 // NOTE: Cette méthode n'est pas encore opérationnelle
419
420 Integer nb_count = 1; //DataTypeTraitsT<DataType>::nbBasicType();
421 typedef typename DataTypeTraitsT<DataType>::BasicType BasicType;
422 //eDataType data_type = DataTypeTraitsT<BasicType>::type();
423
424 ISerializer::eMode mode = sbuf->mode();
425 if (mode==ISerializer::ModeReserve){
426 // Réserve la mémoire pour
427 // - le nombre magique pour verification
428 // - le nombre d'éléments de ids.
429 sbuf->reserveSpan(DT_Int64,2);
430 // Réserve la mémoire pour le nombre d'éléments de chaque dimension (soit RankValue)
431 sbuf->reserveSpan(DT_Int32,RankValue);
432 // Réserve la mémoire pour les valeurs
433 sbuf->reserveSpan(m_value.to1DSpan());
434 }
435 else if (mode==ISerializer::ModePut){
436 Int64 total = m_value.totalNbElement();
437 Int64 n[2];
438 n[0] = SERIALIZE2_MAGIC_NUMBER;
439 n[1] = total;
440 sbuf->putSpan(Span<const Int64>(n,2));
441 {
442 auto ext = m_value.extents().asStdArray();
443 sbuf->putSpan(Span<const Int32>(ext));
444 }
445 sbuf->putSpan(m_value.to1DSpan());
446 }
447 else if (mode==ISerializer::ModeGet){
448 Int64 n[2] = { 0, 0 };
449 sbuf->getSpan(Span<Int64>(n,2));
450 Int64 total = n[1];
451 if (n[0]!=SERIALIZE2_MAGIC_NUMBER)
452 ARCANE_FATAL("Bad magic number");
453 Int32 extents_buf[RankValue];
454 SmallSpan<Int32> extents_span(extents_buf,RankValue);
455 sbuf->getSpan(extents_span);
456 Int32 count = extents_span[0];
457 switch(sbuf->readMode()){
458 case ISerializer::ReadReplace:
459 {
460 //m_trace->info() << "READ REPLACE count=" << count << " dim2_size=" << dim2_size;
461 m_value.resize(ArrayExtents<ExtentType>::fromSpan(extents_span).dynamicExtents());
462 if (operation)
463 ARCANE_THROW(NotImplementedException,"serialize(ReadReplace) with IDataOperation");
464 BasicType* bt = reinterpret_cast<BasicType*>(m_value.to1DSpan().data());
465 Span<BasicType> v(bt,total*nb_count);
466 sbuf->getSpan(v);
467 }
468 break;
469 case ISerializer::ReadAdd:
470 {
471 Int32 current_size = m_value.dim1Size();
472 // TODO: vérifier que dim2_size a la même valeur qu'en entrée.
473 // Int64 dim2_size = _getDim2Size();
474 Int64 current_total = m_value.totalNbElement();
475 //m_trace->info() << "READ ADD NEW_SIZE=" << current_size << " COUNT=" << count
476 // << " dim2_size=" << dim2_size << " current_dim2_size=" << m_value.dim2Size()
477 // << " current_total=" << current_total << " read_elem=" << (total*nb_count);
478 _resizeDim1(current_size + count);
479 if (operation)
480 throw NotImplementedException(A_FUNCINFO,"serialize(ReadAdd) with IDataOperation");
481 BasicType* bt = reinterpret_cast<BasicType*>(m_value.to1DSpan().data()+current_total);
482 //m_trace->info() << "GET array nb_elem=" << (total*nb_count) << " sizeof=" << sizeof(BasicType);
483 Span<BasicType> v(bt,total*nb_count);
484 sbuf->getSpan(v);
485 }
486 break;
487 }
488 }
489}
490
491/*---------------------------------------------------------------------------*/
492/*---------------------------------------------------------------------------*/
493
494template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
495serialize(ISerializer* sbuf,Int32ConstArrayView ids,IDataOperation* operation)
496{
497 ARCANE_UNUSED(operation);
498 // TODO: mutualiser avec serialize(sbuf,ids);
499
500 [[maybe_unused]] Integer nb_count = 1;
501 typedef typename DataTypeTraitsT<DataType>::BasicType BasicType;
502 eDataType data_type = DataTypeTraitsT<BasicType>::type();
503 ISerializer::eMode mode = sbuf->mode();
504 if (mode==ISerializer::ModeReserve){
505 // Réserve la mémoire pour
506 // - le nombre magique pour verification
507 // - le nombre d'éléments de ids.
508 // -
509 sbuf->reserveSpan(DT_Int64,3);
510 // Réserve la mémoire pour le nombre d'éléments de chaque dimension (soit RankValue)
511 sbuf->reserveSpan(DT_Int32,RankValue);
512 // Réserve la mémoire pour les valeurs
513 auto sub_extent = m_value.extents().removeFirstExtent();
514 sbuf->reserveSpan(data_type,sub_extent.totalNbElement() * ids.size());
515 }
516 else if (mode==ISerializer::ModePut){
517 Int32 count = ids.size();
518 Int64 dim2_size = _getDim2Size();
519 Int64 total_nb_value = count * dim2_size;
520 Int64 total = total_nb_value;
521
522 Int64 n[3];
523 n[0] = SERIALIZE2_MAGIC_NUMBER;
524 n[1] = count;
525 n[2] = dim2_size;
526 /*m_trace->info() << "PUT COUNT = " << count << " total=" << total
527 << " dim1 (n[0])=" << n[0]
528 << " dim2 (n[1])=" << n[1]
529 << " count (n[2])=" << n[2]
530 << " magic=" << n[3]
531 << " this=" << this;*/
532 sbuf->putSpan(Span<const Int64>(n,3));
533
534 {
535 auto ext = m_value.extents().asStdArray();
536 sbuf->putSpan(Span<const Int32>(ext));
537 }
538
539 UniqueArray<BasicType> v(total*nb_count);
540 Span2<const DataType> value_as_span2(_valueAsConstSpan2());
541 {
542 Integer index = 0;
543 for( Int32 i=0, n=count; i<n; ++i ){
544 const BasicType* sub_a = reinterpret_cast<const BasicType*>(value_as_span2[ids[i]].data());
545 for( Int64 z=0, iz=dim2_size*nb_count; z<iz; ++z ){
546 v[index] = sub_a[z];
547 ++index;
548 }
549 }
550 }
551
552 sbuf->putSpan(v);
553 }
554 else if (mode==ISerializer::ModeGet){
555 switch(sbuf->readMode()){
556 case ISerializer::ReadReplace:
557 {
558 Int64 n[3] = { 0, 0, 0 };
559 sbuf->getSpan(Span<Int64>(n,3));
560 Int32 count = CheckedConvert::toInt32(n[1]);
561 Int64 dim2_size = n[2];
562 Int64 total = count * dim2_size;
563 // One dim
564 /*m_trace->info() << "COUNT = " << count << " total=" << total
565 << " dim1 (n[0])=" << n[0]
566 << " dim1 current=" << m_value.dim1Size()
567 << " dim2 (n[1])=" << n[1]
568 << " dim2 current=" << m_value.dim2Size()
569 << " count (n[2])=" << n[2]
570 << " magic=" << n[3]
571 << " this=" << this;*/
572 if (n[1]!=SERIALIZE2_MAGIC_NUMBER)
573 ARCANE_FATAL("Bad magic number");
574
575 Int32 extents_buf[RankValue];
576 Span<Int32> extents_span(extents_buf,RankValue);
577 sbuf->getSpan(extents_span);
578
579 // TODO: utiliser extent pour vérifier que le tableau recu à le
580 // même nombre d'éléments dans les dimensions 2+.
581 Int64 current_dim2_size = _getDim2Size();
582
583 if (dim2_size!=current_dim2_size){
584 if (current_dim2_size!=0 && dim2_size!=0)
585 ARCANE_FATAL("serialized data should have the same dim2Size current={0} found={1}",
586 current_dim2_size,dim2_size);
587 else
588 _resizeDim1(m_value.dim1Size());
589 }
590 Int64 nb_value = count;
591 //Array<BasicType> v(total*nb_count);
592 UniqueArray<BasicType> base_value(total*nb_count);
593
594 sbuf->getSpan(base_value);
595
596 Span<DataType> data_value(reinterpret_cast<DataType*>(base_value.data()),nb_value*dim2_size);
597 UniqueArray<DataType> current_value;
598 Span<DataType> transformed_value;
599
600 Span2<DataType> value_as_span2(_valueAsSpan2());
601 // Si on applique une transformantion, effectue la transformation dans un
602 // tableau temporaire 'current_value'.
603 if (operation && nb_value!=0) {
604 current_value.resize(data_value.size());
605
606 Int64 index = 0;
607 for( Int32 i=0, n=count; i<n; ++i ){
608 Span<const DataType> a(value_as_span2[ids[i]]);
609 for( Int64 z=0, iz=dim2_size; z<iz; ++z ){
610 current_value[index] = a[z];
611 ++index;
612 }
613 }
614
615 transformed_value = current_value.view();
616 operation->applySpan(transformed_value,data_value);
617 }
618 else {
619 transformed_value = data_value;
620 }
621
622 {
623 Int64 index = 0;
624 for( Int32 i=0, n=count; i<n; ++i ){
625 Span<DataType> a(value_as_span2[ids[i]]);
626 for( Int64 z=0, iz=dim2_size; z<iz; ++z ){
627 a[z] = transformed_value[index];
628 ++index;
629 }
630 }
631 }
632 }
633 break;
634 case ISerializer::ReadAdd:
635 ARCANE_THROW(NotImplementedException,"option 'ReadAdd'");
636 break;
637 }
638 }
639}
640
641/*---------------------------------------------------------------------------*/
642/*---------------------------------------------------------------------------*/
643
644template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
645fillDefault()
646{
647 m_value.fill(DataType());
648}
649
650/*---------------------------------------------------------------------------*/
651/*---------------------------------------------------------------------------*/
652
653template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
654setName(const String& name)
655{
656 ARCANE_UNUSED(name);
657}
658
659/*---------------------------------------------------------------------------*/
660/*---------------------------------------------------------------------------*/
661
662template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
663computeHash(IHashAlgorithm* algo,ByteArray& output) const
664{
665 // Calcule la fonction de hashage pour les valeurs
666 {
667 Span<const DataType> values = m_value.to1DSpan();
668 Int64 type_size = sizeof(DataType);
669 Int64 nb_element = values.size();
670 const Byte* ptr = reinterpret_cast<const Byte*>(values.data());
671 Span<const Byte> input(ptr,type_size*nb_element);
672 algo->computeHash64(input,output);
673 }
674
675 {
676 // Calcule la fonction de hashage pour les nombres d'éléments
677 auto ext = m_value.extents().asStdArray();
678 auto input = asBytes(Span<const Int32>(ext));
679 algo->computeHash64(input,output);
680 }
681}
682
683/*---------------------------------------------------------------------------*/
684/*---------------------------------------------------------------------------*/
685
686template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
687copy(const IData* data)
688{
689 auto* true_data = dynamic_cast< const DataInterfaceType* >(data);
690 if (!true_data)
691 throw ArgumentException(A_FUNCINFO,"Can not cast 'IData' to 'INumArrayDataT'");
692 m_value.copy(true_data->view());
693}
694
695/*---------------------------------------------------------------------------*/
696/*---------------------------------------------------------------------------*/
697
698template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
699swapValues(IData* data)
700{
701 auto* true_data = dynamic_cast<ThatClass*>(data);
702 if (!true_data)
703 throw ArgumentException(A_FUNCINFO,"Can not cast 'IData' to 'NumArrayDataT'");
704 swapValuesDirect(true_data);
705}
706
707/*---------------------------------------------------------------------------*/
708/*---------------------------------------------------------------------------*/
709
710template<typename DataType,int RankValue> void NumArrayDataT<DataType,RankValue>::
711swapValuesDirect(ThatClass* true_data)
712{
713 m_value.swap(true_data->m_value);
714}
715
716/*---------------------------------------------------------------------------*/
717/*---------------------------------------------------------------------------*/
718
719extern "C++" void
720registerNumArrayDataFactory(IDataFactoryMng* dfm)
721{
722 DataStorageFactory<NumArrayDataT<Real,1>>::registerDataFactory(dfm);
723 //DataStorageFactory<NumArrayDataT<Int16,1>>::registerDataFactory(dfm);
724 //DataStorageFactory<NumArrayDataT<Int32,1>>::registerDataFactory(dfm);
725 DataStorageFactory<NumArrayDataT<Int64,1>>::registerDataFactory(dfm);
726
727 DataStorageFactory<NumArrayDataT<Real,2>>::registerDataFactory(dfm);
728 //DataStorageFactory<NumArrayDataT<Int16,2>>::registerDataFactory(dfm);
729 //DataStorageFactory<NumArrayDataT<Int32,2>>::registerDataFactory(dfm);
730 DataStorageFactory<NumArrayDataT<Int64,2>>::registerDataFactory(dfm);
731
732 DataStorageFactory<NumArrayDataT<Real,3>>::registerDataFactory(dfm);
733 //DataStorageFactory<NumArrayDataT<Int16,2>>::registerDataFactory(dfm);
734 //DataStorageFactory<NumArrayDataT<Int32,2>>::registerDataFactory(dfm);
735 DataStorageFactory<NumArrayDataT<Int64,3>>::registerDataFactory(dfm);
736
737 DataStorageFactory<NumArrayDataT<Real,4>>::registerDataFactory(dfm);
738 //DataStorageFactory<NumArrayDataT<Int16,2>>::registerDataFactory(dfm);
739 //DataStorageFactory<NumArrayDataT<Int32,2>>::registerDataFactory(dfm);
740 DataStorageFactory<NumArrayDataT<Int64,4>>::registerDataFactory(dfm);
741}
742
743/*---------------------------------------------------------------------------*/
744/*---------------------------------------------------------------------------*/
745
746} // End namespace Arcane
747
748/*---------------------------------------------------------------------------*/
749/*---------------------------------------------------------------------------*/
ARCANE_THROW
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
Definition ArcaneGlobal.h:798
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:809
Ref.h
Gestion des références à une classe C++.
Arcane::ArrayShape
Forme d'un tableau.
Definition ArrayShape.h:40
Arcane::Array
Tableau d'items de types quelconques.
Definition AnyItemArray.h:55
Arcane::DataAllocationInfo
Informations sur l'allocation d'une donnée.
Definition DataAllocationInfo.h:31
Arcane::DataHashInfo
Informations pour le calcul du hash d'une donnée.
Definition IDataInternal.h:51
Arcane::DataStorageBuildInfo
Informations pour construire une instance de 'IData'.
Definition DataStorageBuildInfo.h:31
Arcane::DataStorageTypeInfo
Informations de type pour un conteneur de données.
Definition DataStorageTypeInfo.h:33
Arcane::IArray2DataVisitor
Interface du pattern visitor pour une donnée tableau 2D.
Definition IDataVisitor.h:113
Arcane::IArrayDataVisitor
Interface du pattern visitor pour une donnée tableau.
Definition IDataVisitor.h:88
Arcane::IDataInternal
Partie interne de IData.
Definition IDataInternal.h:77
Arcane::IDataOperation
Interface d'une opération sur une donnée.
Definition IDataOperation.h:37
Arcane::IDataVisitor
Interface du pattern visitor pour une donnée.
Definition IDataVisitor.h:43
Arcane::IData
Interface d'une donnée.
Definition IData.h:33
Arcane::IHashAlgorithm
Interface d'un algorithme de hashage.
Definition IHashAlgorithm.h:106
Arcane::INumArrayDataT
Interface d'un 'IData' dont le conteneur repose sur un 'NumArray'.
Definition NumArrayData.cc:64
Arcane::INumArrayDataT::cloneTrueEmptyRef
virtual Ref< ThatClass > cloneTrueEmptyRef()=0
Clone la donnée mais sans éléments.
Arcane::INumArrayDataT::view
virtual MDSpan< const DataType, ExtentType > view() const =0
Vue constante sur la donnée.
Arcane::INumArrayDataT::view
virtual MDSpan< DataType, ExtentType > view()=0
Vue sur la donnée.
Arcane::INumArrayDataT::cloneTrueRef
virtual Ref< ThatClass > cloneTrueRef()=0
Clone la donnée.
Arcane::IScalarDataVisitor
Interface du pattern visitor pour une donnée scalaire.
Definition IDataVisitor.h:63
Arcane::ISerializedData
Interface d'une donnée sérialisée.
Definition ISerializedData.h:62
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:120
Arcane::NumArrayDataT::Internal::computeHash
void computeHash(DataHashInfo &) override
Calcule le hash de la donnée.
Definition NumArrayData.cc:112
Arcane::NumArrayDataT
Implémentation d'un 'IData' dont le conteneur repose sur un 'NumArray'.
Definition NumArrayData.cc:94
Arcane::NumArrayDataT::setShape
void setShape(const ArrayShape &new_shape) override
Positionne la forme du tableau.
Definition NumArrayData.cc:151
Arcane::NumArrayDataT::copy
void copy(const IData *data) override
Copie la donnée data dans l'instance courante.
Definition NumArrayData.cc:687
Arcane::NumArrayDataT::createSerializedDataRef
Ref< ISerializedData > createSerializedDataRef(bool use_basic_type) const override
Sérialise la donnée.
Definition NumArrayData.cc:340
Arcane::NumArrayDataT::dimension
Integer dimension() const override
Dimension. 0 pour un scalaire, 1 pour un tableau mono-dim, 2 pour un tableau bi-dim.
Definition NumArrayData.cc:127
Arcane::NumArrayDataT::multiTag
Integer multiTag() const override
Tag multiple. 0 si non multiple, 1 si multiple, 2 si multiple pour les variable MultiArray (obsolète)
Definition NumArrayData.cc:128
Arcane::NumArrayDataT::m_value
NumArray< DataType, ExtentType > m_value
Donnée.
Definition NumArrayData.cc:187
Arcane::NumArrayDataT::cloneEmptyRef
Ref< IData > cloneEmptyRef() override
Clone la donnée mais sans éléments.
Definition NumArrayData.cc:138
Arcane::NumArrayDataT::clone
IData * clone() override
Clone la donnée. L'instance créée doit être détruite par l'opérateur 'delete'.
Definition NumArrayData.cc:135
Arcane::NumArrayDataT::visitArray
void visitArray(IArrayDataVisitor *) override
Applique le visiteur à la donnée.
Definition NumArrayData.cc:167
Arcane::NumArrayDataT::cloneTrueRef
Ref< DataInterfaceType > cloneTrueRef() override
Clone la donnée.
Definition NumArrayData.cc:140
Arcane::NumArrayDataT::cloneTrueEmptyRef
Ref< DataInterfaceType > cloneTrueEmptyRef() override
Clone la donnée mais sans éléments.
Definition NumArrayData.cc:141
Arcane::NumArrayDataT::swapValues
void swapValues(IData *data) override
Échange les valeurs de data avec celles de l'instance.
Definition NumArrayData.cc:699
Arcane::NumArrayDataT::serialize
void serialize(ISerializer *sbuf, IDataOperation *operation) override
Sérialise la donnée en appliquant l'opération operation.
Definition NumArrayData.cc:416
Arcane::NumArrayDataT::_commonInternal
IDataInternal * _commonInternal() override
Definition NumArrayData.cc:175
Arcane::NumArrayDataT::cloneRef
Ref< IData > cloneRef() override
Clone la donnée.
Definition NumArrayData.cc:137
Arcane::NumArrayDataT::fillDefault
void fillDefault() override
Remplit la donnée avec sa valeur par défaut.
Definition NumArrayData.cc:645
Arcane::NumArrayDataT::view
MDSpan< DataType, ExtentType > view() override
Vue sur la donnée.
Definition NumArrayData.cc:132
Arcane::NumArrayDataT::assignSerializedData
void assignSerializedData(const ISerializedData *sdata) override
Assigne à la donnée les valeurs sérialisées sdata.
Definition NumArrayData.cc:406
Arcane::NumArrayDataT::cloneEmpty
IData * cloneEmpty() override
Clone la donnée mais sans éléments. L'instance créée doit être détruite par l'opérateur 'delete'.
Definition NumArrayData.cc:136
Arcane::NumArrayDataT::dataType
eDataType dataType() const override
Type de la donnée.
Definition NumArrayData.cc:129
Arcane::NumArrayDataT::view
MDSpan< const DataType, ExtentType > view() const override
Vue constante sur la donnée.
Definition NumArrayData.cc:133
Arcane::NumArrayDataT::shape
ArrayShape shape() const override
Forme du tableau pour une donnée 1D ou 2D.
Definition NumArrayData.cc:150
Arcane::NumArrayDataT::resize
void resize(Integer new_size) override
Redimensionne la donnée.
Definition NumArrayData.cc:330
Arcane::NumArrayDataT::allocateBufferForSerializedData
void allocateBufferForSerializedData(ISerializedData *sdata) override
Alloue la mémoire pour lire les valeurs sérialisées sdata.
Definition NumArrayData.cc:375
Arcane::NumArrayDataT::computeHash
void computeHash(IHashAlgorithm *algo, ByteArray &output) const override
Calcul une clé de hashage sur cette donnée.
Definition NumArrayData.cc:663
Arcane::NumArrayDataT::setAllocationInfo
void setAllocationInfo(const DataAllocationInfo &v) override
Positionne les informations sur l'allocation.
Definition NumArrayData.cc:152
Arcane::NumArrayDataT::setName
void setName(const String &name) override
Positionne le nom de la donnée (interne)
Definition NumArrayData.cc:654
Arcane::NumArrayDataT::visitArray2
void visitArray2(IArray2DataVisitor *) override
Applique le visiteur à la donnée.
Definition NumArrayData.cc:171
Arcane::NumArrayDataT::visitScalar
void visitScalar(IScalarDataVisitor *) override
Applique le visiteur à la donnée.
Definition NumArrayData.cc:163
Arcane::NumArrayDataT::allocationInfo
DataAllocationInfo allocationInfo() const override
Informations sur l'allocation.
Definition NumArrayData.cc:153
Arcane::NumArrayDataT::storageTypeInfo
DataStorageTypeInfo storageTypeInfo() const override
Informations sur le type de conteneur de la donnée.
Definition NumArrayData.cc:262
Arcane::NumArrayDataT::visit
void visit(IDataVisitor *visitor) override
Applique le visiteur à la donnée.
Definition NumArrayData.cc:158
Arcane::NumArray::mdspan
MDSpanType mdspan()
Vue multi-dimension sur l'instance.
Definition utils/NumArray.h:503
Arccore::ArgumentException
Exception lorsqu'un argument est invalide.
Definition arccore/src/base/arccore/base/ArgumentException.h:33
Arccore::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arccore::ISerializer::ReadAdd
@ ReadAdd
Ajoute aux éléments actuels ceux lus.
Definition arccore/src/serialize/arccore/serialize/ISerializer.h:71
Arccore::ISerializer::ReadReplace
@ ReadReplace
Replace les éléments actuels par ceux lus.
Definition arccore/src/serialize/arccore/serialize/ISerializer.h:70
Arccore::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arccore::NotImplementedException
Exception lorsqu'une fonction n'est pas implémentée.
Definition arccore/src/base/arccore/base/NotImplementedException.h:33
Arccore::NotSupportedException
Exception lorsqu'une opération n'est pas supportée.
Definition arccore/src/base/arccore/base/NotSupportedException.h:33
Arccore::ReferenceCounterImpl
Implémentation thread-safe d'un compteur de référence.
Definition ReferenceCounterImpl.h:80
Arccore::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::CheckedConvert::toInt32
Int32 toInt32(Int64 v)
Converti un Int64 en un Int32.
Definition CheckedConvert.h:99
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::arcaneCreateSerializedDataRef
Ref< ISerializedData > arcaneCreateSerializedDataRef(eDataType data_type, Int64 memory_size, Integer nb_dim, Int64 nb_element, Int64 nb_base_element, bool is_multi_size, Int64ConstArrayView dimensions)
Créé des données sérialisées.
Definition SerializedData.cc:413
Arcane::eDataType
eDataType
Type d'une donnée.
Definition DataTypes.h:39
Arcane::DT_Int32
@ DT_Int32
Donnée de type entier 32 bits.
Definition DataTypes.h:43
Arcane::DT_Int64
@ DT_Int64
Donnée de type entier 64 bits.
Definition DataTypes.h:44
Arccore::eBasicDataType
eBasicDataType
Type d'une donnée de base.
Definition arccore/src/base/arccore/base/BasicDataType.h:37