diff --git a/mps/src/format.c b/mps/src/format.c index a707898657f..32d9e801ac0 100644 --- a/mps/src/format.c +++ b/mps/src/format.c @@ -2,7 +2,7 @@ * * OBJECT FORMATS * - * $HopeName: MMsrc/!format.c(trunk.1)$ + * $HopeName: MMsrc/!format.c(trunk.2)$ * * Copyright (C) 1995 Harlequin Group, all rights reserved */ @@ -25,6 +25,7 @@ Bool FormatIsValid(Format format, ValidationType validParam) AVER(ISVALIDNESTED(Sig, &FormatSigStruct)); AVER(format->sig == &FormatSigStruct); #endif + AVER(ISVALIDNESTED(Space, format->space)); AVER(IsPoT(format->alignment)); /* **** alignment should be less than maximum allowed */ AVER(format->scan != NULL); @@ -40,17 +41,27 @@ Bool FormatIsValid(Format format, ValidationType validParam) #endif /* DEBUG_ASSERT */ -Error FormatInit(Format format, Addr alignment, - FormatScanMethod scan, - FormatSkipMethod skip, - FormatLengthMethod length, - FormatProbeMethod probe, - FormatMoveMethod move, - FormatIsMovedMethod isMoved, - FormatCopyMethod copy) +Error FormatCreate(Format *formatReturn, Space space, + Addr alignment, + FormatScanMethod scan, + FormatSkipMethod skip, + FormatLengthMethod length, + FormatProbeMethod probe, + FormatMoveMethod move, + FormatIsMovedMethod isMoved, + FormatCopyMethod copy) { - AVER(format != NULL); + Format format; + Error e; + AVER(formatReturn != NULL); + + e = PoolAlloc((Addr *)&format, SpaceControlPool(space), + sizeof(FormatStruct)); + if(e != ErrSUCCESS) + return e; + + format->space = space; format->alignment = alignment; format->scan = scan; format->skip = skip; @@ -67,17 +78,18 @@ Error FormatInit(Format format, Addr alignment, AVER(ISVALID(Format, format)); - return(ErrSUCCESS); + *formatReturn = format; + return ErrSUCCESS; } -void FormatFinish(Format format) +void FormatDestroy(Format format) { -#if !defined(DEBUG_ASSERT) && !defined(DEBUG_SIGN) - UNUSED(format); -#endif AVER(ISVALID(Format, format)); #ifdef DEBUG_SIGN format->sig = SigInvalid; #endif + + PoolFree(SpaceControlPool(format->space), + (Addr)format, sizeof(FormatStruct)); } diff --git a/mps/src/pool.c b/mps/src/pool.c index 0271c9f4d98..df6ee0247e7 100644 --- a/mps/src/pool.c +++ b/mps/src/pool.c @@ -1,6 +1,6 @@ /* ==== POOLS ==== * - * $HopeName: MMsrc/!pool.c(trunk.1)$ + * $HopeName: MMsrc/!pool.c(trunk.3)$ * * Copyright (C) 1994,1995 Harlequin Group, all rights reserved * @@ -110,7 +110,7 @@ void PoolDestroy(Pool pool) } -Error (PoolAllocP)(void **pReturn, Pool pool, size_t size) +Error (PoolAlloc)(Addr *pReturn, Pool pool, Size size) { Error e; @@ -118,7 +118,7 @@ Error (PoolAllocP)(void **pReturn, Pool pool, size_t size) AVER(ISVALID(Pool, pool)); AVER(size > 0); - e = (*pool->class->allocP)(pReturn, pool, size); + e = (*pool->class->alloc)(pReturn, pool, size); if(e != ErrSUCCESS) return e; /* Make sure that the allocated address was in the pool's memory. */ @@ -128,14 +128,14 @@ Error (PoolAllocP)(void **pReturn, Pool pool, size_t size) } -void PoolFreeP(Pool pool, void *old, size_t size) +void PoolFree(Pool pool, Addr old, Size size) { AVER(ISVALID(Pool, pool)); - AVER(old != NULL); - AVER(PoolHasAddr(pool, (Addr)old)); + AVER(old != (Addr)0); + AVER(PoolHasAddr(pool, old)); - if(pool->class->freeP != NULL) - (*pool->class->freeP)(pool, old, size); + if(pool->class->free != NULL) + (*pool->class->free)(pool, old, size); } @@ -237,14 +237,14 @@ Error PoolSegAlloc(Addr *segReturn, Pool pool, Addr size) AVER(IsAligned(ArenaGrain(arena), size)); arpool = PoolArenaPool(arena); - e = PoolAllocP((void **)&seg, arpool, size); + e = PoolAlloc(&seg, arpool, size); if(e != ErrSUCCESS) - return(e); + return e; ArenaPut(arena, seg, ARENA_POOL, (void *)pool); *segReturn = seg; - return(ErrSUCCESS); + return ErrSUCCESS; } @@ -260,7 +260,7 @@ void PoolSegFree(Pool pool, Addr seg, Addr size) ArenaPut(arena, seg, ARENA_POOL, (void *)arpool); - PoolFreeP(arpool, (void *)seg, (size_t)size); + PoolFree(arpool, (Addr)seg, (Size)size); } diff --git a/mps/src/poolmfs.c b/mps/src/poolmfs.c index 01b98891470..f526cf645d9 100644 --- a/mps/src/poolmfs.c +++ b/mps/src/poolmfs.c @@ -1,6 +1,6 @@ /* ==== MANUAL FIXED SMALL UNIT POOL ==== * - * $HopeName: MMsrc/!poolmfs.c(trunk.1)$ + * $HopeName: MMsrc/!poolmfs.c(trunk.3)$ * * Copyright (C) 1994,1995 Harlequin Group, all rights reserved * @@ -20,12 +20,12 @@ * Notes * 1. The simple freelist policy might lead to poor locality of allocation * if the list gets fragmented. richard 1994-11-03 - * 2. freeP should check that the pointer it is asked to free is in a + * 2. free should check that the pointer it is asked to free is in a * segment owned by the pool. This required more support from the * arena manager than is currently available. richard 1994-11-03 * 3. A describe method is needed. richard 1994-11-03 * 4. By not using the rounded extent of a segment some space may be - * wasted at the end in allocP. richard 1994-11-03 + * wasted at the end in alloc. richard 1994-11-03 * 5. isValid should check that free list points into the pool. * richard 1994-11-03 * 6. This pool doesn't support fast cache allocation, which is a shame. @@ -57,8 +57,8 @@ static Error create(Pool *poolReturn, Space space, va_list arg); static void destroy(Pool pool); -static Error allocP(void **pReturn, Pool pool, size_t size); -static void freeP(Pool pool, void *old, size_t size); +static Error alloc(Addr *pReturn, Pool pool, Size size); +static void free_(Pool pool, Addr old, Size size); static Error describe(Pool pool, LibStream stream); static PoolClassStruct PoolClassMFSStruct; @@ -69,7 +69,7 @@ PoolClass PoolClassMFS(void) "MFS", sizeof(PoolMFSStruct), offsetof(PoolMFSStruct, poolStruct), create, destroy, - allocP, freeP, + alloc, free_, NULL, NULL, /* bufferCreate, bufferDestroy */ NULL, NULL, NULL, /* comdemn, mark, scan */ NULL, NULL, /* fix, relcaim */ @@ -138,14 +138,15 @@ Error PoolMFSCreate(PoolMFS *poolMFSReturn, Space space, AVER(poolMFSReturn != NULL); AVER(ISVALID(Space, space)); - e = PoolAllocP((void **)&poolMFS, SpaceControlPool(space), + e = PoolAlloc((Addr *)&poolMFS, SpaceControlPool(space), sizeof(PoolMFSStruct)); - if(e != ErrSUCCESS) return(e); + if(e != ErrSUCCESS) + return e; e = PoolMFSInit(poolMFS, space, extendBy, unitSize); if(e != ErrSUCCESS) { - PoolFreeP(SpaceControlPool(space), poolMFS, sizeof(PoolMFSStruct)); - return(e); + PoolFree(SpaceControlPool(space), (Addr)poolMFS, sizeof(PoolMFSStruct)); + return e; } *poolMFSReturn = poolMFS; @@ -178,7 +179,7 @@ void PoolMFSDestroy(PoolMFS poolMFS) AVER(ISVALID(PoolMFS, poolMFS)); control = SpaceControlPool(PoolSpace(PoolMFSPool(poolMFS))); PoolMFSFinish(poolMFS); - PoolFreeP(control, poolMFS, sizeof(PoolMFSStruct)); + PoolFree(control, (Addr)poolMFS, sizeof(PoolMFSStruct)); } static void destroy(Pool pool) @@ -243,7 +244,7 @@ void PoolMFSFinish(PoolMFS poolMFS) * and returning it. If there are none, a new segment is allocated. */ -static Error allocP(void **pReturn, Pool pool, size_t size) +static Error alloc(Addr *pReturn, Pool pool, Size size) { Header f; Error e; @@ -255,7 +256,7 @@ static Error allocP(void **pReturn, Pool pool, size_t size) AVER(ISVALID(Pool, pool)); AVER(pool->class == &PoolClassMFSStruct); - AVER(pReturn != NULL); + AVER(pReturn != (Addr)0); MFS = PARENT(PoolMFSStruct, poolStruct, pool); @@ -275,7 +276,7 @@ static Error allocP(void **pReturn, Pool pool, size_t size) /* Create a new segment and attach it to the pool. */ e = PoolSegAlloc(&seg, pool, MFS->extendBy); if(e != ErrSUCCESS) - return(e); + return e; /* chain segs through Key1; can find them when finishing */ arena = SpaceArena(PoolSpace(pool)); @@ -314,8 +315,8 @@ static Error allocP(void **pReturn, Pool pool, size_t size) MFS->freeList = f->next; - *pReturn = (void *)f; - return(ErrSUCCESS); + *pReturn = (Addr)f; + return ErrSUCCESS; } @@ -326,7 +327,7 @@ static Error allocP(void **pReturn, Pool pool, size_t size) * locations throughout the pool. */ -static void freeP(Pool pool, void *old, size_t size) +static void free_(Pool pool, Addr old, Size size) { Header h; PoolMFS MFS; @@ -337,7 +338,7 @@ static void freeP(Pool pool, void *old, size_t size) AVER(ISVALID(Pool, pool)); AVER(pool->class == &PoolClassMFSStruct); - AVER(old != NULL); + AVER(old != (Addr)0); MFS = PARENT(PoolMFSStruct, poolStruct, pool); diff --git a/mps/src/poolmfs.h b/mps/src/poolmfs.h index b88046b7a2b..8b627dd8967 100644 --- a/mps/src/poolmfs.h +++ b/mps/src/poolmfs.h @@ -2,7 +2,7 @@ * * MANUAL FIXED SMALL UNIT POOL * - * $HopeName$ + * $HopeName: MMsrc/!poolmfs.h(trunk.1)$ * * Copyright (C) 1994,1995 Harlequin Group, all rights reserved * @@ -14,13 +14,13 @@ * * Create and Init take the following arguments: * - * size_t extendBy + * Size extendBy * * extendBy is the default number of bytes reserved by the pool at a time. * A large size will make allocation cheaper but have a higher resource * overhead. A typical value might be 65536. See note 2. * - * size_t unitSize + * Size unitSize * * unitSize is the size in bytes of the objects you with to allocate. It * must be larger than the minimum unit size returned by GetInfo, and not @@ -42,9 +42,11 @@ typedef struct PoolMFSStruct *PoolMFS; extern PoolClass PoolClassMFS(void); -extern Error PoolMFSCreate(PoolMFS *poolMFSReturn, Space space, size_t extendBy, size_t unitSize); +extern Error PoolMFSCreate(PoolMFS *poolMFSReturn, Space space, + Size extendBy, Size unitSize); extern void PoolMFSDestroy(PoolMFS poolMFS); -extern Error PoolMFSInit(PoolMFS poolMFS, Space space, size_t extendBy, size_t unitSize); +extern Error PoolMFSInit(PoolMFS poolMFS, Space space, + Size extendBy, Size unitSize); extern void PoolMFSFinish(PoolMFS poolMFS); extern Bool PoolMFSIsValid(PoolMFS poolMFS, ValidationType validParam); extern Pool (PoolMFSPool)(PoolMFS poolMFS); @@ -54,7 +56,7 @@ typedef const struct PoolMFSInfoStruct *PoolMFSInfo; struct PoolMFSInfoStruct { - size_t unitSizeMin; /* minimum unit size */ + Size unitSizeMin; /* minimum unit size */ }; extern PoolMFSInfo PoolMFSGetInfo(void); diff --git a/mps/src/poolmv.c b/mps/src/poolmv.c index ef3450d1705..84068a30e6e 100644 --- a/mps/src/poolmv.c +++ b/mps/src/poolmv.c @@ -1,6 +1,6 @@ /* ==== MANUAL VARIABLE POOL ==== * - * $HopeName: MMsrc/!poolmv.c(trunk.1)$ + * $HopeName: MMsrc/!poolmv.c(trunk.3)$ * * Copyright (C) 1994, 1995 Harlequin Group, all rights reserved * @@ -16,7 +16,7 @@ * Notes * 1. Need to measure typical fragmentation levels and adjust the * blockExtendBy parameter appropriately. richard 1994-11-08 - * 2. freeP can lose memory if it can't allocate a block descriptor. The + * 2. free can lose memory if it can't allocate a block descriptor. The * memory could be pushed onto a special chain to be reclaimed later. * richard 1994-11-09 * 3. The span chain could be adaptive. richard 1994-11-09 @@ -52,8 +52,8 @@ static Error create(Pool *poolReturn, Space space, va_list arg); static void destroy(Pool pool); -static Error allocP(void **pReturn, Pool pool, size_t size); -static void freeP(Pool pool, void *old, size_t size); +static Error alloc(Addr *pReturn, Pool pool, Size size); +static void free_(Pool pool, Addr old, Size size); static Error describe(Pool pool, LibStream stream); static PoolClassStruct PoolClassMVStruct; @@ -64,7 +64,7 @@ PoolClass PoolClassMV(void) "MV", sizeof(PoolMVStruct), offsetof(PoolMVStruct, poolStruct), create, destroy, - allocP, freeP, + alloc, free_, NULL, NULL, /* bufferCreate, bufferDestroy */ NULL, NULL, NULL, /* condemn, mark, scan */ NULL, NULL, /* fix, relcaim */ @@ -190,7 +190,7 @@ Pool PoolMVPool(PoolMV poolMV) Error PoolMVCreate(PoolMV *poolMVReturn, Space space, - size_t extendBy, size_t avgSize, size_t maxSize) + Size extendBy, Size avgSize, Size maxSize) { Error e; PoolMV poolMV; @@ -198,13 +198,15 @@ Error PoolMVCreate(PoolMV *poolMVReturn, Space space, AVER(poolMVReturn != NULL); AVER(ISVALID(Space, space)); - e = PoolAllocP((void **)&poolMV, SpaceControlPool(space), sizeof(PoolMVStruct)); - if(e != ErrSUCCESS) return(e); + e = PoolAlloc((Addr *)&poolMV, SpaceControlPool(space), + sizeof(PoolMVStruct)); + if(e != ErrSUCCESS) + return(e); e = PoolMVInit(poolMV, space, extendBy, avgSize, maxSize); if(e != ErrSUCCESS) { - PoolFreeP(SpaceControlPool(space), poolMV, sizeof(PoolMVStruct)); - return(e); + PoolFree(SpaceControlPool(space), (Addr)poolMV, sizeof(PoolMVStruct)); + return e; } *poolMVReturn = poolMV; @@ -213,22 +215,23 @@ Error PoolMVCreate(PoolMV *poolMVReturn, Space space, static Error create(Pool *poolReturn, Space space, va_list arg) { - size_t extendBy, avgSize, maxSize; + Size extendBy, avgSize, maxSize; PoolMV poolMV; Error e; AVER(poolReturn != NULL); AVER(ISVALID(Space, space)); - extendBy = va_arg(arg, size_t); - avgSize = va_arg(arg, size_t); - maxSize = va_arg(arg, size_t); + extendBy = va_arg(arg, Size); + avgSize = va_arg(arg, Size); + maxSize = va_arg(arg, Size); e = PoolMVCreate(&poolMV, space, extendBy, avgSize, maxSize); - if(e != ErrSUCCESS) return(e); + if(e != ErrSUCCESS) + return e; *poolReturn = PoolMVPool(poolMV); - return(ErrSUCCESS); + return ErrSUCCESS; } @@ -238,7 +241,7 @@ void PoolMVDestroy(PoolMV poolMV) AVER(ISVALID(PoolMV, poolMV)); control = SpaceControlPool(PoolSpace(PoolMVPool(poolMV))); PoolMVFinish(poolMV); - PoolFreeP(control, poolMV, sizeof(PoolMVStruct)); + PoolFree(control, (Addr)poolMV, sizeof(PoolMVStruct)); } static void destroy(Pool pool) @@ -249,11 +252,11 @@ static void destroy(Pool pool) } -Error PoolMVInit(PoolMV poolMV, Space space, size_t extendBy, - size_t avgSize, size_t maxSize) +Error PoolMVInit(PoolMV poolMV, Space space, Size extendBy, + Size avgSize, Size maxSize) { Error e; - size_t blockExtendBy, spanExtendBy; + Size blockExtendBy, spanExtendBy; AVER(poolMV != NULL); AVER(ISVALID(Space, space)); @@ -270,13 +273,17 @@ Error PoolMVInit(PoolMV poolMV, Space space, size_t extendBy, blockExtendBy = sizeof(BlockStruct) * (extendBy/avgSize)/2; - e = PoolMFSInit(&poolMV->blockPoolStruct, space, blockExtendBy, sizeof(BlockStruct)); - if(e != ErrSUCCESS) return(e); + e = PoolMFSInit(&poolMV->blockPoolStruct, space, + blockExtendBy, sizeof(BlockStruct)); + if(e != ErrSUCCESS) + return e; spanExtendBy = sizeof(SpanStruct) * (maxSize/extendBy); - e = PoolMFSInit(&poolMV->spanPoolStruct, space, spanExtendBy, sizeof(SpanStruct)); - if(e != ErrSUCCESS) return(e); + e = PoolMFSInit(&poolMV->spanPoolStruct, space, + spanExtendBy, sizeof(SpanStruct)); + if(e != ErrSUCCESS) + return e; poolMV->extendBy = extendBy; poolMV->avgSize = avgSize; @@ -287,7 +294,7 @@ Error PoolMVInit(PoolMV poolMV, Space space, size_t extendBy, AVER(ISVALID(PoolMV, poolMV)); - return(ErrSUCCESS); + return ErrSUCCESS; } @@ -356,7 +363,7 @@ static Bool SpanAlloc(Addr *addrReturn, Span span, Addr size, Block old = block->next; block->limit = old->limit; block->next = old->next; - PoolFreeP(blockPool, old, sizeof(BlockStruct)); + PoolFree(blockPool, (Addr)old, sizeof(BlockStruct)); --span->blockCount; } else @@ -410,7 +417,7 @@ static Error SpanFree(Span span, Addr base, Addr limit, Pool blockPool) { AVER(block->next != NULL); /* should at least be a sentinel */ *prev = block->next; - PoolFreeP(blockPool, block, sizeof(BlockStruct)); + PoolFree(blockPool, (Addr)block, sizeof(BlockStruct)); --span->blockCount; } else if(!isBase && block->base == base) @@ -425,7 +432,7 @@ static Error SpanFree(Span span, Addr base, Addr limit, Pool blockPool) /* The freed area is buried in the middle of the block, so the */ /* block must be split into two parts. */ - e = PoolAllocP((void **)&new, blockPool, sizeof(BlockStruct)); + e = PoolAlloc((Addr *)&new, blockPool, sizeof(BlockStruct)); if(e != ErrSUCCESS) return(e); /* If the freed area is in the base sentinel then insert the new */ @@ -465,23 +472,23 @@ static Error SpanFree(Span span, Addr base, Addr limit, Pool blockPool) while(block != NULL); /* The freed area is in the span, but not within a block. */ - ASSERT2(PoolFreeP(poolMV), FALSE, + ASSERT2(PoolFree(poolMV), FALSE, "Block %p size %lu is already partially free in pool.", (void *)base, (unsigned long)(limit-base)); - return(ErrSUCCESS); + return ErrSUCCESS; } /* == Allocate == */ -static Error allocP(void **pReturn, Pool pool, size_t size) +static Error alloc(Addr *pReturn, Pool pool, Size size) { Error e; Arena arena; Span span; PoolMV poolMV; - size_t segSize; + Size segSize; AVER(pReturn != NULL); AVER(ISVALID(Pool, pool)); @@ -506,8 +513,8 @@ static Error allocP(void **pReturn, Pool pool, size_t size) { poolMV->space -= size; AVER(IsAligned(pool->alignment, new)); - *pReturn = (void *)new; - return(ErrSUCCESS); + *pReturn = new; + return ErrSUCCESS; } } @@ -521,9 +528,9 @@ static Error allocP(void **pReturn, Pool pool, size_t size) * segment. */ - e = PoolAllocP((void **)&span, SPANPOOL(poolMV), sizeof(SpanStruct)); + e = PoolAlloc((Addr *)&span, SPANPOOL(poolMV), sizeof(SpanStruct)); if(e != ErrSUCCESS) - return(e); + return e; if(size <= poolMV->extendBy) segSize = poolMV->extendBy; @@ -536,8 +543,8 @@ static Error allocP(void **pReturn, Pool pool, size_t size) e = PoolSegAlloc(&span->seg, pool, segSize); if(e != ErrSUCCESS) { - PoolFreeP(SPANPOOL(poolMV), span, sizeof(SpanStruct)); - return(e); + PoolFree(SPANPOOL(poolMV), (Addr)span, sizeof(SpanStruct)); + return e; } ArenaPut(arena, span->seg, ARENA_CLASS, (void *)span); @@ -560,12 +567,12 @@ static Error allocP(void **pReturn, Pool pool, size_t size) poolMV->space += span->space; poolMV->spans = span; - *pReturn = (void *)span->base.base; - return(ErrSUCCESS); + *pReturn = span->base.base; + return ErrSUCCESS; } -static void freeP(Pool pool, void *old, size_t size) +static void free_(Pool pool, Addr old, Size size) { Addr base, limit; Arena arena; @@ -582,7 +589,7 @@ static void freeP(Pool pool, void *old, size_t size) poolMV = PARENT(PoolMVStruct, poolStruct, pool); size = AlignUp(pool->alignment, size); - base = (Addr)old; + base = old; limit = base + size; /* Map the pointer onto the segment which contains it, and thence */ diff --git a/mps/src/poolmv.h b/mps/src/poolmv.h index b41f543ac2d..19c1074fc91 100644 --- a/mps/src/poolmv.h +++ b/mps/src/poolmv.h @@ -1,6 +1,6 @@ /* ==== MANUAL VARIABLE POOLS ==== * - * $HopeName$ + * $HopeName: MMsrc/!poolmv.h(trunk.1)$ * * Copyright (C) 1994,1995 Harlequin Group, all rights reserved * @@ -10,13 +10,13 @@ * * This class adds the following arguments to PoolCreate: * - * size_t extendBy + * Size extendBy * * extendBy is the default number of bytes reserved by the pool at a time. * A large size will make allocation cheaper but have a higher resource * overhead. A typical value might be 65536. See note 2. * - * size_t avgSize + * Size avgSize * * avgSize is an estimate of the average size of an allocation, and is used * to choose the size of internal tables. An accurate estimate will @@ -25,7 +25,7 @@ * efficient. A typical value might be 32. avgSize must not be less than * extendBy. * - * size_t maxSize + * Size maxSize * * maxSize is an estimate of the maximum total size that the pool will * reach. Setting this parameter does not actually contrain the pool, but @@ -57,10 +57,10 @@ typedef struct PoolMVStruct *PoolMV; extern PoolClass PoolClassMV(void); extern Error PoolMVCreate(PoolMV *poolMVReturn, Space space, - size_t extendBy, size_t avgSize, size_t maxSize); + Size extendBy, Size avgSize, Size maxSize); extern void PoolMVDestroy(PoolMV poolMV); extern Error PoolMVInit(PoolMV poolMV, Space space, - size_t extendBy, size_t avgSize, size_t maxSize); + Size extendBy, Size avgSize, Size maxSize); extern void PoolMVFinish(PoolMV poolMV); extern Bool PoolMVIsValid(PoolMV poolMV, ValidationType validParam); extern Pool (PoolMVPool)(PoolMV poolMV); diff --git a/mps/src/root.c b/mps/src/root.c index 2acf03b47a5..cf106bc7d00 100644 --- a/mps/src/root.c +++ b/mps/src/root.c @@ -2,7 +2,7 @@ * * ROOT IMPLEMENTATION * - * $HopeName: MMsrc/!root.c(trunk.2)$ + * $HopeName: MMsrc/!root.c(trunk.3)$ * * Copyright (C) 1995 Harlequin Group, all rights reserved * @@ -18,6 +18,7 @@ #include "mpmconf.h" #include "ref.h" #include "trace.h" +#include "spacest.h" #ifdef DEBUG_SIGN @@ -67,7 +68,7 @@ Bool RootIsValid(Root root, ValidationType validParam) } -static Error create(Root *rootReturn, Pool pool, +static Error create(Root *rootReturn, Space space, RefRank rank, RootMode mode, RootType type, RootUnion theUnion) { @@ -75,14 +76,15 @@ static Error create(Root *rootReturn, Pool pool, Error e; AVER(rootReturn != NULL); - AVER(ISVALID(Pool, pool)); + AVER(ISVALID(Space, space)); AVER(modeIsValid(mode)); AVER(ISVALID(RefRank, rank)); - e = PoolAllocP((void **)&root, pool, sizeof(RootStruct)); - if(e != ErrSUCCESS) return e; + e = PoolAlloc((Addr *)&root, SpaceControlPool(space), + sizeof(RootStruct)); + if(e != ErrSUCCESS) + return e; - root->pool = pool; root->rank = rank; root->mode = mode; root->type = type; @@ -98,12 +100,14 @@ static Error create(Root *rootReturn, Pool pool, AVER(ISVALID(Root, root)); + DequeAppend(SpaceRootDeque(space), &root->spaceDeque); + *rootReturn = root; return ErrSUCCESS; } -Error RootCreateTable(Root *rootReturn, Pool pool, +Error RootCreateTable(Root *rootReturn, Space space, RefRank rank, RootMode mode, Addr *base, Addr *limit) { @@ -115,14 +119,14 @@ Error RootCreateTable(Root *rootReturn, Pool pool, theUnion.table.base = base; theUnion.table.limit = limit; - return create(rootReturn, pool, rank, mode, RootTABLE, theUnion); + return create(rootReturn, space, rank, mode, RootTABLE, theUnion); } -Error RootCreateFun(Root *rootReturn, Pool pool, - RefRank rank, RootMode mode, - Error (*scan)(void *p, int i, Trace trace), - void *p, int i) +Error RootCreate(Root *rootReturn, Space space, + RefRank rank, RootMode mode, + Error (*scan)(void *p, int i, Trace trace), + void *p, int i) { RootUnion theUnion; @@ -132,22 +136,31 @@ Error RootCreateFun(Root *rootReturn, Pool pool, theUnion.fun.p = p; theUnion.fun.i = i; - return create(rootReturn, pool, rank, mode, RootFUN, theUnion); + return create(rootReturn, space, rank, mode, RootFUN, theUnion); } void RootDestroy(Root root) { + Space space; + AVER(ISVALID(Root, root)); + + space = PARENT(SpaceStruct, rootDeque, + DequeNodeParent(&root->spaceDeque)); + + AVER(ISVALID(Space, space)); + + DequeNodeRemove(&root->spaceDeque); + DequeNodeFinish(&root->spaceDeque); TraceSetFinish(&root->marked); - DequeNodeFinish(&root->spaceDeque); #ifdef DEBUG_SIGN root->sig = SigInvalid; #endif - PoolFreeP(root->pool, root, sizeof(RootStruct)); + PoolFree(SpaceControlPool(space), (Addr)root, sizeof(RootStruct)); } diff --git a/mps/src/than.c b/mps/src/than.c index 67fdc2ab883..aa7596d62e6 100644 --- a/mps/src/than.c +++ b/mps/src/than.c @@ -2,7 +2,7 @@ * * ANSI THREADS MANAGER * - * $HopeName: MMsrc/!than.c(trunk.1)$ + * $HopeName: MMsrc/!than.c(trunk.2)$ * * Copyright (C) 1995 Harlequin Group, all rights reserved * @@ -61,8 +61,8 @@ Error ThreadRegister(Thread *threadReturn, Space space, Addr *stackBot) AVER(threadReturn != NULL); AVER(stackBot != NULL); - e = PoolAllocP((void *)&thread, SpaceControlPool(space), - sizeof(ThreadStruct)); + e = PoolAlloc((Addr *)&thread, SpaceControlPool(space), + sizeof(ThreadStruct)); if(e != ErrSUCCESS) goto return_e; @@ -101,7 +101,7 @@ void ThreadDeregister(Thread thread, Space space) DequeNodeFinish(&thread->spaceDeque); - PoolFreeP(SpaceControlPool(space), thread, sizeof(ThreadStruct)); + PoolFree(SpaceControlPool(space), (Addr)thread, sizeof(ThreadStruct)); } void ThreadDequeSuspend(Deque threadDeque) diff --git a/mps/src/thw3i3.c b/mps/src/thw3i3.c index 890a2b68f96..159d3be30d0 100644 --- a/mps/src/thw3i3.c +++ b/mps/src/thw3i3.c @@ -2,7 +2,7 @@ * * WIN32 THREAD MANAGER * - * $HopeName: MMsrc/!thntmv.c(MMdevel_dsm_0.1)$ + * $HopeName: MMsrc/!thnti3.c(trunk.1)$ * * Copyright (C) 1995 Harlequin Group, all rights reserved * @@ -119,7 +119,8 @@ Error ThreadRegister(Thread *threadReturn, Space space, Addr *stackBot) AVER(stackBot != NULL); AVER(ISVALID(Space, space)); - e = PoolAllocP(&thread, SpaceControlPool(space), sizeof(ThreadStruct)); + e = PoolAlloc((Addr *)&thread, SpaceControlPool(space), + sizeof(ThreadStruct)); if(e != ErrSUCCESS) goto return_e; @@ -176,7 +177,7 @@ void ThreadDeregister(Thread thread, Space space) b = CloseHandle(thread->handle); AVER(b); /* .error.close-handle */ - PoolFreeP(SpaceControlPool(space), thread, sizeof(ThreadStruct)); + PoolFree(SpaceControlPool(space), (Addr)thread, sizeof(ThreadStruct)); } diff --git a/mps/src/trace.c b/mps/src/trace.c index 8cb199677bc..745c636dd12 100644 --- a/mps/src/trace.c +++ b/mps/src/trace.c @@ -2,7 +2,7 @@ * * GENERIC TRACER IMPLEMENTATION * - * $HopeName: MMsrc/!trace.c(trunk.2)$ + * $HopeName: MMsrc/!trace.c(trunk.3)$ * * Copyright (C) 1995 Harlequin Group, all rights reserved * @@ -31,7 +31,7 @@ static SigStruct TraceSetSigStruct; #endif -#define TRACEBIT(id) ((Addr)(1uL << (id))) +#define TRACEBIT(id) ((Addr)((Addr)1 << (id))) #ifdef DEBUG_ASSERT @@ -211,12 +211,12 @@ Error TraceCreate(Trace *traceReturn, Space space) controlPool = SpaceControlPool(space); - e = PoolAllocP((void **)&trace, controlPool, sizeof(TraceStruct)); + e = PoolAlloc((Addr *)&trace, controlPool, sizeof(TraceStruct)); if(e != ErrSUCCESS) return e; e = TraceInit(trace, space); if(e != ErrSUCCESS) { - PoolFreeP(controlPool, (void *)trace, sizeof(TraceStruct)); + PoolFree(controlPool, (Addr)trace, sizeof(TraceStruct)); return e; } @@ -231,7 +231,7 @@ void TraceDestroy(Trace trace) AVER(ISVALID(Trace, trace)); controlPool = SpaceControlPool(trace->space);; TraceFinish(trace); - PoolFreeP(controlPool, (void *)trace, sizeof(TraceStruct)); + PoolFree(controlPool, (Addr)trace, sizeof(TraceStruct)); }