Diagnostics.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012-2014 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
/* Desc: A diagnostic class
 * Author: Nate Koenig
 * Date: 2 Feb 2011
 */

#ifndef _DIAGNOSTICMANAGER_HH_
#define _DIAGNOSTICMANAGER_HH_

#include <boost/unordered_map.hpp>
#include <string>
#include <boost/filesystem.hpp>

#include "gazebo/gazebo_config.h"

#include "gazebo/transport/TransportTypes.hh"

#include "gazebo/msgs/msgs.hh"

#include "gazebo/common/UpdateInfo.hh"
#include "gazebo/common/SingletonT.hh"
#include "gazebo/common/Timer.hh"

#include "gazebo/util/UtilTypes.hh"

namespace gazebo
{
  namespace util
  {

#ifdef ENABLE_DIAGNOSTICS



    #define DIAG_TIMER_START(_name) \
    gazebo::util::DiagnosticManager::Instance()->StartTimer(_name);

    #define DIAG_TIMER_LAP(_name, _prefix) \
    gazebo::util::DiagnosticManager::Instance()->Lap(_name, _prefix);

    #define DIAG_TIMER_STOP(_name) \
    gazebo::util::DiagnosticManager::Instance()->StopTimer(_name);
#else
    #define DIAG_TIMER_START(_name) ((void) 0)
    #define DIAG_TIMER_LAP(_name, _prefix) ((void)0)
    #define DIAG_TIMER_STOP(_name) ((void) 0)
#endif

    class DiagnosticManager : public SingletonT<DiagnosticManager>
    {
      private: DiagnosticManager();

      private: virtual ~DiagnosticManager();

      public: void Init(const std::string &_worldName);

      public: void StartTimer(const std::string &_name);

      public: void StopTimer(const std::string &_name);

      public: void Lap(const std::string &_name, const std::string &_prefix);

      public: int GetTimerCount() const;

      public: common::Time GetTime(int _index) const;

      public: common::Time GetTime(const std::string &_label) const;

      public: std::string GetLabel(int _index) const;

      public: boost::filesystem::path GetLogPath() const;

      private: void Update(const common::UpdateInfo &_info);

      private: void AddTime(const std::string &_name, common::Time &_wallTime,
                   common::Time &_elapsedtime);

      private: typedef boost::unordered_map<std::string, DiagnosticTimerPtr>
               TimerMap;

      private: TimerMap timers;

      private: boost::filesystem::path logPath;

      private: transport::NodePtr node;

      private: transport::PublisherPtr pub;

      private: msgs::Diagnostics msg;

      private: event::ConnectionPtr updateConnection;

      // Singleton implementation
      private: friend class SingletonT<DiagnosticManager>;

      private: friend class DiagnosticTimer;
    };

    class DiagnosticTimer : public common::Timer
    {
      public: DiagnosticTimer(const std::string &_name);

      public: virtual ~DiagnosticTimer();

      public: void Lap(const std::string &_prefix);

      // Documentation inherited
      public: virtual void Start();

      // Documentation inherited
      public: virtual void Stop();

      public: inline const std::string GetName() const
              { return this->name; }

      private: std::string name;

      private: std::ofstream log;

      private: common::Time prevLap;
    };
  }
}
#endif