benchmark.hpp

#ifndef BENCHMARK_HPP_
#define BENCHMARK_HPP_

#include <chrono>
#include <limits>

#include <boost/filesystem.hpp>
#include <boost/progress.hpp>

#include <fast_methods/fm/solver.hpp>
#include <fast_methods/io/gridwriter.hpp>

template <class grid_t>
class Benchmark {

    public:

        Benchmark
        (unsigned int saveGrid = 0, bool saveLog = true) :
        saveGrid_(saveGrid),
        saveLog_(saveLog),
        runID_(0),
        nruns_(10),
        path_("results"),
        name_("benchmark"),
        fromCFG_(false){}

        virtual ~Benchmark()
        {
            clear();
        }

        void fromCFG
        (bool cfg) {
            fromCFG_ = cfg;
        }

        void addSolver
        (Solver<grid_t>* solver) {
            solvers_.push_back(solver);
        }

        void setSaveGrid
        (unsigned int s) {
            saveGrid_ = s;
        }

        void setEnvironment
        (grid_t* grid) {
            grid_ = grid;
        }

        void setNRuns
        (unsigned int n) {
            nruns_ = n;
        }

        void setPath
        (const boost::filesystem::path & path) {
            path_ = path;
        }

        void setSaveLog
        (bool s) {
            saveLog_ = s;
        }

        void setInitialAndGoalPoints
        (const std::vector<unsigned int> & init_points, unsigned int goal_idx) {
            init_points_ = init_points;
            goal_idx_ = goal_idx;
        }

        void setInitialPoints(const std::vector<unsigned int> & init_points)
        {
            setInitialAndGoalPoints(init_points, -1);
        }

        void run
        () {
            if (saveGrid_)
            {
                boost::filesystem::create_directory(path_);
                boost::filesystem::create_directory(path_ / name_);
            }
            else if (saveLog_)
                boost::filesystem::create_directory(path_);

            boost::progress_display showProgress (solvers_.size()*nruns_);

            configSolvers();

            logConfig();

            for (Solver<grid_t>* s :solvers_)
            {
                for (unsigned int i = 0; i < nruns_; ++i)
                {
                    ++runID_;
                    s->reset();
                    s->compute();
                    logRun(s);

                    if (saveGrid_ == 2)
                        saveGrid(s);

                    ++showProgress;
                }
                if (saveGrid_ == 1)
                    saveGrid(s);
                s->reset();                
            }

            if (saveLog_)
                saveLog();
            else {
                console::info("Benchmark log format:");
                std::cout << "Name\t#Runs\t#Dims\tDim1...DimN\t#Starts\tStartIdx\tGoalIdx"<<'\n';
                std::cout << "RunID\tName\tTime (ms)" << '\n';
                std::cout << log_.str() << '\n';
            }
        }

        void logRun
        (const Solver<grid_t>* s)
        {
            std::ios init(NULL);
            init.copyfmt(std::cout);
            formatID();
            log_ << '\n' << fmtID_;

            std::cout.copyfmt(init);
            log_ << '\t' << s->getName() << "\t" << s->getTime();
        }

        void saveGrid
        (Solver<grid_t>* s) const {
            thread_local boost::filesystem::path filename;
            if (saveGrid_ == 1)
                filename = path_ / name_ / s->getName();
            if (saveGrid_ == 2)
                filename = path_ / name_ / fmtID_;
            
            filename.replace_extension(".grid");
            GridWriter::saveGridValues(filename.string().c_str(), *(s->getGrid()));
        }

        void saveLog
        () const {
            std::ofstream ofs (path_.string() + "/" + name_ + ".log");
            ofs << log_.rdbuf();
            ofs.close();
        }

        void setName
        (const std::string & n)
        {
            name_ = n;
        }

        void clear
        () {
            for (auto & s : solvers_)
                delete s;

            solvers_.clear();

            if(fromCFG_)
                delete grid_;
        }

    private:
        void logConfig
        () {
            log_ << name_ << '\t' << nruns_ << '\t' << grid_->getNDims()
                 << '\t' << grid_->getDimSizesStr();

            // Saving starting points.
            log_ << init_points_.size() << '\t';
            std::copy(init_points_.begin(), init_points_.end(), std::ostream_iterator<unsigned int>(log_, "\t"));

            if (int(goal_idx_) == -1)
                log_ << "nan";
            else
                log_ << goal_idx_;
        }

        void configSolvers
        () {
            for (Solver<grid_t>* s :solvers_)
            {
                s->setEnvironment(grid_);
                s->setInitialAndGoalPoints(init_points_, goal_idx_);
            }
        }

        void formatID
        () {
            thread_local std::ostringstream oss; // To optimize a bit.
            oss.str("");
            oss.clear();
            oss << std::setw(4) << std::setfill('0') << runID_;
            fmtID_ = oss.str();
        }

        std::vector<Solver<grid_t>*>                        solvers_;
        
        grid_t *                                            grid_;

        std::vector<unsigned int>                           init_points_;
        
        unsigned int                                        goal_idx_;

        std::chrono::time_point<std::chrono::system_clock>  start_, end_;

        std::stringstream                                   log_;

        unsigned int                                        saveGrid_;
        
        bool                                                saveLog_;

        unsigned int                                        runID_;
        
        std::string                                         fmtID_;
        
        unsigned int                                        nruns_;

        boost::filesystem::path                             path_;
        
        std::string                                         name_;

        bool                                                fromCFG_;
};

#endif /* BENCHMARK_HPP_*/