/*
* Remember that a buffer pin is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeBuffers()
*
* We allow the case owner == NULL because the bufmgr is sometimes invoked
* outside any transaction (for example, during WAL recovery).
*/
void
ResourceOwnerRememberBuffer(ResourceOwner owner, Buffer buffer)
{
if (owner == NULL)
return;
ResourceArrayAdd(&(owner->bufferarr), BufferGetDatum(buffer));
}
/*
* Make sure there is room for at least one more resource in an array.
*
* This is separate from actually inserting a resource because if we run out
* of memory, it's critical to do so *before* acquiring the resource.
*/
static void
ResourceArrayEnlarge(ResourceArray *resarr)
{
uint32 i,
oldcap,
newcap;
Datum *olditemsarr;
Datum *newitemsarr;
if (resarr->nitems < resarr->maxitems)
return; /* no work needed */
olditemsarr = resarr->itemsarr;
oldcap = resarr->capacity;
/* Double the capacity of the array (capacity must stay a power of 2!) */
newcap = (oldcap > 0) ? oldcap * 2 : RESARRAY_INIT_SIZE;
newitemsarr = (Datum *) MemoryContextAlloc(TopMemoryContext,
newcap * sizeof(Datum));
for (i = 0; i < newcap; i++)
newitemsarr[i] = resarr->invalidval;
/* We assume we can't fail below this point, so OK to scribble on resarr */
resarr->itemsarr = newitemsarr;
resarr->capacity = newcap;
resarr->maxitems = RESARRAY_MAX_ITEMS(newcap);
resarr->nitems = 0;
if (olditemsarr != NULL)
{
/*
* Transfer any pre-existing entries into the new array; they don't
* necessarily go where they were before, so this simple logic is the
* best way. Note that if we were managing the set as a simple array,
* the entries after nitems are garbage, but that shouldn't matter
* because we won't get here unless nitems was equal to oldcap.
*/
for (i = 0; i < oldcap; i++)
{
if (olditemsarr[i] != resarr->invalidval)
ResourceArrayAdd(resarr, olditemsarr[i]);
}
/* And release old array. */
pfree(olditemsarr);
}
Assert(resarr->nitems < resarr->maxitems);
}
/*
* Remember that a catcache reference is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeCatCacheRefs()
*/
void
ResourceOwnerRememberCatCacheRef(ResourceOwner owner, HeapTuple tuple)
{
ResourceArrayAdd(&(owner->catrefarr), PointerGetDatum(tuple));
}
/*
* Remember that a buffer pin is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeBuffers()
*/
void
ResourceOwnerRememberBuffer(ResourceOwner owner, Buffer buffer)
{
ResourceArrayAdd(&(owner->bufferarr), BufferGetDatum(buffer));
}
/*
* Remember that a JIT context is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeJIT()
*/
void
ResourceOwnerRememberJIT(ResourceOwner owner, Datum handle)
{
ResourceArrayAdd(&(owner->jitarr), handle);
}
/*
* Remember that a dynamic shmem segment is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeDSMs()
*/
void
ResourceOwnerRememberDSM(ResourceOwner owner, dsm_segment *seg)
{
ResourceArrayAdd(&(owner->dsmarr), PointerGetDatum(seg));
}
/*
* Remember that a temporary file is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeFiles()
*/
void
ResourceOwnerRememberFile(ResourceOwner owner, File file)
{
ResourceArrayAdd(&(owner->filearr), FileGetDatum(file));
}
/*
* Remember that a snapshot reference is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeSnapshots()
*/
void
ResourceOwnerRememberSnapshot(ResourceOwner owner, Snapshot snapshot)
{
ResourceArrayAdd(&(owner->snapshotarr), PointerGetDatum(snapshot));
}
/*
* Remember that a tupdesc reference is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeTupleDescs()
*/
void
ResourceOwnerRememberTupleDesc(ResourceOwner owner, TupleDesc tupdesc)
{
ResourceArrayAdd(&(owner->tupdescarr), PointerGetDatum(tupdesc));
}
/*
* Remember that a plancache reference is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargePlanCacheRefs()
*/
void
ResourceOwnerRememberPlanCacheRef(ResourceOwner owner, CachedPlan *plan)
{
ResourceArrayAdd(&(owner->planrefarr), PointerGetDatum(plan));
}
/*
* Remember that a relcache reference is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeRelationRefs()
*/
void
ResourceOwnerRememberRelationRef(ResourceOwner owner, Relation rel)
{
ResourceArrayAdd(&(owner->relrefarr), PointerGetDatum(rel));
}
/*
* Remember that a catcache-list reference is owned by a ResourceOwner
*
* Caller must have previously done ResourceOwnerEnlargeCatCacheListRefs()
*/
void
ResourceOwnerRememberCatCacheListRef(ResourceOwner owner, CatCList *list)
{
ResourceArrayAdd(&(owner->catlistrefarr), PointerGetDatum(list));
}
