sco/pokerth
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

New version of the boost timer (addon lib).

Browse Source
This commit is contained in:
lotodore
2007-09-05 00:06:20 +00:00
parent 0900d3844b
commit d789162a2a
27 changed files with 1362 additions and 918 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/boost/timer.hpp
-31
View File
@@ -1,31 +0,0 @@
#ifndef BOOST_TIMER_HPP
#define BOOST_TIMER_HPP
// (C) Copyright Vaucher Philippe 2006
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006
// Speeds up compilation a bit on msvc
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
#pragma once
#endif
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4244)
#endif
// -------------------------- Includes --------------------------
#include "boost/timer/implementation.hpp"
#include "boost/timer/devices.hpp"
#include "boost/timer/typedefs.hpp"
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif // BOOST_TIMER_HPP
src/core/boost/timer/devices.hpp
-31
View File
@@ -1,31 +0,0 @@
#ifndef BOOST_TIMER_DEVICES_HPP
#define BOOST_TIMER_DEVICES_HPP
// (C) Copyright Vaucher Philippe 2006
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006
// -------------------------- Devices --------------------------
//! A device has 3 main member functions: start(), elapsed() & reset().
// -------------------------- Includes --------------------------
#include "boost/timer/devices/clock.hpp"
#include "boost/timer/devices/date_time.hpp"
#ifndef BOOST_WINDOWS
#include "boost/timer/devices/gettimeofday.hpp"
#else
#include "boost/timer/devices/QueryPerformanceCounter.hpp"
#include "boost/timer/devices/timeGetTime.hpp"
#include "boost/timer/devices/GetSystemTimeAsFileTime.hpp"
#include "boost/timer/devices/GetTickCount.hpp"
#endif
#endif // BOOST_TIMER_DEVICES_HPP
src/core/boost/timer/implementation.hpp
-107
View File
@@ -1,107 +0,0 @@
#ifndef BOOST_TIMER_IMPLEMENTATION_HPP
#define BOOST_TIMER_IMPLEMENTATION_HPP
// (C) Copyright Vaucher Philippe 2006
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006
// -------------------------- Code --------------------------
namespace boost
{
//! The timer class takes a device type that's used for the elapsed time computation.
//! Calling start(), pause() or resume() twice has no special effects.
template<class Device>
class timer
{
public:
typedef Device device_type;
typedef typename device_type::time_duration_type time_duration_type;
enum start_options { auto_start = 1, manual_start };
//! By default, start the timer without any time offset
explicit timer(time_duration_type initial_duration = time_duration_type(0, 0, 0), start_options start_op = auto_start)
: m_elapsed(initial_duration), m_running(false)
{
if(start_op == auto_start)
start();
}
//! Starts the timer
void start()
{
if(!m_running)
{
m_device.start();
m_running = true;
}
}
//! Restarts the timer
void restart()
{
reset();
start();
}
//! Returns the elapsed time
time_duration_type elapsed() const
{
return m_running ? (m_device.elapsed() + m_elapsed) : m_elapsed;
}
//! Pauses the timer
void pause()
{
if(m_running)
{
m_elapsed += m_device.elapsed();
m_device.reset();
m_running = false;
}
}
//! Resumes the timer
void resume()
{
if(!m_running)
{
m_device.start();
m_running = true;
}
}
//! Resets the timer
void reset()
{
m_elapsed = time_duration_type(0,0,0);
m_device.reset();
m_running = false;
}
//! Tells wether the timer is currently running or not
bool is_running() const
{
return m_running;
}
private:
mutable device_type m_device;
mutable time_duration_type m_elapsed;
bool m_running;
};
} // namespace boost
#endif // BOOST_TIMER_IMPLEMENTATION_HPP
src/core/boost/timer/typedefs.hpp
-55
View File
@@ -1,55 +0,0 @@
#ifndef BOOST_TIMER_TYPEDEFS_HPP
#define BOOST_TIMER_TYPEDEFS_HPP
// (C) Copyright Vaucher Philippe 2006
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006
// -------------------------- Includes --------------------------
#include <boost/date_time/posix_time/posix_time.hpp>
#include "boost/timer/implementation.hpp"
#include "boost/timer/devices.hpp"
// -------------------------- Devices --------------------------
namespace boost
{
// boost::date_time devices
typedef timer<microsec_device> microsec_timer;
typedef timer<second_device> second_timer;
// std::clock() device
typedef timer<clock_device> clock_timer;
#ifndef BOOST_WINDOWS
// gettimeofday() device
typedef timer<gtod_device> gtod_timer;
#else
// QueryPerformanceCounter() device
typedef timer<qpc_device> qpc_timer;
// timeGetTime() device
typedef timer<tgt_device> tgt_timer;
// GetSystemTimeAsFileTime() device
typedef timer<gstaft_device> gstaft_timer;
// GetTickCount() device
typedef timer<gtc_device> gtc_timer;
#endif
} // namespace boost
#endif // BOOST_TIMER_TYPEDEFS_HPP
src/core/boost/timers.hpp
+29
View File
@@ -0,0 +1,29 @@
#ifndef _BOOST_TIMERS_HPP
#define _BOOST_TIMERS_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Includes --------------------------
// Speeds up compilation a bit on msvc
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
#pragma once
#endif
#include <boost/config.hpp>
#include "timers/timer.hpp"
#include "timers/portable.hpp"
#ifdef BOOST_WINDOWS
#include "timers/win32.hpp"
#else
#include "timers/posix.hpp"
#endif
#endif // _BOOST_TIMERS_HPP
src/core/boost/timers/portable.hpp
+46
View File
@@ -0,0 +1,46 @@
#ifndef _BOOST_TIMERS_PORTABLE_HPP
#define _BOOST_TIMERS_PORTABLE_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Includes --------------------------
#include "timer.hpp"
#include "portable/clock_device.hpp"
#include "portable/date_time_devices.hpp"
#include "portable/time_device.hpp"
// -------------------------- Code --------------------------
namespace boost
{
namespace timers
{
namespace portable
{
// boost::date_time devices
typedef timer<microsec_device> microsec_timer;
typedef timer<second_device> second_timer;
// std::clock() device
typedef timer<clock_device> clock_timer;
// std::time() device
typedef timer<time_device> time_timer;
// Typedef which timer is the best
typedef microsec_timer best_timer;
} // namespace portable
} // namespace timers
} // namespace boost
#endif // _BOOST_TIMERS_PORTABLE_HPP
src/core/boost/timer/devices/clock.hpp → src/core/boost/timers/portable/clock_device.hpp
+84 -85
View File
@@ -1,85 +1,84 @@
#ifndef BOOST_TIMER_DEVICES_CLOCK_HPP #ifndef _BOOST_TIMERS_PORTABLE_CLOCK_DEVICE_HPP
#define BOOST_TIMER_DEVICES_CLOCK_HPP #define _BOOST_TIMERS_PORTABLE_CLOCK_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2006 // (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the // Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying // Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0) // file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006 // Author: Vaucher Philippe 2007
// -------------------------- std::clock() --------------------------
// -------------------------- Includes --------------------------
// Properties:
// - ??? ns resolution. // Standard headers
// - ??? ns overhead. #include <ctime>
// - Is implemented with GetSystemTimeAsFileTime on windows.
// // Boost headers
// Pros: #include <boost/date_time/posix_time/posix_time.hpp>
// - Portable.
//
// Cons: // -------------------------- Code --------------------------
// - High resolution.
namespace boost
{
// -------------------------- Includes -------------------------- namespace timers
{
// Standard headers namespace portable
#include <ctime> {
// Boost headers //! The clock_device class is based on std::clock() to compute the time
#include <boost/date_time/posix_time/posix_time.hpp> class clock_device
{
// -------------------------- Code -------------------------- public:
namespace boost typedef posix_time::ptime time_type;
{ typedef time_type::time_duration_type time_duration_type;
//! The clock_device class is based on std::clock() to compute the time explicit clock_device() : m_running(false), m_start(0), m_elapsed(0, 0, 0)
class clock_device {
{ }
public: void start()
{
typedef posix_time::ptime time_type; if(!m_running)
typedef time_type::time_duration_type time_duration_type; {
m_start = std::clock();
explicit clock_device() : m_start(0), m_elapsed(0, 0, 0) m_running = true;
{ }
} }
void start() const time_duration_type& elapsed() const
{ {
if(!m_start) if(m_running)
m_start = std::clock(); {
} std::clock_t current = std::clock();
double seconds = (current - m_start) / static_cast<double>(CLOCKS_PER_SEC);
const time_duration_type& elapsed() const m_elapsed += posix_time::milliseconds(static_cast<int64_t>(seconds * 1000.0));
{ m_start = current;
if(m_start) }
{ return m_elapsed;
std::clock_t current = std::clock(); }
m_elapsed += posix_time::milliseconds(static_cast<double>(current-m_start) / CLOCKS_PER_SEC * 1000.0);
m_start = current; void reset()
} {
return m_elapsed; m_elapsed = time_duration_type(0,0,0);
} m_start = 0;
m_running = false;
void reset() }
{
m_elapsed = time_duration_type(0,0,0);
m_start = 0; private:
}
bool m_running;
mutable std::clock_t m_start;
private: mutable time_duration_type m_elapsed;
mutable std::clock_t m_start; };
mutable time_duration_type m_elapsed;
} // namespace portable
}; } // namespace timers
} // namespace boost
} // namespace boost
#endif // _BOOST_TIMERS_PORTABLE_CLOCK_DEVICE_HPP
#endif // BOOST_TIMER_DEVICES_CLOCK_HPP
src/core/boost/timer/devices/date_time.hpp → src/core/boost/timers/portable/date_time_devices.hpp
+80 -84
View File
@@ -1,84 +1,80 @@
#ifndef BOOST_TIMER_DEVICES_DATE_TIME_HPP #ifndef _BOOST_TIMERS_PORTABLE_DATE_TIME_DEVICES_HPP
#define BOOST_TIMER_DEVICES_DATE_TIME_HPP #define _BOOST_TIMERS_PORTABLE_DATE_TIME_DEVICES_HPP
// (C) Copyright Vaucher Philippe 2006 // (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the // Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying // Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0) // file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006 // Author: Vaucher Philippe 2007
// -------------------------- date_time devices -------------------------- // -------------------------- Includes --------------------------
// Properties: #include <boost/date_time/posix_time/posix_time.hpp>
// - windows: uses GetSystemTimeAsFileTime()
// - POSIX: uses gettimeofday()
// // -------------------------- Code --------------------------
// Pros:
// - Portable. namespace boost
{
namespace timers
// -------------------------- Includes -------------------------- {
namespace portable
#include <boost/date_time/posix_time/posix_time.hpp> {
//! The date_time device
// -------------------------- Code -------------------------- template <class Clock, class Time = posix_time::ptime>
class date_time_device
namespace boost {
{
public:
//! The date_time device
template <class Clock, class Time = posix_time::ptime> typedef Clock clock_type;
class date_time_device typedef Time time_type;
{ typedef typename clock_type::time_duration_type time_duration_type;
public: explicit date_time_device() : m_start(date_time::not_a_date_time), m_elapsed(0, 0, 0)
{
typedef Clock clock_type; }
typedef Time time_type;
typedef typename clock_type::time_duration_type time_duration_type; void start()
{
explicit date_time_device() : m_start(date_time::not_a_date_time), m_elapsed(0, 0, 0) if(m_start.is_not_a_date_time())
{ m_start = clock_type::local_time();
} }
void start() const time_duration_type& elapsed() const
{ {
if(m_start.is_not_a_date_time()) if(!m_start.is_not_a_date_time())
m_start = clock_type::local_time(); {
} time_type current(clock_type::local_time());
m_elapsed += (current - m_start);
const time_duration_type& elapsed() const m_start = current;
{ }
if(!m_start.is_not_a_date_time()) return m_elapsed;
{ }
time_type current(clock_type::local_time());
m_elapsed += (current - m_start); void reset()
m_start = current; {
} m_start = date_time::not_a_date_time;
return m_elapsed; m_elapsed = time_duration_type(0,0,0);
} }
void reset()
{ private:
m_start = date_time::not_a_date_time;
m_elapsed = time_duration_type(0,0,0); mutable time_type m_start;
} mutable time_duration_type m_elapsed;
};
private:
// Convenience typedefs
mutable time_type m_start; typedef date_time_device<posix_time::microsec_clock> microsec_device;
mutable time_duration_type m_elapsed; typedef date_time_device<posix_time::second_clock> second_device;
}; } // namespace portable
} // namespace timers
// Convenience typedefs } // namespace boost
typedef date_time_device<posix_time::microsec_clock> microsec_device;
typedef date_time_device<posix_time::second_clock> second_device; #endif // _BOOST_TIMERS_PORTABLE_DATE_TIME_DEVICES_HPP
} // namespace boost
#endif // BOOST_TIMER_DEVICES_DATE_TIME_HPP
src/core/boost/timers/portable/time_device.hpp
+76
View File
@@ -0,0 +1,76 @@
#ifndef _BOOST_TIMERS_PORTABLE_TIME_DEVICE_HPP
#define _BOOST_TIMERS_PORTABLE_TIME_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Includes --------------------------
// Standard headers
#include <ctime>
// -------------------------- Code --------------------------
namespace boost
{
namespace timers
{
namespace portable
{
//! The time_device class is based on std::time() to compute the time
class time_device
{
public:
typedef posix_time::ptime time_type;
typedef time_type::time_duration_type time_duration_type;
explicit time_device() : m_start(0), m_elapsed(0, 0, 0)
{
}
void start()
{
if(!m_start)
m_start = std::time(0);
}
const time_duration_type& elapsed() const
{
if(m_start)
{
std::time_t current = std::time(0);
long seconds = static_cast<long>(current - m_start);
m_elapsed += posix_time::seconds(seconds);
m_start = current;
}
return m_elapsed;
}
void reset()
{
m_elapsed = time_duration_type(0,0,0);
m_start = 0;
}
private:
mutable std::time_t m_start;
mutable time_duration_type m_elapsed;
};
} // namespace portable
} // namespace timers
} // namespace boost
#endif // _BOOST_TIMERS_PORTABLE_TIME_DEVICE_HPP
src/core/boost/timers/posix.hpp
+45
View File
@@ -0,0 +1,45 @@
#ifndef _BOOST_TIMERS_POSIX_HPP
#define _BOOST_TIMERS_POSIX_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Includes --------------------------
#include "timer.hpp"
#include "posix/ftime_device.hpp"
#include "posix/gru_device.hpp"
#include "posix/gtod_device.hpp"
// -------------------------- Code --------------------------
namespace boost
{
namespace timers
{
namespace posix
{
// ftime() device
typedef timer<ftime_device> ftime_timer;
// getcputime() device
typedef timer<gru_device> gru_timer;
// gettimeofday() device
typedef timer<gtod_device> gtod_timer;
// Typedef which timer is the best
typedef gtod_timer best_timer;
} // namespace posix
} // namespace timers
} // namespace boost
#endif // _BOOST_TIMERS_POSIX_HPP
src/core/boost/timers/posix/ftime_device.hpp
+86
View File
@@ -0,0 +1,86 @@
#ifndef _BOOST_TIMERS_POSIX_FTIME_DEVICE_HPP
#define _BOOST_TIMERS_POSIX_FTIME_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Includes --------------------------
// Boost headers
#include <boost/date_time/posix_time/posix_time.hpp>
// Linux headers
#include <sys/timeb.h>
// -------------------------- Code --------------------------
namespace boost
{
namespace timers
{
namespace posix
{
//! The gtod_device class is based on gettimeofday() to compute the time
class ftime_device
{
public:
typedef posix_time::ptime time_type;
typedef time_type::time_duration_type time_duration_type;
explicit ftime_device() : m_elapsed(0, 0, 0)
{
std::memset(&m_start, 0, sizeof(timeb));
}
void start()
{
if(!is_time(m_start))
ftime(&m_start);
}
const time_duration_type& elapsed() const
{
if(is_time(m_start))
{
timeb current;
ftime(&current);
int64_t seconds = current.time - m_start.time;
int64_t milliseconds = current.millitm - m_start.millitm;
m_elapsed += posix_time::milliseconds(seconds * 1000 + milliseconds);
m_start = current;
}
return m_elapsed;
}
void reset()
{
m_elapsed = time_duration_type(0,0,0);
std::memset(&m_start, 0, sizeof(timeb));
}
private:
bool is_time(const timeb& value) const
{
return value.time != 0;
}
mutable timeb m_start;
mutable time_duration_type m_elapsed;
};
} // namespace posix
} // namespace timers
} // namespace boost
#endif // _BOOST_TIMERS_POSIX_FTIME_DEVICE_HPP
src/core/boost/timers/posix/gru_device.hpp
+88
View File
@@ -0,0 +1,88 @@
#ifndef _BOOST_TIMERS_POSIX_GRU_DEVICE_HPP
#define _BOOST_TIMERS_POSIX_GRU_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Includes --------------------------
// Boost headers
#include <boost/date_time/posix_time/posix_time.hpp>
// Linux headers
#include <sys/times.h>
#include <sys/resource.h>
// -------------------------- Code --------------------------
namespace boost
{
namespace timers
{
namespace posix
{
//! The gru_device class is based on getrusage() to compute the time
class gru_device
{
public:
typedef posix_time::ptime time_type;
typedef time_type::time_duration_type time_duration_type;
explicit gru_device() : m_elapsed(0, 0, 0)
{
std::memset(&m_start, 0, sizeof(timeval));
}
void start()
{
if(!is_time(m_start))
getrusage(RUSAGE_SELF, &m_start);
}
const time_duration_type& elapsed() const
{
if(is_time(m_start))
{
rusage current;
getrusage(RUSAGE_SELF, &current);
int64_t seconds = current.ru_utime.tv_sec - m_start.ru_utime.tv_sec;
int64_t microseconds = current.ru_utime.tv_usec - m_start.ru_utime.tv_usec;
m_elapsed += posix_time::microseconds(seconds * 1000000 + microseconds);
m_start = current;
}
return m_elapsed;
}
void reset()
{
m_elapsed = time_duration_type(0,0,0);
std::memset(&m_start, 0, sizeof(timeval));
}
private:
bool is_time(const rusage& value) const
{
return value.ru_utime.tv_sec || value.ru_utime.tv_usec;
}
mutable rusage m_start;
mutable time_duration_type m_elapsed;
};
} // namespace posix
} // namespace timers
} // namespace boost
#endif // _BOOST_TIMERS_POSIX_GRU_DEVICE_HPP
src/core/boost/timer/devices/gettimeofday.hpp → src/core/boost/timers/posix/gtod_device.hpp
+86 -98
View File
@@ -1,98 +1,86 @@
#ifndef BOOST_TIMER_DEVICES_GTOD_HPP #ifndef _BOOST_TIMERS_POSIX_GTOD_DEVICE_HPP
#define BOOST_TIMER_DEVICES_GTOD_HPP #define _BOOST_TIMERS_POSIX_GTOD_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2006 // (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the // Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying // Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0) // file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006 // Author: Vaucher Philippe 2007
// -------------------------- gettimeofday() --------------------------
// -------------------------- Includes --------------------------
// Properties:
// - ??? ns resolution. // Boost headers
// - ??? ns overhead. #include <boost/date_time/posix_time/posix_time.hpp>
//
// Pros: // Linux headers
// - Low overhead. #include <sys/time.h>
// - High resolution.
// -------------------------- Code --------------------------
// -------------------------- Includes -------------------------- namespace boost
{
// Get config namespace timers
#include <boost/config.hpp> {
namespace posix
// Check we have gettimeofday() {
#ifndef BOOST_HAS_GETTIMEOFDAY
#error "gettimeofday() can only be used on POSIX systems" //! The gtod_device class is based on gettimeofday() to compute the time
#else class gtod_device
{
// Boost headers
#include <boost/date_time/posix_time/posix_time.hpp> public:
// Linux headers typedef posix_time::ptime time_type;
#include <sys/time.h> typedef time_type::time_duration_type time_duration_type;
// -------------------------- Code -------------------------- explicit gtod_device() : m_elapsed(0, 0, 0)
{
namespace boost std::memset(&m_start, 0, sizeof(timeval));
{ }
//! The gtod_device class is based on gettimeofday() to compute the time void start()
class gtod_device {
{ if(!is_time(m_start))
gettimeofday(&m_start, 0);
public: }
typedef posix_time::ptime time_type; const time_duration_type& elapsed() const
typedef time_type::time_duration_type time_duration_type; {
if(is_time(m_start))
explicit gtod_device() : m_elapsed(0, 0, 0) {
{ timeval current;
std::memset(&m_start, 0, sizeof(timeval)); gettimeofday(&current, 0);
} int64_t seconds = current.tv_sec - m_start.tv_sec;
int64_t microseconds = current.tv_usec - m_start.tv_usec;
void start() m_elapsed += posix_time::microseconds(seconds * 1000000 + microseconds);
{ m_start = current;
if(!is_time(m_start)) }
gettimeofday(&m_start, 0); return m_elapsed;
} }
const time_duration_type& elapsed() const void reset()
{ {
if(is_time(m_start)) m_elapsed = time_duration_type(0,0,0);
{ std::memset(&m_start, 0, sizeof(timeval));
timeval current; }
gettimeofday(&current, 0);
m_elapsed += posix_time::milliseconds((current.tv_sec-m_start.tv_sec) * 1000 + ((current.tv_usec-m_start.tv_usec) / 1000.0));
m_start = current; private:
}
return m_elapsed; bool is_time(const timeval& value) const
} {
return value.tv_sec || value.tv_usec;
void reset() }
{
m_elapsed = time_duration_type(0,0,0); mutable timeval m_start;
std::memset(&m_start, 0, sizeof(timeval)); mutable time_duration_type m_elapsed;
}
};
private: } // namespace posix
} // namespace timers
bool is_time(const timeval& value) const } // namespace boost
{
return value.tv_sec || value.tv_usec; #endif // _BOOST_TIMERS_POSIX_GTOD_DEVICE_HPP
}
mutable timeval m_start;
mutable time_duration_type m_elapsed;
};
} // namespace boost
#endif // BOOST_HAS_GETTIMEOFDAY
#endif // BOOST_TIMER_DEVICES_GTOD_HPP
src/core/boost/timers/timer.hpp
+112
View File
@@ -0,0 +1,112 @@
#ifndef _BOOST_TIMERS_TIMER_HPP
#define _BOOST_TIMERS_TIMER_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Code --------------------------
namespace boost
{
namespace timers
{
//! The timer class takes a device type that's used for the elapsed time computation.
//! Calling start(), pause() or resume() twice has no special effects.
template<class Device>
class timer
{
public:
typedef Device device_type;
typedef typename device_type::time_duration_type time_duration_type;
enum start_options { auto_start = 1, manual_start };
//! By default, start the timer without any time offset
explicit timer(time_duration_type initial_duration = time_duration_type(0, 0, 0), start_options start_op = auto_start)
: m_elapsed(initial_duration), m_running(false)
{
if(start_op == auto_start)
start();
}
//! Starts the timer
void start()
{
if(!m_running)
{
m_device.start();
m_running = true;
}
}
//! Restarts the timer
void restart()
{
reset();
start();
}
//! Returns the elapsed time
time_duration_type elapsed() const
{
return m_running ? (m_device.elapsed() + m_elapsed) : m_elapsed;
}
//! Pauses the timer
void pause()
{
if(m_running)
{
m_elapsed += m_device.elapsed();
m_device.reset();
m_running = false;
}
}
//! Resumes the timer
void resume()
{
if(!m_running)
{
m_device.start();
m_running = true;
}
}
//! Resets the timer
void reset()
{
m_elapsed = time_duration_type(0,0,0);
m_device.reset();
m_running = false;
}
//! Tells wether the timer is currently running or not
bool is_running() const
{
return m_running;
}
private:
mutable device_type m_device;
mutable time_duration_type m_elapsed;
bool m_running;
};
} // namespace timers
} // namespace boost
#endif // _BOOST_TIMERS_TIMER_HPP
src/core/boost/timers/win32.hpp
+57
View File
@@ -0,0 +1,57 @@
#ifndef _BOOST_TIMERS_WIN32_HPP
#define _BOOST_TIMERS_WIN32_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Includes --------------------------
#include "timer.hpp"
#include "win32/gpt_device.hpp"
#include "win32/gtc_device.hpp"
#include "win32/gtt_device.hpp"
#include "win32/gstaft_device.hpp"
#include "win32/qpc_device.hpp"
#include "win32/tgt_device.hpp"
// -------------------------- Code --------------------------
namespace boost
{
namespace timers
{
namespace win32
{
// GetProcessTimes() device
typedef timer<gpt_device> gpt_timer;
// GetThreadTimes() device
typedef timer<gtt_device> gtt_timer;
// GetTickCount() device
typedef timer<gtc_device> gtc_timer;
// GetSystemTimeAsFileTime() device
typedef timer<gstaft_device> gstaft_timer;
// QueryPerformanceCounter() device
typedef timer<qpc_device> qpc_timer;
// timeGetTime() device
typedef timer<tgt_device> tgt_timer;
// Typedef which timer is the best
typedef qpc_timer best_timer;
} // namespace win32
} // namespace timers
} // namespace boost
#endif // _BOOST_TIMERS_WIN32_HPP
src/core/boost/timers/win32/gpt_device.hpp
+97
View File
@@ -0,0 +1,97 @@
#ifndef _BOOST_TIMERS_WIN32_GPT_DEVICE_HPP
#define _BOOST_TIMERS_WIN32_GPT_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Includes --------------------------
// Standard headers
#include <utility>
// Boost headers
#include <boost/cstdint.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
// Windows headers
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
// -------------------------- Code --------------------------
namespace boost
{
namespace timers
{
namespace win32
{
//! The gtt_device class is based on GetThreadTimes() to compute the time
class gpt_device
{
public:
typedef posix_time::ptime time_type;
typedef time_type::time_duration_type time_duration_type;
explicit gpt_device() : m_start(0, 0), m_elapsed(0, 0, 0)
{
}
void start()
{
if(!is_time(m_start))
{
FILETIME tmp1, tmp2;
GetProcessTimes(GetCurrentProcess(), &tmp1, &tmp2, reinterpret_cast<LPFILETIME>(&m_start.first), reinterpret_cast<LPFILETIME>(&m_start.second));
}
}
const time_duration_type& elapsed() const
{
if(is_time(m_start))
{
std::pair<uint64_t, uint64_t> current;
FILETIME tmp1, tmp2;
GetProcessTimes(GetCurrentProcess(), &tmp1, &tmp2, reinterpret_cast<LPFILETIME>(&current.first), reinterpret_cast<LPFILETIME>(&current.second));
// diff is measured in 100ns intervals...
uint64_t diff = (current.first - m_start.first) + (current.second - m_start.second);
// ... so we must divide by 10 to get nanoseconds
uint64_t nanoseconds = static_cast<uint64_t>(diff / 10.0);
m_elapsed += posix_time::milliseconds(static_cast<int64_t>(nanoseconds / 1000.0));
m_start = current;
}
return m_elapsed;
}
void reset()
{
m_elapsed = time_duration_type(0,0,0);
m_start.first = m_start.second = 0;
}
private:
bool is_time(const std::pair<uint64_t, uint64_t>& time) const
{
return (time.first != 0 || time.second != 0);
}
mutable std::pair<uint64_t, uint64_t> m_start;
mutable time_duration_type m_elapsed;
};
} // namespace win32
} // namespace timers
} // namespace boost
#endif // _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP
src/core/boost/timer/devices/GetSystemTimeAsFileTime.hpp → src/core/boost/timers/win32/gstaft_device.hpp
+86 -96
View File
@@ -1,96 +1,86 @@
#ifndef BOOST_TIMER_DEVICES_GSTAFT_HPP #ifndef _BOOST_TIMERS_WIN32_GSTAFT_DEVICE_HPP
#define BOOST_TIMER_DEVICES_GSTAFT_HPP #define _BOOST_TIMERS_WIN32_GSTAFT_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2006 // (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the // Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying // Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0) // file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006 // Author: Vaucher Philippe 2007
// -------------------------- GetSystemTimeAsFileTime() -------------------------- // -------------------------- Includes --------------------------
// Properties: // Boost headers
// - ??? ns resolution. #include <boost/cstdint.hpp>
// - ??? ns overhead (6 clocks (64-bit load/store + synchronization (4))). #include <boost/date_time/posix_time/posix_time.hpp>
//
// Pros: // Windows headers
// - Low overhead. #define WIN32_LEAN_AND_MEAN
// #include <windows.h>
// Cons:
// - Low resolution.
// -------------------------- Code --------------------------
// -------------------------- Includes -------------------------- namespace boost
{
#ifndef BOOST_WINDOWS namespace timers
#error "GetSystemTimeAsFileTime() can only be used on windows" {
#else namespace win32
{
// Boost headers
#include <boost/cstdint.hpp> //! The gstaft_device class is based on GetSystemTimeAsFileTime() to compute the time
#include <boost/date_time/posix_time/posix_time.hpp> class gstaft_device
{
// Windows headers
#define WIN32_LEAN_AND_MEAN public:
#include <windows.h>
typedef posix_time::ptime time_type;
typedef time_type::time_duration_type time_duration_type;
// -------------------------- Code --------------------------
explicit gstaft_device() : m_elapsed(0, 0, 0)
namespace boost {
{ std::memset(&m_start, 0, sizeof(ULARGE_INTEGER));
}
//! The gstaft_device class is based on GetSystemTimeAsFileTime() to compute the time
class gstaft_device void start()
{ {
if(!m_start.QuadPart)
public: GetSystemTimeAsFileTime(reinterpret_cast<LPFILETIME>(&m_start));
}
typedef posix_time::ptime time_type;
typedef time_type::time_duration_type time_duration_type; const time_duration_type& elapsed() const
{
explicit gstaft_device() : m_elapsed(0, 0, 0) if(m_start.QuadPart)
{ {
std::memset(&m_start, 0, sizeof(ULARGE_INTEGER)); ULARGE_INTEGER current;
} GetSystemTimeAsFileTime(reinterpret_cast<LPFILETIME>(&current));
// diff is measured in 100ns intervals...
void start() uint64_t diff = current.QuadPart - m_start.QuadPart;
{ // ... so we must divide by 10 to get nanoseconds
if(!m_start.QuadPart) uint64_t nanoseconds = static_cast<uint64_t>(diff / 10.0);
GetSystemTimeAsFileTime(reinterpret_cast<LPFILETIME>(&m_start)); m_elapsed += posix_time::milliseconds(static_cast<int64_t>(nanoseconds / 1000.0));
} m_start = current;
}
const time_duration_type& elapsed() const return m_elapsed;
{ }
if(m_start.QuadPart)
{ void reset()
ULARGE_INTEGER current; {
GetSystemTimeAsFileTime(reinterpret_cast<LPFILETIME>(&current)); m_elapsed = time_duration_type(0,0,0);
uint64_t tmp = current.QuadPart - m_start.QuadPart; std::memset(&m_start, 0, sizeof(ULARGE_INTEGER));
m_elapsed += posix_time::milliseconds(tmp / 10000.0); }
m_start = current;
}
return m_elapsed; private:
}
mutable ULARGE_INTEGER m_start;
void reset() mutable time_duration_type m_elapsed;
{
m_elapsed = time_duration_type(0,0,0); };
std::memset(&m_start, 0, sizeof(ULARGE_INTEGER));
} } // namespace win32
} // namespace timers
} // namespace boost
private:
#endif // _BOOST_TIMERS_WIN32_GSTAFT_DEVICE_HPP
mutable ULARGE_INTEGER m_start;
mutable time_duration_type m_elapsed;
};
} // namespace boost
#endif // BOOST_WINDOWS
#endif // BOOST_TIMER_DEVICES_GSTAFT_HPP
src/core/boost/timer/devices/GetTickCount.hpp → src/core/boost/timers/win32/gtc_device.hpp
+81 -92
View File
@@ -1,92 +1,81 @@
#ifndef BOOST_TIMER_DEVICES_GTC_HPP #ifndef _BOOST_TIMERS_WIN32_GTC_DEVICE_HPP
#define BOOST_TIMER_DEVICES_GTC_HPP #define _BOOST_TIMERS_WIN32_GTC_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2006 // (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the // Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying // Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0) // file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006 // Author: Vaucher Philippe 2007
// -------------------------- GetTickCount() --------------------------
// -------------------------- Includes --------------------------
// Properties:
// - 5 to 55 ms resolution. // Boost headers
// - ??? ns overhead (8 clock (load, mul, shift)). #include <boost/cstdint.hpp>
// #include <boost/date_time/posix_time/posix_time.hpp>
// Pros:
// - Very low overhead. // Windows headers
// #define WIN32_LEAN_AND_MEAN
// Cons: #include <windows.h>
// - Very low resolution.
// -------------------------- Code --------------------------
// -------------------------- Includes --------------------------
namespace boost
#ifndef BOOST_WINDOWS {
#error "GetTickCount() can only be used on windows" namespace timers
#else {
namespace win32
// Boost headers {
#include <boost/cstdint.hpp>
#include <boost/date_time/posix_time/posix_time.hpp> //! The gtc_device class is based on GetTickCount() to compute the time
class gtc_device
// Windows headers {
#define WIN32_LEAN_AND_MEAN
#include <windows.h> public:
typedef posix_time::ptime time_type;
// -------------------------- Code -------------------------- typedef time_type::time_duration_type time_duration_type;
namespace boost explicit gtc_device() : m_start(0), m_elapsed(0, 0, 0)
{ {
}
//! The gtc_device class is based on GetTickCount() to compute the time
class gtc_device void start()
{ {
if(!m_start)
public: m_start = GetTickCount();
}
typedef posix_time::ptime time_type;
typedef time_type::time_duration_type time_duration_type; const time_duration_type& elapsed() const
{
explicit gtc_device() : m_start(0), m_elapsed(0, 0, 0) if(m_start)
{ {
} uint32_t current = GetTickCount();
uint64_t milliseconds = current - m_start;
void start() m_elapsed += posix_time::milliseconds(milliseconds);
{ m_start = current;
if(!m_start) }
m_start = GetTickCount(); return m_elapsed;
} }
const time_duration_type& elapsed() const void reset()
{ {
if(m_start) m_elapsed = time_duration_type(0,0,0);
{ m_start = 0;
uint32_t current = GetTickCount(); }
m_elapsed += posix_time::milliseconds(current - m_start);
m_start = current;
} private:
return m_elapsed;
} mutable uint32_t m_start;
mutable time_duration_type m_elapsed;
void reset()
{ };
m_elapsed = time_duration_type(0,0,0);
m_start = 0; } // namespace win32
} } // namespace timers
} // namespace boost
private: #endif // _BOOST_TIMERS_WIN32_GTC_DEVICE_HPP
mutable uint32_t m_start;
mutable time_duration_type m_elapsed;
};
} // namespace boost
#endif // BOOST_WINDOWS
#endif // BOOST_TIMER_DEVICES_GTC_HPP
src/core/boost/timers/win32/gtt_device.hpp
+97
View File
@@ -0,0 +1,97 @@
#ifndef _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP
#define _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2007
// -------------------------- Includes --------------------------
// Standard headers
#include <utility>
// Boost headers
#include <boost/cstdint.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
// Windows headers
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
// -------------------------- Code --------------------------
namespace boost
{
namespace timers
{
namespace win32
{
//! The gtt_device class is based on GetThreadTimes() to compute the time
class gtt_device
{
public:
typedef posix_time::ptime time_type;
typedef time_type::time_duration_type time_duration_type;
explicit gtt_device() : m_start(0, 0), m_elapsed(0, 0, 0)
{
}
void start()
{
if(!is_time(m_start))
{
FILETIME tmp1, tmp2;
GetThreadTimes(GetCurrentThread(), &tmp1, &tmp2, reinterpret_cast<LPFILETIME>(&m_start.first), reinterpret_cast<LPFILETIME>(&m_start.second));
}
}
const time_duration_type& elapsed() const
{
if(is_time(m_start))
{
std::pair<uint64_t, uint64_t> current;
FILETIME tmp1, tmp2;
GetThreadTimes(GetCurrentThread(), &tmp1, &tmp2, reinterpret_cast<LPFILETIME>(&current.first), reinterpret_cast<LPFILETIME>(&current.second));
// diff is measured in 100ns intervals...
uint64_t diff = (current.first - m_start.first) + (current.second - m_start.second);
// ... so we must divide by 10 to get nanoseconds
uint64_t nanoseconds = static_cast<uint64_t>(diff / 10.0);
m_elapsed += posix_time::milliseconds(static_cast<int64_t>(nanoseconds / 1000.0));
m_start = current;
}
return m_elapsed;
}
void reset()
{
m_elapsed = time_duration_type(0,0,0);
m_start.first = m_start.second = 0;
}
private:
bool is_time(const std::pair<uint64_t, uint64_t>& time) const
{
return (time.first != 0 || time.second != 0);
}
mutable std::pair<uint64_t, uint64_t> m_start;
mutable time_duration_type m_elapsed;
};
} // namespace win32
} // namespace timers
} // namespace boost
#endif // _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP
src/core/boost/timer/devices/QueryPerformanceCounter.hpp → src/core/boost/timers/win32/qpc_device.hpp
+104 -130
View File
@@ -1,130 +1,104 @@
#ifndef BOOST_TIMER_DEVICES_QPC_HPP #ifndef _BOOST_TIMERS_WIN32_QPC_DEVICE_HPP
#define BOOST_TIMER_DEVICES_QPC_HPP #define _BOOST_TIMERS_WIN32_QPC_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2006 // (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the // Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying // Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0) // file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006 // Author: Vaucher Philippe 2007
// -------------------------- QueryPerformanceCounter() -------------------------- // -------------------------- Includes --------------------------
// Properties: // Boost headers
// Win2k (PIT): #include <boost/throw_exception.hpp>
// - 838 ns resolution. #include <boost/date_time/posix_time/posix_time.hpp>
// - ~3000 ns overhead.
// WinXP (PMT): // Windows headers
// - 279 ns resolution. #define WIN32_LEAN_AND_MEAN
// - 700 ns overhead. #include <windows.h>
//
// Pros:
// - High resolution (usually the best one). // -------------------------- Code --------------------------
//
// Cons: namespace boost
// - High overhead. {
// - Not thread safe. namespace timers
// - Multi core problems. To solve the issue you can #define BOOST_QPC_SET_AFFINITY which will call SetThreadAffinityMask() for you. {
// namespace win32
// Issues: {
// 1) Q274323: may jump several seconds under heavy PCI bus load.
// not a problem, because the older systems on which this occurs class qpc_device
// have safe TSCs, so that is used instead. {
// 2) "System clock problem can inflate benchmark scores":
// incorrect value if not polled every 4.5 seconds? public:
typedef posix_time::ptime time_type;
// -------------------------- Includes -------------------------- typedef time_type::time_duration_type time_duration_type;
#ifndef BOOST_WINDOWS explicit qpc_device() : m_elapsed(0, 0, 0)
#error "QueryPerformanceCounter() can only be used on windows" {
#else #ifdef BOOST_QPC_SET_AFFINITY
m_affinity = SetThreadAffinityMask(GetCurrentThread(), 1);
// Boost headers #endif
#include <boost/throw_exception.hpp>
#include <boost/date_time/posix_time/posix_time.hpp> m_start.QuadPart = 0;
if(!QueryPerformanceFrequency(&m_frequency))
// Windows headers throw_exception(std::runtime_error("qpc_device: QueryPerformanceFrequency() indicated there's no high-resolution performance counter"));
#define WIN32_LEAN_AND_MEAN
#include <windows.h> // Make it so we have the future results directly in milliseconds
m_frequency.QuadPart /= 1000;
}
// -------------------------- Code --------------------------
~qpc_device()
namespace boost {
{ #ifdef BOOST_QPC_SET_AFFINITY
SetThreadAffinityMask(GetCurrentThread(), m_affinity);
class qpc_device #endif
{ }
public: void start()
{
typedef posix_time::ptime time_type; if(!m_start.QuadPart && !QueryPerformanceCounter(&m_start))
typedef time_type::time_duration_type time_duration_type; throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed"));
}
explicit qpc_device() : m_elapsed(0, 0, 0)
{ const time_duration_type& elapsed() const
#ifdef BOOST_QPC_SET_AFFINITY {
m_affinity = SetThreadAffinityMask(GetCurrentThread(), 1); if(m_start.QuadPart)
#endif {
LARGE_INTEGER current;
m_start.QuadPart = 0; if(!QueryPerformanceCounter(&current))
if(!QueryPerformanceFrequency(&m_frequency)) throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed"));
throw_exception(std::runtime_error("qpc_device: QueryPerformanceFrequency() indicated there's no high-resolution performance counter")); int64_t milliseconds = (current.QuadPart - m_start.QuadPart) / m_frequency.QuadPart;
m_elapsed += posix_time::milliseconds(milliseconds);
// Make it so we have the future results directly in milliseconds m_start = current;
m_frequency.QuadPart /= 1000; }
} return m_elapsed;
}
~qpc_device()
{ void reset()
#ifdef BOOST_QPC_SET_AFFINITY {
SetThreadAffinityMask(GetCurrentThread(), m_affinity); m_elapsed = time_duration_type(0,0,0);
#endif m_start.QuadPart = 0;
} }
void start()
{ private:
if(!m_start.QuadPart && !QueryPerformanceCounter(&m_start))
throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed")); LARGE_INTEGER m_frequency;
} mutable LARGE_INTEGER m_start;
mutable time_duration_type m_elapsed;
const time_duration_type& elapsed() const
{ #ifdef BOOST_QPC_SET_AFFINITY
if(m_start.QuadPart) DWORD_PTR m_affinity;
{ #endif
LARGE_INTEGER current;
if(!QueryPerformanceCounter(&current)) };
throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed"));
uint64_t milliseconds = (current.QuadPart - m_start.QuadPart) / m_frequency.QuadPart; } // namespace win32
m_elapsed += posix_time::milliseconds(milliseconds); } // namespace timers
m_start = current; } // namespace boost
}
return m_elapsed; #endif // _BOOST_TIMERS_WIN32_QUERYPERFORMANCECOUNTER_HPP
}
void reset()
{
m_elapsed = time_duration_type(0,0,0);
m_start.QuadPart = 0;
}
private:
LARGE_INTEGER m_frequency;
mutable LARGE_INTEGER m_start;
mutable time_duration_type m_elapsed;
#ifdef BOOST_QPC_SET_AFFINITY
DWORD_PTR m_affinity;
#endif
};
} // namespace boost
#endif // BOOST_WINDOWS
#endif // BOOST_TIMER_DEVICES_QPC_HPP
src/core/boost/timer/devices/timeGetTime.hpp → src/core/boost/timers/win32/tgt_device.hpp
+95 -94
View File
@@ -1,94 +1,95 @@
#ifndef BOOST_TIMER_DEVICES_TGT_HPP #ifndef _BOOST_TIMERS_WIN32_TGT_DEVICE_HPP
#define BOOST_TIMER_DEVICES_TGT_HPP #define _BOOST_TIMERS_WIN32_TGT_DEVICE_HPP
// (C) Copyright Vaucher Philippe 2006 // (C) Copyright Vaucher Philippe 2007
// Use, modification and distribution is subject to the // Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying // Boost Software License, Version 1.0. (See accompanying
// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0) // file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
// Author: Vaucher Philippe 2006 // Author: Vaucher Philippe 2007
// -------------------------- std::clock() --------------------------
// -------------------------- Includes --------------------------
// Properties:
// - 1 ms resolution. // Boost headers
// - ??? ns overhead. #include <boost/cstdint.hpp>
// #include <boost/date_time/posix_time/posix_time.hpp>
// Pros:
// - Low overhead. // Windows headers
// #define WIN32_LEAN_AND_MEAN
// Cons: #include <windows.h>
// - Low resolution.
// Automagically link winmm.lib if we can
// -------------------------- Includes -------------------------- #if (defined _MSC_VER) && (_MSC_VER >= 1200)
#pragma comment(lib, "winmm.lib")
#ifndef BOOST_WINDOWS #endif
#error "timeGetTime() can only be used on windows"
#else // -------------------------- Code --------------------------
// Boost headers namespace boost
#include <boost/cstdint.hpp> {
#include <boost/date_time/posix_time/posix_time.hpp> namespace timers
{
// Windows headers namespace win32
#define WIN32_LEAN_AND_MEAN {
#include <windows.h>
//! The tgt_device class is based on timeGetTime() to compute the time
// Automagically link winmm.lib if we can class tgt_device
#pragma comment(lib, "winmm.lib") {
public:
// -------------------------- Code --------------------------
typedef posix_time::ptime time_type;
namespace boost typedef time_type::time_duration_type time_duration_type;
{
explicit tgt_device() : m_start(0), m_elapsed(0, 0, 0)
//! The tgt_device class is based on timeGetTime() to compute the time {
class tgt_device #ifndef BOOST_TGT_DEFAULT_RES
{ timeBeginPeriod(1);
#endif
public: }
typedef posix_time::ptime time_type; ~tgt_device()
typedef time_type::time_duration_type time_duration_type; {
#ifndef BOOST_TGT_DEFAULT_RES
explicit tgt_device() : m_start(0), m_elapsed(0, 0, 0) timeEndPeriod(1);
{ #endif
} }
void start() void start()
{ {
if(!m_start) if(!m_start)
m_start = timeGetTime(); m_start = timeGetTime();
} }
const time_duration_type& elapsed() const const time_duration_type& elapsed() const
{ {
if(m_start) if(m_start)
{ {
uint32_t current = timeGetTime(); uint32_t current = timeGetTime();
m_elapsed += posix_time::milliseconds(current - m_start); int64_t milliseconds = current - m_start;
m_start = current; m_elapsed += posix_time::milliseconds(milliseconds);
} m_start = current;
return m_elapsed; }
} return m_elapsed;
}
void reset()
{ void reset()
m_elapsed = time_duration_type(0,0,0); {
m_start = 0; m_elapsed = time_duration_type(0,0,0);
} m_start = 0;
}
private:
private:
mutable uint32_t m_start;
mutable time_duration_type m_elapsed; mutable uint32_t m_start;
mutable time_duration_type m_elapsed;
};
};
} // namespace boost
} // namespace win32
#endif // BOOST_WINDOWS } // namespace timers
} // namespace boost
#endif // BOOST_TIMER_DEVICES_TGT_HPP
#endif // _BOOST_TIMERS_WIN32_TGT_DEVICE_HPP
src/gui/qt/mainwindow/mysetlabel.h
+2 -2
View File
@@ -16,7 +16,7 @@
#include <QtGui> #include <QtGui>
#include <QtCore> #include <QtCore>
#include <core/boost/timer.hpp> #include <core/boost/timers.hpp>
#include "sdlplayer.h" #include "sdlplayer.h"
class mainWindowImpl; class mainWindowImpl;
@@ -51,7 +51,7 @@ private:
// boost::shared_ptr<SDLPlayer> mySDLPlayer; // boost::shared_ptr<SDLPlayer> mySDLPlayer;
boost::microsec_timer realTimer; boost::timers::portable::microsec_timer realTimer;
bool timeOutAnimation; bool timeOutAnimation;
src/net/clientstate.h
+3 -5
View File
@@ -24,7 +24,7 @@
#include <net/socket_helper.h> // needed for correct order of header files. #include <net/socket_helper.h> // needed for correct order of header files.
#include <string> #include <string>
#include <memory> #include <memory>
#include <core/boost/timer.hpp> #include <core/boost/timers.hpp>
#define CLIENT_INITIAL_STATE ClientStateInit #define CLIENT_INITIAL_STATE ClientStateInit
@@ -114,8 +114,6 @@ public:
virtual ~ClientStateStartConnect(); virtual ~ClientStateStartConnect();
void SetTimer(boost::microsec_timer timer);
// Call connect. // Call connect.
virtual int Process(ClientThread &client); virtual int Process(ClientThread &client);
@@ -134,7 +132,7 @@ public:
virtual ~ClientStateConnecting(); virtual ~ClientStateConnecting();
void SetTimer(const boost::microsec_timer &timer); void SetTimer(const boost::timers::portable::microsec_timer &timer);
// "Poll" for the completion of the TCP/IP connect call. // "Poll" for the completion of the TCP/IP connect call.
virtual int Process(ClientThread &client); virtual int Process(ClientThread &client);
@@ -146,7 +144,7 @@ protected:
private: private:
boost::microsec_timer m_connectTimer; boost::timers::portable::microsec_timer m_connectTimer;
}; };
// State: Session init. // State: Session init.
src/net/common/clientstate.cpp
+2 -2
View File
@@ -247,7 +247,7 @@ ClientStateStartConnect::Process(ClientThread &client)
int errCode = SOCKET_ERRNO(); int errCode = SOCKET_ERRNO();
if (errCode == SOCKET_ERR_WOULDBLOCK) if (errCode == SOCKET_ERR_WOULDBLOCK)
{ {
boost::microsec_timer connectTimer; boost::timers::portable::microsec_timer connectTimer;
connectTimer.start(); connectTimer.start();
ClientStateConnecting::Instance().SetTimer(connectTimer); ClientStateConnecting::Instance().SetTimer(connectTimer);
client.SetState(ClientStateConnecting::Instance()); client.SetState(ClientStateConnecting::Instance());
@@ -278,7 +278,7 @@ ClientStateConnecting::~ClientStateConnecting()
} }
void void
ClientStateConnecting::SetTimer(const boost::microsec_timer &timer) ClientStateConnecting::SetTimer(const boost::timers::portable::microsec_timer &timer)
{ {
m_connectTimer = timer; m_connectTimer = timer;
} }
src/net/common/serverlobbythread.cpp
+1 -1
View File
@@ -85,7 +85,7 @@ ServerLobbyThread::CloseSessionDelayed(SessionWrapper session)
{ {
m_sessionManager.RemoveSession(session.sessionData->GetSocket()); m_sessionManager.RemoveSession(session.sessionData->GetSocket());
boost::microsec_timer closeTimer; boost::timers::portable::microsec_timer closeTimer;
closeTimer.start(); closeTimer.start();
CloseSessionList::value_type closeSessionData(closeTimer, session.sessionData); CloseSessionList::value_type closeSessionData(closeTimer, session.sessionData);
src/net/servergamestate.h
+3 -3
View File
@@ -23,7 +23,7 @@
#include <net/servergamethread.h> #include <net/servergamethread.h>
#include <playerdata.h> #include <playerdata.h>
#include <core/boost/timer.hpp> #include <core/boost/timers.hpp>
#ifdef _MSC_VER #ifdef _MSC_VER
@@ -78,14 +78,14 @@ public:
virtual void Init(); virtual void Init();
const boost::microsec_timer &GetTimer() const {return m_timer;} const boost::timers::portable::microsec_timer &GetTimer() const {return m_timer;}
protected: protected:
AbstractServerGameStateTimer(); AbstractServerGameStateTimer();
private: private:
boost::microsec_timer m_timer; boost::timers::portable::microsec_timer m_timer;
}; };
// Abstract State: Game is running. // Abstract State: Game is running.
src/net/serverlobbythread.h
+2 -2
View File
@@ -29,7 +29,7 @@
#include <deque> #include <deque>
#include <list> #include <list>
#include <core/boost/timer.hpp> #include <core/boost/timers.hpp>
#define LOBBY_THREAD_TERMINATE_TIMEOUT 200 #define LOBBY_THREAD_TERMINATE_TIMEOUT 200
@@ -65,7 +65,7 @@ protected:
typedef std::deque<boost::shared_ptr<ConnectData> > ConnectQueue; typedef std::deque<boost::shared_ptr<ConnectData> > ConnectQueue;
typedef std::list<SessionWrapper> SessionList; typedef std::list<SessionWrapper> SessionList;
typedef std::list<std::pair<boost::microsec_timer, boost::shared_ptr<SessionData> > > CloseSessionList; typedef std::list<std::pair<boost::timers::portable::microsec_timer, boost::shared_ptr<SessionData> > > CloseSessionList;
typedef std::map<unsigned, boost::shared_ptr<ServerGameThread> > GameMap; typedef std::map<unsigned, boost::shared_ptr<ServerGameThread> > GameMap;
typedef std::list<unsigned> RemoveGameList; typedef std::list<unsigned> RemoveGameList;