void cds_alloc_free(allocator_t *alloc,void *addr)
{
	cds_slab_t *slab_list;
	struct list_head *new_head;
	struct list_head **free_slabs;
	uint32_t size;
	cds_alloc_t *alloc_p = &alloc->priv.cds_alloc;

	dbg_str(DBG_ALLOC_DETAIL,"cds_alloc_free");
	if(addr == NULL){
		dbg_str(DBG_ALLOC_DETAIL,"release addr is NULL");
		return;
	}
	slab_list = container_of(addr,cds_slab_t,data);
	if(slab_list->stat_flag == 0){
		dbg_str(DBG_WARNNING,"this addr has been released");
		return;
	}

	dbg_str(DBG_ALLOC_DETAIL,"release slab_list:%p",slab_list);
	dbg_str(DBG_ALLOC_DETAIL,"release mem_addr:%p,addr:%p",slab_list->mem_addr,addr);
	new_head = &slab_list->list_head;
	size = slab_list->size;
	free_slabs = alloc_p->free_slabs;

	slab_detach_list_from_used_slabs(alloc,
			new_head,//struct list_head *del_head,
			size);//uint32_t size);
	slab_list->stat_flag = 0;
	slab_attach_list_to_free_slabs(alloc,
			new_head,//struct list_head *new_head,
			size);//uint32_t size);
}

/* not del list,just detach it from one link list */
void mempool_detach_list(struct list_head *del_head,struct list_head *hl_head)
{
	cds_mempool_head_list_t *head_list;
	cds_mempool_t *mempool_list;

	dbg_str(DBG_ALLOC_DETAIL,"mempool_detach_list");
	head_list = container_of(hl_head,cds_mempool_head_list_t,list_head);
	/*
	 *pthread_rwlock_wrlock(&head_list->head_lock);
	 */
	sync_lock(&head_list->head_lock,NULL);
	/*
	 *dbg_str(DBG_ALLOC_DETAIL,"mempool del head:%p, hl_head:%p",del_head,hl_head);
	 *dbg_str(DBG_ALLOC_DETAIL,"mempool del heads next:%p, prev:%p",del_head->next,del_head->prev);
	 */
	list_del(del_head);
	head_list->count--;
	mempool_list = container_of(del_head,cds_mempool_t,list_head);
	sync_unlock(&head_list->head_lock);
	/*
	 *pthread_rwlock_unlock(&head_list->head_lock);
	 */

	dbg_str(DBG_ALLOC_DETAIL,"del_mempool list,list count =%d",head_list->count);
}

void *cds_alloc_alloc(allocator_t *alloc,uint32_t size)
{
	cds_slab_t *slab_list;
	uint32_t index;

	index = slab_get_slab_index(alloc,size);
	dbg_str(DBG_ALLOC_DETAIL,"size=%d,index=%d,slab_array_max_num=%d",
			size,index,alloc->priv.cds_alloc.slab_array_max_num);
	if(size > alloc->priv.cds_alloc.mempool_capacity){
		dbg_str(DBG_ERROR,"apply szie excess mempool_capacity");
		return NULL;
	}
	if(index >= alloc->priv.cds_alloc.slab_array_max_num){
		dbg_str(DBG_ERROR,"apply size:%d too large,max size:%d,excess slab num,"
				"please assignd by sys malloc,or reconfig cds_alloc",size,20*8);
		return NULL;
	}else{
		dbg_str(DBG_ALLOC_DETAIL,"cds_alloc_alloc");
		slab_list = slab_get_first_list_from_free_slabs(alloc,size);
		if(slab_list == NULL){
			slab_list = mempool_alloc_slab_list(alloc,size);
		}
		slab_attach_list_to_used_slabs(alloc,&slab_list->list_head,size);
		return slab_list->mem_addr;
	}
}

