bool
PoolCreate(TPool * const poolP,
uint32_t const zonesize) {
bool success;
bool mutexCreated;
poolP->zonesize = zonesize;
mutexCreated = MutexCreate(&poolP->mutexP);
if (mutexCreated) {
TPoolZone * const firstZoneP = PoolZoneAlloc(zonesize);
if (firstZoneP != NULL) {
poolP->firstzone = firstZoneP;
poolP->currentzone = firstZoneP;
success = TRUE;
} else
success = FALSE;
if (!success)
MutexDestroy(poolP->mutexP);
} else
success = FALSE;
return success;
}
int PoolCreate(TPool *p,uint32 zonesize)
{
/* sanity */
if (!p) {
return FALSE;
}
p->zonesize=zonesize;
if (MutexCreate(&p->mutex))
if (!(p->firstzone=p->currentzone=PoolZoneAlloc(zonesize)))
{
MutexFree(&p->mutex);
return FALSE;
};
return TRUE;
}
void *PoolAlloc(TPool *p,uint32 size)
{
TPoolZone *pz = 0;
TPoolZone *npz = 0;
void *x = 0;
uint32 zonesize = 0;
/* sanity */
if (!p || !size) {
return NULL;
}
if (!MutexLock(&p->mutex))
return NULL;
pz=p->currentzone;
if (pz->pos+size<pz->maxpos)
{
x=pz->pos;
pz->pos+=size;
MutexUnlock(&p->mutex);
return x;
};
if (size>p->zonesize)
zonesize=size;
else
zonesize=p->zonesize;
if( (npz = PoolZoneAlloc(zonesize)) )
{
npz->prev=pz;
npz->next=pz->next;
pz->next=npz;
p->currentzone=npz;
x=(void *)(npz+1);
npz->pos=((char *)(npz+1))+size;
}
else
x=NULL;
MutexUnlock(&p->mutex);
return x;
}
void *
PoolAlloc(TPool * const poolP,
uint32_t const size) {
/*----------------------------------------------------------------------------
Allocate a block of size 'size' from pool 'poolP'.
-----------------------------------------------------------------------------*/
void * retval;
if (size == 0)
retval = NULL;
else {
bool gotMutexLock;
gotMutexLock = MutexLock(poolP->mutexP);
if (!gotMutexLock)
retval = NULL;
else {
TPoolZone * const curPoolZoneP = poolP->currentzone;
if (curPoolZoneP->pos + size < curPoolZoneP->maxpos) {
retval = curPoolZoneP->pos;
curPoolZoneP->pos += size;
} else {
uint32_t const zonesize = MAX(size, poolP->zonesize);
TPoolZone * const newPoolZoneP = PoolZoneAlloc(zonesize);
if (newPoolZoneP) {
newPoolZoneP->prev = curPoolZoneP;
newPoolZoneP->next = curPoolZoneP->next;
curPoolZoneP->next = newPoolZoneP;
poolP->currentzone = newPoolZoneP;
retval= newPoolZoneP->data;
newPoolZoneP->pos = newPoolZoneP->data + size;
} else
retval = NULL;
}
MutexUnlock(poolP->mutexP);
}
}
return retval;
}
