PostgreSQL数据库共享内存——开拓者CreateSharedMemoryAndSemaphores函数

水深无声 2022-10-19 00:55 367阅读 0赞

函数CreateSharedMemoryAndSemaphores负责对共享内存和信号量进行初始化，由Postmaster或其子进程调用。Postmaster调用该函数时会初始化共享内存和信号量，其他进程（如Postgres）调用时不进行初始化工作，仅仅获得已创建的共享变量指针和信号量指针。在初始化过程中，系统为共享内存创建了一个名为shmem index的Hash索引。当试图为一个模块分配共享内存时，会调用函数ShmemInitStruct（该函数首先根据模块名在Hash索引中查找，如果找不到则再调用ShmemAlloc函数在内存中为其分配一块区域）。函数CreateSharedMemoryAndSemaphores初始化流程如下：

*  计算共享内存总共需要的大小
 *  分配共享内存空间和初始化共享内存头指针、注册清理函数
 *  创建信号量
 *  构建共享内存Hash索引
 *  初始化各个模块，调用ShmemInitStruct函数从已分配的共享内存分配空间

## 计算共享内存总共需要的大小 ##

<table> 
 <thead> 
  <tr> 
   <th>共享内存使用项</th> 
   <th>计算共享内存大小函数</th> 
   <th>数量</th> 
   <th>大小</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>基本</td> 
   <td></td> 
   <td></td> 
   <td>100000</td> 
  </tr> 
  <tr> 
   <td>InitProcGlobal信号量</td> 
   <td>ProcGlobalSemas</td> 
   <td>MaxBackends + NUM_AUXILIARY_PROCS</td> 
   <td>如果定义了USE_NAMED_POSIX_SEMAPHORES，返回0；否则<code>(MaxBackends + 4)*sizeof(PGSemaphoreData)</code></td> 
  </tr> 
  <tr> 
   <td>spinlocks信号量</td> 
   <td>SpinlockSemas</td> 
   <td>NUM_EMULATION_SEMAPHORES</td> 
   <td><code>(128 + 64)*sizeof(PGSemaphore)</code></td> 
  </tr> 
  <tr> 
   <td>哈希表</td> 
   <td>hash_estimate_size(SHMEM_INDEX_SIZE,sizeof(ShmemIndexEnt))</td> 
   <td>见注1+2+3+4</td> 
   <td>见表下注释</td> 
  </tr> 
  <tr> 
   <td>buffer pool</td> 
   <td>BufferShmemSize</td> 
   <td><code>NBuffers*sizeof(BufferDescPadded) + PG_CACHE_LINE_SIZE + NBuffers*BLCKSZ + StrategyShmemSize() + NBuffers*sizeof(LWLockMinimallyPadded) + NBuffers*sizeof(CkptSortItem)</code></td> 
   <td><code>NBuffers*sizeof(BufferDescPadded) + 128 + NBuffers*BLCKSZ + BufTableShmemSize(NBuffers + NUM_BUFFER_PARTITIONS) + MAXALIGN(sizeof(BufferStrategyControl)) + NBuffers*sizeof(LWLockMinimallyPadded) + NBuffers*sizeof(CkptSortItem)</code></td> 
  </tr> 
  <tr> 
   <td>lock tables</td> 
   <td>LockShmemSize</td> 
   <td>hash_estimate_size(max_table_size, sizeof(LOCK)) + hash_estimate_size(max_table_size*2, sizeof(PROCLOCK)) + size/10</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>predicate lock table</td> 
   <td>PredicateLockShmemSize</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>InitProcGlobal</td> 
   <td>ProcGlobalShmemSize</td> 
   <td>见注5-12</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>XLOG shared memory</td> 
   <td>XLOGShmemSize</td> 
   <td><code>sizeof(XLogCtlData) + sizeof(WALInsertLockPadded)*(NUM_XLOGINSERT_LOCKS + 1) + sizeof(XLogRecPtr)*XLOGbuffers + XLOG_BLCKSZ + XLOG_BLCKSZ*XLOGbuffers</code></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>CLOG shared memory</td> 
   <td>CLOGShmemSize</td> 
   <td>SimpleLruShmemSize(CLOGShmemBuffers(), CLOG_LSNS_PER_PAGE)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>CommitTs shared memory</td> 
   <td>CommitTsShmemSize</td> 
   <td>SimpleLruShmemSize(CommitTsShmemBuffers(), 0) + sizeof(CommitTimestampShared)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>SUBTRANS shared memory</td> 
   <td>SUBTRANSShmemSize</td> 
   <td>SimpleLruShmemSize(NUM_SUBTRANS_BUFFERS, 0)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>TwoPhase shared memory</td> 
   <td>TwoPhaseShmemSize</td> 
   <td><code>offsetof(TwoPhaseStateData, prepXacts) + max_prepared_xacts*sizeof(GlobalTransaction) + MAXALIGN(size) + max_prepared_xacts*sizeof(GlobalTransactionData)</code></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>BGworker shared memory</td> 
   <td>BackgroundWorkerShmemSize</td> 
   <td>offsetof(BackgroundWorkerArray, slot) + max_worker_processes*sizeof(BackgroundWorkerSlot)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>MultiXact shared memory</td> 
   <td>MultiXactShmemSize</td> 
   <td>SHARED_MULTIXACT_STATE_SIZE+SimpleLruShmemSize(NUM_MXACTOFFSET_BUFFERS, 0)+SimpleLruShmemSize(NUM_MXACTMEMBER_BUFFERS, 0)</td> 
   <td><code>offsetof(MultiXactStateData, perBackendXactIds)+sizeof(MultiXactId)+sizeof(MultiXactId) * 2*MaxOldestSlot + SimpleLruShmemSize(NUM_MXACTOFFSET_BUFFERS, 0)+SimpleLruShmemSize(NUM_MXACTMEMBER_BUFFERS, 0)</code></td> 
  </tr> 
  <tr> 
   <td>LWLocks and named tranches</td> 
   <td>LWLockShmemSize</td> 
   <td><code>(NUM_FIXED_LWLOCKS+NumLWLocksByNamedTranches())*sizeof(LWLockPadded)+sizeof(int) + LWLOCK_PADDED_SIZE+NamedLWLockTrancheRequests*sizeof(NamedLWLockTranche)+NamedLWLockTrancheRequests* (strlen(NamedLWLockTrancheRequestArray[i].tranche_name) + 1)</code></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>CreateSharedProcArray</td> 
   <td>ProcArrayShmemSize</td> 
   <td><code>offsetof(ProcArrayStruct, pgprocnos)+sizeof(int)*PROCARRAY_MAXPROCS+(sizeof(TransactionId) +sizeof(bool))*TOTAL_MAX_CACHED_SUBXIDS</code></td> 
   <td><code>offsetof(ProcArrayStruct, pgprocnos)+sizeof(int)*(MaxBackends + max_prepared_xacts)+(sizeof(TransactionId) +sizeof(bool))* ((PGPROC_MAX_CACHED_SUBXIDS + 1) * PROCARRAY_MAXPROCS)</code></td> 
  </tr> 
  <tr> 
   <td>CreateSharedBackendStatus</td> 
   <td>BackendStatusShmemSize</td> 
   <td><code>sizeof(PgBackendStatus)*NumBackendStatSlots+NAMEDATALEN*NumBackendStatSlots*2+pgstat_track_activity_query_size*NumBackendStatSlots+sizeof(PgBackendSSLStatus)*NumBackendStatSlots*2</code></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>SInval</td> 
   <td>SInvalShmemSize</td> 
   <td>offsetof(SISeg, procState)+sizeof(ProcState)*MaxBackends</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>pmsignal</td> 
   <td>PMSignalShmemSize</td> 
   <td>offsetof(PMSignalData, PMChildFlags)+MaxLivePostmasterChildren()*sizeof(sig_atomic_t)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>procsignal</td> 
   <td>ProcSignalShmemSize</td> 
   <td>NumProcSignalSlots * sizeof(ProcSignalSlot)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>Checkpointer</td> 
   <td>CheckpointerShmemSize</td> 
   <td>offsetof(CheckpointerShmemStruct, requests)+NBuffers*sizeof(CheckpointerRequest)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>autovacuum</td> 
   <td>AutoVacuumShmemSize</td> 
   <td>MAXALIGN(sizeof(AutoVacuumShmemStruct))+autovacuum_max_workers*sizeof(WorkerInfoData)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>Replication</td> 
   <td>ReplicationSlotsShmemSize</td> 
   <td>offsetof(ReplicationSlotCtlData, replication_slots)+max_replication_slots*sizeof(ReplicationSlot)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>ReplicationOriginShmemSize</td> 
   <td>offsetof(ReplicationStateCtl, states)+max_replication_slots*sizeof(ReplicationState)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>WalSnd</td> 
   <td>WalSndShmemSize</td> 
   <td>offsetof(WalSndCtlData, walsnds)+max_wal_senders*sizeof(WalSnd)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>WalRcv</td> 
   <td>WalRcvShmemSize</td> 
   <td>sizeof(WalRcvData)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>replication launcher</td> 
   <td>ApplyLauncherShmemSize</td> 
   <td>MAXALIGN(sizeof(LogicalRepCtxStruct)) +max_logical_replication_workers*sizeof(LogicalRepWorker)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>Snap</td> 
   <td>SnapMgrShmemSize</td> 
   <td>offsetof(OldSnapshotControlData, xid_by_minute)+sizeof(TransactionId)*OLD_SNAPSHOT_TIME_MAP_ENTRIES)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>BTree</td> 
   <td>BTreeShmemSize</td> 
   <td>offsetof(BTVacInfo, vacuums)+MaxBackends* sizeof(BTOneVacInfo)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>SyncScan</td> 
   <td>SyncScanShmemSize</td> 
   <td>SizeOfScanLocations(SYNC_SCAN_NELEM)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>Async</td> 
   <td>AsyncShmemSize</td> 
   <td>(MaxBackends + 1)* sizeof(QueueBackendStatus)+offsetof(AsyncQueueControl, backend)+SimpleLruShmemSize(NUM_ASYNC_BUFFERS, 0)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>Backend</td> 
   <td>ShmemBackendArraySize</td> 
   <td>MaxLivePostmasterChildren()*sizeof(Backend)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>total_addin_request</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>round off</td> 
   <td></td> 
   <td></td> 
   <td>size + 8192 - (size % 8192)</td> 
  </tr> 
 </tbody> 
