shmem.c File Reference

#include "postgres.h"
#include "access/transam.h"
#include "fmgr.h"
#include "funcapi.h"
#include "miscadmin.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:

Go to the source code of this file.

Macros
#define	PG_GET_SHMEM_SIZES_COLS   4

Functions
static void *	ShmemAllocRaw (Size size, Size *allocated_size)
void	InitShmemAccess (void *seghdr)
void	InitShmemAllocation (void)
void *	ShmemAlloc (Size size)
void *	ShmemAllocNoError (Size size)
void *	ShmemAllocUnlocked (Size size)
bool	ShmemAddrIsValid (const void *addr)
void	InitShmemIndex (void)
HTAB *	ShmemInitHash (const char *name, long init_size, long 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)

Variables
static PGShmemHeader *	ShmemSegHdr
static void *	ShmemBase
static void *	ShmemEnd
slock_t *	ShmemLock
static HTAB *	ShmemIndex = NULL

Macro Definition Documentation

PG_GET_SHMEM_SIZES_COLS

#define PG_GET_SHMEM_SIZES_COLS   4

Referenced by pg_get_shmem_allocations().

Function Documentation

add_size()

Size add_size	(	Size	s1,
		Size	s2
	)

Definition at line 498 of file shmem.c.

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

Referenced by _bt_parallel_estimate_shared(), ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), begin_parallel_vacuum(), BTreeShmemSize(), BufferShmemSize(), CheckpointerShmemSize(), CreateSharedMemoryAndSemaphores(), CreateSharedProcArray(), estimate_variable_size(), EstimateComboCIDStateSpace(), EstimateGUCStateSpace(), EstimateLibraryStateSpace(), EstimateParamExecSpace(), EstimateParamListSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecAggEstimate(), ExecAppendEstimate(), ExecBitmapHeapEstimate(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecSortEstimate(), expand_planner_arrays(), hash_estimate_size(), index_parallelscan_estimate(), index_parallelscan_initialize(), LockShmemSize(), LWLockShmemSize(), MultiXactShmemSize(), pgss_memsize(), PMSignalShmemSize(), PredicateLockShmemSize(), ProcArrayShmemSize(), ProcGlobalShmemSize(), ProcSignalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), RequestAddinShmemSpace(), SerializeTransactionState(), shm_toc_estimate(), SInvalShmemSize(), SnapMgrShmemSize(), StrategyShmemSize(), table_parallelscan_estimate(), tuplesort_estimate_shared(), TwoPhaseShmemSize(), WalRcvShmemSize(), WalSndShmemSize(), and XLOGShmemSize().

{
    Size        result;

    result = s1 + s2;
    /* We are assuming Size is an unsigned type here... */
    if (result < s1 || result < s2)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("requested shared memory size overflows size_t")));
    return result;
}

InitShmemAccess()

void InitShmemAccess

(

void *

seghdr

)

Definition at line 101 of file shmem.c.

References ShmemBase, ShmemEnd, and PGShmemHeader::totalsize.

Referenced by BackendRun(), and CreateSharedMemoryAndSemaphores().

{
    PGShmemHeader *shmhdr = (PGShmemHeader *) seghdr;

    ShmemSegHdr = shmhdr;
    ShmemBase = (void *) shmhdr;
    ShmemEnd = (char *) ShmemBase + shmhdr->totalsize;
}

InitShmemAllocation()

void InitShmemAllocation

(

void

)

Definition at line 116 of file shmem.c.

References Assert, CACHELINEALIGN, ShmemAlloc(), ShmemAllocUnlocked(), ShmemLock, ShmemSegHdr, ShmemVariableCache, and SpinLockInit.

Referenced by CreateSharedMemoryAndSemaphores().

{
    PGShmemHeader *shmhdr = ShmemSegHdr;
    char       *aligned;

    Assert(shmhdr != NULL);

    /*
     * Initialize the spinlock used by ShmemAlloc.  We must use
     * ShmemAllocUnlocked, since obviously ShmemAlloc can't be called yet.
     */
    ShmemLock = (slock_t *) ShmemAllocUnlocked(sizeof(slock_t));

    SpinLockInit(ShmemLock);

    /*
     * 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.
     */
    aligned = (char *)
        (CACHELINEALIGN((((char *) shmhdr) + shmhdr->freeoffset)));
    shmhdr->freeoffset = aligned - (char *) shmhdr;

    /* ShmemIndex can't be set up yet (need LWLocks first) */
    shmhdr->index = NULL;
    ShmemIndex = (HTAB *) NULL;

    /*
     * Initialize ShmemVariableCache for transaction manager. (This doesn't
     * really belong here, but not worth moving.)
     */
    ShmemVariableCache = (VariableCache)
        ShmemAlloc(sizeof(*ShmemVariableCache));
    memset(ShmemVariableCache, 0, sizeof(*ShmemVariableCache));
}

