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));
}