int hexstr2num(const char* const_str)
{
    uint32_t ret=0;
    uint32_t t;
    char * str = (char *)const_str;
    int len = strlen(str);

    if(strncmp(str,"0x",2) && strncmp(str,"0X",2)) {
        dbg_str(DBG_ERROR,"not hex data err");
        return -1;
    };
    if(len > 10) {
        dbg_str(DBG_ERROR,"str is too long");
        return -1;
    }
    for (str += 2; *str; str++)
    {
        if (*str>='A' && *str <='F')
            t = *str-55;//a-f之间的ascii与对应数值相差55如'A'为65,65-55即为A
        else
            t = *str-48;
        ret <<= 4;
        ret |= t;
    }
    return ret;
}

int vector_push_back(vector_t *vector,void *data)
{
	uint32_t data_size    = vector->data_size;
	void *vector_head     = vector->vector_head;
	uint32_t step         = vector->step;
	uint32_t capacity     = vector->capacity;
	uint32_t push_pos     = vector->end.vector_pos;

	sync_lock(&vector->vector_lock,NULL);
	if(push_pos < capacity){
		memcpy(vector_head + (push_pos++)*step,data,data_size);
		vector_pos_init(&vector->end,push_pos,vector);
	}else{
		dbg_str(DBG_CONTAINER_WARNNING,"realloc mem");
		vector->vector_head = allocator_mem_alloc(
				vector->allocator, 2*capacity * (vector->step));
		if(vector->vector_head == NULL){
			dbg_str(DBG_CONTAINER_ERROR,"vector_push_back,realloc mem");
		}
		vector->capacity = 2*capacity;
		memcpy(vector->vector_head,vector_head,capacity*step);
		memcpy(vector->vector_head + (push_pos++)*step,data,data_size);
		vector_pos_init(&vector->end,push_pos,vector);
		allocator_mem_free(vector->allocator,vector_head);
	}
	sync_unlock(&vector->vector_lock);
	dbg_str(DBG_CONTAINER_DETAIL,"vector_push_back,push_pos=%d,capacity=%d",push_pos,vector->capacity);

	return 0;
}

int pa_copy_protocol_format(struct protocol_analyzer_s *pa)
{
	int ret = 0;
	if(pa->pf_list_head_p == NULL){
		dbg_str(PA_ERROR,"pa_copy_protocol_format,pf_list_head_p == NULL");
		return -1;
	}

	proto_head_list_t *head_list,*head_list_copy;
	proto_info_list_t *info_list,*info_list_copy;
	struct list_head *hl_head = pa->pf_list_head_p;
	struct list_head *pos,*n;

	if(hl_head == NULL){
		dbg_str(PA_ERROR,"a_copy_protocol_format err,hl_head is NULL");
		return -1;
	}
	head_list = container_of(hl_head,proto_head_list_t,list_head);
	head_list_copy = (proto_head_list_t *)allocator_mem_alloc(pa->allocator,sizeof(proto_head_list_t));
	memcpy(head_list_copy,head_list,sizeof(proto_head_list_t));
	head_list_copy->allocator = pa->allocator;
	head_list_copy->list_count = 0;
	INIT_LIST_HEAD(&head_list_copy->list_head);
	list_for_each_safe(pos, n, hl_head) {
		info_list = container_of(pos,proto_info_list_t,list_head);
		info_list_copy = (proto_info_list_t *)allocator_mem_alloc(pa->allocator,sizeof(proto_info_list_t));
		memcpy(info_list_copy,info_list,sizeof(proto_info_list_t));
		pfs_add_list(&info_list_copy->list_head,&head_list_copy->list_head);

	}

static int __init_window(Sdl_Graph *graph, void *window)
{
	int ret;
	Window *w = (Window *)window;

	dbg_str(DBG_DETAIL,"Sdl_Graph create window");

	dbg_str(DBG_DETAIL,"srceen width=%d, height=%d",w->screen_width,w->screen_height);
	//Initialize SDL
	if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
		dbg_str(DBG_ERROR,"SDL could not initialize! SDL_Error: %s", SDL_GetError() );
		ret = -1;
	} else {
		//Create window
		graph->window = SDL_CreateWindow("SDL Tutorial", 
                                         SDL_WINDOWPOS_UNDEFINED, 
                                         SDL_WINDOWPOS_UNDEFINED,
                                         w->screen_width, 
                                         w->screen_height,
                                         SDL_WINDOW_SHOWN );
		if( graph->window == NULL ) {
			dbg_str(DBG_ERROR,"Window could not be created! SDL_Error: %s\n", SDL_GetError() );
			ret = -1;
		} else {
			graph->screen_surface = SDL_GetWindowSurface(graph->window);
			ret = 1;
		}
	}

	return ret;
}

