void
queue_tail_del(struct queue * q)
{
if (!queue_is_empty(q)) {
queue_item_del(q->elems[q->tail]);
free(q->elems[q->tail]);
q->elems[q->tail] = NULL;
q->tail = (q->tail + 1) % q->max_size;
pthread_mutex_lock(&q->mux);
{
q->nr_elems--;
if (queue_is_empty(q))
pthread_cond_wait(&q->not_empty, &q->mux);
pthread_cond_signal(&q->not_full);
}
pthread_mutex_unlock(&q->mux);
}
}
} END_TEST
/* ************************************************************ */
/* bug tests */
/* ************************************************************ */
START_TEST(test_bug005562) {
/*
* BUG 005562: Segfault after sending REGISTER to an invalid address (no registrar aat this address) and waiting >30sec
*/
sipstack_event *event;
sipstack_init();
int counter = 0;
/* send REGISTER */
int regId =
sipstack_send_register("sip:"TEST_SIPSTACK_USER"@192.168.0.1", "sip:192.168.0.99", 1800);
fail_unless(regId > -1, "Sending REGISTER failed. (result = %i)", regId);
/* receive response */
while (queue_is_empty(event_queue) && counter < 60) {
sleep(1);
counter++;
}
fail_unless(!queue_is_empty(event_queue), TEST_SIPSTACK_PREFIX "No response for registering received.");
event = queue_front_and_dequeue(event_queue);
/* expect REGISTRATION_FAILURE (2) */
/* test failed*/
if(event->type != 2) {
/* free allocated memory before test fails */
sipstack_event_free(event);
}
fail_unless(event->type == 2,
"No event of type REGISTRATION_FAILURE received. (type = %i)", event->type);
sipstack_event_free(event);
sipstack_quit();
} END_TEST
void
floodfill(unsigned long * pixels, int x, int y, int width, int height,unsigned long color) {
printf("\nEntrando to floodfill\n");
queue *lista_xy;
lista_xy = queue_init();
int color_start = pixels[x + y * width];
if (color != color_start) {
queue_enqueue(x, lista_xy);
queue_enqueue(y, lista_xy);
pixels[x + y * width] = color;
while (!queue_is_empty(lista_xy)) {
if (x + 1 < width) {
if (pixels[(x + 1) + y * width] == color_start) {
pixels[(x + 1) + y * width] = color;
queue_enqueue(x+1, lista_xy);
queue_enqueue(y, lista_xy);
}
}
if (x - 1 >= 0){
if (pixels[(x - 1) + y * width] == color_start) {
pixels[(x - 1) + y * width] = color;
queue_enqueue(x-1, lista_xy);
queue_enqueue(y, lista_xy);
}
}
if (y + 1 < height){
if (pixels[x + (y + 1) * width] == color_start) {
pixels[x + (y + 1) * width] = color;
queue_enqueue(x, lista_xy);
queue_enqueue(y+1, lista_xy);
}
}
if (y - 1 >= 0){
if (pixels[x + (y - 1) * width] == color_start){
pixels[x + (y - 1) * width] = color;
queue_enqueue(x, lista_xy);
queue_enqueue(y-1, lista_xy);
}
}
x = lista_xy->front->info;
queue_dequeue(lista_xy);
y = lista_xy->front->info;
queue_dequeue(lista_xy);
}
}
queue_destroy(lista_xy);
}
void
queue_invert (queue *q)
{
if (queue_is_empty(q))
return;
pos c = queue_dequeue(q);
queue_invert(q);
queue_enqueue(q, c);
}
static void queue_insert_node(Queue *queue,
struct node *key) {
if (queue_is_empty(queue)) {
queue->head = key;
queue->tail = key;
} else {
queue->tail->next = key;
queue->tail = key;
}
}
/*!
* \brief
* Returns the key to the caller.
* If we have bt_wait flag set, it waits for the user choice.
*
* \param wait Wait for key flag
* \retval key pressed or -1(EOF) if none.
*/
keys_t btn_getkey (uint8_t wait)
{
keys_t ret=BTN_NULL;
// wait for user's action
while (wait && queue_is_empty (&btn_q))
;
queue_get (&btn_q, (void*)&ret);
return ret;
}
void *recExec() {
while (1) {
if (!queue_is_empty(pColaReady) && !queue_is_empty(pColaCpu)) {
sem_wait(&mut_r);
ptmp = queue_pop(pColaReady);
sem_post(&mut_r);
sem_wait(&mut_c);
pcpu = queue_pop(pColaCpu);
sem_post(&mut_c);
ptmp->cpuexec = pcpu;
//printf("Exec proceso %d tiempo cpu %d\n",ptmp->pid,tact);
sem_wait(&mut_e);
queue_push(pColaExec, ptmp);
sem_post(&mut_e);
}
}
}
/*!
* \brief
* This function gets a byte from queue.
* \param pointer to byte
* \return
* \arg 0 Empty queue
* \arg 1 Done
*/
__Os__ int queue_get (queue_t *queue, void *b)
{
if ( queue_is_empty (queue) ) //Empty queue
return 0;
memcpy (b, (const void*)&queue->buf[queue->head*queue->item_size], queue->item_size);
//rotate pointers
if ( ++queue->head >= queue->items )
queue->head = 0;
return 1;
}
void
playlist_update_queued_song(struct playlist *playlist,
struct player_control *pc,
const struct song *prev)
{
int next_order;
const struct song *next_song;
if (!playlist->playing)
return;
assert(!queue_is_empty(&playlist->queue));
assert((playlist->queued < 0) == (prev == NULL));
next_order = playlist->current >= 0
? queue_next_order(&playlist->queue, playlist->current)
: 0;
if (next_order == 0 && playlist->queue.random &&
!playlist->queue.single) {
/* shuffle the song order again, so we get a different
order each time the playlist is played
completely */
unsigned current_position =
queue_order_to_position(&playlist->queue,
playlist->current);
queue_shuffle_order(&playlist->queue);
/* make sure that the playlist->current still points to
the current song, after the song order has been
shuffled */
playlist->current =
queue_position_to_order(&playlist->queue,
current_position);
}
if (next_order >= 0)
next_song = queue_get_order(&playlist->queue, next_order);
else
next_song = NULL;
if (prev != NULL && next_song != prev) {
/* clear the currently queued song */
pc_cancel(pc);
playlist->queued = -1;
}
if (next_order >= 0) {
if (next_song != prev)
playlist_queue_song_order(playlist, pc, next_order);
else
playlist->queued = next_order;
}
}
uint32_t queue_get_ptr(queue_t * queue, uint8_t ** element)
{
if (queue_is_empty(queue))
return ERROR_NOT_FOUND;
*element = &queue->elements[queue->head * queue->element_size];
queue->head = (queue->head + 1u) % queue->size;
return SUCCESS;
}
void queue_cleanup(queue* q)
{
while(!queue_is_empty(q)){
queue_pop(q);
}
free(q->array);
sem_destroy(q->content_sem);
sem_destroy(q->freespace_sem);
pthread_mutex_destroy(q->mutex);
}
void queue_free (Queue* queue) {
/* Empty the queue */
while (!queue_is_empty (queue)) {
queue_pop_head (queue);
}
/* Free back the queue */
free (queue);
}
//-----------------------------------------------------------------
// need to use free() to free up memory
//-----------------------------------------------------------------
boolean_t queue_remove(queue_t q, queue_element_t * e) {
queue_link_t oldHead;
assert(q != NULL);
if(queue_is_empty(q))
return FALSE;
*e = q->head->e;
oldHead = q->head;
q->head = q->head->next;
return TRUE;
}
bool empty_queue(Queue *self) {
if (!self) {
return false;
}
while (!queue_is_empty(self)) {
int *popped = queue_pop_tail(self);
//printf("popped %d from queue\n", *popped);
free(popped);
}
return true;
}
int main()
{
int i;
queue q = queue_create();
assert(queue_is_empty(q));
queue_enqueue(q, 3);
assert(queue_dequeue(q) == 3);
assert(queue_is_empty(q));
for (i= 0; i < 99; i++) {
queue_enqueue(q, i);
}
assert(queue_is_full(q));
assert(queue_dequeue(q) == 0);
queue_enqueue(q, 1);
queue_enqueue(q, 1);
assert(queue_is_full(q));
queue_destroy(&q);
assert(q == NULL);
return 0;
}
void queue_reverse(queue* q) {
assert(q != NULL);
// If empty, do nothing.
if (queue_is_empty(q)) {
return;
}
queue_link* end = queue_reverse_helper(q, q->head);
end->next = NULL;
}
/*
* Dequeueing.
*/
void *dequeue() {
if(queue_is_empty()) {
printf("Fatal error: The queue is empty.\n");
exit(-1);
}
void *item;
item = queue[out_index];
out_index = (out_index+1) % memory_size;
return item;
}
int h2o_http2_scheduler_run(h2o_http2_scheduler_node_t *root, h2o_http2_scheduler_run_cb cb, void *cb_arg)
{
if (root->_queue != NULL) {
while (!queue_is_empty(root->_queue)) {
int bail_out = proceed(root, cb, cb_arg);
if (bail_out)
return bail_out;
}
}
return 0;
}
uint32_t queue_get(queue_t * queue, uint8_t * element)
{
if (queue_is_empty(queue))
return ERROR_NOT_FOUND;
memcpy(element, &queue->elements[queue->head * queue->element_size], queue->element_size);
queue->head = (queue->head + 1u) % queue->size;
return SUCCESS;
}
static void *
async_queue_timed_pop_unlocked(UAsyncQueue *queue, uint64_t end_time)
{
if (queue_is_empty(queue->queue)) {
assert(!queue->is_waiting);
++queue->is_waiting;
if (!end_time)
pthread_cond_wait(&queue->cond, &queue->mutex);
else {
struct timespec timeout;
timeout.tv_sec = end_time / 1000000;
timeout.tv_nsec = 1000 * (end_time % 1000000);
pthread_cond_timedwait(&queue->cond, &queue->mutex, &timeout);
}
--queue->is_waiting;
if (queue_is_empty(queue->queue))
return NULL;
}
return queue_pop(queue->queue);
}
pos
queue_start (queue *q)
{
if (queue_is_empty(q))
{
printf("ERROR: Empty queue. (start)\n");
return position(0,0);
}
return q->content[q->start];
}
BOOL dequeue(queue_t* queue, void* item) {
if (queue_is_empty(queue) == TRUE)
return FALSE;
memcpy(item,
(char*) queue->array_addr + (queue->item_size * queue->get_index),
queue->item_size);
queue->get_index = (queue->get_index + 1) % queue->max_item_count;
queue->last_op = QUEUE_DEQUEUE;
return TRUE;
}
static int
queue_read (volatile struct queue *q)
{
if (queue_is_empty (q))
return -1;
unsigned char c = q->data[q->start++];
q->length--;
if (q->start == sizeof q->data)
q->start = 0;
return c;
}
void queue_destroy(Queue *queue, void (*destroy)(void *))
{
void *data;
while(! queue_is_empty(queue)) {
data = queue_dequeue(queue);
if (destroy) {
destroy(data);
}
}
queue->counter = 0;
}
/** バディページから所定のオーダのページを取り出しページフレーム番号を返す
@param[in] buddy バディページ
@param[in] order 取得するページのオーダ
@param[out] pfnp 取得したページのページフレーム番号を返却する領域
@retval 0 正常にページを獲得した
@retval -EINVAL ページフレーム情報返却域が不正か要求したページオーダが不正
@retval -ENOMEM 空きページがない
*/
int
page_buddy_dequeue(page_buddy *buddy, page_order order, obj_cnt_type *pfnp){
page_order cur_order;
page_frame *cur_page;
kassert( spinlock_locked_by_self(&buddy->lock) );
if ( (pfnp == NULL) ||
(order >= PAGE_POOL_MAX_ORDER) )
return -EINVAL; /* ページフレーム情報返却域 or 要求したページオーダが不正 */
cur_order = order;
while (cur_order < PAGE_POOL_MAX_ORDER) { /* 空きページがあるキューを順番に調べる */
if ( !queue_is_empty(&buddy->page_list[cur_order]) ) {
cur_page = CONTAINER_OF(
queue_get_top(&buddy->page_list[cur_order]),
page_frame, link); /* 空きページを取り出す */
--buddy->free_nr[cur_order];
/* 空きページから要求オーダのページを切り出す */
cur_page = remove_page_from_page_queue(buddy,
cur_page, order, cur_order);
cur_page->state |= PAGE_CSTATE_USED; /* ページを使用中にする */
*pfnp = cur_page->pfn; /* ページフレーム番号を返却する */
if ( cur_page->order != order ) {
/* ページオーダが一致しない場合は内部整合性異常 */
kprintf(KERN_CRI, "Invalid order page is allocated:%p "
"pfn:%u flags=%x order:%d reqest-order:%d find:%d\n",
cur_page, cur_page->pfn, cur_page->state,
cur_page->order, order, cur_order);
kassert(0);
}
kassert( ( buddy->start_pfn <= cur_page->pfn ) &&
( cur_page->pfn < ( buddy->start_pfn + buddy->nr_pages ) ) );
return 0;
}
++cur_order; /* より上のオーダからページを切り出す */
}
return -ENOMEM;
}
enum playlist_result
playlist_play(struct playlist *playlist, struct player_control *pc,
int song)
{
unsigned i = song;
pc_clear_error(pc);
if (song == -1) {
/* play any song ("current" song, or the first song */
if (queue_is_empty(&playlist->queue))
return PLAYLIST_RESULT_SUCCESS;
if (playlist->playing) {
/* already playing: unpause playback, just in
case it was paused, and return */
pc_set_pause(pc, false);
return PLAYLIST_RESULT_SUCCESS;
}
/* select a song: "current" song, or the first one */
i = playlist->current >= 0
? playlist->current
: 0;
} else if (!queue_valid_position(&playlist->queue, song))
return PLAYLIST_RESULT_BAD_RANGE;
if (playlist->queue.random) {
if (song >= 0)
/* "i" is currently the song position (which
would be equal to the order number in
no-random mode); convert it to a order
number, because random mode is enabled */
i = queue_position_to_order(&playlist->queue, song);
if (!playlist->playing)
playlist->current = 0;
/* swap the new song with the previous "current" one,
so playback continues as planned */
queue_swap_order(&playlist->queue,
i, playlist->current);
i = playlist->current;
}
playlist->stop_on_error = false;
playlist->error_count = 0;
playlist_play_order(playlist, pc, i);
return PLAYLIST_RESULT_SUCCESS;
}
void* queue_pop(queue* q){
void* ret_payload;
if(queue_is_empty(q)){
return NULL;
}
ret_payload = q->array[q->front].payload;
q->array[q->front].payload = NULL;
q->front = ((q->front + 1) % q->maxSize);
return ret_payload;
}
int uartRx_getNb(uartRx_t *pThis, chunk_t *pChunk)
{
/* Block till a chunk arrives on the rx queue */
if( queue_is_empty(&pThis->queue) )
{
//printf("RX Queue is empty\r\n");
// powerMode_change(PWR_ACTIVE);
//asm("idle;");
return FAIL;
}
//powerMode_change(PWR_FULL_ON);
return uartRx_getChunk(pThis, pChunk);
}
pos
queue_dequeue (queue *q)
{
if (queue_is_empty(q))
{
printf("ERROR: Empty queue. (dequeue)\n");
return position(0,0);
}
pos e = queue_start(q); q->length--;
q->start = ++q->start % q->size;
return e;
}
/** スレッドキューの先頭のスレッドを取り出す
@param[in] q 操作対象キュー
@param[in] thrp キューの先頭スレッドを設定するポインタ変数のアドレス
@retval 取り出し後のスレッド格納数
@note キュー q のロックを呼出元で獲得しておき, キューが
空でないことを呼出元責任で保証すること
*/
int
tq_get_top(thread_queue *q, struct _thread **thrp) {
kassert( q != NULL);
kassert( spinlock_locked_by_self( &q->lock ) );
kassert( !queue_is_empty( &q->que ) );
*thrp = CONTAINER_OF( queue_get_top( &q->que ),
thread, link); /* キューからスレッドを取り出す */
--q->cnt; /* 取り出し後のキュー内のスレッド数を減算する */
return q->cnt; /* 取り出し後のキュー内のスレッド数を返却する */
}
