#include "postgres.h"
#include "common/int.h"
#include "fmgr.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "port/pg_numa.h"
#include "storage/lwlock.h"
#include "storage/pg_shmem.h"
#include "storage/shmem.h"
#include "storage/spin.h"
#include "utils/builtins.h"

Include dependency graph for shmem.c:

Data Structures
struct	ShmemAllocatorData

Macros
#define	PG_GET_SHMEM_SIZES_COLS 4

#define	PG_GET_SHMEM_NUMA_SIZES_COLS 3

Typedefs
typedef struct ShmemAllocatorData	ShmemAllocatorData

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

Datum	pg_numa_available (PG_FUNCTION_ARGS)

void	InitShmemAllocator (PGShmemHeader *seghdr)

void *	ShmemAlloc (Size size)

void *	ShmemAllocNoError (Size size)

bool	ShmemAddrIsValid (const void *addr)

void	InitShmemIndex (void)

HTAB *	ShmemInitHash (const char name, int64 init_size, int64 max_size, HASHCTL infoP, int hash_flags)

void *	ShmemInitStruct (const char name, Size size, bool foundPtr)

Size	add_size (Size s1, Size s2)

Size	mul_size (Size s1, Size s2)

Datum	pg_get_shmem_allocations (PG_FUNCTION_ARGS)

Datum	pg_get_shmem_allocations_numa (PG_FUNCTION_ARGS)

Size	pg_get_shmem_pagesize (void)

Variables
static PGShmemHeader *	ShmemSegHdr

static void *	ShmemBase

static void *	ShmemEnd

static ShmemAllocatorData *	ShmemAllocator

slock_t *	ShmemLock

static HTAB *	ShmemIndex = NULL

static bool	firstNumaTouch = true

Macro Definition Documentation

◆ PG_GET_SHMEM_NUMA_SIZES_COLS

#define PG_GET_SHMEM_NUMA_SIZES_COLS 3

◆ PG_GET_SHMEM_SIZES_COLS

#define PG_GET_SHMEM_SIZES_COLS 4

Typedef Documentation

◆ ShmemAllocatorData

typedef struct ShmemAllocatorData ShmemAllocatorData

Function Documentation

◆ add_size()

Size add_size	(	Size	s1,
		Size	s2
	)

Definition at line 482 of file shmem.c.

{
    Size        result;
 
    if (pg_add_size_overflow(s1, s2, &result))
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("requested shared memory size overflows size_t")));
    return result;
}

References ereport, errcode(), errmsg(), ERROR, pg_add_size_overflow(), s1, and s2.

Referenced by _brin_parallel_estimate_shared(), _bt_parallel_estimate_shared(), _gin_parallel_estimate_shared(), AioShmemSize(), ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), btestimateparallelscan(), BTreeShmemSize(), BufferManagerShmemSize(), CalculateShmemSize(), CheckpointerShmemSize(), CreateAnonymousSegment(), estimate_variable_size(), EstimateClientConnectionInfoSpace(), EstimateComboCIDStateSpace(), EstimateGUCStateSpace(), EstimateLibraryStateSpace(), EstimateParamExecSpace(), EstimateParamListSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecAggEstimate(), ExecAppendEstimate(), ExecBitmapHeapEstimate(), ExecBitmapHeapInitializeDSM(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecMemoizeEstimate(), ExecSortEstimate(), expand_planner_arrays(), FastPathLockShmemSize(), hash_estimate_size(), index_parallelscan_estimate(), index_parallelscan_initialize(), InitializeShmemGUCs(), InjectionPointShmemSize(), LockManagerShmemSize(), LWLockShmemSize(), MultiXactShmemSize(), pgaio_worker_shmem_size(), PgArchShmemSize(), PGProcShmemSize(), pgss_memsize(), PMSignalShmemSize(), PredicateLockShmemInit(), PredicateLockShmemSize(), ProcArrayShmemInit(), ProcArrayShmemSize(), ProcGlobalShmemSize(), ProcSignalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), RequestAddinShmemSpace(), SerializeTransactionState(), SharedInvalShmemSize(), shm_toc_estimate(), StatsShmemSize(), StrategyShmemSize(), table_parallelscan_estimate(), tuplesort_estimate_shared(), TwoPhaseShmemSize(), WaitEventCustomShmemSize(), WaitLSNShmemSize(), WalRcvShmemSize(), WalSndShmemSize(), and XLOGShmemSize().

