void *
consume_from_render_queue(void *q)
{
    RenderQueue *render_queue = (RenderQueue *)q;

    while (true)
    {
        pthread_mutex_lock(&render_queue->mut);

        while (render_queue->empty)
        {
            log(L_RenderQueue, "consumer: queue EMPTY.");
            pthread_cond_wait(&render_queue->not_empty, &render_queue->mut);
        }

        RenderQueueData render_data;
        queue_del(render_queue, &render_data);

        pthread_mutex_unlock(&render_queue->mut);
        pthread_cond_signal(&render_queue->not_full);

        consume_render_operations(render_data.frame_buffer, render_data.render_operations, render_data.clip_region);
        log(L_RenderQueue, "consumer: recieved.");
    }

    return 0;
}
int coap_recv_queue_pop_node(coap_endpoint_t * p_endpoint, char * buffer, size_t len)
{
	coap_pkt_t * p_pkt = NULL;
	int ret = 0;

	assert(p_endpoint);
	assert(buffer);
	assert(len > 0);

	if (queue_is_empty(&p_endpoint->m_recv_queue))
	{
		return 0;
	}
	
	p_pkt = queue_entry(p_endpoint->m_recv_queue.next, coap_pkt_t, node);
	
	if (p_pkt->packet_length > len)
	{
		coap_log_debug_string("output buffer is too small to store the packet!\r\n");
		return COAP_RET_BUFFER_TOO_SMALL;
	}
	
	memcpy(buffer, &p_pkt->hdr, p_pkt->packet_length);
	ret = p_pkt->packet_length;
	queue_del(&p_pkt->node);
	free(p_pkt);
	p_endpoint->m_recv_queue_pkt_num--;
	
	return ret;
}
示例#3
0
int lifo_out(link *head){
	if (queue_empty(head))
		return -1;
	elem *mem=queue_bottom(head,elem,suiv);
	int val=mem->val;
	queue_del(mem,suiv);
	mem_free(mem,sizeof(elem));
	return val;
}
int coap_free_endpoint(coap_endpoint_mgr_t * p_endpoint_mgr, int i)
{
	int ret = 0;
	coap_pkt_t * p_pkt = NULL;
	
	coap_endpoint_t * p_endpoint = coap_get_endpoint(p_endpoint_mgr, i);
	if (NULL == p_endpoint)
	{
		return COAP_RET_INVALID_PARAMETERS;
	}

	while (!queue_is_empty(&p_endpoint->m_send_queue)) 
	{
		p_pkt = queue_entry(p_endpoint->m_send_queue.next, coap_pkt_t, node);
		queue_del(&p_pkt->node);
		free(p_pkt);
	}
	
	while (!queue_is_empty(&p_endpoint->m_recv_queue))
	{
		p_pkt = queue_entry(p_endpoint->m_recv_queue.next, coap_pkt_t, node);
		queue_del(&p_pkt->node);
		free(p_pkt);
	}

	mutex_uninit(&p_endpoint->m_send_mutex);
	mutex_uninit(&p_endpoint->m_recv_mutex);

	free(p_endpoint);

	ret = coap_set_endpoint(p_endpoint_mgr, i, NULL);
	if (ret < 0)
	{
		return ret;
	}

	return 0;
}
示例#5
0
文件: network.c 项目: 0x0d/lrc
static struct netqueue *queue_get_slot(struct priv_net *pn)
{
	struct netqueue *q = pn->pn_queue_free.q_next;

	if (q != &pn->pn_queue_free) {
		queue_del(q);
		return q;
	}

	if (pn->pn_queue_len++ > QUEUE_MAX)
		return NULL;

