mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2026-03-23 07:12:12 -07:00
Code Issues Projects Releases Wiki Activity

Fix problems identified by rb in review <https://info.ravenbrook.com/mail/2014/06/04/15-13-24/0/>.

Browse source 
Copied from Perforce
 Change: 186449
 ServerID: perforce.ravenbrook.com
This commit is contained in:
Gareth Rees 2014-06-08 20:28:33 +01:00
parent fe20a6e3d8
commit 3c486bd581
12 changed files with 58 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

8
mps/code/arena.c
View file

@ -18,8 +18,8 @@ SRCID(arena, "$Id$");
#define ArenaControlPool(arena) MV2Pool(&(arena)->controlPoolStruct)
#define ArenaCBSBlockPool(arena) (&(arena)->freeCBSBlockPoolStruct.poolStruct)
#define ArenaFreeLand(arena) (&(arena)->freeLandStruct.landStruct)
#define ArenaCBSBlockPool(arena) MFSPool(&(arena)->freeCBSBlockPoolStruct)
#define ArenaFreeLand(arena) CBSLand(&(arena)->freeLandStruct)
/* Forward declarations */
@ -409,7 +409,7 @@ Res ControlInit(Arena arena)
AVERT(Arena, arena);
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, CONTROL_EXTEND_BY);
res = PoolInit(&arena->controlPoolStruct.poolStruct, arena,
res = PoolInit(MV2Pool(&arena->controlPoolStruct), arena,
PoolClassMV(), args);
} MPS_ARGS_END(args);
if (res != ResOK)
@ -425,7 +425,7 @@ void ControlFinish(Arena arena)
{
AVERT(Arena, arena);
arena->poolReady = FALSE;
PoolFinish(&arena->controlPoolStruct.poolStruct);
PoolFinish(MV2Pool(&arena->controlPoolStruct));
}

21
mps/code/cbs.c
View file