◆ InitShmemAllocator()

void InitShmemAllocator ( PGShmemHeader * seghdr )

Definition at line 122 of file shmem.c.

{
    Assert(seghdr != NULL);
 
    /*
     * We assume the pointer and offset are MAXALIGN.  Not a hard requirement,
     * but it's true today and keeps the math below simpler.
     */
    Assert(seghdr == (void *) MAXALIGN(seghdr));
    Assert(seghdr->content_offset == MAXALIGN(seghdr->content_offset));
 
    ShmemSegHdr = seghdr;
    ShmemBase = seghdr;
    ShmemEnd = (char *) ShmemBase + seghdr->totalsize;
 
#ifndef EXEC_BACKEND
    Assert(!IsUnderPostmaster);
#endif
    if (IsUnderPostmaster)
    {
        PGShmemHeader *shmhdr = ShmemSegHdr;
 
        ShmemAllocator = (ShmemAllocatorData *) ((char *) shmhdr + shmhdr->content_offset);
        ShmemLock = &ShmemAllocator->shmem_lock;
    }
    else
    {
        Size        offset;
 
        /*
         * Allocations after this point should go through ShmemAlloc, which
         * expects to allocate everything on cache line boundaries.  Make sure
         * the first allocation begins on a cache line boundary.
         */
        offset = CACHELINEALIGN(seghdr->content_offset + sizeof(ShmemAllocatorData));
        if (offset > seghdr->totalsize)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of shared memory (%zu bytes requested)",
                            offset)));
 
        ShmemAllocator = (ShmemAllocatorData *) ((char *) seghdr + seghdr->content_offset);
 
        SpinLockInit(&ShmemAllocator->shmem_lock);
        ShmemLock = &ShmemAllocator->shmem_lock;
        ShmemAllocator->free_offset = offset;
        /* ShmemIndex can't be set up yet (need LWLocks first) */
        ShmemAllocator->index = NULL;
        ShmemIndex = (HTAB *) NULL;
    }
}

References Assert, CACHELINEALIGN, PGShmemHeader::content_offset, ereport, errcode(), errmsg(), ERROR, ShmemAllocatorData::free_offset, ShmemAllocatorData::index, IsUnderPostmaster, MAXALIGN, ShmemAllocatorData::shmem_lock, ShmemAllocator, ShmemBase, ShmemEnd, ShmemIndex, ShmemLock, ShmemSegHdr, SpinLockInit(), and PGShmemHeader::totalsize.

Referenced by CreateSharedMemoryAndSemaphores().

◆ InitShmemIndex()

void InitShmemIndex ( void )

Definition at line 274 of file shmem.c.

{
    HASHCTL     info;
 
    /*
     * Create the shared memory shmem index.
     *
     * Since ShmemInitHash calls ShmemInitStruct, which expects the ShmemIndex
     * hashtable to exist already, we have a bit of a circularity problem in
     * initializing the ShmemIndex itself.  The special "ShmemIndex" hash
     * table name will tell ShmemInitStruct to fake it.
     */
    info.keysize = SHMEM_INDEX_KEYSIZE;
    info.entrysize = sizeof(ShmemIndexEnt);
 
    ShmemIndex = ShmemInitHash("ShmemIndex",
                               SHMEM_INDEX_SIZE, SHMEM_INDEX_SIZE,
                               &info,
                               HASH_ELEM | HASH_STRINGS);
}

References HASHCTL::entrysize, HASH_ELEM, HASH_STRINGS, HASHCTL::keysize, SHMEM_INDEX_KEYSIZE, SHMEM_INDEX_SIZE, ShmemIndex, and ShmemInitHash().

Referenced by CreateOrAttachShmemStructs().

◆ mul_size()

Size mul_size	(	Size	s1,
		Size	s2
	)

Definition at line 497 of file shmem.c.

{
    Size        result;
 
    if (pg_mul_size_overflow(s1, s2, &result))
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("requested shared memory size overflows size_t")));
    return result;
}

References ereport, errcode(), errmsg(), ERROR, pg_mul_size_overflow(), s1, and s2.

