Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 8183 → Rev 8184

/programs/demos/life2/include/kos_heap.h
1,90 → 1,32
#ifndef __KOLIBRI_HEAP_H_INCLUDED_
#define __KOLIBRI_HEAP_H_INCLUDED_
 
#include <kolibri.h>
#include <memheap.h>
#include "kolibri.h"
#include "memheap.h"
 
// Kolibri memory heap interface.
 
namespace Kolibri // All kolibri functions, types and data are nested in the (Kolibri) namespace.
{
void *Alloc(unsigned int size);
void *ReAlloc(void *mem, unsigned int size);
void Free(void *mem);
}
 
#ifdef __KOLIBRI__
 
namespace Kolibri
long _HeapInit()
{
 
// Global variables
 
MemoryHeap::TFreeSpace _KolibriFreeSpace;
MemoryHeap::TMemBlock _KolibriMemBlock;
TMutex _MemHeapMutex = KOLIBRI_MUTEX_INIT;
 
// Functions
 
void *_HeapInit(void *begin, void *use_end, void *end)
{
MemoryHeap::InitFreeSpace(_KolibriFreeSpace);
_KolibriMemBlock = MemoryHeap::CreateBlock(begin, end, _KolibriFreeSpace);
unsigned int use_beg = (unsigned int)MemoryHeap::BlockBegin(_KolibriMemBlock) +
MemoryHeap::BlockAddSize - MemoryHeap::BlockEndSize;
unsigned int use_size = (unsigned int)use_end;
if (use_size <= use_beg) return 0;
else use_size -= use_beg;
return MemoryHeap::Alloc(_KolibriFreeSpace, use_size);
return MemoryHeap::mem_Init();
}
 
bool _SetUseMemory(unsigned int use_mem);
 
int _RecalculateUseMemory(unsigned int use_mem);
 
void *Alloc(unsigned int size)
{
if (!size) return 0;
Lock(&_MemHeapMutex);
void *res = MemoryHeap::Alloc(_KolibriFreeSpace, size);
if (!res)
{
unsigned use_mem = (unsigned int)MemoryHeap::BlockEndFor(_KolibriMemBlock, size);
if (_SetUseMemory(_RecalculateUseMemory(use_mem)))
{
res = MemoryHeap::Alloc(_KolibriFreeSpace, size);
return MemoryHeap::mem_Alloc(size);
}
}
UnLock(&_MemHeapMutex);
return res;
}
 
void *ReAlloc(void *mem, unsigned int size)
{
Lock(&_MemHeapMutex);
void *res = MemoryHeap::ReAlloc(_KolibriFreeSpace, mem, size);
if (!res && size)
{
unsigned use_mem = (unsigned int)MemoryHeap::BlockEndFor(_KolibriMemBlock, size);
if (_SetUseMemory(_RecalculateUseMemory(use_mem)))
{
res = MemoryHeap::ReAlloc(_KolibriFreeSpace, mem, size);
return MemoryHeap::mem_ReAlloc(size, mem);
}
}
UnLock(&_MemHeapMutex);
return res;
}
 
void Free(void *mem)
{
Lock(&_MemHeapMutex);
MemoryHeap::Free(_KolibriFreeSpace, mem);
UnLock(&_MemHeapMutex);
MemoryHeap::mem_Free(mem);
}
 
void _FreeAndThreadFinish(void *mem, int *exit_proc_now);
}
 
#endif // def __KOLIBRI__
 
#endif // ndef __KOLIBRI_HEAP_H_INCLUDED_