CDRIVER-1558 fix minPoolSize logic

Author: ajdavis

src/mongoc/mongoc-client-pool-private.h

@@ -27,7 +27,8 @@
 
 BSON_BEGIN_DECLS
 
-size_t 				  mongoc_client_pool_get_size(mongoc_client_pool_t *pool);
+size_t 				  mongoc_client_pool_get_size   (mongoc_client_pool_t *pool);
+size_t              mongoc_client_pool_num_pushed (mongoc_client_pool_t *pool);
 
 BSON_END_DECLS
 

src/mongoc/mongoc-client-pool.c

@@ -266,17 +266,19 @@ mongoc_client_pool_push (mongoc_client_pool_t *pool,
    BSON_ASSERT (client);
 
    mongoc_mutex_lock(&pool->mutex);
-   if (pool->min_pool_size && pool->size > pool->min_pool_size) {
+   _mongoc_queue_push_head (&pool->queue, client);
+
+   if (pool->min_pool_size &&
+       _mongoc_queue_get_length (&pool->queue) > pool->min_pool_size) {
+
       mongoc_client_t *old_client;
-      old_client = (mongoc_client_t *)_mongoc_queue_pop_head (&pool->queue);
+      old_client = (mongoc_client_t *)_mongoc_queue_pop_tail (&pool->queue);
       if (old_client) {
           mongoc_client_destroy (old_client);
           pool->size--;
       }
    }
 
-   _mongoc_queue_push_head (&pool->queue, client);
-
    mongoc_cond_signal(&pool->cond);
    mongoc_mutex_unlock(&pool->mutex);
 
@@ -297,6 +299,21 @@ mongoc_client_pool_get_size (mongoc_client_pool_t *pool)
    RETURN (size);
 }
 
+
+size_t
+mongoc_client_pool_num_pushed (mongoc_client_pool_t *pool)
+{
+   size_t num_pushed = 0;
+
+   ENTRY;
+
+   mongoc_mutex_lock (&pool->mutex);
+   num_pushed = pool->queue.length;
+   mongoc_mutex_unlock (&pool->mutex);
+
+   RETURN (num_pushed);
+}
+
 void
 mongoc_client_pool_max_size(mongoc_client_pool_t *pool,
                             uint32_t              max_pool_size)

src/mongoc/mongoc-queue-private.h

@@ -40,6 +40,7 @@ struct _mongoc_queue_t
 {
    mongoc_queue_item_t *head;
    mongoc_queue_item_t *tail;
+   uint32_t             length;
 };
 
 
@@ -52,6 +53,7 @@ struct _mongoc_queue_item_t
 
 void      _mongoc_queue_init      (mongoc_queue_t        *queue);
 void     *_mongoc_queue_pop_head  (mongoc_queue_t        *queue);
+void     *_mongoc_queue_pop_tail  (mongoc_queue_t        *queue);
 void      _mongoc_queue_push_head (mongoc_queue_t        *queue,
                                     void                 *data);
 void      _mongoc_queue_push_tail  (mongoc_queue_t       *queue,

src/mongoc/mongoc-queue.c

@@ -47,6 +47,8 @@ _mongoc_queue_push_head (mongoc_queue_t *queue,
    if (!queue->tail) {
       queue->tail = item;
    }
+
+   queue->length++;
 }
 
 
@@ -69,6 +71,7 @@ _mongoc_queue_push_tail (mongoc_queue_t *queue,
    }
 
    queue->tail = item;
+   queue->length++;
 }
 
 
@@ -87,23 +90,52 @@ _mongoc_queue_pop_head (mongoc_queue_t *queue)
       queue->head = item->next;
       data = item->data;
       bson_free(item);
+      queue->length--;
    }
 
    return data;
 }
 
 
