/******************************************************************//**
Initializes the memory system. */
UNIV_INTERN
void
mem_init(
/*=====*/
ulint size) /*!< in: common pool size in bytes */
{
#ifdef UNIV_MEM_DEBUG
ulint i;
/* Initialize the hash table */
ut_a(FALSE == mem_hash_initialized);
mutex_create(mem_hash_mutex_key, &mem_hash_mutex, SYNC_MEM_HASH);
for (i = 0; i < MEM_HASH_SIZE; i++) {
UT_LIST_INIT(*mem_hash_get_nth_cell(i));
}
UT_LIST_INIT(mem_all_list_base);
mem_hash_initialized = TRUE;
#endif
if (UNIV_LIKELY(srv_use_sys_malloc)) {
/* When innodb_use_sys_malloc is set, the
mem_comm_pool won't be used for any allocations. We
create a dummy mem_comm_pool, because some statistics
and debugging code relies on it being initialized. */
size = 1;
}
mem_comm_pool = mem_pool_create(size);
}
int msg_create_Q (const char *name, int maxmsg, int size)
{
int qid = get_qid ();
if (qid < 0) {
return -1;
}
Queue[qid].mpool_id = mem_pool_create (name, maxmsg * sizeof (struct msg) ,
sizeof(struct msg), 0);
if (Queue[qid].mpool_id < 0) {
printf ("Mem Pool Creation failed ..\n");
return -1;
}
memcpy (Queue[qid].name, name, MAX_Q_NAME);
Queue[qid].max_msg = maxmsg;
Queue[qid].size = size;
Queue[qid].flags = MQ_ACTIVE;
EventInit (&Queue[qid].q_evt);
return qid;
}
int main()
{
MemPool *pool = mem_pool_create(640); //640M
configure_handler_t *config_handler = load_configure_file(pool, "test.conf");
test_log(pool, config_handler);
configure_handler_destroy(pool, config_handler);
mem_pool_destroy(pool);
return 0;
}
void test_key_value()
{
MemPool *pool = NULL;
key_value_t *kv = NULL;
key_value_node_t *node = NULL;
char *keys[5], *vals[5];
pool = mem_pool_create(160); //160M
kv = key_value_init(pool, 20);
keys[0] = "abcde";
vals[0] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
key_value_set(pool, kv, "abcde", strlen("abcde"),
vals[0], strlen(vals[0]), 0);
keys[1] = "qwerty";
vals[1] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
key_value_set(pool, kv, keys[1], strlen(keys[1]),
vals[1], strlen(vals[1]), 0);
keys[2] = "asdf";
vals[2] = "cccccccccccc";
key_value_set(pool, kv, keys[2], strlen(keys[2]),
vals[2], strlen(vals[2]), 0);
node = key_value_get(kv, keys[2], strlen(keys[2]));
printf("get %s node data: %s\n", keys[2], (char *)node->data);
keys[3] = "asdf";
vals[3] = "dddddddddddddddddddddddddddddddddddddddddddddddddddd";
key_value_set(pool, kv, keys[3], strlen(keys[3]),
vals[3], strlen(vals[3]), 0);
node = key_value_get(kv, keys[3], strlen(keys[3]));
printf("get %s node data: %s\n", keys[3], (char *)node->data);
keys[4] = "lkjhgfdsa";
vals[4] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
key_value_set(pool, kv, keys[4], strlen(keys[4]),
vals[4], strlen(vals[4]), 0);
node = key_value_get(kv, "aaaa", strlen("aaaa"));
if(node)
printf("get aaaa node data: %s\n", (char *)node->data);
else
printf("get aaaa node data: Not Found\n");
printf("Key Value: used memory: %u, mem pool used memory: %lu \n",
kv->used_memory, pool->used_size);
printf("Key-Value Pairs number: %u\n", kv->count);
key_value_destroy(pool, kv);
mem_pool_destroy(pool);
}
int msg_create_Q (char *name, int maxmsg, int size)
{
#ifdef SFS_WANTED
mqd_t qid = -1;
struct mq_attr attr;
#define MAX_MQ_NAME 12
char mq_name[MAX_MQ_NAME];
memset (mq_name, 0, MAX_MQ_NAME);
memset (&attr, 0, sizeof(attr));
sprintf (mq_name, "/%s",name);
mq_unlink (mq_name);
attr.mq_flags = 0;
attr.mq_maxmsg = maxmsg;
attr.mq_msgsize = size;
qid = tm_mq_open (mq_name, O_RDWR | O_CREAT,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH , &attr);
if (qid == (mqd_t)-1) {
perror ("mq_open: ");
return -1;
}
return qid;
#else
int qid = get_qid ();
if (qid < 0) {
return -1;
}
Queue[qid].mpool_id = mem_pool_create (name, maxmsg * sizeof (struct msg) ,
sizeof(struct msg), 0);
if (Queue[qid].mpool_id < 0) {
printf ("Mem Pool Creation failed ..\n");
return -1;
}
memcpy (Queue[qid].name, name, MAX_Q_NAME);
Queue[qid].max_msg = maxmsg;
Queue[qid].size = size;
Queue[qid].flags = MQ_ACTIVE;
pthread_cond_init (&Queue[qid].q_cnd, NULL);
pthread_mutex_init (&Queue[qid].q_mtx, NULL);
return qid;
#endif
}
static void
init_thread(thread_pool_t *tp, thread_t *t)
{
ASSERT(tp && t, "init empty thread pool");
pthread_mutex_init(&t->task_list_lock, NULL);
pthread_cond_init(&t->task_list_aval_cond, NULL);
t->manager = tp;
t->state = IDLE;
RING_INIT(&t->tasks, task, link);
t->mem_pool = mem_pool_create(sizeof(task_t), TASK_POOL_SIZE, false);
}
name_tree_t *
name_tree_create()
{
name_tree_t *tree = calloc(1, sizeof(name_tree_t));
if (!tree)
return NULL;
tree->_tree = rbtree_create(name_compare);
if (!tree->_tree)
goto MEM_ALLOC_FAILED;
tree->heap = heap_init(1000, elem_compare);
if (!tree->heap)
goto MEM_ALLOC_FAILED;
tree->node_pool = mem_pool_create(sizeof(rbnode_t), 1024, true);
if (!tree->node_pool)
goto MEM_ALLOC_FAILED;
tree->name_pool = mem_pool_create(sizeof(node_value_t), 1024, true);
if (!tree->name_pool)
goto MEM_ALLOC_FAILED;
tree->lru = lru_list_create();
if (!tree->lru)
goto MEM_ALLOC_FAILED;
tree->count = 0;
return tree;
MEM_ALLOC_FAILED :
if (tree->name_pool) mem_pool_delete(tree->name_pool);
if (tree->node_pool) mem_pool_delete(tree->node_pool);
if (tree->_tree) free(tree->_tree);
if (tree->heap) heap_destory(tree->heap);
if (tree->lru) lru_list_destroy(tree->lru);
free(tree);
}
result_t rs_initmgr(uint flags, uint load_thread_cnt)
{
result_t r;
memset(&g_rs, 0x00, sizeof(g_rs));
log_print(LOG_TEXT, "init res-mgr ...");
r = arr_create(mem_heap(), &g_rs.ress, sizeof(struct rs_resource), 128, 256, MID_RES);
r |= mem_pool_create(mem_heap(), &g_rs.freeslot_pool, sizeof(struct rs_freeslot_item),
100, MID_RES);
r |= mem_pool_create(mem_heap(), &g_rs.dict_itempool, sizeof(struct hashtable_item_chained),
DICT_BLOCK_SIZE, MID_RES);
mem_pool_bindalloc(&g_rs.dict_itempool, &g_rs.dict_itemalloc);
r |= hashtable_chained_create(mem_heap(), &g_rs.dict_itemalloc, &g_rs.dict, 65521, MID_RES);
r |= mem_pool_create(mem_heap(), &g_rs.load_data_pool, sizeof(struct rs_load_data), 256, MID_RES);
if (IS_FAIL(r)) {
err_printn(__FILE__, __LINE__, RET_OUTOFMEMORY);
return r;
}
/* get maximum number of threads available for threaded loading */
if (BIT_CHECK(flags, RS_FLAG_PREPARE_BGLOAD)) {
g_rs.load_threads_max = maxui(load_thread_cnt, 1);
g_rs.job_params.load_items = (struct rs_load_data**)ALLOC(
sizeof(struct rs_load_data*)*load_thread_cnt, MID_RES);
g_rs.job_result.ptrs = (void**)ALLOC(sizeof(void*)*load_thread_cnt, MID_RES);
if (g_rs.job_params.load_items == NULL || g_rs.job_result.ptrs == NULL) {
err_printn(__FILE__, __LINE__, RET_OUTOFMEMORY);
return RET_OUTOFMEMORY;
}
}
g_rs.alloc = mem_heap(); /* default allocator is heap */
g_rs.flags = flags;
g_rs.init = TRUE;
return RET_OK;
}
void test_configure()
{
configure_handler_t *config_handler;
char *filename = "test.conf";
MemPool *pool = mem_pool_create(640); //640M
char section_search[] = "[filter:dlo]";
char key_search[] = "use";
config_handler = load_configure_file(pool, filename);
//print_configure(config_handler);
printf("%s %s: %s\n", section_search, key_search,
get_configure_item(config_handler,section_search ,key_search ));
mem_pool_destroy(pool);
}
xml_doc_t* xml_doc_create(){
xml_doc_t* doc;
mem_pool_t* pool;
pool = mem_pool_create();
if(!pool){
return 0;
}
doc = (xml_doc_t*)mem_pool_alloc(pool,sizeof(xml_doc_t));
if(!doc){
mem_pool_destroy(pool);
return 0;
}
doc->pool = pool;
doc->root = 0;
doc->_raw_item_head = xml_raw_item_create(doc->pool,item_type_none,0,0);
doc->_raw_item_cur = doc->_raw_item_head;
return doc;
}
static void tcp_stream_init(tcp_server_t *server, tcp_server_stream_t *stream,
int sock_fd, struct sockaddr_in *remote_addr)
{
if (NULL == stream) {
return;
}
stream->sock_fd = sock_fd;
stream->pool = mem_pool_create();
if (NULL == stream->pool) {
log_error("create tcp stream pool failed.");
return;
}
stream->close = 0;
stream->error = 0;
gettimeofday(&stream->update_time, NULL);
stream->data = NULL;
stream->server = server;
if (NULL == server->rcv_cb) {
stream->rcv_cb = rcv_cb_default;
}
else {
stream->rcv_cb = server->rcv_cb;
}
if (NULL == server->snd_cb) {
stream->snd_cb = snd_cb_default;
}
else {
stream->snd_cb = server->snd_cb;
}
if (remote_addr) {
memcpy(&stream->remote_addr, remote_addr, sizeof(struct sockaddr_in));
}
}
HASH_TABLE * create_hash_table (char *hashname, int buckets,
int (*cmp)(char *list, char *key),
int (*index_gen)(char *key), int key_len)
{
HASH_TABLE * htable = NULL;
int size = (sizeof (hash_bucket_t *)) *
((!buckets) ? (buckets = DEFAULT_HASH_BUCKETS) : buckets);
htable = (HASH_TABLE *) malloc (sizeof (HASH_TABLE));
if (!htable) {
return NULL;
}
strcpy (htable->htname, hashname);
htable->nbuckets = buckets;
htable->key_len = key_len;
htable->cmp_func = cmp;
htable->hash_index_gen = index_gen;
htable->nentries = 0;
htable->hmem_pool_id = mem_pool_create (hashname, size, buckets, 0);
if (htable->hmem_pool_id < 0) {
free (htable);
return NULL;
}
htable->bucket_array = (hash_bucket_t **) malloc (buckets *
sizeof (hash_bucket_t *));
if (!htable->bucket_array) {
mem_pool_delete (htable->hmem_pool_id);
free (htable);
}
return htable;
}
static int tcp_client_stream_init(tcp_client_t *client,
tcp_client_stream_t *stream,
char *server_ip,
int port,
tcp_client_rcv_cb_t rcv_cb,
tcp_client_snd_cb_t snd_cb,
tcp_client_conn_cb_t conn_cb)
{
struct hostent *hostp = NULL;
struct sockaddr_in server_addr;
struct epoll_event event;
int connected = 0;
if (NULL == stream) {
return;
}
stream->sock_fd = socket(AF_INET, SOCK_STREAM, 0);
if (-1 == stream->sock_fd) {
log_error("create socket for %s failed, %s.", server, strerror(errno));
goto error;
}
if (!set_non_blocking(stream->sock_fd)) {
log_error("set non blocking failed, %s:%d.", server_ip, port);
goto error;
}
stream->pool = mem_pool_create();
if (NULL == stream->pool) {
log_error("create tcp stream pool failed.");
goto error;
}
stream->close = 0;
stream->error = 0;
gettimeofday(&stream->update_time, NULL);
stream->data = NULL;
stream->client = client;
stream->server_ip = (char *)mem_pool_calloc(stream->pool, strlen(server_ip) + 1);
if (NULL == stream->server_ip) {
log_error("mem_pool_calloc for server_ip failed.");
goto error;
}
strcpy(stream->server_ip, server_ip);
stream->port = port;
stream->tcp_state = TCP_STATE_CONNECTING;
stream->server_addr.sin_family = AF_INET;
stream->server_addr.sin_port = htons(port);
stream->server_addr.sin_addr.s_addr = inet_addr(server_ip);
if ((unsigned long)INADDR_NONE == stream->server_addr.sin_addr.s_addr) {
hostp = gethostbyname(server_ip);
if ((struct hostent *)NULL == hostp) {
log_error("gethostbyname for %s failed.", server);
goto error;
}
memcpy(&stream->server_addr.sin_addr, hostp->h_addr, sizeof(struct sockaddr_in));
}
connected = connect(stream->sock_fd, &stream->server_addr, sizeof(struct sockaddr_in));
/* 连接失败 */
if (-1 == connected && errno != EINPROGRESS) {
log_error("connect %s:%d failed.", stream->server_ip, stream->port);
goto error;
}
bzero(&event, sizeof(event));
event.data.fd = sock_fd;
event.data.ptr = stream;
event.events = EPOLLOUT | EPOLLERR;
/* 连接完成 */
if (connected == 0) {
stream->tcp_state = TCP_STATE_CONNECTED;
}
if (epoll_ctl(client->epoll_fd, EPOLL_CTL_ADD, stream->sock_fd, &event) < 0) {
log_error("EPOLL_CTL_ADD failed.");
goto error;
}
stream->rcv_cb = rcv_cb;
stream->snd_cb = snd_cb;
stream->conn_cb = conn_cb;
return 1;
error:
tcp_client_stream_reset(stream);
return 0;
}
