Exemplo n.º 1
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);

	}
Exemplo n.º 2
0
Arquivo: vector.c Projeto: ifzz/libcdf
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;
}
Exemplo n.º 3
0
void test_cds_alloc()
{
	allocator_t *allocator;
	void *p ,*p2,*p3;
	uint32_t size = 8;

	/*
	 *alloc_p->slab_max_num = SLAB_ARRAY_MAX_NUM;
	 *alloc_p->data_min_size = 8;
	 *alloc_p->mempool_capacity = MEM_POOL_MAX_SIZE;
	 */
	allocator = allocator_creator(ALLOCATOR_TYPE_CDS_MALLOC);
	allocator_cds_init(allocator, 0, 0, 1024);
	/*
	 *allocator_cds_init(allocator,0,0,0);
	 */

	p = allocator_mem_alloc(allocator,7);
	dbg_str(DBG_CONTAINER_DETAIL,"alloc addr:%p",p);

	allocator_mem_free(allocator,p);

	p2 = allocator_mem_alloc(allocator,8);
	dbg_str(DBG_CONTAINER_DETAIL,"alloc addr:%p",p2);

	p3 = allocator_mem_alloc(allocator,200);
	dbg_str(DBG_CONTAINER_DETAIL,"alloc addr:%p",p3);

	dbg_str(DBG_CONTAINER_DETAIL,"inquire alloc info");
	allocator_mem_info(allocator);

	allocator_mem_free(allocator,p);
	allocator_mem_free(allocator,p2);
	allocator_mem_free(allocator,p3);

	dbg_str(DBG_CONTAINER_DETAIL,"batch alloc");
	int i;
	for(size = 8,i = 0; i< 20; i++,size += 8){
		p = allocator_mem_alloc(allocator,size);
	}
	dbg_str(DBG_CONTAINER_DETAIL,"inquire alloc info");
	allocator_mem_info(allocator);

	allocator_destroy(allocator);
	dbg_str(DBG_CONTAINER_DETAIL,"test cds alloc end");
}
Exemplo n.º 4
0
Arquivo: vector.c Projeto: ifzz/libcdf
vector_t *vector_create(allocator_t *allocator,uint8_t lock_type)
{
	vector_t *ret = NULL;
	ret = (vector_t *)allocator_mem_alloc(allocator,sizeof(vector_t));
	if(ret == NULL){
		dbg_str(DBG_ERROR,"allock err");
	}
	ret->allocator = allocator;
	ret->lock_type = lock_type;
	return ret;
}
Exemplo n.º 5
0
/*
 *typedef struct shm_queue_s{
 *    uint32_t fifo_fd;
 *    share_mem_t *shm;
 *}shm_queue_t;
 */
shm_queue_t *shm_queue_create(allocator_t *allocator)
{
    shm_queue_t *que;

    que = (shm_queue_t *)allocator_mem_alloc(allocator,sizeof(shm_queue_t));
    if(que == NULL){
        dbg_str(DBG_DETAIL,"allocator_mem_alloc");
        return que;
    }

    return que;
}
struct list_head *pfs_create_head_list(allocator_t *allocator)
{
    proto_head_list_t *head_list;

    head_list = (proto_head_list_t *)allocator_mem_alloc(allocator,sizeof(proto_head_list_t));
    if(head_list == NULL) {
        dbg_str(DBG_ERROR,"create head_list err");
        return NULL;
    }
    /*
     *pthread_rwlock_init(&head_list->head_lock,NULL);
     */
    head_list->allocator = allocator;
    dbg_str(DBG_DETAIL,"allocator=%p",allocator);

    return &head_list->list_head;
}
Exemplo n.º 7
0
Arquivo: vector.c Projeto: ifzz/libcdf
int vector_init(vector_t *vector,uint32_t data_size,uint32_t capacity)
{

	dbg_str(DBG_CONTAINER_DETAIL,"vector init");
	vector->step = data_size;
	vector->data_size = data_size;
	vector->capacity = capacity;
	vector->vector_head = allocator_mem_alloc(
			vector->allocator, capacity * (vector->step));
	if(vector->vector_head == NULL){
		dbg_str(DBG_CONTAINER_ERROR,"vector_init");
	}
	dbg_str(DBG_CONTAINER_DETAIL,"vector_head:%p,size=%d",
			vector->vector_head,
			capacity * (vector->step));
	vector_pos_init(&vector->begin,0,vector);
	vector_pos_init(&vector->end,0,vector);

	sync_lock_init(&vector->vector_lock,vector->lock_type);

	return 0;
}
Exemplo n.º 8
0
container_t *container_creator(uint32_t container_type,allocator_t *allocator)
{
	container_t *p;

	p = (container_t *)allocator_mem_alloc(allocator,sizeof(container_t));
	if(p == NULL){
		goto err;
	}

	dbg_str(DBG_CONTAINER_DETAIL,"container_t addr:%p,sizeof_container_struct:%d",p,sizeof(container_t));
	p->container_type = container_type;
	p->allocator = allocator;
	p->c_ops_p = &container_modules[container_type].c_ops;
	p->it_ops_p = &container_modules[container_type].it_ops;
	pthread_rwlock_init(&p->head_lock,NULL);   

	if(p->c_ops_p == NULL || p->it_ops_p == NULL){
		allocator_mem_free(p->allocator,p);
		p = NULL;
	}
err:
	return p;
}