<row>

<entry><link linkend="view-pg-shmem-allocations"><structname>pg_shmem_allocations</structname></link></entry>

<entry>shared memory allocations</entry>

</row>

<sect1 id="view-pg-shmem-allocations">

<title><structname>pg_shmem_allocations</structname></title>

<indexterm zone="view-pg-shmem-allocations">

<primary>pg_shmem_allocations</primary>

</indexterm>

<para>

The <structname>pg_shmem_allocations</structname> view shows allocations

made from the server's main shared memory segment. This includes both

memory allocated by <productname>postgres</productname> itself and memory

allocated by extensions using the mechanisms detailed in

<xref linkend="xfunc-shared-addin" />.

</para>

<para>

Note that this view does not include memory allocated using the dynamic

shared memory infrastructure.

</para>

<table>

<title><structname>pg_shmem_allocations</structname> Columns</title>

<tgroup cols="3">

<thead>

<row>

<entry>Name</entry>

<entry>Type</entry>

<entry>Description</entry>

</row>

</thead>

<tbody>

<row>

<entry><structfield>name</structfield></entry>

<entry><type>text</type></entry>

<entry>The name of the shared memory allocation. NULL for unused memory

and <literal>&lt;anonymous&gt;</literal> for anonymous

allocations.</entry>

</row>

<row>

<entry><structfield>off</structfield></entry>

<entry><type>bigint</type></entry>

<entry>The offset at which the allocation starts. NULL for anonymous

allocations and unused memory.</entry>

</row>

<row>

<entry><structfield>size</structfield></entry>

<entry><type>bigint</type></entry>

<entry>Size of the allocation</entry>

</row>

<row>

<entry><structfield>allocated_size</structfield></entry>

<entry><type>bigint</type></entry>

<entry>Size of the allocation including padding. For anonymous

allocations, no information about padding is available, so the

<literal>size</literal> and <literal>allocated_size</literal> columns

will always be equal. Padding is not meaningful for free memory, so

the columns will be equal in that case also.</entry>

</row>

</tbody>

</tgroup>

</table>

<para>

Anonymous allocations are allocations that have been made

with <literal>ShmemAlloc()</literal> directly, rather than via

<literal>ShmemInitStruct()</literal> or

<literal>ShmemInitHash()</literal>.

</para>

<para>

By default, the <structname>pg_shmem_allocations</structname> view can be

read only by superusers.

</para>

</sect1>

<sect2 id="xfunc-shared-addin">

CREATE VIEW pg_shmem_allocations AS

SELECT * FROM pg_get_shmem_allocations();

REVOKE ALL ON pg_shmem_allocations FROM PUBLIC;

REVOKE EXECUTE ON FUNCTION pg_get_shmem_allocations() FROM PUBLIC;

#include "fmgr.h"

#include "funcapi.h"

#include "utils/builtins.h"

static void *ShmemAllocRaw(Size size, Size *allocated_size);

Size allocated_size;

newSpace = ShmemAllocRaw(size, &allocated_size);

{

Size allocated_size;

return ShmemAllocRaw(size, &allocated_size);

}

static void *

ShmemAllocRaw(Size size, Size *allocated_size)

*allocated_size = size;

Size allocated_size;

structPtr = ShmemAllocRaw(size, &allocated_size);

result->allocated_size = allocated_size;

pg_get_shmem_allocations(PG_FUNCTION_ARGS)

{

#define PG_GET_SHMEM_SIZES_COLS 4

ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;

TupleDesc tupdesc;

Tuplestorestate *tupstore;

MemoryContext per_query_ctx;

MemoryContext oldcontext;

HASH_SEQ_STATUS hstat;

ShmemIndexEnt *ent;

Size named_allocated = 0;

Datum values[PG_GET_SHMEM_SIZES_COLS];

bool nulls[PG_GET_SHMEM_SIZES_COLS];

/* check to see if caller supports us returning a tuplestore */

if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("set-valued function called in context that cannot accept a set")));

if (!(rsinfo->allowedModes & SFRM_Materialize))

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("materialize mode required, but it is not allowed in this context")));

/* Build a tuple descriptor for our result type */

if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)

elog(ERROR, "return type must be a row type");

per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;

oldcontext = MemoryContextSwitchTo(per_query_ctx);

tupstore = tuplestore_begin_heap(true, false, work_mem);

rsinfo->returnMode = SFRM_Materialize;

rsinfo->setResult = tupstore;

rsinfo->setDesc = tupdesc;

MemoryContextSwitchTo(oldcontext);

LWLockAcquire(ShmemIndexLock, LW_SHARED);

hash_seq_init(&hstat, ShmemIndex);

/* output all allocated entries */

memset(nulls, 0, sizeof(nulls));

while ((ent = (ShmemIndexEnt *) hash_seq_search(&hstat)) != NULL)

{

values[0] = CStringGetTextDatum(ent->key);

values[1] = Int64GetDatum((char *) ent->location - (char *) ShmemSegHdr);

values[2] = Int64GetDatum(ent->size);

values[3] = Int64GetDatum(ent->allocated_size);

named_allocated += ent->allocated_size;

tuplestore_putvalues(tupstore, tupdesc, values, nulls);

}

/* output shared memory allocated but not counted via the shmem index */

values[0] = CStringGetTextDatum("<anonymous>");

nulls[1] = true;

values[2] = Int64GetDatum(ShmemSegHdr->freeoffset - named_allocated);

values[3] = values[2];

tuplestore_putvalues(tupstore, tupdesc, values, nulls);

/* output as-of-yet unused shared memory */

nulls[0] = true;

values[1] = Int64GetDatum(ShmemSegHdr->freeoffset);

nulls[1] = false;

values[2] = Int64GetDatum(ShmemSegHdr->totalsize - ShmemSegHdr->freeoffset);

values[3] = values[2];

tuplestore_putvalues(tupstore, tupdesc, values, nulls);

LWLockRelease(ShmemIndexLock);

tuplestore_donestoring(tupstore);

return (Datum) 0;

}

# shared memory usage

{ oid => '8613',

descr => 'allocations from the main shared memory segment',

proname => 'pg_get_shmem_allocations', 'prorows' => 50, 'proretset' => 't',

provolatile => 'v', 'prorettype' => 'record', 'proargtypes' => '',

proallargtypes => '{text,int8,int8,int8}', proargmodes => '{o,o,o,o}',

proargnames => '{name,off,size,allocated_size}',

prosrc => 'pg_get_shmem_allocations' },

Size size; /* # bytes requested for the structure */

Size allocated_size; /* # bytes actually allocated */

pg_shmem_allocations| SELECT pg_get_shmem_allocations.name,

pg_get_shmem_allocations.off,

pg_get_shmem_allocations.size,

pg_get_shmem_allocations.allocated_size

FROM pg_get_shmem_allocations() pg_get_shmem_allocations(name, off, size, allocated_size);