static void * __render_load_text(Sdl_Graph *graph,void *string,void *font,int r, int g, int b, int a)
{
	allocator_t *allocator = ((Obj *)graph)->allocator;
	Sdl_Text *text;
	Sdl_Font *f = (Sdl_Font *)font;
	SDL_Surface* surface = NULL;
	SDL_Color textColor = {r, g, b, a };
	String *content;

	dbg_str(DBG_DETAIL,"Sdl_Text load text");
    text = OBJECT_NEW(allocator, Sdl_Text,"");
	content = ((Text *)text)->content;
	content->assign(content,string);

	surface = TTF_RenderText_Solid(f->ttf_font,
                                   ((Text *)text)->content->value,
                                   textColor ); 

	if(surface != NULL) {
		text->texture = SDL_CreateTextureFromSurface(graph->render, surface);
		text->width = surface->w;
		text->height = surface->h;
		dbg_str(DBG_DETAIL,"width =%d height=%d",text->width, text->height);
		SDL_FreeSurface(surface);
	}

	return text;
}

static int __open_window(Window *window)
{
	Graph *g = window->graph;

    dbg_str(DBG_DETAIL,"sdl window open_window start");
	if(g != NULL) {
		g->init_window(g,window);
		/*
		 *background->load_image(background);
		 *g->draw_image(g,background);
		 */
	} else {
		dbg_str(DBG_ERROR,"window graph is NULL, please check");
		return -1;
	}

	g->render_create(g);
	g->render_set_color(g,0xff,0xff,0xff,0xff);
	g->render_clear(g);
	g->render_present(g);

    dbg_str(DBG_DETAIL,"sdl window open_window end");
	/*
	 *g->update_window(g);
	 */
}

int 
args_parse_args(args_processor_t *p,int argc, char *argv[])
{
	int i = 0;
	cmd_config_t *c; 
	uint8_t args_count;

	for(i = 0; i < argc;){
		c = args_find_entry(p,argv[i]);
		if(c == NULL){
			dbg_str(ARGS_WARNNING,"%s is not valid cmd,please check.We'll skip this cmd",argv[i]);
			i++;
			continue;
		} else {
			dbg_str(ARGS_DETAIL,"process cmd %s",argv[i]);
			i++;
			args_count = c->fn(p->base,argc - i,argv + i);
			if(args_count != c->args_count){
				dbg_str(ARGS_WARNNING,"the args funtion process args count is not equal the setting,"
						"we'll compute by the default setting");
			}
			i+= c->args_count;
		}
	}

	return 0;
}