</table>

注：

1.  `MAXALIGN(sizeof(HASHHDR))`
2.  `nDirEntries*sizeof(HASHSEGMENT)`
3.  `nSegments*MAXALIGN(DEF_SEGSIZE * sizeof(HASHBUCKET))`–>`next_pow2_long((nBuckets - 1)/256+1)*MAXALIGN(DEF_SEGSIZE * sizeof(HASHBUCKET))`–>`next_pow2_long((next_pow2_long((SHMEM_INDEX_SIZE - 1)+1) - 1)/256+1)*MAXALIGN(DEF_SEGSIZE * sizeof(HASHBUCKET))`
4.  `nElementAllocs*elementAllocCnt*elementSize`–>`((num_entries - 1) / elementAllocCnt + 1)*choose_nelem_alloc(entrysize)*(MAXALIGN(sizeof(HASHELEMENT)) + MAXALIGN(entrysize))`–>`((SHMEM_INDEX_SIZE - 1) / choose_nelem_alloc(sizeof(ShmemIndexEnt)) + 1)*choose_nelem_alloc(sizeof(ShmemIndexEnt))*(MAXALIGN(sizeof(HASHELEMENT)) + MAXALIGN(sizeof(ShmemIndexEnt)))`
5.  `hash_estimate_size(max_table_size,sizeof(PREDICATELOCKTARGET)`–>`hash_estimate_size(NPREDICATELOCKTARGETENTS(), sizeof(PREDICATELOCKTARGET)`
6.  `hash_estimate_size(max_table_size*2,sizeof(PREDICATELOCK))`
7.  size+size / 10
8.  `PredXactListDataSize+((MaxBackends + max_prepared_xacts)*10)*PredXactListElementDataSize`
9.  `hash_estimate_size((MaxBackends + max_prepared_xacts)*10,sizeof(SERIALIZABLEXID))`
10. sizeof(SHM\_QUEUE)
11. sizeof(OldSerXidControlData)
12. SimpleLruShmemSize(NUM\_OLDSERXID\_BUFFERS, 0)

