14#include "arcane/impl/internal/Array2Data.h"
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"
29#include "arcane/core/datatype/DataStorageBuildInfo.h"
30#include "arcane/core/datatype/IDataOperation.h"
32#include "arcane/core/ISerializer.h"
34#include "arcane/impl/SerializedData.h"
47inline constexpr Int64 SERIALIZE2_MAGIC_NUMBER = 0x12ff7789;
57, m_internal(new Impl(this))
64template<
typename DataType> Array2DataT<DataType>::
65Array2DataT(
const Array2DataT<DataType>& rhs)
66: m_value(AlignedMemoryAllocator::Simd())
68, m_internal(new Impl(this))
69, m_allocation_info(rhs.m_allocation_info)
77template<
typename DataType> Array2DataT<DataType>::
79:
m_value(dsbi.memoryAllocator())
80, m_trace(dsbi.traceMng())
81, m_internal(new Impl(this))
88template<
typename DataType> Array2DataT<DataType>::
101staticStorageTypeInfo()
105 Int32 nb_basic_type = TraitsType::nbBasicType();
115storageTypeInfo()
const
117 return staticStorageTypeInfo();
123template<
typename DataType>
void Array2DataT<DataType>::
133createSerializedDataRef(
bool use_basic_type)
const
139 Int64 type_size =
sizeof(DataType);
144 type_size =
sizeof(BasicType);
148 Int64 nb_base_element = nb_element * nb_count;
149 Int64 full_size = nb_base_element * type_size;
150 const Byte* bt =
reinterpret_cast<const Byte*
>(
m_value.to1DSpan().data());
154 dimensions[0] =
m_value.dim1Size();
155 dimensions[1] =
m_value.dim2Size();
158 nb_base_element,
false,dimensions,
shape());
159 sd->setConstBytes(base_values);
166template<
typename DataType>
void Array2DataT<DataType>::
174 if (data_type!=
dataType() && data_type==base_data_type)
186 m_value.resize(dim1_size,dim2_size);
187 m_shape = sdata->
shape();
197template<
typename DataType>
void Array2DataT<DataType>::
200 ARCANE_UNUSED(sdata);
207template<
typename DataType>
void Array2DataT<DataType>::
215 if (mode==ISerializer::ModeReserve){
224 sbuf->
reserveSpan(data_type,total_nb_element*nb_count);
233 n[3] = SERIALIZE2_MAGIC_NUMBER;
235 BasicType* bt =
reinterpret_cast<BasicType*
>(
m_value.to1DSpan().data());
241 Int64 n[4] = { 0, 0, 0, 0 };
244 Int64 dim2_size = n[1];
246 if (n[3]!=SERIALIZE2_MAGIC_NUMBER)
252 m_value.resize(count,dim2_size);
255 BasicType* bt =
reinterpret_cast<BasicType*
>(
m_value.to1DSpan().data());
267 m_value.resize(current_size + count,dim2_size);
270 BasicType* bt =
reinterpret_cast<BasicType*
>(
m_value.to1DSpan().data()+current_total);
283template<
typename DataType>
void Array2DataT<DataType>::
291 if (mode==ISerializer::ModeReserve){
300 sbuf->
reserveSpan(data_type,total_nb_value*nb_count);
306 Int64 total_nb_value = count * dim2_size;
307 Int64 total = total_nb_value;
312 n[3] = SERIALIZE2_MAGIC_NUMBER;
323 for(
Int32 i=0, is=count; i<is; ++i ){
324 const BasicType* sub_a =
reinterpret_cast<const BasicType*
>(
m_value[ids[i]].data());
325 for(
Int64 z=0, iz=dim2_size*nb_count; z<iz; ++z ){
337 Int64 n[4] = { 0, 0, 0, 0 };
340 Int64 dim2_size = n[1];
342 Int64 total = count * dim2_size;
352 if (n[3]!=SERIALIZE2_MAGIC_NUMBER)
355 if (dim2_size!=current_dim2_size){
356 if (current_dim2_size!=0 && dim2_size!=0)
357 ARCANE_FATAL(
"serialized data should have the same dim2Size current={0} found={1}",
358 current_dim2_size,dim2_size);
362 Int64 nb_value = count;
368 Span<DataType> data_value(
reinterpret_cast<DataType*
>(base_value.
data()),nb_value*dim2_size);
374 if (operation && nb_value!=0) {
378 for(
Int32 i=0, n=count; i<n; ++i ){
380 for(
Int64 z=0, iz=dim2_size; z<iz; ++z ){
381 current_value[index] = a[z];
386 transformed_value = current_value.
view();
387 operation->applySpan(transformed_value,data_value);
390 transformed_value = data_value;
395 for(
Int32 i=0, n=count; i<n; ++i ){
397 for(
Int64 z=0, iz=dim2_size; z<iz; ++z ){
398 a[z] = transformed_value[index];
415template<
typename DataType>
void Array2DataT<DataType>::
424template<
typename DataType>
void Array2DataT<DataType>::
425setName(
const String& name)
433template<
typename DataType>
void Array2DataT<DataType>::
440 Int64 type_size =
sizeof(DataType);
442 const Byte* ptr =
reinterpret_cast<const Byte*
>(values.
data());
448 dimensions[0] =
m_value.dim1Size();
449 dimensions[1] =
m_value.dim2Size();
450 ptr =
reinterpret_cast<const Byte*
>(dimensions.
data());
462 hash_info.setVersion(2);
467 dimensions[0] = m_value.dim1Size();
468 dimensions[1] = m_value.dim2Size();
479template<
typename DataType>
void Array2DataT<DataType>::
480copy(
const IData* data)
482 auto* true_data =
dynamic_cast< const DataInterfaceType*
>(data);
485 m_value.copy(true_data->view());
491template<
typename DataType>
void Array2DataT<DataType>::
492swapValues(
IData* data)
494 auto* true_data =
dynamic_cast<ThatClass*
>(data);
497 swapValuesDirect(true_data);
506 m_value.swap(true_data->m_value);
512template<
typename DataType>
void Array2DataT<DataType>::
515 if (m_allocation_info==v)
517 m_allocation_info = v;
518 m_value.setMemoryLocationHint(v.memoryLocationHint());
527 ARCANE_UNUSED(alloc_info);
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Integer size() const
Nombre d'éléments du vecteur.
Allocateur mémoire avec alignement mémoire spécifique.
Exception lorsqu'un argument est invalide.
Donnée tableau bi-dimensionnel d'un type DataType.
UniqueArray2< DataType > m_value
Integer dimension() const override
eDataType dataType() const override
Type de la donnée.
ArrayShape shape() const override
Forme du tableau pour une donnée 1D ou 2D.
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
const T * data() const
Accès à la racine du tableau hors toute protection.
ArrayView< T > view() const
Vue mutable sur ce tableau.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Informations sur l'allocation d'une donnée.
Informations pour le calcul du hash d'une donnée.
Informations pour construire une instance de 'IData'.
Informations de type pour un conteneur de données.
Interface d'une opération sur une donnée.
Contexte pour calculer un hash de manière incrémentale.
virtual void updateHash(Span< const std::byte > input)=0
Ajoute le tableau input au hash calculé
Interface d'un algorithme de hashage.
virtual void computeHash64(Span< const Byte > input, ByteArray &output)
Calcule la valeur du hash pour le tableau input.
Interface d'une donnée sérialisée.
virtual eDataType baseDataType() const =0
Type de la donnée.
virtual ArrayShape shape() const =0
Forme du tableau associé aux données.
virtual Int64 memorySize() const =0
Indique le nombre d'octets qu'il faut allouer pour stocker ou lire les données.
virtual void setWritableBytes(Span< Byte > bytes)=0
Positionne les valeurs de sérialisation.
virtual Int64ConstArrayView extents() const =0
Tableau contenant le nombre d'éléments pour chaque dimension.
virtual bool isMultiSize() const =0
Indique s'il s'agit d'un tableau multi-taille. (pertinent uniquement si nbDimension()>1)
Interface d'un sérialiseur.
eMode
Mode de fonctionnement du sérialiseur.
@ ModePut
Le sérialiseur attend des reserve()
@ ModeGet
Le sérialiseur attend des get()
virtual eReadMode readMode() const =0
Mode de lecture.
virtual void putSpan(Span< const Real > values)
Ajoute le tableau values.
virtual eMode mode() const =0
Mode de fonctionnement actuel.
@ ReadReplace
Replace les éléments actuels par ceux lus.
@ ReadAdd
Ajoute aux éléments actuels ceux lus.
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 de traces.
Options pour configurer les allocations.
Exception lorsqu'une fonction n'est pas implémentée.
Référence à une instance.
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
constexpr __host__ __device__ pointer data() const noexcept
Pointeur sur le début de la vue.
Vue d'un tableau d'éléments de type T.
Chaîne de caractères unicode.
Vecteur 1D de données avec sémantique par valeur (style STL).
Int32 toInt32(Int64 v)
Converti un Int64 en un Int32.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
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.
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
eBasicDataType
Type d'une donnée de base.
@ Int64
Donnée de type entier 64 bits.
impl::SpanTypeFromSize< conststd::byte, SizeType >::SpanType asBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets non modifiables.
unsigned char Byte
Type d'un octet.
eDataType
Type d'une donnée.
std::int32_t Int32
Type entier signé sur 32 bits.