int main(int argc, char **argv) { t_ref *d_ref; t_mlx *d_mlx; if (argc != 2) return (0); if ((d_ref = init_ref(argv[1])) == NULL) free_ex(d_ref, 0, 0, argv[0]); if ((d_mlx = init_mlx(d_ref->win_i, d_ref->win_j, d_ref)) == NULL) free_ex(d_ref, d_mlx, 0, argv[0]); if (print_it(d_ref, d_mlx) == 0) free_ex(d_ref, d_mlx, 0, argv[0]); mlx_hook(d_mlx->win, 2, 0, (*key_hook), d_mlx); mlx_loop(d_mlx->mlx); }
// realloc: this is a bit more complex. First we identify the correct memory // pool and try to realloc there. If this doesn't work, we try to realloc in // another pool before giving up. void* _realloc_r( struct _reent* r, void* ptr, size_t size ) { void* temp; u32 lstart, lend; unsigned i = 0; size_t prevsize; // Realloc with ptr == NULL : malloc // Realloc with size == 0 : free if( !ptr ) return size ? _malloc_r( r, size ) : NULL; else if( !size ) { _free_r( r, ptr ); return NULL; } // At this point we know that this is an actual realloc // Identify the memory pool while( 1 ) { if( ( lstart = ( u32 )platform_get_first_free_ram( i ) ) == 0 ) return NULL; lstart = ( u32 )tlsf_elua_align_addr( ( void* )lstart ); lend = ( u32 )platform_get_last_free_ram( i ); if( ( lstart <= ( u32 )ptr ) && ( ( u32 )ptr <= lend ) ) break; i ++; } // Easy case: realloc succeeds in the same memory pool if( ( temp = realloc_ex( ptr, size, ( void* )lstart ) ) != NULL ) return temp; // If realloc returned NULL, look for another pool prevsize = tlsf_elua_get_block_size( ptr ); i = 0; while( 1 ) { if( ( temp = platform_get_first_free_ram( i ) ) == NULL ) break; temp = tlsf_elua_align_addr( temp ); if( ( u32 )temp != lstart ) { if( ( temp = malloc_ex( size, temp ) ) != NULL ) { memcpy( temp, ptr, prevsize < size ? prevsize : size ); free_ex( ptr, ( void* )lstart ); break; } } i ++; } return temp; }
void event_write(unsigned long index, unsigned long len) { if (page_table[index].addr) free_ex(page_table[index].addr, pool); page_table[index].addr = malloc_ex(len, pool); if (page_table[index].addr == NULL) { printf("Error allocating for index=%lu, len=%lu\n", index, len); return; } page_table[index].len = len; printf("%u\n", KB(get_used_size(pool))); }
void HeapTlsf::TLSF_DEL(void * p ) { if (!mActive) return free(p); //free(p); //return; if (p == NULL) return; p = (char*)p - 4; unsigned int index = *((int*)p); free_ex (p, mTlsfPools[index]); }
// free: find memory pool with the given pointer, then free it void _free_r( struct _reent* r, void* ptr ) { unsigned i = 0; u32 lstart, lend; while( 1 ) { if( ( lstart = ( u32 )platform_get_first_free_ram( i ) ) == 0 ) break; lstart = ( u32 )tlsf_elua_align_addr( ( void* )lstart ); lend = ( u32 )platform_get_last_free_ram( i ); if( ( lstart <= ( u32 )ptr ) && ( ( u32 )ptr <= lend ) ) { free_ex( ptr, ( void* )lstart ); break; } i ++; } }
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); }
void kogmo_rtdb_obj_mem_free (kogmo_rtdb_handle_t *db_h, kogmo_rtdb_objsize_t idx, kogmo_rtdb_objsize_t size ) { #if defined(RTMALLOC_tlsf) void *base = db_h->localdata_p->heap; #endif void *ptr = db_h->localdata_p->heap + idx; DBGL(DBGL_DB,"mem_free: %i bytes at %p", size, ptr); kogmo_rtdb_heap_lock(db_h); #if defined(RTMALLOC_tlsf) free_ex (ptr, base); db_h->localdata_p->heap_free += size; db_h->localdata_p->heap_used -= size; #elif defined(RTMALLOC_suba) suba_free (db_h-> heapinfo, ptr); db_h->localdata_p->heap_free += size; db_h->localdata_p->heap_used -= size; #else // do nothing #endif kogmo_rtdb_heap_unlock(db_h); }
void nx_free(void *ptr) { free_ex(ptr, mp); }
void free(void * p) { scoped_lock lock(data_); free_ex(p, data_.pool); }
void __heapobj_free(struct heapobj *hobj, void *ptr) { __RT(pthread_mutex_lock(&hobj->lock)); free_ex(ptr, hobj->pool); __RT(pthread_mutex_unlock(&hobj->lock)); }
asmlinkage void ufree_sys (void *ptr, int size) { free_ex (ptr, memory_pool); }
void _free_r(void *reent, void *aptr) { // lazy_initialize(); // TODO: Thread safe free_ex(aptr, mem_pool); // free_ex(aptr, heap_for_domain(TDOM_SELF)); }