/* AMSTStressBufferedSeg -- Stress test for a buffered seg
*
* Test splitting or merging a buffered seg.
*
* .bmerge: A merge is performed when the segment had previously
* been split and the segment above meets the constraints (i.e. empty,
* not already attached to a buffer and similar colour)
*
* .bsplit: Whether or not a merge happpened, a split is performed if
* the limit of the buffered region is also the limit of an arena
* grain, and yet does not correspond to the segment limit, provided
* that the part of the segment above the buffer is all free.
*/
static void AMSTStressBufferedSeg(Seg seg, Buffer buffer)
{
AMSTSeg amstseg;
AMST amst;
Arena arena;
Addr limit;
Buffer segBuf;
AVERT(Seg, seg);
AVERT(Buffer, buffer);
AVER(SegBuffer(&segBuf, seg) && segBuf == buffer);
amstseg = Seg2AMSTSeg(seg);
AVERT(AMSTSeg, amstseg);
limit = BufferLimit(buffer);
arena = PoolArena(SegPool(seg));
amst = PoolAMST(SegPool(seg));
AVERT(AMST, amst);
if (amstseg->next != NULL) {
Seg segHi = AMSTSeg2Seg(amstseg->next);
if (AMSSegIsFree(segHi) && SegGrey(segHi) == SegGrey(seg)) {
/* .bmerge */
Seg mergedSeg;
Res res;
res = SegMerge(&mergedSeg, seg, segHi);
if (ResOK == res) {
amst->bmerges++;
printf("J");
} else {
/* deliberate fails only */
AVER(amst->failSegs);
}
}
}
if (SegLimit(seg) != limit &&
AddrIsArenaGrain(limit, arena) &&
AMSSegRegionIsFree(seg, limit, SegLimit(seg))) {
/* .bsplit */
Seg segLo, segHi;
Res res;
res = SegSplit(&segLo, &segHi, seg, limit);
if (ResOK == res) {
amst->bsplits++;
printf("C");
} else {
/* deliberate fails only */
AVER(amst->failSegs);
}
}
}
void PoolReclaim(Pool pool, Trace trace, Seg seg)
{
AVERT_CRITICAL(Pool, pool);
AVERT_CRITICAL(Trace, trace);
AVERT_CRITICAL(Seg, seg);
AVER_CRITICAL(pool->arena == trace->arena);
AVER_CRITICAL(SegPool(seg) == pool);
/* There shouldn't be any grey things left for this trace. */
AVER_CRITICAL(!TraceSetIsMember(SegGrey(seg), trace));
/* Should only be reclaiming segments which are still white. */
AVER_CRITICAL(TraceSetIsMember(SegWhite(seg), trace));
Method(Pool, pool, reclaim)(pool, trace, seg);
}
Res PoolScan(Bool *totalReturn, ScanState ss, Pool pool, Seg seg)
{
AVER(totalReturn != NULL);
AVERT(ScanState, ss);
AVERT(Pool, pool);
AVERT(Seg, seg);
AVER(ss->arena == pool->arena);
/* The segment must belong to the pool. */
AVER(pool == SegPool(seg));
/* We check that either ss->rank is in the segment's
* ranks, or that ss->rank is exact. The check is more complicated if
* we actually have multiple ranks in a seg.
* See <code/trace.c#scan.conservative> */
AVER(ss->rank == RankEXACT || RankSetIsMember(SegRankSet(seg), ss->rank));
/* Should only scan segments which contain grey objects. */
AVER(TraceSetInter(SegGrey(seg), ss->traces) != TraceSetEMPTY);
return Method(Pool, pool, scan)(totalReturn, ss, pool, seg);
}
/* AMSTBufferFill -- the pool class buffer fill method
*
* Calls next method - but possibly splits or merges the chosen
* segment.
*
* .merge: A merge is performed when the next method returns the
* entire segment, this segment had previously been split from the
* segment below, and the segment below is appropriately similar
* (i.e. not already attached to a buffer and similarly coloured)
*
* .split: If we're not merging, a split is performed if the next method
* returns the entire segment, and yet lower half of the segment would
* meet the request.
*/
static Res AMSTBufferFill(Addr *baseReturn, Addr *limitReturn,
Pool pool, Buffer buffer, Size size)
{
Addr base, limit;
Arena arena;
AMS ams;
AMST amst;
Bool b;
Seg seg;
AMSTSeg amstseg;
Res res;
AVERT(Pool, pool);
AVER(baseReturn != NULL);
AVER(limitReturn != NULL);
/* other parameters are checked by next method */
arena = PoolArena(pool);
ams = PoolAMS(pool);
amst = PoolAMST(pool);
/* call next method */
res = NextMethod(Pool, AMSTPool, bufferFill)(&base, &limit, pool, buffer, size);
if (res != ResOK)
return res;
b = SegOfAddr(&seg, arena, base);
AVER(b);
amstseg = Seg2AMSTSeg(seg);
if (SegLimit(seg) == limit && SegBase(seg) == base) {
if (amstseg->prev != NULL) {
Seg segLo = AMSTSeg2Seg(amstseg->prev);
if (!SegHasBuffer(segLo) &&
SegGrey(segLo) == SegGrey(seg) &&
SegWhite(segLo) == SegWhite(seg)) {
/* .merge */
Seg mergedSeg;
Res mres;
AMSUnallocateRange(ams, seg, base, limit);
mres = SegMerge(&mergedSeg, segLo, seg);
if (ResOK == mres) { /* successful merge */
AMSAllocateRange(ams, mergedSeg, base, limit);
/* leave range as-is */
} else { /* failed to merge */
AVER(amst->failSegs); /* deliberate fails only */
AMSAllocateRange(ams, seg, base, limit);
}
}
} else {
Size half = SegSize(seg) / 2;
if (half >= size && SizeIsArenaGrains(half, arena)) {
/* .split */
Addr mid = AddrAdd(base, half);
Seg segLo, segHi;
Res sres;
AMSUnallocateRange(ams, seg, mid, limit);
sres = SegSplit(&segLo, &segHi, seg, mid);
if (ResOK == sres) { /* successful split */
limit = mid; /* range is lower segment */
} else { /* failed to split */
AVER(amst->failSegs); /* deliberate fails only */
AMSAllocateRange(ams, seg, mid, limit);
}
}
}
}
*baseReturn = base;
*limitReturn = limit;
return ResOK;
}
static Res ArenaRootsWalk(Globals arenaGlobals, mps_roots_stepper_t f,
void *p, size_t s)
{
Arena arena;
rootsStepClosureStruct rscStruct;
rootsStepClosure rsc = &rscStruct;
Trace trace;
ScanState ss;
Rank rank;
Res res;
Seg seg;
AVERT(Globals, arenaGlobals);
AVER(FUNCHECK(f));
/* p and s are arbitrary client-provided closure data. */
arena = GlobalsArena(arenaGlobals);
/* Scan all the roots with a minimal trace. Invoke the scanner with a */
/* rootsStepClosure, which is a subclass of ScanState and contains the */
/* client-provided closure. Supply a special fix method in order to */
/* call the client closure. This fix method must perform no tracing */
/* operations of its own. */
res = TraceCreate(&trace, arena, TraceStartWhyWALK);
/* Have to fail if no trace available. Unlikely due to .assume.parked. */
if (res != ResOK)
return res;
/* ArenaRootsWalk only passes references to GCable pools to the client. */
/* NOTE: I'm not sure why this is. RB 2012-07-24 */
if (SegFirst(&seg, arena)) {
do {
if (PoolHasAttr(SegPool(seg), AttrGC)) {
res = TraceAddWhite(trace, seg);
AVER(res == ResOK);
}
} while (SegNext(&seg, arena, seg));
}
/* Make the roots grey so that they are scanned */
res = RootsIterate(arenaGlobals, rootWalkGrey, trace);
/* Make this trace look like any other trace. */
arena->flippedTraces = TraceSetAdd(arena->flippedTraces, trace);
rootsStepClosureInit(rsc, arenaGlobals, trace, RootsWalkFix, f, p, s);
ss = rootsStepClosure2ScanState(rsc);
for(rank = RankAMBIG; rank < RankLIMIT; ++rank) {
ss->rank = rank;
AVERT(ScanState, ss);
res = RootsIterate(arenaGlobals, rootWalk, (void *)ss);
if (res != ResOK)
break;
}
/* Turn segments black again. */
if (SegFirst(&seg, arena)) {
do {
if (PoolHasAttr(SegPool(seg), AttrGC)) {
SegSetGrey(seg, TraceSetDel(SegGrey(seg), trace));
SegSetWhite(seg, TraceSetDel(SegWhite(seg), trace));
}
} while (SegNext(&seg, arena, seg));
}
rootsStepClosureFinish(rsc);
/* Make this trace look like any other finished trace. */
trace->state = TraceFINISHED;
TraceDestroy(trace);
AVER(!ArenaEmergency(arena)); /* There was no allocation. */
return res;
}
