version 1.2.6: random data fix, latency histogram improvements

Author: DovKfir

CHANGES

@@ -1,3 +1,7 @@
+* Version 1.2.6
+    * Improve latency histogram accuracy and range
+    * Fix --random-data when using many threads
+
 * Version 1.2.5
     * Bugfix in --randomize
 

client.cpp

@@ -44,12 +44,22 @@
 #include <assert.h>
 #endif
 
+#include <math.h>
 #include <algorithm>
 
 #include "client.h"
 #include "obj_gen.h"
 #include "memtier_benchmark.h"
 
+float get_2_meaningful_digits(float val)
+{
+    float log = floor(log10(val));
+    float factor = pow(10, log-1); // to save 2 digits
+    float new_val = round( val / factor);
+    new_val *= factor;
+    return new_val;
+}
+
 void client_event_handler(evutil_socket_t sfd, short evtype, void *opaque)
 {
     client *c = (client *) opaque;
@@ -1067,8 +1077,6 @@ run_stats::run_stats() :
 {
     memset(&m_start_time, 0, sizeof(m_start_time));
     memset(&m_end_time, 0, sizeof(m_end_time));
-    memset(m_get_latency, 0, sizeof(m_get_latency));
-    memset(m_set_latency, 0, sizeof(m_set_latency));    
 }
 
 void run_stats::set_start_time(struct timeval* start_time)
@@ -1122,10 +1130,7 @@ void run_stats::update_get_op(struct timeval* ts, unsigned int bytes, unsigned i
     m_totals.m_ops++;
     m_totals.m_latency += latency;
 
-    unsigned int msec_latency = latency / 1000;
-    if (msec_latency > MAX_LATENCY_HISTOGRAM)
-        msec_latency = MAX_LATENCY_HISTOGRAM;
-    m_get_latency[msec_latency]++;    
+    m_get_latency_map[get_2_meaningful_digits((float)latency/1000)]++;
 }
 
 void run_stats::update_set_op(struct timeval* ts, unsigned int bytes, unsigned int latency)
@@ -1140,10 +1145,7 @@ void run_stats::update_set_op(struct timeval* ts, unsigned int bytes, unsigned i
     m_totals.m_ops++;
     m_totals.m_latency += latency;
 
-    unsigned int msec_latency = latency / 1000;
-    if (msec_latency > MAX_LATENCY_HISTOGRAM)
-        msec_latency = MAX_LATENCY_HISTOGRAM;
-    m_set_latency[msec_latency]++;
+    m_set_latency_map[get_2_meaningful_digits(latency/1000)]++;
 }
 
 unsigned int run_stats::get_duration(void)
@@ -1214,24 +1216,24 @@ bool run_stats::save_csv(const char *filename)
         total_set_ops += i->m_ops_set;
     }
 
-    unsigned long int total_count = 0;
+
+    double total_count_float = 0;
+    int i=0;
     fprintf(f, "\n" "Full-Test GET Latency\n");
     fprintf(f, "Latency (<= msec),Percent\n");
-    for (int i = 0; i <= MAX_LATENCY_HISTOGRAM; i++) {
-        if (m_get_latency[i] > 0) {
-            total_count += m_get_latency[i];
-            fprintf(f, "%u,%.2f\n", i, (double) total_count / total_get_ops * 100);
-        }
+    for ( latency_map_itr it = m_get_latency_map.begin() ; it != m_get_latency_map.end() ; it++ ) {
+        total_count_float += it->second;
+        fprintf(f, "%u,%.2f\n", i, total_count_float / total_get_ops * 100);
+        i++;
     }
-    
+    i=0;
     fprintf(f, "\n" "Full-Test SET Latency\n");
     fprintf(f, "Latency (<= msec),Percent\n");
-    total_count = 0;
-    for (int i = 0; i <= MAX_LATENCY_HISTOGRAM; i++) {
-        if (m_set_latency[i] > 0) {
-            total_count += m_set_latency[i];
-            fprintf(f, "%u,%.2f\n", i, (double) total_count / total_set_ops * 100);
-        }
+
+    for ( latency_map_itr it = m_set_latency_map.begin(); it != m_set_latency_map.end() ; it++ ) {
+        total_count_float += it->second;
+        fprintf(f, "%u,%.2f\n", i, total_count_float / total_get_ops * 100);
+        i++;
     }
 
     fclose(f);
@@ -1259,14 +1261,14 @@ void run_stats::debug_dump(void)
             i->m_get_misses);
     }
 
