committed changes from @marcinwoj;

Author: niksu

client.cpp

@@ -89,6 +89,18 @@ inline unsigned long int ts_diff_now(struct timeval a)
     return bval - aval;
 }
 
+/*inline unsigned long int ts_now()
+{
+    struct timeval b;
+
+    gettimeofday(&b, NULL);
+    //unsigned long long bval = b.tv_sec * 1000000 + b.tv_usec;
+
+    //return bval;
+    return b;
+}
+*/
+
 inline timeval timeval_factorial_avarge( timeval a, timeval b, unsigned int weight)
 {
     timeval tv;
@@ -275,7 +287,8 @@ int client::connect(void)
     evbuffer_drain(m_write_buf, evbuffer_get_length(m_write_buf));
 
     if (m_unix_sockaddr != NULL) {
-        m_sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+        //m_sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+        m_sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
         if (m_sockfd < 0) {
             return -errno;
         }
@@ -300,8 +313,8 @@ int client::connect(void)
         error = setsockopt(m_sockfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
         assert(error == 0);
 
-        error = setsockopt(m_sockfd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
-        assert(error == 0);
+        //error = setsockopt(m_sockfd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
+        //assert(error == 0);
     }
 
     // set non-blcoking behavior
@@ -555,6 +568,7 @@ void client::create_request(void)
             assert(key != NULL);
             assert(keylen > 0);
 
+            keylen = 6;
             benchmark_debug_log("GET key=[%.*s]\n", keylen, key);
             cmd_size = m_protocol->write_command_get(key, keylen, m_config->data_offset);
 
@@ -616,15 +630,24 @@ void client::process_first_request(void)
 
 void client::handle_response(request *request, protocol_response *response)
 {
+
+    //long long unsigned int tmp = 0;
     switch (request->m_type) {
         case rt_get:
+            //printf("GET %lu\n",ts_diff_now(request->m_sent_time));
             m_stats.update_get_op(NULL, 
                 request->m_size + response->get_total_len(),
                 ts_diff_now(request->m_sent_time),
                 response->get_hits(),
                 request->m_keys - response->get_hits());
+                //printf("now %d\n",ts_now());
+                //b.tv_sec * 1000000 + b.tv_usec;
+                //printf("request->m_sent_time %lld %lld\n",request->m_sent_time.tv_sec, request->m_sent_time.tv_usec);
+                //printf("Latency %d\n",ts_diff_now(request->m_sent_time));
+                //printf("Get %lld\n",ts_diff_now(request->m_sent_time));
             break;
         case rt_set:
+           // printf("SET %lu\n",ts_diff_now(request->m_sent_time));
             m_stats.update_set_op(NULL,
                 request->m_size + response->get_total_len(),
                 ts_diff_now(request->m_sent_time));
@@ -1380,6 +1403,7 @@ void run_stats::print(FILE *out, bool histogram)
     // aggregate all one_second_stats; we do this only if we have
     // one_second_stats, otherwise it means we're probably printing previously
     // aggregated data
+    debug_dump();
     if (m_stats.size() > 0) {
         summarize(m_totals);
     }

config_types.cpp

@@ -215,7 +215,8 @@ int server_addr::resolve(void)
 
     memset(&hints, 0, sizeof(hints));
     hints.ai_flags = AI_PASSIVE;
-    hints.ai_socktype = SOCK_STREAM;
+    //hints.ai_socktype = SOCK_STREAM;
+    hints.ai_socktype = SOCK_DGRAM;
     hints.ai_family = AF_INET;      // Don't play with IPv6 for now...
 
     snprintf(port_str, sizeof(port_str)-1, "%u", m_port);

libmemcached_protocol/binary.h

@@ -185,6 +185,7 @@ extern "C"
      */
     typedef union {
         struct {
+            uint64_t udp_header;
             uint8_t magic;
             uint8_t opcode;
             uint16_t keylen;
@@ -204,6 +205,7 @@ extern "C"
      */
     typedef union {
         struct {
+            uint64_t udp_header;
             uint8_t magic;
             uint8_t opcode;
             uint16_t keylen;

obj_gen.cpp

@@ -358,12 +358,24 @@ unsigned int object_generator::get_key_index(int iter)
 
 const char* object_generator::get_key(int iter, unsigned int *len)
 {
+    
+    char a[6] = {0xC, 0xA, 0xF, 0xE, 0xC, 0xA};
+    unsigned int i;
     unsigned int l;
     m_key_index = get_key_index(iter);
 
     // format key
-    l = snprintf(m_key_buffer, sizeof(m_key_buffer)-1,
-        "%s%u", m_key_prefix, m_key_index);
+    //l = snprintf(m_key_buffer, sizeof(m_key_buffer)-1,
+    
+    //fixed
+    //l = snprintf(m_key_buffer, 7,
+    //    "%s%u", m_key_prefix, m_key_index);
+    
+    //rnd COMENT OUT for FIX key
+    for (i=0; i < 6; ++i){
+        a[i] = (char)random_range(0, 15);
+    }
+    l = snprintf(m_key_buffer, 7, "%x%x%x%x%x%x%x%x", a[0], a[1], a[2], a[3], a[4], a[5], a[0], a[1]);
     if (len != NULL) *len = l;
 
     return m_key_buffer;
@@ -400,6 +412,8 @@ data_object* object_generator::get_object(int iter)
     }
 
     // set object
+    new_size = 8;
+    //printf("setting key of len %d\n", strlen(m_key_buffer));
     m_object.set_key(m_key_buffer, strlen(m_key_buffer));
     m_object.set_value(m_value_buffer, new_size);
     m_object.set_expiry(expiry);    

protocol.cpp

@@ -410,7 +410,7 @@ int memcache_text_protocol::write_command_set(const char *key, int key_len, cons
     assert(value != NULL);
     assert(value_len > 0);
     int size = 0;
-    
+   
     size = evbuffer_add_printf(m_write_buf,
         "set %.*s 0 %u %u\r\n", key_len, key, expiry, value_len);
     evbuffer_add(m_write_buf, value, value_len);
@@ -630,6 +630,7 @@ int memcache_binary_protocol::write_command_set(const char *key, int key_len, co
     protocol_binary_request_set req;
 
     memset(&req, 0, sizeof(req));
+    req.message.header.request.udp_header = 0x0000010000000000;
     req.message.header.request.magic = PROTOCOL_BINARY_REQ;
     req.message.header.request.opcode = PROTOCOL_BINARY_CMD_SET;
     req.message.header.request.keylen = htons(key_len);
@@ -653,6 +654,8 @@ int memcache_binary_protocol::write_command_get(const char *key, int key_len, un
     protocol_binary_request_get req;
 
     memset(&req, 0, sizeof(req));
+    benchmark_debug_log("here");
+    req.message.header.request.udp_header = 0x0000010000000000;
     req.message.header.request.magic = PROTOCOL_BINARY_REQ;
     req.message.header.request.opcode = PROTOCOL_BINARY_CMD_GET;
     req.message.header.request.keylen = htons(key_len);
@@ -724,6 +727,7 @@ int memcache_binary_protocol::parse_response(void)
 
                 ret = evbuffer_remove(m_read_buf, (void *)&m_response_hdr, sizeof(m_response_hdr));
                 assert(ret == sizeof(m_response_hdr));
+                //printf("sizse of resposne header %d\n",sizeof(m_response_hdr));
 
                 if (m_response_hdr.message.header.response.magic != PROTOCOL_BINARY_RES) {
                     benchmark_error_log("error: invalid memcache response header magic.\n");