portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2024-09-20 09:15:38 +01:00
Code Releases Activity

Revert "Hadrons: A2A vector write can fail and retry"

Browse Source 
This reverts commit 10fc263675.
This commit is contained in:
Antonin Portelli 2018-11-27 17:27:26 +00:00
parent 0e3035c51d
commit c7f33ca2a8
2 changed files with 25 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
Hadrons/A2AVectors.hpp
View File

@ -83,14 +83,9 @@ public:
Record(void): index(0) {} Record(void): index(0) {}
}; };
public: public:
// maxRetry meaning:
// -1: don't read back to check (default)
// 0: read to check, and crash (assert) in case of failure
// n > 0: read to check, retry to write n times before crashing
template <typename Field> template <typename Field>
static void write(const std::string fileStem, std::vector<Field> &vec, static void write(const std::string fileStem, std::vector<Field> &vec,
const bool multiFile, const int trajectory = -1, const bool multiFile, const int trajectory = -1);
const int maxRetry = -1);
template <typename Field> template <typename Field>
static void read(std::vector<Field> &vec, const std::string fileStem, static void read(std::vector<Field> &vec, const std::string fileStem,
const bool multiFile, const int trajectory = -1); const bool multiFile, const int trajectory = -1);
@ -263,13 +258,12 @@ void A2AVectorsSchurDiagTwo<FImpl>::makeHighModeW5D(FermionField &wout_4d,
******************************************************************************/ ******************************************************************************/
template <typename Field> template <typename Field>
void A2AVectorsIo::write(const std::string fileStem, std::vector<Field> &vec, void A2AVectorsIo::write(const std::string fileStem, std::vector<Field> &vec,
const bool multiFile, const int trajectory, const int maxRetry) const bool multiFile, const int trajectory)
{ {
Record record; Record record;
GridBase *grid = vec[0]._grid; GridBase *grid = vec[0]._grid;
ScidacWriter binWriter(grid->IsBoss()); ScidacWriter binWriter(grid->IsBoss());
std::string filename = vecFilename(fileStem, trajectory, multiFile); std::string filename = vecFilename(fileStem, trajectory, multiFile);
Field buf(grid);
if (multiFile) if (multiFile)
{ {
@ -277,86 +271,27 @@ void A2AVectorsIo::write(const std::string fileStem, std::vector<Field> &vec,
for (unsigned int i = 0; i < vec.size(); ++i) for (unsigned int i = 0; i < vec.size(); ++i)
{ {
int status = GridLimeReader::LIME_READ_FAILURE, attempt = std::max(0, maxRetry); fullFilename = filename + "/elem" + std::to_string(i) + ".bin";
while ((status != GridLimeReader::LIME_READ_SUCCESS) and (attempt >= 0)) LOG(Message) << "Writing vector " << i << std::endl;
{ makeFileDir(fullFilename, grid);
fullFilename = filename + "/elem" + std::to_string(i) + ".bin"; binWriter.open(fullFilename);
record.index = i;
LOG(Message) << "Writing vector " << i << std::endl; binWriter.writeScidacFieldRecord(vec[i], record);
makeFileDir(fullFilename, grid); binWriter.close();
binWriter.open(fullFilename);
record.index = i;
binWriter.writeScidacFieldRecord(vec[i], record);
binWriter.close();
if (maxRetry < -1)
{
status = GridLimeReader::LIME_READ_SUCCESS;
}
else if (attempt >= 0)
{
ScidacReader binReader;
LOG(Message) << "Reading back vector " << i
<< " (" << attempt << " attempt(s) left)" << std::endl;
binReader.open(fullFilename);
status = binReader.readScidacFieldRecord(buf, record, false);
if (status != GridLimeReader::LIME_READ_SUCCESS)
{
LOG(Message) << "Read failure" << std::endl;
}
attempt--;
}
}
if (status != GridLimeReader::LIME_READ_SUCCESS)
{
HADRONS_ERROR(Io, "I/O error while writing vector " + std::to_string(i));
}
} }
} }
else else
{ {
int status = GridLimeReader::LIME_READ_FAILURE, attempt = std::max(0, maxRetry); makeFileDir(filename, grid);
binWriter.open(filename);
while ((status != GridLimeReader::LIME_READ_SUCCESS) and (attempt >= 0)) for (unsigned int i = 0; i < vec.size(); ++i)
{ {
makeFileDir(filename, grid); LOG(Message) << "Writing vector " << i << std::endl;
binWriter.open(filename); record.index = i;
for (unsigned int i = 0; i < vec.size(); ++i) binWriter.writeScidacFieldRecord(vec[i], record);
{
LOG(Message) << "Writing vector " << i << std::endl;
record.index = i;
binWriter.writeScidacFieldRecord(vec[i], record);
}
binWriter.close();
if (maxRetry < -1)
{
status = GridLimeReader::LIME_READ_SUCCESS;
}
else if (attempt >= 0)
{
ScidacReader binReader;
binReader.open(filename);
LOG(Message) << "Reading back vector set ("
<< attempt << " attempt(s) left)" << std::endl;
for (unsigned int i = 0; i < vec.size(); ++i)
{
LOG(Message) << "Reading vector " << i << std::endl;
status = binReader.readScidacFieldRecord(buf, record, false);
if (status != GridLimeReader::LIME_READ_SUCCESS)
{
LOG(Message) << "Read failure" << std::endl;
break;
}
}
attempt--;
}
}
if (status != GridLimeReader::LIME_READ_SUCCESS)
{
HADRONS_ERROR(Io, "I/O error while writing vector set");
} }
binWriter.close();
} }
} }

30
Hadrons/Modules/MSolver/A2AVectors.hpp
View File

@ -44,24 +44,16 @@ BEGIN_HADRONS_NAMESPACE
******************************************************************************/ ******************************************************************************/
BEGIN_MODULE_NAMESPACE(MSolver) BEGIN_MODULE_NAMESPACE(MSolver)
class A2AVectorsIoPar: Serializable
{
public:
GRID_SERIALIZABLE_CLASS_MEMBERS(A2AVectorsIoPar,
std::string, filestem,
bool, multiFile,
int, maxRetry);
};
class A2AVectorsPar: Serializable class A2AVectorsPar: Serializable
{ {
public: public:
GRID_SERIALIZABLE_CLASS_MEMBERS(A2AVectorsPar, GRID_SERIALIZABLE_CLASS_MEMBERS(A2AVectorsPar,
std::string, noise, std::string, noise,
std::string, action, std::string, action,
std::string, eigenPack, std::string, eigenPack,
std::string, solver, std::string, solver,
A2AVectorsIoPar, output); std::string, output,
bool, multiFile);
}; };
template <typename FImpl, typename Pack> template <typename FImpl, typename Pack>
@ -248,17 +240,13 @@ void TA2AVectors<FImpl, Pack>::execute(void)
} }
// I/O if necessary // I/O if necessary
if (!par().output.filestem.empty()) if (!par().output.empty())
{ {
startTimer("V I/O"); startTimer("V I/O");
A2AVectorsIo::write(par().output.filestem + "_v", v, A2AVectorsIo::write(par().output + "_v", v, par().multiFile, vm().getTrajectory());
par().output.multiFile, vm().getTrajectory(),
par().output.maxRetry);
stopTimer("V I/O"); stopTimer("V I/O");
startTimer("W I/O"); startTimer("W I/O");
A2AVectorsIo::write(par().output.filestem + "_w", w, A2AVectorsIo::write(par().output + "_w", w, par().multiFile, vm().getTrajectory());
par().output.multiFile, vm().getTrajectory(),
par().output.maxRetry);
stopTimer("W I/O"); stopTimer("W I/O");
} }
} }