extend the bench timer to allow benchmarking of parallel code,

improvements are welcome

1 files changed, 74 insertions, 19 deletions

diff --git a/bench/BenchTimer.h b/bench/BenchTimer.h
index b2d0fc5f6..6889654fe 100644
--- a/bench/BenchTimer.h
+++ b/bench/BenchTimer.h
@@ -23,24 +23,31 @@
 // License and a copy of the GNU General Public License along with
 // Eigen. If not, see <http://www.gnu.org/licenses/>.
 
-#ifndef EIGEN_BENCH_TIMER_H
-#define EIGEN_BENCH_TIMER_H
+#ifndef EIGEN_BENCH_TIMERR_H
+#define EIGEN_BENCH_TIMERR_H
 
 #if defined(_WIN32) || defined(__CYGWIN__)
 #define NOMINMAX
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #else
+#include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
 #endif
 
+#include <cmath>
 #include <cstdlib>
 #include <numeric>
 
 namespace Eigen
 {
 
+enum {
+  CPU_TIMER = 0,
+  REAL_TIMER = 1
+};
+
 /** Elapsed time timer keeping the best try.
   *
   * On POSIX platforms we use clock_gettime with CLOCK_PROCESS_CPUTIME_ID.
@@ -52,37 +59,58 @@ class BenchTimer
 {
 public:
 
-  BenchTimer() 
-  { 
+  BenchTimer()
+  {
 #if defined(_WIN32) || defined(__CYGWIN__)
     LARGE_INTEGER freq;
     QueryPerformanceFrequency(&freq);
     m_frequency = (double)freq.QuadPart;
 #endif
-    reset(); 
+    reset();
   }
 
   ~BenchTimer() {}
 
-  inline void reset(void) {m_best = 1e6;}
-  inline void start(void) {m_start = getTime();}
-  inline void stop(void)
+  inline void reset()
+  {
+    m_bests.fill(1e9);
+    m_totals.setZero();
+  }
+  inline void start()
+  {
+    m_starts[CPU_TIMER]  = getCpuTime();
+    m_starts[REAL_TIMER] = getRealTime();
+  }
+  inline void stop()
   {
-    m_best = std::min(m_best, getTime() - m_start);
+    m_times[CPU_TIMER] = getCpuTime() - m_starts[CPU_TIMER];
+    m_times[REAL_TIMER] = getRealTime() - m_starts[REAL_TIMER];
+    m_bests = m_bests.cwiseMin(m_times);
+    m_totals += m_times;
   }
 
-  /** Return the best elapsed time in seconds.
+  /** Return the elapsed time in seconds between the last start/stop pair
     */
-  inline double value(void)
+  inline double value(int TIMER = CPU_TIMER)
   {
-    return m_best;
+    return m_times[TIMER];
   }
 
-#if defined(_WIN32) || defined(__CYGWIN__)
-  inline double getTime(void)
-#else
-  static inline double getTime(void)
-#endif
+  /** Return the best elapsed time in seconds
+    */
+  inline double best(int TIMER = CPU_TIMER)
+  {
+    return m_bests[TIMER];
+  }
+
+  /** Return the total elapsed time in seconds.
+    */
+  inline double total(int TIMER = CPU_TIMER)
+  {
+    return m_totals[TIMER];
+  }
+
+  inline double getCpuTime()
   {
 #ifdef WIN32
     LARGE_INTEGER query_ticks;
@@ -95,14 +123,41 @@ public:
 #endif
   }
 
+  inline double getRealTime()
+  {
+#ifdef WIN32
+    // TODO
+    return getCputime;
+#else
+    struct timeval tv;
+    struct timezone tz;
+    gettimeofday(&tv, &tz);
+    return (double)tv.tv_sec + 1.e-6 * (double)tv.tv_usec;
+#endif
+  }
+
 protected:
 #if defined(_WIN32) || defined(__CYGWIN__)
   double m_frequency;
 #endif
-  double m_best, m_start;
+  Vector2d m_starts;
+  Vector2d m_times;
+  Vector2d m_bests;
+  Vector2d m_totals;
 
 };
 
+#define BENCH(TIMER,TRIES,REP,CODE) { \
+    TIMER.reset(); \
+    for(int uglyvarname1=0; uglyvarname1<TRIES; ++uglyvarname1){ \
+      TIMER.start(); \
+      for(int uglyvarname2=0; uglyvarname2<REP; ++uglyvarname2){ \
+        CODE; \
+      } \
+      TIMER.stop(); \
+    } \
+  }
+
 }
 
-#endif // EIGEN_BENCH_TIMER_H
+#endif // EIGEN_BENCH_TIMERR_H