Keep the list of to-be-NOTIFYed names in a plain List palloc'd in

TopTransactionContext, rather than using Dllist.  This simplifies and
speeds up the code, and eliminates a former risk of coredump when
out of memory (since the old code didn't bother to check for malloc
failure).  It also moves us one step closer to retiring Dllist...

diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
index 5fda53d02c6c65244fe1eeb4f35eff8335609370..dde2412a6ea4bcb055d7c3f0cc790b0bde62d2be 100644 (file)
--- a/src/backend/commands/async.c
+++ b/src/backend/commands/async.c
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.78 2001/06/12 05:55:49 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.79 2001/06/17 22:27:15 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -82,7 +82,6 @@
 #include "catalog/catname.h"
 #include "catalog/pg_listener.h"
 #include "commands/async.h"
-#include "lib/dllist.h"
 #include "libpq/libpq.h"
 #include "libpq/pqformat.h"
 #include "miscadmin.h"
@@ -100,10 +99,11 @@ extern CommandDest whereToSendOutput;
 /*
  * State for outbound notifies consists of a list of all relnames NOTIFYed
  * in the current transaction. We do not actually perform a NOTIFY until
- * and unless the transaction commits. pendingNotifies is NULL if no
- * NOTIFYs have been done in the current transaction.
+ * and unless the transaction commits. pendingNotifies is NIL if no
+ * NOTIFYs have been done in the current transaction.  The List nodes and
+ * referenced strings are all palloc'd in TopTransactionContext.
  */
-static Dllist *pendingNotifies = NULL;
+static List *pendingNotifies = NIL;
 
 /*
  * State for inbound notifies consists of two flags: one saying whether
@@ -121,16 +121,16 @@ static volatile int notifyInterruptOccurred = 0;
 /* True if we've registered an on_shmem_exit cleanup */
 static bool unlistenExitRegistered = false;
 
+bool   Trace_notify = false;
+
 
 static void Async_UnlistenAll(void);
 static void Async_UnlistenOnExit(void);
 static void ProcessIncomingNotify(void);
 static void NotifyMyFrontEnd(char *relname, int32 listenerPID);
-static int     AsyncExistsPendingNotify(char *relname);
+static bool AsyncExistsPendingNotify(const char *relname);
 static void ClearPendingNotifies(void);
 
-bool           Trace_notify = false;
-
 
 /*
  *--------------------------------------------------------------
@@ -150,26 +150,23 @@ bool              Trace_notify = false;
 void
 Async_Notify(char *relname)
 {
-       char       *notifyName;
-
        if (Trace_notify)
                elog(DEBUG, "Async_Notify: %s", relname);
 
-       if (!pendingNotifies)
-               pendingNotifies = DLNewList();
        /* no point in making duplicate entries in the list ... */
-       if (!AsyncExistsPendingNotify(relname))
+       if (! AsyncExistsPendingNotify(relname))
        {
-
                /*
-                * We allocate list memory from the global malloc pool to ensure
-                * that it will live until we want to use it.  This is probably
-                * not necessary any longer, since we will use it before the end
-                * of the transaction. DLList only knows how to use malloc()
-                * anyway, but we could probably palloc() the strings...
+                * The name list needs to live until end of transaction, so
+                * store it in the top transaction context.
                 */
-               notifyName = strdup(relname);
-               DLAddHead(pendingNotifies, DLNewElem(notifyName));
+               MemoryContext   oldcontext;
+
+               oldcontext = MemoryContextSwitchTo(TopTransactionContext);
+
+               pendingNotifies = lcons(pstrdup(relname), pendingNotifies);
+
+               MemoryContextSwitchTo(oldcontext);
        }
 }
 
@@ -352,7 +349,7 @@ Async_Unlisten(char *relname, int pid)
  *--------------------------------------------------------------
  */
 static void
