HDF5 pour les données de simulation : E/S parallèles et stockage à long terme

Reading Time: 12 minutes

HDF5 est la norme de facto pour le stockage de données de simulation scientifique à grande échelle. Sa structure hiérarchique, ses capacités d’E/S parallèles via MPI et sa compression intégrée le rendent idéal pour les environnements de calcul haute performance. Cependant, une utilisation inappropriée, en particulier de mauvais choix et des modèles d’accès parallèles incorrects, peut entraîner une grave dégradation des performances ou une corruption des données. Ce guide couvre l’architecture HDF5, la mise en œuvre d’E/S parallèles en Python, les techniques d’optimisation des performances et les meilleures pratiques de conservation pour le stockage à long terme.

Introduction : Le défi des données de simulation

Les simulations scientifiques génèrent régulièrement des téraoctets de données sur des milliers de pas de temps et plusieurs champs physiques. La gestion de ce déluge nécessite plus qu’un simple format de fichier. Cela exige un système capable de gérer :

Échelle : gigaoctets en pétaoctets de tableaux multidimensionnels
performance : lecture/écriture efficaces sur les systèmes HPC avec des systèmes de fichiers parallèles
Organisation : des structures auto-décrivantes qui restent compréhensibles des années plus tard
Durabilité : conservation à long terme sans obsolescence de format
Access : sous-réglage rapide sans lecture de jeux de données entiers

HDF5 (format de données hiérarchique version 5) répond à ces défis grâce à une combinaison de modélisation de données flexible, de prise en charge d’E/S parallèles et d’intégration de métadonnées. Largement adopté par la NASA, la NOAA, les laboratoires du DOE et les institutions de recherche, HDF5 est devenu l’épine dorsale des archives de données scientifiques dans le monde[^1][^2].

Qu’est-ce que le HDF5 ? Architecture et concepts de base

HDF5 est à la fois un format de fichier et une bibliothèque logicielle qui fournit un conteneur pour des données scientifiques hétérogènes. Son architecture repose sur six entités fondamentales[^3] :

groupe : objets de conteneur analogues aux répertoires, organisation des données hiérarchique
Dataset : tableaux multidimensionnels contenant des données numériques ou structurées réelles
espace de données : décrit les dimensions de l’ensemble de données (forme, rang et étendue)
Type de données : spécifie les types d’éléments (entiers, flotteurs, chaînes, composés)
Attribut : petites métadonnées attachées à des groupes ou à des ensembles de données
Link : connecte les objets dans la hiérarchie (liens rigides et logiciels)

La structure hiérarchique

Un fichier HDF5 est un graphe dirigé avec un seul groupe racine (/). Les groupes peuvent contenir d’autres groupes et ensembles de données, permettant une imbrication arbitrairement profonde. Cette structure reflète un système de fichiers mais avec des différences clés :

Auto-descriptif : toutes les métadonnées (types de données, dimensions) se déplacent avec les données
Portable : format binaire indépendant de la plate-forme
Extensible : les ensembles de données peuvent être redimensionnés et les groupes/ensembles de données ajoutés dynamiquement
Compressé : le stockage basé sur des blocs permet des filtres de compression par bloc

/simulation
├── metadata
│   ├── title (attribute)
│   ├── creation_date (attribute)
│   └── parameters (group)
│       ├── mesh_size (dataset)
│       └── time_step (dataset)
├── fields
│   ├── temperature (dataset, 3D [x,y,z,time])
│   ├── velocity (dataset, 4D [x,y,z,time,component])
│   └── pressure (dataset, 3D)
└── output
    ├── checkpoint_001.h5 (external link)
    └── checkpoint_002.h5 (external link)

Pourquoi HDF5 pour la simulation scientifique ?

Par rapport aux formats de texte brut (CSV, JSON) ou aux formats binaires plus simples, HDF5 offre des avantages critiques :

