void
sb_gstring_release_buffer(GTrashStack *s)
{
SBGString *sb = (SBGString *) s;
g_trash_stack_push(&local_sb_gstrings, sb);
}
static inline int
pgm_rxw_pkt_data_free1 (
pgm_rxw_t* r,
gpointer packet
)
{
// g_slice_free1 (rp->length, rp->data);
g_static_mutex_lock (r->trash_mutex);
g_trash_stack_push (r->trash_data, packet);
g_static_mutex_unlock (r->trash_mutex);
return PGM_RXW_OK;
}
void
g_queue_free (GQueue *queue)
{
g_return_if_fail (queue != NULL);
g_list_free (queue->head);
#ifdef ENABLE_GC_FRIENDLY
queue->head = NULL;
queue->tail = NULL;
#endif /* ENABLE_GC_FRIENDLY */
G_LOCK (queue_memchunk);
g_trash_stack_push (&free_queue_nodes, queue);
G_UNLOCK (queue_memchunk);
}
int decRef(MemBlock *block)
{
if (!block) return 0;
assert(block->refcount > 0);
block->refcount--;
// If reference count reaches zero then return block to pool
if (block->refcount == 0) {
#ifdef DEBUG_MEMORY
g_message("[%.8x] PUSH BLOCK (ref = 0, pool = %.8x)", block, block->pool);
#endif
g_trash_stack_push(block->pool, block);
} else {
#ifdef DEBUG_MEMORY
g_message("[%.8x] DEC REFERENCE (ref = %d, pool = %.8x)", block, block->refcount, block->pool);
#endif
}
return block->refcount;
}
static inline int
pgm_rxw_pkt_free1 (
pgm_rxw_t* r,
pgm_rxw_packet_t* rp
)
{
ASSERT_RXW_BASE_INVARIANT(r);
g_assert ( rp != NULL );
if (rp->data)
{
pgm_rxw_data_free1 (r, rp);
}
// g_slice_free1 (sizeof(pgm_rxw_t), rp);
g_static_mutex_lock (r->trash_mutex);
g_trash_stack_push (r->trash_packet, rp);
g_static_mutex_unlock (r->trash_mutex);
ASSERT_RXW_BASE_INVARIANT(r);
return PGM_RXW_OK;
}
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;
}
void
sb_th_gstring_release_buffer(GTrashStack *s)
{
g_trash_stack_push(&local_sb_th_gstrings, s);
}
void stack_free(void *p, shared_trash_stack_t *ts) {
pthread_mutex_lock(&myds_pool.mutex);
proxy_debug(PROXY_DEBUG_MEMORY, 5, "%p\n", p);
g_trash_stack_push(&ts->stack, p);
pthread_mutex_unlock(&myds_pool.mutex);
}
pgm_rxw_t*
pgm_rxw_init (
const void* identifier, /* TSI */
guint16 tpdu_length,
guint32 preallocate_size,
guint32 rxw_sqns, /* transmit window size in sequence numbers */
guint rxw_secs, /* size in seconds */
guint rxw_max_rte, /* max bandwidth */
GTrashStack** trash_data,
GTrashStack** trash_packet,
GStaticMutex* trash_mutex
)
{
g_trace ("init (tpdu %i pre-alloc %i rxw_sqns %i rxw_secs %i rxw_max_rte %i).",
tpdu_length, preallocate_size, rxw_sqns, rxw_secs, rxw_max_rte);
pgm_rxw_t* r = g_slice_alloc0 (sizeof(pgm_rxw_t));
r->identifier = identifier;
r->pdata = g_ptr_array_new ();
r->max_tpdu = tpdu_length;
r->trash_data = trash_data;
r->trash_packet = trash_packet;
r->trash_mutex = trash_mutex;
if (preallocate_size)
{
g_static_mutex_lock (r->trash_mutex);
for (guint32 i = 0; i < preallocate_size; i++)
{
gpointer data = g_slice_alloc (r->max_tpdu);
gpointer packet = g_slice_alloc (sizeof(pgm_rxw_packet_t));
g_trash_stack_push (r->trash_data, data);
g_trash_stack_push (r->trash_packet, packet);
}
g_static_mutex_unlock (r->trash_mutex);
}
/* calculate receive window parameters as per transmit window */
if (rxw_sqns)
{
}
else if (rxw_secs && rxw_max_rte)
{
rxw_sqns = (rxw_secs * rxw_max_rte) / r->max_tpdu;
}
g_ptr_array_set_size (r->pdata, rxw_sqns);
/* empty state:
*
* trail = 0, lead = -1
* commit_trail = commit_lead = rxw_trail = rxw_trail_init = 0
*/
r->lead = -1;
r->trail = r->lead + 1;
/* limit retransmit requests on late session joining */
r->is_rxw_constrained = TRUE;
r->is_window_defined = FALSE;
/* empty queue's for nak & ncfs */
r->backoff_queue = g_queue_new ();
r->wait_ncf_queue = g_queue_new ();
r->wait_data_queue = g_queue_new ();
/* statistics */
#if 0
r->min_fill_time = G_MAXINT;
r->max_fill_time = G_MININT;
r->min_nak_transmit_count = G_MAXINT;
r->max_nak_transmit_count = G_MININT;
#endif
#ifdef RXW_DEBUG
guint memory = sizeof(pgm_rxw_t) +
/* pointer array */
sizeof(GPtrArray) + sizeof(guint) +
*(guint*)( (char*)r->pdata + sizeof(gpointer) + sizeof(guint) ) +
/* pre-allocated data & packets */
( preallocate_size * (r->max_tpdu + sizeof(pgm_rxw_packet_t)) ) +
/* state queues */
3 * sizeof(GQueue) +
/* guess at timer */
4 * sizeof(int);
g_trace ("memory usage: %ub (%uMb)", memory, memory / (1024 * 1024));
#endif
ASSERT_RXW_BASE_INVARIANT(r);
ASSERT_RXW_POINTER_INVARIANT(r);
return r;
}
void
scratch_buffer_release(ScratchBuffer *sb)
{
g_trash_stack_push(&local_scratch_buffers, sb);
}
