test_resowner_many.c File Reference

#include "postgres.h"
#include "fmgr.h"
#include "lib/ilist.h"
#include "utils/resowner.h"

Include dependency graph for test_resowner_many.c:

Go to the source code of this file.

Data Structures
struct	ManyTestResourceKind
struct	ManyTestResource

Functions
static void	ReleaseManyTestResource (Datum res)
static char *	PrintManyTest (Datum res)
static void	InitManyTestResourceKind (ManyTestResourceKind *kind, char *name, ResourceReleasePhase phase, uint32 priority)
static void	RememberManyTestResources (ResourceOwner owner, ManyTestResourceKind *kinds, int nkinds, int nresources)
static void	ForgetManyTestResources (ResourceOwner owner, ManyTestResourceKind *kinds, int nkinds, int nresources)
static int	GetTotalResourceCount (ManyTestResourceKind *kinds, int nkinds)
	PG_FUNCTION_INFO_V1 (test_resowner_many)
Datum	test_resowner_many (PG_FUNCTION_ARGS)

Variables
static ResourceReleasePhase	current_release_phase
static uint32	last_release_priority = 0

Function Documentation

ForgetManyTestResources()

static void ForgetManyTestResources ( ResourceOwner  owner, ManyTestResourceKind *  kinds, int  nkinds, int  nresources  )

static

Definition at line 144 of file test_resowner_many.c.

{
    int         kind_idx = 0;
    int         ntotal;
 
    ntotal = GetTotalResourceCount(kinds, nkinds);
    if (ntotal < nresources)
        elog(PANIC, "cannot free %d resources, only %d remembered", nresources, ntotal);
 
    for (int i = 0; i < nresources; i++)
    {
        bool        found = false;
 
        for (int j = 0; j < nkinds; j++)
        {
            kind_idx = (kind_idx + 1) % nkinds;
            if (!dlist_is_empty(&kinds[kind_idx].current_resources))
            {
                ManyTestResource *mres = dlist_head_element(ManyTestResource, node, &kinds[kind_idx].current_resources);
 
                ResourceOwnerForget(owner, PointerGetDatum(mres), &kinds[kind_idx].desc);
                kinds[kind_idx].nforgotten++;
                dlist_delete(&mres->node);
                pfree(mres);
 
                found = true;
                break;
            }
        }
        if (!found)
            elog(ERROR, "could not find a test resource to forget");
    }
}

References dlist_delete(), dlist_head_element, dlist_is_empty(), elog, ERROR, GetTotalResourceCount(), i, j, ManyTestResourceKind::nforgotten, ManyTestResource::node, PANIC, pfree(), PointerGetDatum(), and ResourceOwnerForget().

Referenced by test_resowner_many().

GetTotalResourceCount()

static int GetTotalResourceCount ( ManyTestResourceKind *  kinds, int  nkinds  )

static

Definition at line 184 of file test_resowner_many.c.

{
    int         ntotal = 0;
 
    for (int i = 0; i < nkinds; i++)
        ntotal += kinds[i].nremembered - kinds[i].nforgotten - kinds[i].nreleased;
 
    return ntotal;
}

References i.

Referenced by ForgetManyTestResources(), and test_resowner_many().

InitManyTestResourceKind()

static void InitManyTestResourceKind ( ManyTestResourceKind *  kind, char *  name, ResourceReleasePhase  phase, uint32  priority  )

static

Definition at line 96 of file test_resowner_many.c.

{
    kind->desc.name = name;
    kind->desc.release_phase = phase;
    kind->desc.release_priority = priority;
    kind->desc.ReleaseResource = ReleaseManyTestResource;
    kind->desc.DebugPrint = PrintManyTest;
    kind->nremembered = 0;
    kind->nforgotten = 0;
    kind->nreleased = 0;
    kind->nleaked = 0;
    dlist_init(&kind->current_resources);
}

References ManyTestResourceKind::current_resources, ResourceOwnerDesc::DebugPrint, ManyTestResourceKind::desc, dlist_init(), name, ResourceOwnerDesc::name, ManyTestResourceKind::nforgotten, ManyTestResourceKind::nleaked, ManyTestResourceKind::nreleased, ManyTestResourceKind::nremembered, PrintManyTest(), ResourceOwnerDesc::release_phase, ResourceOwnerDesc::release_priority, ReleaseManyTestResource(), and ResourceOwnerDesc::ReleaseResource.

