14#include "arcane/impl/internal/ArrayData.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/IndexOutOfRangeException.h"
24#include "arcane/utils/ArgumentException.h"
25#include "arcane/utils/FatalErrorException.h"
26#include "arcane/utils/ITraceMng.h"
27#include "arcane/utils/CheckedConvert.h"
28#include "arcane/utils/MemoryAllocator.h"
31#include "arcane/core/datatype/DataStorageBuildInfo.h"
32#include "arcane/core/datatype/IDataOperation.h"
34#include "arcane/core/ISerializer.h"
36#include "arcane/impl/SerializedData.h"
45 inline constexpr Int64 SERIALIZE_MAGIC_NUMBER = 0x456ff989;
55, m_internal(new Impl(this))
63template <
typename DataType> ArrayDataT<DataType>::
64ArrayDataT(
const ArrayDataT<DataType>& rhs)
65: m_value(AlignedMemoryAllocator::Simd())
67, m_internal(new Impl(this))
69, m_allocation_info(rhs.m_allocation_info)
77template <
typename DataType> ArrayDataT<DataType>::
79:
m_value(dsbi.memoryAllocator())
80, m_trace(dsbi.traceMng())
81, m_internal(new
Impl(this))
89template <
typename DataType> ArrayDataT<DataType>::
102staticStorageTypeInfo()
106 Int32 nb_basic_type = TraitsType::nbBasicType();
116storageTypeInfo()
const
118 return staticStorageTypeInfo();
125createSerializedDataRef(
bool use_basic_type)
const
131 Integer type_size =
sizeof(DataType);
133 if (use_basic_type) {
136 type_size =
sizeof(BasicType);
140 Int64 nb_base_element = nb_element * nb_count;
141 Int64 full_size = nb_base_element * type_size;
144 extents.
add(nb_element);
146 nb_base_element,
false, extents,
shape());
147 sd->setConstBytes(base_values);
154template <
typename DataType>
void ArrayDataT<DataType>::
162 if (data_type !=
dataType() && data_type == base_data_type)
170 m_shape = sdata->
shape();
179template <
typename DataType>
void ArrayDataT<DataType>::
182 ARCANE_UNUSED(sdata);
189template <
typename DataType>
void ArrayDataT<DataType>::
197 switch (sbuf->
mode()) {
198 case ISerializer::ModeReserve: {
200 Int64 total_size = nb_value * nb_count;
201 m_trace->debug(
Trace::High) <<
" ArrayDataT::serialize (full) reserve datatype="
202 << data_type <<
" ids=" << nb_value <<
" totalsize=" << total_size;
208 Int64 total_size = nb_value * nb_count;
209 m_trace->debug(
Trace::High) <<
" ArrayDataT::serialize (full) put datatype="
210 << data_type <<
" ids=" << nb_value <<
" totalsize=" << total_size;
212 for (
Int64 i = 0; i < nb_value; ++i)
216 sbuf->
putInt64(SERIALIZE_MAGIC_NUMBER);
224 if (saved_magic_number != SERIALIZE_MAGIC_NUMBER)
225 ARCANE_FATAL(
"Internal errror: bad magic number for serialisation expected={0} current={1}",
226 SERIALIZE_MAGIC_NUMBER, saved_magic_number);
228 Int64 total_size = nb_value * nb_count;
230 m_trace->debug(
Trace::High) <<
" ArrayDataT::serialize (full) get mode=" << sbuf->
readMode()
231 <<
" datatype=" << data_type
232 <<
" ids=" << nb_value <<
" totalsize=" << total_size;
241 operation->applySpan(
m_value, data_value);
243 for (
Int64 i = 0; i < nb_value; ++i)
245 << data_value[i] <<
" transformed value=" <<
m_value[i];
251 for (
Int64 i = 0; i < nb_value; ++i)
257 m_value.resize(current_size + nb_value);
263 for (
Int64 i = 0; i < nb_value; ++i)
275template <
typename DataType>
void ArrayDataT<DataType>::
278 _serialize(sbuf, ids, operation);
293 Int64 total_size = nb_value * nb_count;
295 switch (sbuf->
mode()) {
296 case ISerializer::ModeReserve: {
297 m_trace->debug(
Trace::High) <<
" ArrayDataT::serialize (partial) reserve datatype="
298 << data_type <<
" ids=" << nb_value <<
" totalsize=" << total_size;
302 case ISerializer::ModePut: {
303 m_trace->debug(Trace::High) <<
" ArrayDataT::serialize (partial) put datatype="
304 << data_type <<
" ids=" << nb_value <<
" totalsize=" << total_size;
307 for (Integer i = 0, max_value = m_value.size(); i < nb_value; ++i)
308 if (ids[i] > max_value)
309 throw IndexOutOfRangeException(A_FUNCINFO,
310 String::format(
" put,serialize : bad sizes i={0} ids[i]={1} nb_value={2} this={3}",
311 i, ids[i], max_value,
this),
315 UniqueArray<BasicType> base_value;
316 base_value.reserve(total_size);
317 for (Int64 i = 0; i < nb_value; ++i) {
319 m_trace->debug(Trace::Highest) <<
"Put i=" << i <<
" index=" << ids[i] <<
" value=" << m_value[ids[i]];
321 ConstArrayView<BasicType> current_value(nb_count,
reinterpret_cast<BasicType*
>(&m_value[ids[i]]));
322 base_value.addRange(current_value);
324 sbuf->
putInt64(SERIALIZE_MAGIC_NUMBER);
328 case ISerializer::ModeGet: {
329 m_trace->debug(Trace::High) <<
" ArrayDataT::serialize (partial) get mode=" << sbuf->
readMode()
330 <<
" datatype=" << data_type
331 <<
" ids=" << nb_value <<
" totalsize=" << total_size;
334 for (Integer i = 0, max_value = m_value.size(); i < nb_value; ++i)
335 if (ids[i] > max_value)
336 throw IndexOutOfRangeException(A_FUNCINFO,
337 String::format(
" put,serialize : bad sizes i={0} ids[i]={1} nb_value={2} this={3}",
338 i, ids[i], max_value,
this),
343 case ISerializer::ReadReplace: {
344 Int64 saved_magic_number = sbuf->
getInt64();
345 Int64 saved_nb_value = sbuf->
getInt64();
347 if (saved_magic_number != SERIALIZE_MAGIC_NUMBER)
348 ARCANE_FATAL(
"Internal errror: bad magic number for serialisation expected={0} current={1}",
349 SERIALIZE_MAGIC_NUMBER, saved_magic_number);
351 if (saved_nb_value != nb_value)
352 ARCANE_FATAL(
"Internal errror: bad size for serialisation expected={0} found={1}",
353 nb_value, saved_nb_value);
355 UniqueArray<BasicType> base_value(total_size);
358 Span<DataType> data_value(
reinterpret_cast<DataType*
>(base_value.data()), nb_value);
359 UniqueArray<DataType> current_value;
360 Span<DataType> transformed_value;
362 if (operation && nb_value != 0) {
363 current_value.resize(ids.size());
365 transformed_value = current_value.view();
366 operation->applySpan(transformed_value, data_value);
369 transformed_value = data_value;
374 for (Int64 i = 0; i < nb_value; ++i)
375 m_trace->debug(Trace::Highest) <<
"Get i=" << i <<
" index=" << ids[i]
376 <<
" value=" << data_value[i] <<
" transformed value=" << transformed_value[i];
378 for (Int64 i = 0; i < nb_value; ++i)
379 m_trace->debug(Trace::Highest) <<
"Get i=" << i <<
" index=" << ids[i]
380 <<
" value=" << data_value[i];
383 for (Int64 i = 0; i < nb_value; ++i) {
384 m_value[ids[i]] = transformed_value[i];
387 case ISerializer::ReadAdd:
388 ARCANE_THROW(NotImplementedException,
"ArrayData::serialize : Cannot deserialize with ReadAdd mode");
398template <
typename DataType>
void ArrayDataT<DataType>::
407template <
typename DataType>
void ArrayDataT<DataType>::
408setName(
const String& name)
416template <
typename DataType>
void ArrayDataT<DataType>::
419 Int64 type_size =
sizeof(DataType);
432 hash_info.setVersion(2);
439template <
typename DataType>
void ArrayDataT<DataType>::
440copy(
const IData* data)
442 auto* true_data =
dynamic_cast<const DataInterfaceType*
>(data);
445 m_value.copy(true_data->view());
451template <
typename DataType>
void ArrayDataT<DataType>::
452swapValues(
IData* data)
454 auto* true_data =
dynamic_cast<ThatClass*
>(data);
457 swapValuesDirect(true_data);
466 m_value.swap(true_data->m_value);
472template <
typename DataType>
void ArrayDataT<DataType>::
475 m_shape.setNbDimension(1);
476 m_shape.setDimension(0, 1);
482template <
typename DataType>
void ArrayDataT<DataType>::
485 if (m_allocation_info == v)
487 m_allocation_info = v;
488 m_value.setMemoryLocationHint(v.memoryLocationHint());
505 std::swap(m_value, new_value);
506 m_allocation_info.setMemoryLocationHint(alloc_info.memoryLocationHint());
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Fonctions de gestion mémoire et des allocateurs.
Allocateur mémoire avec alignement mémoire spécifique.
Exception lorsqu'un argument est invalide.
Donnée tableau d'un type T.
eDataType dataType() const override
Type de la donnée.
ArrayShape shape() const override
Forme du tableau pour une donnée 1D ou 2D.
UniqueArray< DataType > m_value
Integer dimension() const override
const T * data() const
Accès à la racine du tableau hors toute protection.
void add(ConstReferenceType val)
Ajoute l'élément val à la fin 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.
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 Int64 nbElement() const =0
Nombre d'éléments.
Interface d'un sérialiseur.
void reserveInt64(Int64 n)
Réserve pour n Int64.
@ ModePut
Le sérialiseur attend des reserve()
@ ModeGet
Le sérialiseur attend des get()
virtual Int64 getInt64()=0
Récupère une taille.
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.
virtual void putInt64(Int64 value)=0
Ajoute l'entier value.
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.
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).
void copy(MutableMemoryView destination, eMemoryResource destination_mem, ConstMemoryView source, eMemoryResource source_mem, const RunQueue *queue=nullptr)
Copie de source vers destination en utilisant la file queue.
@ Highest
Niveau le plus élevé
-*- 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.
bool arcaneIsDebug()
Vrai si la macro ARCANE_DEBUG est définie.
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.
void sampleSpan(Span< const DataType > values, Span< const Int64 > indexes, Span< DataType > result)
Extrait un sous-tableau à à partir d'une liste d'index.