Restructure subtransaction handling to reduce resource consumption,

as per recent discussions.  Invent SubTransactionIds that are managed like
CommandIds (ie, counter is reset at start of each top transaction), and
use these instead of TransactionIds to keep track of subtransaction status
in those modules that need it.  This means that a subtransaction does not
need an XID unless it actually inserts/modifies rows in the database.
Accordingly, don't assign it an XID nor take a lock on the XID until it
tries to do that.  This saves a lot of overhead for subtransactions that
are only used for error recovery (eg plpgsql exceptions).  Also, arrange
to release a subtransaction's XID lock as soon as the subtransaction
exits, in both the commit and abort cases.  This avoids holding many
unique locks after a long series of subtransactions.  The price is some
additional overhead in XactLockTableWait, but that seems acceptable.
Finally, restructure the state machine in xact.c to have a more orthogonal
set of states for subtransactions.

4 files changed, 109 insertions, 81 deletions

diff --git a/src/backend/commands/portalcmds.c b/src/backend/commands/portalcmds.c
index 98ffe4ae47a..8aa7ac8e8cb 100644
--- a/src/backend/commands/portalcmds.c
+++ b/src/backend/commands/portalcmds.c
@@ -14,7 +14,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/commands/portalcmds.c,v 1.35 2004/09/13 20:06:29 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/commands/portalcmds.c,v 1.36 2004/09/16 16:58:28 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -309,7 +309,7 @@ PersistHoldablePortal(Portal portal)
 	 * If we're preserving a holdable portal, we had better be inside the
 	 * transaction that originally created it.
 	 */
-	Assert(portal->createXact == GetCurrentTransactionId());
+	Assert(portal->createSubid != InvalidSubTransactionId);
 	Assert(queryDesc != NULL);
 
 	/*
diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index 53ec53e39fd..de71560d1da 100644
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/commands/sequence.c,v 1.116 2004/08/29 05:06:41 momjian Exp $
+ *	  $PostgreSQL: pgsql/src/backend/commands/sequence.c,v 1.117 2004/09/16 16:58:28 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -23,6 +23,8 @@
 #include "miscadmin.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
+#include "utils/resowner.h"
+
 
 /*
  * We don't want to log each fetching of a value from a sequence,
@@ -754,25 +756,14 @@ static void
 init_sequence(RangeVar *relation, SeqTable *p_elm, Relation *p_rel)
 {
 	Oid			relid = RangeVarGetRelid(relation, false);
-	TransactionId thisxid = GetCurrentTransactionId();
-	SeqTable	elm;
+	TransactionId thisxid = GetTopTransactionId();
+	volatile SeqTable elm;
 	Relation	seqrel;
 
-	/* Look to see if we already have a seqtable entry for relation */
-	for (elm = seqtab; elm != NULL; elm = elm->next)
-	{
-		if (elm->relid == relid)
-			break;
-	}
-
 	/*
-	 * Open the sequence relation, acquiring AccessShareLock if we don't
-	 * already have a lock in the current xact.
+	 * Open the sequence relation.
 	 */
-	if (elm == NULL || elm->xid != thisxid)
-		seqrel = relation_open(relid, AccessShareLock);
-	else
-		seqrel = relation_open(relid, NoLock);
+	seqrel = relation_open(relid, NoLock);
 
 	if (seqrel->rd_rel->relkind != RELKIND_SEQUENCE)
 		ereport(ERROR,
@@ -780,6 +771,13 @@ init_sequence(RangeVar *relation, SeqTable *p_elm, Relation *p_rel)
 				 errmsg("\"%s\" is not a sequence",
 						relation->relname)));
 
+	/* Look to see if we already have a seqtable entry for relation */
+	for (elm = seqtab; elm != NULL; elm = elm->next)
+	{
+		if (elm->relid == relid)
+			break;
+	}
+
 	/*
 	 * Allocate new seqtable entry if we didn't find one.
 	 *
@@ -799,14 +797,42 @@ init_sequence(RangeVar *relation, SeqTable *p_elm, Relation *p_rel)
 					(errcode(ERRCODE_OUT_OF_MEMORY),
 					 errmsg("out of memory")));
 		elm->relid = relid;
+		elm->xid = InvalidTransactionId;
 		/* increment is set to 0 until we do read_info (see currval) */
 		elm->last = elm->cached = elm->increment = 0;
 		elm->next = seqtab;
 		seqtab = elm;
 	}
 
