static void isResRange(void)
{
if (checkDefaultRange(0)) {
Bool b = BTIsResRange(bt, args[0], args[1]);
puts(b ? "TRUE" : "FALSE");
}
}
void ChunkFinish(Chunk chunk)
{
Arena arena;
AVERT(Chunk, chunk);
AVER(BTIsResRange(chunk->allocTable, 0, chunk->pages));
arena = ChunkArena(chunk);
if (arena->hasFreeLand)
ArenaFreeLandDelete(arena,
PageIndexBase(chunk, chunk->allocBase),
chunk->limit);
ArenaChunkRemoved(arena, chunk);
chunk->sig = SigInvalid;
TreeFinish(&chunk->chunkTree);
RingRemove(&chunk->arenaRing);
/* Finish all other fields before class finish, because they might be */
/* unmapped there. */
Method(Arena, arena, chunkFinish)(chunk);
}
static Bool checkCBSAction(CBS cbs, CBSBlock cbsBlock, void *p)
{
Addr base, limit;
CheckCBSClosure closure = (CheckCBSClosure)p;
/* Don't need to check cbs every time */
UNUSED(cbs);
Insist(closure != NULL);
base = CBSBlockBase(cbsBlock);
limit = CBSBlockLimit(cbsBlock);
if (base > closure->oldLimit) {
Insist(BTIsSetRange(closure->allocTable,
indexOfAddr(closure->base, closure->oldLimit),
indexOfAddr(closure->base, base)));
} else { /* must be at start of table */
Insist(base == closure->oldLimit);
Insist(closure->oldLimit == closure->base);
}
Insist(BTIsResRange(closure->allocTable,
indexOfAddr(closure->base, base),
indexOfAddr(closure->base, limit)));
closure->oldLimit = limit;
return TRUE;
}
static Bool checkCallback(Range range, void *closureP, Size closureS)
{
Addr base, limit;
CheckFBMClosure cl = (CheckFBMClosure)closureP;
UNUSED(closureS);
Insist(cl != NULL);
base = RangeBase(range);
limit = RangeLimit(range);
if (base > cl->oldLimit) {
Insist(BTIsSetRange(cl->state->allocTable,
indexOfAddr(cl->state, cl->oldLimit),
indexOfAddr(cl->state, base)));
} else { /* must be at start of table */
Insist(base == cl->oldLimit);
Insist(cl->oldLimit == cl->state->block);
}
Insist(BTIsResRange(cl->state->allocTable,
indexOfAddr(cl->state, base),
indexOfAddr(cl->state, limit)));
cl->oldLimit = limit;
return TRUE;
}
static Bool AMSSegRegionIsFree(Seg seg, Addr base, Addr limit)
{
AMSSeg amsseg = MustBeA(AMSSeg, seg);
Index baseIndex = PoolIndexOfAddr(SegBase(seg), SegPool(seg), base);
if (amsseg->allocTableInUse) {
Index limitIndex = PoolIndexOfAddr(SegBase(seg), SegPool(seg), limit);
return BTIsResRange(amsseg->allocTable, baseIndex, limitIndex);
} else {
return amsseg->firstFree <= baseIndex;
}
}
static void test(mps_arena_t arena)
{
BT bt;
Nailboard board;
Align align;
Count nails;
Addr base, limit;
Index i, j, k;
align = (Align)1 << (rnd() % 10);
nails = (Count)1 << (rnd() % 16);
nails += rnd() % nails;
base = AddrAlignUp(0, align);
limit = AddrAdd(base, nails * align);
die(BTCreate(&bt, arena, nails), "BTCreate");
BTResRange(bt, 0, nails);
die(NailboardCreate(&board, arena, align, base, limit), "NailboardCreate");
for (i = 0; i <= nails / 8; ++i) {
Bool old;
j = rnd() % nails;
old = BTGet(bt, j);
BTSet(bt, j);
cdie(NailboardSet(board, AddrAdd(base, j * align)) == old, "NailboardSet");
for (k = 0; k < nails / 8; ++k) {
Index b, l;
b = rnd() % nails;
l = b + rnd() % (nails - b) + 1;
cdie(BTIsResRange(bt, b, l)
== NailboardIsResRange(board, AddrAdd(base, b * align),
AddrAdd(base, l * align)),
"NailboardIsResRange");
}
}
die(NailboardDescribe(board, mps_lib_get_stdout(), 0), "NailboardDescribe");
}
/* AMSAllocateRange -- set a range to be allocated
*
* Used as a means of overriding the behaviour of AMSBufferFill.
* The code is similar to AMSUnallocateRange.
*/
static void AMSAllocateRange(AMS ams, Seg seg, Addr base, Addr limit)
{
AMSSeg amsseg;
Index baseIndex, limitIndex;
Count allocatedGrains;
/* parameters checked by caller */
amsseg = Seg2AMSSeg(seg);
baseIndex = PoolIndexOfAddr(SegBase(seg), SegPool(seg), base);
limitIndex = PoolIndexOfAddr(SegBase(seg), SegPool(seg), limit);
if (amsseg->allocTableInUse) {
/* check that it's not allocated */
AVER(BTIsResRange(amsseg->allocTable, baseIndex, limitIndex));
BTSetRange(amsseg->allocTable, baseIndex, limitIndex);
} else {
/* check that it's not allocated */
AVER(baseIndex >= amsseg->firstFree);
if (baseIndex == amsseg->firstFree) /* is it at the end? */ {
amsseg->firstFree = limitIndex;
} else { /* start using allocTable */
amsseg->allocTableInUse = TRUE;
BTSetRange(amsseg->allocTable, 0, amsseg->firstFree);
if (amsseg->firstFree < amsseg->grains)
BTResRange(amsseg->allocTable, amsseg->firstFree, amsseg->grains);
BTSetRange(amsseg->allocTable, baseIndex, limitIndex);
}
}
allocatedGrains = limitIndex - baseIndex;
AVER(amsseg->freeGrains >= allocatedGrains);
amsseg->freeGrains -= allocatedGrains;
amsseg->bufferedGrains += allocatedGrains;
PoolGenAccountForFill(ams->pgen, AddrOffset(base, limit));
}
static void allocate(FBMState state, Addr base, Addr limit)
{
Res res;
Index ib, il; /* Indexed for base and limit */
Bool isFree;
RangeStruct range, oldRange;
Addr outerBase, outerLimit; /* interval containing [ib, il) */
ib = indexOfAddr(state, base);
il = indexOfAddr(state, limit);
isFree = BTIsResRange(state->allocTable, ib, il);
NAllocateTried++;
if (isFree) {
Size left, right, total; /* Sizes of block and two fragments */
outerBase =
addrOfIndex(state, lastEdge(state->allocTable, ArraySize, ib));
outerLimit =
addrOfIndex(state, nextEdge(state->allocTable, ArraySize, il - 1));
left = AddrOffset(outerBase, base);
right = AddrOffset(limit, outerLimit);
total = AddrOffset(outerBase, outerLimit);
/* TODO: check these values */
UNUSED(left);
UNUSED(right);
UNUSED(total);
} else {
outerBase = outerLimit = NULL;
}
RangeInit(&range, base, limit);
switch (state->type) {
case FBMTypeCBS:
res = CBSDelete(&oldRange, state->the.cbs, &range);
break;
case FBMTypeFreelist:
res = FreelistDelete(&oldRange, state->the.fl, &range);
break;
default:
fail();
return;
}
if (verbose) {
printf("allocate: [%p,%p) -- %s\n",
(void *)base, (void *)limit, isFree ? "succeed" : "fail");
describe(state);
}
if (!isFree) {
die_expect((mps_res_t)res, MPS_RES_FAIL,
"Succeeded in deleting allocated block");
} else { /* isFree */
die_expect((mps_res_t)res, MPS_RES_OK,
"failed to delete free block");
Insist(RangeBase(&oldRange) == outerBase);
Insist(RangeLimit(&oldRange) == outerLimit);
NAllocateSucceeded++;
BTSetRange(state->allocTable, ib, il);
}
}
static void allocate(CBS cbs, Addr block, BT allocTable,
Addr base, Addr limit)
{
Res res;
Index ib, il; /* Indexed for base and limit */
Bool isFree;
ib = indexOfAddr(block, base);
il = indexOfAddr(block, limit);
isFree = BTIsResRange(allocTable, ib, il);
/*
printf("allocate: [%p, %p) -- %s\n",
base, limit, isFree ? "succeed" : "fail");
*/
NAllocateTried++;
if (isFree) {
Addr outerBase, outerLimit; /* interval containing [ib, il) */
Size left, right, total; /* Sizes of block and two fragments */
outerBase =
addrOfIndex(block, lastEdge(allocTable, ArraySize, ib));
outerLimit =
addrOfIndex(block, nextEdge(allocTable, ArraySize, il - 1));
left = AddrOffset(outerBase, base);
right = AddrOffset(limit, outerLimit);
total = AddrOffset(outerBase, outerLimit);
/* based on detailed knowledge of CBS behaviour */
checkExpectations();
if (total >= MinSize && left < MinSize && right < MinSize) {
if (left == (Size)0 && right == (Size)0) {
expectCallback(&CallbackDelete, total, (Addr)0, (Addr)0);
} else if (left >= right) {
expectCallback(&CallbackDelete, total, outerBase, base);
} else {
expectCallback(&CallbackDelete, total, limit, outerLimit);
}
} else if (left >= MinSize && right >= MinSize) {
if (left >= right) {
expectCallback(&CallbackShrink, total, outerBase, base);
expectCallback(&CallbackNew, (Size)0, limit, outerLimit);
} else {
expectCallback(&CallbackNew, (Size)0, outerBase, base);
expectCallback(&CallbackShrink, total, limit, outerLimit);
}
} else if (total >= MinSize) {
if (left >= right) {
Insist(left >= MinSize);
Insist(right < MinSize);
expectCallback(&CallbackShrink, total, outerBase, base);
} else {
Insist(left < MinSize);
Insist(right >= MinSize);
expectCallback(&CallbackShrink, total, limit, outerLimit);
}
}
}
res = CBSDelete(cbs, base, limit);
if (!isFree) {
die_expect((mps_res_t)res, MPS_RES_FAIL,
"Succeeded in deleting allocated block");
} else { /* isFree */
die_expect((mps_res_t)res, MPS_RES_OK,
"failed to delete free block");
NAllocateSucceeded++;
BTSetRange(allocTable, ib, il);
checkExpectations();
}
}
