BVB Source Codes

mars Show system_clocks.hpp Source code

Return Download mars: download system_clocks.hpp Source code - Download mars Source code - Type:.hpp
  1. //  boost/chrono/system_clocks.hpp  --------------------------------------------------------------//
  2.  
  3. //  Copyright 2008 Howard Hinnant
  4. //  Copyright 2008 Beman Dawes
  5. //  Copyright 2009-2011 Vicente J. Botet Escriba
  6.  
  7. //  Distributed under the Boost Software License, Version 1.0.
  8. //  See http://www.boost.org/LICENSE_1_0.txt
  9.  
  10. /*
  11.  
  12. This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
  13. Many thanks to Howard for making his code available under the Boost license.
  14. The original code was modified to conform to Boost conventions and to section
  15. 20.9 Time utilities [time] of the C++ committee's working paper N2798.
  16. See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
  17.  
  18. time2_demo contained this comment:
  19.  
  20.     Much thanks to Andrei Alexandrescu,
  21.                    Walter Brown,
  22.                    Peter Dimov,
  23.                    Jeff Garland,
  24.                    Terry Golubiewski,
  25.                    Daniel Krugler,
  26.                    Anthony Williams.
  27. */
  28.  
  29. /*
  30.  
  31. TODO:
  32.  
  33.   * Fully implement error handling, with test cases.
  34.   * Consider issues raised by Michael Marcin:
  35.  
  36.     > In the past I've seen QueryPerformanceCounter give incorrect results,
  37.     > especially with SpeedStep processors on laptops. This was many years ago and
  38.     > might have been fixed by service packs and drivers.
  39.     >
  40.     > Typically you check the results of QPC against GetTickCount to see if the
  41.     > results are reasonable.
  42.     > http://support.microsoft.com/kb/274323
  43.     >
  44.     > I've also heard of problems with QueryPerformanceCounter in multi-processor
  45.     > systems.
  46.     >
  47.     > I know some people SetThreadAffinityMask to 1 for the current thread call
  48.     > their QueryPerformance* functions then restore SetThreadAffinityMask. This
  49.     > seems horrible to me because it forces your program to jump to another
  50.     > physical processor if it isn't already on cpu0 but they claim it worked well
  51.     > in practice because they called the timing functions infrequently.
  52.     >
  53.     > In the past I have chosen to use timeGetTime with timeBeginPeriod(1) for
  54.     > high resolution timers to avoid these issues.
  55.  
  56. */
  57.  
  58. #ifndef BOOST_CHRONO_SYSTEM_CLOCKS_HPP
  59. #define BOOST_CHRONO_SYSTEM_CLOCKS_HPP
  60.  
  61. #include <boost/chrono/config.hpp>
  62. #include <boost/chrono/duration.hpp>
  63. #include <boost/chrono/time_point.hpp>
  64. #include <boost/chrono/detail/system.hpp>
  65. #include <boost/chrono/clock_string.hpp>
  66.  
  67. #include <ctime>
  68.  
  69. # if defined( BOOST_CHRONO_POSIX_API )
  70. #   if ! defined(CLOCK_REALTIME) && ! defined (__hpux__)
  71. #     error <time.h> does not supply CLOCK_REALTIME
  72. #   endif
  73. # endif
  74.  
  75. #ifdef BOOST_CHRONO_WINDOWS_API
  76. // The system_clock tick is 100 nanoseconds
  77. # define BOOST_SYSTEM_CLOCK_DURATION mars_boost::chrono::duration<mars_boost::int_least64_t, ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(10000000)> >
  78. #else
  79. # define BOOST_SYSTEM_CLOCK_DURATION mars_boost::chrono::nanoseconds
  80. #endif
  81.  
  82. // this must occur after all of the includes and before any code appears:
  83. #ifndef BOOST_CHRONO_HEADER_ONLY
  84. #include <boost/config/abi_prefix.hpp> // must be the last #include
  85. #endif
  86.  
  87.  
  88. //----------------------------------------------------------------------------//
  89. //                                                                            //
  90. //                        20.9 Time utilities [time]                          //
  91. //                                 synopsis                                   //
  92. //                                                                            //
  93. //----------------------------------------------------------------------------//
  94.  
  95. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  96. namespace chrono {
  97.  
  98.   // Clocks
  99.   class BOOST_CHRONO_DECL system_clock;
  100. #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
  101.   class BOOST_CHRONO_DECL steady_clock;
  102. #endif
  103.  
  104. #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
  105.   typedef steady_clock high_resolution_clock;  // as permitted by [time.clock.hires]
  106. #else
  107.   typedef system_clock high_resolution_clock;  // as permitted by [time.clock.hires]
  108. #endif
  109.  
  110. //----------------------------------------------------------------------------//
  111. //                                                                            //
  112. //      20.9.5 Clocks [time.clock]                                            //
  113. //                                                                            //
  114. //----------------------------------------------------------------------------//
  115.  
  116. // If you're porting, clocks are the system-specific (non-portable) part.
  117. // You'll need to know how to get the current time and implement that under now().
  118. // You'll need to know what units (tick period) and representation makes the most
  119. // sense for your clock and set those accordingly.
  120. // If you know how to map this clock to time_t (perhaps your clock is std::time, which
  121. // makes that trivial), then you can fill out system_clock's to_time_t() and from_time_t().
  122.  
  123. //----------------------------------------------------------------------------//
  124. //      20.9.5.1 Class system_clock [time.clock.system]                       //
  125. //----------------------------------------------------------------------------//
  126.  
  127.   class BOOST_CHRONO_DECL system_clock
  128.   {
  129.   public:
  130.       typedef BOOST_SYSTEM_CLOCK_DURATION          duration;
  131.       typedef duration::rep                        rep;
  132.       typedef duration::period                     period;
  133.       typedef chrono::time_point<system_clock>     time_point;
  134.       BOOST_STATIC_CONSTEXPR bool is_steady =             false;
  135.  
  136.       static BOOST_CHRONO_INLINE time_point  now() BOOST_NOEXCEPT;
  137. #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  138.       static BOOST_CHRONO_INLINE time_point  now(system::error_code & ec);
  139. #endif
  140.  
  141.       static BOOST_CHRONO_INLINE std::time_t to_time_t(const time_point& t) BOOST_NOEXCEPT;
  142.       static BOOST_CHRONO_INLINE time_point  from_time_t(std::time_t t) BOOST_NOEXCEPT;
  143.   };
  144.  
  145. //----------------------------------------------------------------------------//
  146. //      20.9.5.2 Class steady_clock [time.clock.steady]                 //
  147. //----------------------------------------------------------------------------//
  148.  
  149. // As permitted  by [time.clock.steady]
  150. // The class steady_clock is conditionally supported.
  151.  
  152. #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
  153.   class BOOST_CHRONO_DECL steady_clock
  154.   {
  155.   public:
  156.       typedef nanoseconds                          duration;
  157.       typedef duration::rep                        rep;
  158.       typedef duration::period                     period;
  159.       typedef chrono::time_point<steady_clock>  time_point;
  160.       BOOST_STATIC_CONSTEXPR bool is_steady =             true;
  161.  
  162.       static BOOST_CHRONO_INLINE time_point  now() BOOST_NOEXCEPT;
  163. #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  164.       static BOOST_CHRONO_INLINE time_point  now(system::error_code & ec);
  165. #endif
  166.   };
  167. #endif
  168. //----------------------------------------------------------------------------//
  169. //      20.9.5.3 Class high_resolution_clock [time.clock.hires]               //
  170. //----------------------------------------------------------------------------//
  171.  
  172. //  As permitted, steady_clock or system_clock is a typedef for high_resolution_clock.
  173. //  See synopsis.
  174.  
  175.  
  176.   template<class CharT>
  177.   struct clock_string<system_clock, CharT>
  178.   {
  179.     static std::basic_string<CharT> name()
  180.     {
  181.       static const CharT u[] =
  182.       { 's', 'y', 's', 't', 'e', 'm', '_', 'c', 'l', 'o', 'c', 'k' };
  183.       static const std::basic_string<CharT> str(u, u + sizeof(u)
  184.           / sizeof(u[0]));
  185.       return str;
  186.     }
  187.     static std::basic_string<CharT> since()
  188.     {
  189.       static const CharT
  190.           u[] =
  191.               { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'J', 'a', 'n', ' ', '1', ',', ' ', '1', '9', '7', '0' };
  192.       static const std::basic_string<CharT> str(u, u + sizeof(u)
  193.           / sizeof(u[0]));
  194.       return str;
  195.     }
  196.   };
  197.  
  198. #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
  199.  
  200.   template<class CharT>
  201.   struct clock_string<steady_clock, CharT>
  202.   {
  203.     static std::basic_string<CharT> name()
  204.     {
  205.       static const CharT
  206.           u[] =
  207.               { 's', 't', 'e', 'a', 'd', 'y', '_', 'c', 'l', 'o', 'c', 'k' };
  208.       static const std::basic_string<CharT> str(u, u + sizeof(u)
  209.           / sizeof(u[0]));
  210.       return str;
  211.     }
  212.     static std::basic_string<CharT> since()
  213.     {
  214.       const CharT u[] =
  215.       { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'b', 'o', 'o', 't' };
  216.       const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
  217.       return str;
  218.     }
  219.   };
  220.  
  221. #endif
  222.  
  223. } // namespace chrono
  224. } // namespace mars_boost
  225.  
  226. #ifndef BOOST_CHRONO_HEADER_ONLY
  227. // the suffix header occurs after all of our code:
  228. #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
  229. #else
  230. #include <boost/chrono/detail/inlined/chrono.hpp>
  231. #endif
  232.  
  233. #endif // BOOST_CHRONO_SYSTEM_CLOCKS_HPP
  234.  
downloadsystem_clocks.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top