pool: rename data structure fields to stack

Rename the following fields:
 -    uint32_t alloc_list_size;
 +    uint32_t alloc_stack_size;

 -    PoolBucket *alloc_list;
 +    PoolBucket *alloc_stack;

 -    PoolBucket *empty_list;
 -    uint32_t empty_list_size;
 +    PoolBucket *empty_stack;
 +    uint32_t empty_stack_size;

To reflect that these are in fact, stacks.

diff --git a/src/stream-tcp-reassemble.c b/src/stream-tcp-reassemble.c
index 737ec5f38e29ac01db17ab088b967832155883a3..fa9396aa6a05a9b13ebabb1335aac5d8e3d154c1 100644 (file)
--- a/src/stream-tcp-reassemble.c
+++ b/src/stream-tcp-reassemble.c
@@ -245,8 +245,8 @@ void StreamTcpSegmentReturntoPool(TcpSegment *seg)
     uint16_t idx = segment_pool_idx[seg->pool_size];
     SCMutexLock(&segment_pool_mutex[idx]);
     PoolReturn(segment_pool[idx], (void *) seg);
-    SCLogDebug("segment_pool[%"PRIu16"]->empty_list_size %"PRIu32"",
-               idx,segment_pool[idx]->empty_list_size);
+    SCLogDebug("segment_pool[%"PRIu16"]->empty_stack_size %"PRIu32"",
+               idx,segment_pool[idx]->empty_stack_size);
     SCMutexUnlock(&segment_pool_mutex[idx]);
 
 #ifdef DEBUG