E/S partielle : lecture uniquement des sous-ensembles nécessaires sans charger des ensembles de données entiers
Compression : la compression sans perte (GZIP, SZIP, LZF) réduit le stockage de 2 à 10 ×
Accès parallèle : plusieurs processus peuvent lire/écrire simultanément via MPI-IO
Riche des métadonnées : attributs des unités de document, des descriptions et de la provenance
Prise en charge des fichiers volumineux : gère les fichiers dépassant 2 Go (contrairement à l’ancien HDF4)
Plateforme croisée : fonctionne sous Linux, macOS, Windows ; Prise en charge de Python, C, C++, Fortran, Matlab, R

Pour les workflows de simulation, où les fichiers de point de contrôle, les sorties de séries chronologiques et les données de maillage doivent persister pendant des années, ces fonctionnalités ne sont pas facultatives ; Ils sont essentiels.

Comprendre l’organisation des données HDF5

Groupes et ensembles de données : les blocs de construction

Groupes Fournissent des espaces de noms et une organisation logique. Chaque fichier a un groupe racine (/), et vous pouvez créer des groupes imbriqués de manière arbitraire. Les groupes eux-mêmes ne stockent aucune donnée ; Ils contiennent des liens vers des jeux de données et d’autres groupes.

Les ensembles de données sont les résultats de votre simulation. Un ensemble de données est un tableau multidimensionnel avec des dimensions fixes ou extensibles. Modèles communs pour les données de simulation :

Champs 3D : (nx, ny, nz) Tableaux pour les variables spatiales
Série chronologique 4D : (nx, ny, nz, nt) Tableaux avec temps comme quatrième dimension
Tranches 2D : (nx, nt) pour les sondes de ligne ou les données de capteur
Données structurées : types de données composés pour les propriétés des particules (position, vitesse, masse)

Espaces de données : façonnage de vos données

Un espace de données définit la disposition logique d’un jeu de données. HDF5 prend en charge :

Scalaire : valeur unique (0-d)
Simple : tableau régulier à n dimensions avec des dimensions fixes ou illimitées
Complexe : sélections arbitraires utilisant des hyperslaves

Dimensions illimitées (axes extensibles) sont cruciaux pour les sorties de simulation où le nombre de pas de temps est inconnu au préalable.

Attributs : le pouvoir d’auto-descripteur

Les attributs sont de petits objets de métadonnées attachés à des groupes ou à des ensembles de données. Ils sont le mécanisme principal pour documenter vos données[^4]. Utilisez des attributs pour stocker :

Unités physiques ("m/s", "K", "Pa")
Description Chaînes
horodatage
Paramètres de simulation
Informations de citation
Version logicielle utilisée

# Example: Adding attributes with h5py
import h5py

with h5py.File('simulation.h5', 'w') as f:
    grp = f.create_group('temperature')
    dset = grp.create_dataset('field', data=temperature_array)
    
    dset.attrs['units'] = 'Kelvin'
    dset.attrs['long_name'] = 'Temperature field'
    dset.attrs['simulation_time'] = 1234.56

E/S parallèles avec HDF5

Qu’est-ce que le HDF5 parallèle ?

Parallel HDF5 (PHDF5) étend la bibliothèque standard avec la prise en charge MPI-IO, permettant à plusieurs processus d’accéder simultanément au même fichier HDF5. Ceci est essentiel pour les simulations à grande échelle s’exécutant sur des clusters HPC où le travail de calcul s’étend sur des centaines ou des milliers de cœurs[^5].

Comment cela fonctionne

Sous le capot, PHDF5 utilise MPI-IO (le sous-système d’E/S parallèle de MPI) pour coordonner l’accès. Lors de l’ouverture d’un fichier en mode parallèle, tous les processus du communicateur MPI partagent le même handle de fichiers et coordonnent les lectures/écritures.

# Parallel HDF5 example (requires h5py built with MPI support)
from mpi4py import MPI
import h5py

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()

