Hadrons: all objects/modules mapped to an integer address system to remove string operations from scheduling

programs/Hadrons/Application.cc

@@ -42,10 +42,9 @@ using namespace Hadrons;
 Application::Application(const std::string parameterFileName)
 : parameterFileName_(parameterFileName)
 , env_(Environment::getInstance())
-, modFactory_(ModuleFactory::getInstance())
 {
     LOG(Message) << "Modules available:" << std::endl;
-    auto list = modFactory_.getBuilderList();
+    auto list = ModuleFactory::getInstance().getBuilderList();
     for (auto &m: list)
     {
         LOG(Message) << "  " << m << std::endl;
@@ -95,18 +94,12 @@ void Application::parseParameterFile(void)
     do
     {
         read(reader, "id", id);
-        module_[id.name] = modFactory_.create(id.type, id.name);
+        env_.createModule(id.name, id.type, reader);
-        module_[id.name]->parseParameters(reader, "options");
-        std::vector<std::string> output = module_[id.name]->getOutput();
-        for (auto &n: output)
-        {
-            associatedModule_[n] = id.name;
-        }
-        input_[id.name] = module_[id.name]->getInput();
     } while (reader.nextElement("module"));
     pop(reader);
     pop(reader);
     env_.setSeed(strToVec<int>(par_.seed));
+    env_.printContent();
 }
 
 // schedule computation ////////////////////////////////////////////////////////
@@ -116,7 +109,7 @@ sizeString((size)*locVol_) << " (" << sizeString(size)  << "/site)"
 void Application::schedule(void)
 {
     // memory peak function
-    auto memPeak = [this](const std::vector<std::string> &program)
+    auto memPeak = [this](const std::vector<unsigned int> &program)
     {
         unsigned int memPeak;
         bool         msg;
@@ -124,7 +117,7 @@ void Application::schedule(void)
         msg = HadronsLogMessage.isActive();
         HadronsLogMessage.Active(false);
         env_.dryRun(true);
-        memPeak = execute(program);
+        memPeak = env_.executeProgram(program);
         env_.dryRun(false);
         env_.freeAll();
         HadronsLogMessage.Active(true);
@@ -132,32 +125,14 @@ void Application::schedule(void)
         return memPeak;
     };
     
-    // create dependency graph
-    Graph<std::string> moduleGraph;
-    
-    LOG(Message) << "Scheduling computation..." << std::endl;
-    for (auto &m: module_)
-    {
-        std::vector<std::string> input = m.second->getInput();
-        for (auto &n: input)
-        {
-            try
-            {
-                moduleGraph.addEdge(associatedModule_.at(n), m.first);
-            }
-            catch (std::out_of_range &)
-            {
-                HADRON_ERROR("unknown object '" + n + "'");
-            }
-        }
-    }
-    
     // constrained topological sort using a genetic algorithm
+    LOG(Message) << "Scheduling computation..." << std::endl;
     constexpr unsigned int maxGen = 200, maxCstGen = 50;
     unsigned int           k = 0, gen, prevPeak, nCstPeak = 0;
-    std::vector<Graph<std::string>> con = moduleGraph.getConnectedComponents();
+    auto                   graph = env_.makeModuleGraph();
-    GeneticScheduler<std::string>::Parameters par;
+    auto                   con = graph.getConnectedComponents();
-    std::random_device rd;
+    std::random_device     rd;
+    GeneticScheduler<unsigned int>::Parameters par;
 
     par.popSize      = 20;
     par.mutationRate = .1;
@@ -165,7 +140,7 @@ void Application::schedule(void)
     CartesianCommunicator::BroadcastWorld(0, &(par.seed), sizeof(par.seed));
     for (unsigned int i = 0; i < con.size(); ++i)
     {
-        GeneticScheduler<std::string> scheduler(con[i], memPeak, par);
+        GeneticScheduler<unsigned int> scheduler(con[i], memPeak, par);
         
         gen = 0;
         do
@@ -197,13 +172,13 @@ void Application::schedule(void)
         {
             program_.push_back(t[j]);
             LOG(Message) << std::setw(4) << std::right << k + 1 << ": "
-                         << program_[k] << std::endl;
+                         << env_.getModuleName(program_[k]) << std::endl;
             k++;
         }
     }
 }
 
-// program execution ///////////////////////////////////////////////////////////
+// loop on configurations //////////////////////////////////////////////////////
 void Application::configLoop(void)
 {
     auto range = par_.configs.range;
@@ -213,121 +188,8 @@ void Application::configLoop(void)
         LOG(Message) << BIG_SEP << " Starting measurement for trajectory " << t
                      << " " << BIG_SEP << std::endl;
         env_.setTrajectory(t);
-        execute(program_);
+        env_.executeProgram(program_);
         env_.freeAll();
     }
     LOG(Message) << BIG_SEP << " End of measurement " << BIG_SEP << std::endl;
 }
