Profiler.h

/*********************************************************************
* Software License Agreement (BSD License)
*
*  Copyright (c) 2008, Willow Garage, Inc.
*  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 Willow Garage 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_TOOLS_DEBUG_PROFILER_
#define OMPL_TOOLS_DEBUG_PROFILER_

#ifndef ENABLE_PROFILING

#  ifdef NDEBUG
#    define ENABLE_PROFILING 0
#  else
#    define ENABLE_PROFILING 1
#  endif

#endif

#if ENABLE_PROFILING

#include <map>
#include <string>
#include <iostream>
#include <thread>
#include <mutex>

#include "ompl/util/Time.h"

namespace ompl
{

    namespace tools
    {

        class Profiler
        {
        public:
            // non-copyable
            Profiler(const Profiler&) = delete;
            Profiler& operator=(const Profiler&) = delete;

            class ScopedBlock
            {
            public:
                ScopedBlock(const std::string &name, Profiler &prof = Profiler::Instance()) : name_(name), prof_(prof)
                {
                    prof_.begin(name);
                }

                ~ScopedBlock()
                {
                    prof_.end(name_);
                }

            private:

                std::string  name_;
                Profiler    &prof_;
            };

            class ScopedStart
            {
            public:

                ScopedStart(Profiler &prof = Profiler::Instance()) : prof_(prof), wasRunning_(prof_.running())
                {
                    if (!wasRunning_)
                        prof_.start();
                }

                ~ScopedStart()
                {
                    if (!wasRunning_)
                        prof_.stop();
                }

            private:

                Profiler &prof_;
                bool      wasRunning_;
            };

            static Profiler& Instance();

            Profiler(bool printOnDestroy = false, bool autoStart = false) : running_(false), printOnDestroy_(printOnDestroy)
            {
                if (autoStart)
                    start();
            }

            ~Profiler()
            {
                if (printOnDestroy_ && !data_.empty())
                    status();
            }

            static void Start()
            {
                Instance().start();
            }

            static void Stop()
            {
                Instance().stop();
            }

            static void Clear()
            {
                Instance().clear();
            }

            void start();

            void stop();

            void clear();

            static void Event(const std::string& name, const unsigned int times = 1)
            {
                Instance().event(name, times);
            }

            void event(const std::string &name, const unsigned int times = 1);

            static void Average(const std::string& name, const double value)
            {
                Instance().average(name, value);
            }

            void average(const std::string &name, const double value);

            static void Begin(const std::string &name)
            {
                Instance().begin(name);
            }

            static void End(const std::string &name)
            {
                Instance().end(name);
            }

            void begin(const std::string &name);

            void end(const std::string &name);

            static void Status(std::ostream &out = std::cout, bool merge = true)
            {
                Instance().status(out, merge);
            }

            void status(std::ostream &out = std::cout, bool merge = true);

            static void Console()
            {
                Instance().console();
            }

            void console();

            bool running() const
            {
                return running_;
            }

            static bool Running()
            {
                return Instance().running();
            }

        private:

            struct TimeInfo
            {
                TimeInfo() : total(time::seconds(0.)), shortest(time::duration::max()), longest(time::duration::min()), parts(0)
                {
                }

                time::duration    total;

                time::duration    shortest;

                time::duration    longest;

                unsigned long int parts;

                time::point       start;

                void set()
                {
                    start = time::now();
                }

                void update()
                {
                    const time::duration &dt = time::now() - start;
                    if (dt > longest)
                        longest = dt;
                    if (dt < shortest)
                        shortest = dt;
                    total = total + dt;
                    ++parts;
                }
            };

            struct AvgInfo
            {
                double            total;

                double            totalSqr;

                unsigned long int parts;
            };

            struct PerThread
            {
                std::map<std::string, unsigned long int> events;

                std::map<std::string, AvgInfo>           avg;

                std::map<std::string, TimeInfo>          time;
            };

            void printThreadInfo(std::ostream &out, const PerThread &data);

            std::mutex                             lock_;
            std::map<std::thread::id, PerThread>   data_;
            TimeInfo                               tinfo_;
            bool                                   running_;
            bool                                   printOnDestroy_;

        };
    }
}

#else

#include <string>
#include <iostream>

/* If profiling is disabled, provide empty implementations for the
   public functions */
namespace ompl
{

    namespace tools
    {

        class Profiler
        {
        public:

            class ScopedBlock
            {
            public:

                ScopedBlock(const std::string &, Profiler & = Profiler::Instance())
                {
                }

                ~ScopedBlock()
                {
                }
            };

            class ScopedStart
            {
            public:

                ScopedStart(Profiler & = Profiler::Instance())
                {
                }

                ~ScopedStart()
                {
                }
            };

            static Profiler& Instance();

            Profiler(bool = true, bool = true)
            {
            }

            ~Profiler()
            {
            }

            static void Start()
            {
            }

            static void Stop()
            {
            }

            static void Clear()
            {
            }

            void start()
            {
            }

            void stop()
            {
            }

            void clear()
            {
            }

            static void Event(const std::string&, const unsigned int = 1)
            {
            }

            void event(const std::string &, const unsigned int = 1)
            {
            }

            static void Average(const std::string&, const double)
            {
            }

            void average(const std::string &, const double)
            {
            }

            static void Begin(const std::string &)
            {
            }

            static void End(const std::string &)
            {
            }

            void begin(const std::string &)
            {
            }

            void end(const std::string &)
            {
            }

            static void Status(std::ostream & = std::cout, bool = true)
            {
            }

            void status(std::ostream & = std::cout, bool = true)
            {
            }

            static void Console()
            {
            }

            void console()
            {
            }

            bool running() const
            {
                return false;
            }

            static bool Running()
            {
                return false;
            }
        };
    }
}

#endif

#endif