-    for (int i = 0; i <= MAX_LATENCY_HISTOGRAM; i++) {
-        if (m_get_latency[i] > 0) 
-            benchmark_debug_log("  GET <= %u msec: %u\n", i, m_get_latency[i]);
-    }
 
-    for (int i = 0; i <= MAX_LATENCY_HISTOGRAM; i++) {
-        if (m_set_latency[i] > 0) 
-            benchmark_debug_log("  SET <= %u msec: %u\n", i, m_set_latency[i]);
+    for( latency_map_itr it = m_get_latency_map.begin() ; it != m_get_latency_map.end() ; it++) {
+        if (it->second)
+            benchmark_debug_log("  GET <= %u msec: %u\n", it->first, it->second);
+    }
+    for(  latency_map_itr it = m_set_latency_map.begin() ; it != m_set_latency_map.end() ; it++) {
+        if (it->second)
+            benchmark_debug_log("  SET <= %u msec: %u\n", it->first, it->second);
     }
 }
 
@@ -1284,12 +1286,14 @@ void run_stats::aggregate_average(const std::vector<run_stats>& all_stats)
             m_totals.add(i_totals);
 
             // aggregate latency data
-            for (int j = 0; j < MAX_LATENCY_HISTOGRAM + 1; j++) {
-                m_get_latency[j] += i->m_get_latency[j];
-                m_set_latency[j] += i->m_set_latency[j];
-            }            
-    }
 
+        for( latency_map_itr_const it = i->m_get_latency_map.begin() ; it != i->m_get_latency_map.end() ; it++) {
+            m_get_latency_map[it->first] += it->second;
+        }
+        for( latency_map_itr_const it = i->m_set_latency_map.begin() ; it != i->m_set_latency_map.end() ; it++) {
+            m_set_latency_map[it->first] += it->second;
+        }
+    }
     m_totals.m_ops_sec_set /= all_stats.size();
     m_totals.m_ops_sec_get /= all_stats.size();
     m_totals.m_ops_sec /= all_stats.size();
@@ -1342,11 +1346,13 @@ void run_stats::merge(const run_stats& other, int iteration)
     m_totals.m_ops += other.m_totals.m_ops;
 
     // aggregate latency data
-    for (int i = 0; i < MAX_LATENCY_HISTOGRAM + 1; i++) {
-        m_get_latency[i] += other.m_get_latency[i];
-        m_set_latency[i] += other.m_set_latency[i];
+    for( latency_map_itr_const it = other.m_get_latency_map.begin() ; it != other.m_get_latency_map.end() ; it++) {
+	m_get_latency_map[it->first] += it->second;
+    }
+    for( latency_map_itr_const it = other.m_set_latency_map.begin() ; it != other.m_set_latency_map.end() ; it++) {
+	m_set_latency_map[it->first] += it->second;
     }
-           
+       
 }
 
 void run_stats::summarize(totals& result) const
@@ -1440,25 +1446,19 @@ void run_stats::print(FILE *out, bool histogram)
             "Request Latency Distribution\n"
             "%-6s %12s %12s\n"
             "------------------------------------------------------------------------\n",
-            "Type", "<= msec", "Percent");    
+            "Type", "<= msec   ", "Percent");    
 
     unsigned long int total_count = 0;
-    for (int i = 0; i <= MAX_LATENCY_HISTOGRAM; i++) {
-        if (m_set_latency[i] > 0) {
-            total_count += m_set_latency[i];
-            fprintf(out, "%-6s %12u %12.2f\n",
-                    "SET", i, (double) total_count / m_totals.m_ops_set * 100);
-        }
+    for( latency_map_itr_const it = m_set_latency_map.begin() ; it != m_set_latency_map.end() ; it++) {
+        total_count += it->second;
+        fprintf(out, "%-6s %8.3f %12.2f\n", "SET", it->first, (double) total_count / m_totals.m_ops_set * 100);
     }
+    total_count = 0;
 
     fprintf(out, "---\n");
-    total_count = 0;
-    for (int i = 0; i <= MAX_LATENCY_HISTOGRAM; i++) {
-        if (m_get_latency[i] > 0) {
-            total_count += m_get_latency[i];
-            fprintf(out, "%-6s %12u %12.2f\n",
-                    "GET", i, (double) total_count / m_totals.m_ops_get * 100);
-        }
-    }    
+    for( latency_map_itr_const it = m_get_latency_map.begin() ; it != m_get_latency_map.end() ; it++) {
+        total_count += it->second;
+        fprintf(out, "%-6s %8.3f %12.2f\n", "GET", it->first, (double) total_count / m_totals.m_ops_get * 100);
+    }
 }
 