Referenced by _brin_begin_parallel(), _bt_begin_parallel(), _gin_begin_parallel(), AioBackendShmemSize(), AioHandleDataShmemSize(), AioHandleIOVShmemSize(), AioHandleShmemSize(), ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemInit(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), BTreeShmemSize(), BufferManagerShmemSize(), CheckpointerShmemSize(), EstimateComboCIDStateSpace(), EstimatePendingSyncsSpace(), EstimateReindexStateSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecAggEstimate(), ExecBitmapHeapEstimate(), ExecBitmapHeapInitializeDSM(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecInitParallelPlan(), ExecMemoizeEstimate(), ExecParallelRetrieveInstrumentation(), ExecParallelRetrieveJitInstrumentation(), ExecParallelSetupTupleQueues(), ExecSortEstimate(), FastPathLockShmemSize(), hash_estimate_size(), InitializeParallelDSM(), LWLockShmemSize(), parallel_vacuum_init(), PGProcShmemSize(), PGSemaphoreShmemSize(), PMSignalShmemSize(), PredicateLockShmemInit(), PredicateLockShmemSize(), ProcArrayShmemInit(), ProcArrayShmemSize(), ProcSignalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), SharedInvalShmemSize(), shm_toc_estimate(), tuplesort_estimate_shared(), TwoPhaseShmemSize(), WaitLSNShmemSize(), WalSndShmemSize(), and XLOGShmemSize().

◆ pg_get_shmem_allocations()

Datum pg_get_shmem_allocations ( PG_FUNCTION_ARGS )

Definition at line 510 of file shmem.c.

{
#define PG_GET_SHMEM_SIZES_COLS 4
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    HASH_SEQ_STATUS hstat;
    ShmemIndexEnt *ent;
    Size        named_allocated = 0;
    Datum       values[PG_GET_SHMEM_SIZES_COLS];
    bool        nulls[PG_GET_SHMEM_SIZES_COLS];
 
    InitMaterializedSRF(fcinfo, 0);
 
    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(rsinfo->setResult, rsinfo->setDesc,
                             values, nulls);
    }
 
    /* output shared memory allocated but not counted via the shmem index */
    values[0] = CStringGetTextDatum("<anonymous>");
    nulls[1] = true;
    values[2] = Int64GetDatum(ShmemAllocator->free_offset - named_allocated);
    values[3] = values[2];
    tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
 
    /* output as-of-yet unused shared memory */
    nulls[0] = true;
    values[1] = Int64GetDatum(ShmemAllocator->free_offset);
    nulls[1] = false;
    values[2] = Int64GetDatum(ShmemSegHdr->totalsize - ShmemAllocator->free_offset);
    values[3] = values[2];
    tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
 
    LWLockRelease(ShmemIndexLock);
 
    return (Datum) 0;
}

References ShmemIndexEnt::allocated_size, CStringGetTextDatum, ShmemAllocatorData::free_offset, hash_seq_init(), hash_seq_search(), InitMaterializedSRF(), Int64GetDatum(), ShmemIndexEnt::key, ShmemIndexEnt::location, LW_SHARED, LWLockAcquire(), LWLockRelease(), PG_GET_SHMEM_SIZES_COLS, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, ShmemAllocator, ShmemIndex, ShmemSegHdr, ShmemIndexEnt::size, PGShmemHeader::totalsize, tuplestore_putvalues(), and values.

◆ pg_get_shmem_allocations_numa()

Datum pg_get_shmem_allocations_numa ( PG_FUNCTION_ARGS )

Definition at line 567 of file shmem.c.

