home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / timer / zentimer / ztimer.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-21  |  7.5 KB  |  262 lines
  1. /****************************************************************************
  2. *
  3. *                           The Zen Timer Library
  4. *
  5. *                               From the book
  6. *                         "Zen of Assembly Language"
  7. *                            Volume 1, Knowledge
  8. *
  9. *                             by Michael Abrash
  10. *
  11. *                      Modifications by Kendall Bennett
  12. *
  13. * Filename:        $RCSfile: ztimer.h $
  14. * Version:        $Revision: 1.9 $
  15. *
  16. * Language:        ANSI C, C++ 2.1
  17. * Environment:    IBM PC (MS DOS)
  18. *
  19. * Description:    Header file for the Zen Timer library. Provides a number
  20. *                of routines to accurately time segments of code. A
  21. *                precision timer is provided for highly accurate timing of
  22. *                code that takes less than 54 ms to execute, and a long
  23. *                period timer is provided to time code that takes up to
  24. *                one hour to execute. All output is in microseconds.
  25. *
  26. *                The ultra long period timer can be used to time code
  27. *                that takes up to 24 hours to execute (raytracing
  28. *                etc).
  29. *
  30. *                We also now provide a set of C++ classes to manipulate
  31. *                the Zen Timers. Note that you can only have one timer
  32. *                running at a time!! Note that all of the code is inline
  33. *                to make it memory model independant, and to avoid the
  34. *                extra cost of a function call overhead in the C++ wrappers.
  35. *
  36. * $Id: ztimer.h 1.9 92/04/21 01:19:51 kjb release $
  37. *
  38. * Revision History:
  39. * -----------------
  40. *
  41. * $Log:    ztimer.h $
  42. * Revision 1.9  92/04/21  01:19:51  kjb
  43. * Converted to memory model dependant library.
  44. * 
  45. * Revision 1.8  92/04/21  00:47:55  kjb
  46. * Fixed code to be memory model independant.
  47. * 
  48. * Revision 1.7  92/04/20  23:30:52  kjb
  49. * Cosmetic changes.
  50. * 
  51. * Revision 1.6  92/04/20  17:35:07  kjb
  52. * Added C++ classes to manipulate the timers.
  53. * ./
  54. * 
  55. * Revision 1.5  92/01/27  21:40:01  kjb
  56. * Converted to a memory model independant library, and released to the
  57. * public.,
  58. *
  59. * Revision 1.4  91/12/31  19:34:51  kjb
  60. * Changed include file directories.
  61. *
  62. * Revision 1.3  91/12/26  17:56:38  kjb
  63. * Added dependency on DEBUG.H
  64. *
  65. * Revision 1.2  91/11/16  17:12:20  kjb
  66. * Modified to return a long integer representing the count rather than a
  67. * string.
  68. *
  69. * Revision 1.1  91/11/14  17:19:58  kjb
  70. * Initial revision
  71. *
  72. ****************************************************************************/
  73.  
  74. #ifndef    __ZTIMER_H
  75. #define    __ZTIMER_H
  76.  
  77. #ifndef __DEBUG_H
  78. #include "debug.h"
  79. #endif
  80.  
  81. /*-------------------------- Function Prototypes --------------------------*/
  82.  
  83. #ifdef    __cplusplus
  84. extern "C" {            /* Use "C" linkage when in C++ mode    */
  85. #endif
  86.  
  87. /* Precision timing routines in PZTIMER.ASM */
  88.  
  89. void    far PZTimerOn(void);
  90. void    far PZTimerOff(void);
  91. void    far PZTimerReport(void);
  92. ulong    far PZTimerCount(void);
  93.  
  94. /* Long period timing routines in LZTIMER.ASM */
  95.  
  96. void     far LZTimerOn(void);
  97. void     far LZTimerOff(void);
  98. void     far LZTimerReport(void);
  99. ulong     far LZTimerCount(void);
  100.  
  101. /* Ultra long period timing routines in TIMER.C */
  102.  
  103. ulong    ULZReadTime(void);
  104. ulong    ULZElapsedTime(ulong start,ulong finish);
  105.  
  106. #ifdef    __cplusplus
  107. }                        /* End of "C" linkage for C++    */
  108. #endif
  109.  
  110. /*--------------------------- Class Definitions ---------------------------*/
  111.  
  112. #ifdef    __cplusplus
  113.  
  114. #ifndef    __IOSTREAM_H
  115. #include <iostream.h>
  116. #endif
  117.  
  118. //---------------------------------------------------------------------------
  119. // Precision Zen Timer class. This can be used to time code that takes up
  120. // to 54 ms to execute between calls to start() and stop() or lap(). The
  121. // aggregate count can be up to 2^32 - 1 microseconds (about 1 hour
  122. // and 10 mins).
  123. //---------------------------------------------------------------------------
  124.  
  125. class PZTimer {
  126. protected:
  127.     ulong    _count;                // Running count
  128.     short    _overflow;            // Flags an overflow
  129.  
  130. public:
  131.             // Constructor
  132.             PZTimer()        { _count = 0; _overflow = false; };
  133.  
  134.             // Method to start the timer
  135.             void start()    { PZTimerOn(); };
  136.  
  137.             // Method to restart the timer
  138.             void restart()    { reset(); start(); };
  139.  
  140.             // Method to stop the timer
  141.             void stop()
  142.             {
  143.                 PZTimerOff();
  144.                 if (!overflow()) {
  145.                     ulong newcount = _count + PZTimerCount();
  146.                     if (newcount < _count || newcount == 0xFFFFFFFF)
  147.                         _overflow = true;
  148.                     else
  149.                         _count = newcount;
  150.                     }
  151.             };
  152.  
  153.             // Method to return the current count
  154.             ulong count()    { return overflow() ? 0xFFFFFFFF : _count; };
  155.  
  156.             // Method to reset the timer to a zero count
  157.             void reset()    { _count = 0; _overflow = false; };
  158.  
  159.             // Method to determine if overflow occurred
  160.             bool overflow()    { return _overflow; };
  161.  
  162.             // Method to return timer resolution (counts in a second).
  163.             ulong resolution()    { return 1000000L; };
  164.  
  165.             // Method to display the timed count in seconds
  166.     friend    ostream& operator << (ostream& o,PZTimer& timer);
  167.     };
  168.  
  169. //---------------------------------------------------------------------------
  170. // Long Period Zen Timer class. This can be used to time code that takes up
  171. // to 1 hour to execute between calls to start() and stop() or lap(). The
  172. // aggregate count can be up to 2^32 - 1 microseconds (about 1 hour
  173. // and 10 mins).
  174. //---------------------------------------------------------------------------
  175.  
  176. class LZTimer {
  177. protected:
  178.     ulong    _count;
  179.     short    _overflow;
  180. public:
  181.             // Constructor
  182.             LZTimer()        { _count = 0; _overflow = false; };
  183.  
  184.             // Method to start the timer
  185.             void start()    { LZTimerOn(); };
  186.  
  187.             // Method to restart the timer
  188.             void restart()    { reset(); start(); };
  189.  
  190.             // Method to stop the timer
  191.             void stop()
  192.             {
  193.                 LZTimerOff();
  194.                 if (!overflow()) {
  195.                     ulong newcount = _count + LZTimerCount();
  196.                     if (newcount < _count || newcount == 0xFFFFFFFF)
  197.                         _overflow = true;
  198.                     else
  199.                         _count = newcount;
  200.                     }
  201.             };
  202.  
  203.             // Method to return the current count
  204.             ulong count()    { return overflow() ? 0xFFFFFFFF : _count; };
  205.  
  206.             // Method to reset the timer to a zero count
  207.             void reset()    { _count = 0; _overflow = false; };
  208.  
  209.             // Method to determine if overflow occurred
  210.             bool overflow()    { return _overflow; };
  211.  
  212.             // Method to return timer resolution (counts in a second).
  213.             ulong resolution()    { return 1000000L; };
  214.  
  215.             // Method to display the timed count in seconds
  216.     friend    ostream& operator << (ostream& o,LZTimer& timer);
  217.     };
  218.  
  219. //---------------------------------------------------------------------------
  220. // Ultra Long Period Zen Timer class. This can be used to time code that
  221. // takes up 24 hours total to execute between calls to start() and stop().
  222. // The aggregate count can be up to 2^32 - 1 tenths of a second, which
  223. // is about 119,000 hours! Should be enough for most applications.
  224. //---------------------------------------------------------------------------
  225.  
  226. class ULZTimer {
  227. protected:
  228.     ulong    _count,_start,_finish;
  229.     short    _overflow;
  230. public:
  231.             // Constructor
  232.             ULZTimer()        { _count = 0; _overflow = false; };
  233.  
  234.             // Method to start the timer
  235.             void start()    { _start = ULZReadTime(); };
  236.  
  237.             // Method to restart the timer
  238.             void restart()    { reset(); start(); };
  239.  
  240.             // Method to stop the timer
  241.             void stop();
  242.  
  243.             // Method to return the current count
  244.             ulong count()    { return overflow() ? 0xFFFFFFFF : _count; };
  245.  
  246.             // Method to reset the timer to a zero count
  247.             void reset()    { _count = 0; _overflow = false; };
  248.  
  249.             // Method to determine if overflow occurred
  250.             bool overflow()    { return _overflow; };
  251.  
  252.             // Method to return timer resolution (counts in a second).
  253.             ulong resolution()    { return 10L; };
  254.  
  255.             // Method to display the timed count in seconds
  256.     friend    ostream& operator << (ostream& o,ULZTimer& timer);
  257.     };
  258.  
  259. #endif
  260.  
  261. #endif    __ZTIMER_H
  262.