# Each process opens the file collectively
with h5py.File('parallel_output.h5', 'w', driver='mpio', comm=comm) as f:
    # Create a dataset distributed across all processes
    # Each process writes its chunk of the global array
    local_data = compute_local_chunk(rank, size)
    dset = f.create_dataset('field', (global_nx, global_ny), dtype='f8')
    # Write using hyperslabs
    dset[local_slice] = local_data

E/S collectives ou indépendantes

Une distinction de performances critiques en parallèle HDF5 :

E/S collectives : tous les processus participent à la même opération d’E/S. La bibliothèque MPI peut optimiser le mouvement, l’agrégation et la bande de données. Utilisez ceci chaque fois que possible.
E/S Indépendante : Chaque processus s’ouvre, lit et écrit indépendamment. Cela entraîne de mauvaises performances en raison de la contention du système de fichiers et des opportunités d’optimisation manquées[^6].

Best Practice : structurez votre code afin que tous les processus appellent read() ou write() en même temps avec des sélections hyperslaves compatibles. Évitez les E/S conditionnelles que seuls certains processus s’exécutent.

Conseils de performances HDF5 parallèles

Ecrits d’agrégats : Écrivez en gros morceaux contigus, pas beaucoup de petits morceaux
Utiliser la mise en mémoire tampon : laissez le cache de la bibliothèque MPI et coalesce écrit
Alignement des morceaux avec la décomposition du processus : associez un jeu de données à la décomposition de votre domaine
Évitez le thrashing du système de fichiers : utilisez un fichier par étape de sortie, et non un seul fichier par processus.
Définir la taille de cache de blocs appropriée : augmenter le cache pour les ensembles de données fréquemment accédés

HDF5 avec Python : la bibliothèque H5PY

Le package H5PY fournit l’interface la plus pythonic de HDF5[^7].

Opérations de base

import h5py
import numpy as np

# Writing data
with h5py.File('output.h5', 'w') as f:
    # Create a dataset
    data = np.random.randn(1000, 1000)
    dset = f.create_dataset('temperature', data=data, compression='gzip')
    
    # Add attributes
    dset.attrs['units'] = 'K'
    dset.attrs['description'] = 'Temperature at final time step'
    
    # Create groups for organization
    grp = f.create_group('initial_conditions')
    grp.create_dataset('velocity', data=velocity_field)

# Reading data
with h5py.File('output.h5', 'r') as f:
    temp = f['temperature'][:]  # Load entire dataset
    # Or read a slice
    slice_ = f['temperature'][100:200, 300:400]
    
    # Access attributes
    units = f['temperature'].attrs['units']

Écriture efficace de la sortie de la simulation

Pour les simulations en fonction du temps, utilisez les ensembles de données extensibles avec une dimension temporelle illimitée :

with h5py.File('time_series.h5', 'w') as f:
    # Create dataset with unlimited maxshape
    dset = f.create_dataset(
        'temperature', 
        shape=(0, nx, ny), 
        maxshape=(None, nx, ny),  # Unlimited time dimension
        dtype='f8',
        chunks=(1, nx, ny)  # Chunk along time axis
    )
    
    # Append each time step
    for t in range(num_steps):
        current_temp = simulate_step(t)
        dset.resize((t+1, nx, ny))  # Extend dataset
        dset[t, :, :] = current_temp

Ajouter le mode pour les points de contrôle

Utilisez le mode d’ajout ('a') pour ajouter une nouvelle sortie aux fichiers existants sans écraser :

with h5py.File('run_001.h5', 'a') as f:
    if 'checkpoint_002' not in f:
        f.create_dataset('checkpoint_002', data=new_data)

Optimisation des performances : tronçonnage et compression

Chunking : la clé de la performance

HDF5 stocke les ensembles de données dans Chunks : des hyper-rectangles de taille fixe qui sont l’unité d’E/S et de compression[^8]. Le morceau est obligatoire pour :

