Fixes #2: add GetTransactionStateSize, SerializeTransactionState and DeserializeTransactionState to XTM API

knizhnik · knizhnik · commit 02f6b2056bb0 · 2016-06-01T18:40:40.000+03:00
diff --git a/contrib/mmts/multimaster.c b/contrib/mmts/multimaster.c
@@ -131,6 +131,10 @@ static TransactionId MtmAdjustOldestXid(TransactionId xid);
 static bool MtmDetectGlobalDeadLock(PGPROC* proc);
 static void MtmAddSubtransactions(MtmTransState* ts, TransactionId* subxids, int nSubxids);
 static char const* MtmGetName(void);
+static size_t MtmGetTransactionStateSize(void);
+static void MtmSerializeTransactionState(void* ctx);
+static void MtmDeserializeTransactionState(void* ctx);
+
 static void MtmCheckClusterLock(void);
 static void MtmCheckSlots(void);
 static void MtmAddSubtransactions(MtmTransState* ts, TransactionId *subxids, int nSubxids);
@@ -164,7 +168,10 @@ static TransactionManager MtmTM = {
 	PgGetGlobalTransactionId, 
 	MtmXidInMVCCSnapshot, 
 	MtmDetectGlobalDeadLock, 
-	MtmGetName 
+	MtmGetName,
+	MtmGetTransactionStateSize,
+	MtmSerializeTransactionState,
+	MtmDeserializeTransactionState
 };
 
 char const* const MtmNodeStatusMnem[] = 
@@ -323,6 +330,26 @@ static char const* MtmGetName(void)
 	return MULTIMASTER_NAME;
 }
 
+static size_t 
+MtmGetTransactionStateSize(void)
+{
+	return sizeof(MtmTx);
+}
+
+static void
+MtmSerializeTransactionState(void* ctx)
+{
+	memcpy(ctx, &MtmTx, sizeof(MtmTx));
+}
+
+static void
+MtmDeserializeTransactionState(void* ctx)
+{
+	memcpy(&MtmTx, ctx, sizeof(MtmTx));
+}
+
+
+
 /*
  * -------------------------------------------
  * Visibility&snapshots
diff --git a/contrib/pg_dtm/pg_dtm.c b/contrib/pg_dtm/pg_dtm.c
@@ -119,7 +119,10 @@ static TransactionManager DtmTM = {
 	DtmGetGlobalTransactionId,
 	PgXidInMVCCSnapshot,
     DtmDetectGlobalDeadLock,
-	DtmGetName
+	DtmGetName,
+	PgGetTransactionStateSize,
+	PgSerializeTransactionState,
+	PgDeserializeTransactionState	
 };
 
 static char *Arbiters;
diff --git a/contrib/pg_tsdtm/pg_tsdtm.c b/contrib/pg_tsdtm/pg_tsdtm.c
@@ -102,6 +102,10 @@ static bool DtmDetectGlobalDeadLock(PGPROC *proc);
 static cid_t DtmGetCsn(TransactionId xid);
 static void DtmAddSubtransactions(DtmTransStatus * ts, TransactionId *subxids, int nSubxids);
 static char const *DtmGetName(void);
+static size_t DtmGetTransactionStateSize(void);
+static void DtmSerializeTransactionState(void* ctx);
+static void DtmDeserializeTransactionState(void* ctx);
+
 
 static TransactionManager DtmTM = {
 	PgTransactionIdGetStatus,
@@ -113,7 +117,10 @@ static TransactionManager DtmTM = {
 	PgGetGlobalTransactionId,
 	DtmXidInMVCCSnapshot,
 	DtmDetectGlobalDeadLock,
-	DtmGetName
+	DtmGetName,
+	DtmGetTransactionStateSize,
+	DtmSerializeTransactionState,
+	DtmDeserializeTransactionState
 };
 
 void		_PG_init(void);
@@ -949,6 +956,25 @@ DtmDetectGlobalDeadLock(PGPROC *proc)
 	return true;
 }
 
+static size_t 
+DtmGetTransactionStateSize(void)
+{
+	return sizeof(dtm_tx);
+}
+
+static void
+DtmSerializeTransactionState(void* ctx)
+{
+	memcpy(ctx, &dtm_tx, sizeof(dtm_tx));
+}
+
+static void
+DtmDeserializeTransactionState(void* ctx)
+{
+	memcpy(&dtm_tx, ctx, sizeof(dtm_tx));
+}
+
+
 static cid_t
 DtmGetCsn(TransactionId xid)
 {
diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
@@ -27,6 +27,7 @@
 #include "access/transam.h"
 #include "access/twophase.h"
 #include "access/xact.h"
+#include "access/xtm.h"
 #include "access/xlog.h"
 #include "access/xloginsert.h"
 #include "access/xlogutils.h"
@@ -4826,8 +4827,9 @@ EstimateTransactionStateSpace(void)
 		nxids = add_size(nxids, s->nChildXids);
 	}
 
-	nxids = add_size(nxids, nParallelCurrentXids);
-	return mul_size(nxids, sizeof(TransactionId));
+	nxids = add_size(nxids, nParallelCurrentXids);	
+	nxids = mul_size(nxids, sizeof(TransactionId));
+	return add_size(nxids, TM->GetTransactionStateSize());
 }
 
 /*
@@ -4873,6 +4875,7 @@ SerializeTransactionState(Size maxsize, char *start_address)
 		Assert(maxsize >= (nParallelCurrentXids + c) * sizeof(TransactionId));
 		memcpy(&result[c], ParallelCurrentXids,
 			   nParallelCurrentXids * sizeof(TransactionId));
+		TM->SerializeTransactionState(&result[c + nParallelCurrentXids]);
 		return;
 	}
 
@@ -4906,6 +4909,7 @@ SerializeTransactionState(Size maxsize, char *start_address)
 	/* Copy data into output area. */
 	result[c++] = (TransactionId) nxids;
 	memcpy(&result[c], workspace, nxids * sizeof(TransactionId));
