- improve precision of calculations (benchmark results)

- 2 small bugfixes.

Author: oranagra

client.cpp

@@ -1336,41 +1336,37 @@ void run_stats::summarize(totals& result) const
     }
 
     unsigned long int test_duration_usec = ts_diff(m_start_time, m_end_time);
-    unsigned int test_duration_sec = test_duration_usec / 1000000;
 
     result.m_ops_set = totals.m_ops_set;
     result.m_ops_get = totals.m_ops_get;
     result.m_ops = totals.m_ops_get + totals.m_ops_set;
     result.m_bytes = totals.m_bytes_get + totals.m_bytes_set;
 
-    if (test_duration_sec == 0)
-        test_duration_sec = 1;
-    
-    result.m_ops_sec_set = (double) totals.m_ops_set / test_duration_sec;
+    result.m_ops_sec_set = (double) totals.m_ops_set / test_duration_usec * 1000000;
     if (totals.m_ops_set > 0) {
         result.m_latency_set = (double) (totals.m_total_set_latency / totals.m_ops_set) / 1000;
     } else {
         result.m_latency_set = 0;
     }
-    result.m_bytes_sec_set = (double) ((totals.m_bytes_set / 1024) / test_duration_sec);
+    result.m_bytes_sec_set = (totals.m_bytes_set / 1024.0) / test_duration_usec * 1000000;
 
-    result.m_ops_sec_get = (double) totals.m_ops_get / test_duration_sec;
+    result.m_ops_sec_get = (double) totals.m_ops_get / test_duration_usec * 1000000;
     if (totals.m_ops_get > 0) {
         result.m_latency_get = (double) (totals.m_total_get_latency / totals.m_ops_get) / 1000;
     } else {
         result.m_latency_get = 0;
     }
-    result.m_bytes_sec_get = (double) ((totals.m_bytes_get / 1024) / test_duration_sec);
-    result.m_hits_sec = (double) totals.m_get_hits / test_duration_sec;
-    result.m_misses_sec = (double) totals.m_get_misses / test_duration_sec;
+    result.m_bytes_sec_get = (totals.m_bytes_get / 1024.0) / test_duration_usec * 1000000;
+    result.m_hits_sec = (double) totals.m_get_hits / test_duration_usec * 1000000;
+    result.m_misses_sec = (double) totals.m_get_misses / test_duration_usec * 1000000;
 
-    result.m_ops_sec = (double) result.m_ops / test_duration_sec;
+    result.m_ops_sec = (double) result.m_ops / test_duration_usec * 1000000;
     if (result.m_ops > 0) {
         result.m_latency = (double) ((totals.m_total_get_latency + totals.m_total_set_latency) / result.m_ops) / 1000;
     } else {
         result.m_latency = 0;
     }
-    result.m_bytes_sec = (double) ((result.m_bytes / 1024) / test_duration_sec);
+    result.m_bytes_sec = (result.m_bytes / 1024.0) / test_duration_usec * 1000000;
 }
 
 void run_stats::print(FILE *out, bool histogram)

memtier_benchmark.cpp

@@ -725,8 +725,8 @@ run_stats run_benchmark(int run_id, benchmark_config* cfg, object_generator* obj
         unsigned long int bytes_sec = 0;
         double avg_latency = 0;
         if (duration > 1000000) {
-            ops_sec = (total_ops / (duration / 1000000));
-            bytes_sec = (total_bytes / (duration / 1000000));
+            ops_sec = (long)( (double)total_ops / duration * 1000000);
+            bytes_sec = (long)( (double)total_bytes / duration * 1000000);
             avg_latency = ((double) total_latency / 1000 / total_ops) ;
         }
 
@@ -979,13 +979,13 @@ int main(int argc, char *argv[])
             run_stats* worst = NULL;
             run_stats* best = NULL;        
             for (std::vector<run_stats>::iterator i = all_stats.begin(); i != all_stats.end(); i++) {
-                unsigned int secs = (i->get_duration_usec() / 1000);
-                unsigned int ops_sec = (i->get_total_ops() / (secs > 0 ? secs : 1)) * 1000;
-                if (ops_sec < min_ops_sec) {
+                unsigned long usecs = i->get_duration_usec();
+                unsigned int ops_sec = (int)(((double)i->get_total_ops() / (usecs > 0 ? usecs : 1)) * 1000000);
+                if (ops_sec < min_ops_sec || worst == NULL) {
                     min_ops_sec = ops_sec;                
                     worst = &(*i);
                 }
-                if (ops_sec > max_ops_sec) {
+                if (ops_sec > max_ops_sec || best == NULL) {
                     max_ops_sec = ops_sec;
                     best = &(*i);
                 }

obj_gen.cpp

@@ -104,14 +104,14 @@ int gaussian_noise::gaussian_distribution_range(double stddev, double median, in
 {
     int len = max-min;
     double val;
-    if (median==0)
-        median = len/2.0+min + 0.5;
-    if (stddev==0)
-        stddev = len/6.0;
-    assert(median>min && median<max);
+    if (median == 0)
+        median = len / 2.0 + min + 0.5;
+    if (stddev == 0)
+        stddev = len / 6.0;
+    assert(median > min && median < max);
     do {
         val = gaussian_distribution(stddev) + median;
-    } while(val<min || val>max+1);
+    } while(val < min || val > max + 1);
     return val;
 }
 
@@ -124,6 +124,8 @@ object_generator::object_generator() :
     m_key_prefix(NULL),
     m_key_min(0),
     m_key_max(0),
+    m_key_stddev(0),
+    m_key_median(0),
     m_value_buffer(NULL),
     m_random_fd(-1)
 {
@@ -144,6 +146,7 @@ object_generator::object_generator(const object_generator& copy) :
     m_key_min(copy.m_key_min),
     m_key_max(copy.m_key_max),
     m_key_stddev(copy.m_key_stddev),
+    m_key_median(copy.m_key_median),
     m_value_buffer(NULL),
     m_random_fd(-1)