Compression d’ensemble de données
Ensembles de données extensibles
Lectures/écritures partielles efficaces
E/S parallèle

La taille du morceau affecte considérablement les performances :

Trop petit : surcharges de métadonnées excessives, taux de compression médiocres, surcharge d’appels système élevée
Trop grand : la lecture d’un petit sous-ensemble charge l’intégralité du morceau en mémoire, ce qui gaspille la bande passante d’E/S

Règle du pouce : choisissez des morceaux qui correspondent à votre modèle d’accès typique. Pour les séries chronologiques 3D, accédées plan par plan, un bloc comme (1, nx, ny) ou (nt, nx, 1) en fonction de la dimension la plus rapide.

# Optimal chunking for 3D time-series where we read full XY planes
dset = f.create_dataset(
    'field',
    shape=(nt, nx, ny),
    chunks=(1, nx, ny),  # Each time step is one chunk
    compression='gzip'
)

# Reading one time step only decompresses one chunk
time_step_50 = dset[50, :, :]

Compression : échange de stockage contre CPU

HDF5 prend en charge plusieurs filtres de compression sans perte :

GZIP : universelle, bonne compression (2–5×), à forte intensité de processeur
Szip : rapide, matériel-accéléré sur certains systèmes, moins portable
LZF : compression très rapide et modérée (2×)
Blosc : multi-threads hautes performances (via une bibliothèque externe)

Quand compresser :

Stockage d’archives où la taille compte plus que la vitesse d’écriture
Charges de travail liées aux E/S où la surcharge de décompression est inférieure au temps de lecture du disque
Lorsque les données sont redondantes (champs lisses, valeurs répétées)

Quand éviter la compression :

Chemins d’écriture ultra-performants (intervalles de points de contrôle < 1 seconde)
Données déjà compressées (images, vidéos)
Lors de l’utilisation d’E/S parallèles avec des tailles de blocs incompatibles

# Compression examples
dset = f.create_dataset('data', data=data, compression='gzip', compression_opts=4)  # gzip level 4
dset = f.create_dataset('data', data=data, compression='lzf')  # Fast LZF

Configuration du cache

La bibliothèque HDF5 conserve deux caches :

Cache de métadonnées : stocke des informations sur les groupes, les jeux de données, les attributs
Chunk Cache : conserve les blocs de données récemment accédés

Pour les charges de travail critiques pour les performances, réglez ces caches via h5py :

with h5py.File('file.h5', 'w', libver='latest') as f:
    f.swmr_mode = True  # Enable Single-Writer-Multiple-Reader for concurrent access
    
# Configure chunk cache when opening
with h5py.File('file.h5', 'r', rdcc_nbytes=1024**3, rdcc_w0=0.75) as f:
    # 1 GB chunk cache, 75% preemption policy
    pass

Meilleures pratiques d’organisation des données

Modèles de structure de fichiers

Single-file-per-run : stockez toutes les sorties d’une simulation dans un seul fichier HDF5 avec une hiérarchie de groupe claire. Avantages :

Unité de transfert/archivage unique
Mises à jour atomiques (toutes les données sont écrites ou aucune)
Plus facile à valider l’intégrité

Checkpoints de plusieurs fichiers : séparez les fichiers de point de contrôle de la sortie finale. Utilisez des liens logiciels pour les connecter :

run_001.h5
├── /initial (link to checkpoint_000.h5:/data)
├── /final
│   └── field (dataset)
└── /checkpoints (group)
    ├── checkpoint_000.h5 (external link)
    ├── checkpoint_001.h5 (external link)
    └── checkpoint_002.h5 (external link)

Documentez tout avec des attributs

Les fichiers HDF5 peuvent devenir impénétrables sans documentation approfondie. Chaque groupe de données et chaque groupe doivent avoir des attributs descriptifs[^9] :

