avoid distributed deadlocks instead of detecting them

Author: kelvich

multimaster--1.0.sql

@@ -141,13 +141,13 @@ CREATE FUNCTION mtm.make_table_local(relation regclass) RETURNS void
 AS 'MODULE_PATHNAME','mtm_make_table_local'
 LANGUAGE C;
 
-CREATE FUNCTION mtm.dump_lock_graph() RETURNS text
-AS 'MODULE_PATHNAME','mtm_dump_lock_graph'
-LANGUAGE C;
+-- CREATE FUNCTION mtm.dump_lock_graph() RETURNS text
+-- AS 'MODULE_PATHNAME','mtm_dump_lock_graph'
+-- LANGUAGE C;
 
-CREATE FUNCTION mtm.check_deadlock(xid bigint) RETURNS boolean
-AS 'MODULE_PATHNAME','mtm_check_deadlock'
-LANGUAGE C;
+-- CREATE FUNCTION mtm.check_deadlock(xid bigint) RETURNS boolean
+-- AS 'MODULE_PATHNAME','mtm_check_deadlock'
+-- LANGUAGE C;
 
 CREATE FUNCTION mtm.set_temp_schema(nsp text) RETURNS void
 AS 'MODULE_PATHNAME','mtm_set_temp_schema'

src/ddd.c

@@ -22,6 +22,49 @@
 #include "logger.h"
 #include "commit.h"
 
+
+/*
+ * This DDD is based on following observations:
+ *
+ *    Situation when a transaction (say T1) in apply_worker (or receiver
+ * itself) stucks on some lock created by a transaction in a local backend (say
+ * T2) will definetly lead to a deadlock since T2 after beeing prepared and
+ * replicated will fail to obtain lock that is already held by T1.
+ *    Same reasoning may be applied to the situation when apply_worker (or
+ * receiver) is waiting for an apply_worker (or receiver) belonging to other
+ * origin -- no need to wait for a distributed deadlock detection and we may
+ * just instantly abort.
+ *    Only case for distributed deadlock that is left is when apply_worker
+ * (or receiver) is waiting for another apply_worker from same origin. However,
+ * such situation isn't possible since one origin node can not have two
+ * conflicting prepared transaction simultaneosly.
+ *
+ *    So we may construct distributed deadlock avoiding mechanism by disallowing
+ * such edges. Now we may ask inverse question: what amount of wait graphs
+ * with such edges are actually do not represent distributed deadlock? That may
+ * happen in cases when holding transaction is purely local since it holdind
+ * locks only in SHARED mode. Only lock levels that are conflicting with this
+ * modes are EXCLUSIVE and ACCESS EXCLUSIVE. In all other cases proposed
+ * avoiding scheme should not yield false positives.
+ *
+ *     To cope with false positives in EXCLUSIVE and ACCESS EXCLUSIVE modes we
+ * may throw exception not in WaitOnLock() when we first saw forbidden edge
+ * but later during first call to local deadlock detector. This way we still
+ * have `deadlock_timeout` second to grab that lock and database user also can
+ * increse it on per-transaction basis if there are long-living read-only
+ * transactions.
+ *
+ *     As a further optimization it is possible to check whether our lock is
+ * EXCLUSIVE or higher so not to delay rollback till `deadlock_timeout` event.
+ */
+bool
+MtmDetectGlobalDeadLock(PGPROC *proc)
+{
+	return MtmIsReceiver || MtmIsPoolWorker;
+}
+
+#if 0
+
 #define LOCK_BY_INDEX(i) ((LWLockId)&ddd_shared->locks[(i)])
 #define EQUAL_GTID(x,y) ((x).node == (y).node && (x).xid == (y).xid)
 
@@ -613,3 +656,5 @@ mtm_check_deadlock(PG_FUNCTION_ARGS)
 
 	PG_RETURN_BOOL(MtmDetectGlobalDeadLockForXid(xid));
 }
+
+#endif

src/include/ddd.h

@@ -1,12 +1,14 @@
 #ifndef __DDD_H__
 #define __DDD_H__
 
+extern bool MtmDetectGlobalDeadLock(PGPROC *proc);
+
+#if 0
 extern void MtmDeadlockDetectorInit(int n_nodes);
 extern void MtmDeadlockDetectorShmemStartup(int n_nodes);
-
-extern bool MtmDetectGlobalDeadLock(PGPROC *proc);
 extern void MtmUpdateLockGraph(int nodeId, void const *messageBody, int messageSize);
 extern void MtmDeadlockDetectorRemoveXact(TransactionId xid);
 extern void MtmDeadlockDetectorAddXact(TransactionId xid, GlobalTransactionId *gtid);
+#endif
 
 #endif

src/multimaster.c

@@ -277,7 +277,7 @@ MtmShmemStartup(void)
 	if (PreviousShmemStartupHook)
 		PreviousShmemStartupHook();
 
-	MtmDeadlockDetectorShmemStartup(MTM_MAX_NODES);
+	// MtmDeadlockDetectorShmemStartup(MTM_MAX_NODES);
 	MtmDDLReplicationShmemStartup();
 	MtmStateShmemStartup();
 	MtmSharedShmemStartup();
@@ -440,7 +440,7 @@ _PG_init(void)
 							 NULL
 		);
 
-	MtmDeadlockDetectorInit(MTM_MAX_NODES);
+	// MtmDeadlockDetectorInit(MTM_MAX_NODES);
 
 	/*
 	 * Request additional shared resources.	 (These are no-ops if we're not in

src/pglogical_apply.c

@@ -488,7 +488,7 @@ process_remote_begin(StringInfo s, GlobalTransactionId *gtid)
 
 	/* ddd */
 	gtid->my_xid = GetCurrentTransactionId();
-	MtmDeadlockDetectorAddXact(gtid->my_xid, gtid);
+	// MtmDeadlockDetectorAddXact(gtid->my_xid, gtid);
 
 	suppress_internal_consistency_checks = true;
 
@@ -659,8 +659,8 @@ process_remote_message(StringInfo s, MtmReceiverContext *receiver_ctx)
 				 * move DDD
 				 */
 				/* messages to dmq. */
-				mtm_log(MtmApplyMessage, "Executing deadlock message from %d", MtmReplicationNodeId);
-				MtmUpdateLockGraph(MtmReplicationNodeId, messageBody, messageSize);
+				// mtm_log(MtmApplyMessage, "Executing deadlock message from %d", MtmReplicationNodeId);
+				// MtmUpdateLockGraph(MtmReplicationNodeId, messageBody, messageSize);
 				standalone = true;
 				break;
 			}
@@ -1029,7 +1029,7 @@ process_remote_commit(StringInfo in, GlobalTransactionId *current_gtid, MtmRecei
 				current_gtid->node = 0;
 				current_gtid->xid = InvalidTransactionId;
 				current_gtid->my_xid = InvalidTransactionId;
-				MtmDeadlockDetectorRemoveXact(xid);
+				// MtmDeadlockDetectorRemoveXact(xid);
 
 				/*
 				 * Reset on_commit_actions.
@@ -1671,7 +1671,7 @@ MtmExecutor(void *work, size_t size, MtmReceiverContext *receiver_ctx)
 		/* handle only prepare errors here */
 		if (TransactionIdIsValid(current_gtid.my_xid))
 		{
-			MtmDeadlockDetectorRemoveXact(current_gtid.my_xid);
+			// MtmDeadlockDetectorRemoveXact(current_gtid.my_xid);
 			if (receiver_ctx->parallel_allowed)
 				mtm_send_xid_reply(current_gtid.xid, current_gtid.node,
 								   MSG_ABORTED, edata);