diff --git a/src/core/boost/timer.hpp b/src/core/boost/timer.hpp deleted file mode 100644 index 19e2fd72..00000000 --- a/src/core/boost/timer.hpp +++ /dev/null @@ -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 diff --git a/src/core/boost/timer/devices.hpp b/src/core/boost/timer/devices.hpp deleted file mode 100644 index 7f1fe14c..00000000 --- a/src/core/boost/timer/devices.hpp +++ /dev/null @@ -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 diff --git a/src/core/boost/timer/implementation.hpp b/src/core/boost/timer/implementation.hpp deleted file mode 100644 index b1404776..00000000 --- a/src/core/boost/timer/implementation.hpp +++ /dev/null @@ -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 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 diff --git a/src/core/boost/timer/typedefs.hpp b/src/core/boost/timer/typedefs.hpp deleted file mode 100644 index 391f8faf..00000000 --- a/src/core/boost/timer/typedefs.hpp +++ /dev/null @@ -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 - -#include "boost/timer/implementation.hpp" -#include "boost/timer/devices.hpp" - - -// -------------------------- Devices -------------------------- - -namespace boost -{ - -// boost::date_time devices -typedef timer microsec_timer; -typedef timer second_timer; - -// std::clock() device -typedef timer clock_timer; - -#ifndef BOOST_WINDOWS - - // gettimeofday() device - typedef timer gtod_timer; - -#else - - // QueryPerformanceCounter() device - typedef timer qpc_timer; - - // timeGetTime() device - typedef timer tgt_timer; - - // GetSystemTimeAsFileTime() device - typedef timer gstaft_timer; - - // GetTickCount() device - typedef timer gtc_timer; - -#endif - -} // namespace boost - -#endif // BOOST_TIMER_TYPEDEFS_HPP diff --git a/src/core/boost/timers.hpp b/src/core/boost/timers.hpp new file mode 100644 index 00000000..c80b8913 --- /dev/null +++ b/src/core/boost/timers.hpp @@ -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 + +#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 diff --git a/src/core/boost/timers/portable.hpp b/src/core/boost/timers/portable.hpp new file mode 100644 index 00000000..1f765280 --- /dev/null +++ b/src/core/boost/timers/portable.hpp @@ -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_timer; + typedef timer second_timer; + + // std::clock() device + typedef timer clock_timer; + + // std::time() device + typedef timer time_timer; + + // Typedef which timer is the best + typedef microsec_timer best_timer; + +} // namespace portable +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_PORTABLE_HPP diff --git a/src/core/boost/timer/devices/clock.hpp b/src/core/boost/timers/portable/clock_device.hpp similarity index 54% rename from src/core/boost/timer/devices/clock.hpp rename to src/core/boost/timers/portable/clock_device.hpp index 739bcd23..5c58fb42 100644 --- a/src/core/boost/timer/devices/clock.hpp +++ b/src/core/boost/timers/portable/clock_device.hpp @@ -1,85 +1,84 @@ -#ifndef BOOST_TIMER_DEVICES_CLOCK_HPP -#define BOOST_TIMER_DEVICES_CLOCK_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 - -// -------------------------- std::clock() -------------------------- - -// Properties: -// - ??? ns resolution. -// - ??? ns overhead. -// - Is implemented with GetSystemTimeAsFileTime on windows. -// -// Pros: -// - Portable. -// -// Cons: -// - High resolution. - - -// -------------------------- Includes -------------------------- - -// Standard headers -#include - -// Boost headers -#include - - -// -------------------------- Code -------------------------- - -namespace boost -{ - -//! The clock_device class is based on std::clock() to compute the time -class clock_device -{ - - public: - - typedef posix_time::ptime time_type; - typedef time_type::time_duration_type time_duration_type; - - explicit clock_device() : m_start(0), m_elapsed(0, 0, 0) - { - } - - void start() - { - if(!m_start) - m_start = std::clock(); - } - - const time_duration_type& elapsed() const - { - if(m_start) - { - std::clock_t current = std::clock(); - m_elapsed += posix_time::milliseconds(static_cast(current-m_start) / CLOCKS_PER_SEC * 1000.0); - m_start = current; - } - return m_elapsed; - } - - void reset() - { - m_elapsed = time_duration_type(0,0,0); - m_start = 0; - } - - - private: - - mutable std::clock_t m_start; - mutable time_duration_type m_elapsed; - -}; - -} // namespace boost - -#endif // BOOST_TIMER_DEVICES_CLOCK_HPP + #ifndef _BOOST_TIMERS_PORTABLE_CLOCK_DEVICE_HPP +#define _BOOST_TIMERS_PORTABLE_CLOCK_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 + +// Boost headers +#include + + +// -------------------------- Code -------------------------- + +namespace boost +{ +namespace timers +{ +namespace portable +{ + +//! The clock_device class is based on std::clock() to compute the time +class clock_device +{ + + public: + + typedef posix_time::ptime time_type; + typedef time_type::time_duration_type time_duration_type; + + explicit clock_device() : m_running(false), m_start(0), m_elapsed(0, 0, 0) + { + } + + void start() + { + if(!m_running) + { + m_start = std::clock(); + m_running = true; + } + } + + const time_duration_type& elapsed() const + { + if(m_running) + { + std::clock_t current = std::clock(); + double seconds = (current - m_start) / static_cast(CLOCKS_PER_SEC); + m_elapsed += posix_time::milliseconds(static_cast(seconds * 1000.0)); + m_start = current; + } + return m_elapsed; + } + + void reset() + { + m_elapsed = time_duration_type(0,0,0); + m_start = 0; + m_running = false; + } + + + private: + + bool m_running; + mutable std::clock_t m_start; + mutable time_duration_type m_elapsed; + +}; + +} // namespace portable +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_PORTABLE_CLOCK_DEVICE_HPP diff --git a/src/core/boost/timer/devices/date_time.hpp b/src/core/boost/timers/portable/date_time_devices.hpp similarity index 76% rename from src/core/boost/timer/devices/date_time.hpp rename to src/core/boost/timers/portable/date_time_devices.hpp index c311263b..e1e42cc4 100644 --- a/src/core/boost/timer/devices/date_time.hpp +++ b/src/core/boost/timers/portable/date_time_devices.hpp @@ -1,84 +1,80 @@ -#ifndef BOOST_TIMER_DEVICES_DATE_TIME_HPP -#define BOOST_TIMER_DEVICES_DATE_TIME_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 - - -// -------------------------- date_time devices -------------------------- - -// Properties: -// - windows: uses GetSystemTimeAsFileTime() -// - POSIX: uses gettimeofday() -// -// Pros: -// - Portable. - - -// -------------------------- Includes -------------------------- - -#include - - -// -------------------------- Code -------------------------- - -namespace boost -{ - -//! The date_time device -template -class date_time_device -{ - - public: - - typedef Clock clock_type; - typedef Time time_type; - typedef typename clock_type::time_duration_type time_duration_type; - - explicit date_time_device() : m_start(date_time::not_a_date_time), m_elapsed(0, 0, 0) - { - } - - void start() - { - if(m_start.is_not_a_date_time()) - m_start = clock_type::local_time(); - } - - const time_duration_type& elapsed() const - { - if(!m_start.is_not_a_date_time()) - { - time_type current(clock_type::local_time()); - m_elapsed += (current - m_start); - m_start = current; - } - return m_elapsed; - } - - void reset() - { - m_start = date_time::not_a_date_time; - m_elapsed = time_duration_type(0,0,0); - } - - - private: - - mutable time_type m_start; - mutable time_duration_type m_elapsed; - -}; - -// Convenience typedefs -typedef date_time_device microsec_device; -typedef date_time_device second_device; - -} // namespace boost - -#endif // BOOST_TIMER_DEVICES_DATE_TIME_HPP +#ifndef _BOOST_TIMERS_PORTABLE_DATE_TIME_DEVICES_HPP +#define _BOOST_TIMERS_PORTABLE_DATE_TIME_DEVICES_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 + + +// -------------------------- Code -------------------------- + +namespace boost +{ +namespace timers +{ +namespace portable +{ + +//! The date_time device +template +class date_time_device +{ + + public: + + typedef Clock clock_type; + typedef Time time_type; + typedef typename clock_type::time_duration_type time_duration_type; + + explicit date_time_device() : m_start(date_time::not_a_date_time), m_elapsed(0, 0, 0) + { + } + + void start() + { + if(m_start.is_not_a_date_time()) + m_start = clock_type::local_time(); + } + + const time_duration_type& elapsed() const + { + if(!m_start.is_not_a_date_time()) + { + time_type current(clock_type::local_time()); + m_elapsed += (current - m_start); + m_start = current; + } + return m_elapsed; + } + + void reset() + { + m_start = date_time::not_a_date_time; + m_elapsed = time_duration_type(0,0,0); + } + + + private: + + mutable time_type m_start; + mutable time_duration_type m_elapsed; + +}; + +// Convenience typedefs +typedef date_time_device microsec_device; +typedef date_time_device second_device; + +} // namespace portable +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_PORTABLE_DATE_TIME_DEVICES_HPP diff --git a/src/core/boost/timers/portable/time_device.hpp b/src/core/boost/timers/portable/time_device.hpp new file mode 100644 index 00000000..195d0756 --- /dev/null +++ b/src/core/boost/timers/portable/time_device.hpp @@ -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 + + +// -------------------------- 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(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 diff --git a/src/core/boost/timers/posix.hpp b/src/core/boost/timers/posix.hpp new file mode 100644 index 00000000..e33834e0 --- /dev/null +++ b/src/core/boost/timers/posix.hpp @@ -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_timer; + + // getcputime() device + typedef timer gru_timer; + + // gettimeofday() device + typedef timer gtod_timer; + + // Typedef which timer is the best + typedef gtod_timer best_timer; + +} // namespace posix +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_POSIX_HPP diff --git a/src/core/boost/timers/posix/ftime_device.hpp b/src/core/boost/timers/posix/ftime_device.hpp new file mode 100644 index 00000000..c6a620ae --- /dev/null +++ b/src/core/boost/timers/posix/ftime_device.hpp @@ -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 + +// Linux headers +#include + +// -------------------------- 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(¤t); + 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 diff --git a/src/core/boost/timers/posix/gru_device.hpp b/src/core/boost/timers/posix/gru_device.hpp new file mode 100644 index 00000000..f1faceab --- /dev/null +++ b/src/core/boost/timers/posix/gru_device.hpp @@ -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 + +// Linux headers +#include +#include + + +// -------------------------- 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, ¤t); + 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 diff --git a/src/core/boost/timer/devices/gettimeofday.hpp b/src/core/boost/timers/posix/gtod_device.hpp similarity index 60% rename from src/core/boost/timer/devices/gettimeofday.hpp rename to src/core/boost/timers/posix/gtod_device.hpp index ae57959e..df9a8d7d 100644 --- a/src/core/boost/timer/devices/gettimeofday.hpp +++ b/src/core/boost/timers/posix/gtod_device.hpp @@ -1,98 +1,86 @@ -#ifndef BOOST_TIMER_DEVICES_GTOD_HPP -#define BOOST_TIMER_DEVICES_GTOD_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 - -// -------------------------- gettimeofday() -------------------------- - -// Properties: -// - ??? ns resolution. -// - ??? ns overhead. -// -// Pros: -// - Low overhead. -// - High resolution. - - -// -------------------------- Includes -------------------------- - -// Get config -#include - -// Check we have gettimeofday() -#ifndef BOOST_HAS_GETTIMEOFDAY - #error "gettimeofday() can only be used on POSIX systems" -#else - -// Boost headers -#include - -// Linux headers -#include - -// -------------------------- Code -------------------------- - -namespace boost -{ - -//! The gtod_device class is based on gettimeofday() to compute the time -class gtod_device -{ - - public: - - typedef posix_time::ptime time_type; - typedef time_type::time_duration_type time_duration_type; - - explicit gtod_device() : m_elapsed(0, 0, 0) - { - std::memset(&m_start, 0, sizeof(timeval)); - } - - void start() - { - if(!is_time(m_start)) - gettimeofday(&m_start, 0); - } - - const time_duration_type& elapsed() const - { - if(is_time(m_start)) - { - timeval current; - gettimeofday(¤t, 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; - } - 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 timeval& value) const - { - return value.tv_sec || value.tv_usec; - } - - mutable timeval m_start; - mutable time_duration_type m_elapsed; - -}; - -} // namespace boost - -#endif // BOOST_HAS_GETTIMEOFDAY - -#endif // BOOST_TIMER_DEVICES_GTOD_HPP +#ifndef _BOOST_TIMERS_POSIX_GTOD_DEVICE_HPP +#define _BOOST_TIMERS_POSIX_GTOD_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 + +// Linux headers +#include + +// -------------------------- Code -------------------------- + +namespace boost +{ +namespace timers +{ +namespace posix +{ + +//! The gtod_device class is based on gettimeofday() to compute the time +class gtod_device +{ + + public: + + typedef posix_time::ptime time_type; + typedef time_type::time_duration_type time_duration_type; + + explicit gtod_device() : m_elapsed(0, 0, 0) + { + std::memset(&m_start, 0, sizeof(timeval)); + } + + void start() + { + if(!is_time(m_start)) + gettimeofday(&m_start, 0); + } + + const time_duration_type& elapsed() const + { + if(is_time(m_start)) + { + timeval current; + gettimeofday(¤t, 0); + int64_t seconds = current.tv_sec - m_start.tv_sec; + int64_t microseconds = current.tv_usec - m_start.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 timeval& value) const + { + return value.tv_sec || value.tv_usec; + } + + mutable timeval m_start; + mutable time_duration_type m_elapsed; + +}; + +} // namespace posix +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_POSIX_GTOD_DEVICE_HPP diff --git a/src/core/boost/timers/timer.hpp b/src/core/boost/timers/timer.hpp new file mode 100644 index 00000000..d8bf31ab --- /dev/null +++ b/src/core/boost/timers/timer.hpp @@ -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 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 diff --git a/src/core/boost/timers/win32.hpp b/src/core/boost/timers/win32.hpp new file mode 100644 index 00000000..38a33e71 --- /dev/null +++ b/src/core/boost/timers/win32.hpp @@ -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_timer; + + // GetThreadTimes() device + typedef timer gtt_timer; + + // GetTickCount() device + typedef timer gtc_timer; + + // GetSystemTimeAsFileTime() device + typedef timer gstaft_timer; + + // QueryPerformanceCounter() device + typedef timer qpc_timer; + + // timeGetTime() device + typedef timer tgt_timer; + + // Typedef which timer is the best + typedef qpc_timer best_timer; + +} // namespace win32 +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_WIN32_HPP diff --git a/src/core/boost/timers/win32/gpt_device.hpp b/src/core/boost/timers/win32/gpt_device.hpp new file mode 100644 index 00000000..e4992771 --- /dev/null +++ b/src/core/boost/timers/win32/gpt_device.hpp @@ -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 + +// Boost headers +#include +#include + +// Windows headers +#define WIN32_LEAN_AND_MEAN +#include + + +// -------------------------- 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(&m_start.first), reinterpret_cast(&m_start.second)); + } + } + + const time_duration_type& elapsed() const + { + if(is_time(m_start)) + { + std::pair current; + FILETIME tmp1, tmp2; + GetProcessTimes(GetCurrentProcess(), &tmp1, &tmp2, reinterpret_cast(¤t.first), reinterpret_cast(¤t.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(diff / 10.0); + m_elapsed += posix_time::milliseconds(static_cast(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& time) const + { + return (time.first != 0 || time.second != 0); + } + + mutable std::pair m_start; + mutable time_duration_type m_elapsed; + +}; + +} // namespace win32 +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP diff --git a/src/core/boost/timer/devices/GetSystemTimeAsFileTime.hpp b/src/core/boost/timers/win32/gstaft_device.hpp similarity index 65% rename from src/core/boost/timer/devices/GetSystemTimeAsFileTime.hpp rename to src/core/boost/timers/win32/gstaft_device.hpp index f995d65f..542ca41e 100644 --- a/src/core/boost/timer/devices/GetSystemTimeAsFileTime.hpp +++ b/src/core/boost/timers/win32/gstaft_device.hpp @@ -1,96 +1,86 @@ -#ifndef BOOST_TIMER_DEVICES_GSTAFT_HPP -#define BOOST_TIMER_DEVICES_GSTAFT_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 - - -// -------------------------- GetSystemTimeAsFileTime() -------------------------- - -// Properties: -// - ??? ns resolution. -// - ??? ns overhead (6 clocks (64-bit load/store + synchronization (4))). -// -// Pros: -// - Low overhead. -// -// Cons: -// - Low resolution. - - -// -------------------------- Includes -------------------------- - -#ifndef BOOST_WINDOWS - #error "GetSystemTimeAsFileTime() can only be used on windows" -#else - -// Boost headers -#include -#include - -// Windows headers -#define WIN32_LEAN_AND_MEAN -#include - - -// -------------------------- Code -------------------------- - -namespace boost -{ - -//! The gstaft_device class is based on GetSystemTimeAsFileTime() to compute the time -class gstaft_device -{ - - public: - - typedef posix_time::ptime time_type; - typedef time_type::time_duration_type time_duration_type; - - explicit gstaft_device() : m_elapsed(0, 0, 0) - { - std::memset(&m_start, 0, sizeof(ULARGE_INTEGER)); - } - - void start() - { - if(!m_start.QuadPart) - GetSystemTimeAsFileTime(reinterpret_cast(&m_start)); - } - - const time_duration_type& elapsed() const - { - if(m_start.QuadPart) - { - ULARGE_INTEGER current; - GetSystemTimeAsFileTime(reinterpret_cast(¤t)); - uint64_t tmp = current.QuadPart - m_start.QuadPart; - m_elapsed += posix_time::milliseconds(tmp / 10000.0); - m_start = current; - } - return m_elapsed; - } - - void reset() - { - m_elapsed = time_duration_type(0,0,0); - std::memset(&m_start, 0, sizeof(ULARGE_INTEGER)); - } - - - private: - - mutable ULARGE_INTEGER m_start; - mutable time_duration_type m_elapsed; - -}; - -} // namespace boost - -#endif // BOOST_WINDOWS - -#endif // BOOST_TIMER_DEVICES_GSTAFT_HPP +#ifndef _BOOST_TIMERS_WIN32_GSTAFT_DEVICE_HPP +#define _BOOST_TIMERS_WIN32_GSTAFT_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 +#include + +// Windows headers +#define WIN32_LEAN_AND_MEAN +#include + + +// -------------------------- Code -------------------------- + +namespace boost +{ +namespace timers +{ +namespace win32 +{ + +//! The gstaft_device class is based on GetSystemTimeAsFileTime() to compute the time +class gstaft_device +{ + + public: + + typedef posix_time::ptime time_type; + typedef time_type::time_duration_type time_duration_type; + + explicit gstaft_device() : m_elapsed(0, 0, 0) + { + std::memset(&m_start, 0, sizeof(ULARGE_INTEGER)); + } + + void start() + { + if(!m_start.QuadPart) + GetSystemTimeAsFileTime(reinterpret_cast(&m_start)); + } + + const time_duration_type& elapsed() const + { + if(m_start.QuadPart) + { + ULARGE_INTEGER current; + GetSystemTimeAsFileTime(reinterpret_cast(¤t)); + // diff is measured in 100ns intervals... + uint64_t diff = current.QuadPart - m_start.QuadPart; + // ... so we must divide by 10 to get nanoseconds + uint64_t nanoseconds = static_cast(diff / 10.0); + m_elapsed += posix_time::milliseconds(static_cast(nanoseconds / 1000.0)); + m_start = current; + } + return m_elapsed; + } + + void reset() + { + m_elapsed = time_duration_type(0,0,0); + std::memset(&m_start, 0, sizeof(ULARGE_INTEGER)); + } + + + private: + + mutable ULARGE_INTEGER m_start; + mutable time_duration_type m_elapsed; + +}; + +} // namespace win32 +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_WIN32_GSTAFT_DEVICE_HPP diff --git a/src/core/boost/timer/devices/GetTickCount.hpp b/src/core/boost/timers/win32/gtc_device.hpp similarity index 64% rename from src/core/boost/timer/devices/GetTickCount.hpp rename to src/core/boost/timers/win32/gtc_device.hpp index 28739fd5..f7c60f36 100644 --- a/src/core/boost/timer/devices/GetTickCount.hpp +++ b/src/core/boost/timers/win32/gtc_device.hpp @@ -1,92 +1,81 @@ -#ifndef BOOST_TIMER_DEVICES_GTC_HPP -#define BOOST_TIMER_DEVICES_GTC_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 - -// -------------------------- GetTickCount() -------------------------- - -// Properties: -// - 5 to 55 ms resolution. -// - ??? ns overhead (8 clock (load, mul, shift)). -// -// Pros: -// - Very low overhead. -// -// Cons: -// - Very low resolution. - - -// -------------------------- Includes -------------------------- - -#ifndef BOOST_WINDOWS - #error "GetTickCount() can only be used on windows" -#else - -// Boost headers -#include -#include - -// Windows headers -#define WIN32_LEAN_AND_MEAN -#include - - -// -------------------------- Code -------------------------- - -namespace boost -{ - -//! The gtc_device class is based on GetTickCount() to compute the time -class gtc_device -{ - - public: - - typedef posix_time::ptime time_type; - typedef time_type::time_duration_type time_duration_type; - - explicit gtc_device() : m_start(0), m_elapsed(0, 0, 0) - { - } - - void start() - { - if(!m_start) - m_start = GetTickCount(); - } - - const time_duration_type& elapsed() const - { - if(m_start) - { - uint32_t current = GetTickCount(); - m_elapsed += posix_time::milliseconds(current - m_start); - m_start = current; - } - return m_elapsed; - } - - void reset() - { - m_elapsed = time_duration_type(0,0,0); - m_start = 0; - } - - - private: - - mutable uint32_t m_start; - mutable time_duration_type m_elapsed; - -}; - -} // namespace boost - -#endif // BOOST_WINDOWS - -#endif // BOOST_TIMER_DEVICES_GTC_HPP +#ifndef _BOOST_TIMERS_WIN32_GTC_DEVICE_HPP +#define _BOOST_TIMERS_WIN32_GTC_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 +#include + +// Windows headers +#define WIN32_LEAN_AND_MEAN +#include + + +// -------------------------- Code -------------------------- + +namespace boost +{ +namespace timers +{ +namespace win32 +{ + +//! The gtc_device class is based on GetTickCount() to compute the time +class gtc_device +{ + + public: + + typedef posix_time::ptime time_type; + typedef time_type::time_duration_type time_duration_type; + + explicit gtc_device() : m_start(0), m_elapsed(0, 0, 0) + { + } + + void start() + { + if(!m_start) + m_start = GetTickCount(); + } + + const time_duration_type& elapsed() const + { + if(m_start) + { + uint32_t current = GetTickCount(); + uint64_t milliseconds = current - m_start; + m_elapsed += posix_time::milliseconds(milliseconds); + m_start = current; + } + return m_elapsed; + } + + void reset() + { + m_elapsed = time_duration_type(0,0,0); + m_start = 0; + } + + + private: + + mutable uint32_t m_start; + mutable time_duration_type m_elapsed; + +}; + +} // namespace win32 +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_WIN32_GTC_DEVICE_HPP diff --git a/src/core/boost/timers/win32/gtt_device.hpp b/src/core/boost/timers/win32/gtt_device.hpp new file mode 100644 index 00000000..d4d4c103 --- /dev/null +++ b/src/core/boost/timers/win32/gtt_device.hpp @@ -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 + +// Boost headers +#include +#include + +// Windows headers +#define WIN32_LEAN_AND_MEAN +#include + + +// -------------------------- 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(&m_start.first), reinterpret_cast(&m_start.second)); + } + } + + const time_duration_type& elapsed() const + { + if(is_time(m_start)) + { + std::pair current; + FILETIME tmp1, tmp2; + GetThreadTimes(GetCurrentThread(), &tmp1, &tmp2, reinterpret_cast(¤t.first), reinterpret_cast(¤t.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(diff / 10.0); + m_elapsed += posix_time::milliseconds(static_cast(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& time) const + { + return (time.first != 0 || time.second != 0); + } + + mutable std::pair m_start; + mutable time_duration_type m_elapsed; + +}; + +} // namespace win32 +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP diff --git a/src/core/boost/timer/devices/QueryPerformanceCounter.hpp b/src/core/boost/timers/win32/qpc_device.hpp similarity index 63% rename from src/core/boost/timer/devices/QueryPerformanceCounter.hpp rename to src/core/boost/timers/win32/qpc_device.hpp index bf95aef3..59a73bfa 100644 --- a/src/core/boost/timer/devices/QueryPerformanceCounter.hpp +++ b/src/core/boost/timers/win32/qpc_device.hpp @@ -1,130 +1,104 @@ -#ifndef BOOST_TIMER_DEVICES_QPC_HPP -#define BOOST_TIMER_DEVICES_QPC_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 - - -// -------------------------- QueryPerformanceCounter() -------------------------- - -// Properties: -// Win2k (PIT): -// - 838 ns resolution. -// - ~3000 ns overhead. -// WinXP (PMT): -// - 279 ns resolution. -// - 700 ns overhead. -// -// Pros: -// - High resolution (usually the best one). -// -// Cons: -// - High overhead. -// - Not thread safe. -// - Multi core problems. To solve the issue you can #define BOOST_QPC_SET_AFFINITY which will call SetThreadAffinityMask() for you. -// -// Issues: -// 1) Q274323: may jump several seconds under heavy PCI bus load. -// not a problem, because the older systems on which this occurs -// 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? - - -// -------------------------- Includes -------------------------- - -#ifndef BOOST_WINDOWS - #error "QueryPerformanceCounter() can only be used on windows" -#else - -// Boost headers -#include -#include - -// Windows headers -#define WIN32_LEAN_AND_MEAN -#include - - -// -------------------------- Code -------------------------- - -namespace boost -{ - -class qpc_device -{ - - public: - - typedef posix_time::ptime time_type; - typedef time_type::time_duration_type time_duration_type; - - explicit qpc_device() : m_elapsed(0, 0, 0) - { - #ifdef BOOST_QPC_SET_AFFINITY - m_affinity = SetThreadAffinityMask(GetCurrentThread(), 1); - #endif - - m_start.QuadPart = 0; - if(!QueryPerformanceFrequency(&m_frequency)) - throw_exception(std::runtime_error("qpc_device: QueryPerformanceFrequency() indicated there's no high-resolution performance counter")); - - // Make it so we have the future results directly in milliseconds - m_frequency.QuadPart /= 1000; - } - - ~qpc_device() - { - #ifdef BOOST_QPC_SET_AFFINITY - SetThreadAffinityMask(GetCurrentThread(), m_affinity); - #endif - } - - void start() - { - if(!m_start.QuadPart && !QueryPerformanceCounter(&m_start)) - throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed")); - } - - const time_duration_type& elapsed() const - { - if(m_start.QuadPart) - { - LARGE_INTEGER current; - if(!QueryPerformanceCounter(¤t)) - throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed")); - uint64_t milliseconds = (current.QuadPart - m_start.QuadPart) / m_frequency.QuadPart; - m_elapsed += posix_time::milliseconds(milliseconds); - m_start = current; - } - return m_elapsed; - } - - 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 +#ifndef _BOOST_TIMERS_WIN32_QPC_DEVICE_HPP +#define _BOOST_TIMERS_WIN32_QPC_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 +#include + +// Windows headers +#define WIN32_LEAN_AND_MEAN +#include + + +// -------------------------- Code -------------------------- + +namespace boost +{ +namespace timers +{ +namespace win32 +{ + +class qpc_device +{ + + public: + + typedef posix_time::ptime time_type; + typedef time_type::time_duration_type time_duration_type; + + explicit qpc_device() : m_elapsed(0, 0, 0) + { + #ifdef BOOST_QPC_SET_AFFINITY + m_affinity = SetThreadAffinityMask(GetCurrentThread(), 1); + #endif + + m_start.QuadPart = 0; + if(!QueryPerformanceFrequency(&m_frequency)) + throw_exception(std::runtime_error("qpc_device: QueryPerformanceFrequency() indicated there's no high-resolution performance counter")); + + // Make it so we have the future results directly in milliseconds + m_frequency.QuadPart /= 1000; + } + + ~qpc_device() + { + #ifdef BOOST_QPC_SET_AFFINITY + SetThreadAffinityMask(GetCurrentThread(), m_affinity); + #endif + } + + void start() + { + if(!m_start.QuadPart && !QueryPerformanceCounter(&m_start)) + throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed")); + } + + const time_duration_type& elapsed() const + { + if(m_start.QuadPart) + { + LARGE_INTEGER current; + if(!QueryPerformanceCounter(¤t)) + throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed")); + int64_t milliseconds = (current.QuadPart - m_start.QuadPart) / m_frequency.QuadPart; + m_elapsed += posix_time::milliseconds(milliseconds); + m_start = current; + } + return m_elapsed; + } + + 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 win32 +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_WIN32_QUERYPERFORMANCECOUNTER_HPP diff --git a/src/core/boost/timer/devices/timeGetTime.hpp b/src/core/boost/timers/win32/tgt_device.hpp similarity index 64% rename from src/core/boost/timer/devices/timeGetTime.hpp rename to src/core/boost/timers/win32/tgt_device.hpp index a7c9f517..9e70135c 100644 --- a/src/core/boost/timer/devices/timeGetTime.hpp +++ b/src/core/boost/timers/win32/tgt_device.hpp @@ -1,94 +1,95 @@ -#ifndef BOOST_TIMER_DEVICES_TGT_HPP -#define BOOST_TIMER_DEVICES_TGT_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 - -// -------------------------- std::clock() -------------------------- - -// Properties: -// - 1 ms resolution. -// - ??? ns overhead. -// -// Pros: -// - Low overhead. -// -// Cons: -// - Low resolution. - -// -------------------------- Includes -------------------------- - -#ifndef BOOST_WINDOWS - #error "timeGetTime() can only be used on windows" -#else - -// Boost headers -#include -#include - -// Windows headers -#define WIN32_LEAN_AND_MEAN -#include - -// Automagically link winmm.lib if we can -#pragma comment(lib, "winmm.lib") - - -// -------------------------- Code -------------------------- - -namespace boost -{ - -//! The tgt_device class is based on timeGetTime() to compute the time -class tgt_device -{ - - public: - - typedef posix_time::ptime time_type; - typedef time_type::time_duration_type time_duration_type; - - explicit tgt_device() : m_start(0), m_elapsed(0, 0, 0) - { - } - - void start() - { - if(!m_start) - m_start = timeGetTime(); - } - - const time_duration_type& elapsed() const - { - if(m_start) - { - uint32_t current = timeGetTime(); - m_elapsed += posix_time::milliseconds(current - m_start); - m_start = current; - } - return m_elapsed; - } - - void reset() - { - m_elapsed = time_duration_type(0,0,0); - m_start = 0; - } - - - private: - - mutable uint32_t m_start; - mutable time_duration_type m_elapsed; - -}; - -} // namespace boost - -#endif // BOOST_WINDOWS - -#endif // BOOST_TIMER_DEVICES_TGT_HPP +#ifndef _BOOST_TIMERS_WIN32_TGT_DEVICE_HPP +#define _BOOST_TIMERS_WIN32_TGT_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 +#include + +// Windows headers +#define WIN32_LEAN_AND_MEAN +#include + +// Automagically link winmm.lib if we can +#if (defined _MSC_VER) && (_MSC_VER >= 1200) +#pragma comment(lib, "winmm.lib") +#endif + +// -------------------------- Code -------------------------- + +namespace boost +{ +namespace timers +{ +namespace win32 +{ + +//! The tgt_device class is based on timeGetTime() to compute the time +class tgt_device +{ + + public: + + typedef posix_time::ptime time_type; + typedef time_type::time_duration_type time_duration_type; + + explicit tgt_device() : m_start(0), m_elapsed(0, 0, 0) + { + #ifndef BOOST_TGT_DEFAULT_RES + timeBeginPeriod(1); + #endif + } + + ~tgt_device() + { + #ifndef BOOST_TGT_DEFAULT_RES + timeEndPeriod(1); + #endif + } + + void start() + { + if(!m_start) + m_start = timeGetTime(); + } + + const time_duration_type& elapsed() const + { + if(m_start) + { + uint32_t current = timeGetTime(); + int64_t milliseconds = current - m_start; + m_elapsed += posix_time::milliseconds(milliseconds); + m_start = current; + } + return m_elapsed; + } + + void reset() + { + m_elapsed = time_duration_type(0,0,0); + m_start = 0; + } + + + private: + + mutable uint32_t m_start; + mutable time_duration_type m_elapsed; + +}; + +} // namespace win32 +} // namespace timers +} // namespace boost + +#endif // _BOOST_TIMERS_WIN32_TGT_DEVICE_HPP diff --git a/src/gui/qt/mainwindow/mysetlabel.h b/src/gui/qt/mainwindow/mysetlabel.h index c6cd8d43..677f87f3 100644 --- a/src/gui/qt/mainwindow/mysetlabel.h +++ b/src/gui/qt/mainwindow/mysetlabel.h @@ -16,7 +16,7 @@ #include #include -#include +#include #include "sdlplayer.h" class mainWindowImpl; @@ -51,7 +51,7 @@ private: // boost::shared_ptr mySDLPlayer; - boost::microsec_timer realTimer; + boost::timers::portable::microsec_timer realTimer; bool timeOutAnimation; diff --git a/src/net/clientstate.h b/src/net/clientstate.h index 2017984f..db2fc276 100644 --- a/src/net/clientstate.h +++ b/src/net/clientstate.h @@ -24,7 +24,7 @@ #include // needed for correct order of header files. #include #include -#include +#include #define CLIENT_INITIAL_STATE ClientStateInit @@ -114,8 +114,6 @@ public: virtual ~ClientStateStartConnect(); - void SetTimer(boost::microsec_timer timer); - // Call connect. virtual int Process(ClientThread &client); @@ -134,7 +132,7 @@ public: 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. virtual int Process(ClientThread &client); @@ -146,7 +144,7 @@ protected: private: - boost::microsec_timer m_connectTimer; + boost::timers::portable::microsec_timer m_connectTimer; }; // State: Session init. diff --git a/src/net/common/clientstate.cpp b/src/net/common/clientstate.cpp index 588bf268..4b8a6fec 100644 --- a/src/net/common/clientstate.cpp +++ b/src/net/common/clientstate.cpp @@ -247,7 +247,7 @@ ClientStateStartConnect::Process(ClientThread &client) int errCode = SOCKET_ERRNO(); if (errCode == SOCKET_ERR_WOULDBLOCK) { - boost::microsec_timer connectTimer; + boost::timers::portable::microsec_timer connectTimer; connectTimer.start(); ClientStateConnecting::Instance().SetTimer(connectTimer); client.SetState(ClientStateConnecting::Instance()); @@ -278,7 +278,7 @@ ClientStateConnecting::~ClientStateConnecting() } void -ClientStateConnecting::SetTimer(const boost::microsec_timer &timer) +ClientStateConnecting::SetTimer(const boost::timers::portable::microsec_timer &timer) { m_connectTimer = timer; } diff --git a/src/net/common/serverlobbythread.cpp b/src/net/common/serverlobbythread.cpp index 70ab6f54..6e5f194f 100644 --- a/src/net/common/serverlobbythread.cpp +++ b/src/net/common/serverlobbythread.cpp @@ -85,7 +85,7 @@ ServerLobbyThread::CloseSessionDelayed(SessionWrapper session) { m_sessionManager.RemoveSession(session.sessionData->GetSocket()); - boost::microsec_timer closeTimer; + boost::timers::portable::microsec_timer closeTimer; closeTimer.start(); CloseSessionList::value_type closeSessionData(closeTimer, session.sessionData); diff --git a/src/net/servergamestate.h b/src/net/servergamestate.h index c3be8edc..f66a55a4 100644 --- a/src/net/servergamestate.h +++ b/src/net/servergamestate.h @@ -23,7 +23,7 @@ #include #include -#include +#include #ifdef _MSC_VER @@ -78,14 +78,14 @@ public: virtual void Init(); - const boost::microsec_timer &GetTimer() const {return m_timer;} + const boost::timers::portable::microsec_timer &GetTimer() const {return m_timer;} protected: AbstractServerGameStateTimer(); private: - boost::microsec_timer m_timer; + boost::timers::portable::microsec_timer m_timer; }; // Abstract State: Game is running. diff --git a/src/net/serverlobbythread.h b/src/net/serverlobbythread.h index 073cd9e3..4374e8de 100644 --- a/src/net/serverlobbythread.h +++ b/src/net/serverlobbythread.h @@ -29,7 +29,7 @@ #include #include -#include +#include #define LOBBY_THREAD_TERMINATE_TIMEOUT 200 @@ -65,7 +65,7 @@ protected: typedef std::deque > ConnectQueue; typedef std::list SessionList; - typedef std::list > > CloseSessionList; + typedef std::list > > CloseSessionList; typedef std::map > GameMap; typedef std::list RemoveGameList;