dset.attrs['units'] = 'm/s'
dset.attrs['long_name'] = 'Fluid velocity vector'
dset.attrs['standard_name'] = 'velocity'
dset.attrs['positive'] = 'up'  # For vertical components
dset.attrs['grid_mapping'] = '/mesh/x_grid'  # Link to coordinate variables
dset.attrs['comment'] = 'Computed using second-order upwind scheme'
dset.attrs['software'] = 'FiPy 3.4'
dset.attrs['git_commit'] = 'abc123def'

Envisagez d’adopter les Conventions sur le climat et les prévisions (CF) pour les simulations géophysiques ou les normes de métadonnées spécifiques à un domaine, lorsqu’elles sont disponibles.

Éviter la prolifération des jeux de données

Alors que HDF5 autorise des millions d’ensembles de données, les performances se dégradent avec un nombre excessif[^10]. Préférez :

Moins de grands ensembles de données sur de nombreux petits
Types de données composés pour les champs scalaires associés (par exemple, position des particules + vitesse + masse)
Regroupement de petits tableaux similaires dans un seul ensemble de données structuré

défragmenter les fichiers volumineux

Au fil du temps, les fichiers HDF5 peuvent devenir fragmentés au fur et à mesure que les jeux de données sont créés et supprimés. Utilisez h5repack pour réécrire les fichiers de manière optimale :

h5repack -f GZIP=4 input.h5 output_compressed.h5
h5repack -l CHUNK=100x100x100 input.h5 rechunked.h5

Alternatives HDF5 vs : NetCDF4, ZARR, CSV

Résumé de la comparaison

Fonctionnalité	HDF5	NetCDF-4	zarr	CSV/JSON
E/S parallèles	✅ MPI-IO	✅ MPI-IO	✅ (Optimisé en nuage)	❌
Compression	Plusieurs filtres	Gzip/Szip	Plusieurs (blosc, gzip)	❌
Fichier unique	✅	✅	❌ (répertoire)	✅
Cloud-Natif	⚠️ (avec HSD)	⚠️	✅	✅
Python-premier	⚠️ (H5PY)	✅ (NetCDF4)	✅	✅
métadonnées	Attributs riches	Conventions de FC	Attributs riches	Limité
Courbe d’apprentissage	Raide	Modérer	Facile	Banal
Conservation	✅ Excellent	✅ Excellent	⚠️ Évoluant	✅ Lisible par l’homme

Quand choisir HDF5

Environnements HPC : simulations parallèles basées sur MPI
Archives à long terme : format éprouvé avec 20 ans et plus d’antécédents[^1]
Hiérarchies complexes : structures de groupe approfondies, types de données mixtes
Grandes données binaires : images, champs 3D, matrices
Cross-langue : besoin de la compatibilité C/FORTRAN/MATLAB

Quand netcdf-4 ou zarr peut être meilleur

Climat/Science atmosphérique : NETCDF-4 avec les conventions des FC est la norme communautaire
Cloud Storage : la mise en page de Zarr dans les répertoires fonctionne mieux avec les magasins d’objets (S3, GCS)
Série chronologique simple : ZARR ou NETCDF4 proposent des API plus simples
Prototypage rapide : l’implémentation de Pure-Python de Zarr n’a aucune dépendance de compilation en temps de compilation

Pour la plupart des projets de simulation scientifiques, en particulier ceux impliquant des solveurs PDE comme FIPY, HDF5 reste l’option la plus capable et la plus largement prise en charge[^11].

Stockage et conservation à long terme

Pourquoi HDF5 est de qualité archivistique

La Bibliothèque du Congrès et Archives nationales reconnaissent que HDF5 est un format approprié pour la conservation à long terme[^1]. Facteurs clés :

Open Standard : non propriétaire, maintenu par le groupe HDF (à but non lucratif)
Descriptif auto-décrit : aucun fichier de schéma externe n’est nécessaire pour interpréter les données
Indépendant de la plate-forme : le format binaire fonctionne sur n’importe quelle architecture
Adoption large : utilisé par la NASA, la NOAA, le DOE, l’ESA ; Des milliers d’outils existent
Spécification stable : HDF5 1.10+ est rétrocompatible ; Les changements de format sont rares

