aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

pool: rename data structure fields to stack

Browse Source 
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.
pull/792/head
Victor Julien 13 years ago
parent ee83809d8e
commit 7a0649f9c4
3 changed files with 68 additions and 68 deletions
Show Stats Download Patch File Download Diff File

22
src/stream-tcp-reassemble.c
Unescape Escape View File

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

106
src/util-pool.c
Unescape Escape View File

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

8
src/util-pool.h
Unescape Escape View File

@ -46,12 +46,12 @@ typedef struct Pool_ {
uint32_t allocated; /**< counter of data elements, both currently in uint32_t allocated; /**< counter of data elements, both currently in
* the pool and outside of it (outstanding) */ * 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; PoolBucket *empty_stack;
uint32_t empty_list_size; uint32_t empty_stack_size;
int data_buffer_size; int data_buffer_size;
void *data_buffer; void *data_buffer;

Write Preview
Loading…
Cancel
Save