bencher.hh

// bencher.hh: this file is part of the Vaucanson project.
//
// Vaucanson, a generic library for finite state machines.
//
// Copyright (C) 2004, 2005, 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_TOOLS_BENCHER_HH
# define VCSN_TOOLS_BENCHER_HH

# ifdef VCSN_BENCH

#  include <sys/time.h>
#  include <sys/resource.h>
#  include <cstdio>
#  include <cstring>
#  include <cstdlib>
#  include <ctime>
#  include <iostream>
#  include <vector>
#  include <string>
#  include <utility>

namespace vcsn
{
  namespace tools
  {
    class bencher {
      public:
        bencher();
        ~bencher();

      public:
        void    start();
        void    stop();
        double  get_time();

      private:
        double  dtime();

        double  start_;
        double  stop_;
    };

    unsigned int                                        n_bench_indent;
    std::vector<bencher*>                               v_benchers;
    std::vector< std::pair<int, bencher*> >             v_old_benchers;

  } // tools
} // vcsn

#  define VCSN_BENCH_START_QUIET                \
  {                                             \
    using namespace vcsn::tools;                \
    v_benchers.push_back(new bencher);          \
    v_benchers.back()->start();                 \
  }

#  define VCSN_BENCH_START                                      \
  {                                                             \
    using namespace vcsn::tools;                                \
    v_benchers.push_back(new bencher);                          \
    v_benchers.back()->start();                                 \
    std::cerr << std::string(n_bench_indent, ' ') <<            \
      "Start bench in " << __FUNCTION__ << "..." << std::endl;  \
    n_bench_indent += 3;                                        \
  }

#  define VCSN_BENCH_STOP_QUIET(Result)         \
  {                                             \
    using namespace vcsn::tools;                \
    v_benchers.back()->stop();                  \
    Result = v_benchers.back()->get_time();     \
    delete v_benchers.back();                   \
    v_benchers.pop_back();                      \
  }

#  define VCSN_BENCH_STOP                                               \
  {                                                                     \
    using namespace vcsn::tools;                                        \
    v_benchers.back()->stop();                                          \
    v_old_benchers.insert(v_old_benchers.begin(),                       \
                          std::pair<int, bencher*>(n_bench_indent,      \
                                                   v_benchers.back())); \
    n_bench_indent -= 3;                                                \
    std::cerr << std::string(n_bench_indent, ' ') <<                    \
      "Stop bench in " << __FUNCTION__ << "..." << std::endl;           \
    v_benchers.pop_back();                                              \
  }

#  define VCSN_BENCH_PRINT                                              \
  {                                                                     \
    using namespace vcsn::tools;                                        \
    std::cerr << std::string(v_old_benchers.back().first, ' ') <<       \
      __FUNCTION__ << ": " <<                                           \
      v_old_benchers.back().second->get_time() << std::endl;            \
    delete v_old_benchers.back().second;                                \
    v_old_benchers.pop_back();                                          \
  }

#  define VCSN_BENCH_STOP_AND_PRINT                             \
  {                                                             \
    using namespace vcsn::tools;                                \
    v_benchers.back()->stop();                                  \
    std::cerr << std::string(n_bench_indent, ' ') <<            \
      __FUNCTION__ << ": " <<                                   \
      v_benchers.back()->get_time() << std::endl;               \
    n_bench_indent -= 3;                                        \
    std::cerr << std::string(n_bench_indent, ' ') <<            \
      "Stop bench in " << __FUNCTION__ << "..." << std::endl;   \
    delete v_benchers.back();                                   \
    v_benchers.pop_back();                                      \
  }



#  ifndef VCSN_USE_INTERFACE_ONLY
#   include <vaucanson/tools/bencher.hxx>
#  endif // VCSN_USE_INTERFACE_ONLY

# else // VCSN_BENCH

#  define VCSN_BENCH_START
#  define VCSN_BENCH_STOP
#  define VCSN_BENCH_PRINT
#  define VCSN_BENCH_STOP_AND_PRINT
#  define VCSN_BENCH_START_QUIET
#  define VCSN_BENCH_STOP_QUIET

# endif // ! VCSN_BENCH
#endif // ! VCSN_TOOLS_BENCHER_HH

---