int main(int argc, char *argv[])
{
dynmem_init(&Dm);
dynmem_add_pool(&Dm, Memory1, sizeof(Memory1));
tlsf_init(&Tlsf);
tlsf_add_pool(&Tlsf, Memory2, sizeof(Memory2));
printf("\n\n");
HEAD
TEST(free(malloc(16)))
TEST(free(malloc(200)))
TEST(free(malloc(550)))
TEST(free(malloc(65536)))
TEST(free(malloc(65586)))
TEST(dynmem_free(&Dm, dynmem_malloc(&Dm, 16)))
TEST(dynmem_free(&Dm, dynmem_malloc(&Dm, 200)))
TEST(dynmem_free(&Dm, dynmem_malloc(&Dm, 550)))
TEST(dynmem_free(&Dm, dynmem_malloc(&Dm, 65536)))
TEST(dynmem_free(&Dm, dynmem_malloc(&Dm, 65586)))
TEST(tlsf_free(&Tlsf, tlsf_malloc(&Tlsf, 16)))
TEST(tlsf_free(&Tlsf, tlsf_malloc(&Tlsf, 200)))
TEST(tlsf_free(&Tlsf, tlsf_malloc(&Tlsf, 550)))
TEST(tlsf_free(&Tlsf, tlsf_malloc(&Tlsf, 65536)))
TEST(tlsf_free(&Tlsf, tlsf_malloc(&Tlsf, 65586)))
return 0;
}
void free(void *ptr)
{
if(ptr == NULL)
return;
const int bs = tlsf_block_size(ptr);
if(bs >= 65536) {
const int p = (intptr_t)ptr;
const int np = ROUND_UP(p, 65536);
int s = bs - (np - p);
if(s > 0) {
s &= ~0xffff;
if(s > 0) {
#if 0
tracelog(TRACE_NO_PROP, TRACE_DEBUG, "MEMORY",
"free(%p+%d) == page_free(0x%x+%d)",
ptr, bs, np, s);
#endif
#ifdef USE_VIRTUAL_MEM
if(Lv2Syscall2(308, np, s)) // Invalidate
tracelog(TRACE_NO_PROP, TRACE_ERROR, "MEMORY",
"Invalidate failed");
if(Lv2Syscall2(310, np, s)) // Sync
tracelog(TRACE_NO_PROP, TRACE_ERROR, "MEMORY",
"Sync failed");
#endif
}
}
}
hts_lwmutex_lock(&mutex);
tlsf_free(gpool, ptr);
hts_lwmutex_unlock(&mutex);
}
static ssize_t proc_write(struct file *filp, const char __user *buff,
unsigned long len, void *data)
{
unsigned int page_no = 0, clen = 0;
unsigned long used_size;
if (copy_from_user(&buffer, buff, len)) {
pr_info("Error copying buffer from user: len=%lu\n", len);
return -EFAULT;
}
//pr_info("buffer=[%s]\n", buffer);
sscanf(buffer, "%u %u", &page_no, &clen);
//temp
//buffer[len] = '\0';
if (table[page_no])
tlsf_free(table[page_no], mem_pool);
if (!(table[page_no] = tlsf_malloc(clen, mem_pool)))
pr_info("Error allocating mem for page: %u\n", page_no);
used_size = (unsigned long)tlsf_get_used_size(mem_pool);
count++;
//spin_lock(&write_lock);
//sprintf(buffer, "%lu\n", used_size);
sprintf(buffer, "%lu %lu %lu\n", count, used_size, used_size >> 10);
relay_write(relay, buffer, strlen(buffer));
//relay_write(relay, &used_size, sizeof(unsigned long));
//spin_unlock(&write_lock);
return len;
}
static void g_free(void *ptr)
{
if (memory_pool <= ptr && ptr < memory_pool_end)
tlsf_free(memory_pool, ptr);
else
::free(ptr);
}
/**
* Deallocate a block of data.
*/
void free(void *ptr)
{
unsigned old_state = irq_disable();
tlsf_free(gheap, ptr);
irq_restore(old_state);
}
void kfree(void *ptr)
{
uint32_t flags;
save_flags_cli(flags);
tlsf_free(g_kheap, ptr);
restore_flags(flags);
}
void myfree(void *ptr)
{
if(ptr == NULL)
return;
hts_lwmutex_lock(&mutex);
tlsf_free(gpool, ptr);
hts_lwmutex_unlock(&mutex);
}
//----------------------------------------------------------------//
void zipfs_free ( void* ptr ) {
if ( sTlsfPool ) {
tlsf_free ( sTlsfPool->mPool, ptr );
}
else {
free ( ptr );
}
}
void simFree(u64 location)
{
void *ptr = (void *)((size_t)location);
countFree++;
tlsf_free(ptr, pool);
showStats(pool);
}
void _free_impl(void* ptr, int krn)
{
if (krn == 1){ // kernel
if (tlsf_check_pool(kernel_heap))
krn_debugLogf("TLSFk: check failed");
tlsf_free(kernel_heap, ptr);
if (tlsf_check_pool(kernel_heap))
krn_debugLogf("TLSFk: check failed");
//show_mem_info(kernel_heap, 1);
} else { // processes
void* heapStart = sdk_prc_getHeapPointer();
if (tlsf_check_pool(heapStart))
krn_debugLogf("TLSFa: check failed");
tlsf_free(heapStart, ptr);
if (tlsf_check_pool(heapStart))
krn_debugLogf("TLSFa: check failed");
//show_mem_info(kernel_heap, 0);
}
}
static void __exit tlsf_kmod_exit(void)
{
unsigned long entry;
remove_proc_entry("tlsf_test", &proc_root);
relay_close(relay);
for (entry = 0; entry < MAX_SWAP_SIZE / PAGE_SIZE; entry++)
if (table[entry])
tlsf_free(table[entry], mem_pool);
vfree(table);
tlsf_destroy_memory_pool(mem_pool);
}
void AllocatorTLSF_Impl::Deallocate(void* _Pointer)
{
if (_Pointer)
{
size_t blockSize = tlsf_block_size(_Pointer);
tlsf_free(hPool, _Pointer);
Stats.NumAllocations--;
Stats.BytesAllocated -= blockSize;
Stats.BytesFree += blockSize;
}
}
static void *l_alloc (void *ud, void *ptr, size_t osize,
size_t nsize) {
void* ret = 0;
(void)osize; /* not used */
if (nsize == 0) {
//terminal_writeln("");
tlsf_free(ud, ptr);
return NULL;
}
else {
if(ptr == 0) {
ret = tlsf_malloc(ud, nsize);
//terminal_writehexln(ret);
return ret;
}else{
void* new_mem = tlsf_malloc(ud, nsize);
memcpy(new_mem, ptr, osize);
tlsf_free(ud, ptr);
//terminal_writehexln(new_mem);
return new_mem;
}
}
}
bool Allocator::lowMemory(unsigned n, size_t chunk_size)
{
//This should stay on the stack
void *buf[n];
for(unsigned i=0; i<n; ++i)
buf[i] = tlsf_malloc(impl->tlsf, chunk_size);
bool outOfMem = false;
for(unsigned i=0; i<n; ++i)
outOfMem |= (buf[i] == nullptr);
for(unsigned i=0; i<n; ++i)
if(buf[i])
tlsf_free(impl->tlsf, buf[i]);
return outOfMem;
}
int main(void)
{
void *mem, *pool;
pool = tlsf_create_memory_pool(get_mem, put_mem,
INIT_SIZE, MAX_SIZE, GROW_SIZE);
mem = tlsf_malloc(4033, pool);
if (mem == NULL) {
printf("test: error allocating memory\n");
return 0;
}
memset(mem, 0x0, 4033);
tlsf_free(mem, pool);
tlsf_destroy_memory_pool(pool);
return 0;
}
void push_back(T const &e) {
assert(toCopy <= used);
assert(used < capacity);
// Incrementally copy elements from container to nextContainer:
if(toCopy <= (used - 1)) {
nextContainer[toCopy] = container[toCopy];
++toCopy;
}
// Actually push back new element to both containers:
container[used] = e;
nextContainer[used] = e;
++used;
if(used == capacity) {
tlsf_free(static_cast< void * >(container));
container = nextContainer;
capacity *= 2;
nextContainer = static_cast< T * >(tlsf_malloc(2 * capacity * sizeof(T)));
toCopy = 0;
}
}
static void *g_realloc(void *ptr, size_t osize, size_t size)
{
void* p = NULL;
if (ptr && size == 0)
{
g_free(ptr);
}
else if (ptr == NULL)
{
if (size <= 256)
p = tlsf_malloc(memory_pool, size);
if (p == NULL)
p = ::malloc(size);
}
else
{
if (memory_pool <= ptr && ptr < memory_pool_end)
{
if (size <= 256)
p = tlsf_realloc(memory_pool, ptr, size);
if (p == NULL)
{
p = ::malloc(size);
memcpy(p, ptr, osize);
tlsf_free(memory_pool, ptr);
}
}
else
{
p = ::realloc(ptr, size);
}
}
return p;
}
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 pvfree(void *ptr)
{
tlsf_free(ptr);
}
void Allocator::dealloc_mem(void *memory)
{
//printf("dealloc_mem(%d)\n", tlsf_block_size(memory));
tlsf_free(impl->tlsf, memory);
//free(memory);
}
void free(void *ptr) {
tlsf_free(g_pool, ptr);
}
void free(void *mem)
{
tlsf_free(tlsf_mem_pool, mem);
}
void vPortFree( void *pv ){
vTaskSuspendAll();
tlsf_free(pv);
xTaskResumeAll();
}
void free( void* ptr )
{
tlsf_free( g_tlsfPool, ptr );
}
virtual ~vector_const_tlsf() {
tlsf_free(container);
tlsf_free(nextContainer);
}