{
#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_array(Size, max_nodes + 2);
 
    /*
     * Shared memory allocations can vary in size and may not align with OS
     * memory page boundaries, while NUMA queries work on pages.
     *
     * To correctly map each allocation to NUMA nodes, we need to: 1.
     * Determine the OS memory page size. 2. Align each allocation's start/end
     * addresses to page boundaries. 3. Query NUMA node information for all
     * pages spanning the allocation.
     */
    os_page_size = pg_get_shmem_pagesize();
 
    /*
     * Allocate memory for page pointers and status based on total shared
     * memory size. This simplified approach allocates enough space for all
     * pages in shared memory rather than calculating the exact requirements
     * for each segment.
     *
     * Add 1, because we don't know how exactly the segments align to OS
     * pages, so the allocation might use one more memory page. In practice
     * this is not very likely, and moreover we have more entries, each of
     * them using only fraction of the total pages.
     */
    shm_total_page_count = (ShmemSegHdr->totalsize / os_page_size) + 1;
    page_ptrs = palloc0_array(void *, shm_total_page_count);
    pages_status = palloc_array(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 */
    while ((ent = (ShmemIndexEnt *) hash_seq_search(&hstat)) != NULL)
    {
        int         i;
        char       *startptr,
                   *endptr;
        Size        total_len;
 
        /*
         * Calculate the range of OS pages used by this segment. The segment
         * may start / end half-way through a page, we want to count these
         * pages too. So we align the start/end pointers down/up, and then
         * calculate the number of pages from that.
         */
        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;
 
        /*
         * If we ever get 0xff (-1) back from kernel inquiry, then we probably
         * have a bug in mapping buffers to OS pages.
         */
        memset(pages_status, 0xff, sizeof(int) * shm_ent_page_count);
 
        /*
         * Setup page_ptrs[] with pointers to all OS pages for this segment,
         * and get the NUMA status using pg_numa_query_pages.
         *
         * In order to get reliable results we also need to touch memory
         * pages, so that inquiry about NUMA memory node doesn't return -2
         * (ENOENT, which indicates unmapped/unallocated pages).
         */
        for (i = 0; i < shm_ent_page_count; i++)
        {
            page_ptrs[i] = startptr + (i * os_page_size);
 
            if (firstNumaTouch)
                pg_numa_touch_mem_if_required(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 + 2));
 
        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)
            {
                /* valid NUMA node */
                nodes[s]++;
                continue;
            }
            else if (s == -2)
            {
                /* -2 means ENOENT (e.g. page was moved to swap) */
                nodes[max_nodes + 1]++;
                continue;
            }
 
            elog(ERROR, "invalid NUMA node id outside of allowed range "
                 "[0, " UINT64_FORMAT "]: %d", max_nodes, s);
        }
 
        /* no NULLs for regular nodes */
        memset(nulls, 0, sizeof(nulls));
 
        /*
         * Add one entry for each NUMA node, including those without allocated
         * memory for this segment.
         */
        for (i = 0; i <= max_nodes; i++)
        {
            values[0] = CStringGetTextDatum(ent->key);
            values[1] = Int32GetDatum(i);
            values[2] = Int64GetDatum(nodes[i] * os_page_size);
 
            tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                                 values, nulls);
        }
 
        /* The last entry is used for pages without a NUMA node. */
        nulls[1] = true;
        values[0] = CStringGetTextDatum(ent->key);
        values[2] = Int64GetDatum(nodes[max_nodes + 1] * os_page_size);
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                             values, nulls);
    }
 
    LWLockRelease(ShmemIndexLock);
    firstNumaTouch = false;
 
    return (Datum) 0;
}

References ShmemIndexEnt::allocated_size, CHECK_FOR_INTERRUPTS, CStringGetTextDatum, DEBUG1, elog, ERROR, firstNumaTouch, hash_seq_init(), hash_seq_search(), i, InitMaterializedSRF(), Int32GetDatum(), Int64GetDatum(), ShmemIndexEnt::key, ShmemIndexEnt::location, LW_SHARED, LWLockAcquire(), LWLockRelease(), palloc0_array, palloc_array, PG_GET_SHMEM_NUMA_SIZES_COLS, pg_get_shmem_pagesize(), pg_numa_get_max_node(), pg_numa_init(), pg_numa_query_pages(), pg_numa_touch_mem_if_required, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, ShmemIndex, ShmemSegHdr, PGShmemHeader::totalsize, tuplestore_putvalues(), TYPEALIGN, TYPEALIGN_DOWN, UINT64_FORMAT, and values.

◆ pg_get_shmem_pagesize()

Size pg_get_shmem_pagesize ( void )

Definition at line 738 of file shmem.c.

{
    Size        os_page_size;
#ifdef WIN32
    SYSTEM_INFO sysinfo;
 
    GetSystemInfo(&sysinfo);
    os_page_size = sysinfo.dwPageSize;
#else
    os_page_size = sysconf(_SC_PAGESIZE);
#endif
 
    Assert(IsUnderPostmaster);
    Assert(huge_pages_status != HUGE_PAGES_UNKNOWN);
 
    if (huge_pages_status == HUGE_PAGES_ON)
        GetHugePageSize(&os_page_size, NULL);
 
    return os_page_size;
}

