C++ (Cpp) allocator_mem_free Examples

Example #1

File: protocol_format_set.c Project: a1an1in/linux_char_driver_frame

void pfs_del_list(struct list_head *del_head,struct list_head *hl_head)
{
    proto_head_list_t *head_list;
    proto_info_list_t *info_list;

    head_list = container_of(hl_head,proto_head_list_t,list_head);

    /*
     *pthread_rwlock_wrlock(&head_list->head_lock);
     */
    info_list = container_of(del_head,proto_info_list_t,list_head);

    list_del(del_head);
    head_list->list_count--;
    //there may have bug
    /*
     *info_list->free_mem(info_list->mem_used);
     */
    if(info_list->buf.len > 0)
        allocator_mem_free(head_list->allocator,info_list->buf.data_p);
    allocator_mem_free(head_list->allocator,info_list);
    /*
     *pthread_rwlock_unlock(&head_list->head_lock);
     */

}

Example #2

File: vector.c Project: ifzz/libcdf

int vector_destroy(vector_t *vt)
{
	dbg_str(DBG_CONTAINER_DETAIL,"vector_destroy");

	sync_lock_destroy(&vt->vector_lock);

	allocator_mem_free(vt->allocator,vt->vector_head);
	allocator_mem_free(vt->allocator,vt);
}

Example #3

File: container.c Project: a1an1in/libcontainer

int container_destroy(container_t **ct)
{
	(*ct)->c_ops_p->destroy(*ct);
	allocator_mem_free((*ct)->allocator,*ct);
	*ct = NULL;
	return 0;
}

Example #4

File: vector.c Project: 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;
}

Example #5

File: test_cds_alloc.c Project: a1an1in/libcontainer

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");
}

Example #6

File: protocol_format_set.c Project: a1an1in/linux_char_driver_frame

//释放表头
void pfs_release_head_list(struct list_head *hl_head)
{
    proto_head_list_t *head_list;

    head_list = container_of(hl_head,proto_head_list_t,list_head);
    dbg_str(DBG_DETAIL,"release_head_list");
    /*
     *pthread_rwlock_destroy(&head_list->head_lock);
     */
    allocator_mem_free(head_list->allocator,head_list);
}

Example #7

File: container.c Project: a1an1in/libcontainer

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;
}