Merge branch 'release/v1.4'

Author: aportelli

.gitignore

@@ -14,3 +14,5 @@ Makefile.in
 /Hadrons/sqlite
 /Hadrons/Modules.hpp
 /Hadrons/modules.inc
+.DS_Store
+*~

Hadrons/A2AMatrix.hpp

@@ -1,5 +1,5 @@
 /*
- * A2AMatrix.hpp, part of Hadrons (https://github.com/aportelli/Hadrons)
+ * A2AMatrix.hpp, part of Hadrons ()
  *
  * Copyright (C) 2015 - 2020
  *
@@ -45,6 +45,10 @@
 #define HADRONS_A2AM_IO_TYPE ComplexF
 #endif
 
+#ifndef DISTIL_NT_CHUNK_SIZE
+#define DISTIL_NT_CHUNK_SIZE 1
+#endif
+
 #define HADRONS_A2AM_PARALLEL_IO
 
 BEGIN_HADRONS_NAMESPACE
@@ -104,11 +108,22 @@ class A2AMatrixIo
     void initFile(const MetadataType &d, const unsigned int chunkSize);
     // block I/O
     void saveBlock(const T *data, const unsigned int i, const unsigned int j,
-                   const unsigned int blockSizei, const unsigned int blockSizej);
+                   const unsigned int blockSizei, const unsigned int blockSizej, std::string datasetName="");
     void saveBlock(const A2AMatrixSet<T> &m, const unsigned int ext, const unsigned int str,
                    const unsigned int i, const unsigned int j);
+    //distillation overloads and new methods
+    template <typename MetadataType>
+    void initFile(const MetadataType &d);
+    void createDilutionBlock(std::string datasetName, const unsigned int chunkSize, const std::vector<unsigned int> timeSlices);
+    void saveBlock(const A2AMatrixSet<T> &m,
+                               const unsigned int ext, const unsigned int str,
+                               const unsigned int i, const unsigned int j, std::string datasetName,
+                               const std::vector<unsigned int> timeSlices, const unsigned int chunkSize);
+    void saveBlock(const A2AMatrixSet<T> &m, const unsigned int ext, const unsigned int str,
+                   const unsigned int i, const unsigned int j,
+                   std::string datasetName);
     template <template <class> class Vec, typename VecT>
-    void load(Vec<VecT> &v, double *tRead = nullptr, GridBase *grid = nullptr);
+    void load(Vec<VecT> &v, double *tRead = nullptr, GridBase *grid = nullptr, std::string datasetName="");
 private:
     std::string  filename_{""}, dataname_{""};
     unsigned int nt_{0}, ni_{0}, nj_{0};
@@ -460,13 +475,28 @@ void A2AMatrixIo<T>::initFile(const MetadataType &d, const unsigned int chunkSiz
 #endif
 }
 
+//distillation overloads
+template <typename T>
+template <typename MetadataType>
+void A2AMatrixIo<T>::initFile(const MetadataType &d)
+{
+#ifdef HAVE_HDF5
+    Hdf5Writer writer(filename_);
+    push(writer, dataname_);    //creates main h5 group
+    write(writer, "Metadata", d);
+#else
+    HADRONS_ERROR(Implementation, "all-to-all matrix I/O needs HDF5 library");
+#endif
+}
+
 // block I/O ///////////////////////////////////////////////////////////////////
 template <typename T>
 void A2AMatrixIo<T>::saveBlock(const T *data, 
                                const unsigned int i, 
                                const unsigned int j,
                                const unsigned int blockSizei,
-                               const unsigned int blockSizej)
+                               const unsigned int blockSizej,
+                               std::string datasetName)
 {
 #ifdef HAVE_HDF5
     Hdf5Reader           reader(filename_, false);
@@ -479,9 +509,13 @@ void A2AMatrixIo<T>::saveBlock(const T *data,
     H5NS::DataSet        dataset;
     //    size_t               shift;
 
+    if(datasetName.empty()){
+        datasetName = HADRONS_A2AM_NAME;
+    }
+
     push(reader, dataname_);
     auto &group = reader.getGroup();
-    dataset     = group.openDataSet(HADRONS_A2AM_NAME);
+    dataset     = group.openDataSet(datasetName);
     dataspace   = dataset.getSpace();
     dataspace.selectHyperslab(H5S_SELECT_SET, count.data(), offset.data(),
                               stride.data(), block.data());
@@ -504,22 +538,90 @@ void A2AMatrixIo<T>::saveBlock(const A2AMatrixSet<T> &m,
     saveBlock(m.data() + offset, i, j, blockSizei, blockSizej);
 }
 
+//distillation overloads and new methods
+template <typename T>
+void A2AMatrixIo<T>::createDilutionBlock(std::string datasetName, const unsigned int chunkSize, const std::vector<unsigned int> timeSlices)
+{
+#ifdef HAVE_HDF5
+    Hdf5Reader           reader(filename_, false);
+    H5NS::DataSpace      dataspace;
+    H5NS::DataSet        dataset;
+
+    push(reader, dataname_);
+    auto &group = reader.getGroup();
+    unsigned int ntchunk = (nt_ > DISTIL_NT_CHUNK_SIZE) ? DISTIL_NT_CHUNK_SIZE : nt_;
+    
+    //creates new dataset with custom name and certain chunk
+    std::vector<hsize_t>    dim = {static_cast<hsize_t>(nt_), 
+                                static_cast<hsize_t>(ni_), 
+                                static_cast<hsize_t>(nj_)},
+                            chunk = {static_cast<hsize_t>(ntchunk),
+                                static_cast<hsize_t>(chunkSize), 
+                                static_cast<hsize_t>(chunkSize)};
+    dataspace.setExtentSimple(dim.size(), dim.data());
+    H5NS::DSetCreatPropList     plist;
+    plist.setChunk(chunk.size(), chunk.data());
+    plist.setFletcher32();
+    dataset = group.createDataSet(datasetName, Hdf5Type<T>::type(), dataspace, plist);
+
+    //save timeslice metadata
+    hsize_t         attrDim = timeSlices.size();
+    H5NS::DataSpace attrSpace(1, &attrDim);
+    H5NS::Attribute attr = dataset.createAttribute("TimeSlices",  Hdf5Type<unsigned int>::type(), attrSpace);
+    attr.write(Hdf5Type<unsigned int>::type(), timeSlices.data());
+#else
+    HADRONS_ERROR(Implementation, "all-to-all matrix I/O needs HDF5 library");
+#endif
+}
+
+template <typename T>
+void A2AMatrixIo<T>::saveBlock(const A2AMatrixSet<T> &m,
+                               const unsigned int ext, const unsigned int str,
+                               const unsigned int i, const unsigned int j, std::string datasetName,
+                               const std::vector<unsigned int> timeSlices, const unsigned int chunkSize)
+{
+    unsigned int blockSizei = m.dimension(3);
+    unsigned int blockSizej = m.dimension(4);
+    unsigned int nstr       = m.dimension(1);
+    size_t       offset     = (ext*nstr + str)*nt_*blockSizei*blockSizej;
+
+    createDilutionBlock(datasetName, chunkSize, timeSlices);
+    saveBlock(m.data() + offset, i, j, blockSizei, blockSizej, datasetName);
+}
+
+template <typename T>
+void A2AMatrixIo<T>::saveBlock(const A2AMatrixSet<T> &m,
+                               const unsigned int ext, const unsigned int str,
+                               const unsigned int i, const unsigned int j, std::string datasetName)
+{
+    unsigned int blockSizei = m.dimension(3);
+    unsigned int blockSizej = m.dimension(4);
+    unsigned int nstr       = m.dimension(1);
+    size_t       offset     = (ext*nstr + str)*nt_*blockSizei*blockSizej;
+
+    saveBlock(m.data() + offset, i, j, blockSizei, blockSizej, datasetName);
+}
+
 template <typename T>
 template <template <class> class Vec, typename VecT>
-void A2AMatrixIo<T>::load(Vec<VecT> &v, double *tRead, GridBase *grid)
+void A2AMatrixIo<T>::load(Vec<VecT> &v, double *tRead, GridBase *grid, std::string datasetName)
 {
 #ifdef HAVE_HDF5
     std::vector<hsize_t> hdim;
     H5NS::DataSet        dataset;
     H5NS::DataSpace      dataspace;
     H5NS::CompType       datatype;
 
+    if(datasetName.empty()){
+        datasetName = HADRONS_A2AM_NAME;
+    }
+
     if (!(grid) || grid->IsBoss())
     {
         Hdf5Reader reader(filename_);
         push(reader, dataname_);
         auto &group = reader.getGroup();
-        dataset = group.openDataSet(HADRONS_A2AM_NAME);
+        dataset = group.openDataSet(datasetName);
         datatype = dataset.getCompType();
         dataspace = dataset.getSpace();
         hdim.resize(dataspace.getSimpleExtentNdims());

Hadrons/Application.cpp

@@ -140,6 +140,12 @@ void Application::createModule(const std::string name, const std::string type,
     vm().createModule(name, type, reader);
 }
 
+// test if module exists ///////////////////////////////////////////////////////
+bool Application::hasModule(const std::string name) const
+{
+    return vm().hasModule(name);
+}
+
 // generate result DB //////////////////////////////////////////////////////////
 void Application::generateResultDb(void)
 {
@@ -172,26 +178,39 @@ void Application::run(void)
     LOG(Message) << "Attempt(s) for resilient parallel I/O: " 
                  << BinaryIO::latticeWriteMaxRetry << std::endl;
     vm().setRunId(getPar().runId);
-    if (getPar().database.makeStatDb)
+    if (!getPar().database.statDbBase.empty())
     {
         std::string        statDbFilename;
         std::ostringstream oss;
         auto now      = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
         auto nowLocal = *std::localtime(&now);
 
         oss << std::put_time(&nowLocal, "%Y%m%d-%H%M%S");
-        statDbFilename = getPar().runId + "-stat-" + oss.str() + ".db";
+        statDbFilename = getPar().database.statDbBase + "-stat-" + oss.str() + ".db";
         LOG(Message) << "Logging run statistics in '" << statDbFilename << "'" << std::endl;
         if (env().getGrid()->IsBoss())
         {
             statDb.setFilename(statDbFilename);
+            statLogger.setPeriod(getPar().database.statDbPeriodMs);
             statLogger.setDatabase(statDb);
-            statLogger.start(500);
+            statLogger.start();
         }
     }
     if (getPar().saveSchedule or getPar().scheduleFile.empty())
     {
-        schedule();
+        if (getPar().scheduler.schedulerType == "genetic")
+        {
+            schedule();
+        }
+        else if (getPar().scheduler.schedulerType == "naive")
+        {
+            naiveSchedule();
+        }
+        else
+        {
+            HADRONS_ERROR(Parsing, "Unkown scheduler '"
+                                + getPar().scheduler.schedulerType + "'");
+        }
         if (getPar().saveSchedule)
         {
             std::string filename;
@@ -213,7 +232,7 @@ void Application::run(void)
         vm().dumpModuleGraph(getPar().graphFile);
     }
     configLoop();
-    if (getPar().database.makeStatDb and env().getGrid()->IsBoss())
+    if (!getPar().database.statDbBase.empty() and env().getGrid()->IsBoss())
     {
         statLogger.stop();
     }
@@ -292,6 +311,15 @@ void Application::schedule(void)
     }
 }
 
+void Application::naiveSchedule(void)
+{
+    if (!scheduled_ and !loadedSchedule_)
+    {
+        program_   = vm().naiveSchedule();
+        scheduled_ = true;
+    }
+}
+
 void Application::saveSchedule(const std::string filename)
 {
     LOG(Message) << "Saving current schedule to '" << filename << "'..."
@@ -337,9 +365,19 @@ void Application::printSchedule(void)
     {
         HADRONS_ERROR(Definition, "Computation not scheduled");
     }
-    auto peak = vm().memoryNeeded(program_);
-    LOG(Message) << "Schedule (memory needed: " << sizeString(peak) << "):"
-                 << std::endl;
+
+    if (getPar().scheduler.schedulerType == "naive")
+    {
+        LOG(Message) << "Schedule:"
+                    << std::endl;
+    }
+    else
+    {
+        auto peak = vm().memoryNeeded(program_);
+        LOG(Message) << "Schedule (memory needed: " << sizeString(peak) << "):"
+                    << std::endl;
+    }
+
     for (unsigned int i = 0; i < program_.size(); ++i)
     {
         LOG(Message) << std::setw(4) << i + 1 << ": "

Hadrons/Application.hpp

@@ -53,15 +53,23 @@ class Application
     struct DatabasePar: Serializable
     {
         GRID_SERIALIZABLE_CLASS_MEMBERS(DatabasePar,
-                                        std::string, applicationDb,
-                                        std::string, resultDb,
-                                        bool,        restoreModules,
-                                        bool,        restoreMemoryProfile,
-                                        bool,        restoreSchedule,
-                                        bool,        makeStatDb);
+                                        std::string,  applicationDb,
+                                        std::string,  resultDb,
+                                        bool,         restoreModules,
+                                        bool,         restoreMemoryProfile,
+                                        bool,         restoreSchedule,
+                                        std::string,  statDbBase,
+                                        unsigned int, statDbPeriodMs);
         DatabasePar(void): 
         restoreModules{false}, restoreMemoryProfile{false},
-        restoreSchedule{false}, makeStatDb{false} {}
+        restoreSchedule{false}, statDbBase{""} {}
+    };
+
+    struct SchedulerPar: Serializable
+    {
+        GRID_SERIALIZABLE_CLASS_MEMBERS(SchedulerPar,
+                                        std::string, schedulerType,);
+        SchedulerPar(void): schedulerType{"genetic"} {}
     };
 
     struct GlobalPar: Serializable
@@ -70,6 +78,7 @@ class Application
                                         TrajRange,                  trajCounter,
                                         DatabasePar,                database,
                                         VirtualMachine::GeneticPar, genetic,
+                                        SchedulerPar,               scheduler,
                                         std::string,                runId,
                                         std::string,                graphFile,
                                         std::string,                scheduleFile,
@@ -101,6 +110,8 @@ class Application
     template <typename M>
     void createModule(const std::string name, const typename M::Par &par);
     void createModule(const std::string name, const std::string type, XmlReader &reader);
+    // test if module exists
+    bool hasModule(const std::string name) const;
     // module DB entry for result files
     template <typename EntryType>
     void setResultMetadata(const std::string moduleName, const std::string tableName, const EntryType &entry);
@@ -113,6 +124,7 @@ class Application
     void saveParameterFile(const std::string parameterFileName, unsigned int prec = 15);
     // schedule computation
     void schedule(void);
+    void naiveSchedule(void);
     void saveSchedule(const std::string filename);
     void loadSchedule(const std::string filename);
     void printSchedule(void);

Hadrons/Archive/Modules/TestSeqConserved.cpp

@@ -29,5 +29,5 @@ using namespace Grid;
 using namespace Hadrons;
 using namespace MUtilities;
 
-template class Grid::Hadrons::MUtilities::TTestSeqConserved<FIMPL>;
+template class HADRONS_NAMESPACE::MUtilities::TTestSeqConserved<FIMPL>;
 

Hadrons/Archive/Modules/TestSeqGamma.cpp

@@ -29,5 +29,5 @@ using namespace Grid;
 using namespace Hadrons;
 using namespace MUtilities;
 
-template class Grid::Hadrons::MUtilities::TTestSeqGamma<FIMPL>;
+template class HADRONS_NAMESPACE::MUtilities::TTestSeqGamma<FIMPL>;
 

Hadrons/Database.cpp

@@ -289,12 +289,24 @@ QueryResult Database::getTable(const std::string tableName, const std::string ex
 }
 
 void Database::insert(const std::string tableName, const SqlEntry &entry, const bool replace)
+{
+    std::vector<const SqlEntry *> entryPtVec;
+
+    entryPtVec.push_back(&entry);
+    insert(tableName, entryPtVec, replace);
+}
+
+void Database::insert(const std::string tableName, const std::vector<const SqlEntry *> &entryPtVec, const bool replace)
 {
     std::string query;
 
     query += (replace ? "REPLACE" : "INSERT");
-    query += " INTO \"" + tableName + "\" VALUES(";
-    query += entry.sqlInsert() + ");";
+    query += " INTO \"" + tableName + "\" VALUES";
+    for (unsigned int i = 0; i < entryPtVec.size() - 1; ++i)
+    {
+        query += " (" + entryPtVec[i]->sqlInsert() + "),";
+    }
+    query += " (" + entryPtVec.back()->sqlInsert() + ");";
     execute(query);
 }
 

Hadrons/Database.hpp

@@ -99,6 +99,7 @@ class Database
     template <typename EntryType>
     std::vector<EntryType> getTable(const std::string tableName, const std::string extra = "");
     void insert(const std::string tableName, const SqlEntry &entry, const bool replace = false);
+    void insert(const std::string tableName, const std::vector<const SqlEntry *> &entryPtVec, const bool replace = false);
     // key-value tables interface
     void createKeyValueTable(const std::string tableName);
     std::map<std::string, std::string> getKeyValueTable(const std::string tableName);