Make some simple performance improvements in TransactionIdIsInProgress().

For XIDs of our own transaction and subtransactions, it's cheaper to ask
TransactionIdIsCurrentTransactionId() than to look in shared memory.
Also, the xids[] work array is always the same size within any given
process, so malloc it just once instead of doing a palloc/pfree on every
call; aside from being faster this lets us get rid of some goto's, since
we no longer have any end-of-function pfree to do.  Both ideas by Heikki.

diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
index 0565510c31b8676a9d8018b5fe45e1595e6ab859..dbac4a8fd05de662eda005deb1a8bffc98253c3c 100644 (file)
--- a/src/backend/storage/ipc/procarray.c
+++ b/src/backend/storage/ipc/procarray.c
@@ -23,7 +23,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/storage/ipc/procarray.c,v 1.33 2007/09/08 20:31:15 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/storage/ipc/procarray.c,v 1.34 2007/09/21 17:36:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -60,11 +60,13 @@ static ProcArrayStruct *procArray;
 
 /* counters for XidCache measurement */
 static long xc_by_recent_xmin = 0;
+static long xc_by_my_xact = 0;
 static long xc_by_main_xid = 0;
 static long xc_by_child_xid = 0;
 static long xc_slow_answer = 0;
 
 #define xc_by_recent_xmin_inc()        (xc_by_recent_xmin++)
+#define xc_by_my_xact_inc()            (xc_by_my_xact++)
 #define xc_by_main_xid_inc()       (xc_by_main_xid++)
 #define xc_by_child_xid_inc()      (xc_by_child_xid++)
 #define xc_slow_answer_inc()       (xc_slow_answer++)
@@ -73,6 +75,7 @@ static void DisplayXidCache(void);
 #else                          /* !XIDCACHE_DEBUG */
 
 #define xc_by_recent_xmin_inc()        ((void) 0)
+#define xc_by_my_xact_inc()            ((void) 0)
 #define xc_by_main_xid_inc()       ((void) 0)
 #define xc_by_child_xid_inc()      ((void) 0)
 #define xc_slow_answer_inc()       ((void) 0)
@@ -320,14 +323,12 @@ ProcArrayClearTransaction(PGPROC *proc)
 bool
 TransactionIdIsInProgress(TransactionId xid)
 {
-   bool        result = false;
+   static TransactionId *xids = NULL;
+   int         nxids = 0;
    ProcArrayStruct *arrayP = procArray;
+   TransactionId topxid;
    int         i,
                j;
-   int         nxids = 0;
-   TransactionId *xids;
-   TransactionId topxid;
-   bool        locked;
 
    /*
     * Don't bother checking a transaction older than RecentXmin; it could not
@@ -341,18 +342,43 @@ TransactionIdIsInProgress(TransactionId xid)
        return false;
    }
 
-   /* Get workspace to remember main XIDs in */
-   xids = (TransactionId *) palloc(sizeof(TransactionId) * arrayP->maxProcs);
+   /*
+    * Also, we can handle our own transaction (and subtransactions) without
+    * any access to shared memory.
+    */
+   if (TransactionIdIsCurrentTransactionId(xid))
+   {
+       xc_by_my_xact_inc();
+       return true;
+   }
+
+   /*
+    * If not first time through, get workspace to remember main XIDs in.
+    * We malloc it permanently to avoid repeated palloc/pfree overhead.
+    */
+   if (xids == NULL)
+   {
+       xids = (TransactionId *)
+           malloc(arrayP->maxProcs * sizeof(TransactionId));
+       if (xids == NULL)
+           ereport(ERROR,
+                   (errcode(ERRCODE_OUT_OF_MEMORY),
+                    errmsg("out of memory")));
+   }
 
    LWLockAcquire(ProcArrayLock, LW_SHARED);
-   locked = true;
 
    for (i = 0; i < arrayP->numProcs; i++)
    {
        volatile PGPROC    *proc = arrayP->procs[i];
+       TransactionId pxid;
+
+       /* Ignore my own proc --- dealt with it above */
+       if (proc == MyProc)
+           continue;
 
        /* Fetch xid just once - see GetNewTransactionId */
-       TransactionId pxid = proc->xid;
+       pxid = proc->xid;
 
        if (!TransactionIdIsValid(pxid))
            continue;
@@ -362,9 +388,9 @@ TransactionIdIsInProgress(TransactionId xid)
         */
        if (TransactionIdEquals(pxid, xid))
        {
+           LWLockRelease(ProcArrayLock);
            xc_by_main_xid_inc();
-           result = true;
-           goto result_known;
+           return true;
        }
 
        /*
@@ -384,9 +410,9 @@ TransactionIdIsInProgress(TransactionId xid)
 
            if (TransactionIdEquals(cxid, xid))
            {
+               LWLockRelease(ProcArrayLock);
                xc_by_child_xid_inc();
-               result = true;
-               goto result_known;
+               return true;
            }
        }
 
@@ -402,14 +428,13 @@ TransactionIdIsInProgress(TransactionId xid)
    }
 
    LWLockRelease(ProcArrayLock);
-   locked = false;
 
    /*
     * If none of the relevant caches overflowed, we know the Xid is not
     * running without looking at pg_subtrans.
     */
    if (nxids == 0)
-       goto result_known;
+       return false;
 
    /*
     * Step 3: have to check pg_subtrans.
@@ -422,7 +447,7 @@ TransactionIdIsInProgress(TransactionId xid)
    xc_slow_answer_inc();
 
    if (TransactionIdDidAbort(xid))
-       goto result_known;
+       return false;
 
    /*
     * It isn't aborted, so check whether the transaction tree it belongs to
@@ -436,20 +461,11 @@ TransactionIdIsInProgress(TransactionId xid)
        for (i = 0; i < nxids; i++)
        {
            if (TransactionIdEquals(xids[i], topxid))
-           {
-               result = true;
-               break;
-           }
+               return true;
        }
    }
 
-result_known:
-   if (locked)
-       LWLockRelease(ProcArrayLock);
-
-   pfree(xids);
-
-   return result;
+   return false;
 }
 
 /*
@@ -1284,8 +1300,9 @@ static void
 DisplayXidCache(void)
 {
    fprintf(stderr,
-           "XidCache: xmin: %ld, mainxid: %ld, childxid: %ld, slow: %ld\n",
+           "XidCache: xmin: %ld, myxact: %ld, mainxid: %ld, childxid: %ld, slow: %ld\n",
            xc_by_recent_xmin,
+           xc_by_my_xact,
            xc_by_main_xid,
            xc_by_child_xid,
            xc_slow_answer);