InitShmemIndex()

void InitShmemIndex

(

void

)

Definition at line 292 of file shmem.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

{
    HASHCTL     info;
    int         hash_flags;

    /*
     * 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);
    hash_flags = HASH_ELEM;

    ShmemIndex = ShmemInitHash("ShmemIndex",
                               SHMEM_INDEX_SIZE, SHMEM_INDEX_SIZE,
                               &info, hash_flags);
}

mul_size()

Size mul_size	(	Size	s1,
		Size	s2
	)

Definition at line 515 of file shmem.c.

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

Referenced by _bt_begin_parallel(), ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), begin_parallel_vacuum(), BTreeShmemSize(), BufferShmemSize(), CheckpointerShmemSize(), CreateSharedBackendStatus(), CreateSharedProcArray(), EstimateComboCIDStateSpace(), EstimatePendingSyncsSpace(), EstimateReindexStateSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecAggEstimate(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecInitParallelPlan(), ExecParallelRetrieveInstrumentation(), ExecParallelRetrieveJitInstrumentation(), ExecParallelSetupTupleQueues(), ExecSortEstimate(), hash_estimate_size(), InitializeParallelDSM(), InitPredicateLocks(), LWLockShmemSize(), PGSemaphoreShmemSize(), PMSignalShmemSize(), PostmasterMarkPIDForWorkerNotify(), PredicateLockShmemSize(), ProcArrayShmemSize(), ProcGlobalShmemSize(), ProcSignalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), shm_toc_estimate(), SInvalShmemSize(), SnapMgrShmemSize(), tuplesort_estimate_shared(), TwoPhaseShmemSize(), WalSndShmemSize(), and XLOGShmemSize().

{
    Size        result;

    if (s1 == 0 || s2 == 0)
        return 0;
    result = s1 * s2;
    /* We are assuming Size is an unsigned type here... */
    if (result / s2 != s1)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("requested shared memory size overflows size_t")));
    return result;
}

pg_get_shmem_allocations()

Datum pg_get_shmem_allocations

(

PG_FUNCTION_ARGS

)

Definition at line 532 of file shmem.c.

References ReturnSetInfo::allowedModes, CStringGetTextDatum, ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, elog, ereport, errcode(), errmsg(), ERROR, PGShmemHeader::freeoffset, get_call_result_type(), hash_seq_init(), hash_seq_search(), Int64GetDatum(), IsA, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemoryContextSwitchTo(), PG_GET_SHMEM_SIZES_COLS, ReturnSetInfo::returnMode, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, PGShmemHeader::totalsize, tuplestore_begin_heap(), tuplestore_donestoring, tuplestore_putvalues(), TYPEFUNC_COMPOSITE, values, and work_mem.

{
#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;
}

ShmemAddrIsValid()

bool ShmemAddrIsValid

(

const void *

addr

)

Definition at line 283 of file shmem.c.

References ShmemBase, and ShmemEnd.

Referenced by NextPredXact(), ReleasePredXact(), ShmemInitStruct(), SHMQueueDelete(), SHMQueueElemInit(), SHMQueueEmpty(), SHMQueueInit(), SHMQueueInsertAfter(), SHMQueueInsertBefore(), SHMQueueIsDetached(), SHMQueueNext(), and SHMQueuePrev().

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

ShmemAlloc()

void* ShmemAlloc

(

Size

size

)

Definition at line 161 of file shmem.c.

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

Referenced by CreateLWLocks(), InitPredicateLocks(), InitProcGlobal(), InitShmemAllocation(), PostmasterMarkPIDForWorkerNotify(), and ShmemInitStruct().

{
    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;
}

ShmemAllocNoError()

void* ShmemAllocNoError

(

Size

size

)

Definition at line 181 of file shmem.c.

References ShmemAllocRaw().

Referenced by ShmemInitHash().

{
    Size        allocated_size;

    return ShmemAllocRaw(size, &allocated_size);
}

ShmemAllocRaw()

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

static

Definition at line 195 of file shmem.c.

References Assert, CACHELINEALIGN, PGShmemHeader::freeoffset, ShmemBase, ShmemLock, SpinLockAcquire, and SpinLockRelease.

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

{
    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 = ShmemSegHdr->freeoffset;

    newFree = newStart + size;
    if (newFree <= ShmemSegHdr->totalsize)
    {
        newSpace = (void *) ((char *) ShmemBase + newStart);
        ShmemSegHdr->freeoffset = newFree;
    }
    else
        newSpace = NULL;

    SpinLockRelease(ShmemLock);

    /* note this assert is okay with newSpace == NULL */
    Assert(newSpace == (void *) CACHELINEALIGN(newSpace));

    return newSpace;
}