@@ -336,10 +336,10 @@ void StreamTcpReassembleFree(char quiet)
 
         if (quiet == FALSE) {
             PoolPrintSaturation(segment_pool[u16]);
-            SCLogDebug("segment_pool[u16]->empty_list_size %"PRIu32", "
-                       "segment_pool[u16]->alloc_list_size %"PRIu32", alloced "
-                       "%"PRIu32"", segment_pool[u16]->empty_list_size,
-                       segment_pool[u16]->alloc_list_size,
+            SCLogDebug("segment_pool[u16]->empty_stack_size %"PRIu32", "
+                       "segment_pool[u16]->alloc_stack_size %"PRIu32", alloced "
+                       "%"PRIu32"", segment_pool[u16]->empty_stack_size,
+                       segment_pool[u16]->alloc_stack_size,
                        segment_pool[u16]->allocated);
         }
         PoolFree(segment_pool[u16]);
@@ -3601,16 +3601,16 @@ TcpSegment* StreamTcpGetSegment(ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx,
     SCMutexLock(&segment_pool_mutex[idx]);
     TcpSegment *seg = (TcpSegment *) PoolGet(segment_pool[idx]);
 
-    SCLogDebug("segment_pool[%u]->empty_list_size %u, segment_pool[%u]->alloc_"
-               "list_size %u, alloc %u", idx, segment_pool[idx]->empty_list_size,
-               idx, segment_pool[idx]->alloc_list_size,
+    SCLogDebug("segment_pool[%u]->empty_stack_size %u, segment_pool[%u]->alloc_"
+               "list_size %u, alloc %u", idx, segment_pool[idx]->empty_stack_size,
+               idx, segment_pool[idx]->alloc_stack_size,
                segment_pool[idx]->allocated);
     SCMutexUnlock(&segment_pool_mutex[idx]);
 
     SCLogDebug("seg we return is %p", seg);
     if (seg == NULL) {
-        SCLogDebug("segment_pool[%u]->empty_list_size %u, "
-                   "alloc %u", idx, segment_pool[idx]->empty_list_size,
+        SCLogDebug("segment_pool[%u]->empty_stack_size %u, "
+                   "alloc %u", idx, segment_pool[idx]->empty_stack_size,
                    segment_pool[idx]->allocated);
         /* Increment the counter to show that we are not able to serve the
            segment request due to memcap limit */

diff --git a/src/util-pool.c b/src/util-pool.c
index d86fb5211308a2ed8f4604bc5c043285251c1a76..41ab1fd708bcf9ba9ffa9cce62330e222097cecf 100644 (file)
--- a/src/util-pool.c
+++ b/src/util-pool.c
@@ -133,10 +133,10 @@ Pool *PoolInit(uint32_t size, uint32_t prealloc_size, uint32_t elt_size,  void *
         memset(pb, 0, size * sizeof(PoolBucket));
         for (u32 = 0; u32 < size; u32++) {
             /* populate pool */
-            pb->next = p->empty_list;
+            pb->next = p->empty_stack;
             pb->flags |= POOL_BUCKET_PREALLOCATED;
-            p->empty_list = pb;
-            p->empty_list_size++;
+            p->empty_stack = pb;
+            p->empty_stack_size++;
             pb++;
         }
     }
@@ -183,11 +183,11 @@ Pool *PoolInit(uint32_t size, uint32_t prealloc_size, uint32_t elt_size,  void *
             }
             p->allocated++;
 
-            pb->next = p->alloc_list;
-            p->alloc_list = pb;
-            p->alloc_list_size++;
+            pb->next = p->alloc_stack;
+            p->alloc_stack = pb;
+            p->alloc_stack_size++;
         } else {
-            PoolBucket *pb = p->empty_list;
+            PoolBucket *pb = p->empty_stack;
             if (pb == NULL) {
                 SCLogError(SC_ERR_POOL_INIT, "alloc error");
                 goto error;
@@ -201,14 +201,14 @@ Pool *PoolInit(uint32_t size, uint32_t prealloc_size, uint32_t elt_size,  void *
                 goto error;
             }
 
-            p->empty_list = pb->next;
-            p->empty_list_size--;
+            p->empty_stack = pb->next;
+            p->empty_stack_size--;
 
             p->allocated++;
 
-            pb->next = p->alloc_list;
-            p->alloc_list = pb;
-            p->alloc_list_size++;
+            pb->next = p->alloc_stack;
+            p->alloc_stack = pb;
+            p->alloc_stack_size++;
         }
     }
 
@@ -226,9 +226,9 @@ void PoolFree(Pool *p) {
     if (p == NULL)
         return;
 
-    while (p->alloc_list != NULL) {
-        PoolBucket *pb = p->alloc_list;
-        p->alloc_list = pb->next;
+    while (p->alloc_stack != NULL) {
+        PoolBucket *pb = p->alloc_stack;
+        p->alloc_stack = pb->next;
         if (p->Cleanup)
             p->Cleanup(pb->data);
         if (PoolDataPreAllocated(p, pb->data) == 0) {
@@ -243,9 +243,9 @@ void PoolFree(Pool *p) {
         }
     }
 
-    while (p->empty_list != NULL) {
-        PoolBucket *pb = p->empty_list;
-        p->empty_list = pb->next;
+    while (p->empty_stack != NULL) {
+        PoolBucket *pb = p->empty_stack;
+        p->empty_stack = pb->next;
         if (pb->data!= NULL) {
             if (p->Cleanup)
                 p->Cleanup(pb->data);
@@ -271,23 +271,23 @@ void PoolFree(Pool *p) {
 
 void PoolPrint(Pool *p) {
     printf("\n----------- Hash Table Stats ------------\n");
-    printf("Buckets:               %" PRIu32 "\n", p->empty_list_size + p->alloc_list_size);
+    printf("Buckets:               %" PRIu32 "\n", p->empty_stack_size + p->alloc_stack_size);
     printf("-----------------------------------------\n");
 }
 
 void *PoolGet(Pool *p) {
     SCEnter();
 
-    PoolBucket *pb = p->alloc_list;
+    PoolBucket *pb = p->alloc_stack;
     if (pb != NULL) {
         /* pull from the alloc list */
-        p->alloc_list = pb->next;
-        p->alloc_list_size--;
+        p->alloc_stack = pb->next;
+        p->alloc_stack_size--;
 
         /* put in the empty list */
-        pb->next = p->empty_list;
-        p->empty_list = pb;
-        p->empty_list_size++;
+        pb->next = p->empty_stack;
+        p->empty_stack = pb;
+        p->empty_stack_size++;
     } else {
         if (p->max_buckets == 0 || p->allocated < p->max_buckets) {
             void *pitem;
@@ -327,7 +327,7 @@ void *PoolGet(Pool *p) {
 void PoolReturn(Pool *p, void *data) {
     SCEnter();
 
-    PoolBucket *pb = p->empty_list;
+    PoolBucket *pb = p->empty_stack;
 
     SCLogDebug("pb %p", pb);
 
@@ -350,13 +350,13 @@ void PoolReturn(Pool *p, void *data) {
     }
 
     /* pull from the alloc list */
-    p->empty_list = pb->next;
-    p->empty_list_size--;
+    p->empty_stack = pb->next;
+    p->empty_stack_size--;
 
     /* put in the alloc list */
-    pb->next = p->alloc_list;
-    p->alloc_list = pb;
-    p->alloc_list_size++;
+    pb->next = p->alloc_stack;
+    p->alloc_stack = pb;
+    p->alloc_stack_size++;
 
     pb->data = data;
     p->outstanding--;
@@ -406,9 +406,9 @@ static int PoolTestInit02 (void) {
     if (p == NULL)
         goto end;
 
-    if (p->alloc_list == NULL || p->empty_list == NULL) {
+    if (p->alloc_stack == NULL || p->empty_stack == NULL) {
         printf("list(s) not properly initialized (a:%p e:%p): ",
-            p->alloc_list, p->empty_list);
+            p->alloc_stack, p->empty_stack);
         retval = 0;
         goto end;
     }
@@ -449,14 +449,14 @@ static int PoolTestInit03 (void) {
         goto end;
     }
 
-    if (p->alloc_list_size != 4) {
-        printf("p->alloc_list_size 4 != %" PRIu32 ": ", p->alloc_list_size);
+    if (p->alloc_stack_size != 4) {
+        printf("p->alloc_stack_size 4 != %" PRIu32 ": ", p->alloc_stack_size);
         retval = 0;
         goto end;
     }
 
-    if (p->empty_list_size != 6) {
-        printf("p->empty_list_size 6 != %" PRIu32 ": ", p->empty_list_size);
+    if (p->empty_stack_size != 6) {
+        printf("p->empty_stack_size 6 != %" PRIu32 ": ", p->empty_stack_size);
         retval = 0;
         goto end;
     }
@@ -489,14 +489,14 @@ static int PoolTestInit04 (void) {
         goto end;
     }
 
-    if (p->alloc_list_size != 4) {
-        printf("p->alloc_list_size 4 != %" PRIu32 ": ", p->alloc_list_size);
+    if (p->alloc_stack_size != 4) {
+        printf("p->alloc_stack_size 4 != %" PRIu32 ": ", p->alloc_stack_size);
         retval = 0;
         goto end;
     }
 
-    if (p->empty_list_size != 6) {
-        printf("p->empty_list_size 6 != %" PRIu32 ": ", p->empty_list_size);
+    if (p->empty_stack_size != 6) {
+        printf("p->empty_stack_size 6 != %" PRIu32 ": ", p->empty_stack_size);
         retval = 0;
         goto end;
     }
@@ -523,14 +523,14 @@ static int PoolTestInit05 (void) {
         goto end;
     }
 
-    if (p->alloc_list_size != 4) {
-        printf("p->alloc_list_size 4 != %" PRIu32 ": ", p->alloc_list_size);
+    if (p->alloc_stack_size != 4) {
+        printf("p->alloc_stack_size 4 != %" PRIu32 ": ", p->alloc_stack_size);
         retval = 0;
         goto end;
     }
 
-    if (p->empty_list_size != 6) {
-        printf("p->empty_list_size 6 != %" PRIu32 ": ", p->empty_list_size);
+    if (p->empty_stack_size != 6) {
+        printf("p->empty_stack_size 6 != %" PRIu32 ": ", p->empty_stack_size);
         retval = 0;
         goto end;
     }
@@ -538,14 +538,14 @@ static int PoolTestInit05 (void) {
     PoolReturn(p, data);
     data = NULL;
 
-    if (p->alloc_list_size != 5) {
-        printf("p->alloc_list_size 5 != %" PRIu32 ": ", p->alloc_list_size);
+    if (p->alloc_stack_size != 5) {
+        printf("p->alloc_stack_size 5 != %" PRIu32 ": ", p->alloc_stack_size);
         retval = 0;
         goto end;
     }
 
-    if (p->empty_list_size != 5) {
-        printf("p->empty_list_size 5 != %" PRIu32 ": ", p->empty_list_size);
+    if (p->empty_stack_size != 5) {
+        printf("p->empty_stack_size 5 != %" PRIu32 ": ", p->empty_stack_size);
         retval = 0;
         goto end;
     }
@@ -601,8 +601,8 @@ static int PoolTestInit06 (void) {
         goto end;
     }
 
-    if (p->alloc_list_size != 1) {
-        printf("p->alloc_list_size 1 != %" PRIu32 ": ", p->alloc_list_size);
+    if (p->alloc_stack_size != 1) {
+        printf("p->alloc_stack_size 1 != %" PRIu32 ": ", p->alloc_stack_size);
         retval = 0;
         goto end;
     }
@@ -671,8 +671,8 @@ static int PoolTestInit07 (void) {
         goto end;
     }
 
-    if (p->alloc_list_size != 1) {
-        printf("p->alloc_list_size 1 != %" PRIu32 ": ", p->alloc_list_size);
+    if (p->alloc_stack_size != 1) {
+        printf("p->alloc_stack_size 1 != %" PRIu32 ": ", p->alloc_stack_size);
         retval = 0;
         goto end;
     }

diff --git a/src/util-pool.h b/src/util-pool.h
index da4c3dddc34b546a4a957eddf04132afd42eebbb..266d1f4d4c63d47a5caa6cb6813c6022cd682e6c 100644 (file)
--- a/src/util-pool.h
+++ b/src/util-pool.h
@@ -46,12 +46,12 @@ typedef struct Pool_ {
     uint32_t allocated;         /**< counter of data elements, both currently in
                                  *   the pool and outside of it (outstanding) */
 
-    uint32_t alloc_list_size;
+    uint32_t alloc_stack_size;
 
-    PoolBucket *alloc_list;
+    PoolBucket *alloc_stack;
 
-    PoolBucket *empty_list;
-    uint32_t empty_list_size;
+    PoolBucket *empty_stack;
+    uint32_t empty_stack_size;
 
     int data_buffer_size;
     void *data_buffer;