## 分配共享内存空间和创建信号量 ##

### 分配共享内存空间 ###

// Create the shmem segment
    PGShmemHeader *seghdr;
    PGShmemHeader *shim = NULL;
    seghdr = PGSharedMemoryCreate(size, port, &shim);
    InitShmemAccess(seghdr);

PGSharedMemoryCreate函数处于sysv\_shmem.c文件中，创建共享内存段，并初始化其标准头，最后注册on\_shmem\_exit回调函数以释放存储。先检查hugepage的支持，如果代码中没有定义MAP\_HUGETLB，但是huge\_pages指定为开启巨页的话就需要报错不支持。如果shared\_memory\_type参数指定为MMAP，则需要调用[CreateAnonymousSegment函数][CreateAnonymousSegment]创建匿名共享内存，但是还是需要通过system v的共享内存创建函数为PGShmemHeader结构体创建共享内存，然后再将内容其拷贝到匿名页中，最后返回匿名页的地址。如果shared\_memory\_type参数指定为sysv，则指示需要使用system v的共享内存创建函数，最后返回共享内存地址。

PGShmemHeader *PGSharedMemoryCreate(Size size, int port, PGShmemHeader **shim)
    { 
    	IpcMemoryKey NextShmemSegID;
    	void	   *memAddress;
    	PGShmemHeader *hdr;
    	struct stat statbuf;
    	Size		sysvsize;
    #if !defined(MAP_HUGETLB)
    	if (huge_pages == HUGE_PAGES_ON)
    		ereport(ERROR,(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),errmsg("huge pages not supported on this platform")));
    #endif
    	/* Room for a header? */
    	Assert(size > MAXALIGN(sizeof(PGShmemHeader)));
    	if (shared_memory_type == SHMEM_TYPE_MMAP){ 
    		AnonymousShmem = CreateAnonymousSegment(&size);
    		AnonymousShmemSize = size;		
    		on_shmem_exit(AnonymousShmemDetach, (Datum) 0); /* Register on-exit routine to unmap the anonymous segment */		
    		sysvsize = sizeof(PGShmemHeader); /* Now we need only allocate a minimal-sized SysV shmem block. */
    	} else
    		sysvsize = size;