client.h

@@ -26,7 +26,8 @@
 #include <sys/un.h>
 #include <vector>
 #include <queue>
-
+#include <map>
+#include <iterator>
 #include <event2/event.h>
 #include <event2/buffer.h>
 
@@ -39,7 +40,10 @@ struct benchmark_config;
 class object_generator;
 class data_object;
 
-#define MAX_LATENCY_HISTOGRAM       5000
+typedef std::map<float, int> latency_map;
+typedef std::map<float, int>::iterator latency_map_itr;
+typedef std::map<float, int>::const_iterator latency_map_itr_const;
+
 class run_stats {
 protected:
     struct one_second_stats {
@@ -92,8 +96,8 @@ class run_stats {
     std::vector<one_second_stats> m_stats;
     one_second_stats m_cur_stats;
 
-    unsigned int m_get_latency[MAX_LATENCY_HISTOGRAM+1];
-    unsigned int m_set_latency[MAX_LATENCY_HISTOGRAM+1];
+    latency_map m_get_latency_map;
+    latency_map m_set_latency_map;
     void roll_cur_stats(struct timeval* ts);
 
 public:

configure.ac

@@ -16,7 +16,7 @@ dnl You should have received a copy of the GNU General Public License
 dnl along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 AC_PREREQ(2.59)
-AC_INIT(memtier_benchmark,1.2.5,[email protected])
+AC_INIT(memtier_benchmark,1.2.6,[email protected])
 AC_CONFIG_SRCDIR([memtier_benchmark.cpp])
 AC_CONFIG_HEADER([config.h])
 AM_INIT_AUTOMAKE

obj_gen.cpp

@@ -156,8 +156,7 @@ object_generator::object_generator(const object_generator& copy) :
         m_data_size.size_list != NULL) {
         m_data_size.size_list = new config_weight_list(*m_data_size.size_list);
     }
-
-    alloc_value_buffer();
+    alloc_value_buffer(copy.m_value_buffer);
     for (int i = 0; i < OBJECT_GENERATOR_KEY_ITERATORS; i++)
         m_next_key[i] = 0;
 }
@@ -191,7 +190,7 @@ void object_generator::alloc_value_buffer(void)
     unsigned int size = 0;
 
     if (m_value_buffer != NULL)
-        free(m_value_buffer);
+        free(m_value_buffer), m_value_buffer = NULL;
 
     if (m_data_size_type == data_size_fixed) 
         size = m_data_size.size_fixed;
@@ -243,6 +242,27 @@ void object_generator::alloc_value_buffer(void)
     }
 }
 
+void object_generator::alloc_value_buffer(const char* copy_from)
+{
+    unsigned int size = 0;
+
+    if (m_value_buffer != NULL)
+        free(m_value_buffer), m_value_buffer = NULL;
+
+    if (m_data_size_type == data_size_fixed)
+        size = m_data_size.size_fixed;
+    else if (m_data_size_type == data_size_range)
+        size = m_data_size.size_range.size_max;
+    else if (m_data_size_type == data_size_weighted)
+        size = m_data_size.size_list->largest();
+
+    if (size > 0) {
+        m_value_buffer = (char*) malloc(size);
+        assert(m_value_buffer != NULL);
+        memcpy(m_value_buffer, copy_from, size);
+    }
+}
+
 void object_generator::set_random_data(bool random_data)
 {
     m_random_data = random_data;

obj_gen.h

@@ -109,6 +109,7 @@ class object_generator {
     gaussian_noise m_random;
 
     void alloc_value_buffer(void);
+    void alloc_value_buffer(const char* copy_from);
     void random_init(void);
     unsigned int random_range(unsigned int r_min, unsigned int r_max);
     unsigned int normal_distribution(unsigned int r_min, unsigned int r_max, double r_stddev, double r_median);