Subject: [Boost-commit] svn:boost r74623 - in trunk/boost/chrono/stopwatches: . memories
From: vicente.botet_at_[hidden]
Date: 2011-10-01 12:49:37
Author: viboes
Date: 2011-10-01 12:49:36 EDT (Sat, 01 Oct 2011)
New Revision: 74623
URL: http://svn.boost.org/trac/boost/changeset/74623
Log:
Chrono: Simplify basic_stopwatch and extract the suspend/resume part. Added different models of SampleCollectors-Memories
Added:
trunk/boost/chrono/stopwatches/memories/
trunk/boost/chrono/stopwatches/memories/laps_accumulator_set.hpp (contents, props changed)
trunk/boost/chrono/stopwatches/memories/last_lap.hpp (contents, props changed)
trunk/boost/chrono/stopwatches/memories/no_memory.hpp (contents, props changed)
trunk/boost/chrono/stopwatches/suspendable_stopwatch.hpp (contents, props changed)
Text files modified:
trunk/boost/chrono/stopwatches/basic_stopwatch.hpp | 184 +++++++++------------------------------
1 files changed, 45 insertions(+), 139 deletions(-)
Modified: trunk/boost/chrono/stopwatches/basic_stopwatch.hpp
==============================================================================
--- trunk/boost/chrono/stopwatches/basic_stopwatch.hpp (original)
+++ trunk/boost/chrono/stopwatches/basic_stopwatch.hpp 2011-10-01 12:49:36 EDT (Sat, 01 Oct 2011)
@@ -11,6 +11,7 @@
//#include <boost/chrono/chrono.hpp>
#include <boost/chrono/stopwatches/stopwatch_scoped.hpp>
+#include <boost/chrono/stopwatches/memories/no_memory.hpp>
#include <boost/system/error_code.hpp>
namespace boost
@@ -24,59 +25,54 @@
static const dont_start_t dont_start =
{ };
- template<typename Clock, typename Memory>
+ template<typename Clock, typename LapsMemory=no_memory<typename Clock::duration> >
class basic_stopwatch
{
public:
- typedef Memory storage_type;
+ typedef LapsMemory laps_memory;
typedef Clock clock;
typedef typename Clock::duration duration;
typedef typename Clock::time_point time_point;
typedef typename Clock::rep rep;
typedef typename Clock::period period;
+ BOOST_CHRONO_STATIC_CONSTEXPR bool is_steady = Clock::is_steady;
explicit basic_stopwatch(
system::error_code & ec = BOOST_CHRONO_THROWS
) :
- running_(false), suspended_(false), start_(duration::zero()),
- level_(0), partial_(duration::zero()), suspend_level_(0),
- storage_(), construction_(clock::now(ec))
+ start_(duration::zero()),
+ running_(false),
+ storage_()
{
- if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
-
start(ec);
}
explicit basic_stopwatch(
- const dont_start_t&,
- system::error_code & ec = BOOST_CHRONO_THROWS
+ const dont_start_t&
) :
- running_(false), suspended_(false), start_(duration::zero()),
- level_(0), partial_(duration::zero()), suspend_level_(0),
- storage_(), construction_(clock::now(ec))
+ start_(duration::zero()),
+ running_(false),
+ storage_()
{
}
explicit basic_stopwatch(
- storage_type const& acc,
+ laps_memory const& acc,
system::error_code & ec = BOOST_CHRONO_THROWS
) :
- running_(false), suspended_(false), start_(duration::zero()),
- level_(0), partial_(duration::zero()), suspend_level_(0),
- storage_(acc), construction_(clock::now(ec))
+ start_(duration::zero()),
+ running_(false),
+ storage_(acc)
{
- if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
-
start(ec);
}
basic_stopwatch(
- storage_type const& acc,
- const dont_start_t&,
- system::error_code & ec = BOOST_CHRONO_THROWS
+ laps_memory const& acc,
+ const dont_start_t&
) :
- running_(false), suspended_(false), start_(duration::zero()),
- level_(0), partial_(duration::zero()), suspend_level_(0),
- storage_(acc), construction_(clock::now(ec))
+ start_(duration::zero()),
+ running_(false),
+ storage_(acc)
{
}
@@ -86,185 +82,95 @@
stop(ec);
}
- std::pair<duration, time_point> restart(
+ void restart(
system::error_code & ec = BOOST_CHRONO_THROWS
)
{
time_point tmp = clock::now(ec);
- if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return time_point();
+ if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
- if (running_ && (level_ == 1))
+ if (is_running())
{
- partial_ += tmp - start_;
- storage_.store(partial_);
- partial_ = duration::zero();
- } else
+ storage_.store(tmp - start_);
+ }
+ else
{
running_ = true;
}
start_ = tmp;
- return std::make_pair(storage_.elapsed(), start_);
}
- time_point start(
+ void start(
system::error_code & ec = BOOST_CHRONO_THROWS
)
{
- if (!running_)
- {
time_point tmp = clock::now(ec);
- if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return time_point();
+ if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
start_ = tmp;
- ++level_;
running_ = true;
- return start_;
- } else
- {
- ++level_;
- ec.clear();
- return time_point();
- }
}
- duration stop(
+ void stop(
system::error_code & ec = BOOST_CHRONO_THROWS
)
{
- if (running_ && (--level_ == 0))
+ if (is_running())
{
time_point tmp = clock::now(ec);
- if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return duration::zero();
+ if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
- partial_ += tmp - start_;
- storage_.store(partial_);
- partial_ = duration::zero();
+ storage_.store(tmp - start_);
+ start_ = time_point(duration::zero());
running_ = false;
- return storage_.elapsed();
- } else
- {
- ec.clear();
- return duration::zero();
- }
- }
-
- duration suspend(
- system::error_code & ec = BOOST_CHRONO_THROWS
- )
- {
- if (running_)
- {
- if (!suspended_)
- {
- time_point tmp = clock::now(ec);
- if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return duration::zero();
-
- ++suspend_level_;
- partial_ += tmp - start_;
- suspended_ = true;
- return storage_.elapsed();
- } else
- {
- ++suspend_level_;
- ec.clear();
- return duration::zero();
- }
- } else
- {
- ec.clear();
- return duration::zero();
}
}
- time_point resume(
- system::error_code & ec = BOOST_CHRONO_THROWS
- )
- {
- if (suspended_ && (--suspend_level_ == 0))
- {
- time_point tmp = clock::now(ec);
- if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return time_point();
-
- start_ = tmp;
- suspended_ = false;
- return start_;
- } else
- {
- ec.clear();
- return time_point();
- }
+ bool is_running() const {
+ return running_;
}
duration elapsed(
system::error_code & ec = BOOST_CHRONO_THROWS
- )
+ ) const
{
- if (running_)
+ if (is_running())
{
- if (suspended_)
- return storage_.elapsed();
- else
- {
time_point tmp = clock::now(ec);
if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return duration::zero();
- return storage_.elapsed() + tmp - start_;
- }
+ return tmp - start_;
} else
{
- return storage_.elapsed();
+ return duration::zero();
}
}
void reset(
- system::error_code & ec = BOOST_CHRONO_THROWS
)
{
- construction_ = clock::now(ec);
- if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
storage_.reset();
running_ = false;
- suspended_ = false;
- partial_ = duration::zero();
start_ = time_point(duration::zero());
- level_ = 0;
- suspend_level_ = 0;
}
- storage_type const& get_storage()
+ laps_memory const& get_laps_memory()
{
return storage_;
}
- duration lifetime(
- system::error_code & ec = BOOST_CHRONO_THROWS
- )
- {
- typename clock::time_point tmp= clock::now(ec);
- if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return duration::zero();
-
- return tmp - construction_;
- }
- typedef stopwatch_runner<basic_stopwatch<Clock, Memory> >
+ typedef stopwatch_runner<basic_stopwatch<Clock, LapsMemory> >
scoped_run;
- typedef stopwatch_stopper<basic_stopwatch<Clock, Memory> >
+ typedef stopwatch_stopper<basic_stopwatch<Clock, LapsMemory> >
scoped_stop;
- typedef stopwatch_suspender<basic_stopwatch<Clock, Memory> >
- scoped_suspend;
- typedef stopwatch_resumer<basic_stopwatch<Clock, Memory> >
- scoped_resume;
+
private:
- bool running_;
- bool suspended_;
time_point start_;
- std::size_t level_;
- duration partial_;
- std::size_t suspend_level_;
- storage_type storage_;
- time_point construction_;
+ bool running_;
+ laps_memory storage_;
};
} // namespace chrono
Added: trunk/boost/chrono/stopwatches/memories/laps_accumulator_set.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/stopwatches/memories/laps_accumulator_set.hpp 2011-10-01 12:49:36 EDT (Sat, 01 Oct 2011)
@@ -0,0 +1,62 @@
+// boost/chrono/stopwatches/stopwatch_reporter.hpp
+// Copyright 2011 Vicente J. Botet Escriba
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+// See http://www.boost.org/libs/chrono/stopwatches for documentation.
+
+#ifndef BOOST_CHRONO_STOPWATCHES_MEMORIES_LAPS_ACCUMULETOR_SET_HPP
+#define BOOST_CHRONO_STOPWATCHES_MEMORIES_LAPS_ACCUMULETOR_SET_HPP
+
+#include <boost/chrono/stopwatches/memories/last_lap.hpp>
+#include <boost/accumulators/framework/accumulator_set.hpp>
+#include <boost/accumulators/statistics/count.hpp>
+#include <boost/accumulators/statistics/sum.hpp>
+#include <boost/accumulators/statistics/min.hpp>
+#include <boost/accumulators/statistics/max.hpp>
+#include <boost/accumulators/statistics/mean.hpp>
+#include <boost/accumulators/accumulators.hpp>
+
+namespace boost
+{
+ namespace chrono
+ {
+
+ template<
+ typename Duration,
+ typename Features = accumulators::features<accumulators::tag::count,
+ accumulators::tag::sum, accumulators::tag::min,
+ accumulators::tag::max, accumulators::tag::mean>,
+ typename Weight = void>
+ struct laps_accumulator_set : last_lap<Duration>
+ {
+ typedef last_lap<Duration> base_type;
+ typedef Duration duration;
+ typedef typename duration::rep rep;
+ typedef accumulators::accumulator_set<rep, Features,
+ Weight> storage_type;
+ storage_type acc_;
+
+ void store(duration const& d)
+ {
+ this->base_type::store(d);
+ acc_(d.count());
+ }
+ void reset()
+ {
+ this->base_type::reset();
+ acc_ = storage_type();
+ }
+ storage_type const& accumulator_set() const { return acc_; }
+
+
+ };
+
+
+ } // namespace chrono
+} // namespace boost
+
+
+#endif
+
+
Added: trunk/boost/chrono/stopwatches/memories/last_lap.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/stopwatches/memories/last_lap.hpp 2011-10-01 12:49:36 EDT (Sat, 01 Oct 2011)
@@ -0,0 +1,41 @@
+// boost/chrono/stopwatches/stopwatch_reporter.hpp
+// Copyright 2011 Vicente J. Botet Escriba
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+// See http://www.boost.org/libs/chrono/stopwatches for documentation.
+
+#ifndef BOOST_CHRONO_STOPWATCHES_MEMORIES_LAST_LAP_HPP
+#define BOOST_CHRONO_STOPWATCHES_MEMORIES_LAST_LAP_HPP
+
+
+namespace boost
+{
+ namespace chrono
+ {
+
+ template<typename Duration>
+ struct last_lap
+ {
+ typedef Duration duration;
+ duration last_;
+ void store(duration const& d)
+ {
+ last_ = d;
+ }
+ void reset()
+ {
+ last_ = duration::zero();
+ }
+ duration last() const { return last_; }
+
+ };
+
+
+ } // namespace chrono
+} // namespace boost
+
+
+#endif
+
+
Added: trunk/boost/chrono/stopwatches/memories/no_memory.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/stopwatches/memories/no_memory.hpp 2011-10-01 12:49:36 EDT (Sat, 01 Oct 2011)
@@ -0,0 +1,35 @@
+// boost/chrono/stopwatches/stopwatch_reporter.hpp
+// Copyright 2011 Vicente J. Botet Escriba
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+// See http://www.boost.org/libs/chrono/stopwatches for documentation.
+
+#ifndef BOOST_CHRONO_STOPWATCHES_MEMORIES_NO_MEMORY_HPP
+#define BOOST_CHRONO_STOPWATCHES_MEMORIES_NO_MEMORY_HPP
+
+
+namespace boost
+{
+ namespace chrono
+ {
+
+ template<typename Duration>
+ struct no_memory
+ {
+ typedef Duration duration;
+
+ duration last() const { return duration::zero(); }
+ void store(duration const& ) {}
+ void reset() {}
+
+ };
+
+
+ } // namespace chrono
+} // namespace boost
+
+
+#endif
+
+
Added: trunk/boost/chrono/stopwatches/suspendable_stopwatch.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/stopwatches/suspendable_stopwatch.hpp 2011-10-01 12:49:36 EDT (Sat, 01 Oct 2011)
@@ -0,0 +1,245 @@
+// boost/chrono/stopwatches/suspendable_stopwatch.hpp ------------------------------------------------------------//
+// Copyright 2011 Vicente J. Botet Escriba
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+// See http://www.boost.org/libs/libs/chrono/stopwatches for documentation.
+
+#ifndef BOOST_CHRONO_STOPWATCHES_SUSPENDABLE_STOPWATCH__HPP
+#define BOOST_CHRONO_STOPWATCHES_SUSPENDABLE_STOPWATCH__HPP
+
+#include <utility>
+
+//#include <boost/chrono/chrono.hpp>
+#include <boost/chrono/stopwatches/stopwatch_scoped.hpp>
+#include <boost/chrono/stopwatches/memories/no_memory.hpp>
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+ namespace chrono
+ {
+
+ struct dont_start_t
+ {
+ };
+ static const dont_start_t dont_start =
+ { };
+
+ template<typename Clock, typename LapsMemory=no_memory<typename Clock::duration> >
+ class suspendable_stopwatch
+ {
+ public:
+ typedef LapsMemory laps_memory;
+ typedef Clock clock;
+ typedef typename Clock::duration duration;
+ typedef typename Clock::time_point time_point;
+ typedef typename Clock::rep rep;
+ typedef typename Clock::period period;
+ BOOST_CHRONO_STATIC_CONSTEXPR bool is_steady = Clock::is_steady;
+
+ explicit suspendable_stopwatch(
+ system::error_code & ec = BOOST_CHRONO_THROWS
+ ) :
+ start_(duration::zero()),
+ running_(false),
+ storage_(),
+ suspended_(false),
+ partial_(duration::zero())
+ {
+ start(ec);
+ }
+ explicit suspendable_stopwatch(
+ const dont_start_t&
+ ) :
+ start_(duration::zero()),
+ running_(false),
+ storage_(),
+ suspended_(false),
+ partial_(duration::zero())
+ {
+ }
+
+ explicit suspendable_stopwatch(
+ laps_memory const& acc,
+ system::error_code & ec = BOOST_CHRONO_THROWS
+ ) :
+ start_(duration::zero()),
+ running_(false),
+ storage_(acc),
+ suspended_(false),
+ partial_(duration::zero())
+ {
+ start(ec);
+ }
+
+ suspendable_stopwatch(
+ laps_memory const& acc,
+ const dont_start_t&
+ ) :
+ start_(duration::zero()),
+ running_(false),
+ storage_(acc),
+ suspended_(false),
+ partial_(duration::zero())
+ {
+ }
+
+ ~suspendable_stopwatch()
+ {
+ system::error_code ec;
+ stop(ec);
+ }
+
+ void restart(
+ system::error_code & ec = BOOST_CHRONO_THROWS
+ )
+ {
+ time_point tmp = clock::now(ec);
+ if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
+
+ if (running_)
+ {
+ partial_ += tmp - start_;
+ storage_.store(partial_);
+ partial_ = duration::zero();
+ }
+ else
+ {
+ running_ = true;
+ }
+ start_ = tmp;
+ }
+
+ void start(
+ system::error_code & ec = BOOST_CHRONO_THROWS
+ )
+ {
+ time_point tmp = clock::now(ec);
+ if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
+
+ partial_ = duration::zero();
+ start_ = tmp;
+ running_ = true;
+ }
+
+ void stop(
+ system::error_code & ec = BOOST_CHRONO_THROWS
+ )
+ {
+ time_point tmp = clock::now(ec);
+ if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
+
+ partial_ += tmp - start_;
+ storage_.store(partial_);
+ start_ = time_point(duration::zero());
+ running_ = false;
+ suspended_ = false;
+ }
+
+ void suspend(
+ system::error_code & ec = BOOST_CHRONO_THROWS
+ )
+ {
+ if (is_running())
+ {
+ if (!suspended_)
+ {
+ time_point tmp = clock::now(ec);
+ if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
+
+ partial_ += tmp - start_;
+ suspended_ = true;
+ }
+ else
+ {
+ ec.clear();
+ }
+ } else
+ {
+ ec.clear();
+ }
+ }
+
+ void resume(
+ system::error_code & ec = BOOST_CHRONO_THROWS
+ )
+ {
+ if (suspended_)
+ {
+ time_point tmp = clock::now(ec);
+ if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return;
+
+ start_ = tmp;
+ suspended_ = false;
+ } else
+ {
+ ec.clear();
+ }
+ }
+
+ bool is_running() const {
+ return running_;
+ }
+ bool is_suspended() const {
+ return suspended_;
+ }
+
+ duration elapsed(
+ system::error_code & ec = BOOST_CHRONO_THROWS
+ ) const
+ {
+ if (is_running())
+ {
+ if (suspended_) {
+ return partial_;
+ }
+ else
+ {
+ time_point tmp = clock::now(ec);
+ if (!BOOST_CHRONO_IS_THROWS(ec) && ec) return duration::zero();
+
+ return partial_ + tmp - start_;
+ }
+ } else
+ {
+ return duration::zero();
+ }
+ }
+
+
+ void reset(
+ )
+ {
+ storage_.reset();
+ running_ = false;
+ suspended_ = false;
+ partial_ = duration::zero();
+ start_ = time_point(duration::zero());
+ }
+
+ laps_memory const& get_laps_memory()
+ {
+ return storage_;
+ }
+
+
+ typedef stopwatch_runner<suspendable_stopwatch<Clock, LapsMemory> >
+ scoped_run;
+ typedef stopwatch_stopper<suspendable_stopwatch<Clock, LapsMemory> >
+ scoped_stop;
+ typedef stopwatch_suspender<suspendable_stopwatch<Clock, LapsMemory> >
+ scoped_suspend;
+ typedef stopwatch_resumer<suspendable_stopwatch<Clock, LapsMemory> >
+ scoped_resume;
+ private:
+ time_point start_;
+ bool running_;
+ laps_memory storage_;
+ bool suspended_;
+ duration partial_;
+ };
+
+ } // namespace chrono
+} // namespace boost
+
+#endif