Referenced by test_resowner_many().

PG_FUNCTION_INFO_V1()

PG_FUNCTION_INFO_V1

(

test_resowner_many

)

PrintManyTest()

static char * PrintManyTest ( Datum  res )

static

Definition at line 82 of file test_resowner_many.c.

{
    ManyTestResource *mres = (ManyTestResource *) DatumGetPointer(res);
 
    /*
     * XXX: we assume that the DebugPrint function is called once for each
     * leaked resource, and that there are no other callers.
     */
    mres->kind->nleaked++;
 
    return psprintf("many-test resource from %s", mres->kind->desc.name);
}

References DatumGetPointer(), ManyTestResourceKind::desc, ManyTestResource::kind, ResourceOwnerDesc::name, ManyTestResourceKind::nleaked, and psprintf().

Referenced by InitManyTestResourceKind().

ReleaseManyTestResource()

static void ReleaseManyTestResource ( Datum  res )

static

Definition at line 67 of file test_resowner_many.c.

{
    ManyTestResource *mres = (ManyTestResource *) DatumGetPointer(res);
 
    elog(DEBUG1, "releasing resource %p from %s", mres, mres->kind->desc.name);
    Assert(last_release_priority <= mres->kind->desc.release_priority);
 
    dlist_delete(&mres->node);
    mres->kind->nreleased++;
    last_release_priority = mres->kind->desc.release_priority;
    pfree(mres);
}

References Assert(), DatumGetPointer(), DEBUG1, ManyTestResourceKind::desc, dlist_delete(), elog, ManyTestResource::kind, last_release_priority, ResourceOwnerDesc::name, ManyTestResource::node, ManyTestResourceKind::nreleased, pfree(), and ResourceOwnerDesc::release_priority.

Referenced by InitManyTestResourceKind().

RememberManyTestResources()

static void RememberManyTestResources ( ResourceOwner  owner, ManyTestResourceKind *  kinds, int  nkinds, int  nresources  )

static

Definition at line 116 of file test_resowner_many.c.

{
    int         kind_idx = 0;
 
    for (int i = 0; i < nresources; i++)
    {
        ManyTestResource *mres = palloc(sizeof(ManyTestResource));
 
        mres->kind = &kinds[kind_idx];
        dlist_node_init(&mres->node);
 
        ResourceOwnerEnlarge(owner);
        ResourceOwnerRemember(owner, PointerGetDatum(mres), &kinds[kind_idx].desc);
        kinds[kind_idx].nremembered++;
        dlist_push_tail(&kinds[kind_idx].current_resources, &mres->node);
 
        elog(DEBUG1, "remembered resource %p from %s", mres, mres->kind->desc.name);
 
        kind_idx = (kind_idx + 1) % nkinds;
    }
}

References DEBUG1, ManyTestResourceKind::desc, dlist_node_init(), dlist_push_tail(), elog, i, ManyTestResource::kind, ResourceOwnerDesc::name, ManyTestResource::node, ManyTestResourceKind::nremembered, palloc(), PointerGetDatum(), ResourceOwnerEnlarge(), and ResourceOwnerRemember().

Referenced by test_resowner_many().

test_resowner_many()

Datum test_resowner_many

(

PG_FUNCTION_ARGS

)

Definition at line 203 of file test_resowner_many.c.