	return malloc(sizeof(*q));
}
示例#6
0
文件: network.c 项目: 0x0d/lrc
static int queue_get(struct priv_net *pn, void *buf, int len)
{
	struct netqueue *head = &pn->pn_queue;
	struct netqueue *q = head->q_next;

	if (q == head)
		return 0;

	assert(q->q_len <= len);
	memcpy(buf, q->q_buf, q->q_len);

	queue_del(q);
	queue_add(&pn->pn_queue_free, q);

	return q->q_len;
}
示例#7
0
文件: 4.35.c 项目: aquarhead/ZJU2011
int main() {
    
    bt_node *tmp;
    queue *q = queue_init();
    binary_tree *bt = malloc(sizeof(bt_node));
    bt->Element = 0;
    bt->left = malloc(sizeof(bt_node));
    bt->left->Element = 1;
    bt->right = malloc(sizeof(bt_node));
    bt->right->Element = 2;
    tmp = bt->left;
    tmp->left = malloc(sizeof(bt_node));
    tmp->left->Element = 3;
    tmp->right = malloc(sizeof(bt_node));
    tmp->right->Element = 4;
    tmp = tmp->left;
    tmp->left = nil;
    tmp->right = malloc(sizeof(bt_node));
    tmp->right->Element = 6;
    tmp = tmp->right;
    tmp->left = nil;
    tmp->right = nil;
    tmp = bt->left->right;
    tmp->left = nil;
    tmp->right = nil;
    tmp = bt->right;
    tmp->left = malloc(sizeof(bt_node));
    tmp->left->Element = 5;
    tmp->right = nil;
    tmp = tmp->left;
    tmp->left = nil;
    tmp->right = nil;
    
    queue_add(bt, q);
    while (!setjmp(buf)) {
        tmp = queue_del(q);
        printf("visited node index: %d\n", tmp->Element);
        if (tmp->left != nil) {
            queue_add(tmp->left, q);
        }
        if (tmp->right != nil) {
            queue_add(tmp->right, q);
        }
    }
    
    return 0;
}
int coap_send_queue_del_node(coap_endpoint_t * p_endpoint, uint16 message_id)
{
	coap_pkt_t * p_pkt = NULL;
	queue_hdr_t * p = NULL;
	queue_hdr_t * next = NULL;

	assert(p_endpoint);
	
	for (p = p_endpoint->m_send_queue.next; p != &p_endpoint->m_send_queue; p = next)
	{
		p_pkt = queue_entry(p, coap_pkt_t, node);
		next = p->next;
		if (p_pkt->hdr.message_id == message_id) 
		{
			queue_del(&p_pkt->node);
			free(p_pkt);
			p_endpoint->m_send_queue_pkt_num--;		
			return 0;
		}
	}

	return -1;
}
示例#9
0
static void Queue__del(void **queue, void **player){
   struct command com;
    queue_t * q = queue_new();
    player_t * pl[1];
    pl[0] = player_new('w', 's', 'd', 'a', 'f');
    char index = 'w';
    char * moves;
    moves = player_get_moves(pl[0]);
    for (int a = 0; a < 100; a++){
    for (int i = 0; i < 5; i++){
    if (moves[i] == index)
                    {
                        i++;
                        com.command = i;
                        com.players = pl[i];
                        queue_add(q, com);
                    }
    }
    }
    queue_del(q);
    assert_int_equal(queue_size(q),99);
    queue_remove(&q);
    player_remove(&pl);
}
示例#10
0
int main() {
    int i = 0;
    char c;

    queue_t* firstQueue = queue_create();
    queue_t* secondQueue = queue_create();

    while (1) {
        scanf("%c", &c);
        if (c == '+') {
            scanf("%c", &c);

            if (c == '1') {
                firstQueue = queue_add(firstQueue);
            }
            if (c == '2') {
                secondQueue = queue_add(secondQueue);
            }
        }
        if (c == '-') {
            scanf("%c", &c);

            if (c == '1') {
                firstQueue = queue_del(firstQueue);
            }
            if (c == '2') {
                secondQueue = queue_del(secondQueue);
            }
        }
        if (c == 'c') {
            firstQueue = queue_concat(firstQueue, secondQueue);

            /** WARNING: ????
             * Возможно тут имелось ввиду освобождение памяти?
             */
            secondQueue = NULL;
            secondQueue = queue_create();
        }
        if (c == 's') {
            scanf("%c", &c);

            if (c == '1') {
                firstQueue = queue_sort(firstQueue);
            }
            if (c == '2') {
                secondQueue = queue_sort(secondQueue);
            }
        }
        if (c == 'q') {
            printf("Bye\n");
            break;
        }
        if (c == 'p') {
            scanf("%c", &c);
            if (c == '1')
                queue_print(firstQueue);
            if (c == '2')
                queue_print(secondQueue);
        }
    }

    return 0;
}