-uint32_t
-_mongoc_queue_get_length (const mongoc_queue_t *queue)
+void *
+_mongoc_queue_pop_tail (mongoc_queue_t *queue)
 {
    mongoc_queue_item_t *item;
-   uint32_t count = 0;
+   void *data = NULL;
 
    BSON_ASSERT (queue);
 
-   for (item = queue->head; item; item = item->next) {
-      count++;
+   if (queue->length == 0) {
+      return NULL;
+   }
+
+   data = queue->tail->data;
+
+   if (queue->length == 1) {
+      bson_free (queue->tail);
+      queue->head = queue->tail = NULL;
+   } else {
+      /* find item pointing at tail */
+      for (item = queue->head; item; item = item->next) {
+         if (item->next == queue->tail) {
+            item->next = NULL;
+            bson_free (queue->tail);
+            queue->tail = item;
+            break;
+         }
+      }
    }
 
-   return count;
+   queue->length--;
+
+   return data;
+}
+
+
+uint32_t
+_mongoc_queue_get_length (const mongoc_queue_t *queue)
+{
+   BSON_ASSERT (queue);
+
+   return queue->length;
 }

tests/TestSuite.h

@@ -133,6 +133,7 @@ extern "C" {
 #define ASSERT_CMPUINT64(a, eq, b) ASSERT_CMPINT_HELPER(a, eq, b, PRIu64)
 #define ASSERT_CMPSIZE_T(a, eq, b) ASSERT_CMPINT_HELPER(a, eq, b, "zd")
 #define ASSERT_CMPSSIZE_T(a, eq, b) ASSERT_CMPINT_HELPER(a, eq, b, "zx")
+#define ASSERT_CMPVOID(a, eq, b) ASSERT_CMPINT_HELPER(a, eq, b, "p")
 
 #define ASSERT_MEMCMP(a, b, n) \
    do { \

tests/test-mongoc-client-pool.c

@@ -79,47 +79,59 @@ test_mongoc_client_pool_min_size_dispose (void)
    mongoc_client_pool_t *pool;
    mongoc_client_t *client;
    mongoc_uri_t *uri;
-   mongoc_array_t conns;
-   int i;
+   mongoc_client_t *c0, *c1, *c2, *c3;
 
-   _mongoc_array_init (&conns, sizeof client);
-
-   uri = mongoc_uri_new ("mongodb://127.0.0.1?maxpoolsize=10&minpoolsize=3");
+   uri = mongoc_uri_new ("mongodb://127.0.0.1?minpoolsize=2");
    pool = mongoc_client_pool_new (uri);
 
-   for (i = 0; i < 10; i++) {
-      client = mongoc_client_pool_pop (pool);
-      assert (client);
-      _mongoc_array_append_val (&conns, client);
-      assert (mongoc_client_pool_get_size (pool) == i + 1);
-   }
+   c0 = mongoc_client_pool_pop (pool);
+   assert (c0);
+   ASSERT_CMPSIZE_T (mongoc_client_pool_get_size (pool), ==, (size_t) 1);
 
-   for (i = 0; i < 10; i++) {
-      client = _mongoc_array_index (&conns, mongoc_client_t *, i);
-      assert (client);
-      mongoc_client_pool_push (pool, client);
-   }
+   c1 = mongoc_client_pool_pop (pool);
+   assert (c1);
+   ASSERT_CMPSIZE_T (mongoc_client_pool_get_size (pool), ==, (size_t) 2);
 
-   assert (mongoc_client_pool_get_size (pool) == 3);
+   c2 = mongoc_client_pool_pop (pool);
+   assert (c2);
+   ASSERT_CMPSIZE_T (mongoc_client_pool_get_size (pool), ==, (size_t) 3);
 
-   /* assert oldest clients were destroyed, newest were stored */
-   for (i = 9; i >= 7; i--) {
-      client = mongoc_client_pool_pop (pool);
-      assert (client);
-      assert (client == _mongoc_array_index (&conns, mongoc_client_t *, i));
-   }
+   c3 = mongoc_client_pool_pop (pool);
+   assert (c3);
+   ASSERT_CMPSIZE_T (mongoc_client_pool_get_size (pool), ==, (size_t) 4);
 
-   /* clean up */
-   for (i = 7; i < 10; i++) {
-      client = _mongoc_array_index (&conns, mongoc_client_t *, i);
-      assert (client);
-      mongoc_client_pool_push (pool, client);
-   }
+   mongoc_client_pool_push (pool, c0);  /* queue is [c0] */
+   ASSERT_CMPSIZE_T (mongoc_client_pool_num_pushed (pool), ==, (size_t) 1);
+   ASSERT_CMPSIZE_T (mongoc_client_pool_get_size (pool), ==, (size_t) 4);
 
-   _mongoc_array_clear (&conns);
-   _mongoc_array_destroy (&conns);
-   mongoc_uri_destroy (uri);
+   mongoc_client_pool_push (pool, c1);  /* queue is [c1, c0] */
+   ASSERT_CMPSIZE_T (mongoc_client_pool_num_pushed (pool), ==, (size_t) 2);
+   ASSERT_CMPSIZE_T (mongoc_client_pool_get_size (pool), ==, (size_t) 4);
+
+   mongoc_client_pool_push (pool, c2);  /* queue is [c2, c1] */
+   ASSERT_CMPSIZE_T (mongoc_client_pool_num_pushed (pool), ==, (size_t) 2);
+   ASSERT_CMPSIZE_T (mongoc_client_pool_get_size (pool), ==, (size_t) 3);
+
+   mongoc_client_pool_push (pool, c3);  /* queue is [c3, c2] */
+   ASSERT_CMPSIZE_T (mongoc_client_pool_num_pushed (pool), ==, (size_t) 2);
+   ASSERT_CMPSIZE_T (mongoc_client_pool_get_size (pool), ==, (size_t) 2);
+
+   /* assert oldest client was destroyed, newest were stored */
+   client = mongoc_client_pool_pop (pool);
+   assert (client);
+   assert (client == c3);
+
+   client = mongoc_client_pool_pop (pool);
+   assert (client);
+   assert (client == c2);
+
+   ASSERT_CMPSIZE_T (mongoc_client_pool_get_size (pool), ==, (size_t) 2);
+
+   /* clean up */
+   mongoc_client_pool_push (pool, c2);
+   mongoc_client_pool_push (pool, c3);
    mongoc_client_pool_destroy (pool);
+   mongoc_uri_destroy (uri);
 }
 
 static void

tests/test-mongoc-queue.c

@@ -26,8 +26,32 @@ test_mongoc_queue_basic (void)
 }
 
 
+static void
+test_mongoc_queue_pop_tail (void)
+{
+   mongoc_queue_t q = MONGOC_QUEUE_INITIALIZER;
+
+   _mongoc_queue_push_head(&q, (void *) 1);
+   ASSERT_CMPUINT32 (_mongoc_queue_get_length (&q), ==, (uint32_t) 1);
+   ASSERT_CMPVOID (_mongoc_queue_pop_tail (&q), ==, (void *) 1);
+
+   ASSERT_CMPUINT32 (_mongoc_queue_get_length (&q), ==, (uint32_t) 0);
+   ASSERT_CMPVOID (_mongoc_queue_pop_tail (&q), ==, (void *) NULL);
+
+   _mongoc_queue_push_tail(&q, (void *)2);
+   _mongoc_queue_push_head(&q, (void *)3);
+   ASSERT_CMPUINT32 (_mongoc_queue_get_length (&q), ==, (uint32_t) 2);
+   ASSERT_CMPVOID (_mongoc_queue_pop_tail (&q), ==, (void *) 2);
+   ASSERT_CMPUINT32 (_mongoc_queue_get_length (&q), ==, (uint32_t) 1);
+   ASSERT_CMPVOID (_mongoc_queue_pop_tail (&q), ==, (void *) 3);
+   ASSERT_CMPUINT32 (_mongoc_queue_get_length (&q), ==, (uint32_t) 0);
+   ASSERT_CMPVOID (_mongoc_queue_pop_tail (&q), ==, (void *) NULL);
+}
+
+
 void
 test_queue_install (TestSuite *suite)
 {
    TestSuite_Add (suite, "/Queue/basic", test_mongoc_queue_basic);
+   TestSuite_Add (suite, "/Queue/pop_tail", test_mongoc_queue_pop_tail);
 }