Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
BasicCheckpointService.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2024 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/* BasicCheckpointService.cc (C) 2000-2024 */
9/* */
10/* Service basique de protection/reprise. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/std/internal/BasicReader.h"
15#include "arcane/std/internal/BasicWriter.h"
16
17#include "arcane/utils/StringBuilder.h"
18#include "arcane/utils/OStringStream.h"
19#include "arcane/utils/PlatformUtils.h"
20
21#include "arcane/core/IXmlDocumentHolder.h"
22#include "arcane/core/IParallelMng.h"
23#include "arcane/core/CheckpointService.h"
24#include "arcane/core/Directory.h"
25#include "arcane/core/IParallelReplication.h"
26#include "arcane/core/IVariableUtilities.h"
27#include "arcane/core/VerifierService.h"
28#include "arcane/core/IVariableMng.h"
29#include "arcane/core/CheckpointInfo.h"
30
31#include "arcane/std/ArcaneBasicCheckpoint_axl.h"
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
36namespace Arcane
37{
38using namespace Arcane::impl;
39
40/*---------------------------------------------------------------------------*/
41/*---------------------------------------------------------------------------*/
45class ArcaneBasicCheckpointService
47{
48 public:
49
50 struct MetaData
51 {
52 int m_version = -1;
53 static MetaData parse(const String& meta_data, ITraceMng* tm)
54 {
55 auto doc_ptr = IXmlDocumentHolder::loadFromBuffer(meta_data.bytes(), "MetaData", tm);
56 ScopedPtrT<IXmlDocumentHolder> xml_doc(doc_ptr);
57 XmlNode root = xml_doc->documentNode().documentElement();
58 Integer version = root.attr("version").valueAsInteger();
59 if (version != 1)
60 ARCANE_THROW(ReaderWriterException, "Bad checkpoint metadata version '{0}' (expected 1)", version);
61 MetaData md;
62 md.m_version = version;
63 return md;
64 }
65 };
66
67 public:
68
69 explicit ArcaneBasicCheckpointService(const ServiceBuildInfo& sbi)
71 , m_write_index(0)
72 , m_writer(nullptr)
73 , m_reader(nullptr)
74 {}
75 IDataWriter* dataWriter() override { return m_writer; }
76 IDataReader* dataReader() override { return m_reader; }
77
78 void notifyBeginWrite() override;
79 void notifyEndWrite() override;
80 void notifyBeginRead() override;
81 void notifyEndRead() override;
82 void close() override {}
83 String readerServiceName() const override { return "ArcaneBasicCheckpointReader"; }
84
85 private:
86
87 Integer m_write_index;
88 BasicWriter* m_writer;
89 BasicReader* m_reader;
90
91 private:
92
93 String _defaultFileName()
94 {
95 info() << "USE DEFAULT FILE NAME index=" << currentIndex();
96 IParallelReplication* pr = subDomain()->parallelMng()->replication();
97
98 String buf = "arcanedump";
99 if (pr->hasReplication()) {
100 buf = buf + "_r";
101 buf = buf + pr->replicationRank();
102 }
103 info() << "FILE_NAME is " << buf;
104 return buf;
105 }
106 Directory _defaultDirectory()
107 {
108 return Directory(baseDirectoryName());
109 }
110};
111
112/*---------------------------------------------------------------------------*/
113/*---------------------------------------------------------------------------*/
120class ArcaneBasic2CheckpointService
121: public ArcaneBasicCheckpointService
122{
123 public:
124
125 explicit ArcaneBasic2CheckpointService(const ServiceBuildInfo& sbi)
126 : ArcaneBasicCheckpointService(sbi)
127 {}
128 String readerServiceName() const override { return "ArcaneBasic2CheckpointReader"; }
129};
130
131/*---------------------------------------------------------------------------*/
132/*---------------------------------------------------------------------------*/
133
136{
137 String meta_data_str = readerMetaData();
138 MetaData md = MetaData::parse(meta_data_str, traceMng());
139
140 info() << " GET META DATA READER " << readerMetaData()
141 << " version=" << md.m_version
142 << " filename=" << fileName();
143
144 String filename = fileName();
145 if (filename.null()) {
146 Directory dump_dir(_defaultDirectory());
147 filename = dump_dir.file(_defaultFileName());
148 setFileName(filename);
149 }
150 filename = filename + "_n" + currentIndex();
151 info() << " READ CHECKPOINT FILENAME = " << filename;
152 IParallelMng* pm = subDomain()->parallelMng();
153 IApplication* app = subDomain()->application();
154 bool want_parallel = false;
155 m_reader = new BasicReader(app, pm, A_NULL_RANK, filename, want_parallel);
156 m_reader->initialize();
157}
158
159/*---------------------------------------------------------------------------*/
160/*---------------------------------------------------------------------------*/
161
164{
165 delete m_reader;
166 m_reader = nullptr;
167}
168
169/*---------------------------------------------------------------------------*/
170/*---------------------------------------------------------------------------*/
171
174{
175 auto open_mode = BasicReaderWriterCommon::OpenModeAppend;
176 Integer write_index = checkpointTimes().size();
177 --write_index;
178 if (write_index == 0)
179 open_mode = BasicReaderWriterCommon::OpenModeTruncate;
180
181 String filename = fileName();
182 if (filename.null()) {
183 Directory dump_dir(_defaultDirectory());
184 filename = dump_dir.file(_defaultFileName());
185 setFileName(filename);
186 }
187 filename = filename + "_n" + write_index;
188
189 Int32 version = 2;
190 Ref<IDataCompressor> data_compressor;
191 if (options()) {
192 version = options()->formatVersion();
193 // N'utilise la compression qu'à partir de la version 3 car cela est
194 // incompatible avec les anciennes versions
195 if (version >= 3) {
196 data_compressor = options()->dataCompressor.instanceRef();
197 }
198 }
199
200 info() << "Writing checkpoint with 'ArcaneBasicCheckpointService'"
201 << " version=" << version
202 << " filename='" << filename << "'\n";
203
205
206 IParallelMng* pm = subDomain()->parallelMng();
207 IApplication* app = subDomain()->application();
208 bool want_parallel = pm->isParallel();
209 want_parallel = false;
210 m_writer = new BasicWriter(app, pm, filename, open_mode, version, want_parallel);
211 m_writer->setDataCompressor(data_compressor);
212 m_writer->initialize();
213}
214
215/*---------------------------------------------------------------------------*/
216/*---------------------------------------------------------------------------*/
217
220{
221 OStringStream ostr;
222 ostr() << "<infos";
223 const int meta_data_version = 1;
224 ostr() << " version='" << meta_data_version << "'";
225 ostr() << "/>\n";
226 setReaderMetaData(ostr.str());
227 ++m_write_index;
228 delete m_writer;
229 m_writer = nullptr;
230}
231
232/*---------------------------------------------------------------------------*/
233/*---------------------------------------------------------------------------*/
237class ArcaneBasic2CheckpointReaderService
238: public AbstractService
239, public ICheckpointReader2
240{
241 public:
242
243 explicit ArcaneBasic2CheckpointReaderService(const ServiceBuildInfo& sbi)
244 : AbstractService(sbi)
245 , m_application(sbi.application())
246 , m_reader(nullptr)
247 {}
248 IDataReader2* dataReader() override { return m_reader; }
249
250 void notifyBeginRead(const CheckpointReadInfo& cri) override;
251 void notifyEndRead() override;
252
253 private:
254
255 IApplication* m_application;
256 BasicReader* m_reader;
257
258 private:
259
260 String _defaultFileName(const CheckpointInfo& ci)
261 {
262 Integer index = ci.checkpointIndex();
263 bool has_replication = ci.nbReplication() > 1;
264 Int32 replication_rank = ci.replicationRank();
265 info() << "USE DEFAULT FILE NAME index=" << index;
266
267 String buf = "arcanedump";
268 if (has_replication) {
269 buf = buf + "_r";
270 buf = buf + replication_rank;
271 }
272 info() << "FILE_NAME is " << buf;
273 return buf;
274 }
275};
276
277/*---------------------------------------------------------------------------*/
278/*---------------------------------------------------------------------------*/
279
282{
283 const CheckpointInfo& ci = cri.checkpointInfo();
284 String reader_meta_data_str = ci.readerMetaData();
285 auto md = ArcaneBasicCheckpointService::MetaData::parse(reader_meta_data_str, traceMng());
286
287 info() << "Basic2CheckpointReader GET META DATA READER " << reader_meta_data_str
288 << " version=" << md.m_version;
289
290 Directory dump_dir(ci.directory());
291 String filename = dump_dir.file(_defaultFileName(ci));
292 filename = filename + "_n" + ci.checkpointIndex();
293 ;
294 info() << " READ CHECKPOINT FILENAME = " << filename;
295 IParallelMng* pm = cri.parallelMng();
296 bool want_parallel = false;
297 m_reader = new BasicReader(m_application, pm, ci.subDomainRank(), filename, want_parallel);
298 m_reader->initialize();
299}
300
301/*---------------------------------------------------------------------------*/
302/*---------------------------------------------------------------------------*/
303
306{
307 delete m_reader;
308 m_reader = nullptr;
309}
310
311/*---------------------------------------------------------------------------*/
312/*---------------------------------------------------------------------------*/
313
315 ServiceProperty("ArcaneBasicCheckpointWriter", ST_SubDomain | ST_CaseOption),
317
319 ServiceProperty("ArcaneBasicCheckpointReader", ST_SubDomain),
321
323 ServiceProperty("ArcaneBasic2CheckpointWriter", ST_SubDomain | ST_CaseOption),
325
327 ServiceProperty("ArcaneBasic2CheckpointReader", ST_Application),
329
330/*---------------------------------------------------------------------------*/
331/*---------------------------------------------------------------------------*/
332
333} // End namespace Arcane
334
335/*---------------------------------------------------------------------------*/
336/*---------------------------------------------------------------------------*/
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_SERVICE_INTERFACE(ainterface)
Macro pour déclarer une interface lors de l'enregistrement d'un service.
AbstractService(const ServiceBuildInfo &)
Constructeur à partir d'un ServiceBuildInfo.
ArcaneArcaneBasicCheckpointObject(const Arcane::ServiceBuildInfo &sbi)
Constructeur.
CaseOptionsArcaneBasicCheckpoint * options() const
Options du jeu de données du service.
void notifyBeginRead(const CheckpointReadInfo &cri) override
Notifie qu'une protection va être lue avec les informations issues de checkpoint_info.
void notifyEndRead() override
Notifie de la fin de la lecture d'une protection.
IDataReader2 * dataReader() override
Retourne le lecteur de données associé à ce lecteur de protection.
Protection/reprise basique (version 2).
String readerServiceName() const override
Nom du service du lecteur associé à cet écrivain.
Protection/reprise basique (version 1).
String readerServiceName() const override
Nom du service du lecteur associé à cet écrivain.
void notifyEndRead() override
Notifie qu'une protection vient d'être lue.
void notifyBeginRead() override
Notifie qu'une protection va être lue avec les paramètres courants.
void notifyBeginWrite() override
Notifie qu'une protection va être écrite avec les paramètres courants.
IDataReader * dataReader() override
Retourne le lecteur associé
void notifyEndWrite() override
Notifie qu'une protection vient d'être écrite.
IDataWriter * dataWriter() override
Retourne l'écrivain associé.
void close() override
Ferme les protections.
Informations sur une protection.
Informations de relecture d'une protection.
virtual void setReaderMetaData(const String &s)
Méta données associées à ce lecteur.
virtual void setFileName(const String &file_name)
Positionne le nom du fichier de la protection.
virtual String fileName() const
Nom du fichier de la protection.
RealConstArrayView checkpointTimes() const
Temps des protections.
virtual String baseDirectoryName() const
Nom du répertoire de base de la protection.
virtual String readerMetaData() const
Méta données pour le lecteur associé à cet écrivain.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Classe gérant un répertoire.
Definition Directory.h:33
virtual String file(const String &file_name) const
Retourne le chemin complet du fichier file_name dans le répertoire.
Definition Directory.cc:138
Interface de l'application.
Interface du service de lecture d'une protection/reprise (V2)
Interface du service de lecture d'une protection/reprise.
Interface du service d'écriture d'une protection/reprise.
Interface de lecture des données d'une variable (Version 2)
Interface de lecture des données d'une variable.
Definition IDataReader.h:41
Interface d'écriture des données d'une variable.
Definition IDataWriter.h:49
Interface du gestionnaire de parallélisme pour un sous-domaine.
virtual IParallelReplication * replication() const =0
Informations sur la réplication.
virtual bool isParallel() const =0
Retourne true si l'exécution est parallèle.
Informations sur la réplication des sous-domaines en parallèle.
virtual bool hasReplication() const =0
Indique si la réplication est active.
virtual Int32 replicationRank() const =0
Rang dans la réplication (de 0 à nbReplication()-1)
virtual IParallelMng * parallelMng()=0
Retourne le gestionnaire de parallélisme.
Interface du gestionnaire de traces.
static IXmlDocumentHolder * loadFromBuffer(Span< const Byte > buffer, const String &name, ITraceMng *tm)
Charge un document XML.
Definition DomUtils.cc:426
Flot de sortie lié à une String.
Exception dans un lecteur ou écrivain.
Référence à une instance.
Encapsulation d'un pointeur qui se détruit automatiquement.
Definition ScopedPtr.h:44
IApplication * application() const
Accès à l'application IApplication associé.
Structure contenant les informations pour créer un service.
Propriétés de création d'un service.
Chaîne de caractères unicode.
bool null() const
Retourne true si la chaîne est nulle.
Definition String.cc:304
Span< const Byte > bytes() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:291
TraceMessage info() const
Flot pour un message d'information.
ITraceMng * traceMng() const
Gestionnaire de trace.
Noeud d'un arbre DOM.
Definition XmlNode.h:51
XmlNode attr(const String &name, bool throw_exception=false) const
Retourne l'attribut de nom name.
Definition XmlNode.cc:248
Integer valueAsInteger(bool throw_exception=false) const
Valeur du noeud convertie en entier.
Definition XmlNode.cc:432
Lecture/Ecriture simple.
Definition BasicWriter.h:38
#define ARCANE_REGISTER_SERVICE(aclass, a_service_property,...)
Macro pour enregistrer un service.
ARCCORE_BASE_EXPORT bool recursiveCreateDirectory(const String &dir_name)
Créé un répertoire.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Int32 Integer
Type représentant un entier.
@ ST_Application
Le service s'utilise au niveau de l'application.
@ ST_CaseOption
Le service s'utilise au niveau du jeu de données.
@ ST_SubDomain
Le service s'utilise au niveau du sous-domaine.
std::int32_t Int32
Type entier signé sur 32 bits.