int test_datastructure_rbtree_map(void)
{
	int ret = 0;
	rbtree_map_pos_t it,next,end;
	rbtree_map_t *map;
	allocator_t *allocator = allocator_get_default_alloc();
	pair_t *pair;
	struct rbtree_map_node *mnode;
	int key_len = 2;

	struct A t1 = {1,2};
	struct A t2 = {2,2};
	struct A t3 = {3,2};
	struct A t4 = {4,2};
	struct A t5 = {5,2};

	dbg_str(DBG_DETAIL,"rbtree allocator addr:%p",allocator);
	map = rbtree_map_create(allocator,0);

	rbtree_map_init(map,key_len,sizeof(struct A) + key_len,NULL); 

	dbg_str(DBG_DETAIL,"create_pair");
	pair = create_pair(key_len,sizeof(struct A));

	make_pair(pair,"44",&t4);
	rbtree_map_insert(map,pair->data);
	make_pair(pair,"33",&t3);
	rbtree_map_insert(map,pair->data);
	make_pair(pair,"22",&t2);
	rbtree_map_insert(map,pair->data);
	make_pair(pair,"11",&t1);
	rbtree_map_insert(map,pair->data);


	dbg_str(DBG_DETAIL,"foreach ordinal print");
	for(	rbtree_map_begin(map,&it),rbtree_map_pos_next(&it,&next); 
			!rbtree_map_pos_equal(&it,rbtree_map_end(map,&end));
			it = next,rbtree_map_pos_next(&it,&next))
	{
		mnode = rb_entry(it.rb_node_p,struct rbtree_map_node,node);
		dbg_buf(DBG_DETAIL,"key:",mnode->key,mnode->value_pos);
		print_A((struct A*)rbtree_map_pos_get_pointer(&it));
	}

	dbg_str(DBG_DETAIL,"search node key = 22");
	rbtree_map_search(map, (void *)"22",&it);
	print_A((struct A*)rbtree_map_pos_get_pointer(&it));

	/*
	 *dbg_str(DBG_DETAIL,"delte node key = 11");
	 *container_delete(map,&it);
	 */

	rbtree_map_destroy(map);
	allocator_destroy(allocator);
	dbg_str(DBG_DETAIL,"map addr =%p",map);

	return ret;
}

int lab()
{
    if(check_endian()) {
        dbg_str(DBG_DETAIL,"little endian");
    } else {
        dbg_str(DBG_DETAIL,"big endian");
    }
}

int test_pdu_proto_analyzer()
{
	protocol_format_set_t *pfs_p;
	struct protocol_analyzer_s *pa;
	uint32_t ret = 0;
	proto_info_list_t *info_list = NULL; 

	struct proto_analyzer_admin_s *pa_admin = NULL;


	allocator = allocator_creator(ALLOCATOR_TYPE_SYS_MALLOC,0);

	pfs_p = pfs_create_proto_format_set(allocator);
	init_proto_format_set(0x0,100,pfs_p);
	pfs_set_pdu_format_ackd(pfs_p);

	/*
	 *pfs_print_proto_link_lists(pfs_p);
	 */

	/*set and parse test*/
	pa = pa_create_protocol_analyzer(allocator);
	pa_init_protocol_analyzer(0x8, pfs_p, pa);
	/*
	 *pa = proto_analyer_admin_get_pa(pa_admin,0x3008);
	 */

	pa_set_value("LB",1,pa);
	pa_set_value("PF",1,pa);
	pa_set_value("CSBKO",0x2f,pa);
	pa_set_value("FID",0x8,pa);
	pa_set_value("RI",1,pa);
	pa_set_value("ARC",4,pa);
	pa_set_value("RSVD",1,pa);
	pa_set_value("TADDR",0xfffc001,pa);
	pa_set_value("SADDR",0xfffc002,pa);

	dbg_str(DBG_IMPORTANT,"print list for each,orinal data");
	pfs_print_list_for_each(pa->pa_list_head_p);

	pa_generate_protocol_data(pa);

	dbg_str(DBG_DETAIL,"pa_parse_protocol_data\n");
	pa_parse_protocol_data(pa);

	dbg_str(DBG_IMPORTANT,"print list for each after parse");
	pfs_print_list_for_each(pa->pa_list_head_p);

	dbg_str(DBG_DETAIL,"pa_destroy_protocol_analyzer");
	pa_destroy_protocol_analyzer(pa);

	dbg_str(DBG_DETAIL,"pfs_destroy_protocol_format_set");
	pfs_destroy_protocol_format_set(pfs_p);

	return ret;
}

static int process_task_callback(client_task_t *task)
{
	dbg_str(DBG_DETAIL,"process_task begin,client recv");
	/*
	 *user_t *user = task->client;
	 *void *opaque = user->opaque;
	 */
	dbg_buf(DBG_VIP,"task buffer:",task->buffer,task->buffer_len);
	dbg_str(DBG_DETAIL,"process_task end");
}

void lab5()
{
	char *str = "a林能刚";

	dbg_str(DBG_DETAIL,"strlen =%d",strlen(str));
	dbg_str(DBG_DETAIL,"strlen =%s",str);

	dbg_buf(DBG_DETAIL,"buff:",str, strlen(str));

}

