std::pair<void*, int> cast_graph::impl::cast(
void* const p, class_id src, class_id target
, class_id dynamic_id, void const* dynamic_ptr) const
{
if (src == target)
return std::make_pair(p, 0);
if (src >= m_vertices.size() || target >= m_vertices.size())
return std::pair<void*, int>((void*)0, -1);
std::ptrdiff_t const object_offset =
(char const*)dynamic_ptr - (char const*)p;
cache_entry cached = m_cache.get(src, target, dynamic_id, object_offset);
if (cached.first != cache::unknown)
{
if (cached.first == cache::invalid)
return std::pair<void*, int>((void*)0, -1);
return std::make_pair((char*)p + cached.first, cached.second);
}
std::queue<queue_entry> q;
q.push(queue_entry(p, src, 0));
boost::dynamic_bitset<> visited(m_vertices.size());
while (!q.empty())
{
queue_entry const qe = q.front();
q.pop();
visited[qe.vertex_id] = true;
vertex const& v = m_vertices[qe.vertex_id];
if (v.id == target)
{
m_cache.put(
src, target, dynamic_id, object_offset
, (char*)qe.p - (char*)p, qe.distance
);
return std::make_pair(qe.p, qe.distance);
}
BOOST_FOREACH(edge const& e, v.edges)
{
if (visited[e.target])
continue;
if (void* casted = e.cast(qe.p))
q.push(queue_entry(casted, e.target, qe.distance + 1));
}
}
m_cache.put(src, target, dynamic_id, object_offset, cache::invalid, -1);
return std::pair<void*, int>((void*)0, -1);
}
void coap_check_timeouts(coap_endpoint_mgr_t * p_endpoint_mgr, int i)
{
struct queue_hdr_t *p = NULL, *next = NULL;
coap_endpoint_t * p_endpoint = coap_get_endpoint(p_endpoint_mgr, i);
if (NULL == p_endpoint)
{
return;
}
for (p = p_endpoint->m_send_queue.next; p != &p_endpoint->m_send_queue; p = next)
{
coap_pkt_t * p_pkt = queue_entry(p, coap_pkt_t, node);
next = p->next;
if (p_pkt->last_transmit_time + p_pkt->retransmit_interval < p_endpoint_mgr->m_endpoint_mgr_time_cache)
{
if (p_pkt->retransmit_count < COAP_MAX_RETRANSMIT)
{
coap_log_debug_packet((char *)p_pkt);
sendto(p_endpoint->m_servsock, (const char *)&p_pkt->hdr, p_pkt->packet_length, 0, (struct sockaddr *)&p_endpoint->m_servaddr, sizeof(p_endpoint->m_servaddr));
p_pkt->last_transmit_time = coap_get_milliseconds();
p_pkt->retransmit_interval <<= 1;
p_pkt->retransmit_count++;
}
else
{
coap_free_endpoint(p_endpoint_mgr, i);
coap_set_endpoint(p_endpoint_mgr, i, NULL);
break;
}
}
}
return;
}
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;
}
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;
}
/**
* Empties out a queue in the task queue by dequeuing and freeing
* every task.
*/
static void tq_empty_queue(queue_t* q)
{
do {
tq_entry_t *entry;
queue_elem_t *queue_elem;
if (queue_pop_front (q, &queue_elem) == 0)
break;
entry = queue_entry (queue_elem, tq_entry_t, queue_elem);
assert (entry != NULL);
phoenix_mem_free (entry);
} while (1);
}
static void *consumer(void *argc)
{
data_queue_t *datas = (data_queue_t *)argc;
while(1)
{
queue_body_t *pos = queue_get_front(datas->head);
if( pos ==NULL )
{
/*
* here we do wait
*/
sleep(1);
continue;
}
data_t *entry = queue_entry(pos,data_t,next);
int l = entry->length;
pomme_buffer_release(datas->buffer,entry->data_begin,l);
free(entry);
}
return NULL;
}
static void * thread_routine(void *arg)
{
routine_arg *info = arg;
info->tid = pthread_self();
pomme_tpool_t *ptp = info->ptp;
while(1)
{
sem_wait(&ptp->sem);
queue_body_t *wr = queue_get_front(ptp->workers);
pomme_worker_t *w = queue_entry(wr,pomme_worker_t,next);
/* The sem make this assert true */
assert( w!=NULL );
if(w->process == NULL )
{
/* exit from the thread pool */
ptp->tids[info->rank] = 0;
thread_ids_t *ids = malloc(sizeof(thread_ids_t));
assert( ids != NULL );
memset(ids, 0, sizeof(thread_ids_t));
ids->rank = info->rank;
queue_push_back(ptp->finished,&ids->next);
free(w);
break;
}
w->process(w->arg);
free(w->arg);
free(w);
}
free(info);
//TODO use lock?
return NULL;
}
static int add_thread(pomme_tpool_t *ptp)
{
int ret = 0;
if( ptp->cur_thread_num >= ptp->max_thread_num )
{
debug("exceed max");
return POMME_TOO_MANY_THREAD;
}
queue_body_t *id = queue_get_front( ptp->finished );
thread_ids_t *ids = queue_entry(id, thread_ids_t, next);
assert( ids != NULL );
routine_arg arg;
arg.rank = ids->rank;
if( ( ret = pthread_create(ptp->tids+ids->rank, NULL,
ptp->thread_routine, &arg )) < 0 )
{
debug("create thread %d fail %s",ret, strerror(ret));
}else{
ptp->cur_thread_num++;
}
free(ids);
return ret;
}
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;
}
static inline int tq_dequeue_normal_internal (
taskQ_t* tq, task_t* task, int lgrp, int tid, dequeue_fn dequeue_fn)
{
int i, ret, index;
queue_elem_t *queue_elem;
tq_entry_t *entry;
assert (task != NULL);
mem_memset (task, 0, sizeof (task_t));
index = (lgrp < 0) ? rand_r(&tq->seeds[tid]) : lgrp;
index %= tq->num_queues;
ret = (*dequeue_fn)(tq, index, tid, &queue_elem);
/* Do task stealing if nothing on our queue.
Cycle through all indexes until success or exhaustion */
for (i = (index + 1) % tq->num_queues;
(ret == 0) && (i != index);
i = (i + 1) % tq->num_queues)
{
ret = (*dequeue_fn)(tq, i, tid, &queue_elem);
}
if (ret == 0) {
/* There really is no more work. */
return 0;
}
entry = queue_entry (queue_elem, tq_entry_t, queue_elem);
assert (entry != NULL);
mem_memcpy (task, &entry->task, sizeof (task_t));
return 1;
}
