timer.hh

Go to the documentation of this file.

// timer.hh: this file is part of the Vaucanson project.
//
// Vaucanson, a generic library for finite state machines.
//
// Copyright (C) 2006, 2007 The Vaucanson Group.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// The complete GNU General Public Licence Notice can be found as the
// `COPYING' file in the root directory.
//
// The Vaucanson Group consists of people listed in the `AUTHORS' file.
//

#ifndef VCSN_MISC_TIMER_HH
# define VCSN_MISC_TIMER_HH

# include <stack>
# include <map>
# include <list>
# include <string>
# include <iosfwd>
# include <boost/graph/adjacency_list.hpp>
# include <boost/graph/strong_components.hpp>
# include <boost/graph/graphviz.hpp>

/* Disable this when outside Vaucanson */
# define VAUCANSON 1

# ifdef VAUCANSON
#  define NAMESPACE_VCSN_BEGIN namespace vcsn {
#  define NAMESPACE_VCSN_END   } // namespace vcsn
#  include <vaucanson/misc/contract.hh>
#  include <vaucanson/misc/timer_internal_gathering.hh>
#  include <vaucanson/misc/timer_internal_graph.hh>
# else
#  define NAMESPACE_VCSN_BEGIN
#  define NAMESPACE_VCSN_END
#  include <cassert>
#  define precondition(C) assert(C)
#  include "timer_internal_gathering.hh"
#  include "timer_internal_graph.hh"
# endif

NAMESPACE_VCSN_BEGIN

namespace misc
{
  class Timer;

  class ScopedTimer
  {
  public:
    ScopedTimer (Timer& timer, const unsigned int i);

    ScopedTimer (Timer& timer, const std::string& name);

    ~ScopedTimer ();
  private:
    Timer* timer_;
  };

  class Timer
  {
  public:

    Timer ();
    Timer (const Timer& rhs);

    ~Timer ();

    const Timer& operator= (const Timer& rhs);

    unsigned int task (const std::string& name);

    void start ();

    void stop ();

    void clear ();

    std::ostream& print (std::ostream& o,
                         timer::verbose_degree vd = timer::VERBOSE_NORMAL)
      const;

    std::ostream& export_dot (std::ostream&         o,
                              timer::verbose_degree vd = timer::VERBOSE_NORMAL,
                              double                ccr = 1) const;

    std::ostream& dump (std::ostream& o) const;

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

    // Start a sub-timer for a task using its id number (which must
    // be declared beforehand).
    void push (const unsigned int i);

    void pop (const std::string& task_name);

    void pop (const unsigned int i);

    void pop ();

    bool operator< (const Timer& rhs) const;

    Timer& operator+= (const Timer& rhs);

    Timer operator+ (const Timer& rhs);

    Timer& operator/= (unsigned rhs);

    Timer operator/ (unsigned rhs) const;

  private:
    /*------------------------------.
    | Timer: Internal structures.   |
    `------------------------------*/

    // Graph output writers
    friend class timer::GraphWriter;
    friend class timer::VertexWriter;
    friend class timer::EdgeWriter;

    // Add task vertices and call edges to the graph
    void build_output_graph ();
    // Build connected component array
    void build_connected_components ();

    // Compute task & call times in graph
    void compute_output_graph ();
    // Compute component times in graph
    void compute_connected_components ();

    void print_output_graph (std::ostream& o,
                             timer::verbose_degree vd = timer::VERBOSE_NORMAL)
      const;

    timer::call_stack           calls_;
    timer::task_vector          tasks_;
    timer::task_names_map       names_;
    timer::TimeStamp            time_;

    timer::output_graph         graph_;
    timer::component_id_vector  comp_id_;
    timer::component_vector     comp_;
    unsigned int                comp_count_;
    unsigned int                task_count_;

    bool                        is_running_;

    bool                        cleared_;
  };
} // namespace misc

NAMESPACE_VCSN_END

# if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
#  ifdef VAUCANSON
#   include <vaucanson/misc/timer_internal_gathering.hxx>
#   include <vaucanson/misc/timer_internal_graph.hxx>
#   include <vaucanson/misc/timer.hxx>
#   include <vaucanson/misc/timer_internal_gathering.cc>
#   include <vaucanson/misc/timer_internal_graph.cc>
#   include <vaucanson/misc/timer.cc>
#  else
#   include "timer_internal_gathering.hxx"
#   include "timer_internal_graph.hxx"
#   include "timer.hxx"
#  endif
# endif // !VCSN_USE_INTERFACE_ONLY

#endif // !VCSN_MISC_TIMER_HH

---