Hdf5Utils.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Hdf5Utils.cc                                                (C) 2000-2026 */
/*                                                                           */
/* Utilitaires HDF5.                                                         */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Iostream.h"
#include "arcane/utils/Array.h"
#include "arcane/utils/FatalErrorException.h"
#include "arcane/utils/NotSupportedException.h"
#include "arcane/utils/ArgumentException.h"
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/TraceInfo.h"
#include "arcane/utils/IOException.h"
#include "arcane/utils/Convert.h"
 
#include "arcane/core/ArcaneException.h"
#include "arcane/core/IParallelMng.h"
 
#include "arcane/hdf5/Hdf5Utils.h"
 
#include <algorithm>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Hdf5Utils
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace
{
  std::once_flag h5open_once_flag;
 
#if (defined(H5_HAVE_THREADSAFE) || defined(H5_HAVE_CONCURRENCY))
  bool global_hdf5_mutex_is_active = false;
#else
  bool global_hdf5_mutex_is_active = true;
#endif
 
  std::mutex global_hdf5_mutex;
  Hdf5Mutex hdf5_mutex(global_hdf5_mutex, global_hdf5_mutex_is_active);
 
#if (defined(H5_HAVE_THREADSAFE) || defined(H5_HAVE_CONCURRENCY))
#define ARCANE_HDF5_MUTEX
#else
  struct ScopedMutex
  {
    ScopedMutex()
    {
      hdf5_mutex.lock();
    }
    ~ScopedMutex()
    {
      hdf5_mutex.unlock();
    }
  };
#define ARCANE_HDF5_MUTEX ScopedMutex scoped_mutex
#endif
} // namespace
 