-
-unsigned int Application::execute(const std::vector<std::string> &program)
-{
-    unsigned int                       memPeak = 0, sizeBefore, sizeAfter;
-    std::vector<std::set<std::string>> freeProg;
-    bool                               continueCollect, nothingFreed;
-    
-    // build garbage collection schedule
-    freeProg.resize(program.size());
-    for (auto &n: associatedModule_)
-    {
-        auto pred = [&n, this](const std::string &s)
-        {
-            auto &in = input_[s];
-            auto it  = std::find(in.begin(), in.end(), n.first);
-            
-            return (it != in.end()) or (s == n.second);
-        };
-        auto it = std::find_if(program.rbegin(), program.rend(), pred);
-        if (it != program.rend())
-        {
-            freeProg[program.rend() - it - 1].insert(n.first);
-        }
-    }
-    
-    // program execution
-    for (unsigned int i = 0; i < program.size(); ++i)
-    {
-        // execute module
-        LOG(Message) << SEP << " Measurement step " << i+1 << "/"
-                     << program.size() << " (module '" << program[i] << "') "
-                     << SEP << std::endl;
-        (*module_[program[i]])();
-        sizeBefore = env_.getTotalSize();
-        // print used memory after execution
-        LOG(Message) << "Allocated objects: " << MEM_MSG(sizeBefore)
-                     << std::endl;
-        if (sizeBefore > memPeak)
-        {
-            memPeak = sizeBefore;
-        }
-        // garbage collection for step i
-        LOG(Message) << "Garbage collection..." << std::endl;
-        nothingFreed = true;
-        do
-        {
-            continueCollect = false;
-            auto toFree = freeProg[i];
-            for (auto &n: toFree)
-            {
-                // continue garbage collection while there are still
-                // objects without owners
-                continueCollect = continueCollect or !env_.hasOwners(n);
-                if(env_.freeObject(n))
-                {
-                    // if an object has been freed, remove it from
-                    // the garbage collection schedule
-                    freeProg[i].erase(n);
-                    nothingFreed = false;
-                }
-            }
-        } while (continueCollect);
-        // any remaining objects in step i garbage collection schedule
-        // is scheduled for step i + 1
-        if (i + 1 < program.size())
-        {
-            for (auto &n: freeProg[i])
-            {
-                freeProg[i + 1].insert(n);
-            }
-        }
-        // print used memory after garbage collection if necessary
-        sizeAfter = env_.getTotalSize();
-        if (sizeBefore != sizeAfter)
-        {
-            LOG(Message) << "Allocated objects: " << MEM_MSG(sizeAfter)
-                         << std::endl;
-        }
-        else
-        {
-            LOG(Message) << "Nothing to free" << std::endl;
-        }
-    }
-    
-    return memPeak;
-}
-
-// pretty size formatting //////////////////////////////////////////////////////
-std::string Application::sizeString(long unsigned int bytes)
-
-{
-    constexpr unsigned int bufSize = 256;
-    const char             *suffixes[7] = {"", "K", "M", "G", "T", "P", "E"};
-    char                   buf[256];
-    long unsigned int      s     = 0;
-    double                 count = bytes;
-    
-    while (count >= 1024 && s < 7)
-    {
-        s++;
-        count /= 1024;
-    }
-    if (count - floor(count) == 0.0)
-    {
-        snprintf(buf, bufSize, "%d %sB", (int)count, suffixes[s]);
-    }
-    else
-    {
-        snprintf(buf, bufSize, "%.1f %sB", count, suffixes[s]);
-    }
-    
-    return std::string(buf);
-}

programs/Hadrons/Application.hpp

@@ -82,22 +82,14 @@ private:
     void parseParameterFile(void);
     // schedule computation
     void schedule(void);
-    // program execution
+    // loop on configurations
-    void         configLoop(void);
+    void configLoop(void);
-    unsigned int execute(const std::vector<std::string> &program);
-    // pretty size formatting
-    static std::string sizeString(long unsigned int bytes);
 private:
     long unsigned int                               locVol_;
     std::string                                     parameterFileName_;
     GlobalPar                                       par_;
     Environment                                     &env_;
-    ModuleFactory                                   &modFactory_;
+    std::vector<unsigned int>                       program_;
-    std::map<std::string, std::unique_ptr<Module>>  module_;
-    std::map<std::string, std::string>              associatedModule_;
-    std::map<std::string, std::vector<std::string>> input_;
-    std::vector<std::string>                        program_;
-    std::vector<std::vector<std::string>>           freeProg_;
 };
 
 END_HADRONS_NAMESPACE

programs/Hadrons/Environment.cc

@@ -26,6 +26,8 @@ directory.
 *******************************************************************************/
 
 #include <Hadrons/Environment.hpp>
+#include <Hadrons/Module.hpp>
+#include <Hadrons/ModuleFactory.hpp>
 
 using namespace Grid;
 using namespace QCD;
@@ -41,6 +43,12 @@ Environment::Environment(void)
         GridDefaultLatt(), GridDefaultSimd(Nd, vComplex::Nsimd()),
         GridDefaultMpi()));
     gridRb4d_.reset(SpaceTimeGrid::makeFourDimRedBlackGrid(grid4d_.get()));
+    auto loc = getGrid()->LocalDimensions();
+    locVol_ = 1;
+    for (unsigned int d = 0; d < loc.size(); ++d)
+    {
+        locVol_ *= loc[d];
+    }
     rng4d_.reset(new GridParallelRNG(grid4d_.get()));
 }
 
@@ -116,12 +124,312 @@ GridRedBlackCartesian * Environment::getRbGrid(const unsigned int Ls) const
     }
 }
 
