/*
* Allocate shmem space for LWLocks and initialize the locks.
*/
void
CreateLWLocks(void)
{
int numLocks = NumLWLocks();
uint32 spaceLocks = LWLockShmemSize();
LWLock *lock;
int id;
/* Allocate space */
LWLockArray = (LWLock *) ShmemAlloc(spaceLocks);
/*
* Initialize all LWLocks to "unlocked" state
*/
for (id = 0, lock = LWLockArray; id < numLocks; id++, lock++)
{
SpinLockInit(&lock->mutex);
lock->releaseOK = true;
lock->exclusive = 0;
lock->shared = 0;
lock->head = NULL;
lock->tail = NULL;
}
/*
* Initialize the dynamic-allocation counter at the end of the array
*/
LWLockCounter = (int *) lock;
LWLockCounter[0] = (int) NumFixedLWLocks;
LWLockCounter[1] = numLocks;
}
/*
* Allocate shmem space for the main LWLock array and initialize it. We also
* register the main tranch here.
*/
void
CreateLWLocks(void)
{
if (!IsUnderPostmaster)
{
int numLocks = NumLWLocks();
Size spaceLocks = LWLockShmemSize();
LWLockPadded *lock;
int *LWLockCounter;
char *ptr;
int id;
/* Allocate space */
ptr = (char *) ShmemAlloc(spaceLocks);
/* Leave room for dynamic allocation of locks and tranches */
ptr += 3 * sizeof(int);
/* Ensure desired alignment of LWLock array */
ptr += LWLOCK_PADDED_SIZE - ((uintptr_t) ptr) % LWLOCK_PADDED_SIZE;
MainLWLockArray = (LWLockPadded *) ptr;
/* Initialize all LWLocks in main array */
for (id = 0, lock = MainLWLockArray; id < numLocks; id++, lock++)
LWLockInitialize(&lock->lock, 0);
/*
* Initialize the dynamic-allocation counters, which are stored just
* before the first LWLock. LWLockCounter[0] is the allocation
* counter for lwlocks, LWLockCounter[1] is the maximum number that
* can be allocated from the main array, and LWLockCounter[2] is the
* allocation counter for tranches.
*/
LWLockCounter = (int *) ((char *) MainLWLockArray - 3 * sizeof(int));
LWLockCounter[0] = NUM_FIXED_LWLOCKS;
LWLockCounter[1] = numLocks;
LWLockCounter[2] = 1; /* 0 is the main array */
}
if (LWLockTrancheArray == NULL)
{
LWLockTranchesAllocated = 16;
LWLockTrancheArray = (LWLockTranche **)
MemoryContextAlloc(TopMemoryContext,
LWLockTranchesAllocated * sizeof(LWLockTranche *));
}
MainLWLockTranche.name = "main";
MainLWLockTranche.array_base = MainLWLockArray;
MainLWLockTranche.array_stride = sizeof(LWLockPadded);
LWLockRegisterTranche(0, &MainLWLockTranche);
}
/*
* Allocate shmem space for LWLocks and initialize the locks.
*/
void
CreateLWLocks(void)
{
int numLocks = NumLWLocks();
Size spaceLocks = LWLockShmemSize();
LWLockPadded *lock;
int *LWLockCounter;
char *ptr;
int id;
/* Allocate space */
ptr = (char *) ShmemAlloc(spaceLocks);
/* Leave room for dynamic allocation counter */
ptr += 2 * sizeof(int);
/* Ensure desired alignment of LWLock array */
ptr += LWLOCK_PADDED_SIZE - ((unsigned long) ptr) % LWLOCK_PADDED_SIZE;
LWLockArray = (LWLockPadded *) ptr;
/*
* Initialize all LWLocks to "unlocked" state
*/
for (id = 0, lock = LWLockArray; id < numLocks; id++, lock++)
{
SpinLockInit(&lock->lock.mutex);
lock->lock.releaseOK = true;
lock->lock.exclusive = 0;
lock->lock.shared = 0;
lock->lock.head = NULL;
lock->lock.tail = NULL;
}
/*
* Initialize the dynamic-allocation counter, which is stored just before
* the first LWLock.
*/
LWLockCounter = (int *) ((char *) LWLockArray - 2 * sizeof(int));
LWLockCounter[0] = (int) NumFixedLWLocks;
LWLockCounter[1] = numLocks;
}
/*
* Allocate shmem space for LWLocks and initialize the locks.
*/
void
CreateLWLocks(void)
{
int numLocks = NumLWLocks();
Size spaceLocks = LWLockShmemSize();
LWLockPadded *lock;
#if LWLOCK_PART_SIZE > 1
LWLockPart *part;
#endif
int *LWLockCounter;
char *ptr;
int id;
/* Ensure that we didn't mess up the computation of LWLOCK_PART_LOCKS */
Assert(sizeof(LWLockPart) == LWLOCK_PART_SIZE);
/* Allocate space */
ptr = (char *) ShmemAlloc(spaceLocks);
/* Leave room for dynamic allocation counter */
ptr += 2 * sizeof(int);
/* Ensure desired alignment of LWLock array */
ptr += LWLOCK_PADDED_SIZE - ((uintptr_t) ptr) % LWLOCK_PADDED_SIZE;
LWLockArray = (LWLockPadded *) ptr;
ptr += sizeof(LWLockPadded) * numLocks;
#if LWLOCK_LOCK_PARTS > 1
/* Ensure desired alignment of LWLockPart array */
ptr += LWLOCK_PART_SIZE - ((uintptr_t) ptr) % LWLOCK_PART_SIZE;
LWLockPartArray = (LWLockPart *) ptr;
ptr += sizeof(LWLockPart) * LWLOCK_PARTS(numLocks);
#endif
/*
* Initialize all LWLocks to "unlocked" state
*/
for (id = 0, lock = LWLockArray; id < numLocks; id++, lock++)
{
SpinLockInit(&lock->lock.mutex);
lock->lock.releaseOK = true;
lock->lock.exclusive = 0;
#if LWLOCK_LOCK_PARTS == 1
lock->lock.shared = 0;
#endif
lock->lock.head = NULL;
lock->lock.tail = NULL;
}
#if LWLOCK_LOCK_PARTS > 1
for(id = 0, part = LWLockPartArray; id < LWLOCK_PARTS(numLocks); id++, part++) {
#ifndef LWLOCK_PART_SHARED_OPS_ATOMIC
SpinLockInit(&part->mutex);
#endif
memset((char *) part->shared, 0, sizeof(int) * LWLOCK_PART_LOCKS);
}
#endif
/*
* Initialize the dynamic-allocation counter, which is stored just before
* the first LWLock.
*/
LWLockCounter = (int *) ((char *) LWLockArray - 2 * sizeof(int));
LWLockCounter[0] = (int) NumFixedLWLocks;
LWLockCounter[1] = numLocks;
}
/*
* CreateSharedMemoryAndSemaphores
* Creates and initializes shared memory and semaphores.
*
* This is called by the postmaster or by a standalone backend.
* It is also called by a backend forked from the postmaster in the
* EXEC_BACKEND case. In the latter case, the shared memory segment
* already exists and has been physically attached to, but we have to
* initialize pointers in local memory that reference the shared structures,
* because we didn't inherit the correct pointer values from the postmaster
* as we do in the fork() scenario. The easiest way to do that is to run
* through the same code as before. (Note that the called routines mostly
* check IsUnderPostmaster, rather than EXEC_BACKEND, to detect this case.
* This is a bit code-wasteful and could be cleaned up.)
*
* If "makePrivate" is true then we only need private memory, not shared
* memory. This is true for a standalone backend, false for a postmaster.
*/
void
CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
{
if (!IsUnderPostmaster)
{
PGShmemHeader *seghdr;
Size size;
int numSemas;
/*
* Size of the Postgres shared-memory block is estimated via
* moderately-accurate estimates for the big hogs, plus 100K for the
* stuff that's too small to bother with estimating.
*
* We take some care during this phase to ensure that the total size
* request doesn't overflow size_t. If this gets through, we don't
* need to be so careful during the actual allocation phase.
*/
size = 100000;
size = add_size(size, SpinlockSemaSize());
size = add_size(size, hash_estimate_size(SHMEM_INDEX_SIZE,
sizeof(ShmemIndexEnt)));
size = add_size(size, BufferShmemSize());
size = add_size(size, LockShmemSize());
size = add_size(size, PredicateLockShmemSize());
size = add_size(size, ProcGlobalShmemSize());
size = add_size(size, XLOGShmemSize());
size = add_size(size, CLOGShmemSize());
size = add_size(size, SUBTRANSShmemSize());
size = add_size(size, TwoPhaseShmemSize());
size = add_size(size, BackgroundWorkerShmemSize());
size = add_size(size, MultiXactShmemSize());
size = add_size(size, LWLockShmemSize());
size = add_size(size, ProcArrayShmemSize());
size = add_size(size, BackendStatusShmemSize());
size = add_size(size, SInvalShmemSize());
size = add_size(size, PMSignalShmemSize());
size = add_size(size, ProcSignalShmemSize());
size = add_size(size, CheckpointerShmemSize());
size = add_size(size, AutoVacuumShmemSize());
size = add_size(size, ReplicationSlotsShmemSize());
size = add_size(size, WalSndShmemSize());
size = add_size(size, WalRcvShmemSize());
size = add_size(size, BTreeShmemSize());
size = add_size(size, SyncScanShmemSize());
size = add_size(size, AsyncShmemSize());
#ifdef EXEC_BACKEND
size = add_size(size, ShmemBackendArraySize());
#endif
/* freeze the addin request size and include it */
addin_request_allowed = false;
size = add_size(size, total_addin_request);
/* might as well round it off to a multiple of a typical page size */
size = add_size(size, 8192 - (size % 8192));
elog(DEBUG3, "invoking IpcMemoryCreate(size=%zu)", size);
/*
* Create the shmem segment
*/
seghdr = PGSharedMemoryCreate(size, makePrivate, port);
InitShmemAccess(seghdr);
/*
* Create semaphores
*/
numSemas = ProcGlobalSemas();
numSemas += SpinlockSemas();
PGReserveSemaphores(numSemas, port);
}
else
{
/*
* We are reattaching to an existing shared memory segment. This
* should only be reached in the EXEC_BACKEND case, and even then only
* with makePrivate == false.
*/
#ifdef EXEC_BACKEND
Assert(!makePrivate);
#else
elog(PANIC, "should be attached to shared memory already");
#endif
}
/*
* Set up shared memory allocation mechanism
*/
if (!IsUnderPostmaster)
InitShmemAllocation();
/*
* Now initialize LWLocks, which do shared memory allocation and are
* needed for InitShmemIndex.
*/
CreateLWLocks();
/*
* Set up shmem.c index hashtable
*/
InitShmemIndex();
/*
* Set up xlog, clog, and buffers
*/
XLOGShmemInit();
CLOGShmemInit();
SUBTRANSShmemInit();
MultiXactShmemInit();
InitBufferPool();
/*
* Set up lock manager
*/
InitLocks();
/*
* Set up predicate lock manager
*/
InitPredicateLocks();
/*
* Set up process table
*/
if (!IsUnderPostmaster)
InitProcGlobal();
CreateSharedProcArray();
CreateSharedBackendStatus();
TwoPhaseShmemInit();
BackgroundWorkerShmemInit();
/*
* Set up shared-inval messaging
*/
CreateSharedInvalidationState();
/*
* Set up interprocess signaling mechanisms
*/
PMSignalShmemInit();
ProcSignalShmemInit();
CheckpointerShmemInit();
AutoVacuumShmemInit();
ReplicationSlotsShmemInit();
WalSndShmemInit();
WalRcvShmemInit();
/*
* Set up other modules that need some shared memory space
*/
BTreeShmemInit();
SyncScanShmemInit();
AsyncShmemInit();
#ifdef EXEC_BACKEND
/*
* Alloc the win32 shared backend array
*/
if (!IsUnderPostmaster)
ShmemBackendArrayAllocation();
#endif
/* Initialize dynamic shared memory facilities. */
if (!IsUnderPostmaster)
dsm_postmaster_startup();
/*
* Now give loadable modules a chance to set up their shmem allocations
*/
if (shmem_startup_hook)
shmem_startup_hook();
}
/*
* CreateSharedMemoryAndSemaphores
* Creates and initializes shared memory and semaphores.
*
* This is called by the postmaster or by a standalone backend.
* It is also called by a backend forked from the postmaster in the
* EXEC_BACKEND case. In the latter case, the shared memory segment
* already exists and has been physically attached to, but we have to
* initialize pointers in local memory that reference the shared structures,
* because we didn't inherit the correct pointer values from the postmaster
* as we do in the fork() scenario. The easiest way to do that is to run
* through the same code as before. (Note that the called routines mostly
* check IsUnderPostmaster, rather than EXEC_BACKEND, to detect this case.
* This is a bit code-wasteful and could be cleaned up.)
*
* If "makePrivate" is true then we only need private memory, not shared
* memory. This is true for a standalone backend, false for a postmaster.
*/
void
CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
{
if (!IsUnderPostmaster)
{
PGShmemHeader *seghdr;
Size size;
int numSemas;
/*
* Size of the Postgres shared-memory block is estimated via
* moderately-accurate estimates for the big hogs, plus 100K for the
* stuff that's too small to bother with estimating.
*
* We take some care during this phase to ensure that the total size
* request doesn't overflow size_t. If this gets through, we don't
* need to be so careful during the actual allocation phase.
*/
size = 150000;
size = add_size(size, hash_estimate_size(SHMEM_INDEX_SIZE,
sizeof(ShmemIndexEnt)));
size = add_size(size, BufferShmemSize());
size = add_size(size, LockShmemSize());
size = add_size(size, workfile_mgr_shmem_size());
if (Gp_role == GP_ROLE_DISPATCH)
{
size = add_size(size, AppendOnlyWriterShmemSize());
if(ResourceScheduler)
{
size = add_size(size, ResSchedulerShmemSize());
size = add_size(size, ResPortalIncrementShmemSize());
}
}
size = add_size(size, ProcGlobalShmemSize());
size = add_size(size, XLOGShmemSize());
size = add_size(size, DistributedLog_ShmemSize());
size = add_size(size, CLOGShmemSize());
size = add_size(size, ChangeTrackingShmemSize());
size = add_size(size, SUBTRANSShmemSize());
size = add_size(size, TwoPhaseShmemSize());
size = add_size(size, MultiXactShmemSize());
size = add_size(size, LWLockShmemSize());
size = add_size(size, ProcArrayShmemSize());
size = add_size(size, BackendStatusShmemSize());
size = add_size(size, SharedSnapshotShmemSize());
size = add_size(size, SInvalShmemSize());
size = add_size(size, PMSignalShmemSize());
size = add_size(size, ProcSignalShmemSize());
size = add_size(size, primaryMirrorModeShmemSize());
size = add_size(size, FreeSpaceShmemSize());
//size = add_size(size, AutoVacuumShmemSize());
size = add_size(size, FtsShmemSize());
size = add_size(size, tmShmemSize());
size = add_size(size, SeqServerShmemSize());
size = add_size(size, PersistentFileSysObj_ShmemSize());
size = add_size(size, PersistentFilespace_ShmemSize());
size = add_size(size, PersistentTablespace_ShmemSize());
size = add_size(size, PersistentDatabase_ShmemSize());
size = add_size(size, PersistentRelation_ShmemSize());
size = add_size(size, Pass2Recovery_ShmemSize());
/*Add shared memory for PT verification checks*/
if (Gp_role == GP_ROLE_DISPATCH && debug_persistent_ptcat_verification)
{
size = add_size(size, Persistent_PostDTMRecv_ShmemSize());
}
if (GPAreFileReplicationStructuresRequired()) {
size = add_size(size, FileRep_SubProcShmemSize());
size = add_size(size, FileRep_ShmemSize());
size = add_size(size, FileRepAck_ShmemSize());
size = add_size(size, FileRepAckPrimary_ShmemSize());
size = add_size(size, FileRepResync_ShmemSize());
size = add_size(size, FileRepIpc_ShmemSize());
size = add_size(size, FileRepLog_ShmemSize());
size = add_size(size, FileRepStats_ShmemSize());
}
#ifdef FAULT_INJECTOR
size = add_size(size, FaultInjector_ShmemSize());
#endif
#ifdef EXEC_BACKEND
size = add_size(size, ShmemBackendArraySize());
#endif
#ifdef USE_TEST_UTILS
if (gp_simex_init)
{
// initialize SimEx
simex_init();
size = add_size(size, SyncBitVector_ShmemSize(simex_get_subclass_count()));
}
#endif
/* This elog happens before we know the name of the log file we are supposed to use */
elog(DEBUG1, "Size not including the buffer pool %lu",
(unsigned long) size);
size = add_size(size, BgWriterShmemSize());
size = add_size(size, AutoVacuumShmemSize());
size = add_size(size, BTreeShmemSize());
size = add_size(size, SyncScanShmemSize());
size = add_size(size, CheckpointShmemSize());
size = add_size(size, WalSndShmemSize());
size = add_size(size, WalRcvShmemSize());
/* freeze the addin request size and include it */
addin_request_allowed = false;
size = add_size(size, total_addin_request);
/* might as well round it off to a multiple of a typical page size */
size = add_size(size, BLCKSZ - (size % BLCKSZ));
/* Consider the size of the SessionState array */
size = add_size(size, SessionState_ShmemSize());
/*
* Create the shmem segment
*/
seghdr = PGSharedMemoryCreate(size, makePrivate, port);
InitShmemAccess(seghdr);
/*
* Create semaphores
*/
numSemas = ProcGlobalSemas();
numSemas += SpinlockSemas();
if (GPAreFileReplicationStructuresRequired())
{
numSemas += FileRepSemas();
}
elog(DEBUG3,"reserving %d semaphores",numSemas);
PGReserveSemaphores(numSemas, port);
}
else
{
/*
* We are reattaching to an existing shared memory segment. This
* should only be reached in the EXEC_BACKEND case, and even then only
* with makePrivate == false.
*/
#ifdef EXEC_BACKEND
Assert(!makePrivate);
#else
elog(PANIC, "should be attached to shared memory already");
#endif
}
/*
* Set up shared memory allocation mechanism
*/
if (!IsUnderPostmaster)
InitShmemAllocation();
/*
* Now initialize LWLocks, which do shared memory allocation and are
* needed for InitShmemIndex.
*/
if (!IsUnderPostmaster)
CreateLWLocks();
/*
* Set up shmem.c index hashtable
*/
InitShmemIndex();
primaryMirrorModeShmemInit();
/*
* Set up xlog, clog, and buffers
*/
XLOGShmemInit();
CLOGShmemInit();
ChangeTrackingShmemInit();
DistributedLog_ShmemInit();
SUBTRANSShmemInit();
TwoPhaseShmemInit();
MultiXactShmemInit();
FtsShmemInit();
tmShmemInit();
InitBufferPool();
/*
* Set up lock manager
*/
InitLocks();
/*
* Set up append only writer
*/
if (Gp_role == GP_ROLE_DISPATCH)
InitAppendOnlyWriter();
PersistentFileSysObj_ShmemInit();
PersistentFilespace_ShmemInit();
PersistentTablespace_ShmemInit();
PersistentDatabase_ShmemInit();
PersistentRelation_ShmemInit();
Pass2Recovery_ShmemInit();
if (Gp_role == GP_ROLE_DISPATCH && debug_persistent_ptcat_verification)
Persistent_PostDTMRecv_ShmemInit();
/*
* Set up resource schedular
*/
if (Gp_role == GP_ROLE_DISPATCH && ResourceScheduler)
{
InitResScheduler();
InitResPortalIncrementHash();
}
if (!IsUnderPostmaster)
{
/* Set up process table */
InitProcGlobal(PostmasterGetMppLocalProcessCounter());
}
/* Initialize SessionState shared memory array */
SessionState_ShmemInit();
/* Initialize vmem protection */
GPMemoryProtect_ShmemInit();
CreateSharedProcArray();
CreateSharedBackendStatus();
/*
* Set up Shared snapshot slots
*
* TODO: only need to do this if we aren't the QD. for now we are just
* doing it all the time and wasting shemem on the QD. This is
* because this happens at postmaster startup time when we don't
* know who we are.
*/
CreateSharedSnapshotArray();
/*
* Set up shared-inval messaging
*/
CreateSharedInvalidationState();
/*
* Set up free-space map
*/
InitFreeSpaceMap();
/*
* Set up interprocess signaling mechanisms
*/
PMSignalShmemInit();
ProcSignalShmemInit();
BgWriterShmemInit();
CheckpointShmemInit();
WalSndShmemInit();
WalRcvShmemInit();
//AutoVacuumShmemInit();
SeqServerShmemInit();
if (GPAreFileReplicationStructuresRequired()) {
FileRep_SubProcShmemInit();
FileRep_ShmemInit();
FileRepAck_ShmemInit();
FileRepAckPrimary_ShmemInit();
FileRepResync_ShmemInit();
FileRepIpc_ShmemInit();
FileRepLog_ShmemInit();
FileRepStats_ShmemInit();
}
#ifdef FAULT_INJECTOR
FaultInjector_ShmemInit();
#endif
#ifdef USE_TEST_UTILS
if (gp_simex_init)
{
// initialize shmem segment for SimEx
simex_set_sync_bitvector_container(
SyncBitVector_ShmemInit("SimEx bit vector container", simex_get_subclass_count()));
}
#endif /* USE_TEST_UTILS */
/*
* Set up other modules that need some shared memory space
*/
BTreeShmemInit();
SyncScanShmemInit();
workfile_mgr_cache_init();
#ifdef EXEC_BACKEND
/*
* Alloc the win32 shared backend array
*/
if (!IsUnderPostmaster)
ShmemBackendArrayAllocation();
#endif
BackoffStateInit();
if (gp_resqueue_memory_policy != RESQUEUE_MEMORY_POLICY_NONE)
{
SPI_InitMemoryReservation();
}
/*
* Now give loadable modules a chance to set up their shmem allocations
*/
if (shmem_startup_hook)
shmem_startup_hook();
}