Hdf5Mutex& _ArcaneHdf5UtilsMutex()
{
  return hdf5_mutex;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
HInit::
HInit()
{
  // Garanti que cela ne sera appelé qu'une seule fois et protège des appels
  // concurrents.
  std::call_once(h5open_once_flag, []() { H5open(); });
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HInit::
useMutex([[maybe_unused]] bool is_active, [[maybe_unused]] IParallelMng* pm)
{
#if (defined(H5_HAVE_THREADSAFE) || defined(H5_HAVE_CONCURRENCY))
  pm->traceMng()->info(4) << "HDF5 -- Is HDF5 threadsafe: 1 -- Is Mutex enabled: " << global_hdf5_mutex_is_active;
#else
  bool env_is_enable = true;
  if (const auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_HDF5_DISABLE_MUTEX", true)) {
    env_is_enable = (v.value() == 0);
  }
  pm->barrier();
  global_hdf5_mutex.lock();
  global_hdf5_mutex_is_active = env_is_enable && is_active;
  global_hdf5_mutex.unlock();
  pm->barrier();
  pm->traceMng()->info(4) << "HDF5 -- Is HDF5 threadsafe: 0 -- Is Mutex enabled: " << global_hdf5_mutex_is_active;
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace
{
 
  hid_t _H5Gopen(hid_t loc_id, const char* name)
  {
    return H5Gopen2(loc_id, name, H5P_DEFAULT);
  }
 
  hid_t _H5Gcreate(hid_t loc_id, const char* name)
  {
    return H5Gcreate2(loc_id, name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
  }
 
} // namespace
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
extern "C" ARCANE_HDF5_EXPORT herr_t
_ArcaneHdf5UtilsGroupIterateMe(hid_t g, const char* mn, void* ptr)
{
  ARCANE_UNUSED(g);
  HGroupSearch* rw = reinterpret_cast<HGroupSearch*>(ptr);
  return rw->iterateMe(mn);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void splitString(const String& str, Array<String>& str_array, char c)
{
  const char* str_str = str.localstr();
  Int64 offset = 0;
  Int64 len = str.length();
  for (Int64 i = 0; i < len; ++i) {
    if (str_str[i] == c && i != offset) {
      str_array.add(std::string_view(str_str + offset, i - offset));
      offset = i + 1;
    }
  }
  if (len != offset)
    str_array.add(std::string_view(str_str + offset, len - offset));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HFile::
openTruncate(const String& var)
{
  close();
  {
    ARCANE_HDF5_MUTEX;
    _setId(H5Fcreate(var.localstr(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT));
  }
  if (isBad())
    ARCANE_THROW(ReaderWriterException, "Can not open file '{0}'", var);
}
 
void HFile::
openAppend(const String& var)
{
  close();
  {
    ARCANE_HDF5_MUTEX;
    _setId(H5Fopen(var.localstr(), H5F_ACC_RDWR, H5P_DEFAULT));
  }
  if (isBad())
    ARCANE_THROW(ReaderWriterException, "Can not open file '{0}'", var);
}
 
void HFile::
openRead(const String& var)
{
  close();
  {
    ARCANE_HDF5_MUTEX;
    _setId(H5Fopen(var.localstr(), H5F_ACC_RDONLY, H5P_DEFAULT));
  }
  if (isBad())
    ARCANE_THROW(ReaderWriterException, "Can not open file '{0}'", var);
}
 
void HFile::
openTruncate(const String& var, hid_t plist_id)
{
  close();
  {
    ARCANE_HDF5_MUTEX;
    _setId(H5Fcreate(var.localstr(), H5F_ACC_TRUNC, H5P_DEFAULT, plist_id));
  }
  if (isBad())
    ARCANE_THROW(ReaderWriterException, "Can not open file '{0}'", var);
}
 
void HFile::
openAppend(const String& var, hid_t plist_id)
{
  close();
  {
    ARCANE_HDF5_MUTEX;
    _setId(H5Fopen(var.localstr(), H5F_ACC_RDWR, plist_id));
  }
  if (isBad())
    ARCANE_THROW(ReaderWriterException, "Can not open file '{0}'", var);
}
 
void HFile::
openRead(const String& var, hid_t plist_id)
{
  close();
  {
    ARCANE_HDF5_MUTEX;
    _setId(H5Fopen(var.localstr(), H5F_ACC_RDONLY, plist_id));
  }
  if (isBad())
    ARCANE_THROW(ReaderWriterException, "Can not open file '{0}'", var);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
herr_t HFile::
_close()
{
  herr_t e = 0;
  if (id() > 0) {
    ARCANE_HDF5_MUTEX;
    e = H5Fclose(id());
    _setNullId();
  }
  return e;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HFile::
close()
{
  herr_t e = _close();
  if (e < 0)
    ARCANE_THROW(ReaderWriterException, "Can not close file");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HGroup::
recursiveCreate(const Hid& loc_id, const String& var)
{
  UniqueArray<String> bufs;
  splitString(var, bufs, '/');
  recursiveCreate(loc_id, bufs);
}
 
void HGroup::
recursiveCreate(const Hid& loc_id, const Array<String>& bufs)
{
  close();
  hid_t last_hid = loc_id.id();
  Integer nb_create = bufs.size();
  UniqueArray<hid_t> ref_ids(nb_create);
  for (Integer i = 0; i < nb_create; ++i) {
    last_hid = _checkOrCreate(last_hid, bufs[i]);
    ref_ids[i] = last_hid;
  }
  // Libere tous les groupes intermediaires crees
  ARCANE_HDF5_MUTEX;
  for (Integer i = 0; i < nb_create - 1; ++i) {
    H5Gclose(ref_ids[i]);
  }
  _setId(last_hid);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HGroup::
checkDelete(const Hid& loc_id, const String& var)
{
  UniqueArray<String> bufs;
  splitString(var, bufs, '/');
  hid_t last_hid = loc_id.id();
  hid_t parent_hid = last_hid;
  Integer i = 0;
  Integer size = bufs.size();
  for (; i < size; ++i) {
    parent_hid = last_hid;
    last_hid = _checkExist(last_hid, bufs[i]);
    if (last_hid == 0)
      break;
  }
  // Groupe trouvé, on le détruit.
  if (last_hid > 0 && parent_hid > 0 && i == size) {
    //cerr << "** DELETE <" << bufs[size-1] << "\n";
    ARCANE_HDF5_MUTEX;
    H5Gunlink(parent_hid, bufs[size - 1].localstr());
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HGroup::
recursiveOpen(const Hid& loc_id, const String& var)
{
  close();
  UniqueArray<String> bufs;
  splitString(var, bufs, '/');
  hid_t last_hid = loc_id.id();
  Integer nb_open = bufs.size();
  UniqueArray<hid_t> ref_ids(nb_open);
  ARCANE_HDF5_MUTEX;
  for (Integer i = 0; i < nb_open; ++i) {
    last_hid = _H5Gopen(last_hid, bufs[i].localstr());
    ref_ids[i] = last_hid;
  }
  // Libere tous les groupes intermediaires ouverts
  for (Integer i = 0; i < nb_open - 1; ++i) {
    H5Gclose(ref_ids[i]);
  }
  _setId(last_hid);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HGroup::
openIfExists(const Hid& loc_id, const Array<String>& paths)
{
  close();
  hid_t last_hid = loc_id.id();
  bool is_valid = true;
  Integer nb_open = paths.size();
  UniqueArray<hid_t> ref_ids;
  ref_ids.reserve(nb_open);
  for (Integer i = 0; i < nb_open; ++i) {
    if (HGroup::hasChildren(last_hid, paths[i].localstr())) {
      ARCANE_HDF5_MUTEX;
      last_hid = _H5Gopen(last_hid, paths[i].localstr());
      ref_ids.add(last_hid);
    }
    else {
      is_valid = false;
      break;
    }
  }
  if (is_valid)
    _setId(last_hid);
  // Ferme tous les groupes intermediaires
  ARCANE_HDF5_MUTEX;
  for (Integer i = 0; i < ref_ids.size(); ++i) {
    if (ref_ids[i] != last_hid) {
      H5Gclose(ref_ids[i]);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool HGroup::
hasChildren(const String& var)
{
  return hasChildren(id(), var);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool HGroup::
hasChildren(hid_t loc_id, const String& var)
{
  HGroupSearch gs(var);
  ARCANE_HDF5_MUTEX;
  herr_t v = H5Giterate(loc_id, ".", 0, _ArcaneHdf5UtilsGroupIterateMe, &gs);
  bool has_children = v > 0;
  //cout << "** HAS CHILDREN " << var << " v=" << has_children << '\n';
  return has_children;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
hid_t HGroup::
_checkOrCreate(hid_t loc_id, const String& group_name)
{
  // Pour vérifier si un groupe existe déjà, comme il n'existe aucune
  // fonction digne de ce nom dans HDF5, on utilise le mécanisme d'itération
  // pour stocker tous les groupes fils de ce groupe, et on recherche ensuite
  // si le groupe souhaité existe
  HGroupSearch gs(group_name);
  //cerr << "** CHECK CREATE <" << group_name.str()  << ">\n";
  ARCANE_HDF5_MUTEX;
  herr_t v = H5Giterate(loc_id, ".", 0, _ArcaneHdf5UtilsGroupIterateMe, &gs);
 
  // Regarde si le groupe existe déjà
  //herr_t he = H5Gget_objinfo(loc_id,group_name.str(),true,0);
  //cerr << "** CHECK CREATE <" << group_name.str()  << "> " << v << "\n";
  //cerr << "** CHECK CREATE <" << group_name.str()  << "> " << v << ' ' << he << "\n";
  if (v > 0) {
    return _H5Gopen(loc_id, group_name.localstr());
  }
  hid_t new_id = _H5Gcreate(loc_id, group_name.localstr());
  //cerr << "** TRY TO CREATE <" << group_name.str()  << "> " << new_id << "\n";
  return new_id;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HGroup::
create(const Hid& loc_id, const String& group_name)
{
  ARCANE_HDF5_MUTEX;
  _setId(H5Gcreate2(loc_id.id(), group_name.localstr(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HGroup::
openOrCreate(const Hid& loc_id, const String& group_name)
{
  hid_t id = _checkOrCreate(loc_id.id(), group_name);
  if (id < 0)
    ARCANE_THROW(ReaderWriterException, "Can not open or create group named '{0}'", group_name);
  _setId(id);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HGroup::
open(const Hid& loc_id, const String& var)
{
  hid_t id = -1;
  {
    ARCANE_HDF5_MUTEX;
    id = _H5Gopen(loc_id.id(), var.localstr());
  }
  if (id < 0)
    ARCANE_THROW(ReaderWriterException, "Can not find group named '{0}'", var);
  _setId(id);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HGroup::
close()
{
  if (id() > 0) {
    ARCANE_HDF5_MUTEX;
    H5Gclose(id());
    _setNullId();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
hid_t HGroup::
_checkExist(hid_t loc_id, const String& group_name)
{
  // Pour vérifier si un groupe existe déjà, comme il n'existe aucune
  // fonction digne de ce nom dans HDF5, on utilise le mécanisme d'itération
  // pour stocker tous les groupes fils de ce groupe, et on recherche ensuite
  // si le groupe souhaité existe
  HGroupSearch gs(group_name);
  //cerr << "** CHECK CREATE <" << group_name.str()  << ">\n";
  ARCANE_HDF5_MUTEX;
  herr_t v = H5Giterate(loc_id, ".", 0, _ArcaneHdf5UtilsGroupIterateMe, &gs);
 
  // Regarde si le groupe existe déjà
  //herr_t he = H5Gget_objinfo(loc_id,group_name.str(),true,0);
  //cerr << "** CHECK CREATE <" << group_name.str()  << "> " << v << "\n";
  //cerr << "** CHECK CREATE <" << group_name.str()  << "> " << v << ' ' << he << "\n";
  if (v > 0) {
    return _H5Gopen(loc_id, group_name.localstr());
  }
  //hid_t new_id = H5Gcreate(loc_id,group_name.localstr(),0);
  //cerr << "** TRY TO CREATE <" << group_name.str()  << "> " << new_id << "\n";
  return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
HSpace::
~HSpace()
{
  if (id() > 0) {
    ARCANE_HDF5_MUTEX;
    H5Sclose(id());
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HSpace::
createSimple(int nb, hsize_t dims[])
{
  ARCANE_HDF5_MUTEX;
  _setId(H5Screate_simple(nb, dims, nullptr));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HSpace::
createSimple(int nb, hsize_t dims[], hsize_t max_dims[])
{
  ARCANE_HDF5_MUTEX;
  _setId(H5Screate_simple(nb, dims, max_dims));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
int HSpace::
nbDimension()
{
  ARCANE_HDF5_MUTEX;
  return H5Sget_simple_extent_ndims(id());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
herr_t HSpace::
getDimensions(hsize_t dims[], hsize_t max_dims[])
{
  ARCANE_HDF5_MUTEX;
  return H5Sget_simple_extent_dims(id(), dims, max_dims);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HDataset::
close()
{
  if (id() > 0) {
    ARCANE_HDF5_MUTEX;
    H5Dclose(id());
  }
  _setNullId();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HDataset::
create(const Hid& loc_id, const String& var, hid_t save_type,
       const HSpace& space_id, hid_t plist)
{
  ARCANE_HDF5_MUTEX;
  hid_t hid = H5Dcreate2(loc_id.id(), var.localstr(), save_type, space_id.id(),
                         plist, H5P_DEFAULT, H5P_DEFAULT);
  //cerr << "** CREATE ID=" << hid << '\n';
  _setId(hid);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HDataset::
create(const Hid& loc_id, const String& var, hid_t save_type,
       const HSpace& space_id, const HProperty& link_plist,
       const HProperty& creation_plist, const HProperty& access_plist)
{
  ARCANE_HDF5_MUTEX;
  hid_t hid = H5Dcreate2(loc_id.id(), var.localstr(), save_type, space_id.id(),
                         link_plist.id(), creation_plist.id(), access_plist.id());
  //cerr << "** CREATE ID=" << hid << '\n';
  _setId(hid);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
herr_t HDataset::
write(hid_t native_type, const void* array)
{
  //cerr << "** WRITE ID=" << id() << '\n';
  ARCANE_HDF5_MUTEX;
  return H5Dwrite(id(), native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, array);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
herr_t HDataset::
write(hid_t native_type, const void* array, const HSpace& memspace_id,
      const HSpace& filespace_id, hid_t plist)
{
  //cerr << "** WRITE ID=" << id() << '\n';
  ARCANE_HDF5_MUTEX;
  return H5Dwrite(id(), native_type, memspace_id.id(), filespace_id.id(), plist, array);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
herr_t HDataset::
write(hid_t native_type, const void* array, const HSpace& memspace_id,
      const HSpace& filespace_id, const HProperty& plist)
{
  //cerr << "** WRITE ID=" << id() << '\n';
  ARCANE_HDF5_MUTEX;
  return H5Dwrite(id(), native_type, memspace_id.id(), filespace_id.id(), plist.id(), array);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
herr_t HDataset::
read(hid_t native_type, void* array)
{
  ARCANE_HDF5_MUTEX;
  return H5Dread(id(), native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, array);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HDataset::
readWithException(hid_t native_type, void* array)
{
  herr_t err = -1;
  {
    ARCANE_HDF5_MUTEX;
    err = H5Dread(id(), native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, array);
  }
  if (err != 0)
    ARCANE_THROW(IOException, "Can not read dataset");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
HSpace HDataset::
getSpace()
{
  ARCANE_HDF5_MUTEX;
  return HSpace(H5Dget_space(id()));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
herr_t HDataset::
setExtent(const hsize_t new_dims[])
{
  ARCANE_HDF5_MUTEX;
  return H5Dset_extent(id(), new_dims);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HDataset::
recursiveCreate(const Hid& loc_id, const String& var, hid_t save_type,
                const HSpace& space_id, hid_t plist)
{
  // Si le dataset existe déjà, il faut le supprimer
  // car sinon il n'est pas toujours possible de modifer le space_id
  UniqueArray<String> paths;
  splitString(var, paths, '/');
  Integer nb_path = paths.size();
  if (nb_path == 1) {
    if (HGroup::hasChildren(loc_id.id(), var)) {
      _remove(loc_id.id(), var);
    }
    create(loc_id, var, save_type, space_id, plist);
    return;
  }
  String last_name = paths[nb_path - 1];
  paths.resize(nb_path - 1);
  HGroup group;
  group.recursiveCreate(loc_id, paths);
  if (group.hasChildren(last_name)) {
    _remove(group.id(), last_name);
  }
  create(group.id(), last_name, save_type, space_id, plist);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HDataset::
_remove(hid_t hid, const String& var)
{
  ARCANE_HDF5_MUTEX;
  H5Gunlink(hid, var.localstr());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
HAttribute::
~HAttribute()
{
  if (id() > 0) {
    ARCANE_HDF5_MUTEX;
    H5Aclose(id());
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HAttribute::
remove(const Hid& loc_id, const String& var)
{
  ARCANE_HDF5_MUTEX;
  _setId(H5Adelete(loc_id.id(), var.localstr()));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HAttribute::
create(const Hid& loc_id, const String& var, hid_t save_type, const HSpace& space_id)
{
  ARCANE_HDF5_MUTEX;
  _setId(H5Acreate2(loc_id.id(), var.localstr(), save_type, space_id.id(), H5P_DEFAULT, H5P_DEFAULT));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HAttribute::
open(const Hid& loc_id, const String& var)
{
  ARCANE_HDF5_MUTEX;
  _setId(H5Aopen_name(loc_id.id(), var.localstr()));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
herr_t HAttribute::
write(hid_t native_type, void* array)
{
  ARCANE_HDF5_MUTEX;
  return H5Awrite(id(), native_type, array);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
herr_t HAttribute::
read(hid_t native_type, void* array)
{
  ARCANE_HDF5_MUTEX;
  return H5Aread(id(), native_type, array);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
HSpace HAttribute::
getSpace()
{
  ARCANE_HDF5_MUTEX;
  return HSpace(H5Aget_space(id()));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
HType::
~HType()
{
  if (id() > 0) {
    ARCANE_HDF5_MUTEX;
    H5Tclose(id());
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HDataset::
open(const Hid& loc_id, const String& var)
{
  {
    ARCANE_HDF5_MUTEX;
    _setId(H5Dopen2(loc_id.id(), var.localstr(), H5P_DEFAULT));
  }
  if (isBad())
    ARCANE_THROW(IOException, "Can not open dataset '{0}'", var);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HDataset::
openIfExists(const Hid& loc_id, const String& var)
{
  UniqueArray<String> paths;
  splitString(var, paths, '/');
  Integer nb_path = paths.size();
  HGroup parent_group;
  String last_name = var;
  if (nb_path > 1) {
    last_name = paths[nb_path - 1];
    paths.resize(nb_path - 1);
    parent_group.openIfExists(loc_id, paths);
  }
  else {
    parent_group.open(loc_id, ".");
  }
  if (parent_group.isBad())
    return;
  if (parent_group.hasChildren(last_name))
    open(loc_id.id(), var.localstr());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HProperty::
close()
{
  if (id() > 0) {
    ARCANE_HDF5_MUTEX;
    H5Pclose(id());
    _setNullId();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HProperty::
create(hid_t cls_id)
{
  close();
  ARCANE_HDF5_MUTEX;
  _setId(H5Pcreate(cls_id));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HProperty::
createFilePropertyMPIIO(IParallelMng* pm)
{
#ifdef H5_HAVE_PARALLEL
  void* arcane_comm = pm->getMPICommunicator();
  if (!arcane_comm)
    ARCANE_FATAL("No MPI environment available");
  MPI_Comm mpi_comm = *((MPI_Comm*)arcane_comm);
  MPI_Info mpi_info = MPI_INFO_NULL;
 
  create(H5P_FILE_ACCESS);
  H5Pset_fapl_mpio(id(), mpi_comm, mpi_info);
#else
  ARCANE_UNUSED(pm);
  ARCANE_THROW(NotSupportedException, "HDF5 is not compiled with MPI support");
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HProperty::
createDatasetTransfertCollectiveMPIIO()
{
#ifdef H5_HAVE_PARALLEL
  create(H5P_DATASET_XFER);
  H5Pset_dxpl_mpio(id(), H5FD_MPIO_COLLECTIVE);
 
#if (H5_VERS_MAJOR >= 2 || H5_VERS_MINOR >= 14)
  H5Pset_selection_io(id(), H5D_SELECTION_IO_MODE_OFF);
#endif
 
#else
  ARCANE_THROW(NotSupportedException, "HDF5 is not compiled with MPI support");
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void HProperty::
createDatasetTransfertIndependentMPIIO()
{
#ifdef H5_HAVE_PARALLEL
  create(H5P_DATASET_XFER);
  H5Pset_dxpl_mpio(id(), H5FD_MPIO_INDEPENDENT);
 
#if (H5_VERS_MAJOR >= 2 || H5_VERS_MINOR >= 14)
  H5Pset_selection_io(id(), H5D_SELECTION_IO_MODE_OFF);
#endif
 
#else
  ARCANE_THROW(NotSupportedException, "HDF5 is not compiled with MPI support");
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StandardTypes::
StandardTypes()
{
  initialize();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StandardTypes::
StandardTypes(bool do_init)
{
  if (do_init)
    initialize();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StandardTypes::
initialize()
{
  ARCANE_HDF5_MUTEX;
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_CHAR);
    m_char_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_UCHAR);
    m_uchar_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_SCHAR);
    m_schar_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_SHORT);
    H5Tset_precision(type_id, 8 * sizeof(short));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_short_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_INT);
    H5Tset_precision(type_id, 8 * sizeof(int));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_int_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_LONG);
    H5Tset_precision(type_id, 8 * sizeof(long));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_long_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_LLONG);
    H5Tset_precision(type_id, 8 * sizeof(long long));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_llong_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_USHORT);
    H5Tset_precision(type_id, 8 * sizeof(unsigned short));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_ushort_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_UINT);
    H5Tset_precision(type_id, 8 * sizeof(unsigned int));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_uint_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_ULONG);
    H5Tset_precision(type_id, 8 * sizeof(unsigned long));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_ulong_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_ULLONG);
    H5Tset_precision(type_id, 8 * sizeof(unsigned long long));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_ullong_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_FLOAT);
    H5Tset_precision(type_id, 8 * sizeof(float));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_float32_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_DOUBLE);
    H5Tset_precision(type_id, 8 * sizeof(double));
    H5Tset_order(type_id, H5T_ORDER_LE);
    m_real_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcreate(H5T_COMPOUND, sizeof(Real2POD));
    _H5Tinsert(type_id, "X", HOFFSET(Real2POD, x), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "Y", HOFFSET(Real2POD, y), H5T_NATIVE_DOUBLE);
    m_real2_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcreate(H5T_COMPOUND, sizeof(Real3POD));
    _H5Tinsert(type_id, "X", HOFFSET(Real3POD, x), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "Y", HOFFSET(Real3POD, y), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "Z", HOFFSET(Real3POD, z), H5T_NATIVE_DOUBLE);
    m_real3_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcreate(H5T_COMPOUND, sizeof(Real2x2POD));
    _H5Tinsert(type_id, "XX", HOFFSET(Real2x2POD, x.x), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "XY", HOFFSET(Real2x2POD, x.y), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "YX", HOFFSET(Real2x2POD, y.x), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "YY", HOFFSET(Real2x2POD, y.y), H5T_NATIVE_DOUBLE);
    m_real2x2_id.setId(type_id);
  }
  {
    hid_t type_id = H5Tcreate(H5T_COMPOUND, sizeof(Real3x3POD));
    _H5Tinsert(type_id, "XX", HOFFSET(Real3x3POD, x.x), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "XY", HOFFSET(Real3x3POD, x.y), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "XZ", HOFFSET(Real3x3POD, x.z), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "YX", HOFFSET(Real3x3POD, y.x), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "YY", HOFFSET(Real3x3POD, y.y), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "YZ", HOFFSET(Real3x3POD, y.z), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "ZX", HOFFSET(Real3x3POD, z.x), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "ZY", HOFFSET(Real3x3POD, z.y), H5T_NATIVE_DOUBLE);
    _H5Tinsert(type_id, "ZZ", HOFFSET(Real3x3POD, z.z), H5T_NATIVE_DOUBLE);
    m_real3x3_id.setId(type_id);
  }
 
  // HDF5 1.10 et 1.12 ne supportent pas encore les types 'BFloat16' et 'Float16'.
  // Lorsque ce sera le cas, on pourra utiliser le type fourni par HDF5.
  // (NOTE: HDF5 1.14.4 supporte Float16)
 
  // Ajoute type opaque pour BFloat16.
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_B16);
    m_bfloat16_id.setId(type_id);
  }
  // Ajoute type opaque pour Float16.
  {
    hid_t type_id = H5Tcopy(H5T_NATIVE_B16);
    m_float16_id.setId(type_id);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StandardTypes::
~StandardTypes()
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StandardTypes::
_H5Tinsert(hid_t type, const char* name, Integer offset, hid_t field_id)
{
  // Mutex géré par initialize.
  herr_t herr = H5Tinsert(type, name, offset, field_id);
  if (herr < 0) {
    ARCANE_FATAL("Can not insert type");
  }
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifdef ARCANE_REAL_NOT_BUILTIN
hid_t StandardTypes::
nativeType(Real) const
{
  ARCANE_FATAL("Real is a complex type");
}
#endif
 
hid_t StandardTypes::
saveType(eDataType sd) const
{
  switch (sd) {
  case DT_Byte:
    return saveType(Byte());
  case DT_Real:
    return saveType(Real());
  case DT_Real2:
    return saveType(Real2());
  case DT_Real2x2:
    return saveType(Real2x2());
  case DT_Real3:
    return saveType(Real3());
  case DT_Real3x3:
    return saveType(Real3x3());
  case DT_Int8:
    return saveType(Int8());
  case DT_Int16:
    return saveType(Int16());
  case DT_Int32:
    return saveType(Int32());
  case DT_Int64:
    return saveType(Int64());
  case DT_Float32:
    return saveType(Float32());
  case DT_Float16:
    return saveType(Float16());
  case DT_BFloat16:
    return saveType(BFloat16());
  default:
    throw ArgumentException(String::format("Bad type '{0}'", sd));
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
hid_t StandardTypes::
nativeType(eDataType sd) const
{
  switch (sd) {
  case DT_Byte:
    return nativeType(Byte());
  case DT_Real:
    return nativeType(Real());
  case DT_Real2:
    return nativeType(Real2());
  case DT_Real2x2:
    return nativeType(Real2x2());
  case DT_Real3:
    return nativeType(Real3());
  case DT_Real3x3:
    return nativeType(Real3x3());
  case DT_Int8:
    return nativeType(Int8());
  case DT_Int16:
    return nativeType(Int16());
  case DT_Int32:
    return nativeType(Int32());
  case DT_Int64:
    return nativeType(Int64());
  case DT_Float32:
    return nativeType(Float32());
  case DT_Float16:
    return nativeType(Float16());
  case DT_BFloat16:
    return nativeType(BFloat16());
  default:
    throw ArgumentException(String::format("Bad type '{0}'", sd));
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
StandardArray::
StandardArray(hid_t hfile, const String& hpath)
: m_hfile(hfile)
, m_hpath(hpath)
, m_ids_hpath(hpath + "_Ids")
, m_is_init(false)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StandardArray::
readDim()
{
  if (m_is_init)
    return;
  m_is_init = true;
  m_hdataset.open(m_hfile, m_hpath);
  HSpace hspace(m_hdataset.getSpace());
  {
    const int max_dim = 256; // Nombre maxi de dimensions des tableaux HDF
    hsize_t hdf_dims[max_dim];
    hsize_t max_dims[max_dim];
    int nb_dim = -1;
    {
      ARCANE_HDF5_MUTEX;
      nb_dim = H5Sget_simple_extent_ndims(hspace.id());
      H5Sget_simple_extent_dims(hspace.id(), hdf_dims, max_dims);
    }
    for (Integer i = 0; i < nb_dim; ++i) {
      //cerr << "** DIM i=" << i << " hdim=" << hdf_dims[i]
      //   << " max=" << max_dims[i] << '\n';
      m_dimensions.add((Int64)hdf_dims[i]);
    }
  }
  // Vérifie s'il existe une variable suffixée '_Ids' contenant les numéros
  // uniques des entités
  m_ids_dataset.openIfExists(m_hfile, m_ids_hpath);
  //cout << "TRY OPEN ID DATASET path=" << m_ids_hpath << " r=" << m_ids_dataset.id()>0 << '\n';
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StandardArray::
setIdsPath(const String& ids_path)
{
  m_ids_hpath = ids_path;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void StandardArray::
_write(const void* buffer, Integer nb_element, hid_t save_type, hid_t native_type)
{
  if (!m_is_init) {
    hsize_t dims[1];
    dims[0] = nb_element;
 
    HSpace hspace;
    hspace.createSimple(1, dims);
    if (hspace.isBad())
      ARCANE_THROW(IOException, "Can not create space");
 
    m_dimensions.clear();
    m_dimensions.add(nb_element);
 
    m_hdataset.recursiveCreate(m_hfile, m_hpath, save_type, hspace, H5P_DEFAULT);
    if (m_hdataset.isBad())
      ARCANE_THROW(IOException, "Can not create dataset");
 
    m_is_init = true;
  }
 
  m_hdataset.write(native_type, buffer);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool StandardArray::
exists() const
{
  HDataset dataset;
  dataset.openIfExists(m_hfile, m_hpath);
  return dataset.id() > 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType> StandardArrayT<DataType>::
StandardArrayT(hid_t hfile, const String& hpath)
: StandardArray(hfile, hpath)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType> void StandardArrayT<DataType>::
read(StandardTypes& st, ArrayView<DataType> buffer)
{
  m_hdataset.readWithException(st.nativeType(DataType()), buffer.data());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType> void StandardArrayT<DataType>::
directRead(StandardTypes& st, Array<DataType>& buffer)
{
  readDim();
  buffer.resize(m_dimensions[0]);
  read(st, buffer);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType> void StandardArrayT<DataType>::
parallelRead(IParallelMng* pm, StandardTypes& st, Array<DataType>& buffer, Int64Array& unique_ids)
{
  bool is_master = pm->isMasterIO();
  Integer master_rank = pm->masterIORank();
  bool has_ids = false;
  if (is_master) {
    read(st, buffer);
    Integer buf_size = buffer.size();
    if (m_ids_dataset.id() > 0) {
      has_ids = true;
      m_ids_dataset.read(st.nativeType(Int64()), unique_ids.data());
    }
    Integer infos[2];
    infos[0] = buf_size;
    infos[1] = has_ids ? 1 : 0;
    IntegerArrayView iav(2, infos);
    pm->broadcast(iav, master_rank);
    pm->broadcast(buffer, master_rank);
    pm->broadcast(unique_ids, master_rank);
  }
  else {
    Integer infos[2];
    IntegerArrayView iav(2, infos);
    pm->broadcast(iav, master_rank);
    Integer buf_size = infos[0];
    has_ids = infos[1] != 0;
    buffer.resize(buf_size);
    unique_ids.resize(buf_size);
    pm->broadcast(buffer, master_rank);
    pm->broadcast(unique_ids, master_rank);
  }
  if (!has_ids) {
    for (Integer i = 0, is = unique_ids.size(); i < is; ++i)
      unique_ids[i] = i;
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType> void StandardArrayT<DataType>::
write(StandardTypes& st, ConstArrayView<DataType> buffer)
{
  Integer nb_element = buffer.size();
  _write(buffer.data(), nb_element, st.saveType(DataType()), st.nativeType(DataType()));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType> void StandardArrayT<DataType>::
_writeSortedValues(ITraceMng* tm, StandardTypes& st,
                   ConstArrayView<DataType> buffer,
                   Int64ConstArrayView unique_ids)
{
  ARCANE_UNUSED(tm);
 
  Integer total_size = buffer.size();
  Integer nb_element = unique_ids.size();
  Integer dim2_size = 1;
  if (nb_element != total_size) {
    if (nb_element == 0)
      ARCANE_THROW(ArgumentException, "unique_ids size is zero but not buffer size ({0})",
                   total_size);
    dim2_size = total_size / nb_element;
    if (dim2_size * nb_element != total_size)
      ARCANE_THROW(ArgumentException, "buffer size ({0}) is not a multiple of unique_ids size ({1})",
                   total_size, nb_element);
  }
 
  UniqueArray<ValueWithUid> values_to_sort(nb_element);
  UniqueArray<DataType> out_buffer(total_size);
  //tm->info() << " WRITE total_size=" << total_size
  //<< " uid_size=" << unique_ids.size();
  for (Integer i = 0; i < nb_element; ++i) {
    values_to_sort[i].m_uid = unique_ids[i];
    values_to_sort[i].m_index = i;
    //values_to_sort[i].m_value = buffer[i];
    //tm->info() << "BEFORE SORT i=" << i << " uid=" << unique_ids[i];
  }
  std::sort(std::begin(values_to_sort), std::end(values_to_sort));
  for (Integer i = 0; i < nb_element; ++i) {
    Integer old_index = values_to_sort[i].m_index;
    for (Integer j = 0; j < dim2_size; ++j) {
      Integer pos = (i * dim2_size) + j;
      out_buffer[pos] = buffer[(old_index * dim2_size) + j];
      //tm->info() << "AFTER SORT i=" << i << " uid=" << values_to_sort[i].m_uid
      //           << " j=" << j << " pos=" << pos
      //           << " value=" << out_buffer[pos];
    }
  }
  write(st, out_buffer);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType> void StandardArrayT<DataType>::
parallelWrite(IParallelMng* pm, StandardTypes& st,
              ConstArrayView<DataType> buffer, Int64ConstArrayView unique_ids)
{
  //TODO:
  // Pour l'instant, seul le proc maitre ecrit.
  // Il recupère toutes les valeurs, les trie par uniqueId croissant
  // et les écrit.
  // Il est important que tout soit trié par ordre croissant car
  // cela permet de garder le même ordre d'écriture même en présence
  // de repartitionnement du maillage. La relecture considère
  // que cette contrainte est respectée et ne relit les informations
  // des uniqueId qu'au démarrage du cas.
  bool is_parallel = pm->isParallel();
  ITraceMng* tm = pm->traceMng();
 
  if (!is_parallel) {
    _writeSortedValues(tm, st, buffer, unique_ids);
    return;
  }
 
  bool is_master = pm->isMasterIO();
  Integer master_rank = pm->masterIORank();
  Integer nb_rank = pm->commSize();
  Integer buf_size = buffer.size();
  Integer unique_id_size = unique_ids.size();
  IntegerUniqueArray rank_sizes(2 * nb_rank);
  // Le sous-domaine maitre récupère les infos de tous les autres.
  // Si un sous-domaine n'a pas d'éléments à envoyer, il ne fait rien
  // (on n'envoie pas de buffers vides)
  if (is_master) {
    Integer buf[2];
    buf[0] = buf_size;
    buf[1] = unique_id_size;
    IntegerArrayView iav(2, buf);
    pm->allGather(iav, rank_sizes);
 
    Integer buffer_total_size = 0;
    Integer unique_id_total_size = 0;
    IntegerUniqueArray buffer_rank_index(nb_rank);
    IntegerUniqueArray unique_id_rank_index(nb_rank);
 
    for (Integer i = 0; i < nb_rank; ++i) {
      buffer_rank_index[i] = buffer_total_size;
      buffer_total_size += rank_sizes[(i * 2)];
      unique_id_rank_index[i] = unique_id_total_size;
      unique_id_total_size += rank_sizes[(i * 2) + 1];
    }
 
    UniqueArray<DataType> full_buffer(buffer_total_size);
    Int64UniqueArray full_unique_ids(unique_id_total_size);
 
    for (Integer i = 0; i < nb_rank; ++i) {
      // Ne recoit pas de valeurs des processus n'ayant pas de valeurs
      if (rank_sizes[(i * 2)] == 0)
        continue;
      ArrayView<DataType> local_buf(rank_sizes[(i * 2)], &full_buffer[buffer_rank_index[i]]);
      Int64ArrayView local_unique_ids(rank_sizes[(i * 2) + 1], &full_unique_ids[unique_id_rank_index[i]]);
      if (i == master_rank) {
        local_buf.copy(buffer);
        local_unique_ids.copy(unique_ids);
      }
      else {
        pm->recv(local_buf, i);
        pm->recv(local_unique_ids, i);
      }
    }
    tm->info(5) << "PARALLEL WRITE path=" << m_hpath << " total_size=" << full_buffer.size();
    _writeSortedValues(tm, st, full_buffer, full_unique_ids);
  }
  else {
    Integer buf[2];
    buf[0] = buf_size;
    buf[1] = unique_id_size;
    IntegerArrayView iav(2, buf);
    pm->allGather(iav, rank_sizes);
    // Pas la peine d'envoyer des buffers vides
    if (buffer.size() > 0) {
      pm->send(buffer, master_rank);
      pm->send(unique_ids, master_rank);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template class StandardArrayT<Real>;
template class StandardArrayT<Real3>;
template class StandardArrayT<Real3x3>;
template class StandardArrayT<Real2>;
template class StandardArrayT<Real2x2>;
template class StandardArrayT<Int16>;
template class StandardArrayT<Int32>;
template class StandardArrayT<Int64>;
template class StandardArrayT<Byte>;
template class StandardArrayT<Int8>;
template class StandardArrayT<Float32>;
// NOTE: on ne peut pas encore instantier ces types car ils nécessitent
// de pouvoir faire des send/receive via le IParallelMng et cela n'est pas
// encore implémenté.
//template class StandardArrayT<Float16>;
//template class StandardArrayT<BFloat16>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType> DataType
StandardScalarT<DataType>::
read(Hdf5Utils::StandardTypes& st)
{
  Hdf5Utils::HDataset m_hdataset;
  m_hdataset.open(m_hfile, m_hpath);
  Hdf5Utils::HSpace hspace(m_hdataset.getSpace());
  {
    const int max_dim = 256; // Nombre maxi de dimensions des tableaux HDF
    hsize_t hdf_dims[max_dim];
    hsize_t max_dims[max_dim];
    int nb_dim = -1;
    {
      ARCANE_HDF5_MUTEX;
      nb_dim = H5Sget_simple_extent_ndims(hspace.id());
      H5Sget_simple_extent_dims(hspace.id(), hdf_dims, max_dims);
    }
    if (nb_dim != 1 || hdf_dims[0] != 1)
      ARCANE_THROW(IOException, "Cannot read non scalar");
  }
 
  DataType dummy;
  m_hdataset.read(st.nativeType(DataType()), &dummy);
  return dummy;
}
 
/*---------------------------------------------------------------------------*/
 
template <> String
StandardScalarT<String>::
read(Hdf5Utils::StandardTypes& st)
{
  ByteUniqueArray utf8_bytes;
 
  Hdf5Utils::HDataset m_hdataset;
  m_hdataset.open(m_hfile, m_hpath);
  Hdf5Utils::HSpace hspace(m_hdataset.getSpace());
  {
    const int max_dim = 256; // Nombre maxi de dimensions des tableaux HDF
    hsize_t hdf_dims[max_dim];
    hsize_t max_dims[max_dim];
    int nb_dim = -1;
    {
      ARCANE_HDF5_MUTEX;
      nb_dim = H5Sget_simple_extent_ndims(hspace.id());
      H5Sget_simple_extent_dims(hspace.id(), hdf_dims, max_dims);
    }
 
    if (nb_dim != 1)
      ARCANE_THROW(IOException, "Cannot read multidim string");
    utf8_bytes.resize(hdf_dims[0]);
  }
 
  m_hdataset.read(st.nativeType(Byte()), utf8_bytes.data());
  return String(utf8_bytes);
}
 
/*---------------------------------------------------------------------------*/
 
template <typename DataType> void
StandardScalarT<DataType>::
write(Hdf5Utils::StandardTypes& st, const DataType& t)
{
  hsize_t dims[1] = { 1 };
  Hdf5Utils::HSpace hspace;
  hspace.createSimple(1, dims);
  if (hspace.isBad())
    ARCANE_THROW(IOException, "Can not create space");
 
  Hdf5Utils::HDataset m_hdataset;
  m_hdataset.recursiveCreate(m_hfile, m_hpath, st.saveType(DataType()), hspace, H5P_DEFAULT);
  if (m_hdataset.isBad())
    ARCANE_THROW(IOException, "Can not create dataset");
 
  herr_t herr = m_hdataset.write(st.nativeType(DataType()), &t);
  if (herr < 0)
    ARCANE_THROW(IOException, "Cannot write data");
}
 
/*---------------------------------------------------------------------------*/
 
template <> void
StandardScalarT<String>::
write(Hdf5Utils::StandardTypes& st, const String& s)
{
  ByteConstArrayView utf8_bytes = s.utf8();
 
  hsize_t dims[1];
  dims[0] = utf8_bytes.size() + 1;
 
  Hdf5Utils::HSpace hspace;
  hspace.createSimple(1, dims);
  if (hspace.isBad())
    ARCANE_THROW(IOException, "Can not create space");
 
  Hdf5Utils::HDataset m_hdataset;
  m_hdataset.recursiveCreate(m_hfile, m_hpath, st.saveType(Byte()), hspace, H5P_DEFAULT);
  if (m_hdataset.isBad())
    ARCANE_THROW(IOException, "Can not create dataset");
 
  herr_t herr = m_hdataset.write(st.nativeType(Byte()), utf8_bytes.data());
  if (herr < 0)
    ARCANE_THROW(IOException, "Cannot write data");
}
 
/*---------------------------------------------------------------------------*/
 
template class StandardScalarT<String>;
template class StandardScalarT<Real>;
template class StandardScalarT<Real3>;
template class StandardScalarT<Real3x3>;
template class StandardScalarT<Real2>;
template class StandardScalarT<Real2x2>;
template class StandardScalarT<Int16>;
template class StandardScalarT<Int32>;
template class StandardScalarT<Int64>;
template class StandardScalarT<Byte>;
template class StandardScalarT<Int8>;
template class StandardScalarT<Float16>;
template class StandardScalarT<BFloat16>;
template class StandardScalarT<Float32>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::Hdf5Utils
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/