-	/* Flag that we have a lock in the current xact. */
-	elm->xid = thisxid;
+	/*
+	 * If we haven't touched the sequence already in this transaction,
+	 * we need to acquire AccessShareLock.  We arrange for the lock to
+	 * be owned by the top transaction, so that we don't need to do it
+	 * more than once per xact.
+	 */
+	if (elm->xid != thisxid)
+	{
+		ResourceOwner currentOwner;
+
+		currentOwner = CurrentResourceOwner;
+		PG_TRY();
+		{
+			CurrentResourceOwner = TopTransactionResourceOwner;
+
+			LockRelation(seqrel, AccessShareLock);
+		}
+		PG_CATCH();
+		{
+			/* Ensure CurrentResourceOwner is restored on error */
+			CurrentResourceOwner = currentOwner;
+			PG_RE_THROW();
+		}
+		PG_END_TRY();
+		CurrentResourceOwner = currentOwner;
+
+		/* Flag that we have a lock in the current xact. */
+		elm->xid = thisxid;
+	}
 
 	*p_elm = elm;
 	*p_rel = seqrel;
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 8c50d228435..63ee33dd304 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.131 2004/08/31 23:27:05 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.132 2004/09/16 16:58:28 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -71,14 +71,14 @@ typedef struct OnCommitItem
 	OnCommitAction oncommit;	/* what to do at end of xact */
 
 	/*
-	 * If this entry was created during this xact, it should be deleted at
-	 * xact abort.	Conversely, if this entry was deleted during this
-	 * xact, it should be removed at xact commit.  We leave deleted
-	 * entries in the list until commit so that we can roll back if
-	 * needed.
+	 * If this entry was created during the current transaction,
+	 * creating_subid is the ID of the creating subxact; if created in a prior
+	 * transaction, creating_subid is zero.  If deleted during the current
+	 * transaction, deleting_subid is the ID of the deleting subxact; if no
+	 * deletion request is pending, deleting_subid is zero.
 	 */
-	TransactionId creating_xid;
-	TransactionId deleting_xid;
+	SubTransactionId creating_subid;
+	SubTransactionId deleting_subid;
 } OnCommitItem;
 
 static List *on_commits = NIL;
@@ -5821,8 +5821,8 @@ register_on_commit_action(Oid relid, OnCommitAction action)
 	oc = (OnCommitItem *) palloc(sizeof(OnCommitItem));
 	oc->relid = relid;
 	oc->oncommit = action;
-	oc->creating_xid = GetCurrentTransactionId();
-	oc->deleting_xid = InvalidTransactionId;
+	oc->creating_subid = GetCurrentSubTransactionId();
+	oc->deleting_subid = InvalidSubTransactionId;
 
 	on_commits = lcons(oc, on_commits);
 
@@ -5845,7 +5845,7 @@ remove_on_commit_action(Oid relid)
 
 		if (oc->relid == relid)
 		{
-			oc->deleting_xid = GetCurrentTransactionId();
+			oc->deleting_subid = GetCurrentSubTransactionId();
 			break;
 		}
 	}
@@ -5860,7 +5860,6 @@ remove_on_commit_action(Oid relid)
 void
 PreCommit_on_commit_actions(void)
 {
-	TransactionId xid = GetCurrentTransactionId();
 	ListCell   *l;
 
 	foreach(l, on_commits)
@@ -5868,7 +5867,7 @@ PreCommit_on_commit_actions(void)
 		OnCommitItem *oc = (OnCommitItem *) lfirst(l);
 
 		/* Ignore entry if already dropped in this xact */
-		if (oc->deleting_xid == xid)
+		if (oc->deleting_subid != InvalidSubTransactionId)
 			continue;
 
 		switch (oc->oncommit)
@@ -5895,7 +5894,7 @@ PreCommit_on_commit_actions(void)
 					 * remove_on_commit_action, so the entry should get
 					 * marked as deleted.
 					 */
-					Assert(oc->deleting_xid == xid);
+					Assert(oc->deleting_subid != InvalidSubTransactionId);
 					break;
 				}
 		}
@@ -5911,7 +5910,7 @@ PreCommit_on_commit_actions(void)
  * during abort, remove those created during this transaction.
  */
 void