-Async_UnlistenAll()
+Async_UnlistenAll(void)
 {
        Relation        lRel;
        TupleDesc       tdesc;
@@ -401,7 +398,6 @@ Async_UnlistenAll()
 static void
 Async_UnlistenOnExit(void)
 {
-
        /*
         * We need to start/commit a transaction for the unlisten, but if
         * there is already an active transaction we had better abort that one
@@ -438,7 +434,7 @@ Async_UnlistenOnExit(void)
  *--------------------------------------------------------------
  */
 void
-AtCommit_Notify()
+AtCommit_Notify(void)
 {
        Relation        lRel;
        TupleDesc       tdesc;
@@ -449,7 +445,7 @@ AtCommit_Notify()
        char            repl[Natts_pg_listener],
                                nulls[Natts_pg_listener];
 
-       if (!pendingNotifies)
+       if (pendingNotifies == NIL)
                return;                                 /* no NOTIFY statements in this
                                                                 * transaction */
 
@@ -579,7 +575,7 @@ AtCommit_Notify()
  *--------------------------------------------------------------
  */
 void
-AtAbort_Notify()
+AtAbort_Notify(void)
 {
        ClearPendingNotifies();
 }
@@ -601,7 +597,6 @@ AtAbort_Notify()
  *             per above
  *--------------------------------------------------------------
  */
-
 void
 Async_NotifyHandler(SIGNAL_ARGS)
 {
@@ -671,7 +666,6 @@ Async_NotifyHandler(SIGNAL_ARGS)
  *             PostgresMain calls this the first time.
  * --------------------------------------------------------------
  */
-
 void
 EnableNotifyInterrupt(void)
 {
@@ -729,7 +723,6 @@ EnableNotifyInterrupt(void)
  *             is disabled until the next EnableNotifyInterrupt call.
  * --------------------------------------------------------------
  */
-
 void
 DisableNotifyInterrupt(void)
 {
@@ -848,8 +841,9 @@ ProcessIncomingNotify(void)
                elog(DEBUG, "ProcessIncomingNotify: done");
 }
 
-/* Send NOTIFY message to my front end. */
-
+/*
+ * Send NOTIFY message to my front end.
+ */
 static void
 NotifyMyFrontEnd(char *relname, int32 listenerPID)
 {
@@ -874,50 +868,32 @@ NotifyMyFrontEnd(char *relname, int32 listenerPID)
                elog(NOTICE, "NOTIFY for %s", relname);
 }
 
-/* Does pendingNotifies include the given relname?
- *
- * NB: not called unless pendingNotifies != NULL.
- */
-
-static int
-AsyncExistsPendingNotify(char *relname)
+/* Does pendingNotifies include the given relname? */
+static bool
+AsyncExistsPendingNotify(const char *relname)
 {
-       Dlelem     *p;
+       List       *p;
 
-       for (p = DLGetHead(pendingNotifies);
-                p != NULL;
-                p = DLGetSucc(p))
+       foreach(p, pendingNotifies)
        {
                /* Use NAMEDATALEN for relname comparison.        DZ - 26-08-1996 */
-               if (strncmp((const char *) DLE_VAL(p), relname, NAMEDATALEN) == 0)
-                       return 1;
+               if (strncmp((const char *) lfirst(p), relname, NAMEDATALEN) == 0)
+                       return true;
        }
 
-       return 0;
+       return false;
 }
 
 /* Clear the pendingNotifies list. */
-
 static void
-ClearPendingNotifies()
+ClearPendingNotifies(void)
 {
-       Dlelem     *p;
-
-       if (pendingNotifies)
-       {
-
-               /*
-                * Since the referenced strings are malloc'd, we have to scan the
-                * list and delete them individually.  If we used palloc for the
-                * strings then we could just do DLFreeList to get rid of both the
-                * list nodes and the list base...
-                */
-               while ((p = DLRemHead(pendingNotifies)) != NULL)
-               {
-                       free(DLE_VAL(p));
-                       DLFreeElem(p);
-               }
-               DLFreeList(pendingNotifies);
-               pendingNotifies = NULL;
-       }
+       /*
+        * We used to have to explicitly deallocate the list members and nodes,
+        * because they were malloc'd.  Now, since we know they are palloc'd
+        * in TopTransactionContext, we need not do that --- they'll go away
+        * automatically at transaction exit.  We need only reset the list head
+        * pointer.
+        */
+       pendingNotifies = NIL;
 }