先通过InternalIpcMemoryCreate函数使用指定的key（NextShmemSegID = 1 + port \* 1000）创建共享内存，如果失败，直接调用shmget为PGShmemHeader结构体创建共享内存，然后对state进行判断，然后再进行循环处理。

/* Loop till we find a free IPC key. Trust CreateDataDirLockFile() to ensure no more than one postmaster per data directory can enter this loop simultaneously. (CreateDataDirLockFile() does not ensure that, but prefer fixing it over coping here.) */
    	NextShmemSegID = 1 + port * 1000;
    	for (;;){ 
    		IpcMemoryId shmid;
    		PGShmemHeader *oldhdr;
    		IpcMemoryState state;
    		/* Try to create new segment */
    		memAddress = InternalIpcMemoryCreate(NextShmemSegID, sysvsize);
    		if (memAddress)
    			break;				/* successful create and attach */
    		/* Check shared memory and possibly remove and recreate */
    		/* shmget() failure is typically EACCES, hence SHMSTATE_FOREIGN. ENOENT, a narrow possibility, implies SHMSTATE_ENOENT, but one can safely treat SHMSTATE_ENOENT like SHMSTATE_FOREIGN. */
    		shmid = shmget(NextShmemSegID, sizeof(PGShmemHeader), 0);
    		if (shmid < 0){ 
    			oldhdr = NULL;
    			state = SHMSTATE_FOREIGN;
    		}else
    			state = PGSharedMemoryAttach(shmid, NULL, &oldhdr);
    		switch (state){ 
    			case SHMSTATE_ANALYSIS_FAILURE:
    			case SHMSTATE_ATTACHED:
    				ereport(FATAL,(errcode(ERRCODE_LOCK_FILE_EXISTS),errmsg("pre-existing shared memory block (key %lu, ID %lu) is still in use",(unsigned long) NextShmemSegID,(unsigned long) shmid),errhint("Terminate any old server processes associated with data directory \"%s\".",DataDir)));
    				break;
    			case SHMSTATE_ENOENT:
    				/* To our surprise, some other process deleted since our last InternalIpcMemoryCreate(). Moments earlier, we would have seen SHMSTATE_FOREIGN. Try that same ID again. */
    				elog(LOG,"shared memory block (key %lu, ID %lu) deleted during startup",(unsigned long) NextShmemSegID,(unsigned long) shmid);
    				break;
    			case SHMSTATE_FOREIGN:
    				NextShmemSegID++;
    				break;
    			case SHMSTATE_UNATTACHED:
    				/* * The segment pertains to DataDir, and every process that had * used it has died or detached. Zap it, if possible, and any * associated dynamic shared memory segments, as well. This * shouldn't fail, but if it does, assume the segment belongs * to someone else after all, and try the next candidate. * Otherwise, try again to create the segment. That may fail * if some other process creates the same shmem key before we * do, in which case we'll try the next key. */
    				if (oldhdr->dsm_control != 0)
    					dsm_cleanup_using_control_segment(oldhdr->dsm_control);
    				if (shmctl(shmid, IPC_RMID, NULL) < 0)
    					NextShmemSegID++;
    				break;
    		}
    		if (oldhdr && shmdt(oldhdr) < 0)
    			elog(LOG, "shmdt(%p) failed: %m", oldhdr);
    	}
    	/* Initialize new segment. */
    	hdr = (PGShmemHeader *) memAddress;
    	hdr->creatorPID = getpid();
    	hdr->magic = PGShmemMagic;
    	hdr->dsm_control = 0;
    	/* Fill in the data directory ID info, too */
    	if (stat(DataDir, &statbuf) < 0)
    		ereport(FATAL,(errcode_for_file_access(),errmsg("could not stat data directory \"%s\": %m",DataDir)));
    	hdr->device = statbuf.st_dev;
    	hdr->inode = statbuf.st_ino;
    	/* Initialize space allocation status for segment. */
    	hdr->totalsize = size;
    	hdr->freeoffset = MAXALIGN(sizeof(PGShmemHeader));
    	*shim = hdr;
    	/* Save info for possible future use */
    	UsedShmemSegAddr = memAddress;
    	UsedShmemSegID = (unsigned long) NextShmemSegID;
    
    	/* * If AnonymousShmem is NULL here, then we're not using anonymous shared * memory, and should return a pointer to the System V shared memory * block. Otherwise, the System V shared memory block is only a shim, and * we must return a pointer to the real block. */
    	if (AnonymousShmem == NULL)
    		return hdr;
    	memcpy(AnonymousShmem, hdr, sizeof(PGShmemHeader));
    	return (PGShmemHeader *) AnonymousShmem;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center]