static int __construct(Font *font,char *init_str)
{
	Sdl_Font *f = (Sdl_Font *)font;

	dbg_str(OBJ_DETAIL,"font construct, font addr:%p",font);

	if(TTF_Init() == -1){
		dbg_str(DBG_WARNNING,"TTF_Init error");
		return -1;
	}

	return 0;
}

int test_miscellany_net()
{
    unsigned char  mac_addr[6];
    char ip_addr[100];

#if 0
    get_mac((char *)"eth0",mac_addr, sizeof(mac_addr));
    print_mac(mac_addr);

    get_local_ip((char *)"eth0",ip_addr);
    print_ipaddr(ip_addr);

    set_local_ip((char *)"eth0","192.168.20.182");
    get_local_ip((char *)"eth0",ip_addr);
    print_ipaddr(ip_addr);

    dbg_str(DBG_DETAIL,"get local netmask");
    get_local_netmask((char *)"eth0",ip_addr); 
    print_ipaddr(ip_addr);
    dbg_str(DBG_DETAIL,"set local netmask");
    set_local_netmask((char *)"eth0",(char *)"255.255.255.0");  
    get_local_netmask((char *)"eth0",ip_addr); 
    print_ipaddr(ip_addr);

    dbg_str(DBG_DETAIL,"ip and str convert");
    inet_str2num(AF_INET,(char *)"192.168.20.2");
    
    inet_num2str(AF_INET,34908352,ip_addr);
#endif

#if 0
    if(inet_is_in_same_subnet("192.168.2.32","eth0")) {
        /*
         *dbg_str(DBG_DETAIL,"this ip addr add local addr is in the same net");
         */
    } else {
        dbg_str(DBG_DETAIL,"this ip addr add local addr is not in the same net");
    }
#endif

    get_broadcast_addr("eth0", ip_addr);
    print_ipaddr(ip_addr);

    /*
     *char ip_addr2[100];
     *set_broadcast_addr("eth0", "192.168.20.255");
     *print_ipaddr(ip_addr2);
     */

    return 0;
}

int str2num(const char *const_str)
{
    char * str = (char *)const_str;
    int ret;

    if(strncmp(str,"0x",2) && strncmp(str,"0X",2)) {
        dbg_str(DBG_DETAIL,"str is dex data,convert func is atoi");
        ret = atoi(const_str);
    } else {
        dbg_str(DBG_DETAIL,"str is hex data,convert func is hexstr2num");
        ret = hexstr2num(const_str);
    }
    return ret;
}

int pa_check_protocol_num(struct protocol_analyzer_s *pa)
{
	uint32_t protocol_num = pa->protocol_num;
	uint32_t proto_base_addr = pa->pfs_p->proto_base_addr;
	uint32_t proto_max_num = pa->pfs_p->proto_max_num;
	dbg_str(PA_DETAIL,"proto_base_addr =%x,proto_max_num=%d",proto_base_addr,proto_max_num);
	if(	
		(uint32_t)protocol_num > proto_base_addr + proto_max_num ||
		(uint32_t)protocol_num < proto_base_addr)
	{
		dbg_str(PA_ERROR,"protocol num is err,please check");
		return -1;
	}
	return 0;
}

void test_ui_sdl_grath()
{
    Sdl_Graph *sdl_grath;
	allocator_t *allocator = allocator_get_default_alloc();
    char *set_str;
    cjson_t *root, *e, *s;
    char buf[2048];

    root = cjson_create_object();{
        cjson_add_item_to_object(root, "Sdl_Graph", e = cjson_create_object());{
            cjson_add_string_to_object(e, "name", "alan");
        }
    }

    set_str = cjson_print(root);

    sdl_grath = OBJECT_NEW(allocator, Sdl_Graph,set_str);

    object_dump(sdl_grath, "Sdl_Graph", buf, 2048);
    dbg_str(DBG_DETAIL,"Sdl_Graph dump: %s",buf);

    object_destroy(sdl_grath);

    free(set_str);

}