Arcane  v4.1.7.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
Hdf5MpiReaderWriter.cc
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/* Hdf5MpiReaderWriter.cc (C) 2000-2026 */
9/* */
10/* Lecture/Ecriture au format HDF5. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/String.h"
15#include "arcane/utils/StringBuilder.h"
16#include "arcane/utils/OStringStream.h"
17#include "arcane/utils/ScopedPtr.h"
18#include "arcane/utils/List.h"
19#include "arcane/utils/ITraceMng.h"
20
21#include "arcane/core/Item.h"
22#include "arcane/core/IDataReader.h"
23#include "arcane/core/IDataWriter.h"
24#include "arcane/core/ISubDomain.h"
25#include "arcane/core/StdNum.h"
26#include "arcane/core/IVariable.h"
27#include "arcane/core/CheckpointService.h"
28#include "arcane/core/Directory.h"
29#include "arcane/core/IParallelMng.h"
30#include "arcane/core/ArcaneException.h"
31#include "arcane/core/VerifierService.h"
32#include "arcane/core/IVariableMng.h"
33#include "arcane/core/FactoryService.h"
34#include "arcane/core/IData.h"
35#include "arcane/core/Timer.h"
36#include "arcane/core/ISerializedData.h"
37#include "arcane/core/IIOMng.h"
38#include "arcane/core/IXmlDocumentHolder.h"
39#include "arcane/core/VariableCollection.h"
40#include "arcane/core/internal/SerializeMessage.h"
41#include "arcane/core/SerializeBuffer.h"
42#include "arcane/core/ISerializeMessageList.h"
43
44#include "arcane/hdf5/Hdf5MpiReaderWriter.h"
45
46#include "arcane/hdf5/Hdf5MpiReaderWriter_axl.h"
47
48#include "arcane_packages.h"
49
50#ifdef ARCANE_HAS_PACKAGE_MPI
51#ifndef OMPI_SKIP_MPICXX
52#define OMPI_SKIP_MPICXX
53#endif
54#ifndef MPICH_SKIP_MPICXX
55#define MPICH_SKIP_MPICXX
56#endif
57#include <mpi.h>
58
59//#define ARCANE_TEST_HDF5MPI
60
61// Pour l'instant (1.8.0 beta 2), cela ne fonctionne pas sur tera 10
62// #define ARCANE_TEST_HDF5DIRECT
63
64/*---------------------------------------------------------------------------*/
65/*---------------------------------------------------------------------------*/
66
67namespace Arcane
68{
69
70/*---------------------------------------------------------------------------*/
71/*---------------------------------------------------------------------------*/
72
73using namespace Hdf5Utils;
74
75static herr_t _Hdf5MpiReaderWriterIterateMe(hid_t,const char*,void*);
76
77/*---------------------------------------------------------------------------*/
78/*---------------------------------------------------------------------------*/
79
80Hdf5MpiReaderWriter::
81Hdf5MpiReaderWriter(ISubDomain* sd,const String& filename,
82 const String& sub_group_name,Integer fileset_size,
83 eOpenMode open_mode,bool do_verif)
84: TraceAccessor(sd->traceMng())
85, m_sub_domain(sd)
86, m_parallel_mng(sd->parallelMng())
87, m_open_mode(open_mode)
88, m_filename(filename)
89, m_sub_group_name(sub_group_name)
90, m_is_initialized(false)
91, m_io_timer(sd,"Hdf5TimerHd",Timer::TimerReal)
92, m_write_timer(sd,"Hdf5TimerWrite",Timer::TimerReal)
93, m_is_parallel(false)
94, m_my_rank(m_parallel_mng->commRank())
95, m_send_rank(m_my_rank)
96, m_last_recv_rank(m_my_rank)
97, m_fileset_size(fileset_size)
98{
99 ARCANE_UNUSED(do_verif);
100 if (m_fileset_size!=1 && m_parallel_mng->isParallel()){
101 m_is_parallel = true;
102 Integer nb_rank = m_parallel_mng->commSize();
103 if (m_fileset_size==0){
104 m_send_rank = 0;
105 m_last_recv_rank = nb_rank;
106 --m_last_recv_rank;
107 }
108 else{
109 m_send_rank = (m_my_rank / m_fileset_size) * m_fileset_size;
110 m_last_recv_rank = m_send_rank + m_fileset_size;
111 if (m_last_recv_rank>nb_rank)
112 m_last_recv_rank = nb_rank;
113 --m_last_recv_rank;
114 }
115 }
116 sd->traceMng()->info() << " INFOS PARALLEL: my_rank=" << m_my_rank
117 << " send_rank=" << m_send_rank
118 << " last_recv_rank=" << m_last_recv_rank
119 << " filename=" << filename
120 << " fileset_size=" << m_fileset_size;
121}
122
123/*---------------------------------------------------------------------------*/
124/*---------------------------------------------------------------------------*/
125
126void Hdf5MpiReaderWriter::
127initialize()
128{
129 if (m_is_initialized)
130 return;
131
132 m_is_initialized = true;
133
134 const char* func_name = "Hdf5MpiReaderWriter::initialize()";
135
136 HInit();
137 HInit::useMutex(m_parallel_mng->isThreadImplementation(), m_parallel_mng);
138
139 if (m_open_mode==OpenModeRead){
140 m_file_id.openRead(m_filename);
141 m_sub_group_id.recursiveOpen(m_file_id,m_sub_group_name);
142 //m_variable_group_id.open(m_sub_group_id,"Variables");
143 }
144 else{
145 void* arcane_comm = m_sub_domain->parallelMng()->getMPICommunicator();
146 if (!arcane_comm)
147 throw FatalErrorException("No MPI environment available");
148 MPI_Comm mpi_comm = *((MPI_Comm*)arcane_comm);
149 Integer nb_rank = m_parallel_mng->commSize();
150 if (m_fileset_size>1){
151 UniqueArray<int> senders;
152 for( Integer i=0; i<nb_rank; ++i ){
153 Integer modulo = i % m_fileset_size;
154 if (modulo==0){
155 info() << " ADD SENDER n=" << i;
156 senders.add(i);
157 }
158 }
159 MPI_Group all_group;
160 if (MPI_Comm_group(mpi_comm,&all_group)!=MPI_SUCCESS)
161 fatal() << "Error in MPI_Comm_group";
162 MPI_Group writer_group;
163 if (MPI_Group_incl(all_group,senders.size(),senders.data(),&writer_group)!=MPI_SUCCESS)
164 fatal() << "Error in MPI_Group_incl";
165 if (MPI_Comm_create(mpi_comm,writer_group,&mpi_comm)!=MPI_SUCCESS)
166 fatal() << "Error in MPI_Comm_create";
167 }
168
169 // Si ce n'est pas moi qui écrit, n'ouvre pas le fichier
170 if (m_send_rank!=m_my_rank)
171 return;
172 if (m_open_mode==OpenModeTruncate || m_open_mode==OpenModeAppend){
173 hid_t plist_id = H5Pcreate(H5P_FILE_ACCESS);
174 //bool use_gpfs = false;
175 info() << " USE MPI-POSIX";
176 //H5Pset_fapl_mpiposix(plist_id, mpi_comm, true);
177#ifdef H5_HAVE_PARALLEL
178 H5Pset_fapl_mpio(plist_id, mpi_comm, MPI_INFO_NULL); //mpi_info);
179#endif
180
181#ifdef ARCANE_TEST_HDF5DIRECT
182# ifdef H5_HAVE_DIRECT
183 info() << " HAVE DIRECT DRIVER";
184 H5Pset_fapl_direct(plist_id,4096,512,16*1024*1024);
185# endif
186#endif
187 int mdc_nelmts;
188 size_t rdcc_nelmts;
189 size_t rdcc_nbytes;
190 double rdcc_w0;
191 herr_t r = H5Pget_cache(plist_id,&mdc_nelmts,&rdcc_nelmts,&rdcc_nbytes,&rdcc_w0);
192 info() << " CACHE SIZE r=" << r << " mdc=" << mdc_nelmts
193 << " rdcc=" << rdcc_nelmts << " rdcc_bytes=" << rdcc_nbytes << " w0=" << rdcc_w0;
194 mdc_nelmts *= 10;
195 rdcc_nelmts *= 10;
196 rdcc_nbytes = 10000000;
197 r = H5Pset_cache(plist_id,mdc_nelmts,rdcc_nelmts,rdcc_nbytes,rdcc_w0);
198 info() << " SET CACHE SIZE R1=" << r;
199 //r = H5Pset_fapl_stdio(plist_id);
200 //info() << " R2=" << r;
201 hsize_t sieve_buf = (1024 << 12);
202 r = H5Pset_sieve_buf_size(plist_id,sieve_buf);
203 info() << " SIEVE_BUF=" << sieve_buf << " r=" << r;
204 hsize_t small_block_size = 0;
205 r = H5Pget_small_data_block_size(plist_id,&small_block_size);
206 info() << " SMALL BLOCK SIZE=" << small_block_size;
207 small_block_size <<= 10;
208 r = H5Pset_small_data_block_size(plist_id,small_block_size);
209 info() << " SET SMALL BLOCK SIZE s=" << small_block_size << " r=" << r;
210 //hsize_t block_size = 0;
211 //block_size = H5Pget_buffer(plist_id,0,0);
212 //info() << " BLOCK SIZE s=" << block_size;
213 //block_size = 10000000;
214 //herr_t r = H5Pset_buffer(plist_id,block_size,0,0);
215 //info() << " BLOCK SIZE r=" << r << " s=" << block_size;
216 //if (m_parallel_mng->commRank()==0){
217 //herr_t r = H5Pset_fapl_core(plist_id,1000000,1);
218 //else
219 //herr_t r = H5Pset_fapl_core(plist_id,1000000,0);
220 //m_file_id.openTruncate("toto",plist_id);
221 //}
222 //else
223 if (m_open_mode==OpenModeTruncate){
224 info() << " BEGIN OPEN TRUNCATE";
225 m_file_id.openTruncate(m_filename,plist_id);
226 info() << " END OPEN TRUNCATE";
227 }
228 else if (m_open_mode==OpenModeAppend){
229 info() << " BEGIN OPEN ADD";
230 m_file_id.openAppend(m_filename,plist_id);
231 info() << " END OPEN ADD";
232 }
233 }
234 if (m_sub_group_name!="/"){
235 info() << " CHECK CREATE GROUP name=" << m_sub_group_name;
236 //m_sub_group_id.checkDelete(m_file_id,m_sub_group_name);
237 m_sub_group_id.recursiveCreate(m_file_id,m_sub_group_name);
238 info() << " END CHECK CREATE GROUP name=" << m_sub_group_name;
239 }
240 else
241 m_sub_group_id.open(m_file_id,m_sub_group_name);
242 m_variable_group_id.create(m_sub_group_id,"Variables");
243 }
244
245 if (m_file_id.isBad()){
246 OStringStream ostr;
247 ostr() << "Unable to open file <" << m_filename << ">";
248 throw ReaderWriterException(func_name,ostr.str());
249 }
250 if (m_sub_group_id.isBad()){
251 OStringStream ostr;
252 ostr() << "HDF5 group '" << m_sub_group_name << "' not found";
253 throw ReaderWriterException(func_name,ostr.str());
254 }
255#if 0
256 if (m_variable_group_id.isBad()){
257 OStringStream ostr;
258 ostr() << "Group HDF5 'Variables' not found";
259 throw ReaderWriterException(func_name,ostr.str());
260 }
261#endif
262
263 info() << " INFO END INITIALIZE";
264
265
266 if (m_open_mode==OpenModeRead){
267 int index = 0;
268 //H5Giterate(m_sub_group_id.id(),"Variables",&index,_Hdf5MpiReaderWriterIterateMe,this);
269 H5Giterate(m_file_id.id(),m_sub_group_name.localstr(),&index,_Hdf5MpiReaderWriterIterateMe,this);
270 }
271}
272
273/*---------------------------------------------------------------------------*/
274/*---------------------------------------------------------------------------*/
275
276Hdf5MpiReaderWriter::
277~Hdf5MpiReaderWriter()
278{
279}
280
281/*---------------------------------------------------------------------------*/
282/*---------------------------------------------------------------------------*/
283
284void Hdf5MpiReaderWriter::
285_checkValid()
286{
287 if (m_is_initialized)
288 return;
289 fatal() << "Use of a Hdf5MpiReaderWriter instance not initialized";
290}
291
292/*---------------------------------------------------------------------------*/
293/*---------------------------------------------------------------------------*/
294
295String Hdf5MpiReaderWriter::
296_variableGroupName(IVariable* var)
297{
298 return var->fullName();
299}
300
301/*---------------------------------------------------------------------------*/
302/*---------------------------------------------------------------------------*/
303
304void Hdf5MpiReaderWriter::
305beginWrite(const VariableCollection& vars)
306{
307 IParallelMng* pm = m_parallel_mng;
308 Integer nb_rank = pm->commSize();
309
310 pwarning() << "Implementation of this checkpoint format is not operational yet";
311
312 for( VariableCollection::Enumerator i(vars); ++i; ){
313 IVariable* v = *i;
314 if (v->itemKind()==IK_Unknown)
315 continue;
316
317 Ref<ISerializedData> sdata(v->data()->createSerializedDataRef(false));
318 Int64 nb_base_element = sdata->nbBaseElement();
319
320 Int64 my_size = nb_base_element;
321 Int64ConstArrayView a_my_size(1,&my_size);
322 SharedArray<Int64> all_sizes(nb_rank);
323 pm->allGather(a_my_size,all_sizes);
324
325 Int64 total_size = 0;
326 for( Integer i=0; i<nb_rank; ++i )
327 total_size += all_sizes[i];
328 Int64 my_index = 0;
329 for( Integer i=0; i<m_my_rank; ++i )
330 my_index += all_sizes[i];
331 m_variables_offset.insert(std::make_pair(v->fullName(),VarOffset(my_index,total_size,all_sizes)));
332 info() << " ADD OFFSET v=" << v->fullName() << " offset=" << my_index
333 << " total_size=" << total_size;
334 }
335
336}
337
338/*---------------------------------------------------------------------------*/
339/*---------------------------------------------------------------------------*/
340/*!
341 * \brief Ecriture en parallèle.
342 *
343 * \warning En cours de test, pas utilisable.
344 */
345void Hdf5MpiReaderWriter::
346_writeValParallel(IVariable* v,const ISerializedData* sdata)
347{
348 SerializeBuffer sb;
349 sb.setMode(ISerializer::ModeReserve);
350 sb.reserve(DT_Int32,1); // Pour indiquer la fin des envois
351 sb.reserve(v->fullName());
352 sb.reserve(m_sub_group_name); //!< Nom du groupe.
353 //sb.reserveInteger(1); // Pour le type de données
354 //sb.reserveInteger(1); // Pour la dimension
355 //v->serialize(&sb,0);
356 sdata->serialize(&sb);
357 sb.allocateBuffer();
358 sb.setMode(ISerializer::ModePut);
359 sb.putInt32(1); // Indique qu'il s'agit d'un message non vide
360 sb.put(v->fullName());
361 sb.put(m_sub_group_name); //!< Nom du groupe.
362 //sb.putInteger(v->dataType()); // Pour le type de données
363 //sb.putInteger(v->dimension()); // Pour la dimension
364 //v->serialize(&sb,0);
365 sdata->serialize(&sb);
366
367 m_parallel_mng->sendSerializer(&sb,m_send_rank);
368}
369
370/*---------------------------------------------------------------------------*/
371/*---------------------------------------------------------------------------*/
372
373void Hdf5MpiReaderWriter::
374_directReadVal(IVariable* v,IData* data)
375{
376 _checkValid();
377
378 info() << "DIRECT READ VAL v=" << v->name();
379 _readVal(v,data);
380}
381
382/*---------------------------------------------------------------------------*/
383/*---------------------------------------------------------------------------*/
384
385void Hdf5MpiReaderWriter::
386_directWriteVal(IVariable* v,IData* data)
387{
388 _checkValid();
389
390 Ref<ISerializedData> sdata(data->createSerializedDataRef(false));
391
392 _writeVal(v->fullName(),m_sub_group_name,sdata.get());
393}
394
395/*---------------------------------------------------------------------------*/
396/*---------------------------------------------------------------------------*/
397
398static herr_t
399_Hdf5MpiReaderWriterIterateMe(hid_t g,const char* mn,void* ptr)
400{
401 Hdf5MpiReaderWriter* rw = reinterpret_cast<Hdf5MpiReaderWriter*>(ptr);
402 return rw->iterateMe(g,mn);
403}
404
405/*---------------------------------------------------------------------------*/
406/*---------------------------------------------------------------------------*/
407
408herr_t Hdf5MpiReaderWriter::
409iterateMe(hid_t group_id,const char* member_name)
410{
411 ARCANE_UNUSED(group_id);
412
413 m_variables_name.add(std::string_view(member_name));
414 return 0;
415}
416
417/*---------------------------------------------------------------------------*/
418/*---------------------------------------------------------------------------*/
419/*!
420 */
421void Hdf5MpiReaderWriter::
422_writeVal(const String& var_group_name,const String& sub_group_name,
423 const ISerializedData* sdata)
424{
425 ARCANE_UNUSED(sub_group_name);
426 const char* func_name = "Hdf5MpiReaderWriter::_writeVal() ";
427 Timer::Sentry ts(&m_io_timer);
428 double v0 = ::MPI_Wtime();
429 info() << " SDATA name=" << var_group_name << " nb_element=" << sdata->nbElement()
430 << " dim=" << sdata->nbDimension() << " datatype=" << sdata->baseDataType()
431 << " nb_basic_element=" << sdata->nbBaseElement()
432 << " is_multi=" << sdata->isMultiSize()
433 << " dimensions_size=" << sdata->extents().size()
434 << " memory_size=" << sdata->memorySize()
435 << " bytes_size=" << sdata->constBytes().size();
436
437 hid_t save_typeid = m_types.saveType(sdata->baseDataType());
438 hid_t trueid = m_types.nativeType(sdata->baseDataType());
439 const void* ptr = sdata->constBytes().data();
440 Int64 nb_base_element = sdata->nbBaseElement();
441
442 OffsetMap::const_iterator offset_info = m_variables_offset.find(var_group_name);
443 if (offset_info==m_variables_offset.end()){
444 fatal() << "Can not find offset informations for ->" << var_group_name;
445 }
446 Int64 nb_element_to_write = nb_base_element;
447
448 //String var_group_name = _variableGroupName(v);
449 RealUniqueArray real_array;
450 Real3UniqueArray real3_array;
451 Real3x3UniqueArray real3x3_array;
452 Int32UniqueArray int32_array;
453 if (m_is_parallel && m_fileset_size!=1){
454 if (m_send_rank==m_my_rank){
455 // Je recois les valeurs des autres
456 nb_element_to_write = 0;
457 for( Integer i=m_send_rank; i<=m_last_recv_rank; ++i ){
458 nb_element_to_write += offset_info->second.m_all_sizes[i];
459 //info() << "ADD TO WRITE n=" << nb_element_to_write << " add=" << offset_info->second.m_all_sizes[i];
460 }
461 switch(sdata->baseDataType()){
462 case DT_Real:
463 real_array.resize(nb_element_to_write);
464 ptr = real_array.data();
465 break;
466 case DT_Real3:
467 real3_array.resize(nb_element_to_write);
468 ptr = real3_array.data();
469 break;
470 case DT_Real3x3:
471 real3x3_array.resize(nb_element_to_write);
472 ptr = real3x3_array.data();
473 break;
474 case DT_Int32:
475 int32_array.resize(nb_element_to_write);
476 ptr = int32_array.data();
477 break;
478 default:
479 fatal() << "Type not handled "<< dataTypeName(sdata->baseDataType());
480 }
481 }
482 else{
483 return;
484 // J'envoie à mon référent
485 //switch(sdata->baseDataType()){
486 //case DT_Real:
487 //_send(sdata,Real());
488 // break;
489 //}
490 }
491 }
492
493#if 0
494 HGroup var_base_group;
495 var_base_group.recursiveCreate(m_file_id,sub_group_name);
496
497 // Création du groupe contenant les informations de la variable
498 HGroup group_id;
499 //group_id.create(m_variable_group_id,var_group_name);
500 group_id.create(var_base_group,var_group_name);
501 if (group_id.isBad()){
502 OStringStream ostr;
503 ostr() << "Group HDF5 '" << var_group_name << "' not found";
504 throw ReaderWriterException(func_name,ostr.str());
505 }
506#endif
507
508 //Integer dim2 = dim2_array.size();
509 //Integer nb_element = sdata->nbElement();
510#if 0
511 bool is_multi_size = sdata->isMultiSize();
512 Integer dim2_size = 0;
513 Integer dim1_size = 0;
514 if (nb_dimension==2 && !is_multi_size){
515 dim1_size = dimensions[0];
516 dim2_size = dimensions[1];
517 }
518#endif
519 //Integer dimension_array_size = dimensions.size();
520
521#if 0
522 // Sauve les informations concernant les tailles et dimensions de la variable
523 {
524 hsize_t att_dims[1];
525 att_dims[0] = 9;
526 HSpace space_id;
527 space_id.createSimple(1,att_dims);
528 Integer dim_val[9];
529
530 dim_val[0] = nb_dimension;
531 dim_val[1] = dim1_size;
532 dim_val[2] = dim2_size;
533 dim_val[3] = nb_element;
534 dim_val[4] = nb_base_element;
535 dim_val[5] = dimension_array_size;
536 dim_val[6] = is_multi_size ? 1 : 0;
537 dim_val[7] = (Integer)sdata->baseDataType();
538 dim_val[8] = sdata->memorySize();
539
540 HAttribute att_id;
541
542 att_id.create(group_id,"Dims",m_types.saveType(dim1_size),space_id);
543 herr_t herr = att_id.write(m_types.nativeType(dim2_size),dim_val);
544 if (herr<0){
545 OStringStream ostr;
546 ostr() << "Bad writing of the dimensions for the variable '" << var_group_name << "'";
547 throw ReaderWriterException(func_name,ostr.str());
548 }
549 }
550#endif
551
552#if 0
553 // Si la variable est de type tableau à deux dimensions, sauve les
554 // tailles de la deuxième dimension par élément.
555 if (dimension_array_size!=0){
556 hsize_t att_dims[1];
557 att_dims[0] = dimension_array_size;
558 HSpace space_id;
559 HDataset array_id;
560
561 space_id.createSimple(1,att_dims);
562
563 array_id.create(group_id,"Dim2",m_types.saveType(dim1_size),space_id,H5P_DEFAULT);
564 herr_t herr = array_id.write(m_types.nativeType(dim1_size),dimensions.begin());
565 if (herr<0){
566 OStringStream ostr;
567 ostr() << "Bad writing of the dimensions for the variable '" << var_group_name << "'";
568 throw ReaderWriterException(func_name,ostr.str());
569 }
570 }
571#endif
572
573 //IParallelMng* pm = m_parallel_mng;
574 //Integer nb_rank = pm->commSize();
575
576 // Maintenant, sauve les valeurs si necessaire
577 if (nb_base_element!=0 && ptr!=0){
578 debug(Trace::High) << "Variable " << var_group_name << " begin dumped (nb_base_element=" << nb_base_element << ").";
579
580 hsize_t offset[1];
581 hsize_t count[1];
582 offset[0] = 0;
583 count[0] = nb_element_to_write;
584
585 //Int64UniqueArray all_sizes(nb_rank);
586 //Int64 my_size = nb_base_element;
587 //Int64ConstArrayView a_my_size(1,&my_size);
588 //double v1 = MPI_Wtime();
589 //pm->allGather(a_my_size,all_sizes);
590 //info() << " CLOCK GATHER = " << (MPI_Wtime() - v1);
591
592 //Int64 total_size = 0;
593 //for( Integer i=0; i<nb_rank; ++i )
594 //total_size += all_sizes[i];
595 //Int64 my_index = 0;
596 // for( Integer i=0; i<m_my_rank; ++i )
597 //my_index += all_sizes[i];
598 //my_index -= nb_base_element;
599 Int64 my_index = offset_info->second.m_offset;
600 Int64 total_size = offset_info->second.m_total_size;
601 offset[0] = my_index;
602
603 double v1 = MPI_Wtime();
604 hsize_t dims[1];
605 dims[0] = total_size;
606 HSpace filespace_id;
607 filespace_id.createSimple(1,dims);
608 HSpace memspace_id;
609 memspace_id.createSimple(1,count);
610 if (memspace_id.isBad()){
611 OStringStream ostr;
612 ostr() << "Wrong dataspace for variable '" << var_group_name << "'";
613 throw ReaderWriterException(func_name,ostr.str());
614 }
615
616
617 HDataset dataset_id;
618
619 //hid_t plist_id = H5P_DEFAULT;
620 hid_t write_plist_id = H5Pcreate(H5P_DATASET_XFER);
621#ifdef H5_HAVE_PARALLEL
622 H5Pset_dxpl_mpio(write_plist_id, H5FD_MPIO_COLLECTIVE);
623#endif
624 //H5Pset_dxpl_mpio(write_plist_id, H5FD_MPIO_INDEPENDENT);
625
626 hid_t create_dataset_plist_id = H5P_DEFAULT;
627#if 0
628 Integer chunk_size = (4096 << 9);
629 if (total_size>chunk_size){
630 create_dataset_plist_id = H5Pcreate(H5P_DATASET_CREATE);
631 H5Pcreate(H5P_DATASET_CREATE);
632 hsize_t chunk_dim[1];
633 chunk_dim[0] = chunk_size;
634 herr_t r = H5Pset_chunk(create_dataset_plist_id,1,chunk_dim);
635 info() << " SET CHUNK FOR " << var_group_name << " total=" << total_size << " chunk=" << chunk_dim[0];
636 }
637#endif
638
639 //dataset_id.create(group_id,"Values",save_typeid,filespace_id,plist_id);
640 v1 = MPI_Wtime();
641 dataset_id.create(m_variable_group_id,var_group_name,save_typeid,filespace_id,create_dataset_plist_id);
642 if (dataset_id.isBad()){
643 OStringStream ostr;
644 ostr() << "Wrong dataset for variable '" << var_group_name << "'";
645 throw ReaderWriterException(func_name,ostr.str());
646 }
647 H5Sselect_hyperslab(filespace_id.id(), H5S_SELECT_SET, offset, NULL, count, NULL);
648
649
650 v1 = MPI_Wtime();
651 {
652 Timer::Sentry ts(&m_write_timer);
653 herr_t herr = dataset_id.write(trueid,ptr,memspace_id,filespace_id,write_plist_id);
654 if (herr<0){
655 OStringStream ostr;
656 ostr() << "Wrong dataset written for variable '" << var_group_name << "'";
657 throw ReaderWriterException(func_name,ostr.str());
658 }
659 }
660 if (create_dataset_plist_id!=H5P_DEFAULT)
661 H5Pclose(create_dataset_plist_id);
662 H5Pclose(write_plist_id);
663
664 info() << " WRITE DATASET name=" << var_group_name
665 << " offset=" << offset[0]
666 << " mysize=" << nb_base_element
667 << " write_size=" << count[0]
668 << " total=" << total_size
669 << " rank=" << m_my_rank
670 << " clock=" << (MPI_Wtime() - v1);
671
672 //pinfo() << " CLOCK WRITE = " << << " CPU=" << m_my_rank;
673 //pm->barrier();
674 //info() << " CLOCK BARRIER = " << (MPI_Wtime() - v1);
675
676 dataset_id.close();
677 }
678 info() << "TOTAL = " << (MPI_Wtime()-v0);
679}
680
681/*---------------------------------------------------------------------------*/
682/*---------------------------------------------------------------------------*/
683
684Ref<ISerializedData> Hdf5MpiReaderWriter::
685_readDim2(IVariable* var)
686{
687 const char* func_name = "Hdf5MpiReaderWriter::_readDim2()";
688
689 const int max_dim = 256; // Nombre maxi de dimensions des tableaux HDF
690
691 String vname = _variableGroupName(var);
692
693 info() << " READ DIM name=" << vname;
694
695 Integer dimension_array_size = 0;
696 Integer nb_element = 0;
697 Integer nb_dimension = -1;
698 // Regarde si le nom correspondant est dans la liste des variables.
699 // S'il n'y est pas, cela signifie que le tableau n'a pas été sauvé et
700 // donc que ses dimensions sont nulles.
701 {
702 bool is_found = false;
703 for( StringList::Enumerator i(m_variables_name); ++i; )
704 if (*i==vname){
705 is_found = true;
706 break;
707 }
708 if (!is_found){
709 OStringStream ostr;
710 ostr() << "No HDF5 group with name '" << vname << "' exists";
711 throw ReaderWriterException(func_name,ostr.str());
712 }
713 }
714
715 // Récupère le groupe contenant les informations de la variable
716 HGroup group_id;
717 //group_id.open(m_variable_group_id,vname);
718 group_id.open(m_sub_group_id,vname);
719 if (group_id.isBad()){
720 OStringStream ostr;
721 ostr() << "No HDF5 with name '" << vname << "' exists";
722 throw ReaderWriterException(func_name,ostr.str());
723 }
724 bool is_multi_size = false;
725 eDataType data_type = DT_Unknown;
726 Integer memory_size = 0;
727 Integer nb_base_element = 0;
728 Integer dim1_size = 0;
729 Integer dim2_size = 0;
730 Int64UniqueArray dims;
731 // Récupère les informations concernant les tailles et dimensions de la variable
732 {
733 HAttribute att_id;
734 att_id.open(group_id,"Dims");
735 HSpace space_id = att_id.getSpace();
736
737 // On attend une seule dimension, et le nombre d'eléments de
738 // l'attribut (hdf_dims[0]) doit être égal à 1 ou 2.
739 hsize_t hdf_dims[max_dim];
740 hsize_t max_dims[max_dim];
741 H5Sget_simple_extent_dims(space_id.id(),hdf_dims,max_dims);
742
743 Integer dim_val[9];
744 //herr_t herr = H5Aread(att_id,nativeType(Integer()),dim_val);
745 att_id.read(m_types.nativeType(Integer()),dim_val);
746 if (hdf_dims[0]!=9){
747 OStringStream ostr;
748 ostr() << "Wrong dimensions for variable '" << vname
749 << "' (found: " << (int)hdf_dims[0] << " expected 9)";
750 throw ReaderWriterException(func_name,ostr.str());
751 }
752 nb_dimension = dim_val[0];
753 dim1_size = dim_val[1];
754 dim2_size = dim_val[2];
755 nb_element = dim_val[3];
756 nb_base_element = dim_val[4];
757 dimension_array_size = dim_val[5];
758 is_multi_size = dim_val[6]!=0;
759 data_type = (eDataType)dim_val[7];
760 memory_size = dim_val[8];
761 }
762
763 info() << " READ DIM name=" << vname
764 << " nb_dim=" << nb_dimension << " dim1_size=" << dim1_size
765 << " dim2_size=" << dim2_size << " nb_element=" << nb_element
766 << " dimension_size=" << dimension_array_size
767 << " is_multi_size=" << is_multi_size
768 << " data_type" << data_type;
769
770 if (dimension_array_size>0){
771 HDataset array_id;
772 array_id.open(group_id,"Dim2");
773 //hid_t array_id = H5Dopen(group_id.id(),"Dim2");
774 if (array_id.isBad()){
775 OStringStream ostr;
776 ostr() << "Wrong dataset for variable '" << vname << "'";
777 throw ReaderWriterException(func_name,ostr.str());
778 }
779 HSpace space_id = array_id.getSpace();
780 if (space_id.isBad()){
781 OStringStream ostr;
782 ostr() << "Wrong dataspace for variable '" << vname << "'";
783 throw ReaderWriterException(func_name,ostr.str());
784 }
785 hsize_t hdf_dims[max_dim];
786 hsize_t max_dims[max_dim];
787 H5Sget_simple_extent_dims(space_id.id(),hdf_dims,max_dims);
788 // Vérifie que le nombre d'éléments du dataset est bien égal à celui
789 // attendu.
790 if ((Integer)hdf_dims[0]!=dimension_array_size){
791 OStringStream ostr;
792 ostr() << "Wrong number of elements in 'Dim2' for variable '"
793 << vname << "' (found: " << hdf_dims[0]
794 << " expected " << dimension_array_size << ")";
795 throw ReaderWriterException(func_name,ostr.str());
796 }
797 dim2_size = 0;
798 dims.resize(dimension_array_size);
799 herr_t herr = array_id.read(m_types.nativeType(Integer()),dims.data());
800 if (herr<0){
801 OStringStream ostr;
802 ostr() << "Wrong dataset read for variable '" << vname << "'";
803 throw ReaderWriterException(func_name,ostr.str());
804 }
805 }
806
807 Ref<ISerializedData> sdata = arcaneCreateSerializedDataRef(data_type,memory_size,nb_dimension,nb_element,
808 nb_base_element,is_multi_size,dims);
809 return sdata;
810}
811
812/*---------------------------------------------------------------------------*/
813/*---------------------------------------------------------------------------*/
814
815/*---------------------------------------------------------------------------*/
816/*---------------------------------------------------------------------------*/
817
818void Hdf5MpiReaderWriter::
819write(IVariable* v,IData* data)
820{
821 if (v->itemKind()==IK_Unknown)
822 return;
823 //if (v->dataType()==DT_Real3)
824 //return;
825 _directWriteVal(v,data);
826}
827
828/*---------------------------------------------------------------------------*/
829/*---------------------------------------------------------------------------*/
830
831void Hdf5MpiReaderWriter::
832_readVal(IVariable* v,IData* data)
833{
834 const char* func_name = "Hdf5MpiReaderWriter::_readVal() ";
835
836 String var_group_name = _variableGroupName(v);
837
838 info() << " TRY TO READ var_group=" << var_group_name;
839
840 Ref<ISerializedData> sd(_readDim2(v));
841 Int64 storage_size = sd->memorySize();
842 //ByteUniqueArray byte_values(storage_size);
843 info() << " READ DATA n=" << storage_size;
844
845 data->allocateBufferForSerializedData(sd.get());
846
847 //bool no_dump = v.property() & IVariable::PNoDump;
848 // Lit toujours, car le fait de sauver ou non se fait en amont
849 //bool no_dump = false;
850 if (storage_size!=0){
851 // Récupère le groupe contenant les informations de la variable
852 HGroup group_id;
853 //group_id.open(m_variable_group_id,var_group_name);
854 group_id.open(m_sub_group_id,var_group_name);
855 if (group_id.isBad()){
856 OStringStream ostr;
857 ostr() << "No HDF5 group with name '" << var_group_name << "' exists";
858 throw ReaderWriterException(func_name,ostr.str());
859 }
860
861 HDataset dataset_id;
862 dataset_id.open(group_id,"Values");
863 if (dataset_id.isBad()){
864 OStringStream ostr;
865 ostr() << "Wrong dataset for variable '" << var_group_name << "'";
866 throw ReaderWriterException(func_name,ostr.str());
867 }
868
869 //dataset_id.read(trueid,ptr);
870 //debug(Trace::High) << "Variable " << var_group_name << " readed (nb_element=" << nb_element << ").";
871 void* ptr = sd->writableBytes().data();
872 info() << "READ Variable " << var_group_name << " ptr=" << ptr;;
873 hid_t trueid = m_types.nativeType(sd->baseDataType());
874 dataset_id.read(trueid,ptr);
875 }
876
877 data->assignSerializedData(sd.get());
878}
879
880/*---------------------------------------------------------------------------*/
881/*---------------------------------------------------------------------------*/
882
883void Hdf5MpiReaderWriter::
884read(IVariable* var,IData* data)
885{
886 _directReadVal(var,data);
887}
888
889/*---------------------------------------------------------------------------*/
890/*---------------------------------------------------------------------------*/
891
892void Hdf5MpiReaderWriter::
893setMetaData(const String& meta_data)
894{
895 ARCANE_UNUSED(meta_data);
896#if 0
897 if (m_is_parallel){
898 IParallelMng* pm = m_parallel_mng;
899 Integer nb_rank = pm->commSize();
900 if (m_send_rank!=m_my_rank){
901 // Envoie le groupe et les meta donnees
902 SerializeBuffer sb;
903 sb.setMode(ISerializer::ModeReserve);
904 sb.reserve(m_sub_group_name);
905 sb.reserve(meta_data);
906 sb.allocateBuffer();
907 sb.setMode(ISerializer::ModePut);
908 sb.put(m_sub_group_name);
909 sb.put(meta_data);
910 m_parallel_mng->sendSerializer(&sb,m_send_rank);
911 }
912 else{
913 _setMetaData(meta_data,m_sub_group_name);
914 for( Integer i=m_send_rank+1; i<=m_last_recv_rank; ++i ){
915 SerializeBuffer sb;
916 pm->recvSerializer(&sb,i);
917 sb.setMode(ISerializer::ModeGet);
918 String remote_group_name;
919 String remote_meta_data;
920 sb.get(remote_group_name);
921 sb.get(remote_meta_data);
922 _setMetaData(remote_meta_data,remote_group_name);
923 }
924 }
925 }
926 else
927 _setMetaData(meta_data,m_sub_group_name);
928#endif
929}
930
931/*---------------------------------------------------------------------------*/
932/*---------------------------------------------------------------------------*/
933
934void Hdf5MpiReaderWriter::
935_setMetaData(const String& meta_data,const String& sub_group_name)
936{
937 ARCANE_UNUSED(meta_data);
938 ARCANE_UNUSED(sub_group_name);
939#if 0
940 const char* func_name ="Hdf5MpiReaderWriter::setMetaData()";
941
942 HGroup base_group;
943 base_group.recursiveCreate(m_file_id,sub_group_name);
944
945 ByteConstArrayView meta_data_utf8 = meta_data.utf8();
946 const Byte* _meta_data = meta_data_utf8.begin();
947
948 hsize_t dims[1];
949 dims[0] = meta_data_utf8.size() + 1;
950 HSpace space_id;
951 space_id.createSimple(1,dims);
952 if (space_id.isBad())
953 throw ReaderWriterException(func_name,"Bad 'space' for the meta-data ('MetaData')");
954
955 HDataset dataset_id;
956 dataset_id.create(base_group,"MetaData",m_types.nativeType(Byte()),space_id,H5P_DEFAULT);
957 if (dataset_id.isBad())
958 throw ReaderWriterException(func_name,"Bad 'dataset' for the meta-data ('MetaData')");
959
960 herr_t herr = dataset_id.write(m_types.nativeType(Byte()),_meta_data);
961 if (herr<0)
962 throw ReaderWriterException(func_name,"Can't write the meta-data ('MetaData')");
963#endif
964}
965
966/*---------------------------------------------------------------------------*/
967/*---------------------------------------------------------------------------*/
968
969String Hdf5MpiReaderWriter::
970metaData()
971{
972 const char* func_name ="Hdf5MpiReaderWriter::readMetaData()";
973 HDataset dataset_id;
974 dataset_id.open(m_sub_group_id,"MetaData");
975 if (dataset_id.isBad()){
976 throw ReaderWriterException(func_name,"Wrong dataset for meta-data ('MetaData')");
977 }
978 HSpace space_id = dataset_id.getSpace();
979 if (space_id.isBad()){
980 throw ReaderWriterException(func_name,"Wrong space for meta-data ('MetaData')");
981 }
982 const int max_dim = 256;
983 hsize_t hdf_dims[max_dim];
984 hsize_t max_dims[max_dim];
985 H5Sget_simple_extent_dims(space_id.id(),hdf_dims,max_dims);
986 if (hdf_dims[0]<=0)
987 throw ReaderWriterException(func_name,"Wrong number of elements for meta-data ('MetaData')");
988 Integer nb_byte = static_cast<Integer>(hdf_dims[0]);
989 ByteUniqueArray uchars(nb_byte);
990 dataset_id.read(m_types.nativeType(Byte()),uchars.data());
991 String s(uchars);
992 return s;
993}
994
995/*---------------------------------------------------------------------------*/
996/*---------------------------------------------------------------------------*/
997
998void Hdf5MpiReaderWriter::
999endWrite()
1000{
1001#if 0
1002 if (m_is_parallel){
1003 if (m_my_rank==m_send_rank){
1004 _receiveRemoteVariables();
1005 }
1006 else{
1007 // Envoie un message de fin
1008 SerializeBuffer sb;
1009 sb.setMode(ISerializer::ModeReserve);
1010 sb.reserve(DT_Int32,1); // Pour indiquer la fin des envoies
1011 sb.allocateBuffer();
1012 sb.setMode(ISerializer::ModePut);
1013 sb.putInt32(0); // Indique qu'il s'agit d'un message de fin
1014 m_parallel_mng->sendSerializer(&sb,m_send_rank);
1015 }
1016 }
1017#endif
1018 {
1019 info() << " Hdf5Timer: nb_activated=" << m_io_timer.nbActivated()
1020 << " time=" << m_io_timer.totalTime()
1021 << " write=" << m_write_timer.nbActivated()
1022 << " timewrite=" << m_write_timer.totalTime();
1023 }
1024}
1025
1026/*---------------------------------------------------------------------------*/
1027/*---------------------------------------------------------------------------*/
1028
1029void Hdf5MpiReaderWriter::
1030_receiveRemoteVariables()
1031{
1032 IParallelMng* pm = m_parallel_mng;
1033 Integer nb_remaining = m_last_recv_rank - m_send_rank;
1034 info() << "NB REMAINING = " << nb_remaining;
1035 Ref<ISerializeMessageList> m_messages(pm->createSerializeMessageListRef());
1036
1037 while(nb_remaining>0){
1038 ISerializeMessage* sm = new SerializeMessage(m_my_rank,NULL_SUB_DOMAIN_ID,ISerializeMessage::MT_Recv);
1039 m_messages->addMessage(sm);
1040 m_messages->processPendingMessages();
1041 m_messages->waitMessages(Parallel::WaitAll);
1042
1043 ISerializer* sb = sm->serializer();
1044 sb->setMode(ISerializer::ModeGet);
1045 //info() << " RECEIVING BUFFER!";
1046 Int32 id = sb->getInt32();
1047 if (id==0){
1048 //info() << " LAST MESSAGE!";
1049 --nb_remaining;
1050 }
1051 else
1052 _writeRemoteVariable(sb);
1053 delete sm;
1054 }
1055}
1056
1057/*---------------------------------------------------------------------------*/
1058/*---------------------------------------------------------------------------*/
1059
1060void Hdf5MpiReaderWriter::
1061_writeRemoteVariable(ISerializer* sb)
1062{
1063 String var_name;
1064 sb->get(var_name);
1065 String group_name;
1066 sb->get(group_name);
1067 //eDataType data_type = (eDataType)sb->getInteger();
1068 //Integer dim = sb->getInteger();
1069 //info() << " REMOTE VAR = name=" << var_name << " data_type=" << data_type
1070 // << " dim=" << dim << " group=" << group_name;
1071 Ref<ISerializedData> sdata = arcaneCreateEmptySerializedDataRef();
1072 sb->setReadMode(ISerializer::ReadReplace);
1073 sdata->serialize(sb);
1074 _writeVal(var_name,group_name,sdata.get());
1075}
1076
1077/*---------------------------------------------------------------------------*/
1078/*---------------------------------------------------------------------------*/
1079
1080/*---------------------------------------------------------------------------*/
1081/*---------------------------------------------------------------------------*/
1082/*!
1083 * \brief Protection/reprise au format ArcaneHdf5.
1084 */
1085class ArcaneHdf5MpiCheckpointService2
1086: public ArcaneHdf5MpiReaderWriterObject
1087{
1088 public:
1089
1090 ArcaneHdf5MpiCheckpointService2(const ServiceBuildInfo& sbi)
1091 : ArcaneHdf5MpiReaderWriterObject(sbi), m_write_index(0), m_writer(0), m_reader(0)
1092 , m_fileset_size(0)
1093 {
1094 }
1095 virtual IDataWriter* dataWriter() { return m_writer; }
1096 virtual IDataReader* dataReader() { return m_reader; }
1097
1098 virtual void notifyBeginWrite();
1099 virtual void notifyEndWrite();
1100 virtual void notifyBeginRead();
1101 virtual void notifyEndRead();
1102 virtual void close() {}
1103 virtual String readerServiceName() const { return "ArcaneHdf5MpiCheckpointReader2"; }
1104
1105 private:
1106
1107 Integer m_write_index;
1108 Hdf5MpiReaderWriter* m_writer;
1109 Hdf5MpiReaderWriter* m_reader;
1110 Integer m_fileset_size;
1111
1112 private:
1113
1114 String _defaultFileName()
1115 {
1116 return "arcanedump.mpi.h5";
1117 }
1118 Directory _defaultDirectory()
1119 {
1120 return Directory(baseDirectoryName());
1121 }
1122 void _parseMetaData(String meta_data);
1123};
1124
1125/*---------------------------------------------------------------------------*/
1126/*---------------------------------------------------------------------------*/
1127
1128void ArcaneHdf5MpiCheckpointService2::
1129_parseMetaData(String meta_data)
1130{
1131 IIOMng* io_mng = subDomain()->ioMng();
1132 ScopedPtrT<IXmlDocumentHolder> xml_doc(io_mng->parseXmlBuffer(meta_data.utf8(),"MetaData"));
1133 XmlNode root = xml_doc->documentNode().documentElement();
1134 Integer version = root.attr("version").valueAsInteger();
1135 if (version!=1){
1136 throw ReaderWriterException("ArcaneHdf5MpiCheckpointService2::_parseMetaData","Bad version (expected 1)");
1137 }
1138 m_fileset_size = 0;
1139
1140 info() << " FileSet size=" << m_fileset_size;
1141}
1142
1143/*---------------------------------------------------------------------------*/
1144/*---------------------------------------------------------------------------*/
1145
1146void ArcaneHdf5MpiCheckpointService2::
1147notifyBeginRead()
1148{
1149 String meta_data = readerMetaData();
1150 _parseMetaData(meta_data);
1151
1152 info() << " GET META DATA READER " << readerMetaData()
1153 << " filename=" << fileName();
1154
1155 if (fileName().null()){
1156 Directory dump_dir(_defaultDirectory());
1157 //Directory dump_dir(subDomain()->exportDirectory(),"protection");
1158 //Directory dump_dir("/tmp/grospelx/");
1159 setFileName(dump_dir.file(_defaultFileName()));
1160 //setFileName(dump_dir.file("arcanedump.0.h5"));
1161 //setFileName(_defaultFileName());
1162 }
1163 info() << " READ CHECKPOINT FILENAME = " << fileName();
1164 StringBuilder sub_group;
1165 //sub_group = "SubDomain";
1166 //sub_group += subDomain()->subDomainId();
1167 //sub_group += "/Index";
1168 //sub_group += currentIndex();
1169 sub_group = "Index";
1170 sub_group += currentIndex();
1171 m_reader = new Hdf5MpiReaderWriter(subDomain(),fileName(),sub_group.toString(),0,Hdf5MpiReaderWriter::OpenModeRead);
1172 m_reader->initialize();
1173}
1174
1175/*---------------------------------------------------------------------------*/
1176/*---------------------------------------------------------------------------*/
1177
1178void ArcaneHdf5MpiCheckpointService2::
1179notifyEndRead()
1180{
1181 delete m_reader;
1182 m_reader = 0;
1183}
1184
1185/*---------------------------------------------------------------------------*/
1186/*---------------------------------------------------------------------------*/
1187
1188void ArcaneHdf5MpiCheckpointService2::
1189notifyBeginWrite()
1190{
1191 if (options())
1192 m_fileset_size = options()->filesetSize();
1193
1194 if (fileName().null()){
1195 Directory dump_dir(_defaultDirectory());
1196 //info() << "USE TMP DIRECTORY\n";
1197 //Directory dump_dir("/tmp/grospelx/");
1198 //dump_dir.createDirectory();
1199 setFileName(dump_dir.file(_defaultFileName()));
1200 //setFileName(_defaultFileName());
1201 }
1202 Hdf5MpiReaderWriter::eOpenMode open_mode = Hdf5MpiReaderWriter::OpenModeAppend;
1203 Integer write_index = checkpointTimes().size();
1204 --write_index;
1205 if (write_index==0)
1206 open_mode = Hdf5MpiReaderWriter::OpenModeTruncate;
1207
1208 //IParallelMng* pm = subDomain()->parallelMng();
1209 //Integer sid = pm->commRank();
1210
1211 StringBuilder sub_group;
1212 //sub_group = "SubDomain";
1213 //sub_group += sid;
1214 //sub_group += "/Index";
1215 //sub_group += write_index;
1216
1217 sub_group = "Index";
1218 sub_group += write_index;
1219
1220 m_writer = new Hdf5MpiReaderWriter(subDomain(),fileName(),sub_group.toString(),m_fileset_size,open_mode);
1221 m_writer->initialize();
1222}
1223
1224/*---------------------------------------------------------------------------*/
1225/*---------------------------------------------------------------------------*/
1226
1227void ArcaneHdf5MpiCheckpointService2::
1228notifyEndWrite()
1229{
1230 OStringStream ostr;
1231 ostr() << "<infos version='1'>\n";
1232 ostr() << " <fileset-size>" << m_fileset_size << "</fileset-size>\n";
1233 ostr() << "</infos>\n";
1234 setReaderMetaData(ostr.str());
1235 ++m_write_index;
1236 delete m_writer;
1237 m_writer = 0;
1238}
1239
1240/*---------------------------------------------------------------------------*/
1241/*---------------------------------------------------------------------------*/
1242
1243ARCANE_REGISTER_SUB_DOMAIN_FACTORY(ArcaneHdf5MpiCheckpointService2,
1244 ICheckpointReader,
1245 ArcaneHdf5MpiCheckpointReader2);
1246
1247ARCANE_REGISTER_SUB_DOMAIN_FACTORY(ArcaneHdf5MpiCheckpointService2,
1248 ICheckpointWriter,
1249 ArcaneHdf5MpiCheckpointWriter2);
1250
1251ARCANE_REGISTER_SERVICE_HDF5MPIREADERWRITER(ArcaneHdf5MpiCheckpoint2,
1252 ArcaneHdf5MpiCheckpointService2);
1253
1254/*---------------------------------------------------------------------------*/
1255/*---------------------------------------------------------------------------*/
1256
1257} // End namespace Arcane
1258
1259/*---------------------------------------------------------------------------*/
1260/*---------------------------------------------------------------------------*/
1261
1262#endif
ARCANE_REGISTER_SUB_DOMAIN_FACTORY
#define ARCANE_REGISTER_SUB_DOMAIN_FACTORY(aclass, ainterface, aname)
Enregistre un service de fabrique pour la classe aclass.
Definition ServiceFactory.h:586
Arcane::ISubDomain
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::Timer
Gestion d'un timer.
Definition Timer.h:62
Arcane::Hdf5Utils
Fonctions utilitaires pour Hdf5.
Definition Hdf5Utils.cc:34
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AbstractCaseDocumentVisitor.cc:20
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::Real3x3UniqueArray
UniqueArray< Real3x3 > Real3x3UniqueArray
Tableau dynamique à une dimension de tenseurs de rang 3.
Definition UtilsTypes.h:367
Arcane::Int64UniqueArray
UniqueArray< Int64 > Int64UniqueArray
Tableau dynamique à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:339
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:281
Arcane::Real3UniqueArray
UniqueArray< Real3 > Real3UniqueArray
Tableau dynamique à une dimension de vecteurs de rang 3.
Definition UtilsTypes.h:363
Arcane::Int64ConstArrayView
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:480
Arcane::ByteUniqueArray
UniqueArray< Byte > ByteUniqueArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:335
Arcane::Int32UniqueArray
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:341
Arcane::RealUniqueArray
UniqueArray< Real > RealUniqueArray
Tableau dynamique à une dimension de réels.
Definition UtilsTypes.h:349
Arcane::arcaneCreateEmptySerializedDataRef
Ref< ISerializedData > arcaneCreateEmptySerializedDataRef()
Créé des données sérialisées.
Definition SerializedData.cc:426
Arcane::ByteConstArrayView
ConstArrayView< Byte > ByteConstArrayView
Equivalent C d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:476
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::DT_Real3x3
@ DT_Real3x3
Donnée de type tenseur 3x3.
Definition DataTypes.h:49
Arcane::DT_Int32
@ DT_Int32
Donnée de type entier 32 bits.
Definition DataTypes.h:43
Arcane::DT_Real3
@ DT_Real3
Donnée de type vecteur 3.
Definition DataTypes.h:47
Arcane::DT_Unknown
@ DT_Unknown
Donnée de type inconnue ou non initialisée.
Definition DataTypes.h:56
Arcane::DT_Real
@ DT_Real
Donnée de type réel.
Definition DataTypes.h:41
Arcane::dataTypeName
const char * dataTypeName(eDataType type)
Nom du type de donnée.
Definition DataTypes.cc:70