Encapsulated a couple of options/moved flags around a bit.

diff --git a/libmemcached/io.c b/libmemcached/io.c
index 3a523213357aaf3c15a7c7f29ac3d472630c992e..6aad480510f4ce5df02fab12273ca6220a1e4cc4 100644 (file)
--- a/libmemcached/io.c
+++ b/libmemcached/io.c
@@ -127,14 +127,14 @@ static bool process_input_buffer(memcached_server_instance_st *ptr)
    */
     memcached_callback_st cb= *ptr->root->callbacks;
 
-    ptr->root->options.is_processing_input= true;
+    memcached_set_processing_input(ptr->root, true);
 
     char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
     memcached_return_t error;
     error= memcached_response(ptr, buffer, sizeof(buffer),
                               &ptr->root->result);
 
-    ptr->root->options.is_processing_input = false;
+    memcached_set_processing_input(ptr->root, false);
 
     if (error == MEMCACHED_SUCCESS)
     {

diff --git a/libmemcached/memcached.c b/libmemcached/memcached.c
index 027ef20acbacc3a5260dbecbffc76e5ae409aeb4..2b96d422682edf59527f0aafca0838bab20708a8 100644 (file)
--- a/libmemcached/memcached.c
+++ b/libmemcached/memcached.c
@@ -21,9 +21,10 @@ memcached_st *memcached_create(memcached_st *ptr)
     memset(ptr, 0, sizeof(memcached_st));
   }
 
-  ptr->options.is_initialized= true;
-  ptr->options.is_purging= false;
-  ptr->options.is_processing_input= false;
+#if 0
+  memcached_set_purging(ptr, false);
+  memcached_set_processing_input(ptr, false);
+#endif
 
   memcached_set_memory_allocators(ptr, NULL, NULL, NULL, NULL);
 
@@ -103,10 +104,6 @@ void memcached_free(memcached_st *ptr)
   {
     ptr->call_free(ptr, ptr);
   }
-  else
-  {
-    ptr->options.is_initialized= false;
-  }
 }
 
 /*

diff --git a/libmemcached/memcached.h b/libmemcached/memcached.h
index d86f9bc9f74cdfa5cddce68c33c2b6c71827bb50..c6b898dc9f38dc855f0bc4aa46171963e215fdbc 100644 (file)
--- a/libmemcached/memcached.h
+++ b/libmemcached/memcached.h
@@ -45,29 +45,13 @@ extern "C" {
 #endif
 
 struct memcached_st {
-  struct {
-    bool is_allocated:1;
-    bool is_initialized:1;
-    bool is_purging:1;
-    bool is_processing_input:1;
-  } options;
-  memcached_server_distribution_t distribution;
-  memcached_hash_t hash;
-  uint32_t continuum_points_counter; // Ketama
-  memcached_server_st *servers;
-  memcached_server_st *last_disconnected_server;
-  int32_t snd_timeout;
-  int32_t rcv_timeout;
-  uint32_t server_failure_limit;
-  uint32_t io_msg_watermark;
-  uint32_t io_bytes_watermark;
-  uint32_t io_key_prefetch;
-  uint32_t number_of_hosts;
-  int cached_errno;
   /**
     @note these are static and should not change without a call to behavior.
   */
   struct {
+    bool is_purging:1;
+    bool is_processing_input:1;
+    // Everything below here is pretty static.
     bool auto_eject_hosts:1;
     bool binary_protocol:1;
     bool buffer_requests:1;
@@ -85,6 +69,19 @@ struct memcached_st {
     bool verify_key:1;
     bool cork:1;
   } flags;
+  memcached_server_distribution_t distribution;
+  memcached_hash_t hash;
+  uint32_t continuum_points_counter; // Ketama
+  memcached_server_st *servers;
+  memcached_server_st *last_disconnected_server;
+  int32_t snd_timeout;
+  int32_t rcv_timeout;
+  uint32_t server_failure_limit;
+  uint32_t io_msg_watermark;
+  uint32_t io_bytes_watermark;
+  uint32_t io_key_prefetch;
+  uint32_t number_of_hosts;
+  int cached_errno;
   int32_t poll_timeout;
   int32_t connect_timeout;
   int32_t retry_timeout;
@@ -108,6 +105,9 @@ struct memcached_st {
   memcached_trigger_delete_key_fn delete_trigger;
   memcached_callback_st *callbacks;
   char prefix_key[MEMCACHED_PREFIX_KEY_MAX_SIZE];
+  struct {
+    bool is_allocated:1;
+  } options;
 };
 
 LIBMEMCACHED_API
@@ -250,8 +250,13 @@ void *memcached_set_user_data(memcached_st *ptr, void *data);
 LIBMEMCACHED_LOCAL
 memcached_return_t run_distribution(memcached_st *ptr);
 
+// These are private 
 #define memcached_is_allocated(__object) ((__object)->options.is_allocated)
 #define memcached_is_initialized(__object) ((__object)->options.is_initialized)
+#define memcached_is_purging(__object) ((__object)->flags.is_purging)
+#define memcached_is_processing_input(__object) ((__object)->flags.is_processing_input)
+#define memcached_set_purging(__object, __value) ((__object)->flags.is_purging= (__value))
+#define memcached_set_processing_input(__object, __value) ((__object)->flags.is_processing_input= (__value))
 
 #ifdef __cplusplus
 }

