<row>

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

<entry>NUMA node mappings for shared memory allocations</entry>

</row>

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

<title><structname>pg_shmem_allocations_numa</structname></title>

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

<primary>pg_shmem_allocations_numa</primary>

</indexterm>

<para>

The <structname>pg_shmem_allocations_numa</structname> shows how shared

memory allocations in the server's main shared memory segment are distributed

across NUMA nodes. This includes both memory allocated by

<productname>PostgreSQL</productname> itself and memory allocated

by extensions using the mechanisms detailed in

<xref linkend="xfunc-shared-addin" />. This view will output multiple rows

for each of the shared memory segments provided that they are spread accross

multiple NUMA nodes. This view should not be queried by monitoring systems

as it is very slow and may end up allocating shared memory in case it was not

used earlier.

Current limitation for this view is that won't show anonymous shared memory

allocations.

</para>

<para>

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

shared memory infrastructure.

</para>

<warning>

<para>

When determining the <acronym>NUMA</acronym> node, the view touches

all memory pages for the shared memory segment. This will force

allocation of the shared memory, if it wasn't allocated already,

and the memory may get allocated in a single <acronym>NUMA</acronym>

node (depending on system configuration).

</para>

</warning>

<table>

<title><structname>pg_shmem_allocations_numa</structname> Columns</title>

<tgroup cols="1">

<thead>

<row>

<entry role="catalog_table_entry"><para role="column_definition">

Column Type

</para>

<para>

Description

</para></entry>

</row>

</thead>

<tbody>

<row>

<entry role="catalog_table_entry"><para role="column_definition">

<structfield>name</structfield> <type>text</type>

</para>

<para>

The name of the shared memory allocation.

</para></entry>

</row>

<row>

<entry role="catalog_table_entry"><para role="column_definition">

<structfield>numa_node</structfield> <type>int4</type>

</para>

<para>

ID of <acronym>NUMA</acronym> node

</para></entry>

</row>

<row>

<entry role="catalog_table_entry"><para role="column_definition">

<structfield>size</structfield> <type>int4</type>

</para>

<para>

Size of the allocation on this particular NUMA memory node in bytes

</para></entry>

</row>

</tbody>

</tgroup>

</table>

<para>

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

read only by superusers or roles with privileges of the

<literal>pg_read_all_stats</literal> role.

</para>

</sect1>

CREATE VIEW pg_shmem_allocations_numa AS

SELECT * FROM pg_get_shmem_allocations_numa();

REVOKE ALL ON pg_shmem_allocations_numa FROM PUBLIC;

GRANT SELECT ON pg_shmem_allocations_numa TO pg_read_all_stats;

REVOKE EXECUTE ON FUNCTION pg_get_shmem_allocations_numa() FROM PUBLIC;

GRANT EXECUTE ON FUNCTION pg_get_shmem_allocations_numa() TO pg_read_all_stats;

#include "port/pg_numa.h"

static bool firstNumaTouch = true;

pg_get_shmem_allocations_numa(PG_FUNCTION_ARGS)

{

#define PG_GET_SHMEM_NUMA_SIZES_COLS 3

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

HASH_SEQ_STATUS hstat;

ShmemIndexEnt *ent;

Datum values[PG_GET_SHMEM_NUMA_SIZES_COLS];

bool nulls[PG_GET_SHMEM_NUMA_SIZES_COLS];

Size os_page_size;

void **page_ptrs;

int *pages_status;

uint64 shm_total_page_count,

shm_ent_page_count,

max_nodes;

Size *nodes;

if (pg_numa_init() == -1)

elog(ERROR, "libnuma initialization failed or NUMA is not supported on this platform");

InitMaterializedSRF(fcinfo, 0);

max_nodes = pg_numa_get_max_node();

nodes = palloc(sizeof(Size) * (max_nodes + 1));

/*

os_page_size = pg_numa_get_pagesize();

/*

shm_total_page_count = (ShmemSegHdr->totalsize / os_page_size) + 1;

page_ptrs = palloc0(sizeof(void *) * shm_total_page_count);

pages_status = palloc(sizeof(int) * shm_total_page_count);

if (firstNumaTouch)

elog(DEBUG1, "NUMA: page-faulting shared memory segments for proper NUMA readouts");

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)

{

int i;

char *startptr,

*endptr;

Size total_len;

/*

startptr = (char *) TYPEALIGN_DOWN(os_page_size, ent->location);

endptr = (char *) TYPEALIGN(os_page_size,

(char *) ent->location + ent->allocated_size);

total_len = (endptr - startptr);

shm_ent_page_count = total_len / os_page_size;

/*

memset(pages_status, 0xff, sizeof(int) * shm_ent_page_count);

/*

for (i = 0; i < shm_ent_page_count; i++)

{

volatile uint64 touch pg_attribute_unused();

page_ptrs[i] = startptr + (i * os_page_size);

if (firstNumaTouch)

pg_numa_touch_mem_if_required(touch, page_ptrs[i]);

CHECK_FOR_INTERRUPTS();

}

if (pg_numa_query_pages(0, shm_ent_page_count, page_ptrs, pages_status) == -1)

elog(ERROR, "failed NUMA pages inquiry status: %m");

/* Count number of NUMA nodes used for this shared memory entry */

memset(nodes, 0, sizeof(Size) * (max_nodes + 1));

for (i = 0; i < shm_ent_page_count; i++)

{

int s = pages_status[i];

/* Ensure we are adding only valid index to the array */

if (s < 0 || s > max_nodes)

{

elog(ERROR, "invalid NUMA node id outside of allowed range "

"[0, " UINT64_FORMAT "]: %d", max_nodes, s);

}

nodes[s]++;

}

/*

for (i = 0; i <= max_nodes; i++)

{

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

values[1] = i;

values[2] = Int64GetDatum(nodes[i] * os_page_size);

tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,

values, nulls);

}

}

LWLockRelease(ShmemIndexLock);

firstNumaTouch = false;

return (Datum) 0;

}

#define CATALOG_VERSION_NO 202504073

# shared memory usage with NUMA info

{ oid => '4100', descr => 'NUMA mappings for the main shared memory segment',

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

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

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

proargnames => '{name,numa_node,size}',

prosrc => 'pg_get_shmem_allocations_numa' },

SELECT NOT(pg_numa_available()) AS skip_test \gset

\if :skip_test

SELECT COUNT(*) = 0 AS ok FROM pg_shmem_allocations_numa;

\quit

\endif

-- switch to superuser

\c -

SELECT COUNT(*) >= 0 AS ok FROM pg_shmem_allocations_numa;

ok

----

t

(1 row)

SELECT NOT(pg_numa_available()) AS skip_test \gset

\if :skip_test

SELECT COUNT(*) = 0 AS ok FROM pg_shmem_allocations_numa;

ERROR: libnuma initialization failed or NUMA is not supported on this platform

\quit

-- test to check privileges of system views pg_shmem_allocations,

-- pg_shmem_allocations_numa and pg_backend_memory_contexts.

SELECT has_table_privilege('regress_readallstats','pg_shmem_allocations_numa','SELECT'); -- no

has_table_privilege

---------------------

f

(1 row)

SELECT has_table_privilege('regress_readallstats','pg_shmem_allocations_numa','SELECT'); -- yes

has_table_privilege

---------------------

t

(1 row)

pg_shmem_allocations_numa| SELECT name,

numa_node,

size

FROM pg_get_shmem_allocations_numa() pg_get_shmem_allocations_numa(name, numa_node, size);