+	TM->SerializeTransactionState(&result[c + nxids]);
 }
 
 /*
@@ -4928,6 +4932,7 @@ StartParallelWorkerTransaction(char *tstatespace)
 	currentCommandId = tstate[4];
 	nParallelCurrentXids = (int) tstate[5];
 	ParallelCurrentXids = &tstate[6];
+	TM->DeserializeTransactionState(&tstate[nParallelCurrentXids + 6]);
 
 	CurrentTransactionState->blockState = TBLOCK_PARALLEL_INPROGRESS;
 }
diff --git a/src/backend/access/transam/xtm.c b/src/backend/access/transam/xtm.c
@@ -36,6 +36,23 @@ PgGetTransactionManagerName(void)
 	return "postgres";
 }
 
+size_t 
+PgGetTransactionStateSize(void)
+{
+	return 0;
+}
+
+void
+PgSerializeTransactionState(void* ctx)
+{
+}
+
+void
+PgDeserializeTransactionState(void* ctx)
+{
+}
+
+
 TransactionManager PgTM = {
 	PgTransactionIdGetStatus,
 	PgTransactionIdSetTreeStatus,
@@ -46,7 +63,10 @@ TransactionManager PgTM = {
 	PgGetGlobalTransactionId,
 	PgXidInMVCCSnapshot,
 	PgDetectGlobalDeadLock,
-	PgGetTransactionManagerName
+	PgGetTransactionManagerName,
+	PgGetTransactionStateSize,
+	PgSerializeTransactionState,
+	PgDeserializeTransactionState
 };
 
 TransactionManager *TM = &PgTM;
diff --git a/src/include/access/xtm.h b/src/include/access/xtm.h
@@ -71,6 +71,23 @@ typedef struct
 
 	/* Get transaction manager name */
 	char const *(*GetName) (void);
+
+	/* 
+	 * Calculate transaction state size. This method is invoked by EstimateTransactionStateSpace to copy transaction
+	 * state to parallel workers
+	 */
+	size_t      (*GetTransactionStateSize)(void);
+
+	/*
+	 * Serialize transaction state
+	 */
+	void        (*SerializeTransactionState)(void* ctx);
+
+	/*
+	 * Deserialize transaction state
+	 */	
+	void        (*DeserializeTransactionState)(void* ctx);
+
 }	TransactionManager;
 
 /* Get pointer to transaction manager: actually returns content of TM variable */
@@ -101,4 +118,9 @@ extern bool PgDetectGlobalDeadLock(PGPROC *proc);
 
 extern char const *PgGetTransactionManagerName(void);
 
+extern size_t PgGetTransactionStateSize(void);
+extern void PgSerializeTransactionState(void* ctx);
+extern void PgDeserializeTransactionState(void* ctx);
+
+
 #endif
