static void malloc_func(void** state) { size_t pool_size = 0x40000; /* void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); size_t mem_size = 0x3e000; void* mem = __malloc(mem_size, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); printf("extra malloc\n"); void* mem2 = __malloc(1800, malloc_pool); assert_in_range(mem2, malloc_pool, malloc_pool + pool_size); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; return; */ /* * 0x3e000 is max size that won't make failure of malloc * when pool size is set to 0x4000 * If malloc size over the 0x3e000(may be 0x3e001), malloc failed. * more problems is descirbed in Packetngin App Test Sheet. */ /* use private malloc_pool */ for(size_t i = 1; i < pool_size - 0x3e001; i++) { void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); size_t mem_size = i; void* mem = __malloc(mem_size, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; } /* use __malloc_pool */ for(size_t i = 1; i < pool_size - 0x3e001; i++) { __malloc_pool = malloc(pool_size); init_memory_pool(pool_size, __malloc_pool, 0); size_t mem_size = i; void* mem = __malloc(mem_size, NULL); assert_in_range(mem, __malloc_pool, __malloc_pool + pool_size); destroy_memory_pool(__malloc_pool); free(__malloc_pool); __malloc_pool = NULL; } }
static void arp_pack_func(void** state) { // Nic initialization void* malloc_pool = malloc(POOL_SIZE); init_memory_pool(POOL_SIZE, malloc_pool, 0); __nics[0] = malloc(sizeof(NIC)); __nic_count++; __nics[0]->mac = 0x10c37b9309d1; __nics[0]->pool_size = POOL_SIZE; __nics[0]->pool = malloc_pool; __nics[0]->output_buffer = fifo_create(8, malloc_pool); __nics[0]->config = map_create(8, NULL, NULL, __nics[0]->pool); uint32_t spa = 0xc0a80a6f; uint32_t dpa = 0xc0a80a90; arp_request(__nics[0], dpa, spa); Packet* packet = fifo_pop(__nics[0]->output_buffer); uint32_t comp_size = packet->end; packet->end = 0; arp_pack(packet); // Checking packet->end assert_int_equal(comp_size, packet->end); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; }
static void arp_announce_func(void** state) { // Nic initialization void* malloc_pool = malloc(POOL_SIZE); init_memory_pool(POOL_SIZE, malloc_pool, 0); __nics[0] = malloc(sizeof(NIC)); __nic_count++; __nics[0]->mac = 0x10c37b9309d1; __nics[0]->pool_size = POOL_SIZE; __nics[0]->pool = malloc_pool; __nics[0]->output_buffer = fifo_create(8, malloc_pool); __nics[0]->config = map_create(8, NULL, NULL, __nics[0]->pool); uint32_t spa = 0xc0a80a6f; arp_announce(__nics[0], spa); Packet* packet = fifo_pop(__nics[0]->output_buffer); assert_memory_equal(packet->buffer + packet->start, arp_announce_packet, 46); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; }
~data(void) { scoped_lock lock(*this); if(pool) { destroy_memory_pool(pool); operator delete(pool); } }
static void arp_process_func(void** state) { // Timer setting timer_init("IntelCore(TM) i5-4670 CPU @ 3.40GHz"); // Nic initialization void* malloc_pool = malloc(POOL_SIZE); init_memory_pool(POOL_SIZE, malloc_pool, 0); __nics[0] = malloc(sizeof(NIC)); __nic_count++; __nics[0]->mac = 0x74d4358f66cb; __nics[0]->pool_size = POOL_SIZE; __nics[0]->pool = malloc_pool; __nics[0]->output_buffer = fifo_create(8, malloc_pool); __nics[0]->config = map_create(8, NULL, NULL, __nics[0]->pool); // Arp request Packet* packet = nic_alloc(__nics[0], sizeof(arp_request_packet)); memcpy(packet->buffer + packet->start, arp_request_packet, sizeof(arp_request_packet)); Ether* ether = (Ether*)(packet->buffer + packet->start); ARP* arp = (ARP*)ether->payload; uint32_t addr = endian32(arp->tpa); nic_ip_add(__nics[0], addr); assert_true(arp_process(packet)); packet = fifo_pop(__nics[0]->output_buffer); assert_memory_equal(packet->buffer + packet->start, arp_reply_packet, 42); nic_free(packet); packet = NULL; // Arp response packet = nic_alloc(__nics[0], sizeof(arp_reply_packet)); memcpy(packet->buffer + packet->start, arp_reply_packet, sizeof(arp_reply_packet)); ether = (Ether*)(packet->buffer + packet->start); arp = (ARP*)ether->payload; addr = endian32(arp->tpa); nic_ip_add(__nics[0], addr); uint8_t comp_mac[6] = { 0xcb, 0x66, 0x8f, 0x35, 0xd4, 0x74 }; uint32_t sip = endian32(arp->spa); Map* arp_table = nic_config_get(packet->nic, "net.arp.arptable"); assert_true(arp_process(packet)); ARPEntity* entity = map_get(arp_table, (void*)(uintptr_t)sip); assert_memory_equal((uint8_t*)&entity->mac, comp_mac, 6); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; }
static void interface_alloc_func(void** state) { void* malloc_pool = malloc(POOL_SIZE); init_memory_pool(POOL_SIZE, malloc_pool, 0); IPv4Interface* interface = interface_alloc(malloc_pool); assert_in_range(interface, malloc_pool, malloc_pool + POOL_SIZE); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; }
void HeapTlsf::TLSF_RESET() { if (mTotalSize > 0) { for (unsigned int n=0;n<mTlsfIndex;n++) { LOGI("Tlsf reset pool: %d\n", n); destroy_memory_pool(mTlsfPools[n]); memset(mTlsfPools[n], 9, DEFAULT_TLSF_SIZE); mTlsfPoolsMem[n] = init_memory_pool( DEFAULT_TLSF_SIZE, mTlsfPools[n] ); } } }
static void file_write_func() { int file_fd = 0; int file_context = 0; int size = 1024; char* buffer; __malloc_pool = malloc(0x40000); init_memory_pool(0x40000, __malloc_pool, 0); buffer = malloc(size); __fio = fio_create(__malloc_pool); timer_init("Intel(R) Core(TM) i5-4670 CPU @ 3.40GHz"); event_init(); file_init(); for(int i = 0; i < 256; i++) { file_context = file_fd = i; sprintf(buffer, "Write Test %d", file_fd); int status = file_read(file_fd, buffer, size, write_callback, &file_context); __fio->output_buffer->head = i; __fio->output_buffer->tail = i + 1; FIORequest* output_buffer = malloc(sizeof(FIORequest)); output_buffer->type = FILE_T_WRITE; output_buffer->context = &file_context; output_buffer->fd = file_fd; output_buffer->id = (__fio->request_id - 1) % FIO_MAX_REQUEST_ID; output_buffer->op.file_io.buffer = buffer; output_buffer->op.file_io.size = size; __fio->output_buffer->array[i] = output_buffer; assert_int_equal(status, FIO_OK); event_loop(); } fifo_destroy(__fio->input_buffer); fifo_destroy(__fio->output_buffer); __free(__fio, __malloc_pool); destroy_memory_pool(__malloc_pool); free(__malloc_pool); __malloc_pool = NULL; }
static void free_func() { size_t pool_size = 0x40000; size_t malloc_size = 253951; void* mem; /* use private pool */ void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); mem = __malloc(malloc_size, malloc_pool); __free(mem, malloc_pool); mem = NULL; mem = __malloc(malloc_size, malloc_pool); assert_non_null(mem); __free(mem, malloc_pool); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; /* use __malloc_pool */ __malloc_pool = malloc(pool_size); init_memory_pool(pool_size, __malloc_pool, 0); mem = __malloc(malloc_size, __malloc_pool); __free(mem, __malloc_pool); mem = NULL; mem = __malloc(malloc_size, __malloc_pool); assert_non_null(mem); __free(mem, __malloc_pool); mem = NULL; destroy_memory_pool(__malloc_pool); free(__malloc_pool); __malloc_pool = NULL; }
void kogmo_rtdb_obj_mem_destroy (kogmo_rtdb_handle_t *db_h) { void *base = db_h->localdata_p->heap; DBGL(DBGL_DB,"mem_destroy: release %p, %lli bytes were used, %lli free", base, (long long int) db_h->localdata_p->heap_used, (long long int) db_h->localdata_p->heap_free); #if defined(RTMALLOC_tlsf) destroy_memory_pool (base); #elif defined(RTMALLOC_suba) // do nothing #else // do nothing #endif }
int main(int argc, char **argv) { int ret; size_t pool_size; char *fname; if (argc < 2) { printf("Usage: tlsf_test <file>\n"); printf("\t<file> is swap replay dump file from sr_collect\n"); goto out; } fname = argv[1]; ret = set_sr_file(fname); if (ret < 0) { printf("Error setting replay data file.\n"); goto out; } pool = malloc(MAX_POOL_SIZE); if (pool == NULL) { printf("Error allocating memory pool.\n"); goto out; } pool_size = init_memory_pool(MAX_POOL_SIZE, pool); printf("# total pool size: %u\n", pool_size); page_table = calloc(MAX_TABLE_SIZE, sizeof(*page_table)); if (page_table == NULL) { printf("Error allocating page table structure.\n"); goto out_pgtbl; } set_sr_callbacks(event_read, event_write, event_replay_end); sr_start(); free(page_table); out_pgtbl: destroy_memory_pool(pool); free(pool); out: return 0; }
static void file_opendir_func() { int file_fd = 0; int file_context = 0; __malloc_pool = malloc(0x40000); init_memory_pool(0x40000, __malloc_pool, 0); __fio = fio_create(__malloc_pool); timer_init("Intel(R) Core(TM) i5-4670 CPU @ 3.40GHz"); event_init(); file_init(); /* check context & fd unitl get to Max request id */ for(int i = 0; i < 256; i++) { file_context = i; int status = file_opendir("Test", opendir_callback, &file_context); __fio->output_buffer->head = i; __fio->output_buffer->tail = i + 1; /* FIORequest that put in to output_buffer of __fio */ FIORequest* output_buffer = malloc(sizeof(FIORequest)); output_buffer->type = FILE_T_OPENDIR; output_buffer->context = &file_context; output_buffer->id = (__fio->request_id - 1) % FIO_MAX_REQUEST_ID; output_buffer->fd = file_fd = i; __fio->output_buffer->array[i] = output_buffer; assert_int_equal(FIO_OK, status); event_loop(); } fifo_destroy(__fio->input_buffer); fifo_destroy(__fio->output_buffer); __free(__fio, __malloc_pool); destroy_memory_pool(__malloc_pool); free(__malloc_pool); __malloc_pool = NULL; }
static void file_close_func() { int file_fd = 0; int file_context = 0; __malloc_pool = malloc(0x40000); init_memory_pool(0x40000, __malloc_pool, 0); __fio = fio_create(__malloc_pool); timer_init("Intel(R) Core(TM) i5-4670 CPU @ 3.40GHz"); event_init(); file_init(); for(int i = 0; i < 256; i++) { file_context = file_fd = i; int status = file_close(file_fd, close_callback, &file_context); __fio->output_buffer->head = i; __fio->output_buffer->tail = i + 1; FIORequest* output_buffer = malloc(sizeof(FIORequest)); output_buffer->type = FILE_T_CLOSE; output_buffer->context = &file_context; output_buffer->id = (__fio->request_id - 1) % FIO_MAX_REQUEST_ID; output_buffer->fd = file_fd; __fio->output_buffer->array[i] = output_buffer; assert_int_equal(status, FIO_OK); event_loop(); } fifo_destroy(__fio->input_buffer); fifo_destroy(__fio->output_buffer); __free(__fio, __malloc_pool); destroy_memory_pool(__malloc_pool); free(__malloc_pool); __malloc_pool = NULL; }
main(){ int *ptr[100]; int i, free_mem; free_mem = init_memory_pool(POOL_SIZE, pool); printf("Total free memory= %d\n", free_mem); for (i=0; i< 100; i++) if (!(ptr[i]=malloc_ex(1024, pool))){ printf("Error\n"); exit(-1); } for (i=0; i< 100; i++) free_ex(ptr[i], pool); destroy_memory_pool(pool); printf("Test OK\n"); exit(0); }
static void interface_free_func(void** state) { void* malloc_pool = malloc(POOL_SIZE); init_memory_pool(POOL_SIZE, malloc_pool, 0); size_t first_size = get_used_size(malloc_pool); IPv4Interface* interface = interface_alloc(malloc_pool); size_t comp_size = get_used_size(malloc_pool); assert_int_not_equal(comp_size, first_size); interface_free(interface, malloc_pool); comp_size = get_used_size(malloc_pool); assert_int_equal(comp_size, first_size); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; }
static void arp_get_mac_func(void** state) { //timer setting timer_init("IntelCore(TM) i5-4670 CPU @ 3.40GHz"); // Nic initialization void* malloc_pool = malloc(POOL_SIZE); init_memory_pool(POOL_SIZE, malloc_pool, 0); __nics[0] = malloc(sizeof(NIC)); __nic_count++; __nics[0]->mac = 0x74d4358f66cb; __nics[0]->pool_size = POOL_SIZE; __nics[0]->pool = malloc_pool; __nics[0]->output_buffer = fifo_create(8, malloc_pool); __nics[0]->config = map_create(8, NULL, NULL, __nics[0]->pool); Packet* packet = nic_alloc(__nics[0], sizeof(arp_reply_packet)); memcpy(packet->buffer + packet->start, arp_reply_packet, sizeof(arp_reply_packet)); Ether* ether = (Ether*)(packet->buffer + packet->start); ARP* arp = (ARP*)ether->payload; uint32_t addr = endian32(arp->tpa); nic_ip_add(__nics[0], addr); if(!arp_process(packet)) return; uint32_t spa = 0xc0a80a6f; uint32_t dpa = 0xc0a80a90; uint64_t comp_tha = 0x74d4358f66cb; uint64_t d_mac = arp_get_mac(__nics[0], dpa, spa); assert_memory_equal((uint8_t*)&d_mac, (uint8_t*)&comp_tha, 6); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; }
static void realloc_func() { size_t pool_size = 0x40000; size_t malloc_size; for(size_t i = 1; i < pool_size - 0x3e001; i++) { malloc_size = i; void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); void* mem = __malloc(malloc_size, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); mem = __realloc(mem, 0x3e000, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; } }
int heapobj_pkg_init_private(void) { size_t size; void *mem; /* * We want to know how many bytes from a memory pool TLSF will * use for its own internal use. We get the probe memory from * tlsf_malloc(), so that the main pool will be set up in the * same move. */ mem = tlsf_malloc(__this_node.mem_pool); size = init_memory_pool(__this_node.mem_pool, mem); if (size == (size_t)-1) panic("cannot initialize TLSF memory manager"); destroy_memory_pool(mem); tlsf_pool_overhead = __this_node.mem_pool - size; tlsf_pool_overhead = (tlsf_pool_overhead + 15) & ~15; tlsf_free(mem); return 0; }
void nx_memalloc_destroy(void) { destroy_memory_pool(mp); }
void __heapobj_destroy(struct heapobj *hobj) { destroy_memory_pool(hobj->pool); __RT(pthread_mutex_destroy(&hobj->lock)); }