References Assert, GetHugePageSize(), HUGE_PAGES_ON, huge_pages_status, HUGE_PAGES_UNKNOWN, and IsUnderPostmaster.

Referenced by pg_buffercache_os_pages_internal(), and pg_get_shmem_allocations_numa().

◆ pg_numa_available()

Datum pg_numa_available ( PG_FUNCTION_ARGS )

Definition at line 760 of file shmem.c.

{
    PG_RETURN_BOOL(pg_numa_init() != -1);
}

References pg_numa_init(), and PG_RETURN_BOOL.

◆ ShmemAddrIsValid()

bool ShmemAddrIsValid ( const void * addr )

Definition at line 265 of file shmem.c.

{
    return (addr >= ShmemBase) && (addr < ShmemEnd);
}

References ShmemBase, and ShmemEnd.

Referenced by ReleasePredXact(), and ShmemInitStruct().

◆ ShmemAlloc()

void * ShmemAlloc ( Size size )

Definition at line 182 of file shmem.c.

{
    void       *newSpace;
    Size        allocated_size;
 
    newSpace = ShmemAllocRaw(size, &allocated_size);
    if (!newSpace)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of shared memory (%zu bytes requested)",
                        size)));
    return newSpace;
}

References ereport, errcode(), errmsg(), ERROR, and ShmemAllocRaw().

Referenced by CreateLWLocks(), PGReserveSemaphores(), ShmemInitStruct(), and StatsShmemInit().

◆ ShmemAllocNoError()

void * ShmemAllocNoError ( Size size )

Definition at line 202 of file shmem.c.

{
    Size        allocated_size;
 
    return ShmemAllocRaw(size, &allocated_size);
}

References ShmemAllocRaw().

Referenced by ShmemInitHash().

◆ ShmemAllocRaw()

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

static

Definition at line 216 of file shmem.c.

{
    Size        newStart;
    Size        newFree;
    void       *newSpace;
 
    /*
     * Ensure all space is adequately aligned.  We used to only MAXALIGN this
     * space but experience has proved that on modern systems that is not good
     * enough.  Many parts of the system are very sensitive to critical data
     * structures getting split across cache line boundaries.  To avoid that,
     * attempt to align the beginning of the allocation to a cache line
     * boundary.  The calling code will still need to be careful about how it
     * uses the allocated space - e.g. by padding each element in an array of
     * structures out to a power-of-two size - but without this, even that
     * won't be sufficient.
     */
    size = CACHELINEALIGN(size);
    *allocated_size = size;
 
    Assert(ShmemSegHdr != NULL);
 
    SpinLockAcquire(ShmemLock);
 
    newStart = ShmemAllocator->free_offset;
 
    newFree = newStart + size;
    if (newFree <= ShmemSegHdr->totalsize)
    {
        newSpace = (char *) ShmemBase + newStart;
        ShmemAllocator->free_offset = newFree;
    }
    else
        newSpace = NULL;
 
    SpinLockRelease(ShmemLock);
 
    /* note this assert is okay with newSpace == NULL */
    Assert(newSpace == (void *) CACHELINEALIGN(newSpace));
 
    return newSpace;
}

References Assert, CACHELINEALIGN, ShmemAllocatorData::free_offset, ShmemAllocator, ShmemBase, ShmemLock, ShmemSegHdr, SpinLockAcquire(), and SpinLockRelease().

Referenced by ShmemAlloc(), ShmemAllocNoError(), and ShmemInitStruct().

◆ ShmemInitHash()

HTAB * ShmemInitHash	(	const char *	name,
		int64	init_size,
		int64	max_size,
		HASHCTL *	infoP,
		int	hash_flags
	)

Definition at line 323 of file shmem.c.

