move all lwlocks to shared structs -- windows compat

Author: kelvich

src/commit.c

@@ -247,7 +247,7 @@ MtmTwoPhaseCommit()
 	while (Mtm->stop_new_commits)
 		MtmSleep(USECS_PER_SEC);
 
-	LWLockAcquire(MtmCommitBarrier, LW_SHARED);
+	LWLockAcquire(Mtm->commit_barrier, LW_SHARED);
 
 	participants = MtmGetEnabledNodeMask() &
 					~((nodemask_t)1 << (mtm_cfg->my_node_id-1));
@@ -291,7 +291,7 @@ MtmTwoPhaseCommit()
 	// XXX: make this conditional
 	gather(participants, messages, &n_messages);
 
-	LWLockRelease(MtmCommitBarrier);
+	LWLockRelease(Mtm->commit_barrier);
 
 	dmq_stream_unsubscribe(gid);
 	mtm_log(MtmTxTrace, "%s unsubscribed for %s", gid, gid);

src/ddl.c

@@ -59,6 +59,10 @@
 #define Anum_mtm_local_tables_rel_schema 1
 #define Anum_mtm_local_tables_rel_name	 2
 
+struct DDLSharedState
+{
+	LWLock   *localtab_lock;
+} *ddl_shared;
 
 typedef struct MtmGucEntry
 {
@@ -86,7 +90,6 @@ static bool DDLApplyInProgress;
 static HTAB *MtmGucHash = NULL;
 static dlist_head MtmGucList = DLIST_STATIC_INIT(MtmGucList);
 
-static LWLock  *MtmLocalTablesMapLock;
 static HTAB	   *MtmRemoteFunctions;
 static HTAB	   *MtmLocalTables;
 
@@ -137,6 +140,7 @@ MtmDDLReplicationInit()
 {
 	Size	size = 0;
 
+	size = add_size(size, sizeof(struct DDLSharedState));
 	size = add_size(size, hash_estimate_size(MULTIMASTER_MAX_LOCAL_TABLES,
 											 sizeof(Oid)));
 	size = MAXALIGN(size);
@@ -161,14 +165,22 @@ MtmDDLReplicationInit()
 void
 MtmDDLReplicationShmemStartup(void)
 {
-	HASHCTL info;
+	HASHCTL		info;
+	bool		found;
 
 	memset(&info, 0, sizeof(info));
 	info.entrysize = info.keysize = sizeof(Oid);
 
 	LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
 
-	MtmLocalTablesMapLock = &(GetNamedLWLockTranche("mtm-ddl"))->lock;
+	ddl_shared = ShmemInitStruct("ddl",
+								sizeof(struct DDLSharedState),
+								&found);
+
+	if (!found)
+	{
+		ddl_shared->localtab_lock = &(GetNamedLWLockTranche("mtm-ddl"))->lock;
+	}
 
 	MtmLocalTables = ShmemInitHash("MtmLocalTables",
 		MULTIMASTER_MAX_LOCAL_TABLES, MULTIMASTER_MAX_LOCAL_TABLES,
@@ -1237,9 +1249,9 @@ MtmMakeRelationLocal(Oid relid)
 {
 	if (OidIsValid(relid))
 	{
-		LWLockAcquire(MtmLocalTablesMapLock, LW_EXCLUSIVE);
+		LWLockAcquire(ddl_shared->localtab_lock, LW_EXCLUSIVE);
 		hash_search(MtmLocalTables, &relid, HASH_ENTER, NULL);
-		LWLockRelease(MtmLocalTablesMapLock);
+		LWLockRelease(ddl_shared->localtab_lock);
 	}
 }
 
@@ -1282,11 +1294,11 @@ MtmIsRelationLocal(Relation rel)
 {
 	bool found;
 
-	LWLockAcquire(MtmLocalTablesMapLock, LW_SHARED);
+	LWLockAcquire(ddl_shared->localtab_lock, LW_SHARED);
 	if (!Mtm->localTablesHashLoaded)
 	{
-		LWLockRelease(MtmLocalTablesMapLock);
-		LWLockAcquire(MtmLocalTablesMapLock, LW_EXCLUSIVE);
+		LWLockRelease(ddl_shared->localtab_lock);
+		LWLockAcquire(ddl_shared->localtab_lock, LW_EXCLUSIVE);
 		if (!Mtm->localTablesHashLoaded)
 		{
 			MtmLoadLocalTables();
@@ -1295,7 +1307,7 @@ MtmIsRelationLocal(Relation rel)
 	}
 
 	hash_search(MtmLocalTables, &RelationGetRelid(rel), HASH_FIND, &found);
-	LWLockRelease(MtmLocalTablesMapLock);
+	LWLockRelease(ddl_shared->localtab_lock);
 
 	return found;
 }

src/include/multimaster.h

@@ -153,6 +153,11 @@ extern bool receiver_mtm_cfg_valid;
 
 typedef struct
 {
+	LWLock	   *lock;
+	LWLock	   *commit_barrier;
+	LWLock	   *receiver_barrier;
+	LWLock	   *syncpoint_lock;
+
 	int			my_node_id;
 	bool		stop_new_commits;
 	XLogRecPtr	latestSyncpoint;
@@ -176,8 +181,6 @@ extern MtmCurrentTrans MtmTx;
 extern MemoryContext MtmApplyContext;
 
 /* Locks */
-extern LWLock *MtmLock;
-extern LWLock *MtmCommitBarrier;
 extern LWLock *MtmReceiverBarrier;
 extern LWLock *MtmSyncpointLock;
 

src/multimaster.c

@@ -123,11 +123,6 @@ static TransactionManager MtmTM =
 	MtmResumeTransaction
 };
 
-LWLock *MtmLock;
-LWLock *MtmCommitBarrier;
-LWLock *MtmReceiverBarrier;
-LWLock *MtmSyncpointLock;
-
 // XXX
 bool  MtmBackgroundWorker;
 int	  MtmReplicationNodeId;
@@ -278,6 +273,11 @@ MtmSharedShmemStartup()
 		Mtm->localTablesHashLoaded = false;
 		Mtm->latestSyncpoint = InvalidXLogRecPtr;
 
+		Mtm->lock = &(GetNamedLWLockTranche(MULTIMASTER_NAME)[0].lock);
+		Mtm->commit_barrier = &(GetNamedLWLockTranche(MULTIMASTER_NAME)[1].lock);
+		Mtm->receiver_barrier = &(GetNamedLWLockTranche(MULTIMASTER_NAME)[2].lock);
+		Mtm->syncpoint_lock = &(GetNamedLWLockTranche(MULTIMASTER_NAME)[3].lock);
+
 		for (i = 0; i < MtmMaxNodes; i++)
 		{
 			Mtm->peers[i].receiver_pid = InvalidPid;
@@ -291,11 +291,6 @@ MtmSharedShmemStartup()
 
 	RegisterXactCallback(MtmXactCallback, NULL);
 
-	MtmLock = &(GetNamedLWLockTranche(MULTIMASTER_NAME)[0].lock);
-	MtmCommitBarrier = &(GetNamedLWLockTranche(MULTIMASTER_NAME)[1].lock);
-	MtmReceiverBarrier = &(GetNamedLWLockTranche(MULTIMASTER_NAME)[2].lock);
-	MtmSyncpointLock = &(GetNamedLWLockTranche(MULTIMASTER_NAME)[3].lock);
-
 	TM = &MtmTM;
 	LWLockRelease(AddinShmemInitLock);
 }
@@ -984,9 +979,9 @@ mtm_join_node(PG_FUNCTION_ARGS)
 	 * Create syncpoints for all our peers so that new node can safely start
 	 * recovered replication connections.
 	 */
-	LWLockAcquire(MtmReceiverBarrier, LW_EXCLUSIVE);
+	LWLockAcquire(Mtm->receiver_barrier, LW_EXCLUSIVE);
 	curr_lsn = GetXLogWriteRecPtr();
-	LWLockRelease(MtmReceiverBarrier);
+	LWLockRelease(Mtm->receiver_barrier);
 
 	/* as we going to write that lsn on a new node, let's sync it */
 	XLogFlush(curr_lsn);

src/pglogical_apply.c

@@ -855,9 +855,9 @@ mtm_send_xid_reply(TransactionId xid, int node_id, MtmMessageCode msg_code)
 	DmqDestinationId dest_id;
 	StringInfoData msg;
 
-	LWLockAcquire(MtmLock, LW_SHARED);
+	LWLockAcquire(Mtm->lock, LW_SHARED);
 	dest_id = Mtm->peers[node_id - 1].dmq_dest_id;
-	LWLockRelease(MtmLock);
+	LWLockRelease(Mtm->lock);
 
 	Assert(dest_id >= 0);
 
@@ -882,9 +882,9 @@ mtm_send_gid_reply(char *gid, int node_id, MtmMessageCode msg_code)
 	DmqDestinationId dest_id;
 	StringInfoData msg;
 
-	LWLockAcquire(MtmLock, LW_SHARED);
+	LWLockAcquire(Mtm->lock, LW_SHARED);
 	dest_id = Mtm->peers[node_id - 1].dmq_dest_id;
-	LWLockRelease(MtmLock);
+	LWLockRelease(Mtm->lock);
 
 	Assert(dest_id >= 0);
 

src/pglogical_output.c

@@ -477,7 +477,7 @@ pg_decode_caughtup(LogicalDecodingContext *ctx)
 		 */
 		if (!hooks_data->recovery_done)
 		{
-			LWLockAcquire(MtmReceiverBarrier, LW_EXCLUSIVE);
+			LWLockAcquire(Mtm->receiver_barrier, LW_EXCLUSIVE);
 			hooks_data->recovery_done = true;
 			mtm_log(ProtoTraceState, "Start building safe point to finish recovery");
 		}
@@ -488,7 +488,7 @@ pg_decode_caughtup(LogicalDecodingContext *ctx)
 			data->api->write_caughtup(ctx->out, data, ctx->reader->EndRecPtr);
 			MtmOutputPluginWrite(ctx, true, true);
 
-			LWLockRelease(MtmReceiverBarrier);
+			LWLockRelease(Mtm->receiver_barrier);
 
 			/*
 			* This hook can be called mupltiple times when there is concurrent

src/pglogical_proto.c

@@ -776,9 +776,9 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args)
 	 * to setup all stuff in shared memory. But seems that there is no such
 	 * callback in vanilla pg and adding one will require some carefull thoughts.
 	 */
-	LWLockAcquire(MtmLock, LW_EXCLUSIVE);
+	LWLockAcquire(Mtm->lock, LW_EXCLUSIVE);
 	Mtm->peers[MtmReplicationNodeId - 1].sender_pid = MyProcPid;
-	LWLockRelease(MtmLock);
+	LWLockRelease(Mtm->lock);
 
 	if (hooks_data->is_recovery)
 	{
@@ -815,10 +815,10 @@ MtmReplicationStartupHook(struct PGLogicalStartupHookArgs* args)
 			char *session_id = psprintf(INT64_FORMAT, hooks_data->session_id);
 
 			Mtm->stop_new_commits = true;
-			LWLockAcquire(MtmCommitBarrier, LW_EXCLUSIVE);
+			LWLockAcquire(Mtm->commit_barrier, LW_EXCLUSIVE);
 			MtmStateProcessNeighborEvent(MtmReplicationNodeId, MTM_NEIGHBOR_WAL_SENDER_START_RECOVERED, false);
 			msg_xptr = LogLogicalMessage("P", session_id, strlen(session_id) + 1, false);
-			LWLockRelease(MtmCommitBarrier);
+			LWLockRelease(Mtm->commit_barrier);
 			Mtm->stop_new_commits = false;
 
 			XLogFlush(msg_xptr);
@@ -837,9 +837,9 @@ MtmReplicationShutdownHook(struct PGLogicalShutdownHookArgs* args)
 {
 	Assert(MtmReplicationNodeId >= 0);
 
-	LWLockAcquire(MtmLock, LW_EXCLUSIVE);
+	LWLockAcquire(Mtm->lock, LW_EXCLUSIVE);
 	Mtm->peers[MtmReplicationNodeId - 1].sender_pid = InvalidPid;
-	LWLockRelease(MtmLock);
+	LWLockRelease(Mtm->lock);
 
 	MtmStateProcessNeighborEvent(MtmReplicationNodeId,
 								 MTM_NEIGHBOR_WAL_SENDER_STOP, false);

src/pglogical_receiver.c

@@ -289,16 +289,16 @@ MtmExecute(void* work, int size, MtmReceiverContext *receiver_ctx, bool no_pool)
 	/* parallel_allowed should never be set during recovery */
 	Assert( !(receiver_ctx->is_recovery && receiver_ctx->parallel_allowed) );
 
-	LWLockAcquire(MtmReceiverBarrier, LW_SHARED);
+	LWLockAcquire(Mtm->receiver_barrier, LW_SHARED);
 
 	if (receiver_ctx->is_recovery || !receiver_ctx->parallel_allowed || no_pool)
 		MtmExecutor(work, size, receiver_ctx);
 	else
 		BgwPoolExecute(&Mtm->pools[MtmReplicationNodeId-1], work, size, receiver_ctx);
 
 	/* Our error handler can release lock */
-	if (LWLockHeldByMe(MtmReceiverBarrier))
-		LWLockRelease(MtmReceiverBarrier);
+	if (LWLockHeldByMe(Mtm->receiver_barrier))
+		LWLockRelease(Mtm->receiver_barrier);
 }
 
 /*
@@ -489,9 +489,9 @@ pglogical_receiver_at_exit(int status, Datum arg)
 {
 	int node_id = DatumGetInt32(arg);
 	BgwPoolCancel(&Mtm->pools[node_id - 1]);
-	LWLockAcquire(MtmLock, LW_EXCLUSIVE);
+	LWLockAcquire(Mtm->lock, LW_EXCLUSIVE);
 	Mtm->peers[node_id - 1].receiver_pid = InvalidPid;
-	LWLockRelease(MtmLock);
+	LWLockRelease(Mtm->lock);
 }
 
 void
@@ -581,10 +581,10 @@ pglogical_receiver_main(Datum main_arg)
 									nodeId),
 							true);
 
-		LWLockAcquire(MtmLock, LW_EXCLUSIVE);
+		LWLockAcquire(Mtm->lock, LW_EXCLUSIVE);
 		Mtm->peers[nodeId - 1].receiver_pid = MyProcPid;
 		Mtm->peers[nodeId - 1].receiver_mode = mode;
-		LWLockRelease(MtmLock);
+		LWLockRelease(Mtm->lock);
 
 		// XXX: delete unnecessary modes
 		Assert(mode == REPLMODE_RECOVERY || mode == REPLMODE_RECOVERED);

src/resolver.c

@@ -442,9 +442,9 @@ scatter_status_requests(MtmConfig *mtm_cfg)
 				StringInfoData msg;
 				DmqDestinationId dest_id;
 
-				LWLockAcquire(MtmLock, LW_SHARED);
+				LWLockAcquire(Mtm->lock, LW_SHARED);
 				dest_id = Mtm->peers[node_id - 1].dmq_dest_id;
-				LWLockRelease(MtmLock);
+				LWLockRelease(Mtm->lock);
 				Assert(dest_id >= 0);
 
 				initStringInfo(&msg);