diff --git a/libmemcached/purge.c b/libmemcached/purge.c
index 6780c54f115e28eb402a5b99011655647aab08e9..17c5b9d295b601a9b586a1ecdc0452230d8ab97d 100644 (file)
--- a/libmemcached/purge.c
+++ b/libmemcached/purge.c
@@ -5,7 +5,7 @@ memcached_return_t memcached_purge(memcached_server_instance_st *ptr)
   uint32_t x;
   memcached_return_t ret= MEMCACHED_SUCCESS;
 
-  if (ptr->root->options.is_purging || /* already purging */
+  if (memcached_is_purging(ptr->root) || /* already purging */
       (memcached_server_response_count(ptr) < ptr->root->io_msg_watermark &&
        ptr->io_bytes_sent < ptr->root->io_bytes_watermark) ||
       (ptr->io_bytes_sent >= ptr->root->io_bytes_watermark &&
@@ -16,14 +16,15 @@ memcached_return_t memcached_purge(memcached_server_instance_st *ptr)
 
   /* memcached_io_write and memcached_response may call memcached_purge
     so we need to be able stop any recursion.. */
-  ptr->root->options.is_purging= true;
+  memcached_set_purging(ptr->root, true);
 
   WATCHPOINT_ASSERT(ptr->fd != -1);
   /* Force a flush of the buffer to ensure that we don't have the n-1 pending
     requests buffered up.. */
   if (memcached_io_write(ptr, NULL, 0, 1) == -1)
   {
-    ptr->root->options.is_purging= true;
+    memcached_set_purging(ptr->root, true);
+
     return MEMCACHED_WRITE_FAILURE;
   }
   WATCHPOINT_ASSERT(ptr->fd != -1);
@@ -82,7 +83,7 @@ memcached_return_t memcached_purge(memcached_server_instance_st *ptr)
     memcached_result_free(result_ptr);
     ptr->root->poll_timeout= timeo;
   }
-  ptr->root->options.is_purging= false;
+  memcached_set_purging(ptr->root, false);
 
   return ret;
 }

diff --git a/libmemcached/response.c b/libmemcached/response.c
index f9269e55b1e67dc5e3cd4f3d83aa15ab39b4f623..dafdbbc40128da37fdc89c7fdddfedf6f6f70cf9 100644 (file)
--- a/libmemcached/response.c
+++ b/libmemcached/response.c
@@ -47,7 +47,7 @@ memcached_return_t memcached_response(memcached_server_instance_st *ptr,
                                       memcached_result_st *result)
 {
   /* We may have old commands in the buffer not set, first purge */
-  if ((ptr->root->flags.no_block) && (ptr->root->options.is_processing_input == false))
+  if ((ptr->root->flags.no_block) && (memcached_is_processing_input(ptr->root) == false))
   {
     (void)memcached_io_write(ptr, NULL, 0, 1);
   }

diff --git a/tests/include.am b/tests/include.am
index e1bf136884e84cb481d1666b1e4283c9567c0fd8..1bf7201106a290eaa93e275314a83b7307986f47 100644 (file)
--- a/tests/include.am
+++ b/tests/include.am
@@ -8,6 +8,8 @@ VALGRIND_COMMAND= $(LIBTOOL) --mode=execute valgrind --leak-check=yes --show-rea
 
 DEBUG_COMMAND= $(LIBTOOL) --mode=execute gdb
 
+PAHOLE_COMMAND= $(LIBTOOL) --mode=execute pahole
+
 if BUILD_LIBMEMCACHEDUTIL
 TESTS_LDADDS+= libmemcached/libmemcachedutil.la
 endif
@@ -215,6 +217,10 @@ test-plus: tests/testplus
 test-hash: tests/testhashkit
        $(HASH_COMMAND)
 
+pahole-mem: tests/testapp
+       $(PAHOLE_COMMAND)  $(MEM_COMMAND)
+
+
 gdb-mem: tests/testapp
        $(DEBUG_COMMAND)  $(MEM_COMMAND)