world.hpp

Go to the documentation of this file.

#ifndef MECACELL_WORLD_H
#define MECACELL_WORLD_H
#include <array>
#include <functional>
#include <unordered_set>
#include <utility>
#include <vector>
#include "integrators.hpp"
#include "mecacell/utilities/hooktools.hpp"
#include "mecacell/utilities/threadpool.hpp"
#include "mecacell/utilities/utils.hpp"
#include <chrono>
#include <string>
#include <map>
#include <unordered_map>
 
namespace MecaCell {
 
template <typename Cell, typename Integrator = Euler> class World {
 private:
    size_t nbThreads = 0;
    using Clock = std::chrono::high_resolution_clock;
    std::unordered_map<std::string, std::map<size_t, double>> benchResults;
 
 public:
    using cell_t = Cell;
    using integrator_t = Integrator;
    using hook_s = void(World *);  
 
    ThreadPool threadpool;  // threadpool that can be used by plugins (and is also used to
                            // parallelize updateBehavior)
 
    // -------------------------------------
    // The following code detects if any embedded plugin type is specified and defaults
    // to the instantiation of a useles byte if not.
    struct dumb {};
    template <class, class = MecaCell::void_t<>>
    struct embedded_plugin_type {  // declaration
        using type = dumb;  // defaults to empty type if no embedded plugin is defined
    };
    template <class T>  // specialization
    struct embedded_plugin_type<T, void_t<typename T::embedded_plugin_t>> {
        using type = typename T::embedded_plugin_t;  // embedded plugin detected
    };
    using cellPlugin_t =
        typename embedded_plugin_type<cell_t>::type;  // either dumb empty struct or the
                                                      // plugin type
                                                      // defined by Cell (if existing)
 protected:
    size_t frame = 0;         
    size_t nbAddedCells = 0;  
    size_t updtBhvPeriod = 1;  
    bool parallelUpdateBehavior = false;
    bool shuffleCells = true;
 
    void deleteDeadCells() {
        for (auto i = cells.begin(); i != cells.end();) {
            if ((*i)->isDead()) {
                auto tmp = *i;
                i = cells.erase(i);
                delete tmp;
            } else {
                ++i;
            }
        }
    }
 
 public:
    double dt = 1.0 / 100.0;  
    double dtMn = dt/60.;
    double dtH = dt/3600.;
    bool benchmark = false;  
 
    cellPlugin_t cellPlugin;  // instance of the embedded cell plugin type
                              // (cellPlugin_t default to a dumb char if not specified)
 
    vector<Cell *> newCells;  
 
    /* HOOKS
     */
    DECLARE_HOOK(onAddCell, beginUpdate, preBehaviorUpdate, preDeleteDeadCellsUpdate,
                 postBehaviorUpdate, endUpdate, allForcesAppliedToCells, destructor)
 
    /* CELLS */
    std::vector<Cell *> cells;  
 
    World(size_t nThreads = 0) : nbThreads(nThreads), threadpool(nThreads) {
        registerPlugins(cellPlugin);
    }
 
    void setParallelUpdateBehavior(bool p) { parallelUpdateBehavior = p; };
 
    size_t getNbThreads() { return nbThreads; }
 
    void setNbThreads(size_t n) {
        nbThreads = n;
        threadpool.setNbThreads(n);
    }
 
    /**********************************************
     *               HOOKS & PLUGINS              *
     *********************************************/
 
    //void registerHook(const Hooks &h, hook_t f) { hooks[eToUI(h)].push_back(f); }
    void registerHook(const Hooks &h,
                      const std::string &pluginName,
                      const std::string &hookName,
                      std::function<hook_s> fn) {
        hooks[eToUI(h)].push_back({ pluginName, hookName, std::move(fn) });
    }
 
    void runHooks(const Hooks &h) {
        if(!benchmark){
            for (auto &hw : hooks[eToUI(h)]) hw.f(this);
        } else {
            for (auto &hw : hooks[eToUI(h)]) {
                auto t0 = Clock::now();
                hw.f(this);
                auto dt = std::chrono::duration<double, std::micro>(Clock::now() - t0).count();
                benchResults[hw.pluginName + "@" + hw.hookName][frame] += dt;
            }
        }
    }
    template <typename P, typename... Rest>
    void registerPlugins(P &&p, Rest &&... otherPlugins) {
        // registerPlugin returns the onRegister hook from the plugin
        registerPlugin(std::forward<P>(p))(this);
        registerPlugins(std::forward<Rest>(otherPlugins)...);
    }
    void registerPlugins() {}  
 
    void clearHooks() {
        for (auto &h : hooks) h.clear();
    }
 
    /**********************************************
     *                 GET & SET                  *
     *********************************************/
 
    size_t getNbUpdates() const { return frame; }
 
    template <typename... Args> Cell *createCell(Args &&... args) {
        Cell *c = new Cell(std::forward<Args>(args)...);
        addCell(c);
        return c;
    }
 
    void addCell(Cell *c) {
        if (c) {
            c->getBody().setCellPlugin(&cellPlugin);
            c->setWorld(this);
            newCells.push_back(c);
            c->id = nbAddedCells++;
        }
    }
 
    void refreshId(Cell *c) {
        if (c) {
            c->id = nbAddedCells++;
        }
    }
 
    void addNewCells() {
        if (newCells.size()) {
            runHooks(Hooks::onAddCell);
            cells.insert(cells.end(), newCells.begin(), newCells.end());
            newCells.clear();
        }
    }
 
    void allForcesHaveBeenAppliedToCells() {
        runHooks(Hooks::allForcesAppliedToCells);
    }
 
    void setDt(double d) { dt = d; dtMn = d/60.; dtH = d/3600.; }
    void setDtInS(double d) { dt = d; dtMn = d/60.; dtH = d/3600.; }
    void setDtInMn(double d) { dt = d*60.; dtMn = d; dtH = d/60.; }
    void setDtInH(double d) { dt = d*3600.; dtMn = d*60.; dtH = d; }
    double getDt() const{ return dt; }
    double getDtInS() const{ return dt; }
    double getDtInMn() const{ return dtMn; }
    double getDtInH() const{ return dtH; }
 
    void setShuffleCells(bool s) { shuffleCells = s; }
 
    void setUpdateBehaviorPeriod(size_t p) { updtBhvPeriod = p; }
    
    size_t getUpdateBehaviorPeriod() const { return updtBhvPeriod; }
 
 
    std::vector<std::pair<cell_t *, cell_t *>> getConnectedCellsList() {
        std::unordered_set<ordered_pair<cell_t *>> res;
        for (auto &c : cells) {
            for (auto &connected : c->getConnectedCells())
                res.insert(make_ordered_cell_pair(c, connected));
        }
        std::vector<std::pair<cell_t *, cell_t *>> vecRes;
        for (auto &r : res) vecRes.push_back(std::make_pair(r.first, r.second));
        return vecRes;
    }
 
    void callUpdateBehavior() {
        if (!benchmark) {
            if(shuffleCells) std::shuffle(std::begin(cells), std::end(cells), MecaCell::Config::globalRand());
            const size_t MIN_CHUNK_SIZE = 2;
            const double AVG_TASKS_PER_THREAD = 3.0;
            if (parallelUpdateBehavior && nbThreads > 0) {
                threadpool.autoChunks(cells, MIN_CHUNK_SIZE, AVG_TASKS_PER_THREAD,
                                    [](auto *c) { c->updateBehavior(); });
                threadpool.waitUntilLast();
            } else
                for (auto &c : cells) c->updateBehavior();
        } else {
            auto t0 = Clock::now();
            if(shuffleCells) std::shuffle(std::begin(cells), std::end(cells), MecaCell::Config::globalRand());
            const size_t MIN_CHUNK_SIZE = 2;
            const double AVG_TASKS_PER_THREAD = 3.0;
            if (parallelUpdateBehavior && nbThreads > 0) {
                threadpool.autoChunks(cells, MIN_CHUNK_SIZE, AVG_TASKS_PER_THREAD,
                                    [](auto *c) { c->updateBehavior(); });
                threadpool.waitUntilLast();
            } else
                for (auto &c : cells) c->updateBehavior();
            auto dt = std::chrono::duration<double, std::micro>(Clock::now() - t0).count();
            benchResults["World@callUpdateBehavior"][frame] = dt;
        }
    }
 
    void update() {
        runHooks(Hooks::beginUpdate);
        runHooks(Hooks::preBehaviorUpdate);
        if (frame % updtBhvPeriod == 0) callUpdateBehavior();
        addNewCells();
        runHooks(Hooks::preDeleteDeadCellsUpdate);
        deleteDeadCells();
        runHooks(Hooks::postBehaviorUpdate);
        runHooks(Hooks::endUpdate);
        ++frame;
    }
 
    std::string getBenchmarksJSON() const {
        auto demangle = [&](const std::string &mangled) {
            int status = 0;
            char* dem = abi::__cxa_demangle(mangled.c_str(), nullptr, nullptr, &status);
            std::string s = (status == 0 && dem) ? dem : mangled;
            std::free(dem);
            return s;
        };
        std::map<std::string,std::map<std::string, std::map<size_t, double>>> nested;
 
        for (auto const& [key, frameMap] : benchResults) {
            auto pos = key.rfind('@');
            std::string mangledP = (pos != std::string::npos ? key.substr(0, pos) : key);
            std::string hookName  = (pos != std::string::npos ? key.substr(pos + 1) : "");
            std::string pluginName = demangle(mangledP);
            auto lt            = pluginName.find('<');
            pluginName         = lt!=std::string::npos ? pluginName.substr(0,lt) : pluginName;
            auto ns            = pluginName.rfind("::");
            pluginName         = ns!=std::string::npos ? pluginName.substr(ns+2) : pluginName;
            nested[pluginName][hookName] = frameMap;
        }
 
        std::ostringstream oss;
        oss << "{";
        bool firstPlugin = true;
        for (auto const& [plugin, hooks] : nested) {
            if (!firstPlugin) oss << ",";
            firstPlugin = false;
            oss << "\n  \"" << plugin << "\": {";
 
            bool firstHook = true;
            for (auto const& [hook, frames] : hooks) {
                if (!firstHook) oss << ",";
                firstHook = false;
                oss << "\n    \"" << hook << "\": {";
 
                bool firstFrame = true;
                for (auto const& [frm, us] : frames) {
                    if (!firstFrame) oss << ",";
                    firstFrame = false;
                    oss << "\n      \"" << frm << "\": " << us;
                }
                oss << "\n    }";  // end hook
            }
            oss << "\n  }";  // end plugin
        }
        oss << "\n}";
        return oss.str();
    }
 
    void showBenchmarksSummaries() const {
        if(!benchmark) {
            std::cout << "Benchmarking is disabled. Enable it by setting World::benchmark to true.\n";
            return;
        }
        struct Stats { double sum=0, mean=0, stddev=0; size_t n=0; };
 
        auto demangle = [&](const std::string &mangled) {
            int status = 0;
            char* dem = abi::__cxa_demangle(mangled.c_str(), nullptr, nullptr, &status);
            std::string s = (status==0 && dem) ? dem : mangled;
            std::free(dem);
            return s;
        };
 
        auto formatTime = [&](double us)->std::string {
            std::ostringstream o;
            if      (us < 1e3)   o << std::fixed<<std::setprecision(2)<<us    << " us";
            else if (us < 1e6)   o << std::fixed<<std::setprecision(2)<<us/1e3<< " ms";
            else if (us < 6e7)   o << std::fixed<<std::setprecision(2)<<us/1e6<< "  s";
            else                 o << std::fixed<<std::setprecision(2)<<us/6e7<< " min";
            return o.str();
        };
 
        struct Row { std::string plugin, hook; Stats st; };
        std::vector<Row> rows;
        rows.reserve(benchResults.size());
        size_t maxP=0, maxH=0;
        for (auto const& [key, frameMap] : benchResults) {
            auto pos = key.rfind('@');
            std::string mangledP = (pos!=std::string::npos ? key.substr(0,pos) : key);
            std::string hookName = (pos!=std::string::npos ? key.substr(pos+1) : "");
            std::string pluginName = demangle(mangledP);
            auto lt            = pluginName.find('<');
            pluginName         = lt!=std::string::npos ? pluginName.substr(0,lt) : pluginName;
            auto ns            = pluginName.rfind("::");
            pluginName         = ns!=std::string::npos ? pluginName.substr(ns+2) : pluginName;
 
            maxP = std::max(maxP, pluginName.size());
            maxH = std::max(maxH, hookName.size());
 
            Stats st; st.n = frameMap.size();
            for (auto const& [_f, us] : frameMap) st.sum += us;
            if (st.n) {
                st.mean = st.sum / st.n;
                double var = 0;
                for (auto const& [_f, us] : frameMap) {
                    double d = us - st.mean;
                    var += d*d;
                }
                st.stddev = std::sqrt(var / st.n);
            }
            rows.push_back({ pluginName, hookName, st });
        }
 
        std::sort(rows.begin(), rows.end(),
        [](auto const &a, auto const &b){
            return a.st.sum > b.st.sum;
        }
        );
 
        const size_t W_P = std::min(maxP+2, size_t(40));
        const size_t W_H = std::min(maxH+2, size_t(30));
        const int    W_N = 14;
 
        std::cout
        << std::left << std::setw(W_P) << "Plugin"
        << std::left << std::setw(W_H) << "Hook"
        << std::right
        << std::setw(W_N) << "Total"
        << std::setw(W_N) << "Mean"
        << std::setw(W_N) << "StdDev"
        << std::setw(10) << "Frames"
        << "\n"
        << std::string(W_P + W_H + W_N*3 + 10, '-') << "\n";
 
        for (auto const& r : rows) {
            auto p = r.plugin.size() > W_P-1
                    ? r.plugin.substr(0, W_P-4) + "..."
                    : r.plugin;
            auto h = r.hook.size()   > W_H-1
                    ? r.hook.substr(0, W_H-4) + "..."
                    : r.hook;
 
            std::cout
            << std::left  << std::setw(W_P) << p
            << std::left  << std::setw(W_H) << h
            << std::right
            << std::setw(W_N) << formatTime(r.st.sum)
            << std::setw(W_N) << formatTime(r.st.mean)
            << std::setw(W_N) << formatTime(r.st.stddev)
            << std::setw(10) << r.st.n
            << "\n";
        }
    }
    ~World() {
        runHooks(Hooks::destructor);
        while (!cells.empty()) delete cells.back(), cells.pop_back();
        while (!newCells.empty()) delete newCells.back(), newCells.pop_back();
    }
 
    EXPORTABLE(World, KV(frame), KV(cells));
};
}  // namespace MecaCell
#endif