InitShmemAccess函数设置共享内存的全局指针，比如ShmemSegHdr全局共享内存头指针，共享内存起始地址，共享内存结束地址。

static PGShmemHeader *ShmemSegHdr;	/* shared mem segment header */
    static void *ShmemBase;			/* start address of shared memory */
    static void *ShmemEnd;			/* end+1 address of shared memory */
    
    void InitShmemAccess(void *seghdr) { 
    	PGShmemHeader *shmhdr = (PGShmemHeader *) seghdr;
    	ShmemSegHdr = shmhdr;
    	ShmemBase = (void *) shmhdr;
    	ShmemEnd = (char *) ShmemBase + shmhdr->totalsize;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center 1]

### 创建信号量 ###

// Create semaphores
    PGReserveSemaphores(numSemas, port);

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70]

PGSemaphore是指向Postgres信号量结构体的指针

typedef union SemTPadded{ 
    	sem_t		pgsem;
    	char		pad[PG_CACHE_LINE_SIZE];
    } SemTPadded;
    typedef struct PGSemaphoreData { 
    	SemTPadded	sem_padded;
    } PGSemaphoreData;
    typedef struct PGSemaphoreData *PGSemaphore;
    static PGSemaphore sharedSemas; /* array of PGSemaphoreData in shared memory */

