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
}
Bool TractCheck(Tract tract)
{
if (TractHasPool(tract)) {
CHECKU(Pool, TractPool(tract));
CHECKL(AddrIsArenaGrain(TractBase(tract), TractArena(tract)));
}
if (TractHasSeg(tract)) {
CHECKL(TraceSetCheck(TractWhite(tract)));
CHECKU(Seg, (Seg)TractP(tract));
} else {
CHECKL(TractWhite(tract) == TraceSetEMPTY);
}
return TRUE;
}
Bool PoolOfAddr(Pool *poolReturn, Arena arena, Addr addr)
{
Tract tract;
AVER(poolReturn != NULL);
AVERT(Arena, arena);
if (TractOfAddr(&tract, arena, addr)) {
*poolReturn = TractPool(tract);
return TRUE;
}
return FALSE;
}
static Res SegAbsInit(Seg seg, Pool pool, Addr base, Size size, ArgList args)
{
Arena arena;
Addr addr, limit;
Tract tract;
AVER(seg != NULL);
AVERT(Pool, pool);
arena = PoolArena(pool);
AVER(AddrIsArenaGrain(base, arena));
AVER(SizeIsArenaGrains(size, arena));
AVERT(ArgList, args);
NextMethod(Inst, Seg, init)(CouldBeA(Inst, seg));
limit = AddrAdd(base, size);
seg->limit = limit;
seg->rankSet = RankSetEMPTY;
seg->white = TraceSetEMPTY;
seg->nailed = TraceSetEMPTY;
seg->grey = TraceSetEMPTY;
seg->pm = AccessSetEMPTY;
seg->sm = AccessSetEMPTY;
seg->defer = WB_DEFER_INIT;
seg->depth = 0;
seg->queued = FALSE;
seg->firstTract = NULL;
RingInit(SegPoolRing(seg));
TRACT_FOR(tract, addr, arena, base, limit) {
AVERT(Tract, tract);
AVER(TractP(tract) == NULL);
AVER(!TractHasSeg(tract));
AVER(TractPool(tract) == pool);
AVER(TractWhite(tract) == TraceSetEMPTY);
TRACT_SET_SEG(tract, seg);
if (addr == base) {
AVER(seg->firstTract == NULL);
seg->firstTract = tract;
}
AVER(seg->firstTract != NULL);
}
/* PoolOfRange -- return the pool containing a given range
*
* If all addresses in the range [base, limit) are owned by a single
* pool, update *poolReturn to that pool and return TRUE. Otherwise,
* leave *poolReturn unchanged and return FALSE.
*/
Bool PoolOfRange(Pool *poolReturn, Arena arena, Addr base, Addr limit)
{
Bool havePool = FALSE;
Pool pool = NULL;
Tract tract;
Addr addr, alignedBase, alignedLimit;
AVER(poolReturn != NULL);
AVERT(Arena, arena);
AVER(base < limit);
alignedBase = AddrArenaGrainDown(base, arena);
alignedLimit = AddrArenaGrainUp(limit, arena);
TRACT_FOR(tract, addr, arena, alignedBase, alignedLimit) {
Pool p = TractPool(tract);
if (havePool && pool != p)
return FALSE;
pool = p;
havePool = TRUE;
}