@ -26,7 +26,6 @@ SRCID(cbs, "$Id$");
#define CBSBlockSize(block) AddrOffset((block)->base, (block)->limit)
#define cbsLand(cbs) (&((cbs)->landStruct))
#define cbsOfLand(land) PARENT(CBSStruct, landStruct, land)
#define cbsSplay(cbs) (&((cbs)->splayTreeStruct))
#define cbsOfSplay(_splay) PARENT(CBSStruct, splayTreeStruct, _splay)
@ -54,7 +53,7 @@ Bool CBSCheck(CBS cbs)
/* See .enter-leave.simple. */
Land land;
CHECKS(CBS, cbs);
land = cbsLand(cbs);
land = CBSLand(cbs);
CHECKD(Land, land);
CHECKD(SplayTree, cbsSplay(cbs));
CHECKD(Pool, cbs->blockPool);
@ -126,7 +125,7 @@ static Bool cbsTestNode(SplayTree splay, Tree tree,
AVERT(Tree, tree);
AVER(closureP == NULL);
AVER(size > 0);
AVER(IsLandSubclass(cbsLand(cbsOfSplay(splay)), CBSFastLandClass));
AVER(IsLandSubclass(CBSLand(cbsOfSplay(splay)), CBSFastLandClass));
block = cbsBlockOfTree(tree);
@ -142,7 +141,7 @@ static Bool cbsTestTree(SplayTree splay, Tree tree,
AVERT(Tree, tree);
AVER(closureP == NULL);
AVER(size > 0);
AVER(IsLandSubclass(cbsLand(cbsOfSplay(splay)), CBSFastLandClass));
AVER(IsLandSubclass(CBSLand(cbsOfSplay(splay)), CBSFastLandClass));
block = cbsFastBlockOfTree(tree);
@ -158,7 +157,7 @@ static void cbsUpdateFastNode(SplayTree splay, Tree tree)
AVERT_CRITICAL(SplayTree, splay);
AVERT_CRITICAL(Tree, tree);
AVER_CRITICAL(IsLandSubclass(cbsLand(cbsOfSplay(splay)), CBSFastLandClass));
AVER_CRITICAL(IsLandSubclass(CBSLand(cbsOfSplay(splay)), CBSFastLandClass));
maxSize = CBSBlockSize(cbsBlockOfTree(tree));
@ -189,13 +188,13 @@ static void cbsUpdateZonedNode(SplayTree splay, Tree tree)
AVERT_CRITICAL(SplayTree, splay);
AVERT_CRITICAL(Tree, tree);
AVER_CRITICAL(IsLandSubclass(cbsLand(cbsOfSplay(splay)), CBSZonedLandClass));
AVER_CRITICAL(IsLandSubclass(CBSLand(cbsOfSplay(splay)), CBSZonedLandClass));
cbsUpdateFastNode(splay, tree);
zonedBlock = cbsZonedBlockOfTree(tree);
block = &zonedBlock->cbsFastBlockStruct.cbsBlockStruct;
arena = LandArena(cbsLand(cbsOfSplay(splay)));
arena = LandArena(CBSLand(cbsOfSplay(splay)));
zones = ZoneSetOfRange(arena, CBSBlockBase(block), CBSBlockLimit(block));
if (TreeHasLeft(tree))
@ -840,7 +839,7 @@ static Bool cbsFindFirst(Range rangeReturn, Range oldRangeReturn,
AVERT(Land, land);
cbs = cbsOfLand(land);
AVERT(CBS, cbs);
AVER(IsLandSubclass(cbsLand(cbs), CBSFastLandClass));
AVER(IsLandSubclass(CBSLand(cbs), CBSFastLandClass));
AVER(rangeReturn != NULL);
AVER(oldRangeReturn != NULL);
@ -925,7 +924,7 @@ static Bool cbsFindLast(Range rangeReturn, Range oldRangeReturn,
AVERT(Land, land);
cbs = cbsOfLand(land);
AVERT(CBS, cbs);
AVER(IsLandSubclass(cbsLand(cbs), CBSFastLandClass));
AVER(IsLandSubclass(CBSLand(cbs), CBSFastLandClass));
AVER(rangeReturn != NULL);
AVER(oldRangeReturn != NULL);
@ -962,7 +961,7 @@ static Bool cbsFindLargest(Range rangeReturn, Range oldRangeReturn,
AVERT(Land, land);
cbs = cbsOfLand(land);
AVERT(CBS, cbs);
AVER(IsLandSubclass(cbsLand(cbs), CBSFastLandClass));
AVER(IsLandSubclass(CBSLand(cbs), CBSFastLandClass));
AVER(rangeReturn != NULL);
AVER(oldRangeReturn != NULL);
@ -1013,7 +1012,7 @@ static Res cbsFindInZones(Bool *foundReturn, Range rangeReturn,
AVERT(Land, land);
cbs = cbsOfLand(land);
AVERT(CBS, cbs);
AVER(IsLandSubclass(cbsLand(cbs), CBSZonedLandClass));
AVER(IsLandSubclass(CBSLand(cbs), CBSZonedLandClass));
/* AVERT(ZoneSet, zoneSet); */
AVER(BoolCheck(high));

1
mps/code/cbs.h
View file

@ -37,6 +37,7 @@ typedef struct CBSZonedBlockStruct {
typedef struct CBSStruct *CBS;
extern Bool CBSCheck(CBS cbs);
#define CBSLand(cbs) (&(cbs)->landStruct)
extern LandClass CBSLandClassGet(void);
extern LandClass CBSFastLandClassGet(void);

2
mps/code/failover.h
View file

@ -13,6 +13,8 @@
typedef struct FailoverStruct *Failover;
#define FailoverLand(fo) (&(fo)->landStruct)
extern Bool FailoverCheck(Failover failover);
extern LandClass FailoverLandClassGet(void);

4
mps/code/freelist.c
View file

@ -14,7 +14,7 @@ SRCID(freelist, "$Id$");
#define freelistOfLand(land) PARENT(FreelistStruct, landStruct, land)
#define freelistAlignment(fl) LandAlignment(&(fl)->landStruct)
#define freelistAlignment(fl) LandAlignment(FreelistLand(fl))
typedef union FreelistBlockUnion {
@ -178,7 +178,7 @@ Bool FreelistCheck(Freelist fl)
{
Land land;
CHECKS(Freelist, fl);
land = &fl->landStruct;
land = FreelistLand(fl);
CHECKD(Land, land);
/* See <design/freelist/#impl.grain.align> */
CHECKL(AlignIsAligned(freelistAlignment(fl), freelistMinimumAlignment));

2
mps/code/freelist.h
View file

@ -13,6 +13,8 @@
typedef struct FreelistStruct *Freelist;
#define FreelistLand(fl) (&(fl)->landStruct)
extern Bool FreelistCheck(Freelist freelist);
extern LandClass FreelistLandClassGet(void);

8
mps/code/landtest.c
View file

@ -486,10 +486,10 @@ extern int main(int argc, char *argv[])
CBSStruct cbsStruct;
FreelistStruct flStruct;
FailoverStruct foStruct;
Land cbs = &cbsStruct.landStruct;
Land fl = &flStruct.landStruct;
Land fo = &foStruct.landStruct;
Pool mfs = &blockPool.poolStruct;
Land cbs = CBSLand(&cbsStruct);
Land fl = FreelistLand(&flStruct);
Land fo = FailoverLand(&foStruct);
Pool mfs = MFSPool(&blockPool);
Align align;
int i;

7
mps/code/poolmfs.c
View file

@ -60,13 +60,6 @@ typedef struct MFSHeaderStruct {
#define UNIT_MIN sizeof(HeaderStruct)
Pool (MFSPool)(MFS mfs)
{
AVERT(MFS, mfs);
return &mfs->poolStruct;
}
/* MFSVarargs -- decode obsolete varargs */
static void MFSVarargs(ArgStruct args[MPS_ARGS_MAX], va_list varargs)

4
mps/code/poolmfs.h
View file

@ -33,11 +33,11 @@
typedef struct MFSStruct *MFS;
#define MFSPool(mfs) (&(mfs)->poolStruct)
extern PoolClass PoolClassMFS(void);
extern Bool MFSCheck(MFS mfs);
extern Pool (MFSPool)(MFS mfs);
extern const struct mps_key_s _mps_key_MFSExtendSelf;
#define MFSExtendSelf (&_mps_key_MFSExtendSelf)

8
mps/code/poolmv.c
View file

@ -252,7 +252,7 @@ static Res MVInit(Pool pool, ArgList args)
MPS_ARGS_BEGIN(piArgs) {
MPS_ARGS_ADD(piArgs, MPS_KEY_EXTEND_BY, blockExtendBy);
MPS_ARGS_ADD(piArgs, MPS_KEY_MFS_UNIT_SIZE, sizeof(MVBlockStruct));
res = PoolInit(&mv->blockPoolStruct.poolStruct, arena, PoolClassMFS(), piArgs);
res = PoolInit(mvBlockPool(mv), arena, PoolClassMFS(), piArgs);
} MPS_ARGS_END(piArgs);
if(res != ResOK)
return res;
@ -262,7 +262,7 @@ static Res MVInit(Pool pool, ArgList args)
MPS_ARGS_BEGIN(piArgs) {
MPS_ARGS_ADD(piArgs, MPS_KEY_EXTEND_BY, spanExtendBy);
MPS_ARGS_ADD(piArgs, MPS_KEY_MFS_UNIT_SIZE, sizeof(MVSpanStruct));
res = PoolInit(&mv->spanPoolStruct.poolStruct, arena, PoolClassMFS(), piArgs);
res = PoolInit(mvSpanPool(mv), arena, PoolClassMFS(), piArgs);
} MPS_ARGS_END(piArgs);
if(res != ResOK)
return res;
@ -304,8 +304,8 @@ static void MVFinish(Pool pool)
mv->sig = SigInvalid;
PoolFinish(&mv->blockPoolStruct.poolStruct);
PoolFinish(&mv->spanPoolStruct.poolStruct);
PoolFinish(mvBlockPool(mv));
PoolFinish(mvSpanPool(mv));
}

6
mps/code/poolmv2.c
View file

@ -167,19 +167,19 @@ static ABQ MVTABQ(MVT mvt)
static Land MVTCBS(MVT mvt)
{
return &mvt->cbsStruct.landStruct;
return CBSLand(&mvt->cbsStruct);
}
static Land MVTFreelist(MVT mvt)
{
return &mvt->flStruct.landStruct;
return FreelistLand(&mvt->flStruct);
}
static Land MVTFailover(MVT mvt)
{
return &mvt->foStruct.landStruct;
return FailoverLand(&mvt->foStruct);
}

48
mps/code/poolmvff.c
View file

@ -65,13 +65,13 @@ typedef struct MVFFStruct { /* MVFF pool outer structure */
#define Pool2MVFF(pool) PARENT(MVFFStruct, poolStruct, pool)
#define MVFF2Pool(mvff) (&((mvff)->poolStruct))
#define MVFFTotalCBS(mvff) (&((mvff)->totalCBSStruct.landStruct))
#define MVFFFreeCBS(mvff) (&((mvff)->freeCBSStruct.landStruct))
#define MVFFFreelist(mvff) (&((mvff)->flStruct.landStruct))
#define MVFFFailover(mvff) (&((mvff)->foStruct.landStruct))
#define MVFFSegPref(mvff) (&((mvff)->segPrefStruct))
#define MVFFBlockPool(mvff) (&((mvff)->cbsBlockPoolStruct.poolStruct))
#define MVFF2Pool(mvff) (&(mvff)->poolStruct)
#define MVFFTotalCBS(mvff) CBSLand(&(mvff)->totalCBSStruct)
#define MVFFFreeCBS(mvff) CBSLand(&(mvff)->freeCBSStruct)
#define MVFFFreelist(mvff) FreelistLand(&(mvff)->flStruct)
#define MVFFFreeLand(mvff) FailoverLand(&(mvff)->foStruct)
#define MVFFSegPref(mvff) (&(mvff)->segPrefStruct)
#define MVFFBlockPool(mvff) MFSPool(&(mvff)->cbsBlockPoolStruct)
static Bool MVFFCheck(MVFF mvff);
@ -125,7 +125,7 @@ static void MVFFReduce(MVFF mvff)
stored at the root node. */
freeLimit = (Size)(LandSize(MVFFTotalCBS(mvff)) * mvff->spare);
freeSize = LandSize(MVFFFailover(mvff));
freeSize = LandSize(MVFFFreeLand(mvff));
if (freeSize < freeLimit)
return;
@ -138,7 +138,7 @@ static void MVFFReduce(MVFF mvff)
loop will terminate */
while (freeSize > targetFree
&& LandFindLargest(&freeRange, &oldFreeRange, MVFFFailover(mvff),
&& LandFindLargest(&freeRange, &oldFreeRange, MVFFFreeLand(mvff),
align, FindDeleteNONE))
{
RangeStruct pageRange, oldRange;
@ -177,16 +177,16 @@ static void MVFFReduce(MVFF mvff)
to delete from the TotalCBS we add back to the free list, which
can't fail. */
res = LandDelete(&oldRange, MVFFFailover(mvff), &pageRange);
res = LandDelete(&oldRange, MVFFFreeLand(mvff), &pageRange);
if (res != ResOK)
break;
freeSize -= RangeSize(&pageRange);
AVER(freeSize == LandSize(MVFFFailover(mvff)));
AVER(freeSize == LandSize(MVFFFreeLand(mvff)));
res = LandDelete(&oldRange, MVFFTotalCBS(mvff), &pageRange);
if (res != ResOK) {
RangeStruct coalescedRange;
res = LandInsert(&coalescedRange, MVFFFailover(mvff), &pageRange);
res = LandInsert(&coalescedRange, MVFFFreeLand(mvff), &pageRange);
AVER(res == ResOK);
break;
}
@ -253,7 +253,7 @@ static Res MVFFExtend(Range rangeReturn, MVFF mvff, Size size,
}
DebugPoolFreeSplat(pool, RangeBase(&range), RangeLimit(&range));
res = LandInsert(rangeReturn, MVFFFailover(mvff), &range);
res = LandInsert(rangeReturn, MVFFFreeLand(mvff), &range);
AVER(res == ResOK);
/* Don't call MVFFReduce; that would be silly. */
@ -287,7 +287,7 @@ static Bool MVFFFindFree(Range rangeReturn, MVFF mvff, Size size)
foundBlock =
(mvff->firstFit ? LandFindFirst : LandFindLast)
(rangeReturn, &oldRange, MVFFFailover(mvff), size, findDelete);
(rangeReturn, &oldRange, MVFFFreeLand(mvff), size, findDelete);
return foundBlock;
}
@ -352,7 +352,7 @@ static void MVFFFree(Pool pool, Addr old, Size size)
AVER(size > 0);
RangeInitSize(&range, old, SizeAlignUp(size, PoolAlignment(pool)));
res = LandInsert(&coalescedRange, MVFFFailover(mvff), &range);
res = LandInsert(&coalescedRange, MVFFFreeLand(mvff), &range);
AVER(res == ResOK);
MVFFReduce(mvff);
}
@ -381,14 +381,14 @@ static Res MVFFBufferFill(Addr *baseReturn, Addr *limitReturn,
AVER(SizeIsAligned(size, PoolAlignment(pool)));
AVERT(Bool, withReservoirPermit);
found = LandFindLargest(&range, &oldRange, MVFFFailover(mvff), size,
found = LandFindLargest(&range, &oldRange, MVFFFreeLand(mvff), size,
FindDeleteENTIRE);
if (!found) {
/* Add a new range to the free lists and try again. */
res = MVFFExtend(&newRange, mvff, size, withReservoirPermit);
if (res != ResOK)
return res;
found = LandFindLargest(&range, &oldRange, MVFFFailover(mvff), size,
found = LandFindLargest(&range, &oldRange, MVFFFreeLand(mvff), size,
FindDeleteENTIRE);
AVER(found && RangesOverlap(&range, &newRange));
}
@ -421,7 +421,7 @@ static void MVFFBufferEmpty(Pool pool, Buffer buffer,
if (RangeIsEmpty(&range))
return;
res = LandInsert(&coalescedRange, MVFFFailover(mvff), &range);
res = LandInsert(&coalescedRange, MVFFFreeLand(mvff), &range);
AVER(res == ResOK);
MVFFReduce(mvff);
}
@ -563,7 +563,7 @@ static Res MVFFInit(Pool pool, ArgList args)
MPS_ARGS_BEGIN(foArgs) {
MPS_ARGS_ADD(foArgs, FailoverPrimary, MVFFFreeCBS(mvff));
MPS_ARGS_ADD(foArgs, FailoverSecondary, MVFFFreelist(mvff));
res = LandInit(MVFFFailover(mvff), FailoverLandClassGet(), arena, align,
res = LandInit(MVFFFreeLand(mvff), FailoverLandClassGet(), arena, align,
mvff, foArgs);
} MPS_ARGS_END(foArgs);
if (res != ResOK)
@ -621,7 +621,7 @@ static void MVFFFinish(Pool pool)
* now, but CBS doesn't support deletion while iterating. See
* job003826. */
LandFinish(MVFFFailover(mvff));
LandFinish(MVFFFreeLand(mvff));
LandFinish(MVFFFreelist(mvff));
LandFinish(MVFFFreeCBS(mvff));
LandFinish(MVFFTotalCBS(mvff));
@ -750,7 +750,7 @@ size_t mps_mvff_free_size(mps_pool_t mps_pool)
mvff = Pool2MVFF(pool);
AVERT(MVFF, mvff);
return (size_t)LandSize(MVFFFailover(mvff));
return (size_t)LandSize(MVFFFreeLand(mvff));
}
/* Total owned bytes. See <design/poolmvff/#design.arena-enter> */
@ -786,9 +786,9 @@ static Bool MVFFCheck(MVFF mvff)
CHECKD(Land, MVFFTotalCBS(mvff));
CHECKD(Land, MVFFFreeCBS(mvff));
CHECKD(Land, MVFFFreelist(mvff));
CHECKD(Land, MVFFFailover(mvff));
CHECKL(LandSize(MVFFTotalCBS(mvff)) >= LandSize(MVFFFailover(mvff)));
CHECKL(SizeIsAligned(LandSize(MVFFFailover(mvff)), PoolAlignment(MVFF2Pool(mvff))));
CHECKD(Land, MVFFFreeLand(mvff));
CHECKL(LandSize(MVFFTotalCBS(mvff)) >= LandSize(MVFFFreeLand(mvff)));
CHECKL(SizeIsAligned(LandSize(MVFFFreeLand(mvff)), PoolAlignment(MVFF2Pool(mvff))));
CHECKL(SizeIsAligned(LandSize(MVFFTotalCBS(mvff)), ArenaAlign(PoolArena(MVFF2Pool(mvff)))));
CHECKL(BoolCheck(mvff->slotHigh));
CHECKL(BoolCheck(mvff->firstFit));