void freePool(GTrashStack **pool, int blocksize)
{
MemBlock *block;
for(block = g_trash_stack_pop(pool); block; block = g_trash_stack_pop(pool)) {
#ifdef DEBUG_MEMORY
free(block);
#else
g_slice_free1(sizeof(MemBlock) + blocksize, block);
#endif
}
}
GQueue*
g_queue_new (void)
{
GQueue *queue;
G_LOCK (queue_memchunk);
queue = g_trash_stack_pop (&free_queue_nodes);
if (!queue)
{
if (!queue_memchunk)
queue_memchunk = g_mem_chunk_new ("GLib GQueue chunk",
sizeof (GNode),
sizeof (GNode) * 128,
G_ALLOC_ONLY);
queue = g_chunk_new (GQueue, queue_memchunk);
}
G_UNLOCK (queue_memchunk);
queue->head = NULL;
queue->tail = NULL;
queue->length = 0;
return queue;
}
void
sb_gstring_free_stack(void)
{
SBGString *sb;
while ((sb = g_trash_stack_pop(&local_sb_gstrings)) != NULL)
{
g_free(sb_gstring_string(sb)->str);
g_free(sb);
}
}
void
scratch_buffers_free(void)
{
ScratchBuffer *sb;
while ((sb = g_trash_stack_pop(&local_scratch_buffers)) != NULL)
{
g_free(sb_string(sb)->str);
g_free(sb);
}
}
void * stack_alloc(shared_trash_stack_t *ts) {
void *p;
pthread_mutex_lock(&myds_pool.mutex);
p=g_trash_stack_pop(&ts->stack);
if (p) {
pthread_mutex_unlock(&myds_pool.mutex);
proxy_debug(PROXY_DEBUG_MEMORY, 5, "%p\n", p);
return p;
}
void *m;
//if ((m=malloc(ts->size*ts->incremental))==NULL) { exit(EXIT_FAILURE); }
m=g_malloc0(ts->size*ts->incremental);
g_ptr_array_add(ts->blocks,m);
int i;
for (i=0; i<ts->incremental; i++) {
pkt *n=m+i*ts->size;
g_trash_stack_push(&ts->stack,n);
}
p=g_trash_stack_pop(&ts->stack);
pthread_mutex_unlock(&myds_pool.mutex);
proxy_debug(PROXY_DEBUG_MEMORY, 5, "%p\n", p);
return p;
}
ScratchBuffer *
scratch_buffer_acquire(void)
{
ScratchBuffer *sb;
sb = g_trash_stack_pop(&local_scratch_buffers);
if (!sb)
{
sb = g_new(ScratchBuffer, 1);
g_string_steal(sb_string(sb));
}
else
g_string_set_size(sb_string(sb), 0);
return sb;
}
GTrashStack *
sb_gstring_acquire_buffer(void)
{
SBGString *sb;
sb = g_trash_stack_pop(&local_sb_gstrings);
if (!sb)
{
sb = g_new(SBGString, 1);
g_string_steal(sb_gstring_string(sb));
}
else
g_string_set_size(sb_gstring_string(sb), 0);
return (GTrashStack *) sb;
}
GTrashStack *
sb_th_gstring_acquire_buffer (void)
{
SBTHGString *sb;
sb = g_trash_stack_pop(&local_sb_th_gstrings);
if (!sb)
{
sb = g_new(SBTHGString, 1);
g_string_steal(sb_th_gstring_string(sb));
sb->type_hint = TYPE_HINT_STRING;
}
else
g_string_set_size(sb_th_gstring_string(sb), 0);
return (GTrashStack *)sb;
}
static inline gpointer
pgm_rxw_alloc_packet (
pgm_rxw_t* r
)
{
ASSERT_RXW_BASE_INVARIANT(r);
gpointer p;
g_static_mutex_lock (r->trash_mutex);
if (*r->trash_packet) {
p = g_trash_stack_pop (r->trash_packet);
} else {
p = g_slice_alloc (sizeof(pgm_rxw_packet_t));
}
g_static_mutex_unlock (r->trash_mutex);
return p;
}
MemBlock *getBlock(int size)
{
assert(size <= MAX_MEMBLOCK_SIZE);
GTrashStack **pool;
int blocksize;
if (size <= 1024) {
pool = &g_mem_1k;
blocksize = 1024;
} else if (size <= 16*1024) {
pool = &g_mem_16k;
blocksize = 16*1024;
} else if (size <= 64*1024) {
pool = &g_mem_64k;
blocksize = 64*1024;
} else if (size <= 1024*1024) {
pool = &g_mem_1024k;
blocksize = 1024*1024;
} else {
g_error("Request block size is too big");
return NULL;
}
MemBlock *block = g_trash_stack_pop(pool);
if (!block) {
#ifdef DEBUG_MEMORY
block = malloc(sizeof(MemBlock) + blocksize);
g_message("[%.8x] NEW BLOCK (pool = %.8x)", block, pool);
#else
block = (MemBlock*)g_slice_alloc(sizeof(MemBlock) + blocksize);
#endif
} else {
#ifdef DEBUG_MEMORY
g_message("[%.8x] POP BLOCK (pool = %.8x)", block, pool);
#endif
}
block->pool = pool;
block->refcount = 0;
block->size = blocksize;
block->nbytes = 0;
return block;
}
