Arcane  4.1.12.0
User documentation
Loading...
Searching...
No Matches
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/* HDF5 format Reading/Writing. */
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// For now (1.8.0 beta 2), this does not work on 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 // If I am not the one writing, do not open the file
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 if (m_open_mode == OpenModeRead) {
266 int index = 0;
267 //H5Giterate(m_sub_group_id.id(),"Variables",&index,_Hdf5MpiReaderWriterIterateMe,this);
268 H5Giterate(m_file_id.id(), m_sub_group_name.localstr(), &index, _Hdf5MpiReaderWriterIterateMe, this);
269 }
270}
271
272/*---------------------------------------------------------------------------*/
273/*---------------------------------------------------------------------------*/
274
275Hdf5MpiReaderWriter::
276~Hdf5MpiReaderWriter()
277{
278}
279
280/*---------------------------------------------------------------------------*/
281/*---------------------------------------------------------------------------*/
282
283void Hdf5MpiReaderWriter::
284_checkValid()
285{
286 if (m_is_initialized)
287 return;
288 fatal() << "Use of a Hdf5MpiReaderWriter instance not initialized";
289}
290
291/*---------------------------------------------------------------------------*/
292/*---------------------------------------------------------------------------*/
293
294String Hdf5MpiReaderWriter::
295_variableGroupName(IVariable* var)
296{
297 return var->fullName();
298}
299
300/*---------------------------------------------------------------------------*/
301/*---------------------------------------------------------------------------*/
302
303void Hdf5MpiReaderWriter::
304beginWrite(const VariableCollection& vars)
305{
306 IParallelMng* pm = m_parallel_mng;
307 Integer nb_rank = pm->commSize();
308
309 pwarning() << "Implementation of this checkpoint format is not operational yet";
310
311 for (VariableCollection::Enumerator i(vars); ++i;) {
312 IVariable* v = *i;
313 if (v->itemKind() == IK_Unknown)
314 continue;
315
316 Ref<ISerializedData> sdata(v->data()->createSerializedDataRef(false));
317 Int64 nb_base_element = sdata->nbBaseElement();
318
319 Int64 my_size = nb_base_element;
320 Int64ConstArrayView a_my_size(1, &my_size);
321 SharedArray<Int64> all_sizes(nb_rank);
322 pm->allGather(a_my_size, all_sizes);
323
324 Int64 total_size = 0;
325 for (Integer i = 0; i < nb_rank; ++i)
326 total_size += all_sizes[i];
327 Int64 my_index = 0;
328 for (Integer i = 0; i < m_my_rank; ++i)
329 my_index += all_sizes[i];
330 m_variables_offset.insert(std::make_pair(v->fullName(), VarOffset(my_index, total_size, all_sizes)));
331 info() << " ADD OFFSET v=" << v->fullName() << " offset=" << my_index
332 << " total_size=" << total_size;
333 }
334}
335
336/*---------------------------------------------------------------------------*/
337/*---------------------------------------------------------------------------*/
338/*!
339 * \brief Parallel writing.
340 *
341 * \warning Under test, not usable.
342 */
343void Hdf5MpiReaderWriter::
344_writeValParallel(IVariable* v, const ISerializedData* sdata)
345{
346 SerializeBuffer sb;
347 sb.setMode(ISerializer::ModeReserve);
348 sb.reserve(DT_Int32, 1); // To indicate the end of sends
349 sb.reserve(v->fullName());
350 sb.reserve(m_sub_group_name); //!< Group name.
351 //sb.reserveInteger(1); // For data type
352 //sb.reserveInteger(1); // For dimension
353 //v->serialize(&sb,0);
354 sdata->serialize(&sb);
355 sb.allocateBuffer();
356 sb.setMode(ISerializer::ModePut);
357 sb.putInt32(1); // Indicates a non-empty message
358 sb.put(v->fullName());
359 sb.put(m_sub_group_name); //!< Group name.
360 //sb.putInteger(v->dataType()); // For data type
361 //sb.putInteger(v->dimension()); // For dimension
362 //v->serialize(&sb,0);
363 sdata->serialize(&sb);
364
365 m_parallel_mng->sendSerializer(&sb, m_send_rank);
366}
367
368/*---------------------------------------------------------------------------*/
369/*---------------------------------------------------------------------------*/
370
371void Hdf5MpiReaderWriter::
372_directReadVal(IVariable* v, IData* data)
373{
374 _checkValid();
375
376 info() << "DIRECT READ VAL v=" << v->name();
377 _readVal(v, data);
378}
379
380/*---------------------------------------------------------------------------*/
381/*---------------------------------------------------------------------------*/
382
383void Hdf5MpiReaderWriter::
384_directWriteVal(IVariable* v, IData* data)
385{
386 _checkValid();
387
388 Ref<ISerializedData> sdata(data->createSerializedDataRef(false));
389
390 _writeVal(v->fullName(), m_sub_group_name, sdata.get());
391}
392
393/*---------------------------------------------------------------------------*/
394/*---------------------------------------------------------------------------*/
395
396static herr_t
397_Hdf5MpiReaderWriterIterateMe(hid_t g, const char* mn, void* ptr)
398{
399 Hdf5MpiReaderWriter* rw = reinterpret_cast<Hdf5MpiReaderWriter*>(ptr);
400 return rw->iterateMe(g, mn);
401}
402
403/*---------------------------------------------------------------------------*/
404/*---------------------------------------------------------------------------*/
405
406herr_t Hdf5MpiReaderWriter::
407iterateMe(hid_t group_id, const char* member_name)
408{
409 ARCANE_UNUSED(group_id);
410
411 m_variables_name.add(std::string_view(member_name));
412 return 0;
413}
414
415/*---------------------------------------------------------------------------*/
416/*---------------------------------------------------------------------------*/
417/*!
418 */
419void Hdf5MpiReaderWriter::
420_writeVal(const String& var_group_name, const String& sub_group_name,
421 const ISerializedData* sdata)
422{
423 ARCANE_UNUSED(sub_group_name);
424 const char* func_name = "Hdf5MpiReaderWriter::_writeVal() ";
425 Timer::Sentry ts(&m_io_timer);
426 double v0 = ::MPI_Wtime();
427 info() << " SDATA name=" << var_group_name << " nb_element=" << sdata->nbElement()
428 << " dim=" << sdata->nbDimension() << " datatype=" << sdata->baseDataType()
429 << " nb_basic_element=" << sdata->nbBaseElement()
430 << " is_multi=" << sdata->isMultiSize()
431 << " dimensions_size=" << sdata->extents().size()
432 << " memory_size=" << sdata->memorySize()
433 << " bytes_size=" << sdata->constBytes().size();
434
435 hid_t save_typeid = m_types.saveType(sdata->baseDataType());
436 hid_t trueid = m_types.nativeType(sdata->baseDataType());
437 const void* ptr = sdata->constBytes().data();
438 Int64 nb_base_element = sdata->nbBaseElement();
439
440 OffsetMap::const_iterator offset_info = m_variables_offset.find(var_group_name);
441 if (offset_info == m_variables_offset.end()) {
442 fatal() << "Can not find offset informations for ->" << var_group_name;
443 }
444 Int64 nb_element_to_write = nb_base_element;
445
446 //String var_group_name = _variableGroupName(v);
447 RealUniqueArray real_array;
448 Real3UniqueArray real3_array;
449 Real3x3UniqueArray real3x3_array;
450 Int32UniqueArray int32_array;
451 if (m_is_parallel && m_fileset_size != 1) {
452 if (m_send_rank == m_my_rank) {
453 // I receive the values from others
454 nb_element_to_write = 0;
455 for (Integer i = m_send_rank; i <= m_last_recv_rank; ++i) {
456 nb_element_to_write += offset_info->second.m_all_sizes[i];
457 //info() << "ADD TO WRITE n=" << nb_element_to_write << " add=" << offset_info->second.m_all_sizes[i];
458 }
459 switch (sdata->baseDataType()) {
460 case DT_Real:
461 real_array.resize(nb_element_to_write);
462 ptr = real_array.data();
463 break;
464 case DT_Real3:
465 real3_array.resize(nb_element_to_write);
466 ptr = real3_array.data();
467 break;
468 case DT_Real3x3:
469 real3x3_array.resize(nb_element_to_write);
470 ptr = real3x3_array.data();
471 break;
472 case DT_Int32:
473 int32_array.resize(nb_element_to_write);
474 ptr = int32_array.data();
475 break;
476 default:
477 fatal() << "Type not handled " << dataTypeName(sdata->baseDataType());
478 }
479 }
480 else {
481 return;
482 // I send to my reference
483 //switch(sdata->baseDataType()){
484 //case DT_Real:
485 //_send(sdata,Real());
486 // break;
487 //}
488 }
489 }
490
491#if 0
492 HGroup var_base_group;
493 var_base_group.recursiveCreate(m_file_id,sub_group_name);
494
495 // Creation of the group containing the variable information
496 HGroup group_id;
497 //group_id.create(m_variable_group_id,var_group_name);
498 group_id.create(var_base_group,var_group_name);
499 if (group_id.isBad()){
500 OStringStream ostr;
501 ostr() << "Group HDF5 '" << var_group_name << "' not found";
502 throw ReaderWriterException(func_name,ostr.str());
503 }
504#endif
505
506 //Integer dim2 = dim2_array.size();
507 //Integer nb_element = sdata->nbElement();
508#if 0
509 bool is_multi_size = sdata->isMultiSize();
510 Integer dim2_size = 0;
511 Integer dim1_size = 0;
512 if (nb_dimension==2 && !is_multi_size){
513 dim1_size = dimensions[0];
514 dim2_size = dimensions[1];
515 }
516#endif
517 //Integer dimension_array_size = dimensions.size();
518
519#if 0
520 // Save the information concerning the sizes and dimensions of the variable
521 {
522 hsize_t att_dims[1];
523 att_dims[0] = 9;
524 HSpace space_id;
525 space_id.createSimple(1,att_dims);
526 Integer dim_val[9];
527
528 dim_val[0] = nb_dimension;
529 dim_val[1] = dim1_size;
530 dim_val[2] = dim2_size;
531 dim_val[3] = nb_element;
532 dim_val[4] = nb_base_element;
533 dim_val[5] = dimension_array_size;
534 dim_val[6] = is_multi_size ? 1 : 0;
535 dim_val[7] = (Integer)sdata->baseDataType();
536 dim_val[8] = sdata->memorySize();
537
538 HAttribute att_id;
539
540 att_id.create(group_id,"Dims",m_types.saveType(dim1_size),space_id);
541 herr_t herr = att_id.write(m_types.nativeType(dim2_size),dim_val);
542 if (herr<0){
543 OStringStream ostr;
544 ostr() << "Bad writing of the dimensions for the variable '" << var_group_name << "'";
545 throw ReaderWriterException(func_name,ostr.str());
546 }
547 }
548#endif
549
550#if 0
551 // If the variable is a two-dimensional array type, save the
552 // sizes of the second dimension per element.
553 if (dimension_array_size!=0){
554 hsize_t att_dims[1];
555 att_dims[0] = dimension_array_size;
556 HSpace space_id;
557 HDataset array_id;
558
559 space_id.createSimple(1,att_dims);
560
561 array_id.create(group_id,"Dim2",m_types.saveType(dim1_size),space_id,H5P_DEFAULT);
562 herr_t herr = array_id.write(m_types.nativeType(dim1_size),dimensions.begin());
563 if (herr<0){
564 OStringStream ostr;
565 ostr() << "Bad writing of the dimensions for the variable '" << var_group_name << "'";
566 throw ReaderWriterException(func_name,ostr.str());
567 }
568 }
569#endif
570
571 //IParallelMng* pm = m_parallel_mng;
572 //Integer nb_rank = pm->commSize();
573
574 // Now, save the values if necessary
575 if (nb_base_element != 0 && ptr != 0) {
576 debug(Trace::High) << "Variable " << var_group_name << " begin dumped (nb_base_element=" << nb_base_element << ").";
577
578 hsize_t offset[1];
579 hsize_t count[1];
580 offset[0] = 0;
581 count[0] = nb_element_to_write;
582
583 //Int64UniqueArray all_sizes(nb_rank);
584 //Int64 my_size = nb_base_element;
585 //Int64ConstArrayView a_my_size(1,&my_size);
586 //double v1 = MPI_Wtime();
587 //pm->allGather(a_my_size,all_sizes);
588 //info() << " CLOCK GATHER = " << (MPI_Wtime() - v1);
589
590 //Int64 total_size = 0;
591 //for( Integer i=0; i<nb_rank; ++i )
592 //total_size += all_sizes[i];
593 //Int64 my_index = 0;
594 // for( Integer i=0; i<m_my_rank; ++i )
595 //my_index += all_sizes[i];
596 //my_index -= nb_base_element;
597 Int64 my_index = offset_info->second.m_offset;
598 Int64 total_size = offset_info->second.m_total_size;
599 offset[0] = my_index;
600
601 double v1 = MPI_Wtime();
602 hsize_t dims[1];
603 dims[0] = total_size;
604 HSpace filespace_id;
605 filespace_id.createSimple(1, dims);
606 HSpace memspace_id;
607 memspace_id.createSimple(1, count);
608 if (memspace_id.isBad()) {
609 OStringStream ostr;
610 ostr() << "Wrong dataspace for variable '" << var_group_name << "'";
611 throw ReaderWriterException(func_name, ostr.str());
612 }
613
614 HDataset dataset_id;
615
616 //hid_t plist_id = H5P_DEFAULT;
617 hid_t write_plist_id = H5Pcreate(H5P_DATASET_XFER);
618#ifdef H5_HAVE_PARALLEL
619 H5Pset_dxpl_mpio(write_plist_id, H5FD_MPIO_COLLECTIVE);
620#endif
621 //H5Pset_dxpl_mpio(write_plist_id, H5FD_MPIO_INDEPENDENT);
622
623 hid_t create_dataset_plist_id = H5P_DEFAULT;
624#if 0
625 Integer chunk_size = (4096 << 9);
626 if (total_size>chunk_size){
627 create_dataset_plist_id = H5Pcreate(H5P_DATASET_CREATE);
628 H5Pcreate(H5P_DATASET_CREATE);
629 hsize_t chunk_dim[1];
630 chunk_dim[0] = chunk_size;
631 herr_t r = H5Pset_chunk(create_dataset_plist_id,1,chunk_dim);
632 info() << " SET CHUNK FOR " << var_group_name << " total=" << total_size << " chunk=" << chunk_dim[0];
633 }
634#endif
635
636 //dataset_id.create(group_id,"Values",save_typeid,filespace_id,plist_id);
637 v1 = MPI_Wtime();
638 dataset_id.create(m_variable_group_id, var_group_name, save_typeid, filespace_id, create_dataset_plist_id);
639 if (dataset_id.isBad()) {
640 OStringStream ostr;
641 ostr() << "Wrong dataset for variable '" << var_group_name << "'";
642 throw ReaderWriterException(func_name, ostr.str());
643 }
644 H5Sselect_hyperslab(filespace_id.id(), H5S_SELECT_SET, offset, NULL, count, NULL);
645
646 v1 = MPI_Wtime();
647 {
648 Timer::Sentry ts(&m_write_timer);
649 herr_t herr = dataset_id.write(trueid, ptr, memspace_id, filespace_id, write_plist_id);
650 if (herr < 0) {
651 OStringStream ostr;
652 ostr() << "Wrong dataset written for variable '" << var_group_name << "'";
653 throw ReaderWriterException(func_name, ostr.str());
654 }
655 }
656 if (create_dataset_plist_id != H5P_DEFAULT)
657 H5Pclose(create_dataset_plist_id);
658 H5Pclose(write_plist_id);
659
660 info() << " WRITE DATASET name=" << var_group_name
661 << " offset=" << offset[0]
662 << " mysize=" << nb_base_element
663 << " write_size=" << count[0]
664 << " total=" << total_size
665 << " rank=" << m_my_rank
666 << " clock=" << (MPI_Wtime() - v1);
667
668 //pinfo() << " CLOCK WRITE = " << << " CPU=" << m_my_rank;
669 //pm->barrier();
670 //info() << " CLOCK BARRIER = " << (MPI_Wtime() - v1);
671
672 dataset_id.close();
673 }
674 info() << "TOTAL = " << (MPI_Wtime() - v0);
675}
676
677/*---------------------------------------------------------------------------*/
678/*---------------------------------------------------------------------------*/
679
680Ref<ISerializedData> Hdf5MpiReaderWriter::
681_readDim2(IVariable* var)
682{
683 const char* func_name = "Hdf5MpiReaderWriter::_readDim2()";
684
685 const int max_dim = 256; // Maximum number of dimensions for HDF arrays
686
687 String vname = _variableGroupName(var);
688
689 info() << " READ DIM name=" << vname;
690
691 Integer dimension_array_size = 0;
692 Integer nb_element = 0;
693 Integer nb_dimension = -1;
694 // Checks if the corresponding name is in the list of variables.
695 // If it is not there, it means that the array was not saved and
696 // therefore its dimensions are null.
697 {
698 bool is_found = false;
699 for (StringList::Enumerator i(m_variables_name); ++i;)
700 if (*i == vname) {
701 is_found = true;
702 break;
703 }
704 if (!is_found) {
705 OStringStream ostr;
706 ostr() << "No HDF5 group with name '" << vname << "' exists";
707 throw ReaderWriterException(func_name, ostr.str());
708 }
709 }
710
711 // Retrieves the group containing the variable information
712 HGroup group_id;
713 //group_id.open(m_variable_group_id,vname);
714 group_id.open(m_sub_group_id, vname);
715 if (group_id.isBad()) {
716 OStringStream ostr;
717 ostr() << "No HDF5 with name '" << vname << "' exists";
718 throw ReaderWriterException(func_name, ostr.str());
719 }
720 bool is_multi_size = false;
721 eDataType data_type = DT_Unknown;
722 Integer memory_size = 0;
723 Integer nb_base_element = 0;
724 Integer dim1_size = 0;
725 Integer dim2_size = 0;
726 Int64UniqueArray dims;
727 // Retrieves the information concerning the sizes and dimensions of the variable
728 {
729 HAttribute att_id;
730 att_id.open(group_id, "Dims");
731 HSpace space_id = att_id.getSpace();
732
733 // We expect a single dimension, and the number of elements of
734 // the attribute (hdf_dims[0]) must be equal to 1 or 2.
735 hsize_t hdf_dims[max_dim];
736 hsize_t max_dims[max_dim];
737 H5Sget_simple_extent_dims(space_id.id(), hdf_dims, max_dims);
738
739 Integer dim_val[9];
740 //herr_t herr = H5Aread(att_id,nativeType(Integer()),dim_val);
741 att_id.read(m_types.nativeType(Integer()), dim_val);
742 if (hdf_dims[0] != 9) {
743 OStringStream ostr;
744 ostr() << "Wrong dimensions for variable '" << vname
745 << "' (found: " << (int)hdf_dims[0] << " expected 9)";
746 throw ReaderWriterException(func_name, ostr.str());
747 }
748 nb_dimension = dim_val[0];
749 dim1_size = dim_val[1];
750 dim2_size = dim_val[2];
751 nb_element = dim_val[3];
752 nb_base_element = dim_val[4];
753 dimension_array_size = dim_val[5];
754 is_multi_size = dim_val[6] != 0;
755 data_type = (eDataType)dim_val[7];
756 memory_size = dim_val[8];
757 }
758
759 info() << " READ DIM name=" << vname
760 << " nb_dim=" << nb_dimension << " dim1_size=" << dim1_size
761 << " dim2_size=" << dim2_size << " nb_element=" << nb_element
762 << " dimension_size=" << dimension_array_size
763 << " is_multi_size=" << is_multi_size
764 << " data_type" << data_type;
765
766 if (dimension_array_size > 0) {
767 HDataset array_id;
768 array_id.open(group_id, "Dim2");
769 //hid_t array_id = H5Dopen(group_id.id(),"Dim2");
770 if (array_id.isBad()) {
771 OStringStream ostr;
772 ostr() << "Wrong dataset for variable '" << vname << "'";
773 throw ReaderWriterException(func_name, ostr.str());
774 }
775 HSpace space_id = array_id.getSpace();
776 if (space_id.isBad()) {
777 OStringStream ostr;
778 ostr() << "Wrong dataspace for variable '" << vname << "'";
779 throw ReaderWriterException(func_name, ostr.str());
780 }
781 hsize_t hdf_dims[max_dim];
782 hsize_t max_dims[max_dim];
783 H5Sget_simple_extent_dims(space_id.id(), hdf_dims, max_dims);
784 // Checks that the number of elements in the dataset is equal to that
785 // expected.
786 if ((Integer)hdf_dims[0] != dimension_array_size) {
787 OStringStream ostr;
788 ostr() << "Wrong number of elements in 'Dim2' for variable '"
789 << vname << "' (found: " << hdf_dims[0]
790 << " expected " << dimension_array_size << ")";
791 throw ReaderWriterException(func_name, ostr.str());
792 }
793 dim2_size = 0;
794 dims.resize(dimension_array_size);
795 herr_t herr = array_id.read(m_types.nativeType(Integer()), dims.data());
796 if (herr < 0) {
797 OStringStream ostr;
798 ostr() << "Wrong dataset read for variable '" << vname << "'";
799 throw ReaderWriterException(func_name, ostr.str());
800 }
801 }
802
803 Ref<ISerializedData> sdata = arcaneCreateSerializedDataRef(data_type, memory_size, nb_dimension, nb_element,
804 nb_base_element, is_multi_size, dims);
805 return sdata;
806}
807
808/*---------------------------------------------------------------------------*/
809/*---------------------------------------------------------------------------*/
810
811/*---------------------------------------------------------------------------*/
812/*---------------------------------------------------------------------------*/
813
814void Hdf5MpiReaderWriter::
815write(IVariable* v, IData* data)
816{
817 if (v->itemKind() == IK_Unknown)
818 return;
819 //if (v->dataType()==DT_Real3)
820 //return;
821 _directWriteVal(v, data);
822}
823
824/*---------------------------------------------------------------------------*/
825/*---------------------------------------------------------------------------*/
826
827void Hdf5MpiReaderWriter::
828_readVal(IVariable* v, IData* data)
829{
830 const char* func_name = "Hdf5MpiReaderWriter::_readVal() ";
831
832 String var_group_name = _variableGroupName(v);
833
834 info() << " TRY TO READ var_group=" << var_group_name;
835
836 Ref<ISerializedData> sd(_readDim2(v));
837 Int64 storage_size = sd->memorySize();
838 //ByteUniqueArray byte_values(storage_size);
839 info() << " READ DATA n=" << storage_size;
840
841 data->allocateBufferForSerializedData(sd.get());
842
843 //bool no_dump = v.property() & IVariable::PNoDump;
844 // Always read, because whether or not to save is done upstream
845 //bool no_dump = false;
846 if (storage_size != 0) {
847 // Retrieves the group containing the variable information
848 HGroup group_id;
849 //group_id.open(m_variable_group_id,var_group_name);
850 group_id.open(m_sub_group_id, var_group_name);
851 if (group_id.isBad()) {
852 OStringStream ostr;
853 ostr() << "No HDF5 group with name '" << var_group_name << "' exists";
854 throw ReaderWriterException(func_name, ostr.str());
855 }
856
857 HDataset dataset_id;
858 dataset_id.open(group_id, "Values");
859 if (dataset_id.isBad()) {
860 OStringStream ostr;
861 ostr() << "Wrong dataset for variable '" << var_group_name << "'";
862 throw ReaderWriterException(func_name, ostr.str());
863 }
864
865 //dataset_id.read(trueid,ptr);
866 //debug(Trace::High) << "Variable " << var_group_name << " readed (nb_element=" << nb_element << ").";
867 void* ptr = sd->writableBytes().data();
868 info() << "READ Variable " << var_group_name << " ptr=" << ptr;
869 ;
870 hid_t trueid = m_types.nativeType(sd->baseDataType());
871 dataset_id.read(trueid, ptr);
872 }
873
874 data->assignSerializedData(sd.get());
875}
876
877/*---------------------------------------------------------------------------*/
878/*---------------------------------------------------------------------------*/
879
880void Hdf5MpiReaderWriter::
881read(IVariable* var, IData* data)
882{
883 _directReadVal(var, data);
884}
885
886/*---------------------------------------------------------------------------*/
887/*---------------------------------------------------------------------------*/
888
889void Hdf5MpiReaderWriter::
890setMetaData(const String& meta_data)
891{
892 ARCANE_UNUSED(meta_data);
893#if 0
894 if (m_is_parallel){
895 IParallelMng* pm = m_parallel_mng;
896 Integer nb_rank = pm->commSize();
897 if (m_send_rank!=m_my_rank){
898 // Sends the group and the meta data
899 SerializeBuffer sb;
900 sb.setMode(ISerializer::ModeReserve);
901 sb.reserve(m_sub_group_name);
902 sb.reserve(meta_data);
903 sb.allocateBuffer();
904 sb.setMode(ISerializer::ModePut);
905 sb.put(m_sub_group_name);
906 sb.put(meta_data);
907 m_parallel_mng->sendSerializer(&sb,m_send_rank);
908 }
909 else{
910 _setMetaData(meta_data,m_sub_group_name);
911 for( Integer i=m_send_rank+1; i<=m_last_recv_rank; ++i ){
912 SerializeBuffer sb;
913 pm->recvSerializer(&sb,i);
914 sb.setMode(ISerializer::ModeGet);
915 String remote_group_name;
916 String remote_meta_data;
917 sb.get(remote_group_name);
918 sb.get(remote_meta_data);
919 _setMetaData(remote_meta_data,remote_group_name);
920 }
921 }
922 }
923 else
924 _setMetaData(meta_data,m_sub_group_name);
925#endif
926}
927
928/*---------------------------------------------------------------------------*/
929/*---------------------------------------------------------------------------*/
930
931void Hdf5MpiReaderWriter::
932_setMetaData(const String& meta_data, const String& sub_group_name)
933{
934 ARCANE_UNUSED(meta_data);
935 ARCANE_UNUSED(sub_group_name);
936#if 0
937 const char* func_name ="Hdf5MpiReaderWriter::setMetaData()";
938
939 HGroup base_group;
940 base_group.recursiveCreate(m_file_id,sub_group_name);
941
942 ByteConstArrayView meta_data_utf8 = meta_data.utf8();
943 const Byte* _meta_data = meta_data_utf8.begin();
944
945 hsize_t dims[1];
946 dims[0] = meta_data_utf8.size() + 1;
947 HSpace space_id;
948 space_id.createSimple(1,dims);
949 if (space_id.isBad())
950 throw ReaderWriterException(func_name,"Bad 'space' for the meta-data ('MetaData')");
951
952 HDataset dataset_id;
953 dataset_id.create(base_group,"MetaData",m_types.nativeType(Byte()),space_id,H5P_DEFAULT);
954 if (dataset_id.isBad())
955 throw ReaderWriterException(func_name,"Bad 'dataset' for the meta-data ('MetaData')");
956
957 herr_t herr = dataset_id.write(m_types.nativeType(Byte()),_meta_data);
958 if (herr<0)
959 throw ReaderWriterException(func_name,"Can't write the meta-data ('MetaData')");
960#endif
961}
962
963/*---------------------------------------------------------------------------*/
964/*---------------------------------------------------------------------------*/
965
966String Hdf5MpiReaderWriter::
967metaData()
968{
969 const char* func_name = "Hdf5MpiReaderWriter::readMetaData()";
970 HDataset dataset_id;
971 dataset_id.open(m_sub_group_id, "MetaData");
972 if (dataset_id.isBad()) {
973 throw ReaderWriterException(func_name, "Wrong dataset for meta-data ('MetaData')");
974 }
975 HSpace space_id = dataset_id.getSpace();
976 if (space_id.isBad()) {
977 throw ReaderWriterException(func_name, "Wrong space for meta-data ('MetaData')");
978 }
979 const int max_dim = 256;
980 hsize_t hdf_dims[max_dim];
981 hsize_t max_dims[max_dim];
982 H5Sget_simple_extent_dims(space_id.id(), hdf_dims, max_dims);
983 if (hdf_dims[0] <= 0)
984 throw ReaderWriterException(func_name, "Wrong number of elements for meta-data ('MetaData')");
985 Integer nb_byte = static_cast<Integer>(hdf_dims[0]);
986 ByteUniqueArray uchars(nb_byte);
987 dataset_id.read(m_types.nativeType(Byte()), uchars.data());
988 String s(uchars);
989 return s;
990}
991
992/*---------------------------------------------------------------------------*/
993/*---------------------------------------------------------------------------*/
994
995void Hdf5MpiReaderWriter::
996endWrite()
997{
998#if 0
999 if (m_is_parallel){
1000 if (m_my_rank==m_send_rank){
1001 _receiveRemoteVariables();
1002 }
1003 else{
1004 // Sends an end message
1005 SerializeBuffer sb;
1006 sb.setMode(ISerializer::ModeReserve);
1007 sb.reserve(DT_Int32,1); // To indicate the end of sends
1008 sb.allocateBuffer();
1009 sb.setMode(ISerializer::ModePut);
1010 sb.putInt32(0); // Indicates it is an end message
1011 m_parallel_mng->sendSerializer(&sb,m_send_rank);
1012 }
1013 }
1014#endif
1015 {
1016 info() << " Hdf5Timer: nb_activated=" << m_io_timer.nbActivated()
1017 << " time=" << m_io_timer.totalTime()
1018 << " write=" << m_write_timer.nbActivated()
1019 << " timewrite=" << m_write_timer.totalTime();
1020 }
1021}
1022
1023/*---------------------------------------------------------------------------*/
1024/*---------------------------------------------------------------------------*/
1025
1026void Hdf5MpiReaderWriter::
1027_receiveRemoteVariables()
1028{
1029 IParallelMng* pm = m_parallel_mng;
1030 Integer nb_remaining = m_last_recv_rank - m_send_rank;
1031 info() << "NB REMAINING = " << nb_remaining;
1032 Ref<ISerializeMessageList> m_messages(pm->createSerializeMessageListRef());
1033
1034 while (nb_remaining > 0) {
1035 ISerializeMessage* sm = new SerializeMessage(m_my_rank, NULL_SUB_DOMAIN_ID, ISerializeMessage::MT_Recv);
1036 m_messages->addMessage(sm);
1037 m_messages->processPendingMessages();
1038 m_messages->waitMessages(Parallel::WaitAll);
1039
1040 ISerializer* sb = sm->serializer();
1041 sb->setMode(ISerializer::ModeGet);
1042 //info() << " RECEIVING BUFFER!";
1043 Int32 id = sb->getInt32();
1044 if (id == 0) {
1045 //info() << " LAST MESSAGE!";
1046 --nb_remaining;
1047 }
1048 else
1049 _writeRemoteVariable(sb);
1050 delete sm;
1051 }
1052}
1053
1054/*---------------------------------------------------------------------------*/
1055/*---------------------------------------------------------------------------*/
1056
1057void Hdf5MpiReaderWriter::
1058_writeRemoteVariable(ISerializer* sb)
1059{
1060 String var_name;
1061 sb->get(var_name);
1062 String group_name;
1063 sb->get(group_name);
1064 //eDataType data_type = (eDataType)sb->getInteger();
1065 //Integer dim = sb->getInteger();
1066 //info() << " REMOTE VAR = name=" << var_name << " data_type=" << data_type
1067 // << " dim=" << dim << " group=" << group_name;
1068 Ref<ISerializedData> sdata = arcaneCreateEmptySerializedDataRef();
1069 sb->setReadMode(ISerializer::ReadReplace);
1070 sdata->serialize(sb);
1071 _writeVal(var_name, group_name, sdata.get());
1072}
1073
1074/*---------------------------------------------------------------------------*/
1075/*---------------------------------------------------------------------------*/
1076
1077/*---------------------------------------------------------------------------*/
1078/*---------------------------------------------------------------------------*/
1079/*!
1080 * \brief Protection/reprise au format ArcaneHdf5.
1081 */
1082class ArcaneHdf5MpiCheckpointService2
1083: public ArcaneHdf5MpiReaderWriterObject
1084{
1085 public:
1086
1087 ArcaneHdf5MpiCheckpointService2(const ServiceBuildInfo& sbi)
1088 : ArcaneHdf5MpiReaderWriterObject(sbi)
1089 , m_write_index(0)
1090 , m_writer(0)
1091 , 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)
Registers a factory service for the class aclass.
Definition ServiceFactory.h:651
Arcane::ISubDomain
Interface of the subdomain manager.
Definition ISubDomain.h:75
Arcane::Timer
Management of a timer.
Definition Timer.h:63
Arcane::Hdf5Utils
Utility functions for Hdf5.
Definition Hdf5Utils.cc:34
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition AbstractCaseDocumentVisitor.cc:21
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)
Creates serialized data.
Definition SerializedData.cc:414
Arcane::Real3x3UniqueArray
UniqueArray< Real3x3 > Real3x3UniqueArray
Dynamic 1D array of rank 3 tensors.
Definition UtilsTypes.h:367
Arcane::Int64UniqueArray
UniqueArray< Int64 > Int64UniqueArray
Dynamic 1D array of 64-bit integers.
Definition UtilsTypes.h:339
Arcane::Integer
Int32 Integer
Type representing an integer.
Definition ArccoreGlobal.h:293
Arcane::Real3UniqueArray
UniqueArray< Real3 > Real3UniqueArray
Dynamic 1D array of rank 3 vectors.
Definition UtilsTypes.h:363
Arcane::Int64ConstArrayView
ConstArrayView< Int64 > Int64ConstArrayView
C equivalent of a 1D array of 64-bit integers.
Definition UtilsTypes.h:480
Arcane::ByteUniqueArray
UniqueArray< Byte > ByteUniqueArray
Dynamic 1D array of characters.
Definition UtilsTypes.h:335
Arcane::Int32UniqueArray
UniqueArray< Int32 > Int32UniqueArray
Dynamic 1D array of 32-bit integers.
Definition UtilsTypes.h:341
Arcane::RealUniqueArray
UniqueArray< Real > RealUniqueArray
Dynamic 1D array of reals.
Definition UtilsTypes.h:349
Arcane::arcaneCreateEmptySerializedDataRef
Ref< ISerializedData > arcaneCreateEmptySerializedDataRef()
Creates serialized data.
Definition SerializedData.cc:427
Arcane::ByteConstArrayView
ConstArrayView< Byte > ByteConstArrayView
C equivalent of a 1D array of characters.
Definition UtilsTypes.h:476
Arcane::Byte
unsigned char Byte
Type of a byte.
Definition BaseTypes.h:43
Arcane::eDataType
eDataType
Data type.
Definition DataTypes.h:41
Arcane::DT_Real3x3
@ DT_Real3x3
3x3 tensor data type
Definition DataTypes.h:51
Arcane::DT_Int32
@ DT_Int32
32-bit integer data type
Definition DataTypes.h:45
Arcane::DT_Real3
@ DT_Real3
Vector 3 data type.
Definition DataTypes.h:49
Arcane::DT_Unknown
@ DT_Unknown
Unknown or uninitialized data type.
Definition DataTypes.h:58
Arcane::DT_Real
@ DT_Real
Real data type.
Definition DataTypes.h:43
Arcane::dataTypeName
const char * dataTypeName(eDataType type)
Data type name.
Definition DataTypes.cc:72