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; }