TEST_F(GQueueTest, popHeadLink)
{
int testData1 = 42;
int testData2 = 1337;
g_queue_push_tail(queue, &testData1);
g_queue_push_tail(queue, &testData2);
GList *head = g_queue_pop_head_link(queue);
ASSERT_TRUE(head != NULL) << "popped queue element should not be NULL";
ASSERT_EQ(&testData1, head->data) << "popped queue head should have correct value";
ASSERT_TRUE(head->next == NULL) << "poppoed queue head should not have a next element";
ASSERT_TRUE(head->prev == NULL) << "poppoed queue head should not have a next element";
ASSERT_TRUE(queue->head != NULL) << "queue head should not be NULL after removing one element";
ASSERT_EQ(queue->head, queue->tail) << "queue tail should be equal to head after removing one element";
ASSERT_TRUE(queue->head->next == NULL) << "queue element should not have a next element";
ASSERT_TRUE(queue->head->prev == NULL) << "queue element should not have a previous element";
ASSERT_EQ(1, queue->length) << "queue should have one element left after popping one";
g_list_free(head);
head = g_queue_pop_head_link(queue);
ASSERT_TRUE(head != NULL) << "popped queue element should not be NULL";
ASSERT_EQ(&testData2, head->data) << "popped queue head should have correct value";
ASSERT_TRUE(head->next == NULL) << "poppoed queue head should not have a next element";
ASSERT_TRUE(head->prev == NULL) << "poppoed queue head should not have a next element";
ASSERT_TRUE(queue->head == NULL) << "queue head should be NULL after popping another element";
ASSERT_TRUE(queue->tail == NULL) << "queue tail should be NULL after popping another element";
ASSERT_EQ(0, queue->length) << "queue length should be zero after popping another element";
g_list_free(head);
head = g_queue_pop_head_link(queue);
ASSERT_TRUE(head == NULL) << "popped queue element of empty queue should be NULL";
}
/* steal the first chunk from in and append it to out, return number of bytes stolen */
goffset li_chunkqueue_steal_chunk(liChunkQueue *out, liChunkQueue *in) {
liChunk *c;
goffset length;
GList *l = g_queue_pop_head_link(&in->queue);
if (!l) return 0;
g_queue_push_tail_link(&out->queue, l);
c = (liChunk*) l->data;
length = li_chunk_length(c);
in->bytes_out += length;
in->length -= length;
out->bytes_in += length;
out->length += length;
if (in->limit != out->limit) {
if (c->type == STRING_CHUNK) {
cqlimit_update(out, c->data.str->len);
cqlimit_update(in, - (goffset)c->data.str->len);
} else if (c->type == MEM_CHUNK) {
cqlimit_update(out, c->mem->len);
cqlimit_update(in, - (goffset)c->mem->len);
} else if (c->type == BUFFER_CHUNK) {
cqlimit_update(out, c->data.buffer.length);
cqlimit_update(in, - (goffset)c->data.buffer.length);
}
}
return length;
}
static void job_queue_run(liJobQueue* jq, int loops) {
int i;
for (i = 0; i < loops; i++) {
GQueue *q = &jq->queue;
GList *l;
liJob *job;
guint todo = q->length;
INC_GEN(jq);
if (0 == todo) return;
while ((todo-- > 0) && (NULL != (l = g_queue_pop_head_link(q)))) {
job = LI_CONTAINER_OF(l, liJob, link);
job->generation = jq->generation;
job->link.data = NULL;
job->callback(job);
}
}
if (jq->queue.length > 0) {
/* make sure we will run again soon */
li_event_timer_once(&jq->queue_watcher, 0);
}
}
/**
* rtp_jitter_buffer_flush:
* @jbuf: an #RTPJitterBuffer
* @free_func: function to free each item
* @user_data: user data passed to @free_func
*
* Flush all packets from the jitterbuffer.
*/
void
rtp_jitter_buffer_flush (RTPJitterBuffer * jbuf, GFunc free_func,
gpointer user_data)
{
GList *item;
g_return_if_fail (jbuf != NULL);
g_return_if_fail (free_func != NULL);
while ((item = g_queue_pop_head_link (jbuf->packets)))
free_func ((RTPJitterBufferItem *) item, user_data);
}
static void explorer_prune_history (Explorer* self, int max_nodes)
{
while (self->history_queue->length > max_nodes) {
GList* link = g_queue_pop_head_link(self->history_queue);
if (!link)
break;
if (link == self->history_current_link)
self->history_current_link = NULL;
history_node_free(link->data);
g_list_free_1(link);
}
}
static void throttle_pool_rearm(liWorker *wrk, liThrottlePool *pool, guint now) {
liThrottlePoolWorkerState *wpool = &pool->workers[wrk->ndx];
guint last = g_atomic_int_get((gint*) &pool->last_rearm);
guint time_diff = now - last;
if (G_UNLIKELY(time_diff >= LI_THROTTLE_GRANULARITY)) {
g_mutex_lock(pool->rearm_mutex);
/* check again */
last = g_atomic_int_get((gint*) &pool->last_rearm);
time_diff = now - last;
if (G_LIKELY(time_diff >= LI_THROTTLE_GRANULARITY)) {
S_throttle_pool_rearm_workers(pool, wrk->srv->worker_count, time_diff);
g_atomic_int_set((gint*) &pool->last_rearm, now);
}
g_mutex_unlock(pool->rearm_mutex);
}
if (G_UNLIKELY(wpool->last_rearm < last)) {
/* distribute wpool->magazine */
GList *lnk;
guint connections = wpool->connections;
gint magazine = g_atomic_int_get(&wpool->magazine);
gint supply = magazine / connections;
g_atomic_int_add(&wpool->magazine, -supply * connections);
wpool->last_rearm = now;
throttle_debug("throttle_pool_rearm: distribute supply %i on each of %i connections\n",
supply, connections);
if (0 == supply) return;
g_atomic_int_set((gint*) &wpool->connections, 0);
while (NULL != (lnk = g_queue_pop_head_link(&wpool->waiting))) {
liThrottlePoolState *pstate = LI_CONTAINER_OF(lnk, liThrottlePoolState, pool_link);
pstate->magazine += supply;
lnk->data = NULL;
}
}
}
GList *
tracker_priority_queue_pop_node (TrackerPriorityQueue *queue,
gint *priority_out)
{
PrioritySegment *segment;
GList *node;
g_return_val_if_fail (queue != NULL, NULL);
node = g_queue_peek_head_link (&queue->queue);
if (!node) {
/* No elements in queue */
return NULL;
}
segment = &g_array_index (queue->segments, PrioritySegment, 0);
g_assert (segment->first_elem == node);
if (priority_out) {
*priority_out = segment->priority;
}
if (segment->last_elem == node) {
/* It is the last element of the first
* segment, remove segment as well.
*/
g_array_remove_index (queue->segments, 0);
} else {
/* Move segments first element forward */
segment->first_elem = segment->first_elem->next;
}
return g_queue_pop_head_link (&queue->queue);
}
/* steal up to length bytes from in and put them into out, return number of bytes stolen */
goffset li_chunkqueue_steal_len(liChunkQueue *out, liChunkQueue *in, goffset length) {
liChunk *c, *cnew;
GList* l;
goffset bytes = 0, meminbytes = 0, memoutbytes = 0;
goffset we_have;
while ( (NULL != (c = li_chunkqueue_first_chunk(in))) && length > 0 ) {
we_have = li_chunk_length(c);
if (!we_have) { /* remove empty chunks */
if (c->type == STRING_CHUNK) meminbytes -= c->data.str->len;
else if (c->type == MEM_CHUNK) meminbytes -= c->mem->len;
else if (c->type == BUFFER_CHUNK) meminbytes -= c->data.buffer.length;
chunk_free(in, c);
continue;
}
if (we_have <= length) { /* move complete chunk */
l = g_queue_pop_head_link(&in->queue);
g_queue_push_tail_link(&out->queue, l);
bytes += we_have;
if (c->type == STRING_CHUNK) {
meminbytes -= c->data.str->len;
memoutbytes += c->data.str->len;
} else if (c->type == MEM_CHUNK) {
meminbytes -= c->mem->len;
memoutbytes += c->mem->len;
} else if (c->type == BUFFER_CHUNK) {
meminbytes -= c->data.buffer.length;
memoutbytes += c->data.buffer.length;
}
length -= we_have;
} else { /* copy first part of a chunk */
cnew = chunk_new();
switch (c->type) {
case UNUSED_CHUNK: /* impossible, has length 0 */
/* remove "empty" chunks */
chunk_free(in, c);
chunk_free(NULL, cnew);
continue;
case STRING_CHUNK: /* change type to MEM_CHUNK, as we copy it anyway */
cnew->type = MEM_CHUNK;
cnew->mem = g_byte_array_sized_new(length);
g_byte_array_append(cnew->mem, (guint8*) c->data.str->str + c->offset, length);
memoutbytes += length;
break;
case MEM_CHUNK:
cnew->type = MEM_CHUNK;
cnew->mem = g_byte_array_sized_new(length);
g_byte_array_append(cnew->mem, (guint8*) c->mem->data + c->offset, length);
memoutbytes += length;
break;
case FILE_CHUNK:
cnew->type = FILE_CHUNK;
li_chunkfile_acquire(c->data.file.file);
cnew->data.file.file = c->data.file.file;
cnew->data.file.start = c->data.file.start + c->offset;
cnew->data.file.length = length;
break;
case BUFFER_CHUNK:
cnew->type = BUFFER_CHUNK;
li_buffer_acquire(c->data.buffer.buffer);
cnew->data.buffer.buffer = c->data.buffer.buffer;
cnew->data.buffer.offset = c->data.buffer.offset + c->offset;
cnew->data.buffer.length = length;
memoutbytes += length;
break;
}
c->offset += length;
bytes += length;
length = 0;
g_queue_push_tail_link(&out->queue, &cnew->cq_link);
}
}
in->bytes_out += bytes;
in->length -= bytes;
out->bytes_in += bytes;
out->length += bytes;
cqlimit_update(out, memoutbytes);
cqlimit_update(in, meminbytes);
return bytes;
}
void
sql_reserved_query_rebuild(sql_reserved_query *srq, gint max_query_num)
{
GQueue *gq = NULL;
GList *travel_list = NULL;
gint i = 0, remove_item_num = 0, time_interval = 0;
reserved_query_item *rm_rqi = NULL;
time_t cur_time = time(NULL);
g_assert(max_query_num >= 0);
g_rw_lock_writer_lock(&srq->rq_lock);
if (srq == NULL) goto exit;
if (srq->ht_reserved_query == NULL) goto exit ;
remove_item_num = g_queue_get_length(srq->gq_reserved_short_query);
remove_item_num += g_queue_get_length(srq->gq_reserved_long_query);
remove_item_num -= max_query_num;
if (remove_item_num <= 0) goto exit;
/* 4 roll lru */
for(i = 0; i < 4; i++)
{
gq = (i%2 == 0) ? srq->gq_reserved_short_query : srq->gq_reserved_long_query;
if (g_queue_get_length(gq) == 0) continue;
travel_list = g_queue_peek_head_link(gq);
while (travel_list != NULL)
{
rm_rqi = (reserved_query_item *)travel_list->data;
g_assert(rm_rqi->list_pos == travel_list);
if (i < 2 && max_query_num != 0)
{
time_interval = cur_time - rm_rqi->item_last_access_time;
if (time_interval < g_atomic_int_get(&srq->freq_time_window))
{
break;
}
}
#ifdef FILTER_DEBUG
g_debug("[reserved query][lru remove][%s]", rm_rqi->item_rewrite->str);
#endif
travel_list = g_queue_pop_head_link(gq);
g_hash_table_remove(srq->ht_reserved_query, rm_rqi->item_rewrite_md5->str);
g_list_free(travel_list);
travel_list = NULL;
if (remove_item_num-- == 0) goto exit;
travel_list = g_queue_peek_head_link(gq);
}
}
exit :
#ifdef FILTER_DEBUG
g_queue_travel(srq->gq_reserved_long_query);
g_queue_travel(srq->gq_reserved_short_query);
#endif
g_rw_lock_writer_unlock(&srq->rq_lock);
return ;
}
int main()
{
GQueue *q;
GList *node;
gpointer data;
q = g_queue_new ();
g_assert (g_queue_is_empty (q) == TRUE);
g_queue_push_head (q, GINT_TO_POINTER (2));
g_assert (g_queue_peek_head (q) == GINT_TO_POINTER (2));
g_assert (g_queue_is_empty (q) == FALSE);
g_assert (g_list_length (q->head) == 1);
g_assert (q->head == q->tail);
g_queue_push_head (q, GINT_TO_POINTER (1));
g_assert (q->head->next == q->tail);
g_assert (q->tail->prev == q->head);
g_assert (g_list_length (q->head) == 2);
g_assert (q->tail->data == GINT_TO_POINTER (2));
g_assert (q->head->data == GINT_TO_POINTER (1));
g_queue_push_tail (q, GINT_TO_POINTER (3));
g_assert (g_list_length (q->head) == 3);
g_assert (q->head->data == GINT_TO_POINTER (1));
g_assert (q->head->next->data == GINT_TO_POINTER (2));
g_assert (q->head->next->next == q->tail);
g_assert (q->head->next == q->tail->prev);
g_assert (q->tail->data == GINT_TO_POINTER (3));
g_queue_push_tail (q, GINT_TO_POINTER (4));
g_assert (g_list_length (q->head) == 4);
g_assert (q->head->data == GINT_TO_POINTER (1));
g_assert (g_queue_peek_tail (q) == GINT_TO_POINTER (4));
g_queue_push_tail (q, GINT_TO_POINTER (5));
g_assert (g_list_length (q->head) == 5);
g_assert (g_queue_is_empty (q) == FALSE);
g_assert (q->length == 5);
g_assert (q->head->prev == NULL);
g_assert (q->head->data == GINT_TO_POINTER (1));
g_assert (q->head->next->data == GINT_TO_POINTER (2));
g_assert (q->head->next->next->data == GINT_TO_POINTER (3));
g_assert (q->head->next->next->next->data == GINT_TO_POINTER (4));
g_assert (q->head->next->next->next->next->data == GINT_TO_POINTER (5));
g_assert (q->head->next->next->next->next->next == NULL);
g_assert (q->head->next->next->next->next == q->tail);
g_assert (q->tail->data == GINT_TO_POINTER (5));
g_assert (q->tail->prev->data == GINT_TO_POINTER (4));
g_assert (q->tail->prev->prev->data == GINT_TO_POINTER (3));
g_assert (q->tail->prev->prev->prev->data == GINT_TO_POINTER (2));
g_assert (q->tail->prev->prev->prev->prev->data == GINT_TO_POINTER (1));
g_assert (q->tail->prev->prev->prev->prev->prev == NULL);
g_assert (q->tail->prev->prev->prev->prev == q->head);
g_assert (g_queue_peek_tail (q) == GINT_TO_POINTER (5));
g_assert (g_queue_peek_head (q) == GINT_TO_POINTER (1));
g_assert (g_queue_pop_head (q) == GINT_TO_POINTER (1));
g_assert (g_list_length (q->head) == 4 && q->length == 4);
g_assert (g_queue_pop_tail (q) == GINT_TO_POINTER (5));
g_assert (g_list_length (q->head) == 3);
g_assert (g_queue_pop_head_link (q)->data == GINT_TO_POINTER (2));
g_assert (g_list_length (q->head) == 2);
g_assert (g_queue_pop_tail (q) == GINT_TO_POINTER (4));
g_assert (g_list_length (q->head) == 1);
g_assert (g_queue_pop_head_link (q)->data == GINT_TO_POINTER (3));
g_assert (g_list_length (q->head) == 0);
g_assert (g_queue_pop_tail (q) == NULL);
g_assert (g_list_length (q->head) == 0);
g_assert (g_queue_pop_head (q) == NULL);
g_assert (g_list_length (q->head) == 0);
g_assert (g_queue_is_empty (q) == TRUE);
/************************/
g_queue_push_head (q, GINT_TO_POINTER (1));
g_assert (g_list_length (q->head) == 1 && 1 == q->length);
g_queue_push_head (q, GINT_TO_POINTER (2));
g_assert (g_list_length (q->head) == 2 && 2 == q->length);
g_queue_push_head (q, GINT_TO_POINTER (3));
g_assert (g_list_length (q->head) == 3 && 3 == q->length);
g_queue_push_head (q, GINT_TO_POINTER (4));
g_assert (g_list_length (q->head) == 4 && 4 == q->length);
g_queue_push_head (q, GINT_TO_POINTER (5));
g_assert (g_list_length (q->head) == 5 && 5 == q->length);
g_assert (g_queue_pop_head (q) == GINT_TO_POINTER (5));
g_assert (g_list_length (q->head) == 4);
node = q->tail;
g_assert (node == g_queue_pop_tail_link (q));
g_assert (g_list_length (q->head) == 3);
data = q->head->data;
g_assert (data == g_queue_pop_head (q));
g_assert (g_list_length (q->head) == 2);
g_assert (g_queue_pop_tail (q) == GINT_TO_POINTER (2));
g_assert (g_list_length (q->head) == 1);
g_assert (q->head == q->tail);
g_assert (g_queue_pop_tail (q) == GINT_TO_POINTER (3));
g_assert (g_list_length (q->head) == 0);
g_assert (g_queue_pop_head (q) == NULL);
g_assert (g_queue_pop_head_link (q) == NULL);
g_assert (g_list_length (q->head) == 0);
g_assert (g_queue_pop_tail_link (q) == NULL);
g_assert (g_list_length (q->head) == 0);
g_queue_free (q);
return 0;
}
static void
_eventd_nd_notification_refresh_list(EventdPluginContext *context, EventdNdQueue *queue)
{
if ( queue->more_notification != NULL )
{
g_queue_pop_tail_link(queue->queue);
queue->more_notification->visible = FALSE;
}
while ( ( g_queue_get_length(queue->queue) < queue->limit ) && ( ! g_queue_is_empty(queue->wait_queue) ) )
{
GList *link;
link = g_queue_pop_head_link(queue->wait_queue);
if ( queue->reverse )
g_queue_push_tail_link(queue->queue, link);
else
g_queue_push_head_link(queue->queue, link);
EventdNdNotification *self = link->data;
gint timeout;
timeout = eventd_nd_style_get_bubble_timeout(self->style);
if ( timeout > 0 )
self->timeout = g_timeout_add_full(G_PRIORITY_DEFAULT, timeout, _eventd_nd_event_timedout, self, NULL);
self->visible = TRUE;
}
if ( queue->more_indicator )
{
if ( ! g_queue_is_empty(queue->wait_queue) )
{
if ( queue->more_notification == NULL )
queue->more_notification = eventd_nd_notification_new(context, NULL, context->style);
else
{
_eventd_nd_notification_update(queue->more_notification, NULL);
g_queue_push_tail_link(queue->queue, queue->more_notification->link);
}
queue->more_notification->visible = TRUE;
}
else if ( queue->more_notification != NULL )
eventd_nd_notification_free(queue->more_notification);
}
gpointer data = NULL;
if ( context->backend->move_begin != NULL )
data = context->backend->move_begin(context->backend->context, g_queue_get_length(queue->queue));
gboolean right, center, bottom;
right = ( queue->anchor == EVENTD_ND_ANCHOR_TOP_RIGHT ) || ( queue->anchor == EVENTD_ND_ANCHOR_BOTTOM_RIGHT );
center = ( queue->anchor == EVENTD_ND_ANCHOR_TOP ) || ( queue->anchor == EVENTD_ND_ANCHOR_BOTTOM );
bottom = ( queue->anchor == EVENTD_ND_ANCHOR_BOTTOM_LEFT ) || ( queue->anchor == EVENTD_ND_ANCHOR_BOTTOM ) || ( queue->anchor == EVENTD_ND_ANCHOR_BOTTOM_RIGHT );
gint bx, by;
bx = queue->margin_x;
by = queue->margin_y;
if ( center )
bx = context->geometry.w;
else if ( right )
bx = context->geometry.w - bx;
if ( bottom )
by = context->geometry.h - by;
GList *self_;
for ( self_ = g_queue_peek_head_link(queue->queue) ; self_ != NULL ; self_ = g_list_next(self_) )
{
EventdNdNotification *self = self_->data;
if ( bottom )
by -= self->border_size.height;
gint x, y;
x = center ? ( ( bx / 2 ) - ( self->border_size.width / 2 ) ) : right ? ( bx - self->border_size.width ) : bx;
y = by;
x -= self->offset.x;
y -= self->offset.y;
context->backend->move_surface(self->surface, x, y, data);
if ( bottom )
by -= queue->spacing;
else
by += self->border_size.height + queue->spacing;
}
if ( context->backend->move_end != NULL )
context->backend->move_end(context->backend->context, data);
}
