Arcane  v4.1.5.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
Array2Data.inst.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2026 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/* Array2Data.inst.h (C) 2000-2026 */
9/* */
10/* Donnée du type 'Array2'. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/impl/internal/Array2Data.h"
15
16#include "arcane/utils/NotSupportedException.h"
17#include "arcane/utils/Real2.h"
18#include "arcane/utils/Real2x2.h"
19#include "arcane/utils/Real3.h"
20#include "arcane/utils/Real3x3.h"
21#include "arcane/utils/IHashAlgorithm.h"
22#include "arcane/utils/NotImplementedException.h"
23#include "arcane/utils/ArgumentException.h"
24#include "arcane/utils/FatalErrorException.h"
25#include "arcane/utils/ITraceMng.h"
26#include "arcane/utils/CheckedConvert.h"
27#include "arcane/utils/MemoryAllocator.h"
28#include "arcane/utils/MemoryUtils.h"
29
30#include "arcane/core/datatype/DataStorageBuildInfo.h"
31#include "arcane/core/datatype/IDataOperation.h"
32
33#include "arcane/core/ISerializer.h"
34
35#include "arcane/impl/SerializedData.h"
36
37/*---------------------------------------------------------------------------*/
38/*---------------------------------------------------------------------------*/
39
40namespace Arcane
41{
42
43/*---------------------------------------------------------------------------*/
44/*---------------------------------------------------------------------------*/
45
46namespace
47{
48inline constexpr Int64 SERIALIZE2_MAGIC_NUMBER = 0x12ff7789;
49}
50
51/*---------------------------------------------------------------------------*/
52/*---------------------------------------------------------------------------*/
53
54template<typename DataType> Array2DataT<DataType>::
55Array2DataT(ITraceMng* trace)
56: m_value(AlignedMemoryAllocator::Simd())
57, m_trace(trace)
58, m_internal(new Impl(this))
59{
60}
61
62/*---------------------------------------------------------------------------*/
63/*---------------------------------------------------------------------------*/
64
65template<typename DataType> Array2DataT<DataType>::
66Array2DataT(const Array2DataT<DataType>& rhs)
67: m_value(AlignedMemoryAllocator::Simd())
68, m_trace(rhs.m_trace)
69, m_internal(new Impl(this))
70, m_allocation_info(rhs.m_allocation_info)
71{
72 m_value = rhs.m_value;
73}
74
75/*---------------------------------------------------------------------------*/
76/*---------------------------------------------------------------------------*/
77
78template<typename DataType> Array2DataT<DataType>::
79Array2DataT(const DataStorageBuildInfo& dsbi)
80: m_value(dsbi.memoryAllocator())
81, m_trace(dsbi.traceMng())
82, m_internal(new Impl(this))
83{
84}
85
86/*---------------------------------------------------------------------------*/
87/*---------------------------------------------------------------------------*/
88
89template<typename DataType> Array2DataT<DataType>::
90~Array2DataT()
91{
92 delete m_internal;
93}
94
95/*---------------------------------------------------------------------------*/
96/*---------------------------------------------------------------------------*/
97
98/*---------------------------------------------------------------------------*/
99/*---------------------------------------------------------------------------*/
100
101template<typename DataType> DataStorageTypeInfo Array2DataT<DataType>::
102staticStorageTypeInfo()
103{
104 typedef DataTypeTraitsT<DataType> TraitsType;
105 eBasicDataType bdt = TraitsType::basicDataType();
106 Int32 nb_basic_type = TraitsType::nbBasicType();
107 Int32 dimension = 2;
108 Int32 multi_tag = 0;
109 return DataStorageTypeInfo(bdt,nb_basic_type,dimension,multi_tag);
110}
111
112/*---------------------------------------------------------------------------*/
113/*---------------------------------------------------------------------------*/
114
115template<typename DataType> DataStorageTypeInfo Array2DataT<DataType>::
116storageTypeInfo() const
117{
118 return staticStorageTypeInfo();
119}
120
121/*---------------------------------------------------------------------------*/
122/*---------------------------------------------------------------------------*/
123
124template<typename DataType> void Array2DataT<DataType>::
125resize(Integer new_size)
126{
127 m_value.resize(new_size);
128}
129
130/*---------------------------------------------------------------------------*/
131/*---------------------------------------------------------------------------*/
132
133template<typename DataType> Ref<ISerializedData> Array2DataT<DataType>::
134createSerializedDataRef(bool use_basic_type) const
135{
136 typedef typename DataTypeTraitsT<DataType>::BasicType BasicType;
137
138 Int64 nb_count = 1;
139 eDataType data_type = dataType();
140 Int64 type_size = sizeof(DataType);
141
142 if (use_basic_type){
143 nb_count = DataTypeTraitsT<DataType>::nbBasicType();
144 data_type = DataTypeTraitsT<BasicType>::type();
145 type_size = sizeof(BasicType);
146 }
147
148 Int64 nb_element = m_value.totalNbElement();
149 Int64 nb_base_element = nb_element * nb_count;
150 Int64 full_size = nb_base_element * type_size;
151 const Byte* bt = reinterpret_cast<const Byte*>(m_value.to1DSpan().data());
152 Span<const Byte> base_values(bt,full_size);
153 UniqueArray<Int64> dimensions;
154 dimensions.resize(2);
155 dimensions[0] = m_value.dim1Size();
156 dimensions[1] = m_value.dim2Size();
157
158 auto sd = arcaneCreateSerializedDataRef(data_type,base_values.size(),2,nb_element,
159 nb_base_element,false,dimensions,shape());
160 sd->setConstBytes(base_values);
161 return sd;
162}
163
164/*---------------------------------------------------------------------------*/
165/*---------------------------------------------------------------------------*/
166
167template<typename DataType> void Array2DataT<DataType>::
168allocateBufferForSerializedData(ISerializedData* sdata)
169{
170 typedef typename DataTypeTraitsT<DataType>::BasicType BasicType;
171
172 eDataType data_type = sdata->baseDataType();
173 eDataType base_data_type = DataTypeTraitsT<BasicType>::type();
174
175 if (data_type!=dataType() && data_type==base_data_type)
176 ARCANE_FATAL("Bad serialized type");
177 bool is_multi_size = sdata->isMultiSize();
178 if (is_multi_size)
179 ARCANE_FATAL("Can not allocate multi-size array");
180
181 Int64 dim1_size = sdata->extents()[0];
182 Int64 dim2_size = sdata->extents()[1];
183 //m_trace->info() << " ASSIGN DATA dim1=" << dim1_size
184 // << " dim2=" << dim2_size
185 // << " addr=" << m_value.viewAsArray().unguardedBasePointer();
186
187 m_value.resize(dim1_size,dim2_size);
188 m_shape = sdata->shape();
189
190 Byte* byte_data = reinterpret_cast<Byte*>(m_value.to1DSpan().data());
191 Span<Byte> bytes_view(byte_data,sdata->memorySize());
192 sdata->setWritableBytes(bytes_view);
193}
194
195/*---------------------------------------------------------------------------*/
196/*---------------------------------------------------------------------------*/
197
198template<typename DataType> void Array2DataT<DataType>::
199assignSerializedData(const ISerializedData* sdata)
200{
201 ARCANE_UNUSED(sdata);
202 // Rien à faire car \a sdata pointe directement vers m_value
203}
204
205/*---------------------------------------------------------------------------*/
206/*---------------------------------------------------------------------------*/
207
208template<typename DataType> void Array2DataT<DataType>::
209serialize(ISerializer* sbuf,IDataOperation* operation)
210{
211 Integer nb_count = DataTypeTraitsT<DataType>::nbBasicType();
212 typedef typename DataTypeTraitsT<DataType>::BasicType BasicType;
213 eBasicDataType data_type = DataTypeTraitsT<BasicType>::basicDataType();
214
215 ISerializer::eMode mode = sbuf->mode();
216 if (mode==ISerializer::ModeReserve){
217 // Réserve la mémoire pour
218 // - le nombre d'éléments de la première dimension
219 // - le nombre d'éléments de la deuxième dimension
220 // - le nombre d'éléments de ids.
221 // - le nombre magique pour verification
222 sbuf->reserveSpan(eBasicDataType::Int64,4);
223 // Réserve la mémoire pour les valeurs
224 Int64 total_nb_element = m_value.totalNbElement();
225 sbuf->reserveSpan(data_type,total_nb_element*nb_count);
226 }
227 else if (mode==ISerializer::ModePut){
228 Int64 count = m_value.dim1Size();
229 Int64 total = m_value.totalNbElement();
230 Int64 n[4];
231 n[0] = count;
232 n[1] = m_value.dim2Size();
233 n[2] = total;
234 n[3] = SERIALIZE2_MAGIC_NUMBER;
235 sbuf->putSpan(Span<const Int64>(n,4));
236 BasicType* bt = reinterpret_cast<BasicType*>(m_value.to1DSpan().data());
237 Span<const BasicType> v(bt,total*nb_count);
238 //m_trace->info() << "PUT array nb_elem=" << (total*nb_count) << " sizeof=" << sizeof(BasicType);
239 sbuf->putSpan(v);
240 }
241 else if (mode==ISerializer::ModeGet){
242 Int64 n[4] = { 0, 0, 0, 0 };
243 sbuf->getSpan(Span<Int64>(n,4));
244 Int64 count = n[0];
245 Int64 dim2_size = n[1];
246 Int64 total = n[2];
247 if (n[3]!=SERIALIZE2_MAGIC_NUMBER)
248 ARCANE_FATAL("Bad magic number");
249 switch(sbuf->readMode()){
250 case ISerializer::ReadReplace:
251 {
252 //m_trace->info() << "READ REPLACE count=" << count << " dim2_size=" << dim2_size;
253 m_value.resize(count,dim2_size);
254 if (operation)
255 throw NotImplementedException(A_FUNCINFO,"serialize(ReadReplace) with IDataOperation");
256 BasicType* bt = reinterpret_cast<BasicType*>(m_value.to1DSpan().data());
257 Span<BasicType> v(bt,total*nb_count);
258 sbuf->getSpan(v);
259 }
260 break;
261 case ISerializer::ReadAdd:
262 {
263 Int64 current_size = m_value.dim1Size();
264 Int64 current_total = m_value.totalNbElement();
265 //m_trace->info() << "READ ADD NEW_SIZE=" << current_size << " COUNT=" << count
266 // << " dim2_size=" << dim2_size << " current_dim2_size=" << m_value.dim2Size()
267 // << " current_total=" << current_total << " read_elem=" << (total*nb_count);
268 m_value.resize(current_size + count,dim2_size);
269 if (operation)
270 throw NotImplementedException(A_FUNCINFO,"serialize(ReadAdd) with IDataOperation");
271 BasicType* bt = reinterpret_cast<BasicType*>(m_value.to1DSpan().data()+current_total);
272 //m_trace->info() << "GET array nb_elem=" << (total*nb_count) << " sizeof=" << sizeof(BasicType);
273 Span<BasicType> v(bt,total*nb_count);
274 sbuf->getSpan(v);
275 }
276 break;
277 }
278 }
279}
280
281/*---------------------------------------------------------------------------*/
282/*---------------------------------------------------------------------------*/
283
284template<typename DataType> void Array2DataT<DataType>::
285serialize(ISerializer* sbuf,Int32ConstArrayView ids,IDataOperation* operation)
286{
287 Integer nb_count = DataTypeTraitsT<DataType>::nbBasicType();
288 typedef typename DataTypeTraitsT<DataType>::BasicType BasicType;
289 eBasicDataType data_type = DataTypeTraitsT<BasicType>::basicDataType();
290
291 ISerializer::eMode mode = sbuf->mode();
292 if (mode==ISerializer::ModeReserve){
293 // Réserve la mémoire pour
294 // - le nombre d'éléments de la première dimension
295 // - le nombre d'éléments de la deuxième dimension
296 // - le nombre d'éléments de ids.
297 // - le nombre magique pour verification
298 sbuf->reserveSpan(eBasicDataType::Int64,4);
299 // Réserve la mémoire pour les valeurs
300 Int64 total_nb_value = ((Int64)ids.size()) * ((Int64)m_value.dim2Size());
301 sbuf->reserveSpan(data_type,total_nb_value*nb_count);
302
303 }
304 else if (mode==ISerializer::ModePut){
305 Int32 count = ids.size();
306 Int64 dim2_size = m_value.dim2Size();
307 Int64 total_nb_value = count * dim2_size;
308 Int64 total = total_nb_value;
309 Int64 n[4];
310 n[0] = m_value.dim1Size();
311 n[1] = m_value.dim2Size();
312 n[2] = count;
313 n[3] = SERIALIZE2_MAGIC_NUMBER;
314 /*m_trace->info() << "PUT COUNT = " << count << " total=" << total
315 << " dim1 (n[0])=" << n[0]
316 << " dim2 (n[1])=" << n[1]
317 << " count (n[2])=" << n[2]
318 << " magic=" << n[3]
319 << " this=" << this;*/
320 sbuf->putSpan(Span<const Int64>(n,4));
321 UniqueArray<BasicType> v(total*nb_count);
322 {
323 Integer index = 0;
324 for( Int32 i=0, is=count; i<is; ++i ){
325 const BasicType* sub_a = reinterpret_cast<const BasicType*>(m_value[ids[i]].data());
326 for( Int64 z=0, iz=dim2_size*nb_count; z<iz; ++z ){
327 v[index] = sub_a[z];
328 ++index;
329 }
330 }
331 }
332 sbuf->putSpan(v);
333 }
334 else if (mode==ISerializer::ModeGet){
335 switch(sbuf->readMode()){
336 case ISerializer::ReadReplace:
337 {
338 Int64 n[4] = { 0, 0, 0, 0 };
339 sbuf->getSpan(Span<Int64>(n,4));
340 //Integer dim1_size = n[0];
341 Int64 dim2_size = n[1];
342 Int32 count = CheckedConvert::toInt32(n[2]);
343 Int64 total = count * dim2_size;
344 // One dim
345 /*m_trace->info() << "COUNT = " << count << " total=" << total
346 << " dim1 (n[0])=" << n[0]
347 << " dim1 current=" << m_value.dim1Size()
348 << " dim2 (n[1])=" << n[1]
349 << " dim2 current=" << m_value.dim2Size()
350 << " count (n[2])=" << n[2]
351 << " magic=" << n[3]
352 << " this=" << this;*/
353 if (n[3]!=SERIALIZE2_MAGIC_NUMBER)
354 ARCANE_FATAL("Bad magic number");
355 Int64 current_dim2_size = m_value.dim2Size();
356 if (dim2_size!=current_dim2_size){
357 if (current_dim2_size!=0 && dim2_size!=0)
358 ARCANE_FATAL("serialized data should have the same dim2Size current={0} found={1}",
359 current_dim2_size,dim2_size);
360 else
361 m_value.resize(m_value.dim1Size(),dim2_size);
362 }
363 Int64 nb_value = count;
364 //Array<BasicType> v(total*nb_count);
365 UniqueArray<BasicType> base_value(total*nb_count);
366
367 sbuf->getSpan(base_value);
368
369 Span<DataType> data_value(reinterpret_cast<DataType*>(base_value.data()),nb_value*dim2_size);
370 UniqueArray<DataType> current_value;
371 Span<DataType> transformed_value;
372
373 // Si on applique une transformantion, effectue la transformation dans un
374 // tableau temporaire 'current_value'.
375 if (operation && nb_value!=0) {
376 current_value.resize(data_value.size());
377
378 Int64 index = 0;
379 for( Int32 i=0, n=count; i<n; ++i ){
380 Span<const DataType> a(m_value[ids[i]]);
381 for( Int64 z=0, iz=dim2_size; z<iz; ++z ){
382 current_value[index] = a[z];
383 ++index;
384 }
385 }
386
387 transformed_value = current_value.view();
388 operation->applySpan(transformed_value,data_value);
389 }
390 else {
391 transformed_value = data_value;
392 }
393
394 {
395 Int64 index = 0;
396 for( Int32 i=0, n=count; i<n; ++i ){
397 Span<DataType> a(m_value[ids[i]]);
398 for( Int64 z=0, iz=dim2_size; z<iz; ++z ){
399 a[z] = transformed_value[index];
400 ++index;
401 }
402 }
403 }
404 }
405 break;
406 case ISerializer::ReadAdd:
407 throw NotImplementedException(A_FUNCINFO,"option 'ReadAdd'");
408 break;
409 }
410 }
411}
412
413/*---------------------------------------------------------------------------*/
414/*---------------------------------------------------------------------------*/
415
416template<typename DataType> void Array2DataT<DataType>::
417fillDefault()
418{
419 m_value.fill(DataType());
420}
421
422/*---------------------------------------------------------------------------*/
423/*---------------------------------------------------------------------------*/
424
425template<typename DataType> void Array2DataT<DataType>::
426setName(const String& name)
427{
428 m_value.setDebugName(name);
429}
430
431/*---------------------------------------------------------------------------*/
432/*---------------------------------------------------------------------------*/
433
434template<typename DataType> void Array2DataT<DataType>::
435computeHash(IHashAlgorithm* algo,ByteArray& output) const
436{
437 //TODO: passer en 64 bits
438 Span<const DataType> values = m_value.to1DSpan();
439
440 // Calcule la fonction de hashage pour les valeurs
441 Int64 type_size = sizeof(DataType);
442 Int64 nb_element = values.size();
443 const Byte* ptr = reinterpret_cast<const Byte*>(values.data());
444 Span<const Byte> input(ptr,type_size*nb_element);
445 algo->computeHash64(input,output);
446
447 // Calcule la fonction de hashage pour les tailles
448 UniqueArray<Int64> dimensions(2);
449 dimensions[0] = m_value.dim1Size();
450 dimensions[1] = m_value.dim2Size();
451 ptr = reinterpret_cast<const Byte*>(dimensions.data());
452 Int64 array_len = dimensions.size() * sizeof(Int64);
453 input = Span<const Byte>(ptr,array_len);
454 algo->computeHash64(input,output);
455}
456
457/*---------------------------------------------------------------------------*/
458/*---------------------------------------------------------------------------*/
459
460template<typename DataType> void Array2DataT<DataType>::
461computeHash(DataHashInfo& hash_info) const
462{
463 hash_info.setVersion(2);
464 IHashAlgorithmContext* context = hash_info.context();
465
466 // Calcule la fonction de hashage pour les tailles
467 Int64 dimensions[2];
468 dimensions[0] = m_value.dim1Size();
469 dimensions[1] = m_value.dim2Size();
470 Span<const Int64> dimension_span(dimensions,2);
471 context->updateHash(asBytes(dimension_span));
472
473 // Calcule la fonction de hashage pour les valeurs
474 context->updateHash(asBytes(m_value.to1DSpan()));
475}
476
477/*---------------------------------------------------------------------------*/
478/*---------------------------------------------------------------------------*/
479
480template<typename DataType> void Array2DataT<DataType>::
481copy(const IData* data)
482{
483 auto* true_data = dynamic_cast< const DataInterfaceType* >(data);
484 if (!true_data)
485 throw ArgumentException(A_FUNCINFO,"Can not cast 'IData' to 'IArray2DataT'");
486 m_value.copy(true_data->view());
487}
488
489/*---------------------------------------------------------------------------*/
490/*---------------------------------------------------------------------------*/
491
492template<typename DataType> void Array2DataT<DataType>::
493swapValues(IData* data)
494{
495 auto* true_data = dynamic_cast<ThatClass*>(data);
496 if (!true_data)
497 throw ArgumentException(A_FUNCINFO,"Can not cast 'IData' to 'Array2DataT'");
498 swapValuesDirect(true_data);
499}
500
501/*---------------------------------------------------------------------------*/
502/*---------------------------------------------------------------------------*/
503
504template<typename DataType> void Array2DataT<DataType>::
505swapValuesDirect(ThatClass* true_data)
506{
507 m_value.swap(true_data->m_value);
508}
509
510/*---------------------------------------------------------------------------*/
511/*---------------------------------------------------------------------------*/
512
513template<typename DataType> void Array2DataT<DataType>::
514setAllocationInfo(const DataAllocationInfo& v)
515{
516 if (m_allocation_info==v)
517 return;
518 m_allocation_info = v;
519 m_value.setMemoryLocationHint(v.memoryLocationHint());
520}
521
522/*---------------------------------------------------------------------------*/
523/*---------------------------------------------------------------------------*/
524
525template<typename DataType> void Array2DataT<DataType>::
526changeAllocator(const MemoryAllocationOptions& alloc_info)
527{
528 m_value.changeAllocator(alloc_info);
529 m_allocation_info.setMemoryLocationHint(alloc_info.memoryLocationHint());
530}
531
532/*---------------------------------------------------------------------------*/
533/*---------------------------------------------------------------------------*/
534
535} // End namespace Arcane
536
537/*---------------------------------------------------------------------------*/
538/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:740
MemoryUtils.h
Fonctions de gestion mémoire et des allocateurs.
Arcane::AbstractArray::size
Integer size() const
Nombre d'éléments du vecteur.
Definition AbstractArray.h:301
Arcane::AlignedMemoryAllocator
Allocateur mémoire avec alignement mémoire spécifique.
Definition AlignedMemoryAllocator.h:46
Arcane::ArgumentException
Exception lorsqu'un argument est invalide.
Definition arccore/src/base/arccore/base/ArgumentException.h:33
Arcane::Array2DataT::Impl::memoryAllocator
IMemoryAllocator * memoryAllocator() const override
Allocateur utilisé pour la donnée.
Definition Array2Data.h:243
Arcane::Array2DataT
Donnée tableau bi-dimensionnel d'un type DataType.
Definition Array2Data.h:49
Arcane::Array2DataT::Impl::m_value
UniqueArray2< DataType > m_value
Definition Array2Data.h:146
Arcane::Array2DataT::Impl::dimension
Integer dimension() const override
Definition Array2Data.h:68
Arcane::Array2DataT::dataType
eDataType dataType() const override
Type de la donnée.
Definition Array2Data.h:70
Arcane::Array2DataT::shape
ArrayShape shape() const override
Forme du tableau pour une donnée 1D ou 2D.
Definition Array2Data.h:104
Arcane::Array::resize
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
Definition arccore/src/common/arccore/common/Array.h:249
Arcane::Array::data
const T * data() const
Accès à la racine du tableau hors toute protection.
Definition arccore/src/common/arccore/common/Array.h:446
Arcane::Array::view
ArrayView< T > view() const
Vue mutable sur ce tableau.
Definition arccore/src/common/arccore/common/Array.h:142
Arcane::ConstArrayView::size
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:713
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:34
Arcane::IDataOperation
Interface d'une opération sur une donnée.
Definition IDataOperation.h:37
Arcane::IData
Interface d'une donnée.
Definition IData.h:33
Arcane::IHashAlgorithmContext
Contexte pour calculer un hash de manière incrémentale.
Definition IHashAlgorithm.h:83
Arcane::IHashAlgorithmContext::updateHash
virtual void updateHash(Span< const std::byte > input)=0
Ajoute le tableau input au hash calculé
Arcane::IHashAlgorithm
Interface d'un algorithme de hashage.
Definition IHashAlgorithm.h:106
Arcane::IHashAlgorithm::computeHash64
virtual void computeHash64(Span< const Byte > input, ByteArray &output)
Calcule la valeur du hash pour le tableau input.
Definition HashAlgorithm.cc:59
Arcane::ISerializedData
Interface d'une donnée sérialisée.
Definition ISerializedData.h:62
Arcane::ISerializedData::baseDataType
virtual eDataType baseDataType() const =0
Type de la donnée.
Arcane::ISerializedData::shape
virtual ArrayShape shape() const =0
Forme du tableau associé aux données.
Arcane::ISerializedData::memorySize
virtual Int64 memorySize() const =0
Indique le nombre d'octets qu'il faut allouer pour stocker ou lire les données.
Arcane::ISerializedData::setWritableBytes
virtual void setWritableBytes(Span< Byte > bytes)=0
Positionne les valeurs de sérialisation.
Arcane::ISerializedData::extents
virtual Int64ConstArrayView extents() const =0
Tableau contenant le nombre d'éléments pour chaque dimension.
Arcane::ISerializedData::isMultiSize
virtual bool isMultiSize() const =0
Indique s'il s'agit d'un tableau multi-taille. (pertinent uniquement si nbDimension()>1)
Arcane::ISerializer::eMode
eMode
Mode de fonctionnement du sérialiseur.
Definition arccore/src/serialize/arccore/serialize/ISerializer.h:63
Arcane::ISerializer::ModePut
@ ModePut
Le sérialiseur attend des reserve()
Definition arccore/src/serialize/arccore/serialize/ISerializer.h:65
Arcane::ISerializer::readMode
virtual eReadMode readMode() const =0
Mode de lecture.
Arcane::ISerializer::putSpan
virtual void putSpan(Span< const Real > values)
Ajoute le tableau values.
Definition SerializeGlobal.cc:30
Arcane::ISerializer::mode
virtual eMode mode() const =0
Mode de fonctionnement actuel.
Arcane::ISerializer::ReadReplace
@ ReadReplace
Replace les éléments actuels par ceux lus.
Definition arccore/src/serialize/arccore/serialize/ISerializer.h:71
Arcane::ISerializer::ReadAdd
@ ReadAdd
Ajoute aux éléments actuels ceux lus.
Definition arccore/src/serialize/arccore/serialize/ISerializer.h:72
Arcane::ISerializer::getSpan
virtual void getSpan(Span< Real > values)
Récupère le tableau values.
Definition SerializeGlobal.cc:132
Arcane::ISerializer::reserveSpan
virtual void reserveSpan(eBasicDataType dt, Int64 n)=0
Réserve de la mémoire pour n valeurs de dt.
Arcane::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arcane::NotImplementedException
Exception lorsqu'une fonction n'est pas implémentée.
Definition arccore/src/base/arccore/base/NotImplementedException.h:33
Arcane::Ref
Référence à une instance.
Definition arccore/src/base/arccore/base/Ref.h:143
Arcane::SpanImpl::data
constexpr __host__ __device__ pointer data() const noexcept
Pointeur sur le début de la vue.
Definition Span.h:537
Arcane::SpanImpl::size
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Definition Span.h:325
Arcane::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:633
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/common/arccore/common/Array.h:888
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37
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::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:227
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:281
Arcane::ByteArray
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:121
Arcane::Int32ConstArrayView
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:482
Arcane::eBasicDataType
eBasicDataType
Type d'une donnée de base.
Definition arccore/src/base/arccore/base/BasicDataType.h:37
Arcane::asBytes
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:1022
Arcane::Byte
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43
Arcane::eDataType
eDataType
Type d'une donnée.
Definition DataTypes.h:39
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:225