-// fermion actions /////////////////////////////////////////////////////////////
+// random number generator /////////////////////////////////////////////////////
-void Environment::addFermionMatrix(const std::string name, FMat *fMat)
+void Environment::setSeed(const std::vector<int> &seed)
+{
+    rng4d_->SeedFixedIntegers(seed);
+}
+
+GridParallelRNG * Environment::get4dRng(void) const
+{
+    return rng4d_.get();
+}
+
+// module management ///////////////////////////////////////////////////////////
+void Environment::createModule(const std::string name, const std::string type,
+                               XmlReader &reader)
+{
+    auto addObject = [this](const std::string name, const int moduleAddress)
+    {
+        ObjInfo info;
+        
+        object_.push_back(info);
+        objectName_.push_back(name);
+        objectAddress_[name] = object_.size() - 1;
+        objectModule_.push_back(moduleAddress);
+        owners_.push_back(std::set<unsigned int>());
+        properties_.push_back(std::set<unsigned int>());
+    };
+    
+    if (!hasModule(name))
+    {
+        auto                      &factory = ModuleFactory::getInstance();
+        std::vector<unsigned int> inputAddress;
+
+        module_.push_back(factory.create(type, name));
+        moduleType_.push_back(type);
+        moduleName_.push_back(name);
+        moduleAddress_[name] = module_.size() - 1;
+        module_.back()->parseParameters(reader, "options");
+        auto input  = module_.back()->getInput();
+        for (auto &in: input)
+        {
+            if (!hasObject(in))
+            {
+                addObject(in , -1);
+            }
+            inputAddress.push_back(objectAddress_[in]);
+        }
+        moduleInput_.push_back(inputAddress);
+        auto output = module_.back()->getOutput();
+        for (auto &out: output)
+        {
+            if (!hasObject(out))
+            {
+                addObject(out , module_.size() - 1);
+            }
+            else
+            {
+                if (objectModule_[objectAddress_[out]] < 0)
+                {
+                    objectModule_[objectAddress_[out]] = module_.size() - 1;
+                }
+                else
+                {
+                    HADRON_ERROR("object '" + out
+                             + "' is already produced by module '"
+                             + moduleName_[objectModule_[getObjectAddress(out)]]
+                             + "' (while creating module '" + name + "')");
+                }
+            }
+        }
+    }
+    else
+    {
+        HADRON_ERROR("module '" + name + "' already exists");
+    }
+}
+
+Module * Environment::getModule(const unsigned int address) const
+{
+    if (hasModule(address))
+    {
+        return module_[address].get();
+    }
+    else
+    {
+        HADRON_ERROR("no module with address " + std::to_string(address));
+    }
+}
+
+Module * Environment::getModule(const std::string name) const
+{
+    return getModule(getModuleAddress(name));
+}
+
+unsigned int Environment::getModuleAddress(const std::string name) const
+{
+    if (hasModule(name))
+    {
+        return moduleAddress_.at(name);
+    }
+    else
+    {
+        HADRON_ERROR("no module with name '" + name + "'");
+    }
+}
+
+std::string Environment::getModuleName(const unsigned int address) const
+{
+    if (hasModule(address))
+    {
+        return moduleName_[address];
+    }
+    else
+    {
+        HADRON_ERROR("no module with address " + std::to_string(address));
+    }
+}
+
+std::string Environment::getModuleType(const unsigned int address) const
+{
+    if (hasModule(address))
+    {
+        return moduleType_[address];
+    }
+    else
+    {
+        HADRON_ERROR("no module with address " + std::to_string(address));
+    }
+}
+
+std::string Environment::getModuleType(const std::string name) const
+{
+    return getModuleType(getModuleAddress(name));
+}
+
+bool Environment::hasModule(const unsigned int address) const
+{
+    return (address < module_.size());
+}
+
+bool Environment::hasModule(const std::string name) const
+{
+    return (moduleAddress_.find(name) != moduleAddress_.end());
+}
+
+Graph<unsigned int> Environment::makeModuleGraph(void) const
+{
+    Graph<unsigned int> moduleGraph;
+    
+    for (unsigned int i = 0; i < module_.size(); ++i)
+    {
+        for (auto &j: moduleInput_[i])
+        {
+            moduleGraph.addEdge(objectModule_[j], i);
+        }
+    }
+    
+    return moduleGraph;
+}
+
+#define BIG_SEP "==============="
+#define SEP     "---------------"
+#define MEM_MSG(size)\
+sizeString((size)*locVol_) << " (" << sizeString(size)  << "/site)"
+
+unsigned int Environment::executeProgram(const std::vector<unsigned int> &p)
+{
+    unsigned int                        memPeak = 0, sizeBefore, sizeAfter;
+    std::vector<std::set<unsigned int>> freeProg;
+    bool                                continueCollect, nothingFreed;
+    
+    // build garbage collection schedule
+    freeProg.resize(p.size());
+    for (unsigned int i = 0; i < object_.size(); ++i)
+    {
+        auto pred = [i, this](const unsigned int j)
+        {
+            auto &in = moduleInput_[j];
+            auto it  = std::find(in.begin(), in.end(), i);
+            
+            return (it != in.end()) or (j == objectModule_[i]);
+        };
+        auto it = std::find_if(p.rbegin(), p.rend(), pred);
+        if (it != p.rend())
+        {
+            freeProg[p.rend() - it - 1].insert(i);
+        }
+    }
+    
+    // program execution
+    for (unsigned int i = 0; i < p.size(); ++i)
+    {
+        // execute module
+        LOG(Message) << SEP << " Measurement step " << i+1 << "/"
+                     << p.size() << " (module '" << moduleName_[p[i]] << "') "
+                     << SEP << std::endl;
+        (*module_[p[i]])();
+        sizeBefore = getTotalSize();
+        // print used memory after execution
+        LOG(Message) << "Allocated objects: " << MEM_MSG(sizeBefore)
+                     << std::endl;
+        if (sizeBefore > memPeak)
+        {
+            memPeak = sizeBefore;
+        }
+        // garbage collection for step i
+        LOG(Message) << "Garbage collection..." << std::endl;
+        nothingFreed = true;
+        do
+        {
+            continueCollect = false;
+            auto toFree = freeProg[i];
+            for (auto &j: toFree)
+            {
+                // continue garbage collection while there are still
+                // objects without owners
+                continueCollect = continueCollect or !hasOwners(j);
+                if(freeObject(j))
+                {
+                    // if an object has been freed, remove it from
+                    // the garbage collection schedule
+                    freeProg[i].erase(j);
+                    nothingFreed = false;
+                }
+            }
+        } while (continueCollect);
+        // any remaining objects in step i garbage collection schedule
+        // is scheduled for step i + 1
+        if (i + 1 < p.size())
+        {
+            for (auto &j: freeProg[i])
+            {
+                freeProg[i + 1].insert(j);
+            }
+        }
+        // print used memory after garbage collection if necessary
+        sizeAfter = getTotalSize();
+        if (sizeBefore != sizeAfter)
+        {
+            LOG(Message) << "Allocated objects: " << MEM_MSG(sizeAfter)
+                         << std::endl;
+        }
+        else
+        {
+            LOG(Message) << "Nothing to free" << std::endl;
+        }
+    }
+    
+    return memPeak;
+}
+
+unsigned int Environment::executeProgram(const std::vector<std::string> &p)
+{
+    std::vector<unsigned int> pAddress;
+    
+    for (auto &n: p)
+    {
+        pAddress.push_back(getModuleAddress(n));
+    }
+    
+    return executeProgram(pAddress);
+}
+
+// lattice store ///////////////////////////////////////////////////////////////
+void Environment::freeLattice(const unsigned int address)
+{
+    if (hasLattice(address))
+    {
+        if (!isDryRun())
+        {
+            LOG(Message) << "Freeing lattice '" << moduleName_[address]
+                         << "'" << std::endl;
+        }
+        lattice_.erase(address);
+        object_[address] = ObjInfo();
+    }
+    else
+    {
+        HADRON_ERROR("trying to free unknown lattice (address "
+                     + std::to_string(address) + ")");
+    }
+}
+
+bool Environment::hasLattice(const unsigned int address) const
+{
+    return (hasRegisteredObject(address)
+            and (lattice_.find(address) != lattice_.end()));
+}
+
+bool Environment::hasLattice(const std::string name) const
 {
     if (hasObject(name))
     {
-        fMat_[name].reset(fMat);
+        return hasLattice(getObjectAddress(name));
+    }
+    else
+    {
+        return false;
+    }
+}
+
+// fermion actions /////////////////////////////////////////////////////////////
+void Environment::addFermionMatrix(const std::string name, FMat *fMat)
+{
+    if (hasRegisteredObject(name))
+    {
+        fMat_[getObjectAddress(name)].reset(fMat);
     }
     else
     {
@@ -131,15 +439,21 @@ void Environment::addFermionMatrix(const std::string name, FMat *fMat)
 
 Environment::FMat * Environment::getFermionMatrix(const std::string name) const
 {
+    unsigned int i;
+    
     if (hasFermionMatrix(name))
     {
-        return fMat_.at(name).get();
+        i = getObjectAddress(name);
+        
+        return fMat_.at(i).get();
     }
     else
     {
         if (hasSolver(name))
         {
-            return fMat_.at(solverAction_.at(name)).get();
+            i = getObjectAddress(solverAction_.at(name));
+            
+            return fMat_.at(i).get();
         }
         else
         {
@@ -148,41 +462,80 @@ Environment::FMat * Environment::getFermionMatrix(const std::string name) const
     }
 }
 
-void Environment::freeFermionMatrix(const std::string name)
+bool Environment::hasFermionMatrix(const unsigned int address) const
 {
-    if (hasFermionMatrix(name))
+    return (hasRegisteredObject(address)
-    {
+            and (fMat_.find(address) != fMat_.end()));
-        LOG(Message) << "Freeing fermion matrix '" << name << "'" << std::endl;
-        fMat_.erase(name);
-        object_.erase(name);
-    }
-    else
-    {
-        HADRON_ERROR("trying to free unknown fermion matrix '" + name + "'");
-    }
 }
 
 bool Environment::hasFermionMatrix(const std::string name) const
 {
-    return (hasObject(name) and (fMat_.find(name) != fMat_.end()));
+    if (hasObject(name))
+    {
+        return hasFermionMatrix(getObjectAddress(name));
+    }
+    else
+    {
+        return false;
+    }
+}
+
+void Environment::freeFermionMatrix(const unsigned int address)
+{
+    if (hasFermionMatrix(address))
+    {
+        if (!isDryRun())
+        {
+            LOG(Message) << "Freeing fermion matrix '" << objectName_[address]
+                         << "'" << std::endl;
+        }
+        fMat_.erase(address);
+        object_[address] = ObjInfo();
+    }
+    else
+    {
+        HADRON_ERROR("trying to free unknown fermion matrix (address "
+                     + std::to_string(address) + ")");
+    }
+}
+
+void Environment::freeFermionMatrix(const std::string name)
+{
+    freeFermionMatrix(getObjectAddress(name));
 }
 
 // solvers /////////////////////////////////////////////////////////////////////
 void Environment::addSolver(const std::string name, Solver s)
 {
-    if (hasObject(name))
+    auto address = getObjectAddress(name);
+    
+    if (hasRegisteredObject(address))
     {
-        solver_[name] = s;
+        solver_[address] = s;
     }
     else
     {
-        HADRON_ERROR("no object named '" << name << "'");
+        HADRON_ERROR("object with name '" + name
+                     + "' exsists but is not registered");
     }
 }
 
+bool Environment::hasSolver(const unsigned int address) const
+{
+    return (hasRegisteredObject(address)
+            and (solver_.find(address) != solver_.end()));
+}
+
 bool Environment::hasSolver(const std::string name) const
 {
-    return (hasObject(name) and (solver_.find(name) != solver_.end()));
+    if (hasObject(name))
+    {
+        return hasSolver(getObjectAddress(name));
+    }
+    else
+    {
+        return false;
+    }
 }
 
 void Environment::setSolverAction(const std::string name,
@@ -222,7 +575,7 @@ void Environment::callSolver(const std::string name, LatticeFermion &sol,
 {
     if (hasSolver(name))
     {
-        solver_.at(name)(sol, source);
+        solver_.at(getObjectAddress(name))(sol, source);
     }
     else
     {
@@ -230,114 +583,124 @@ void Environment::callSolver(const std::string name, LatticeFermion &sol,
     }
 }
 
-// random number generator /////////////////////////////////////////////////////
+// general memory management ///////////////////////////////////////////////////
-void Environment::setSeed(const std::vector<int> &seed)
+void Environment::registerObject(const unsigned int address,
+                                 const unsigned int size, const unsigned int Ls)
 {
-    rng4d_->SeedFixedIntegers(seed);
+    if (!hasRegisteredObject(address))
-}
-
-GridParallelRNG * Environment::get4dRng(void) const
-{
-    return rng4d_.get();
-}
-
-// lattice store ///////////////////////////////////////////////////////////////
-void Environment::freeLattice(const std::string name)
-{
-    if (hasLattice(name))
     {
-        LOG(Message) << "Freeing lattice '" << name << "'" << std::endl;
+        if (hasObject(address))
-        lattice_.erase(name);
+        {
-        object_.erase(name);
+            ObjInfo info;
+            
+            info.size         = size;
+            info.Ls           = Ls;
+            info.isRegistered = true;
+            object_[address]  = info;
+        }
+        else
+        {
+            HADRON_ERROR("no object with address " + std::to_string(address));
+        }
     }
     else
     {
-        HADRON_ERROR("trying to free unknown lattice '" + name + "'");
+        HADRON_ERROR("object with address " + std::to_string(address)
+                     + " already registered");
     }
 }
 
-bool Environment::hasLattice(const std::string name) const
-{
-    return (hasObject(name) and (lattice_.find(name) != lattice_.end()));
-}
-
-// general memory management ///////////////////////////////////////////////////
-bool Environment::hasObject(const std::string name) const
-{
-    return (object_.find(name) != object_.end());
-}
-
 void Environment::registerObject(const std::string name,
                                  const unsigned int size, const unsigned int Ls)
 {
-    if (!hasObject(name))
+    registerObject(getObjectAddress(name), size, Ls);
+}
+
+unsigned int Environment::getObjectAddress(const std::string name) const
+{
+    if (hasObject(name))
     {
-        ObjInfo info{size, Ls};
+        return objectAddress_.at(name);
-        
-        object_[name] = info;
     }
     else
     {
-        HADRON_ERROR("object '" + name + "' already exists");
+        HADRON_ERROR("no object with name '" + name + "'");
+    }
+}
+
+std::string Environment::getObjectName(const unsigned int address) const
+{
+    if (hasObject(address))
+    {
+        return objectName_[address];
+    }
+    else
+    {
+        HADRON_ERROR("no object with address " + std::to_string(address));
+    }
+}
+
+unsigned int Environment::getObjectSize(const unsigned int address) const
+{
+    if (hasRegisteredObject(address))
+    {
+        return object_[address].size;
+    }
+    else if (hasObject(address))
+    {
+        HADRON_ERROR("object with address " + std::to_string(address)
+                     + " exsists but is not registered");
+    }
+    else
+    {
+        HADRON_ERROR("no object with address " + std::to_string(address));
     }
 }
 
 unsigned int Environment::getObjectSize(const std::string name) const
 {
-    if (hasObject(name))
+    return getObjectSize(getObjectAddress(name));
+}
+
+unsigned int Environment::getObjectLs(const unsigned int address) const
+{
+    if (hasRegisteredObject(address))
     {
-        return object_.at(name).size;
+        return object_[address].Ls;
+    }
+    else if (hasObject(address))
+    {
+        HADRON_ERROR("object with address " + std::to_string(address)
+                     + " exsists but is not registered");
     }
     else
     {
-        HADRON_ERROR("no object named '" + name + "'");
+        HADRON_ERROR("no object with address " + std::to_string(address));
     }
 }
 
-long unsigned int Environment::getTotalSize(void) const
-{
-    long unsigned int size = 0;
-    
-    for (auto &s: object_)
-    {
-        size += s.second.size;
-    }
-    
-    return size;
-}
-
 unsigned int Environment::getObjectLs(const std::string name) const
 {
-    if (hasObject(name))
+    return getObjectLs(getObjectAddress(name));
-    {
-        return object_.at(name).Ls;
-    }
-    else
-    {
-        HADRON_ERROR("no object named '" + name + "'");
-    }
 }
 
-bool Environment::isObject5d(const std::string name) const
+bool Environment::hasObject(const unsigned int address) const
 {
-    return (getObjectLs(name) > 1);
+    return (address < object_.size());
 }
 
-void Environment::addOwnership(const std::string owner,
+bool Environment::hasObject(const std::string name) const
-                               const std::string property)
-{
-    owners_[property].insert(owner);
-    properties_[owner].insert(property);
-}
-
-bool Environment::hasOwners(const std::string name) const
 {
+    auto it = objectAddress_.find(name);
     
-    auto it = owners_.find(name);
+    return ((it != objectAddress_.end()) and hasObject(it->second));
-    
+}
-    if (it != owners_.end())
+
+bool Environment::hasRegisteredObject(const unsigned int address) const
+{
+    if (hasObject(address))
     {
-        return (!it->second.empty());
+        return object_[address].isRegistered;
     }
     else
     {
@@ -345,26 +708,94 @@ bool Environment::hasOwners(const std::string name) const
     }
 }
 
-bool Environment::freeObject(const std::string name)
+bool Environment::hasRegisteredObject(const std::string name) const
 {
-    if (!hasOwners(name))
+    if (hasObject(name))
     {
-        for (auto &p: properties_[name])
+        return hasRegisteredObject(getObjectAddress(name));
+    }
+    else
+    {
+        return false;
+    }
+}
+
+bool Environment::isObject5d(const unsigned int address) const
+{
+    return (getObjectLs(address) > 1);
+}
+
+bool Environment::isObject5d(const std::string name) const
+{
+    return (getObjectLs(name) > 1);
+}
+
+long unsigned int Environment::getTotalSize(void) const
+{
+    long unsigned int size = 0;
+    
+    for (auto &o: object_)
+    {
+        if (o.isRegistered)
         {
-            owners_[p].erase(name);
+            size += o.size;
         }
-        properties_[name].clear();
+    }
-        if (hasLattice(name))
+    
+    return size;
+}
+
+void Environment::addOwnership(const unsigned int owner,
+                               const unsigned int property)
+{
+    owners_[property].insert(owner);
+    properties_[owner].insert(property);
+}
+
+void Environment::addOwnership(const std::string owner,
+                               const std::string property)
+{
+    addOwnership(getObjectAddress(owner), getObjectAddress(property));
+}
+
+bool Environment::hasOwners(const unsigned int address) const
+{
+    
+    if (hasObject(address))
+    {
+        return (!owners_[address].empty());
+    }
+    else
+    {
+        HADRON_ERROR("no object with address " + std::to_string(address));
+    }
+}
+
+bool Environment::hasOwners(const std::string name) const
+{
+    return hasOwners(getObjectAddress(name));
+}
+
+bool Environment::freeObject(const unsigned int address)
+{
+    if (!hasOwners(address))
+    {
+        for (auto &p: properties_[address])
         {
-            freeLattice(name);
+            owners_[p].erase(address);
         }
-        else if (hasFermionMatrix(name))
+        properties_[address].clear();
+        if (hasLattice(address))
         {
-            freeFermionMatrix(name);
+            freeLattice(address);
         }
-        else if (hasObject(name))
+        else if (hasFermionMatrix(address))
         {
-            object_.erase(name);
+            freeFermionMatrix(address);
+        }
+        else if (hasObject(address))
+        {
+            object_[address] = ObjInfo();
         }
         
         return true;
@@ -375,9 +806,13 @@ bool Environment::freeObject(const std::string name)
     }
 }
 
+bool Environment::freeObject(const std::string name)
+{
+    return freeObject(getObjectAddress(name));
+}
+
 void Environment::freeAll(void)
 {
-    object_.clear();
     lattice_.clear();
     fMat_.clear();
     solver_.clear();
@@ -385,3 +820,20 @@ void Environment::freeAll(void)
     owners_.clear();
     properties_.clear();
 }
+
+void Environment::printContent(void)
+{
+    LOG(Message) << "Modules: " << std::endl;
+    for (unsigned int i = 0; i < module_.size(); ++i)
+    {
+        LOG(Message) << std::setw(4) << std::right << i << ": "
+                     << moduleName_[i] << " ("
+                     << moduleType_[i] << ")" << std::endl;
+    }
+    LOG(Message) << "Objects: " << std::endl;
+    for (unsigned int i = 0; i < object_.size(); ++i)
+    {
+        LOG(Message) << std::setw(4) << std::right << i << ": "
+                     << objectName_[i] << std::endl;
+    }
+}

programs/Hadrons/Environment.hpp

@@ -29,28 +29,34 @@ directory.
 #define Hadrons_Environment_hpp_
 
 #include <Hadrons/Global.hpp>
+#include <Hadrons/Graph.hpp>
 
 BEGIN_HADRONS_NAMESPACE
 
 /******************************************************************************
  *                         Global environment                                 *
  ******************************************************************************/
+// forward declaration of Module
+class Module;
+
 class Environment
 {
     SINGLETON(Environment);
 public:
-    typedef FermionOperator<WilsonImplR>                FMat;
+    typedef std::unique_ptr<Module>                     ModPt;
-    typedef std::function<void(LatticeFermion &,
-                               const LatticeFermion &)> Solver;
     typedef std::unique_ptr<GridCartesian>              GridPt;
     typedef std::unique_ptr<GridRedBlackCartesian>      GridRbPt;
-    typedef std::unique_ptr<GridParallelRNG>            RngPt;
+    typedef FermionOperator<WilsonImplR>                FMat;
     typedef std::unique_ptr<FMat>                       FMatPt;
+    typedef std::function<void(LatticeFermion &,
+                               const LatticeFermion &)> Solver;
+    typedef std::unique_ptr<GridParallelRNG>            RngPt;
     typedef std::unique_ptr<LatticeBase>                LatticePt;
 private:
     struct ObjInfo
     {
-        unsigned int size, Ls;
+        unsigned int size{0}, Ls{0};
+        bool         isRegistered{false};
     };
 public:
     // dry run
@@ -63,13 +69,45 @@ public:
     void                    createGrid(const unsigned int Ls);
     GridCartesian *         getGrid(const unsigned int Ls = 1) const;
     GridRedBlackCartesian * getRbGrid(const unsigned int Ls = 1) const;
+    // random number generator
+    void                    setSeed(const std::vector<int> &seed);
+    GridParallelRNG *       get4dRng(void) const;
+    // module management
+    void                    createModule(const std::string name,
+                                         const std::string type,
+                                         XmlReader &reader);
+    Module *                getModule(const unsigned int address) const;
+    Module *                getModule(const std::string name) const;
+    unsigned int            getModuleAddress(const std::string name) const;
+    std::string             getModuleName(const unsigned int address) const;
+    std::string             getModuleType(const unsigned int address) const;
+    std::string             getModuleType(const std::string name) const;
+    bool                    hasModule(const unsigned int address) const;
+    bool                    hasModule(const std::string name) const;
+    Graph<unsigned int>     makeModuleGraph(void) const;
+    unsigned int            executeProgram(const std::vector<unsigned int> &p);
+    unsigned int            executeProgram(const std::vector<std::string> &p);
+    // lattice store
+    template <typename T>
+    T *                     create(const std::string name);
+    template <typename T>
+    T *                     get(const std::string name) const;
+    bool                    hasLattice(const unsigned int address) const;
+    bool                    hasLattice(const std::string name) const;
+    void                    freeLattice(const unsigned int address);
+    void                    freeLattice(const std::string name);
+    template <typename T>
+    unsigned int            lattice4dSize(void) const;
     // fermion actions
     void                    addFermionMatrix(const std::string name, FMat *mat);
     FMat *                  getFermionMatrix(const std::string name) const;
-    void                    freeFermionMatrix(const std::string name);
+    bool                    hasFermionMatrix(const unsigned int address) const;
     bool                    hasFermionMatrix(const std::string name) const;
+    void                    freeFermionMatrix(const unsigned int address);
+    void                    freeFermionMatrix(const std::string name);
     // solvers
     void                    addSolver(const std::string name, Solver s);
+    bool                    hasSolver(const unsigned int address) const;
     bool                    hasSolver(const std::string name) const;
     void                    setSolverAction(const std::string name,
                                             const std::string actionName);
@@ -77,52 +115,73 @@ public:
     void                    callSolver(const std::string name,
                                        LatticeFermion &sol,
                                        const LatticeFermion &src) const;
-    // random number generator
-    void                    setSeed(const std::vector<int> &seed);
-    GridParallelRNG *       get4dRng(void) const;
-    // lattice store
-    template <typename T>
-    T *                     create(const std::string name);
-    template <typename T>
-    T *                     get(const std::string name) const;
-    bool                    hasLattice(const std::string name) const;
-    void                    freeLattice(const std::string name);
-    template <typename T>
-    unsigned int            lattice4dSize(void) const;
     // general memory management
-    bool                    hasObject(const std::string name) const;
+    void                    registerObject(const unsigned int address,
+                                           const unsigned int size,
+                                           const unsigned int Ls = 1);
     void                    registerObject(const std::string name,
                                            const unsigned int size,
                                            const unsigned int Ls = 1);
     template <typename T>
+    void                    registerLattice(const unsigned int address,
+                                            const unsigned int Ls = 1);
+    template <typename T>
     void                    registerLattice(const std::string name,
                                             const unsigned int Ls = 1);
+    unsigned int            getObjectAddress(const std::string name) const;
+    std::string             getObjectName(const unsigned int address) const;
+    unsigned int            getObjectSize(const unsigned int address) const;
     unsigned int            getObjectSize(const std::string name) const;
-    long unsigned int       getTotalSize(void) const;
+    unsigned int            getObjectLs(const unsigned int address) const;
     unsigned int            getObjectLs(const std::string name) const;
+    bool                    hasObject(const unsigned int address) const;
+    bool                    hasObject(const std::string name) const;
+    bool                    hasRegisteredObject(const unsigned int address) const;
+    bool                    hasRegisteredObject(const std::string name) const;
+    bool                    isObject5d(const unsigned int address) const;
     bool                    isObject5d(const std::string name) const;
+    long unsigned int       getTotalSize(void) const;
+    void                    addOwnership(const unsigned int owner,
+                                         const unsigned int property);
     void                    addOwnership(const std::string owner,
                                          const std::string property);
+    bool                    hasOwners(const unsigned int address) const;
     bool                    hasOwners(const std::string name) const;
+    bool                    freeObject(const unsigned int address);
     bool                    freeObject(const std::string name);
     void                    freeAll(void);
+    void                    printContent(void);
 private:
-    
+    // general
-private:
+    bool                                   dryRun_{false};
-    bool                                         dryRun_{false};
+    unsigned int                           traj_, locVol_;
-    unsigned int                                 traj_;
+    // grids
-    GridPt                                       grid4d_;
+    GridPt                                 grid4d_;
-    std::map<unsigned int, GridPt>               grid5d_;
+    std::map<unsigned int, GridPt>         grid5d_;
-    GridRbPt                                     gridRb4d_;
+    GridRbPt                               gridRb4d_;
-    std::map<unsigned int, GridRbPt>             gridRb5d_;
+    std::map<unsigned int, GridRbPt>       gridRb5d_;
-    RngPt                                        rng4d_;
+    // random number generator
-    std::map<std::string, ObjInfo>               object_;
+    RngPt                                  rng4d_;
-    std::map<std::string, LatticePt>             lattice_;
+    // module and related maps
-    std::map<std::string, FMatPt>                fMat_;
+    std::vector<ModPt>                     module_;
-    std::map<std::string, Solver>                solver_;
+    std::vector<std::string>               moduleType_;
-    std::map<std::string, std::string>           solverAction_;
+    std::vector<std::string>               moduleName_;
-    std::map<std::string, std::set<std::string>> owners_;
+    std::map<std::string, unsigned int>    moduleAddress_;
-    std::map<std::string, std::set<std::string>> properties_;
+    std::vector<std::vector<unsigned int>> moduleInput_;
+    // lattice store
+    std::map<unsigned int, LatticePt>      lattice_;
+    // fermion matrix store
+    std::map<unsigned int, FMatPt>         fMat_;
+    // solver store & solver/action map
+    std::map<unsigned int, Solver>         solver_;
+    std::map<std::string, std::string>     solverAction_;
+    // object register
+    std::vector<ObjInfo>                   object_;
+    std::vector<std::string>               objectName_;
+    std::map<std::string, unsigned int>    objectAddress_;
+    std::vector<int>                       objectModule_;
+    std::vector<std::set<unsigned int>>    owners_;
+    std::vector<std::set<unsigned int>>    properties_;
 };
 
 /******************************************************************************
@@ -137,11 +196,12 @@ unsigned int Environment::lattice4dSize(void) const
 template <typename T>
 T * Environment::create(const std::string name)
 {
-    GridCartesian *g = getGrid(getObjectLs(name));
+    auto           i = getObjectAddress(name);
+    GridCartesian *g = getGrid(getObjectLs(i));
     
-    lattice_[name].reset(new T(g));
+    lattice_[i].reset(new T(g));
 
-    return dynamic_cast<T *>(lattice_[name].get());
+    return dynamic_cast<T *>(lattice_[i].get());
 }
 
 template <typename T>
@@ -149,25 +209,35 @@ T * Environment::get(const std::string name) const
 {
     if (hasLattice(name))
     {
-        if (auto pt = dynamic_cast<T *>(lattice_.at(name).get()))
+        auto i = getObjectAddress(name);
+        
+        if (auto pt = dynamic_cast<T *>(lattice_.at(i).get()))
         {
             return pt;
         }
         else
         {
             HADRON_ERROR("object '" + name + "' does not have type "
-                         + typeid(T *).name() + "(object type: "
+                         + typeName<T>() + "(object type: "
-                         + typeid(lattice_.at(name).get()).name() + ")");
+                         + typeName(*lattice_.at(i).get()) + ")");
         }
     }
     else
     {
-        HADRON_ERROR("no lattice name '" + name + "'");
+        HADRON_ERROR("no lattice with name '" + name + "'");
         
         return nullptr;
     }
 }
 
+template <typename T>
+void Environment::registerLattice(const unsigned int address,
+                                  const unsigned int Ls)
+{
+    createGrid(Ls);
+    registerObject(address, Ls*lattice4dSize<T>());
+}
+
 template <typename T>
 void Environment::registerLattice(const std::string name, const unsigned int Ls)
 {

programs/Hadrons/Global.cc

@@ -36,3 +36,30 @@ HadronsLogger Hadrons::HadronsLogWarning(1,"Warning");
 HadronsLogger Hadrons::HadronsLogMessage(1,"Message");
 HadronsLogger Hadrons::HadronsLogIterative(1,"Iterative");
 HadronsLogger Hadrons::HadronsLogDebug(1,"Debug");
+
+// pretty size formatting //////////////////////////////////////////////////////
+std::string Hadrons::sizeString(long unsigned int bytes)
+
+{
+    constexpr unsigned int bufSize = 256;
+    const char             *suffixes[7] = {"", "K", "M", "G", "T", "P", "E"};
+    char                   buf[256];
+    long unsigned int      s     = 0;
+    double                 count = bytes;
+    
+    while (count >= 1024 && s < 7)
+    {
+        s++;
+        count /= 1024;
+    }
+    if (count - floor(count) == 0.0)
+    {
+        snprintf(buf, bufSize, "%d %sB", (int)count, suffixes[s]);
+    }
+    else
+    {
+        snprintf(buf, bufSize, "%.1f %sB", count, suffixes[s]);
+    }
+    
+    return std::string(buf);
+}

programs/Hadrons/Global.hpp

@@ -30,6 +30,7 @@ directory.
 
 #include <set>
 #include <stack>
+#include <cxxabi.h>
 #include <Grid.h>
 
 #define BEGIN_HADRONS_NAMESPACE \
@@ -91,6 +92,25 @@ public:\
 private:\
     name(void) = default;
 
+// pretty size formating
+std::string sizeString(long unsigned int bytes);
+
+template <typename T>
+std::string typeName(const T &x)
+{
+    std::string name(typeid(x).name());
+
+    return name;
+}
+
+template <typename T>
+std::string typeName(void)
+{
+    std::string name(typeid(T).name());
+
+    return name;
+}
+
 END_HADRONS_NAMESPACE
 
 #endif // Hadrons_Global_hpp_