static Size MFSFreeSize(Pool pool)
{
MFS mfs;
AVERT(Pool, pool);
mfs = PoolPoolMFS(pool);
AVERT(MFS, mfs);
return mfs->free;
}
static Size MFSTotalSize(Pool pool)
{
MFS mfs;
AVERT(Pool, pool);
mfs = PoolPoolMFS(pool);
AVERT(MFS, mfs);
return mfs->total;
}
static void MFSFinish(Pool pool)
{
MFS mfs;
AVERT(Pool, pool);
mfs = PoolPoolMFS(pool);
AVERT(MFS, mfs);
MFSFinishTracts(pool, MFSTractFreeVisitor, NULL, 0);
mfs->sig = SigInvalid;
}
static void MFSFinish(Pool pool)
{
MFS mfs;
AVERT(Pool, pool);
mfs = PoolPoolMFS(pool);
AVERT(MFS, mfs);
MFSFinishTracts(pool, MFSTractFreeVisitor, UNUSED_POINTER, UNUSED_SIZE);
mfs->sig = SigInvalid;
}
void MFSExtend(Pool pool, Addr base, Size size)
{
MFS mfs;
Tract tract;
Word i, unitsPerExtent;
Size unitSize;
Header header = NULL;
AVERT(Pool, pool);
mfs = PoolPoolMFS(pool);
AVERT(MFS, mfs);
AVER(size == mfs->extendBy);
/* Ensure that the memory we're adding belongs to this pool. This is
automatic if it was allocated using ArenaAlloc, but if the memory is
being inserted from elsewhere then it must have been set up correctly. */
AVER(PoolHasAddr(pool, base));
/* .tract.chain: chain first tracts through TractP(tract) */
tract = TractOfBaseAddr(PoolArena(pool), base);
AVER(TractPool(tract) == pool);
TractSetP(tract, (void *)mfs->tractList);
mfs->tractList = tract;
/* Update accounting */
mfs->total += size;
mfs->free += size;
/* Sew together all the new empty units in the region, working down */
/* from the top so that they are in ascending order of address on the */
/* free list. */
unitSize = mfs->unitSize;
unitsPerExtent = size/unitSize;
AVER(unitsPerExtent > 0);
#define SUB(b, s, i) ((Header)AddrAdd(b, (s)*(i)))
for(i = 0; i < unitsPerExtent; ++i)
{
header = SUB(base, unitSize, unitsPerExtent-i - 1);
AVER(AddrIsAligned(header, pool->alignment));
AVER(AddrAdd((Addr)header, unitSize) <= AddrAdd(base, size));
header->next = mfs->freeList;
mfs->freeList = header;
}
#undef SUB
}
static Res MFSAlloc(Addr *pReturn, Pool pool, Size size,
Bool withReservoirPermit)
{
Header f;
Res res;
MFS mfs;
AVERT(Pool, pool);
mfs = PoolPoolMFS(pool);
AVERT(MFS, mfs);
AVER(pReturn != NULL);
AVER(size == mfs->unroundedUnitSize);
AVERT(Bool, withReservoirPermit);
f = mfs->freeList;
/* If the free list is empty then extend the pool with a new region. */
if(f == NULL)
{
Addr base;
if (!mfs->extendSelf)
return ResLIMIT;
/* Create a new region and attach it to the pool. */
res = ArenaAlloc(&base, SegPrefDefault(), mfs->extendBy, pool,
withReservoirPermit);
if(res != ResOK)
return res;
MFSExtend(pool, base, mfs->extendBy);
/* The first unit in the region is now the head of the new free list. */
f = mfs->freeList;
}
AVER(f != NULL);
/* Detach the first free unit from the free list and return its address. */
mfs->freeList = f->next;
AVER(mfs->free >= mfs->unitSize);
mfs->free -= mfs->unitSize;
*pReturn = (Addr)f;
return ResOK;
}
void MFSFinishTracts(Pool pool, MFSTractVisitor visitor,
void *closureP, Size closureS)
{
MFS mfs;
AVERT(Pool, pool);
mfs = PoolPoolMFS(pool);
AVERT(MFS, mfs);
while (mfs->tractList != NULL) {
Tract nextTract = (Tract)TractP(mfs->tractList); /* .tract.chain */
visitor(pool, TractBase(mfs->tractList), mfs->extendBy, closureP, closureS);
mfs->tractList = nextTract;
}
}
static Res MFSInit(Pool pool, ArgList args)
{
Size extendBy = MFS_EXTEND_BY_DEFAULT;
Bool extendSelf = TRUE;
Size unitSize;
MFS mfs;
Arena arena;
ArgStruct arg;
AVER(pool != NULL);
AVERT(ArgList, args);
ArgRequire(&arg, args, MPS_KEY_MFS_UNIT_SIZE);
unitSize = arg.val.size;
if (ArgPick(&arg, args, MPS_KEY_EXTEND_BY))
extendBy = arg.val.size;
else {
if (extendBy < unitSize)
extendBy = unitSize;
}
if (ArgPick(&arg, args, MFSExtendSelf))
extendSelf = arg.val.b;
AVER(extendBy >= unitSize);
AVERT(Bool, extendSelf);
mfs = PoolPoolMFS(pool);
arena = PoolArena(pool);
mfs->unroundedUnitSize = unitSize;
if (unitSize < UNIT_MIN)
unitSize = UNIT_MIN;
unitSize = SizeAlignUp(unitSize, MPS_PF_ALIGN);
extendBy = SizeAlignUp(extendBy, ArenaAlign(arena));
mfs->extendBy = extendBy;
mfs->extendSelf = extendSelf;
mfs->unitSize = unitSize;
mfs->freeList = NULL;
mfs->tractList = NULL;
mfs->sig = MFSSig;
AVERT(MFS, mfs);
EVENT5(PoolInitMFS, pool, arena, extendBy, BOOL(extendSelf), unitSize);
return ResOK;
}
static void MFSFree(Pool pool, Addr old, Size size)
{
Header h;
MFS mfs;
AVERT(Pool, pool);
mfs = PoolPoolMFS(pool);
AVERT(MFS, mfs);
AVER(old != (Addr)0);
AVER(size == mfs->unroundedUnitSize);
/* .freelist.fragments */
h = (Header)old;
h->next = mfs->freeList;
mfs->freeList = h;
}
static Res MFSDescribe(Pool pool, mps_lib_FILE *stream)
{
MFS mfs;
Res res;
AVERT(Pool, pool);
mfs = PoolPoolMFS(pool);
AVERT(MFS, mfs);
AVER(stream != NULL);
res = WriteF(stream,
" unrounded unit size $W\n", (WriteFW)mfs->unroundedUnitSize,
" unit size $W\n", (WriteFW)mfs->unitSize,
" extent size $W\n", (WriteFW)mfs->extendBy,
" free list begins at $P\n", (WriteFP)mfs->freeList,
" tract list begin at $P\n", (WriteFP)mfs->tractList,
NULL);
if(res != ResOK) return res;
return ResOK;
}