Meilleures pratiques de conservation

Utiliser les formats numériques IEEE : évitez les formats « natifs » qui lient les données à une endianness matérielle spécifique[^1]
Document à fond : inclure des unités, des descriptions, des versions de logiciels et des citations comme attributs
Inclure un README : stocker la documentation lisible par l’homme en tant qu’attribut ou fichier compagnon
Valider les fichiers : utilisez h5dump ou h5py pour vérifier l’intégrité avant l’archivage.
Préservez le logiciel : archivez la version exacte de la bibliothèque HDF5 (ou un conteneur Docker) utilisée pour créer le fichier.
Évitez la compression exotique : le gzip standard est le plus sûr ; Les filtres personnalisés peuvent ne pas être pris en charge dans 20 ans

Des pièges courants qui risquent des données

Aucune journalisation : HDF5 manque de journaux de transactions. Si un processus plante pendant l’écriture, le fichier peut devenir corruption et irrécupérable[^12]. Écrivez toujours dans un fichier temporaire et renommez-le à la fin.
Écriture parallèle : plusieurs écrivains sans synchronisation appropriée provoquent la corruption. Utilisez le mode SWMR ou les E/S collectives.
Types de données incompatibles : Lecture d’un jeu de données avec le mauvais type de données déforme les données. Vérifiez toujours dtype les correspondances entre l’écrivain et le lecteur.
La suppression des jeux de données ne réduit pas les fichiers : HDF5 marque l’espace comme étant libre en interne mais ne réduit pas la taille du fichier. Utilisez h5repack pour récupérer de l’espace disque.

Liste de contrôle pratique : HDF5 pour les projets de simulation

Avant d’utiliser HDF5 dans votre flux de travail de simulation :

Choisissez des tailles de blocs en fonction des modèles d’accès typiques (non arbitraires)
Activer la compression pour les sorties d’archives, désactivez les données de point de contrôle à chaud
Documentez chaque jeu de données avec des unités, des descriptions et des logiciels de création
Utilisez des ensembles de données extensibles pour les séries chronologiques afin d’éviter la préallocation
Valider les écritures parallèles avec des opérations collectives et non des E/S indépendantes
Fermer toutes les poignées de fichiers (Utiliser les gestionnaires de contexte : with h5py.File(...))
Backup Critical Runs pour séparer le stockage avant le post-traitement
Récupération des tests : simulez des plantages pour s’assurer que les fichiers partiels sont détectés
Considérez NetCDF-4 si votre communauté utilise déjà les conventions de CF
Pour le stockage en nuage, évaluez ZARR comme un format alternatif

Liens internes et guides connexes

La compréhension de HDF5 est cruciale pour gérer les sorties de simulation dans divers guides MatForge :

Gérer les problèmes de PDE à grande échelle couvre les stratégies HPC dans lesquelles les E/S parallèles HDF5 excelle.
Utiliser FIPY pour la modélisation en champ de phase démontre la sauvegarde des résultats de simulation en HDF5 pour une analyse ultérieure.
visualiser efficacement les résultats de la simulation montre comment lire les sorties HDF5 pour le post-traitement avec Paraview ou MatPlotlib.
La reproductibilité et son rôle dans le débogage expliquent comment la nature auto-décrite de HDF5 facilite la recherche reproductible.

recommandations et quand choisir ce

Pour la plupart des simulations basées sur l’EDP (y compris les utilisateurs de Fipy) :

Commencez avec HDF5 + H5PY pour sa maturité et sa prise en charge MPI
Utilisez la compression GZIP au niveau 4-6 pour les sorties d’archives (bon équilibre entre vitesse/taille)
Dimensation de temps comme (1, nx, ny) pour les séries temporelles 3D
Stocker les tableaux de coordonnées (x, y, z) en tant que jeux de données distincts avec des unités
Ajouter un groupe /metadata avec des paramètres de simulation, des versions de logiciels et des hachages Git