#### sysv\_sema ####

按set来组织共享信号量，以SEMAS\_PER\_SET（16）为单位，mySemaSets是指向共享信号量集数组的指针。

typedef key_t IpcSemaphoreKey;	/* semaphore key passed to semget(2) */
    typedef int IpcSemaphoreId;		/* semaphore ID returned by semget(2) */
    #define SEMAS_PER_SET 16
    
    void PGReserveSemaphores(int maxSemas, int port) { 
    	/* We must use ShmemAllocUnlocked(), since the spinlock protecting ShmemAlloc() won't be ready yet. (This ordering is necessary when we are emulating spinlocks with semaphores.) */
    	sharedSemas = (PGSemaphore) ShmemAllocUnlocked(PGSemaphoreShmemSize(maxSemas));
    	numSharedSemas = 0;
    	maxSharedSemas = maxSemas;
    	maxSemaSets = (maxSemas + SEMAS_PER_SET - 1) / SEMAS_PER_SET;
    	mySemaSets = (IpcSemaphoreId *) malloc(maxSemaSets * sizeof(IpcSemaphoreId));
    	if (mySemaSets == NULL) elog(PANIC, "out of memory");
    	numSemaSets = 0;
    	nextSemaKey = port * 1000;
    	nextSemaNumber = SEMAS_PER_SET; /* force sema set alloc on 1st call */
    	on_shmem_exit(ReleaseSemaphores, 0);
    }

#### posix\_sema ####

如果指定了命名POSIX信号量，mySemPointers是指向存放sem\_t指针的数组，否则和system v一样调用ShmemAllocUnlocked函数创建sharedSemas。

void PGReserveSemaphores(int maxSemas, int port) { 
    #ifdef USE_NAMED_POSIX_SEMAPHORES
    	mySemPointers = (sem_t **) malloc(maxSemas * sizeof(sem_t *));
    	if (mySemPointers == NULL) elog(PANIC, "out of memory");
    #else
    	/* We must use ShmemAllocUnlocked(), since the spinlock protecting ShmemAlloc() won't be ready yet. (This ordering is necessary when we are emulating spinlocks with semaphores.) */
    	sharedSemas = (PGSemaphore) ShmemAllocUnlocked(PGSemaphoreShmemSize(maxSemas));
    #endif
    	numSems = 0;
    	maxSems = maxSemas;
    	nextSemKey = port * 1000;
    	on_shmem_exit(ReleaseSemaphores, 0);
    }

## 构建共享内存Hash索引 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70 1]

https://blog.csdn.net/BeiiGang/article/details/7288763

[CreateAnonymousSegment]: https://feishujun.blog.csdn.net/article/details/118585165
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/95aa6d00b0d74db0b421bfe8d5d02611.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221005/fe05a0f18b7f45ed9f0530db5209116d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70]: /images/20221005/9cf898dde8f143e0b54c69da0e487107.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70 1]: /images/20221005/8138ef5ef66f4a899165924b2bff9f5e.png