Benchmark.h

Go to the documentation of this file.

/*********************************************************************
* Software License Agreement (BSD License)
*
*  Copyright (c) 2010, Rice University
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*   * Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*   * Redistributions in binary form must reproduce the above
*     copyright notice, this list of conditions and the following
*     disclaimer in the documentation and/or other materials provided
*     with the distribution.
*   * Neither the name of the Rice University nor the names of its
*     contributors may be used to endorse or promote products derived
*     from this software without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
*********************************************************************/

/* Author: Ioan Sucan */

#ifndef OMPL_BENCHMARK_BENCHMARK_
#define OMPL_BENCHMARK_BENCHMARK_

#include "ompl/geometric/SimpleSetup.h"
#include "ompl/control/SimpleSetup.h"

namespace ompl
{

    class Benchmark
    {
    public:

        struct Status
        {
            Status(void)
            {
                running = false;
                activePlanner = "";
                activeRun = 0;
                progressPercentage = 0.0;
            }

            bool         running;

            std::string  activePlanner;

            unsigned int activeRun;

            double       progressPercentage;
        };

        typedef std::map<std::string, std::string> RunProperties;

        struct PlannerExperiment
        {
            std::string                name;

            std::vector<RunProperties> runs;

            RunProperties              common;
        };

        struct CompleteExperiment
        {
            std::string                    name;

            std::vector<PlannerExperiment> planners;

            double                         maxTime;

            double                         maxMem;

            time::point                    startTime;

            double                         totalDuration;

            std::string                    setupInfo;

            boost::uint32_t                seed;

            std::string                    host;
        };

        Benchmark(geometric::SimpleSetup &setup, const std::string &name = std::string()) : gsetup_(&setup), csetup_(NULL), msg_("Benchmark")
        {
            exp_.name = name;
        }

        Benchmark(control::SimpleSetup &setup, const std::string &name = std::string()) : gsetup_(NULL), csetup_(&setup), msg_("Benchmark")
        {
            exp_.name = name;
        }

        virtual ~Benchmark(void)
        {
        }

        void setExperimentName(const std::string &name)
        {
            exp_.name = name;
        }

        const std::string& getExperimentName(void) const
        {
            return exp_.name;
        }

        void addPlanner(const base::PlannerPtr &planner)
        {
            if (planner && planner->getSpaceInformation().get() !=
                (gsetup_ ? gsetup_->getSpaceInformation().get() : csetup_->getSpaceInformation().get()))
                throw Exception("Planner instance does not match space information");
            planners_.push_back(planner);
        }

        void addPlannerAllocator(const base::PlannerAllocator &pa)
        {
            planners_.push_back(pa(gsetup_ ? gsetup_->getSpaceInformation() : csetup_->getSpaceInformation()));
        }

        void clearPlanners(void)
        {
            planners_.clear();
        }

        virtual void benchmark(double maxTime, double maxMem, unsigned int runCount, bool displayProgress = false);

        const Status& getStatus(void) const
        {
            return status_;
        }

        const CompleteExperiment& getRecordedExperimentData(void) const
        {
            return exp_;
        }

        virtual bool saveResultsToStream(std::ostream &out = std::cout) const;

        bool saveResultsToFile(const char *filename) const;

        bool saveResultsToFile(void) const;

    protected:

        std::string getResultsFilename(void) const;

        geometric::SimpleSetup       *gsetup_;

        control::SimpleSetup         *csetup_;

        std::vector<base::PlannerPtr> planners_;

        CompleteExperiment            exp_;

        Status                        status_;

        msg::Interface                msg_;

    };

}
#endif

---

ompl
Author(s): Ioan Sucan/isucan@rice.edu, Mark Moll/mmoll@rice.edu, Lydia Kavraki/kavraki@rice.edu
autogenerated on Fri Jan 11 09:33:19 2013