ShmemAllocUnlocked()

void* ShmemAllocUnlocked

(

Size

size

)

Definition at line 247 of file shmem.c.

References Assert, ereport, errcode(), errmsg(), ERROR, PGShmemHeader::freeoffset, MAXALIGN, ShmemBase, and PGShmemHeader::totalsize.

Referenced by InitShmemAllocation(), PGReserveSemaphores(), and SpinlockSemaInit().

{
    Size        newStart;
    Size        newFree;
    void       *newSpace;

    /*
     * Ensure allocated space is adequately aligned.
     */
    size = MAXALIGN(size);

    Assert(ShmemSegHdr != NULL);

    newStart = ShmemSegHdr->freeoffset;

    newFree = newStart + size;
    if (newFree > ShmemSegHdr->totalsize)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of shared memory (%zu bytes requested)",
                        size)));
    ShmemSegHdr->freeoffset = newFree;

    newSpace = (void *) ((char *) ShmemBase + newStart);

    Assert(newSpace == (void *) MAXALIGN(newSpace));

    return newSpace;
}

ShmemInitHash()

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

Definition at line 337 of file shmem.c.

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, ShmemAllocNoError(), and ShmemInitStruct().

Referenced by InitBufTable(), InitLocks(), InitPredicateLocks(), InitShmemIndex(), and pgss_shmem_startup().

{
    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);
}

ShmemInitStruct()

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

Definition at line 392 of file shmem.c.

References ShmemIndexEnt::allocated_size, Assert, CACHELINEALIGN, ereport, errcode(), errmsg(), ERROR, HASH_ENTER_NULL, HASH_REMOVE, hash_search(), PGShmemHeader::index, IsUnderPostmaster, ShmemIndexEnt::location, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ShmemAddrIsValid(), ShmemAlloc(), ShmemAllocRaw(), ShmemSegHdr, and ShmemIndexEnt::size.

Referenced by ApplyLauncherShmemInit(), apw_init_shmem(), AsyncShmemInit(), AutoVacuumShmemInit(), AuxiliaryPidGetProc(), BackgroundWorkerShmemInit(), BTreeShmemInit(), CheckpointerShmemInit(), CommitTsShmemInit(), CreateSharedBackendStatus(), CreateSharedInvalidationState(), CreateSharedProcArray(), InitBufferPool(), InitLocks(), InitPredicateLocks(), InitProcGlobal(), MultiXactShmemInit(), pgss_shmem_startup(), PMSignalShmemInit(), ProcSignalShmemInit(), ReplicationOriginShmemInit(), ReplicationSlotsShmemInit(), SerialInit(), ShmemInitHash(), SimpleLruInit(), SnapMgrInit(), StrategyInitialize(), SyncScanShmemInit(), TwoPhaseShmemInit(), WalRcvShmemInit(), WalSndShmemInit(), and XLOGShmemInit().

{
    ShmemIndexEnt *result;
    void       *structPtr;

    LWLockAcquire(ShmemIndexLock, LW_EXCLUSIVE);

    if (!ShmemIndex)
    {
        PGShmemHeader *shmemseghdr = ShmemSegHdr;

        /* Must be trying to create/attach to ShmemIndex itself */
        Assert(strcmp(name, "ShmemIndex") == 0);

        if (IsUnderPostmaster)
        {
            /* Must be initializing a (non-standalone) backend */
            Assert(shmemseghdr->index != NULL);
            structPtr = shmemseghdr->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(shmemseghdr->index == NULL);
            structPtr = ShmemAlloc(size);
            shmemseghdr->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;
}

Variable Documentation

ShmemBase

void* ShmemBase

static

Definition at line 84 of file shmem.c.

Referenced by InitShmemAccess(), ShmemAddrIsValid(), ShmemAllocRaw(), and ShmemAllocUnlocked().

ShmemEnd

void* ShmemEnd

static

Definition at line 86 of file shmem.c.

Referenced by InitShmemAccess(), and ShmemAddrIsValid().

ShmemIndex

HTAB* ShmemIndex = NULL

static

Definition at line 91 of file shmem.c.

ShmemLock

slock_t* ShmemLock

Definition at line 88 of file shmem.c.

Referenced by InitShmemAllocation(), LWLockNewTrancheId(), PostmasterMarkPIDForWorkerNotify(), and ShmemAllocRaw().

ShmemSegHdr

PGShmemHeader* ShmemSegHdr

static

Definition at line 82 of file shmem.c.

Referenced by InitShmemAllocation(), and ShmemInitStruct().