{
    bool        found;
    void       *location;
 
    /*
     * Hash tables allocated in shared memory have a fixed directory; it can't
     * grow or other backends wouldn't be able to find it. So, make sure we
     * make it big enough to start with.
     *
     * The shared memory allocator must be specified too.
     */
    infoP->dsize = infoP->max_dsize = hash_select_dirsize(max_size);
    infoP->alloc = ShmemAllocNoError;
    hash_flags |= HASH_SHARED_MEM | HASH_ALLOC | HASH_DIRSIZE;
 
    /* look it up in the shmem index */
    location = ShmemInitStruct(name,
                               hash_get_shared_size(infoP, hash_flags),
                               &found);
 
    /*
     * if it already exists, attach to it rather than allocate and initialize
     * new space
     */
    if (found)
        hash_flags |= HASH_ATTACH;
 
    /* Pass location of hashtable header to hash_create */
    infoP->hctl = (HASHHDR *) location;
 
    return hash_create(name, init_size, infoP, hash_flags);
}

References HASHCTL::alloc, HASHCTL::dsize, HASH_ALLOC, HASH_ATTACH, hash_create(), HASH_DIRSIZE, hash_get_shared_size(), hash_select_dirsize(), HASH_SHARED_MEM, HASHCTL::hctl, HASHCTL::max_dsize, name, ShmemAllocNoError(), and ShmemInitStruct().

Referenced by InitBufTable(), InitShmemIndex(), LockManagerShmemInit(), pgss_shmem_startup(), PredicateLockShmemInit(), and WaitEventCustomShmemInit().

◆ ShmemInitStruct()

void * ShmemInitStruct	(	const char *	name,
		Size	size,
		bool *	foundPtr
	)

Definition at line 378 of file shmem.c.

{
    ShmemIndexEnt *result;
    void       *structPtr;
 
    LWLockAcquire(ShmemIndexLock, LW_EXCLUSIVE);
 
    if (!ShmemIndex)
    {
        /* Must be trying to create/attach to ShmemIndex itself */
        Assert(strcmp(name, "ShmemIndex") == 0);
 
        if (IsUnderPostmaster)
        {
            /* Must be initializing a (non-standalone) backend */
            Assert(ShmemAllocator->index != NULL);
            structPtr = ShmemAllocator->index;
            *foundPtr = true;
        }
        else
        {
            /*
             * If the shmem index doesn't exist, we are bootstrapping: we must
             * be trying to init the shmem index itself.
             *
             * Notice that the ShmemIndexLock is released before the shmem
             * index has been initialized.  This should be OK because no other
             * process can be accessing shared memory yet.
             */
            Assert(ShmemAllocator->index == NULL);
            structPtr = ShmemAlloc(size);
            ShmemAllocator->index = structPtr;
            *foundPtr = false;
        }
        LWLockRelease(ShmemIndexLock);
        return structPtr;
    }
 
    /* look it up in the shmem index */
    result = (ShmemIndexEnt *)
        hash_search(ShmemIndex, name, HASH_ENTER_NULL, foundPtr);
 
    if (!result)
    {
        LWLockRelease(ShmemIndexLock);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("could not create ShmemIndex entry for data structure \"%s\"",
                        name)));
    }
 
    if (*foundPtr)
    {
        /*
         * Structure is in the shmem index so someone else has allocated it
         * already.  The size better be the same as the size we are trying to
         * initialize to, or there is a name conflict (or worse).
         */
        if (result->size != size)
        {
            LWLockRelease(ShmemIndexLock);
            ereport(ERROR,
                    (errmsg("ShmemIndex entry size is wrong for data structure"
                            " \"%s\": expected %zu, actual %zu",
                            name, size, result->size)));
        }
        structPtr = result->location;
    }
    else
    {
        Size        allocated_size;
 
        /* It isn't in the table yet. allocate and initialize it */
        structPtr = ShmemAllocRaw(size, &allocated_size);
        if (structPtr == NULL)
        {
            /* out of memory; remove the failed ShmemIndex entry */
            hash_search(ShmemIndex, name, HASH_REMOVE, NULL);
            LWLockRelease(ShmemIndexLock);
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("not enough shared memory for data structure"
                            " \"%s\" (%zu bytes requested)",
                            name, size)));
        }
        result->size = size;
        result->allocated_size = allocated_size;
        result->location = structPtr;
    }
 
    LWLockRelease(ShmemIndexLock);
 
    Assert(ShmemAddrIsValid(structPtr));
 
    Assert(structPtr == (void *) CACHELINEALIGN(structPtr));
 
    return structPtr;
}