1 files changed, 60 insertions, 23 deletions

diff --git a/util/timer.h b/util/timer.h
index f5a21f8..cbfe859 100644
--- a/util/timer.h
+++ b/util/timer.h
@@ -24,44 +24,81 @@ namespace mongo {
     /**
      *  simple scoped timer
      */
-    class Timer {
+    class Timer /*copyable*/ {
     public:
-        Timer() {
-            reset();
-        }
-
-        Timer( unsigned long long start ) {
-            old = start;
-        }
-
-        int seconds() const {
-            return (int)(micros() / 1000000);
-        }
+        Timer() { reset(); }
+        Timer( unsigned long long startMicros ) { old = startMicros; }
+        int seconds() const { return (int)(micros() / 1000000); }
+        int millis() const { return (int)(micros() / 1000); }
+        int minutes() const { return seconds() / 60; }
+        
 
-        int millis() const {
-            return (long)(micros() / 1000);
+        /** gets time interval and resets at the same time.  this way we can call curTimeMicros
+              once instead of twice if one wanted millis() and then reset().
+            @return time in millis
+        */
+        int millisReset() { 
+            unsigned long long now = curTimeMicros64();
+            int m = (int)((now-old)/1000);
+            old = now;
+            return m;
         }
 
+        // note: dubious that the resolution is as anywhere near as high as ethod name implies!
         unsigned long long micros() const {
             unsigned long long n = curTimeMicros64();
             return n - old;
         }
-
         unsigned long long micros(unsigned long long & n) const { // returns cur time in addition to timer result
             n = curTimeMicros64();
             return n - old;
         }
 
-        unsigned long long startTime() {
-            return old;
-        }
-
-        void reset() {
-            old = curTimeMicros64();
-        }
-
+        unsigned long long startTime() const { return old; }
+        void reset() { old = curTimeMicros64(); }
     private:
         unsigned long long old;
     };
 
+#if 1
+    class DevTimer {
+    public:
+        class scoped { 
+        public:
+            scoped(DevTimer& dt) { }
+            ~scoped() { }
+        };
+        DevTimer(string) { }
+        ~DevTimer() { }
+    };
+#elif defined(_WIN32)
+    class DevTimer {
+        const string _name;
+    public:
+        unsigned long long _ticks;
+        class scoped { 
+            DevTimer& _dt;
+            unsigned long long _start;
+        public:
+            scoped(DevTimer& dt) : _dt(dt) { 
+                LARGE_INTEGER i;
+                QueryPerformanceCounter(&i);
+                _start = i.QuadPart;
+            }
+            ~scoped() { 
+                LARGE_INTEGER i;
+                QueryPerformanceCounter(&i);
+                _dt._ticks += (i.QuadPart - _start);
+            }
+        };
+        DevTimer(string name) : _name(name), _ticks(0) { 
+        }
+        ~DevTimer() {
+            LARGE_INTEGER freq;
+            assert( QueryPerformanceFrequency(&freq) );

+            cout << "devtimer\t" << _name << '\t' << _ticks*1000.0/freq.QuadPart << "ms" << endl;
+        }
+    };
+#endif
+
 }  // namespace mongo