-AtEOXact_on_commit_actions(bool isCommit, TransactionId xid)
+AtEOXact_on_commit_actions(bool isCommit)
 {
 	ListCell   *cur_item;
 	ListCell   *prev_item;
@@ -5923,8 +5922,8 @@ AtEOXact_on_commit_actions(bool isCommit, TransactionId xid)
 	{
 		OnCommitItem *oc = (OnCommitItem *) lfirst(cur_item);
 
-		if (isCommit ? TransactionIdEquals(oc->deleting_xid, xid) :
-			TransactionIdEquals(oc->creating_xid, xid))
+		if (isCommit ? oc->deleting_subid != InvalidSubTransactionId :
+			oc->creating_subid != InvalidSubTransactionId)
 		{
 			/* cur_item must be removed */
 			on_commits = list_delete_cell(on_commits, cur_item, prev_item);
@@ -5937,8 +5936,8 @@ AtEOXact_on_commit_actions(bool isCommit, TransactionId xid)
 		else
 		{
 			/* cur_item must be preserved */
-			oc->creating_xid = InvalidTransactionId;
-			oc->deleting_xid = InvalidTransactionId;
+			oc->creating_subid = InvalidSubTransactionId;
+			oc->deleting_subid = InvalidSubTransactionId;
 			prev_item = cur_item;
 			cur_item = lnext(prev_item);
 		}
@@ -5953,8 +5952,8 @@ AtEOXact_on_commit_actions(bool isCommit, TransactionId xid)
  * this subtransaction as being the parent's responsibility.
  */
 void
-AtEOSubXact_on_commit_actions(bool isCommit, TransactionId childXid,
-							  TransactionId parentXid)
+AtEOSubXact_on_commit_actions(bool isCommit, SubTransactionId mySubid,
+							  SubTransactionId parentSubid)
 {
 	ListCell   *cur_item;
 	ListCell   *prev_item;
@@ -5966,7 +5965,7 @@ AtEOSubXact_on_commit_actions(bool isCommit, TransactionId childXid,
 	{
 		OnCommitItem *oc = (OnCommitItem *) lfirst(cur_item);
 
-		if (!isCommit && TransactionIdEquals(oc->creating_xid, childXid))
+		if (!isCommit && oc->creating_subid == mySubid)
 		{
 			/* cur_item must be removed */
 			on_commits = list_delete_cell(on_commits, cur_item, prev_item);
@@ -5979,10 +5978,10 @@ AtEOSubXact_on_commit_actions(bool isCommit, TransactionId childXid,
 		else
 		{
 			/* cur_item must be preserved */
-			if (TransactionIdEquals(oc->creating_xid, childXid))
-				oc->creating_xid = parentXid;
-			if (TransactionIdEquals(oc->deleting_xid, childXid))
-				oc->deleting_xid = isCommit ? parentXid : InvalidTransactionId;
+			if (oc->creating_subid == mySubid)
+				oc->creating_subid = parentSubid;
+			if (oc->deleting_subid == mySubid)
+				oc->deleting_subid = isCommit ? parentSubid : InvalidSubTransactionId;
 			prev_item = cur_item;
 			cur_item = lnext(prev_item);
 		}
diff --git a/src/backend/commands/user.c b/src/backend/commands/user.c
index e365f946b17..0221fe17e18 100644
--- a/src/backend/commands/user.c
+++ b/src/backend/commands/user.c
@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/backend/commands/user.c,v 1.144 2004/08/29 05:06:41 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/user.c,v 1.145 2004/09/16 16:58:28 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -45,28 +45,30 @@
 extern bool Password_encryption;
 
 /*
- * The need-to-update-files flags are a pair of TransactionIds that show what
- * level of the transaction tree requested the update.	To register an update,
- * the transaction saves its own TransactionId in the flag, unless the value
- * was already set to a valid TransactionId.  If it aborts and the value is its
- * TransactionId, it resets the value to InvalidTransactionId.	If it commits,
- * it changes the value to its parent's TransactionId.  This way the value is
- * propagated up to the topmost transaction, which will update the files if a
- * valid TransactionId is detected.
+ * The need-to-update-files flags are a pair of SubTransactionIds that show
+ * what level of the subtransaction tree requested the update. To register
+ * an update, the subtransaction saves its own SubTransactionId in the flag,
+ * unless the value was already set to a valid SubTransactionId (which implies
+ * that it or a parent level has already requested the same).  If it aborts
+ * and the value is its SubTransactionId, it resets the flag to
+ * InvalidSubTransactionId. If it commits, it changes the value to its
+ * parent's SubTransactionId.  This way the value is propagated up to the
+ * top-level transaction, which will update the files if a valid
+ * SubTransactionId is detected.
  */
-static TransactionId user_file_update_xid = InvalidTransactionId;
-static TransactionId group_file_update_xid = InvalidTransactionId;
+static SubTransactionId user_file_update_subid = InvalidSubTransactionId;
+static SubTransactionId group_file_update_subid = InvalidSubTransactionId;
 
 #define user_file_update_needed() \
 	do { \
-		if (user_file_update_xid == InvalidTransactionId) \
-			user_file_update_xid = GetCurrentTransactionId(); \
+		if (user_file_update_subid == InvalidSubTransactionId) \
+			user_file_update_subid = GetCurrentSubTransactionId(); \
 	} while (0)
 
 #define group_file_update_needed() \
 	do { \
-		if (group_file_update_xid == InvalidTransactionId) \
-			group_file_update_xid = GetCurrentTransactionId(); \
+		if (group_file_update_subid == InvalidSubTransactionId) \
+			group_file_update_subid = GetCurrentSubTransactionId(); \
 	} while (0)
 
 
@@ -451,14 +453,14 @@ AtEOXact_UpdatePasswordFile(bool isCommit)
 	Relation	urel = NULL;
 	Relation	grel = NULL;
 
-	if (user_file_update_xid == InvalidTransactionId &&
-		group_file_update_xid == InvalidTransactionId)
+	if (user_file_update_subid == InvalidSubTransactionId &&
+		group_file_update_subid == InvalidSubTransactionId)
 		return;
 
 	if (!isCommit)
 	{
-		user_file_update_xid = InvalidTransactionId;
-		group_file_update_xid = InvalidTransactionId;
+		user_file_update_subid = InvalidSubTransactionId;
+		group_file_update_subid = InvalidSubTransactionId;
 		return;
 	}
 
@@ -470,22 +472,22 @@ AtEOXact_UpdatePasswordFile(bool isCommit)
 	 * pg_shadow or pg_group, which likely won't have gotten a strong
 	 * enough lock), so get the locks we need before writing anything.
 	 */
-	if (user_file_update_xid != InvalidTransactionId)
+	if (user_file_update_subid != InvalidSubTransactionId)
 		urel = heap_openr(ShadowRelationName, ExclusiveLock);
-	if (group_file_update_xid != InvalidTransactionId)
+	if (group_file_update_subid != InvalidSubTransactionId)
 		grel = heap_openr(GroupRelationName, ExclusiveLock);
 
 	/* Okay to write the files */
-	if (user_file_update_xid != InvalidTransactionId)
+	if (user_file_update_subid != InvalidSubTransactionId)
 	{
-		user_file_update_xid = InvalidTransactionId;
+		user_file_update_subid = InvalidSubTransactionId;
 		write_user_file(urel);
 		heap_close(urel, NoLock);
 	}
 
-	if (group_file_update_xid != InvalidTransactionId)
+	if (group_file_update_subid != InvalidSubTransactionId)
 	{
-		group_file_update_xid = InvalidTransactionId;
+		group_file_update_subid = InvalidSubTransactionId;
 		write_group_file(grel);
 		heap_close(grel, NoLock);
 	}
@@ -503,24 +505,25 @@ AtEOXact_UpdatePasswordFile(bool isCommit)
  * need-to-update-files flags.
  */
 void
-AtEOSubXact_UpdatePasswordFile(bool isCommit, TransactionId myXid,
-							   TransactionId parentXid)
+AtEOSubXact_UpdatePasswordFile(bool isCommit,
+							   SubTransactionId mySubid,
+							   SubTransactionId parentSubid)
 {
 	if (isCommit)
 	{
-		if (user_file_update_xid == myXid)
-			user_file_update_xid = parentXid;
+		if (user_file_update_subid == mySubid)
+			user_file_update_subid = parentSubid;
 
-		if (group_file_update_xid == myXid)
-			group_file_update_xid = parentXid;
+		if (group_file_update_subid == mySubid)
+			group_file_update_subid = parentSubid;
 	}
 	else
 	{
-		if (user_file_update_xid == myXid)
-			user_file_update_xid = InvalidTransactionId;
+		if (user_file_update_subid == mySubid)
+			user_file_update_subid = InvalidSubTransactionId;
 
-		if (group_file_update_xid == myXid)
-			group_file_update_xid = InvalidTransactionId;
+		if (group_file_update_subid == mySubid)
+			group_file_update_subid = InvalidSubTransactionId;
 	}
 }