void *cache_malloc(cache_head_t *cache)
{
cache_node_t *a_node;
queue_t *queue;
if (!queue_empty(&cache->free_que))
{
queue = queue_next(&cache->free_que);
queue_remove(queue);
a_node = queue_data(queue, cache_node_t, next);
queue_insert_head(&cache->used_que, queue);
cache->nr_used++;
cache->nr_free--;
/*set the memory to zero*/
memset(a_node->data, 0, cache->size);
return a_node->data;
}
else
{
size_t len = cache->size + sizeof(cache_node_t);
a_node = Malloc(len);
queue_insert_head(&cache->used_que, &a_node->next);
a_node->data = (void *)(a_node+1);
/*set the memory to zero*/
memset(a_node->data, 0, cache->size);
cache->nr_used++;
return a_node->data;
}
}
void httproute_callback_add(HttpServer *server,char *path,HttpRouteCallback func,void *arg)
{
HttpRoute *route=NULL;
route = malloc(sizeof(HttpRoute));
route->path=strdup(path);
route->func=func;
route->arg=arg;
queue_insert_head(&server->routes, &route->node);
}
static HttpSession *httpserver_session_new(HttpServer *server,int fd)
{
HttpSession *session=NULL;
session=malloc(sizeof(HttpSession));
bzero(session,sizeof(HttpSession) );
queue_init(&session->request.headers);
session->fd=fd;
session->server=server;
session->request.buff=buff_new(1024,0);
session->ev=event_fd_new( fd, EPOLLIN, httpsession_read, session);
session->request.prase_status=HPARSE_FIRST_LINE;
queue_insert_head(&server->sessions,&session->node);
return session;
}
void cache_free(cache_head_t *cache, void *data)
{
cache_node_t *a_node = data - sizeof(cache_node_t);
queue_remove(&a_node->next);
/*too many free cache objects? free it */
if (cache->nr_free >= MAX_FREE_CACHES)
{
Free (a_node);
cache->nr_used--;
return;
}
queue_insert_head(&cache->free_que, &a_node->next);
cache->nr_used--;
cache->nr_free++;
}
/* the stable insertion sort */
void
queue_sort(queue_t *queue,
int (*cmp)(const queue_t *, const queue_t *))
{
queue_t *q, *prev, *next;
q = queue_head(queue);
if (q == queue_tail(queue)) {
return;
}
for (q = queue_next(q); q != queue_sentinel(queue); q = next) {
prev = queue_prev(q);
next = queue_next(q);
queue_remove(q);
do {
if (cmp(prev, q) <= 0) {
break;
}
prev = queue_prev(prev);
} while (prev != queue_sentinel(queue));
queue_insert_head(prev, q);
}
}
channel_t channel_select(int need_default,char *fmt,...){
va_list argp;
int cnt = strlen(fmt);
queue_t select_node[HEAP_SELECT_CNT];
channel_t channels[HEAP_SELECT_CNT];
channel *chan=NULL;
uvc_ctx *ctx=uvc_self();
channel_t c;
int i = 0;
if (cnt < 0)return -1;
va_start(argp, fmt);
for (i = 0; i<cnt; i++)
{
c = va_arg(argp, channel_t);
channels[i] = c;
select_node[i].ext = ctx;
if (fmt[i] == 'r' && channel_readable(c)){
return c;
}
else if (fmt[i] == 'w' && channel_writeable(c)){
return c;
}
else if (fmt[i] != 'w' && fmt[i] != 'r'){
abort();
}
}
va_end(argp);
if (need_default){
return -1;
}
for(i=0;i<cnt;i++)
{
c = channels[i];
if(fmt[i]=='r' ){
chan = channel_pool_get(get_chan_pool(), c);
queue_insert_head(&chan->readq, &select_node[i]);
}
else if(fmt[i]=='w'){
chan = channel_pool_get(get_chan_pool(), c);
queue_insert_head(&chan->writq, &select_node[i]);
}else if(fmt[i] != 'w' && fmt[i] != 'r'){
abort();
}
}
uvc_yield();
c = 0;
for (i = 0; i < cnt; i++)
{
if (fmt[i] == 'r' && channel_readable(channels[i])){
assert(c == 0);
c = channels[i];
}
else if (fmt[i] == 'w' && channel_writeable(channels[i])){
assert(c == 0);
c = channels[i];
}
else{
queue_remove(&select_node[i]);
}
}
assert(c != 0);
//assert("won't be run here :\n");
return c;
}
static void channel_queue_put(queue_t *q, uvc_ctx *ctx){
queue_insert_head(q, &ctx->i_node);
}
void uvc_ready(uvc_ctx *ctx){
if (ctx){
uvc_thread_env *env = uvc_get_env();
queue_insert_head(&env->ready_queue, &ctx->task_node);
}
}
void uvc_io_ready(uvc_ctx *ctx){
uvc_thread_env *env = uvc_get_env();
queue_insert_head(&env->ready_queue, &ctx->task_node);
YIELD(env);;
}
