int display_matrix_shutdown(void)
{
allocator_destroy(matrixdef_allocator);
allocator_destroy(matrixref_allocator);
matrixdef_allocator = 0;
matrixref_allocator = 0;
return 0;
}
int EPLIB_finalize()
{
if (!__sync_bool_compare_and_swap(&is_eplib_finalized, 0, 1))
{
DEBUG_PRINT("already finalized, skip EPLIB_finalize\n");
return MPI_SUCCESS;
}
allocator_pre_destroy();
if (max_ep > 0)
{
if (std_mpi_mode == STD_MPI_MODE_IMPLICIT)
free(block_coll_request);
handle_finalize();
window_finalize();
client_finalize();
}
allocator_destroy();
fini_sig_handlers();
return MPI_SUCCESS;
}
int main(int argc, char* argv[])
{
Allocator* alloc = allocator_nginx_create(1024);
Config* config = config_xml_expat_create();
config_load(config, "../../../src/app/genesis-config.xml");
Reactor* reactor = reactor_create(config, alloc);
SourcesManager* sources_manager = NULL;
reactor_get_sources_manager(reactor, &sources_manager);
MainLoop* main_loop = NULL;
reactor_get_main_loop(reactor, &main_loop);
Source* timer_source = source_timer_create(2000, test_timer, (void*)reactor);
//sources_manager_add_source(sources_manager, timer_source);
logger_debug(reactor->logger, "sources_count = %d", sources_manager_get_count(sources_manager));
main_loop_add_source(main_loop, timer_source);
logger_debug(reactor->logger, "sources_count = %d", sources_manager_get_count(sources_manager));
reactor_run(reactor);
reactor_destroy(reactor);
config_destroy(config);
allocator_destroy(alloc);
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;
}
static ssize_t allocator_new(allocator_fixed_t **pfdata, hash_t *config){ // {{{
ssize_t ret;
data_t *sample;
allocator_fixed_t *fdata;
if((fdata = calloc(1, sizeof(allocator_fixed_t))) == NULL)
return error("calloc failed");
pthread_rwlock_init(&fdata->rwlock, NULL);
// get removed items tracker
hash_holder_consume(ret, fdata->removed_items, config, HK(removed_items));
hash_holder_consume(ret, fdata->storage, config, HK(storage));
if(ret != 0){
ret = error("invalid storage supplied");
goto error;
}
hash_data_get(ret, TYPE_UINTT, fdata->item_size, config, HK(item_size));
if(ret != 0){
if( (sample = hash_data_find(config, HK(item_sample))) == NULL){
ret = error("no item_size nor item_sample supplied");
goto error;
}
fastcall_length r_len = { { 4, ACTION_LENGTH }, 0, FORMAT(binary) };
if( data_query(sample, &r_len) != 0 ){
ret = error("bad item_sample");
goto error;
}
fdata->item_size = r_len.length;
}
if(fdata->item_size == 0){
ret = error("bad item size");
goto error;
}
// get last id
fastcall_length r_len = { { 4, ACTION_LENGTH }, 0, FORMAT(clean) };
if( data_query(&fdata->storage, &r_len) != 0){
ret = error("bad underlying storage");
goto error;
}
fdata->last_id = r_len.length / fdata->item_size;
*pfdata = fdata;
return 0;
error:
allocator_destroy(fdata);
return ret;
} // }}}
int cpeer_kill(struct cpeer *p)
{
if(!p)
return 0;
if(__sync_bool_compare_and_swap(&p->status,CPEER_CONNECTED,CPEER_DISCONNECTED))
{
printf("ref:%d,close peer id:%lu,peer:%p,nc:%p\n",p->refcount,p->id,p,p->nc);
close(p->sd);
fdev_del(&p->ioev);
//push one msg to notify disconnect
struct msg_t *msg = (struct msg_t *)mmalloc(p->nc->allocator,
sizeof(struct msg_t));
msg->buf = NULL;
msg->len = 0;
msg->peer_id = p->id;
msg->type = MSG_DISCONNECT;
queue_push(p->nc->recv_queue,msg);
}
if(__sync_bool_compare_and_swap(&p->refcount,0,1))
{
printf("free peer id:%lu\n",p->id);
iobuf_free(p->allocator,&p->recvbuf);
iobuf_free(p->allocator,&p->sendbuf);
//free send queue
struct msg_t *msg = NULL,*next = NULL;
thread_mutex_lock(p->sq_mutex);
msg = BTPDQ_FIRST(&p->send_queue);
while(msg){
next = BTPDQ_NEXT(msg,msg_entry);
BTPDQ_REMOVE(&p->send_queue,msg,msg_entry);
mfree(p->allocator,msg->buf);
mfree(p->allocator,msg);
msg = next;
}
thread_mutex_unlock(p->sq_mutex);
thread_mutex_destroy(p->mpool_mutex);
thread_mutex_destroy(p->sq_mutex);
allocator_destroy(p->allocator);
thread_mutex_lock(p->nc->peer_mutex);
mfree(p->nc->allocator,p);
p->nc->peer = NULL;
thread_mutex_unlock(p->nc->peer_mutex);
}
return 0;
}
int main(int argc, char *argv[])
{
int error;
allocator_t *allocator;
(void) argc;
(void) argv;
printf("default allocator:\n");
allocator = default_allocator_get();
error = run(allocator);
allocator_destroy(allocator);
#ifdef HAVE_MMAP
if (!error) {
printf("mmap allocator:\n");
allocator = mmap_allocator_get();
error = run(allocator);
allocator_destroy(allocator);
}
#endif
return !error ? EXIT_SUCCESS : EXIT_FAILURE;
}
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");
}
//*************************************************************************//
//* release the av heap.
//*************************************************************************//
void av_heap_release(void)
{
if(heap_ctx == NULL)
{
loge("av heap context is not initialized yet.");
return;
}
if(heap_ctx->allocator != NULL)
allocator_destroy(heap_ctx->allocator);
pthread_mutex_destroy(&heap_ctx->mutex);
free(heap_ctx);
heap_ctx = NULL;
return;
}
int main(int argc, char* argv[])
{
int i = 0;
int n = 100;
Allocator* allocator = allocator_normal_create();
for(i = 0; i < n; i++)
{
char* ptr = allocator_alloc(allocator, i);
ptr = allocator_realloc(allocator, ptr, i+4);
allocator_free(allocator, ptr);
ptr = allocator_calloc(allocator, i+4, 4);
allocator_free(allocator, ptr);
}
allocator_destroy(allocator);
return 0;
}
int nc_disconnect(net_client_t *nc)
{
if(!nc)
return -1;
fdev_del(&nc->ev);
close(nc->sd);
nc->endgame = 1;
pthread_join(nc->td_start,NULL);
cpeer_kill(nc->peer);
queue_destroy(nc->recv_queue);
thread_mutex_destroy(nc->peer_mutex);
//thread_mutex_destroy(nc->recv_mutex);
thread_mutex_destroy(nc->mpool_mutex);
allocator_destroy(nc->allocator);
free(nc);
return 0;
}
int
main(int argc, char* argv[])
{
int* arr[ALLOC_TIMES];
int i, counter;
clock_t beg, end;
allocator_init();
counter = 0;
beg = clock();
while (counter++ < LOOP_TIMES) {
for (i = 0; i < ALLOC_TIMES; ++i)
arr[i] = (int*)malloc(sizeof(int));
for (i = 0; i < ALLOC_TIMES; ++i)
free(arr[i]);
}
end = clock();
fprintf(stdout, "default use : %lu\n", end - beg);
counter = 0;
beg = clock();
while (counter++ < LOOP_TIMES) {
for (i = 0; i < ALLOC_TIMES; ++i)
arr[i] = (int*)al_malloc(sizeof(int));
for (i = 0; i < ALLOC_TIMES; ++i)
al_free(arr[i]);
}
end = clock();
fprintf(stdout, "allocator use : %lu\n", end - beg);
allocator_destroy();
return 0;
}
int peer_kill(struct peer *p)
{
if(!p)
return 0;
if(__sync_bool_compare_and_swap(&p->status,PEER_CONNECTED,PEER_DISCONNECTED))
{
close(p->sd);
fdev_del(&p->ioev);
log_error(p->ns->log,"ns peer socket closed,peer ip:%s.", inet_ntoa(p->addr.sin_addr));
//push one msg to notify disconnect
if(!p->ns->close_func)
{
struct msg_t *msg = (struct msg_t *)mmalloc(p->ns->allocator,
sizeof(struct msg_t));
msg->buf = NULL;
msg->len = 0;
msg->peer_id = p->id;
msg->type = MSG_DISCONNECT;
queue_push(p->ns->recv_queue,msg);
log_error(p->ns->log,"ns push notify msg for client:%s disconneced.", inet_ntoa(p->addr.sin_addr));
}
else
{
log_error(p->ns->log,"ns call close_func for client:%s disconneced.", inet_ntoa(p->addr.sin_addr));
p->ns->close_func(p->ns,p->id);
}
}
if(__sync_bool_compare_and_swap(&p->refcount,0,1))
{
log_error(p->ns->log,"ns peer freed,peer ip:%s.", inet_ntoa(p->addr.sin_addr));
iobuf_free(p->allocator,&p->recvbuf);
iobuf_free(p->allocator,&p->sendbuf);
//free send queue
struct msg_t *msg = NULL,*next = NULL;
thread_mutex_lock(p->sq_mutex);
msg = BTPDQ_FIRST(&p->send_queue);
while(msg){
next = BTPDQ_NEXT(msg,msg_entry);
BTPDQ_REMOVE(&p->send_queue,msg,msg_entry);
mfree(p->allocator,msg->buf);
mfree(p->allocator,msg);
msg = next;
}
thread_mutex_unlock(p->sq_mutex);
thread_mutex_destroy(p->mpool_mutex);
thread_mutex_destroy(p->sq_mutex);
allocator_destroy(p->allocator);
mfree(p->ns->allocator,p);
thread_mutex_lock(p->ns->ptbl_mutex);
ptbl_remove(p->ns->ptbl,&p->id);
p->ns->npeers--;
thread_mutex_unlock(p->ns->ptbl_mutex);
}
return 0;
}
static ssize_t data_allocator_fixed_t_free(data_t *data, fastcall_free *fargs){ // {{{
if(data->ptr != NULL)
allocator_destroy(data->ptr);
return 0;
} // }}}
