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