diff --git a/code/dbgpool.c b/code/dbgpool.c index 54ab6864bb..306bcf8177 100644 --- a/code/dbgpool.c +++ b/code/dbgpool.c @@ -356,12 +356,12 @@ static void debugPoolSegIterate(Arena arena, Addr base, Addr limit, static void debugPoolShieldExpose(Arena arena, Seg seg) { - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); } static void debugPoolShieldCover(Arena arena, Seg seg) { - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); } diff --git a/code/global.c b/code/global.c index 6c7cd39b94..12223f342a 100644 --- a/code/global.c +++ b/code/global.c @@ -78,7 +78,7 @@ void GlobalsReleaseAll(void) static void arenaReinitLock(Arena arena) { AVERT(Arena, arena); - ShieldLeave(arena); + ShieldLeave(ArenaShield(arena)); LockInit(ArenaGlobals(arena)->lock); } @@ -579,7 +579,7 @@ void ArenaEnterLock(Arena arena, Bool recursive) if(recursive) { /* already in shield */ } else { - ShieldEnter(arena); + ShieldEnter(ArenaShield(arena)); } } @@ -611,7 +611,7 @@ void ArenaLeaveLock(Arena arena, Bool recursive) if(recursive) { /* no need to leave shield */ } else { - ShieldLeave(arena); + ShieldLeave(ArenaShield(arena)); } ProtSync(arena); /* */ if(recursive) { @@ -917,9 +917,9 @@ Ref ArenaPeekSeg(Arena arena, Seg seg, Ref *p) /* We don't need to update the Seg Summary as in PoolSingleAccess * because we are not changing it after it has been scanned. */ - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); ref = *p; - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); return ref; } @@ -953,12 +953,12 @@ void ArenaPokeSeg(Arena arena, Seg seg, Ref *p, Ref ref) /* TODO: Consider checking p's alignment using seg->pool->alignment */ /* ref is arbitrary and can't be checked */ - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); *p = ref; summary = SegSummary(seg); summary = RefSetAdd(arena, summary, (Addr)ref); SegSetSummary(seg, summary); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); } /* ArenaRead -- like ArenaPeek, but reference known to be owned by arena */ diff --git a/code/ld.c b/code/ld.c index 483c2f90cb..51342e786f 100644 --- a/code/ld.c +++ b/code/ld.c @@ -149,11 +149,11 @@ void LDReset(mps_ld_t ld, Arena arena) b = SegOfAddr(&seg, arena, (Addr)ld); if (b) - ShieldExpose(arena, seg); /* .ld.access */ + ShieldExpose(ArenaShield(arena), seg); /* .ld.access */ ld->_epoch = ArenaHistory(arena)->epoch; ld->_rs = RefSetEMPTY; if (b) - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); } diff --git a/code/mpm.h b/code/mpm.h index 9979d20180..a5941ec4c7 100644 --- a/code/mpm.h +++ b/code/mpm.h @@ -872,37 +872,38 @@ extern ZoneSet ZoneSetBlacklist(Arena arena); /* Shield Interface -- see */ +#define ShieldArena(shield) PARENT(ArenaStruct, shieldStruct, shield) extern void ShieldInit(Shield shield); extern void ShieldFinish(Shield shield); extern Bool ShieldCheck(Shield shield); extern Res ShieldDescribe(Shield shield, mps_lib_FILE *stream, Count depth); extern void ShieldDestroyQueue(Shield shield, Arena arena); -extern void (ShieldRaise)(Arena arena, Seg seg, AccessSet mode); -extern void (ShieldLower)(Arena arena, Seg seg, AccessSet mode); -extern void (ShieldEnter)(Arena arena); -extern void (ShieldLeave)(Arena arena); -extern void (ShieldExpose)(Arena arena, Seg seg); -extern void (ShieldCover)(Arena arena, Seg seg); -extern void (ShieldHold)(Arena arena); -extern void (ShieldRelease)(Arena arena); -extern void (ShieldFlush)(Arena arena); +extern void (ShieldRaise)(Shield shield, Seg seg, AccessSet mode); +extern void (ShieldLower)(Shield shield, Seg seg, AccessSet mode); +extern void (ShieldEnter)(Shield shield); +extern void (ShieldLeave)(Shield shield); +extern void (ShieldExpose)(Shield shield, Seg seg); +extern void (ShieldCover)(Shield shield, Seg seg); +extern void (ShieldHold)(Shield shield); +extern void (ShieldRelease)(Shield shield); +extern void (ShieldFlush)(Shield shield); #if defined(SHIELD) /* Nothing to do: functions declared in all shield configurations. */ #elif defined(SHIELD_NONE) -#define ShieldRaise(arena, seg, mode) \ - BEGIN UNUSED(arena); UNUSED(seg); UNUSED(mode); END -#define ShieldLower(arena, seg, mode) \ - BEGIN UNUSED(arena); UNUSED(seg); UNUSED(mode); END -#define ShieldEnter(arena) BEGIN UNUSED(arena); END -#define ShieldLeave(arena) AVER(arena->busyTraces == TraceSetEMPTY) -#define ShieldExpose(arena, seg) \ - BEGIN UNUSED(arena); UNUSED(seg); END -#define ShieldCover(arena, seg) \ - BEGIN UNUSED(arena); UNUSED(seg); END -#define ShieldHold(arena) BEGIN UNUSED(arena); END -#define ShieldRelease(arena) BEGIN UNUSED(arena); END -#define ShieldFlush(arena) BEGIN UNUSED(arena); END +#define ShieldRaise(shield, seg, mode) \ + BEGIN UNUSED(shield); UNUSED(seg); UNUSED(mode); END +#define ShieldLower(shield, seg, mode) \ + BEGIN UNUSED(shield); UNUSED(seg); UNUSED(mode); END +#define ShieldEnter(shield) BEGIN UNUSED(shield); END +#define ShieldLeave(shield) AVER(ShieldArena(shield)->busyTraces == TraceSetEMPTY) +#define ShieldExpose(shield, seg) \ + BEGIN UNUSED(shield); UNUSED(seg); END +#define ShieldCover(shield, seg) \ + BEGIN UNUSED(shield); UNUSED(seg); END +#define ShieldHold(shield) BEGIN UNUSED(shield); END +#define ShieldRelease(shield) BEGIN UNUSED(shield); END +#define ShieldFlush(shield) BEGIN UNUSED(shield); END #else #error "No shield configuration." #endif /* SHIELD */ diff --git a/code/poolamc.c b/code/poolamc.c index 8a29aee552..a22ef0e2e6 100644 --- a/code/poolamc.c +++ b/code/poolamc.c @@ -985,9 +985,9 @@ static Res AMCBufferFill(Addr *baseReturn, Addr *limitReturn, AVER(SizeIsAligned(padSize, PoolAlignment(pool))); AVER(AddrAdd(limit, padSize) == SegLimit(seg)); if(padSize > 0) { - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); (*pool->format->pad)(limit, padSize); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); } } @@ -1032,9 +1032,9 @@ static void amcSegBufferEmpty(Seg seg, Buffer buffer) /* */ if (init < limit) { - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); (*pool->format->pad)(init, AddrOffset(init, limit)); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); } /* Any allocation in the buffer (including the padding object just @@ -1508,9 +1508,9 @@ static Res amcSegFixEmergency(Seg seg, ScanState ss, Ref *refIO) if(ss->rank == RankAMBIG) goto fixInPlace; - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); newRef = (*pool->format->isMoved)(*refIO); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); if(newRef != (Addr)0) { /* Object has been forwarded already, so snap-out pointer. */ /* TODO: Implement weak pointer semantics in emergency fixing. This @@ -1592,7 +1592,7 @@ static Res amcSegFix(Seg seg, ScanState ss, Ref *refIO) /* .exposed.seg: Statements tagged ".exposed.seg" below require */ /* that "seg" (that is: the 'from' seg) has been ShieldExposed. */ - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); newRef = (*format->isMoved)(ref); /* .exposed.seg */ if(newRef == (Addr)0) { @@ -1637,7 +1637,7 @@ static Res amcSegFix(Seg seg, ScanState ss, Ref *refIO) newRef = AddrAdd(newBase, headerSize); toSeg = BufferSeg(buffer); - ShieldExpose(arena, toSeg); + ShieldExpose(ArenaShield(arena), toSeg); /* Since we're moving an object from one segment to another, */ /* union the greyness and the summaries together. */ @@ -1653,7 +1653,7 @@ static Res amcSegFix(Seg seg, ScanState ss, Ref *refIO) /* */ (void)AddrCopy(newBase, base, length); /* .exposed.seg */ - ShieldCover(arena, toSeg); + ShieldCover(ArenaShield(arena), toSeg); } while (!BUFFER_COMMIT(buffer, newBase, length)); STATISTIC(ss->copiedSize += length); @@ -1675,7 +1675,7 @@ static Res amcSegFix(Seg seg, ScanState ss, Ref *refIO) res = ResOK; returnRes: - ShieldCover(arena, seg); /* .exposed.seg */ + ShieldCover(ArenaShield(arena), seg); /* .exposed.seg */ return res; } @@ -1706,7 +1706,7 @@ static void amcSegReclaimNailed(Pool pool, Trace trace, Seg seg) /* see for improvements */ headerSize = format->headerSize; - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); p = SegBase(seg); limit = SegBufferScanLimit(seg); padBase = p; @@ -1753,7 +1753,7 @@ static void amcSegReclaimNailed(Pool pool, Trace trace, Seg seg) (*format->pad)(padBase, padLength); STATISTIC(bytesReclaimed += padLength); } - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); SegSetNailed(seg, TraceSetDel(SegNailed(seg), trace)); SegSetWhite(seg, TraceSetDel(SegWhite(seg), trace)); @@ -1887,9 +1887,9 @@ static void amcWalkAll(Pool pool, FormattedObjectsVisitor f, void *p, size_t s) RING_FOR(node, ring, next) { Seg seg = SegOfPoolRing(node); - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); amcSegWalk(seg, format, f, p, s); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); } } diff --git a/code/poolams.c b/code/poolams.c index a76c5a86d8..7a24da0fca 100644 --- a/code/poolams.c +++ b/code/poolams.c @@ -1491,10 +1491,11 @@ static Res amsSegFix(Seg seg, ScanState ss, Ref *refIO) if (SegRankSet(seg) == RankSetEMPTY && ss->rank != RankAMBIG) { /* */ Addr clientNext, next; + Shield shield = ArenaShield(PoolArena(pool)); - ShieldExpose(PoolArena(pool), seg); + ShieldExpose(shield, seg); clientNext = (*pool->format->skip)(clientRef); - ShieldCover(PoolArena(pool), seg); + ShieldCover(shield, seg); next = AddrSub(clientNext, format->headerSize); /* Part of the object might be grey, because of ambiguous */ /* fixes, but that's OK, because scan will ignore that. */ diff --git a/code/poolawl.c b/code/poolawl.c index 17347d7af5..4e60d1bc9c 100644 --- a/code/poolawl.c +++ b/code/poolawl.c @@ -869,7 +869,7 @@ static Res awlScanObject(Arena arena, AWL awl, ScanState ss, dependent = SegOfAddr(&dependentSeg, arena, dependentObject); if (dependent) { /* */ - ShieldExpose(arena, dependentSeg); + ShieldExpose(ArenaShield(arena), dependentSeg); /* */ SegSetSummary(dependentSeg, RefSetUNIV); } @@ -877,7 +877,7 @@ static Res awlScanObject(Arena arena, AWL awl, ScanState ss, res = TraceScanFormat(ss, base, limit); if (dependent) - ShieldCover(arena, dependentSeg); + ShieldCover(ArenaShield(arena), dependentSeg); return res; } diff --git a/code/poolmrg.c b/code/poolmrg.c index 426aaf8667..631fd64a07 100644 --- a/code/poolmrg.c +++ b/code/poolmrg.c @@ -829,13 +829,13 @@ static Res MRGDescribe(Inst inst, mps_lib_FILE *stream, Count depth) Bool outsideShield = !ArenaShield(arena)->inside; refPart = MRGRefPartOfLink(linkOfRing(node), arena); if (outsideShield) { - ShieldEnter(arena); + ShieldEnter(ArenaShield(arena)); } res = WriteF(stream, depth + 2, "at $A Ref $A\n", (WriteFA)refPart, (WriteFA)MRGRefPartRef(arena, refPart), NULL); if (outsideShield) { - ShieldLeave(arena); + ShieldLeave(ArenaShield(arena)); } if (res != ResOK) return res; diff --git a/code/poolsnc.c b/code/poolsnc.c index 6b9d87f21e..75b75b7063 100644 --- a/code/poolsnc.c +++ b/code/poolsnc.c @@ -287,9 +287,9 @@ static void sncRecordFreeSeg(Arena arena, SNC snc, Seg seg) SegSetRankAndSummary(seg, RankSetEMPTY, RefSetEMPTY); /* Pad the whole segment so we don't try to walk it. */ - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); (*SNCPool(snc)->format->pad)(SegBase(seg), SegSize(seg)); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); sncSegSetNext(seg, snc->freeSegs); snc->freeSegs = seg; @@ -498,9 +498,9 @@ static void sncSegBufferEmpty(Seg seg, Buffer buffer) /* Pad the unused space at the end of the segment */ if (init < limit) { - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); (*pool->format->pad)(init, AddrOffset(init, limit)); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); } } diff --git a/code/seg.c b/code/seg.c index 9782e43b3c..e139379116 100644 --- a/code/seg.c +++ b/code/seg.c @@ -194,7 +194,7 @@ static void segAbsFinish(Inst inst) unmapped. This would require tracking of protection independent of the existence of a SegStruct. */ if (seg->sm != AccessSetEMPTY) { - ShieldLower(arena, seg, seg->sm); + ShieldLower(ArenaShield(arena), seg, seg->sm); } seg->rankSet = RankSetEMPTY; @@ -202,7 +202,7 @@ static void segAbsFinish(Inst inst) /* See */ AVER(seg->depth == 0); if (seg->queued) - ShieldFlush(PoolArena(SegPool(seg))); + ShieldFlush(ArenaShield(PoolArena(SegPool(seg)))); AVER(!seg->queued); limit = SegLimit(seg); @@ -624,7 +624,7 @@ Res SegMerge(Seg *mergedSegReturn, Seg segLo, Seg segHi) arena = PoolArena(SegPool(segLo)); if (segLo->queued || segHi->queued) - ShieldFlush(arena); /* see */ + ShieldFlush(ArenaShield(arena)); /* see */ /* Invoke class-specific methods to do the merge */ res = Method(Seg, segLo, merge)(segLo, segHi, base, mid, limit); @@ -678,7 +678,7 @@ Res SegSplit(Seg *segLoReturn, Seg *segHiReturn, Seg seg, Addr at) AVER(!SegBuffer(&buffer, seg) || BufferLimit(buffer) <= at); if (seg->queued) - ShieldFlush(arena); /* see */ + ShieldFlush(ArenaShield(arena)); /* see */ AVER(SegSM(seg) == SegPM(seg)); /* Allocate the new segment object from the control pool */ @@ -1297,7 +1297,7 @@ Res SegSingleAccess(Seg seg, Arena arena, Addr addr, Ref ref; Res res; - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); if(mode & SegSM(seg) & AccessREAD) { /* Read access. */ @@ -1325,7 +1325,7 @@ Res SegSingleAccess(Seg seg, Arena arena, Addr addr, * this is conservative. */ SegSetSummary(seg, RefSetAdd(arena, SegSummary(seg), ref)); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); return ResOK; } else { @@ -1608,10 +1608,10 @@ static void mutatorSegSetGrey(Seg seg, TraceSet grey) flippedTraces = arena->flippedTraces; if (TraceSetInter(oldGrey, flippedTraces) == TraceSetEMPTY) { if (TraceSetInter(grey, flippedTraces) != TraceSetEMPTY) - ShieldRaise(arena, seg, AccessREAD); + ShieldRaise(ArenaShield(arena), seg, AccessREAD); } else { if (TraceSetInter(grey, flippedTraces) == TraceSetEMPTY) - ShieldLower(arena, seg, AccessREAD); + ShieldLower(ArenaShield(arena), seg, AccessREAD); } } @@ -1631,7 +1631,7 @@ static void mutatorSegFlip(Seg seg, Trace trace) /* Raise the read barrier if the segment was not grey for any currently flipped trace. */ if (TraceSetInter(SegGrey(seg), flippedTraces) == TraceSetEMPTY) { - ShieldRaise(arena, seg, AccessREAD); + ShieldRaise(ArenaShield(arena), seg, AccessREAD); } else { /* If the segment is grey for some currently flipped trace then the read barrier must already have been raised, either in this @@ -1702,12 +1702,12 @@ static void mutatorSegSetRankSet(Seg seg, RankSet rankSet) if (oldRankSet == RankSetEMPTY) { if (rankSet != RankSetEMPTY) { AVER_CRITICAL(SegGCSeg(seg)->summary == RefSetEMPTY); - ShieldRaise(PoolArena(SegPool(seg)), seg, AccessWRITE); + ShieldRaise(ArenaShield(PoolArena(SegPool(seg))), seg, AccessWRITE); } } else { if (rankSet == RankSetEMPTY) { AVER_CRITICAL(SegGCSeg(seg)->summary == RefSetEMPTY); - ShieldLower(PoolArena(SegPool(seg)), seg, AccessWRITE); + ShieldLower(ArenaShield(PoolArena(SegPool(seg))), seg, AccessWRITE); } } } @@ -1727,9 +1727,9 @@ static void mutatorSegSyncWriteBarrier(Seg seg) Arena arena = PoolArena(SegPool(seg)); /* Can't check seg -- this function enforces invariants tested by SegCheck. */ if (SegSummary(seg) == RefSetUNIV) - ShieldLower(arena, seg, AccessWRITE); + ShieldLower(ArenaShield(arena), seg, AccessWRITE); else - ShieldRaise(arena, seg, AccessWRITE); + ShieldRaise(ArenaShield(arena), seg, AccessWRITE); } @@ -1888,7 +1888,7 @@ static Res gcSegMerge(Seg seg, Seg segHi, /* This shield won't cope with a partially-protected segment, so flush the shield queue to bring both halves in sync. See also . */ - ShieldFlush(PoolArena(SegPool(seg))); + ShieldFlush(ArenaShield(PoolArena(SegPool(seg)))); } /* Merge the superclass fields via next-method call */ diff --git a/code/shield.c b/code/shield.c index 86d0a4cf3f..dc1a4595eb 100644 --- a/code/shield.c +++ b/code/shield.c @@ -265,16 +265,13 @@ static void shieldSync(Shield shield, Seg seg) * .inv.unsynced.suspended. */ -static void shieldSuspend(Arena arena) +static void shieldSuspend(Shield shield) { - Shield shield; - - AVERT(Arena, arena); - shield = ArenaShield(arena); AVERT(Shield, shield); AVER(shield->inside); if (!shield->suspended) { + Arena arena = ShieldArena(shield); ThreadRingSuspend(ArenaThreadRing(arena), ArenaDeadRing(arena)); shield->suspended = TRUE; } @@ -288,11 +285,11 @@ static void shieldSuspend(Arena arena) * when we must scan all thread registers at once. */ -void (ShieldHold)(Arena arena) +void (ShieldHold)(Shield shield) { - AVERT(Arena, arena); - shieldSuspend(arena); - ++ArenaShield(arena)->holds; + AVERT(Shield, shield); + shieldSuspend(shield); + ++shield->holds; } @@ -302,16 +299,11 @@ void (ShieldHold)(Arena arena) * this marks the earliest point at which we could resume. */ -void (ShieldRelease)(Arena arena) +void (ShieldRelease)(Shield shield) { - Shield shield; - - AVERT(Arena, arena); - shield = ArenaShield(arena); AVERT(Shield, shield); AVER(shield->inside); AVER(shield->suspended); - AVER(shield->holds > 0); --shield->holds; @@ -444,6 +436,7 @@ static void shieldFlushEntries(Shield shield) shieldQueueEntryCompare, UNUSED_POINTER, &shield->sortStruct); + /* Coalesce runs of segments that need the same protection mode. */ mode = AccessSetEMPTY; limit = NULL; for (i = 0; i < shield->limit; ++i) { @@ -480,13 +473,9 @@ static void shieldFlushEntries(Shield shield) * queued and the mutator is suspended. */ -static void shieldQueue(Arena arena, Seg seg) +static void shieldQueue(Shield shield, Seg seg) { - Shield shield; - /* */ - AVERT_CRITICAL(Arena, arena); - shield = ArenaShield(arena); AVERT_CRITICAL(Shield, shield); SHIELD_AVERT_CRITICAL(Seg, seg); @@ -501,7 +490,7 @@ static void shieldQueue(Arena arena, Seg seg) segment, then raise the shield on it. In this case, the mutator isn't allowed to see the segment, but we don't need to queue it until its covered. */ - shieldSuspend(arena); + shieldSuspend(shield); return; } @@ -518,7 +507,7 @@ static void shieldQueue(Arena arena, Seg seg) else length = shield->length * 2; - res = ControlAlloc(&p, arena, length * sizeof shield->queue[0]); + res = ControlAlloc(&p, ShieldArena(shield), length * sizeof shield->queue[0]); if (res != ResOK) { AVER(ResIsAllocFailure(res)); /* Carry on with the existing queue. */ @@ -527,7 +516,7 @@ static void shieldQueue(Arena arena, Seg seg) Size oldSize = shield->length * sizeof shield->queue[0]; AVER(shield->queue != NULL); mps_lib_memcpy(p, shield->queue, oldSize); - ControlFree(arena, shield->queue, oldSize); + ControlFree(ShieldArena(shield), shield->queue, oldSize); } shield->queue = p; shield->length = length; @@ -579,37 +568,30 @@ static void shieldQueue(Arena arena, Seg seg) * covered and the shield queue is unavailable. */ -void (ShieldRaise)(Arena arena, Seg seg, AccessSet mode) +void (ShieldRaise)(Shield shield, Seg seg, AccessSet mode) { - Shield shield; - - SHIELD_AVERT(Arena, arena); + SHIELD_AVERT(Shield, shield); SHIELD_AVERT(Seg, seg); AVERT(AccessSet, mode); - shield = ArenaShield(arena); - AVERT(Shield, shield); /* preserved */ - shieldSetSM(ArenaShield(arena), seg, BS_UNION(SegSM(seg), mode)); + shieldSetSM(shield, seg, BS_UNION(SegSM(seg), mode)); /* Ensure and */ - shieldQueue(arena, seg); + shieldQueue(shield, seg); /* Check queue and segment consistency. */ - AVERT(Arena, arena); + AVERT(Shield, shield); /* FIXME: Does this acheive the above comment? */ AVERT(Seg, seg); } /* ShieldLower -- declare segment may be accessed by mutator */ -void (ShieldLower)(Arena arena, Seg seg, AccessSet mode) +void (ShieldLower)(Shield shield, Seg seg, AccessSet mode) { - Shield shield; - - AVERT(Arena, arena); - shield = ArenaShield(arena); + AVERT(Shield, shield); SHIELD_AVERT(Seg, seg); AVERT(AccessSet, mode); @@ -620,23 +602,19 @@ void (ShieldLower)(Arena arena, Seg seg, AccessSet mode) /* TODO: Do we need to promptly call shieldProtLower here? It loses the opportunity to coalesce the protection call. It would violate . */ - /* shieldQueue(arena, seg); */ + /* shieldQueue(shield, seg); */ shieldProtLower(shield, seg, mode); /* Check queue and segment consistency. */ - AVERT(Arena, arena); + AVERT(Shield, shield); /* FIXME: Does this acheive the above comment? */ AVERT(Seg, seg); } /* ShieldEnter -- enter the shield, allowing exposes */ -void (ShieldEnter)(Arena arena) +void (ShieldEnter)(Shield shield) { - Shield shield; - - AVERT(Arena, arena); - shield = ArenaShield(arena); AVERT(Shield, shield); AVER(!shield->inside); AVER(shield->depth == 0); @@ -661,9 +639,9 @@ void (ShieldEnter)(Arena arena) */ #if defined(SHIELD_DEBUG) -static void shieldDebugCheck(Arena arena) +static void shieldDebugCheck(Shield shield) { - Shield shield; + Arena arena; Seg seg; Count queued = 0; Count depth = 0; @@ -671,12 +649,11 @@ static void shieldDebugCheck(Arena arena) Count unsynced = 0; Count synced = 0; - AVERT(Arena, arena); - shield = ArenaShield(arena); AVERT(Shield, shield); AVER(shield->inside || shield->limit == 0); - if (SegFirst(&seg, arena)) + arena = ShieldArena(shield); + if (SegFirst(&seg, arena)) { do { depth += SegDepth(seg); if (shield->limit == 0) { @@ -695,6 +672,7 @@ static void shieldDebugCheck(Arena arena) if (!seg->queued && !SegIsSynced(seg)) ++unqueued; } while(SegNext(&seg, arena, seg)); + } AVER(depth == shield->depth); AVER(queued == shield->limit); @@ -721,44 +699,37 @@ static void shieldDebugCheck(Arena arena) * . */ -void (ShieldFlush)(Arena arena) +void (ShieldFlush)(Shield shield) { - Shield shield; - - AVERT(Arena, arena); - shield = ArenaShield(arena); AVERT(Shield, shield); #ifdef SHIELD_DEBUG - shieldDebugCheck(arena); + shieldDebugCheck(shield); #endif shieldFlushEntries(shield); AVER(shield->unsynced == 0); /* everything back in sync */ #ifdef SHIELD_DEBUG - shieldDebugCheck(arena); + shieldDebugCheck(shield); #endif } /* ShieldLeave -- leave the shield, protect segs from mutator */ -void (ShieldLeave)(Arena arena) +void (ShieldLeave)(Shield shield) { - Shield shield; - - AVERT(Arena, arena); - shield = ArenaShield(arena); AVERT(Shield, shield); AVER(shield->inside); AVER(shield->depth == 0); /* no pending covers */ AVER(shield->holds == 0); - ShieldFlush(arena); + ShieldFlush(shield); AVER(shield->unsynced == 0); /* everything back in sync */ /* Ensuring the mutator is running at this point guarantees .inv.outside.running */ if (shield->suspended) { + Arena arena = ShieldArena(shield); ThreadRingResume(ArenaThreadRing(arena), ArenaDeadRing(arena)); shield->suspended = FALSE; } @@ -774,15 +745,12 @@ void (ShieldLeave)(Arena arena) * ensure the MPS has exclusive access. */ -void (ShieldExpose)(Arena arena, Seg seg) +void (ShieldExpose)(Shield shield, Seg seg) { - Shield shield; AccessSet mode = AccessREAD | AccessWRITE; /* */ - AVERT_CRITICAL(Arena, arena); - shield = ArenaShield(arena); - AVERT(Shield, shield); + AVERT_CRITICAL(Shield, shield); AVER_CRITICAL(shield->inside); SegSetDepth(seg, SegDepth(seg) + 1); @@ -791,7 +759,7 @@ void (ShieldExpose)(Arena arena, Seg seg) AVER_CRITICAL(shield->depth > 0); /* overflow */ if (BS_INTER(SegPM(seg), mode) != AccessSetEMPTY) - shieldSuspend(arena); + shieldSuspend(shield); /* Ensure . */ /* TODO: Mass exposure -- see @@ -802,13 +770,9 @@ void (ShieldExpose)(Arena arena, Seg seg) /* ShieldCover -- declare MPS no longer needs access to seg */ -void (ShieldCover)(Arena arena, Seg seg) +void (ShieldCover)(Shield shield, Seg seg) { - Shield shield; - /* */ - AVERT_CRITICAL(Arena, arena); - shield = ArenaShield(arena); AVERT_CRITICAL(Shield, shield); AVERT_CRITICAL(Seg, seg); AVER_CRITICAL(SegPM(seg) == AccessSetEMPTY); @@ -819,7 +783,7 @@ void (ShieldCover)(Arena arena, Seg seg) --shield->depth; /* Ensure . */ - shieldQueue(arena, seg); + shieldQueue(shield, seg); } diff --git a/code/trace.c b/code/trace.c index 27799698da..faccb5b727 100644 --- a/code/trace.c +++ b/code/trace.c @@ -454,7 +454,7 @@ Res TraceCondemnEnd(double *mortalityReturn, Trace trace) AVER(trace->state == TraceINIT); AVER(trace->white == ZoneSetEMPTY); - ShieldHold(trace->arena); + ShieldHold(ArenaShield(trace->arena)); RING_FOR(genNode, &trace->genRing, genNext) { Size condemnedBefore, condemnedGen; Ring segNode, segNext; @@ -472,7 +472,7 @@ Res TraceCondemnEnd(double *mortalityReturn, Trace trace) condemnedGen = trace->condemned - condemnedBefore; casualtySize += (Size)((double)condemnedGen * gen->mortality); } - ShieldRelease(trace->arena); + ShieldRelease(ArenaShield(trace->arena)); if (TraceIsEmpty(trace)) return ResFAIL; @@ -489,7 +489,7 @@ Res TraceCondemnEnd(double *mortalityReturn, Trace trace) triggered. In that case, we'll have to recover here by blackening the segments again. */ AVER(TraceIsEmpty(trace)); - ShieldRelease(trace->arena); + ShieldRelease(ArenaShield(trace->arena)); return res; } @@ -624,7 +624,7 @@ static Res traceFlip(Trace trace) arena = trace->arena; rfc.arena = arena; - ShieldHold(arena); + ShieldHold(ArenaShield(arena)); AVER(trace->state == TraceUNFLIPPED); AVER(!TraceSetIsMember(arena->flippedTraces, trace)); @@ -681,11 +681,11 @@ static Res traceFlip(Trace trace) EVENT2(TraceFlipEnd, trace, arena); - ShieldRelease(arena); + ShieldRelease(ArenaShield(arena)); return ResOK; failRootFlip: - ShieldRelease(arena); + ShieldRelease(ArenaShield(arena)); return res; } @@ -1202,10 +1202,10 @@ static Res traceScanSegRes(TraceSet ts, Rank rank, Arena arena, Seg seg) ScanStateInitSeg(ss, ts, arena, rank, white, seg); /* Expose the segment to make sure we can scan it. */ - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); res = SegScan(&wasTotal, seg, ss); /* Cover, regardless of result */ - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); traceSetUpdateCounts(ts, arena, ss, traceAccountingPhaseSegScan); /* Count segments scanned pointlessly */ @@ -1473,7 +1473,7 @@ static Res traceScanSingleRefRes(TraceSet ts, Rank rank, Arena arena, } ScanStateInit(&ss, ts, arena, rank, white); - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); TRACE_SCAN_BEGIN(&ss) { res = TRACE_FIX12(&ss, refIO); @@ -1483,7 +1483,7 @@ static Res traceScanSingleRefRes(TraceSet ts, Rank rank, Arena arena, summary = SegSummary(seg); summary = RefSetAdd(arena, summary, *refIO); SegSetSummary(seg, summary); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); traceSetUpdateCounts(ts, arena, &ss, traceAccountingPhaseSingleScan); ScanStateFinish(&ss); diff --git a/code/walk.c b/code/walk.c index 853198303e..2af6d56f24 100644 --- a/code/walk.c +++ b/code/walk.c @@ -75,9 +75,9 @@ static void ArenaFormattedObjectsWalk(Arena arena, FormattedObjectsVisitor f, if (SegFirst(&seg, arena)) { do { if (PoolFormat(&format, SegPool(seg))) { - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); SegWalk(seg, format, f, p, s); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); } } while(SegNext(&seg, arena, seg)); } @@ -476,9 +476,9 @@ static Res poolWalk(Arena arena, Pool pool, mps_area_scan_t area_scan, void *clo ScanStateSetSummary(&ss, RefSetEMPTY); /* Expose the segment to make sure we can scan it. */ - ShieldExpose(arena, seg); + ShieldExpose(ArenaShield(arena), seg); res = SegScan(&wasTotal, seg, &ss); - ShieldCover(arena, seg); + ShieldCover(ArenaShield(arena), seg); if (needSummary) ScanStateUpdateSummary(&ss, seg, res == ResOK && wasTotal);