{
    int32       nkinds = PG_GETARG_INT32(0);
    int32       nremember_bl = PG_GETARG_INT32(1);
    int32       nforget_bl = PG_GETARG_INT32(2);
    int32       nremember_al = PG_GETARG_INT32(3);
    int32       nforget_al = PG_GETARG_INT32(4);
 
    ResourceOwner resowner;
 
    ManyTestResourceKind *before_kinds;
    ManyTestResourceKind *after_kinds;
 
    /* Sanity check the arguments */
    if (nkinds < 0)
        elog(ERROR, "nkinds must be >= 0");
    if (nremember_bl < 0)
        elog(ERROR, "nremember_bl must be >= 0");
    if (nforget_bl < 0 || nforget_bl > nremember_bl)
        elog(ERROR, "nforget_bl must between 0 and 'nremember_bl'");
    if (nremember_al < 0)
        elog(ERROR, "nremember_al must be greater than zero");
    if (nforget_al < 0 || nforget_al > nremember_al)
        elog(ERROR, "nforget_al must between 0 and 'nremember_al'");
 
    /* Initialize all the different resource kinds to use */
    before_kinds = palloc(nkinds * sizeof(ManyTestResourceKind));
    for (int i = 0; i < nkinds; i++)
    {
        InitManyTestResourceKind(&before_kinds[i],
                                 psprintf("resource before locks %d", i),
                                 RESOURCE_RELEASE_BEFORE_LOCKS,
                                 RELEASE_PRIO_FIRST + i);
    }
    after_kinds = palloc(nkinds * sizeof(ManyTestResourceKind));
    for (int i = 0; i < nkinds; i++)
    {
        InitManyTestResourceKind(&after_kinds[i],
                                 psprintf("resource after locks %d", i),
                                 RESOURCE_RELEASE_AFTER_LOCKS,
                                 RELEASE_PRIO_FIRST + i);
    }
 
    resowner = ResourceOwnerCreate(CurrentResourceOwner, "TestOwner");
 
    /* Remember a bunch of resources */
    if (nremember_bl > 0)
    {
        elog(NOTICE, "remembering %d before-locks resources", nremember_bl);
        RememberManyTestResources(resowner, before_kinds, nkinds, nremember_bl);
    }
    if (nremember_al > 0)
    {
        elog(NOTICE, "remembering %d after-locks resources", nremember_al);
        RememberManyTestResources(resowner, after_kinds, nkinds, nremember_al);
    }
 
    /* Forget what was remembered */
    if (nforget_bl > 0)
    {
        elog(NOTICE, "forgetting %d before-locks resources", nforget_bl);
        ForgetManyTestResources(resowner, before_kinds, nkinds, nforget_bl);
    }
 
    if (nforget_al > 0)
    {
        elog(NOTICE, "forgetting %d after-locks resources", nforget_al);
        ForgetManyTestResources(resowner, after_kinds, nkinds, nforget_al);
    }
 
    /* Start releasing */
    elog(NOTICE, "releasing resources before locks");
    current_release_phase = RESOURCE_RELEASE_BEFORE_LOCKS;
    last_release_priority = 0;
    ResourceOwnerRelease(resowner, RESOURCE_RELEASE_BEFORE_LOCKS, false, false);
    Assert(GetTotalResourceCount(before_kinds, nkinds) == 0);
 
    elog(NOTICE, "releasing locks");
    current_release_phase = RESOURCE_RELEASE_LOCKS;
    last_release_priority = 0;
    ResourceOwnerRelease(resowner, RESOURCE_RELEASE_LOCKS, false, false);
 
    elog(NOTICE, "releasing resources after locks");
    current_release_phase = RESOURCE_RELEASE_AFTER_LOCKS;
    last_release_priority = 0;
    ResourceOwnerRelease(resowner, RESOURCE_RELEASE_AFTER_LOCKS, false, false);
    Assert(GetTotalResourceCount(before_kinds, nkinds) == 0);
    Assert(GetTotalResourceCount(after_kinds, nkinds) == 0);
 
    ResourceOwnerDelete(resowner);
 
    PG_RETURN_VOID();
}

References Assert(), current_release_phase, CurrentResourceOwner, elog, ERROR, ForgetManyTestResources(), GetTotalResourceCount(), i, InitManyTestResourceKind(), last_release_priority, NOTICE, palloc(), PG_GETARG_INT32, PG_RETURN_VOID, psprintf(), RELEASE_PRIO_FIRST, RememberManyTestResources(), RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerCreate(), ResourceOwnerDelete(), and ResourceOwnerRelease().

Variable Documentation

current_release_phase

ResourceReleasePhase current_release_phase

static

Definition at line 49 of file test_resowner_many.c.

Referenced by test_resowner_many().

last_release_priority

uint32 last_release_priority = 0

static

Definition at line 50 of file test_resowner_many.c.

Referenced by ReleaseManyTestResource(), and test_resowner_many().