Considérez les alternatives quand :

Travailler exclusivement en Python et besoin de stockage cloud natif → Zarr
Construire des modèles climatiques/atmosphériques avec des conventions standard → NETCDF-4
Besoin de sorties simples lisibles par l’homme → CSV/JSON (mais attendez-vous à une taille de fichier importante et une E/S lente)

Conclusion

HDF5 est la base d’une gestion robuste des données scientifiques. Sa combinaison d’organisation hiérarchique, d’E/S parallèles, de compression et de métadonnées riches en fait une solution idéale pour les sorties de simulation qui doivent persister pendant des années tout en restant accessibles sur les plates-formes et les langages de programmation.

Cependant, le pouvoir du format vient avec la responsabilité. Les mauvais choix de coupure, l’ignorance des schémas d’E/S collectifs et les métadonnées inadéquates peuvent compromettre les performances et la convivialité à long terme. Suivez les meilleures pratiques décrites ici, en particulier en ce qui concerne la stratégie de segmentation, la documentation des attributs et les modèles d’accès parallèles, pour vous assurer que vos données de simulation restent à la fois performantes et préservables.

Le HDF5 n’est pas le format le plus récent, mais ses 20 ans et plus de stabilité et son adoption généralisée dans les principales institutions de recherche en font le pari le plus sûr pour les projets où la longévité des données est importante[^1][^2].

Lectures complémentaires

Guide de l’utilisateur HDF5 (documentation officielle)
Documentation H5PY
E/S parallèles avec HDF5 (le blog du groupe HDF)
Meilleures pratiques NASA HDF5 (NASA EarthData)

[^1] : Bibliothèque du Congrès. « HDF5, format de données hiérarchique, version 5. » Format Description Document. Disponible via Clarin : https://standards.clarin.eu/sis/views/view-format.xq?id=fhdf5
[^2] : le groupe HDF. « HDF5 : une nouvelle génération de HDF. » https://www.hdfgroup.org/solutions/hdf5/
[^3] : groupe HDF. « Modèle de données HDF5 et structure de fichiers. » https://support.hdfgroup.org/documentation/hdf5/latest/_h5_d_m_u_g.html
[^4] : groupe HDF. « Attributs HDF5. » https://support.hdfgroup.org/documentation/hdf5/latest/_h5_a__u_g.html
[^5] : NERSC. « Introduction aux E/S scientifiques. » https://support.hdfgroup.org/documentation/hdf5-docs/hdf5_topics/2016_nersc_introduction_to_scientific_io.pdf
[^6] : LRZ. « Guide des meilleures pratiques – E/S parallèles. » https://doku.lrz.de/files/10746566/10746567/11/175 5197969103/meilleure-pratique-guide-parallèle-io.pdf
[^7] : Projet H5PY. « Documentation H5PY. » https://docs.h5py.org/en/latest/
[^8] : groupe HDF. « Chunking en HDF5. » https://support.hdfgroup.org/documentation/hdf5-docs/advanced_topics/chunking_in_hdf5.html
[^9] : groupe HDF. « Obtenir des E/S hautes performances avec HDF5. » https://support.hdfgroup.org/documentation/hdf5-docs/hdf5_topics/20200206_ecptutorial-final.pdf
[^10] : Forum HDF. « Des questions sur la taille et le nombre d’un ensemble de données HDF5. » https://forum.hdfgroup.org/t/hdf5-dataset-size-and-number-questions/12215
[^11] : Ambatipudi et al. « Une comparaison de HDF5, ZARR et NETCDF4 dans les opérations d’E/S courantes. » arxiv:2207.09503, 2022.
[^12] : Forum HDF. « HDF5 Corruption ou perte de données possible ? » https://stackoverflow.com/questions/35837243/hdf5-possible-data-corruption-or-loss