embedded list v2

From c3c80925e780489351c4de210364e55d223f02a8 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Sun, 6 May 2012 00:26:35 +0200
Subject: [PATCH 1/2] Add embedded list interface

Adds a single and a double linked list which can easily embedded into other
datastructures and can be used without additional memory allocations.
---
 src/backend/lib/Makefile |    2 +-
 src/backend/lib/ilist.c  |  123 ++++++++++++
 src/include/lib/ilist.h  |  468 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 592 insertions(+), 1 deletion(-)
 create mode 100644 src/backend/lib/ilist.c
 create mode 100644 src/include/lib/ilist.h

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 2e1061e..c94297a 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/lib
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = dllist.o stringinfo.o
+OBJS = dllist.o stringinfo.o ilist.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/ilist.c b/src/backend/lib/ilist.c
new file mode 100644
index 0000000..f78ac51
--- /dev/null
+++ b/src/backend/lib/ilist.c
@@ -0,0 +1,123 @@
+/*-------------------------------------------------------------------------
+ *
+ * ilist.c
+ *	  support for integrated/inline double and single linked lists
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/lib/ilist.c
+ *
+ * NOTES
+ *
+ *	  This function only contains testing code for inline single/double linked
+ *	  lists.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+/*
+ * If inlines aren't available include the function as defined in the header,
+ * but without 'static inline' defined. That way we do not have to duplicate
+ * their functionality.
+ */
+#ifndef USE_INLINE
+#define ILIST_USE_DECLARATION
+#endif
+
+#include "lib/ilist.h"
+
+#ifndef USE_INLINE
+#undef ILIST_USE_DECLARATION
+#endif
+
+/*
+ * removes a node from a list
+ *
+ * Attention: O(n)
+ */
+void
+ilist_s_delete(ilist_s_head *head, ilist_s_node *node)
+{
+	ilist_s_node *last = &head->head;
+	ilist_s_node *cur;
+#ifdef ILIST_DEBUG
+	bool found = false;
+#endif
+	while ((cur = last->next) != NULL)
+	{
+		if (cur == node)
+		{
+			last->next = cur->next;
+#ifdef  ILIST_DEBUG
+			found = true;
+#endif
+			break;
+		}
+		last = cur;
+	}
+	ilist_s_check(head);
+
+#ifdef ILIST_DEBUG
+   if(!found)
+	   elog(ERROR, "tried to delete nonexisting node");
+#endif
+}
+
+#ifdef ILIST_DEBUG
+void ilist_d_check(ilist_d_head* head)
+{
+    ilist_d_node *cur;
+
+    if(!head || !(&head->head))
+	    elog(ERROR, "double linked list head is not properly initialized");
+
+    for(cur = head->head.next; cur != &head->head; cur = cur->next)
+    {
+	    if(!(cur) ||
+	       !(cur->next) ||
+	       !(cur->prev) ||
+	       !(cur->prev->next == cur) ||
+	       !(cur->next->prev == cur))
+	    {
+		    elog(ERROR, "double linked list is corrupted");
+	    }
+    }
+
+    for(cur = head->head.prev; cur != &head->head; cur = cur->prev)
+    {
+	    if(!(cur) ||
+	       !(cur->next) ||
+	       !(cur->prev) ||
+	       !(cur->prev->next == cur) ||
+	       !(cur->next->prev == cur))
+	    {
+		    elog(ERROR, "double linked list is corrupted");
+	    }
+    }
+}
+
+void ilist_s_check(ilist_s_head* head)
+{
+    ilist_s_node *cur;
+
+    if(!head ||
+       !(&head->head))
+	    elog(ERROR, "single linked list head is not properly initialized");
+
+    /*
+     * there isn't much we can test in a single linked list except that its
+     * really circular
+     */
+    for(cur = head->head.next; cur != &head->head; cur = cur->next)
+    {
+	    if(!cur)
+		    elog(ERROR, "single linked list is corrupted");
+    }
+}
+
+#endif /* ILIST_DEBUG */
diff --git a/src/include/lib/ilist.h b/src/include/lib/ilist.h
new file mode 100644
index 0000000..ef66d39
--- /dev/null
+++ b/src/include/lib/ilist.h
@@ -0,0 +1,468 @@
+/*-------------------------------------------------------------------------
+ *
+ * ilist.h
+ *		integrated/inline double and single linked lists without memory
+ *		managment overhead
+ *
+ *	This is intended to be used in the following manner:
+ *
+ *	#include "lib/ilist.h"
+ *
+ *	typedef struct something_in_a_list
+ *	{
+ *		int value;
+ *		int somethingelse;
+ *		ilist_d_head values;
+ *	} something_in_a_list;
+ *
+ *	typedef struct value_in_a_list
+ *	{
+ *		int data;
+ *		int somethingelse;
+ *		ilist_d_node list_node;
+ *	} value_in_a_list;
+ *
+ *	something_in_a_list *somelist = get_blarg();
+ *
+ *	ilist_d_push_head(somelist, &get_value_in_a_list()->list_node);
+ *  ...
+ *	ilist_d_push_head(somelist, &get_value_in_a_list()->list_node);
+ *	...
+ *	...
+ *	ilist_d_node *node, *next;
+ *
+ *	ilist_d_foreach(node, somelist)
+ *	{
+ *		value_in_a_list *val = ilist_container(value_in_a_list, list_node, node);
+ *		do_something_with_val(val);
+ *	}
+ *
+ *	ilist_d_foreach_modify(node, next, somelist)
+ *	{
+ *		ilist_d_delete(node);
+ *	}
+ *
+ *  This allows somewhat convenient list manipulation with low overhead.
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/lib/ilist.h
+ *-------------------------------------------------------------------------
+ */
+#ifndef ILIST_H
+#define ILIST_H
+
+/*
+ * enable for extra debugging. This is rather expensive so its not enabled by
+ * default even with --enable-cassert
+*/
+/* #define ILIST_DEBUG */
+
+/*
+ * gcc warns about unused parameters if -Wunused-parameter is specified (part
+ * of -Wextra ). In the cases below its perfectly fine not to use those
+ * parameters because they are just passed to make the interface consistent and
+ * to allow debugging in case of ILIST_DEBUG.
+ *
+ */
+#ifdef __GNUC__
+#define unused_attr __attribute__((unused))
+#else
+#define unused_attr
+#endif
+
+/*
+ * struct to embed in other structs that need to be part of a double linked
+ * list.
+ */
+typedef struct ilist_d_node ilist_d_node;
+struct ilist_d_node
+{
+	ilist_d_node* prev;
+	ilist_d_node* next;
+};
+
+/*
+ * Head of a double linked list. Lists are internally *always* circularly
+ * linked, even when empty. This allows to do many many manipulations without
+ * branches which is beneficial performancewise.
+ */
+typedef struct
+{
+	ilist_d_node head;
+} ilist_d_head;
+
+/*
+ * struct to embed in other structs that need to be part of a single linked
+ * list.
+ */
+typedef struct ilist_s_node ilist_s_node;
+struct ilist_s_node
+{
+	ilist_s_node* next;
+};
+
+/*
+ * Head of a single linked list.
+ */
+typedef struct
+{
+	ilist_s_node head;
+} ilist_s_head;
+
+
+#ifdef USE_INLINE
+#define INLINE_IF_POSSIBLE static inline
+#define ILIST_USE_DECLARATION
+#else
+#define INLINE_IF_POSSIBLE
+#endif
+
+/* Functions we want to be inlined if possible */
+#ifndef USE_INLINE
+extern void ilist_d_check(unused_attr ilist_d_head* head);
+extern void ilist_d_init(ilist_d_head *head);
+extern void ilist_d_push_head(ilist_d_head *head, ilist_d_node *node);
+extern void ilist_d_push_tail(ilist_d_head *head, ilist_d_node *node);
+extern void ilist_d_insert_after(unused_attr ilist_d_head *head,
+                                 ilist_d_node *after, ilist_d_node *node);
+extern void ilist_d_insert_before(unused_attr ilist_d_head *head,
+                                  ilist_d_node *before, ilist_d_node *node);
+extern void ilist_d_delete(unused_attr ilist_d_head *head, ilist_d_node *node);
+extern ilist_d_node* ilist_d_pop_head(ilist_d_head *head);
+extern void ilist_d_move_head(ilist_d_head *head, ilist_d_node *node);
+extern bool ilist_d_has_next(ilist_d_head *head, ilist_d_node *node);
+extern bool ilist_d_has_prev(ilist_d_head *head, ilist_d_node *node);
+extern bool ilist_d_is_empty(ilist_d_head *head);
+extern void ilist_d_check(ilist_d_head* head);
+
+extern void ilist_s_init(ilist_s_head *head);
+extern void ilist_s_push_head(ilist_s_head *head, ilist_s_node *node);
+extern ilist_s_node* ilist_s_pop_head(ilist_s_head *head);
+extern void ilist_s_insert_after(unused_attr ilist_s_head *head,
+                              ilist_s_node *after, ilist_s_node *node);
+extern bool ilist_s_is_empty(ilist_s_head *head);
+extern bool ilist_s_has_next(unused_attr ilist_s_head* head,
+                             ilist_s_node *node);
+
+#endif /* USE_INLINE */
+
+/* Functions which are too big to be inline */
+
+/*
+ * deletes a node from a list
+ *
+ * Attention: O(n)
+ */
+extern void ilist_s_delete(ilist_s_head *head, ilist_s_node *node);
+
+#ifdef ILIST_DEBUG
+extern void ilist_d_check(ilist_d_head* head);
+extern void ilist_s_check(ilist_s_head* head);
+#else
+#define ilist_d_check(head)
+#define ilist_s_check(head)
+#endif /*ILIST_DEBUG*/
+
+
+/*
+ * The following function declarations are only used if inlining is supported
+ * or when included from a file that explicitly declares USE_DECLARATION
+ */
+#ifdef ILIST_USE_DECLARATION
+
+/*
+ * Initialize the head of a list. Previous state will be thrown away without
+ * any cleanup.
+ */
+INLINE_IF_POSSIBLE void
+ilist_d_init(ilist_d_head *head)
+{
+	head->head.next = head->head.prev = &head->head;
+	ilist_d_check(head);
+}
+
+/*
+ * inserts a node at the beginning of the list
+ */
+INLINE_IF_POSSIBLE void
+ilist_d_push_head(ilist_d_head *head, ilist_d_node *node)
+{
+	node->next = head->head.next;
+	node->prev = &head->head;
+	node->next->prev = node;
+	head->head.next = node;
+	ilist_d_check(head);
+}
+
+
+/*
+ * inserts a node at the end of the list
+ */
+INLINE_IF_POSSIBLE void
+ilist_d_push_tail(ilist_d_head *head, ilist_d_node *node)
+{
+	node->next = &head->head;
+	node->prev = head->head.prev;
+	node->prev->next = node;
+	head->head.prev = node;
+	ilist_d_check(head);
+}
+
+
+/*
+ * insert a node after another *in the same list*
+ */
+INLINE_IF_POSSIBLE void
+ilist_d_insert_after(unused_attr ilist_d_head *head, ilist_d_node *after,
+                     ilist_d_node *node)
+{
+	ilist_d_check(head);
+	node->prev = after;
+	node->next = after->next;
+	after->next = node;
+	node->next->prev = node;
+	ilist_d_check(head);
+}
+
+/*
+ * insert a node after another *in the same list*
+ */
+INLINE_IF_POSSIBLE void
+ilist_d_insert_before(unused_attr ilist_d_head *head, ilist_d_node *before,
+                      ilist_d_node *node)
+{
+	ilist_d_check(head);
+	node->prev = before->prev;
+	node->next = before;
+	before->prev = node;
+	node->prev->next = node;
+	ilist_d_check(head);
+}
+
+
+/*
+ * deletes a node from a list
+ */
+INLINE_IF_POSSIBLE void
+ilist_d_delete(unused_attr ilist_d_head *head, ilist_d_node *node)
+{
+	ilist_d_check(head);
+	node->prev->next = node->next;
+	node->next->prev = node->prev;
+	ilist_d_check(head);
+}
+
+/*
+ * deletes the first node from a list or returns NULL
+ */
+INLINE_IF_POSSIBLE ilist_d_node*
+ilist_d_pop_head(ilist_d_head *head)
+{
+	ilist_d_node* ret;
+
+	if (&head->head == head->head.next)
+		return NULL;
+
+	ret = head->head.next;
+	ilist_d_delete(head, head->head.next);
+	return ret;
+}
+
+/*
+ * moves an element that has to be in the list to the head of the list
+ */
+INLINE_IF_POSSIBLE void
+ilist_d_move_head(ilist_d_head *head, ilist_d_node *node)
+{
+	/* fast path if its already at the head */
+	if(&head->head == node)
+		return;
+	ilist_d_delete(head, node);
+	ilist_d_push_head(head, node);
+	ilist_d_check(head);
+}
+
+/*
+ * Check whether the passed node is the last element in the list
+ */
+INLINE_IF_POSSIBLE bool
+ilist_d_has_next(ilist_d_head *head, ilist_d_node *node)
+{
+	return node->next != &head->head;
+}
+
+/*
+ * Check whether the passed node is the first element in the list
+ */
+INLINE_IF_POSSIBLE bool
+ilist_d_has_prev(ilist_d_head *head, ilist_d_node *node)
+{
+	return node->prev != &head->head;
+}
+
+/*
+ * Check whether the list is empty.
+ */
+INLINE_IF_POSSIBLE bool
+ilist_d_is_empty(ilist_d_head *head)
+{
+	return head->head.next == head->head.prev;
+}
+
+#endif /* ILIST_USE_DECLARATION */
+
+/*
+ * Return the value of first element in the list if there is one, return NULL
+ * otherwise.
+ *
+ * ptr *will* be evaluated multiple times.
+ */
+#define ilist_d_head(type, membername, ptr)								\
+(																			\
+	(&((ptr)->head) == (ptr)->head.next) ?									\
+		NULL : ilist_container(type, membername, (ptr)->head.next)			\
+)
+
+/*
+ * Return the value of the first element. This will corrupt data if there is no
+ * element in the list.
+ */
+#define ilist_d_head_unchecked(type, membername, ptr)						\
+	ilist_container(type, membername, (ptr)->head.next)
+
+/*
+ * Return the value of the last element in the list if ther eis one, return
+ * NULL otherwise.
+ *
+ * ptr *will* be evaluated multiple times.
+ */
+#define ilist_d_tail(type, membername, ptr)									\
+(																			\
+	(&((ptr)->head) == (ptr)->head.prev) ?									\
+		NULL : ilist_container(type, membername, (ptr)->head.prev)			\
+)
+
+/*
+ * Return a pointer to the struct `type` when the passed `ptr` points to the
+ * element `membername`.
+ */
+#define ilist_container(type, membername, ptr)								\
+	((type*)((char*)(ptr) - offsetof(type, membername)))
+
+/*
+ * Iterate through the list storing the current element in the variable
+ * `name`. `ptr` will be evaluated repeatedly.
+ *
+ * It is *not* allowed to manipulate the list during iteration.
+ */
+#define ilist_d_foreach(name, ptr)											\
+	for(name = (ptr)->head.next; name != &(ptr)->head; name = name->next)
+
+
+/*
+ * Iterate through the list storing the current element in the variable `name`
+ * and also storing the next list element in the variable `nxt`.
+ *
+ * It is allowed to delete the current element from the list. Every other
+ * manipulation can lead to curruption.
+ */
+#define ilist_d_foreach_modify(name, nxt, ptr)								\
+	for(name = (ptr)->head.next, nxt = name->next; name != &(ptr)->head;	\
+		name = nxt, nxt = name->next)
+
+/*
+ * Iterate through the list in reverse order storing the current element in the
+ * variable `name`. `ptr` will be evaluated repeatedly.
+ *
+ * It is *not* allowed to manipulate the list during iteration.
+ */
+#define ilist_d_reverse_foreach(name, ptr)									\
+	for(name = (ptr)->head.prev; name != &(ptr)->head; name = name->prev)
+
+
+#ifdef ILIST_USE_DECLARATION
+
+/*
+ * Initialize a single linked list element.
+ */
+INLINE_IF_POSSIBLE void
+ilist_s_init(ilist_s_head *head)
+{
+	head->head.next = NULL;
+	ilist_s_check(head);
+}
+
+INLINE_IF_POSSIBLE void
+ilist_s_push_head(ilist_s_head *head, ilist_s_node *node)
+{
+	node->next = head->head.next;
+	head->head.next = node;
+	ilist_s_check(head);
+}
+
+/*
+ * fails if the list is empty
+ */
+INLINE_IF_POSSIBLE ilist_s_node*
+ilist_s_pop_head(ilist_s_head *head)
+{
+	ilist_s_node* node = head->head.next;
+	head->head.next = head->head.next->next;
+	ilist_s_check(head);
+	return node;
+}
+
+INLINE_IF_POSSIBLE void
+ilist_s_insert_after(unused_attr ilist_s_head *head, ilist_s_node *after,
+                     ilist_s_node *node)
+{
+	node->next = after->next;
+	after->next = node;
+	ilist_s_check(head);
+}
+
+
+INLINE_IF_POSSIBLE
+bool ilist_s_is_empty(ilist_s_head *head)
+{
+	return head->head.next == NULL;
+}
+
+INLINE_IF_POSSIBLE bool
+ilist_s_has_next(unused_attr ilist_s_head* head,
+                 ilist_s_node *node)
+{
+	return node->next != NULL;
+}
+
+#endif /* ILIST_USE_DECLARATION */
+
+#define ilist_s_head(type, membername, ptr)									\
+(																			\
+	ilist_s_is_empty(ptr) ?													\
+		ilist_container(type, membername, (ptr).next)						\
+	: NULL																	\
+)
+
+#define ilist_s_head_unchecked(type, membername, ptr)						\
+	ilist_container(type, membername, (ptr)->head.next)
+
+#define ilist_s_foreach(name, ptr)											\
+	for(name = (ptr)->head.next; name != NULL; name = name->next)
+
+#define ilist_s_foreach_modify(name, nxt, ptr)								\
+	for(name = (ptr)->head.next, nxt = name ? name->next : NULL;			\
+		name != NULL;														\
+	    name = nxt, nxt = name ? name->next : NULL)
+
+/*
+ * if we defined ILIST_USE_DECLARATION undef it again, its not interesting
+ * outside this file
+ */
+#ifdef USE_INLINE
+#undef ILIST_USE_DECLARATION
+#endif
+
+#endif /* ILIST_H */
-- 
1.7.10.rc3.3.g19a6c.dirty

From 5d2e23c6dc346b9f277869f4e4f1e048faaa574d Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Tue, 26 Jun 2012 19:53:24 +0200
Subject: [PATCH 2/2] Remove usage of lib/dllist.h and replace it by the new
 lib/ilist.h interface

---
 src/backend/postmaster/autovacuum.c |   91 +++++++++++++-----------------
 src/backend/postmaster/postmaster.c |   54 +++++++++---------
 src/backend/utils/cache/catcache.c  |  106 +++++++++++++++++------------------
 src/include/utils/catcache.h        |   14 ++---
 4 files changed, 125 insertions(+), 140 deletions(-)

diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index dade5cc..1f0886c 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -76,6 +76,7 @@
 #include "catalog/pg_database.h"
 #include "commands/dbcommands.h"
 #include "commands/vacuum.h"
+#include "lib/ilist.h"
 #include "libpq/pqsignal.h"
 #include "miscadmin.h"
 #include "pgstat.h"
@@ -149,6 +150,7 @@ typedef struct avl_dbase
 	Oid			adl_datid;		/* hash key -- must be first */
 	TimestampTz adl_next_worker;
 	int			adl_score;
+	ilist_d_node adl_node;
 } avl_dbase;
 
 /* struct to keep track of databases in worker */
@@ -256,7 +258,7 @@ typedef struct
 static AutoVacuumShmemStruct *AutoVacuumShmem;
 
 /* the database list in the launcher, and the context that contains it */
-static Dllist *DatabaseList = NULL;
+static ilist_d_head DatabaseList;
 static MemoryContext DatabaseListCxt = NULL;
 
 /* Pointer to my own WorkerInfo, valid on each worker */
@@ -403,6 +405,9 @@ AutoVacLauncherMain(int argc, char *argv[])
 	/* Identify myself via ps */
 	init_ps_display("autovacuum launcher process", "", "", "");
 
+	/* initialize to be empty */
+	ilist_d_init(&DatabaseList);
+
 	ereport(LOG,
 			(errmsg("autovacuum launcher started")));
 
@@ -505,7 +510,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 
 		/* don't leave dangling pointers to freed memory */
 		DatabaseListCxt = NULL;
-		DatabaseList = NULL;
+		ilist_d_init(&DatabaseList);
 
 		/*
 		 * Make sure pgstat also considers our stat data as gone.  Note: we
@@ -573,7 +578,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 		struct timeval nap;
 		TimestampTz current_time = 0;
 		bool		can_launch;
-		Dlelem	   *elem;
+		avl_dbase   *avdb;
 		int			rc;
 
 		/*
@@ -735,11 +740,9 @@ AutoVacLauncherMain(int argc, char *argv[])
 
 		/* We're OK to start a new worker */
 
-		elem = DLGetTail(DatabaseList);
-		if (elem != NULL)
+		avdb = ilist_d_head(avl_dbase, adl_node, &DatabaseList);
+		if (avdb != NULL)
 		{
-			avl_dbase  *avdb = DLE_VAL(elem);
-
 			/*
 			 * launch a worker if next_worker is right now or it is in the
 			 * past
@@ -780,7 +783,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 static void
 launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
 {
-	Dlelem	   *elem;
+	avl_dbase  *avdb;
 
 	/*
 	 * We sleep until the next scheduled vacuum.  We trust that when the
@@ -793,9 +796,8 @@ launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
 		nap->tv_sec = autovacuum_naptime;
 		nap->tv_usec = 0;
 	}
-	else if ((elem = DLGetTail(DatabaseList)) != NULL)
+	else if ((avdb = ilist_d_tail(avl_dbase, adl_node, &DatabaseList)) != NULL)
 	{
-		avl_dbase  *avdb = DLE_VAL(elem);
 		TimestampTz current_time = GetCurrentTimestamp();
 		TimestampTz next_wakeup;
 		long		secs;
@@ -864,6 +866,7 @@ rebuild_database_list(Oid newdb)
 	int			score;
 	int			nelems;
 	HTAB	   *dbhash;
+	ilist_d_node *elem;
 
 	/* use fresh stats */
 	autovac_refresh_stats();
@@ -924,36 +927,28 @@ rebuild_database_list(Oid newdb)
 	}
 
 	/* Now insert the databases from the existing list */
-	if (DatabaseList != NULL)
+	ilist_d_foreach(elem, &DatabaseList)
 	{
-		Dlelem	   *elem;
-
-		elem = DLGetHead(DatabaseList);
-		while (elem != NULL)
-		{
-			avl_dbase  *avdb = DLE_VAL(elem);
-			avl_dbase  *db;
-			bool		found;
-			PgStat_StatDBEntry *entry;
-
-			elem = DLGetSucc(elem);
+		avl_dbase  *avdb = ilist_container(avl_dbase, adl_node, elem);
+		avl_dbase  *db;
+		bool		found;
+		PgStat_StatDBEntry *entry;
 
-			/*
-			 * skip databases with no stat entries -- in particular, this gets
-			 * rid of dropped databases
-			 */
-			entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
-			if (entry == NULL)
-				continue;
+		/*
+		 * skip databases with no stat entries -- in particular, this gets
+		 * rid of dropped databases
+		 */
+		entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
+		if (entry == NULL)
+			continue;
 
-			db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
+		db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
 
-			if (!found)
-			{
-				/* hash_search already filled in the key */
-				db->adl_score = score++;
-				/* next_worker is filled in later */
-			}
+		if (!found)
+		{
+			/* hash_search already filled in the key */
+			db->adl_score = score++;
+			/* next_worker is filled in later */
 		}
 	}
 
@@ -984,7 +979,7 @@ rebuild_database_list(Oid newdb)
 
 	/* from here on, the allocated memory belongs to the new list */
 	MemoryContextSwitchTo(newcxt);
-	DatabaseList = DLNewList();
+	ilist_d_init(&DatabaseList);
 
 	if (nelems > 0)
 	{
@@ -1026,15 +1021,13 @@ rebuild_database_list(Oid newdb)
 		for (i = 0; i < nelems; i++)
 		{
 			avl_dbase  *db = &(dbary[i]);
-			Dlelem	   *elem;
 
 			current_time = TimestampTzPlusMilliseconds(current_time,
 													   millis_increment);
 			db->adl_next_worker = current_time;
 
-			elem = DLNewElem(db);
 			/* later elements should go closer to the head of the list */
-			DLAddHead(DatabaseList, elem);
+			ilist_d_push_head(&DatabaseList, &db->adl_node);
 		}
 	}
 
@@ -1144,7 +1137,7 @@ do_start_worker(void)
 	foreach(cell, dblist)
 	{
 		avw_dbase  *tmp = lfirst(cell);
-		Dlelem	   *elem;
+		ilist_d_node *elem;
 
 		/* Check to see if this one is at risk of wraparound */
 		if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
@@ -1176,11 +1169,10 @@ do_start_worker(void)
 		 * autovacuum time yet.
 		 */
 		skipit = false;
-		elem = DatabaseList ? DLGetTail(DatabaseList) : NULL;
 
-		while (elem != NULL)
+		ilist_d_reverse_foreach(elem, &DatabaseList)
 		{
-			avl_dbase  *dbp = DLE_VAL(elem);
+			avl_dbase  *dbp = ilist_container(avl_dbase, adl_node, elem);
 
 			if (dbp->adl_datid == tmp->adw_datid)
 			{
@@ -1197,7 +1189,6 @@ do_start_worker(void)
 
 				break;
 			}
-			elem = DLGetPred(elem);
 		}
 		if (skipit)
 			continue;
@@ -1271,7 +1262,7 @@ static void
 launch_worker(TimestampTz now)
 {
 	Oid			dbid;
-	Dlelem	   *elem;
+	ilist_d_node *elem;
 
 	dbid = do_start_worker();
 	if (OidIsValid(dbid))
@@ -1280,10 +1271,9 @@ launch_worker(TimestampTz now)
 		 * Walk the database list and update the corresponding entry.  If the
 		 * database is not on the list, we'll recreate the list.
 		 */
-		elem = (DatabaseList == NULL) ? NULL : DLGetHead(DatabaseList);
-		while (elem != NULL)
+		ilist_d_foreach(elem, &DatabaseList)
 		{
-			avl_dbase  *avdb = DLE_VAL(elem);
+			avl_dbase  *avdb = ilist_container(avl_dbase, adl_node, elem);
 
 			if (avdb->adl_datid == dbid)
 			{
@@ -1294,10 +1284,9 @@ launch_worker(TimestampTz now)
 				avdb->adl_next_worker =
 					TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000);
 
-				DLMoveToFront(elem);
+				ilist_d_move_head(&DatabaseList, elem);
 				break;
 			}
-			elem = DLGetSucc(elem);
 		}
 
 		/*
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index 913734f..36e9b0b 100644
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -95,7 +95,7 @@
 #include "access/xlog.h"
 #include "bootstrap/bootstrap.h"
 #include "catalog/pg_control.h"
-#include "lib/dllist.h"
+#include "lib/ilist.h"
 #include "libpq/auth.h"
 #include "libpq/ip.h"
 #include "libpq/libpq.h"
@@ -145,10 +145,10 @@ typedef struct bkend
 	int			child_slot;		/* PMChildSlot for this backend, if any */
 	bool		is_autovacuum;	/* is it an autovacuum process? */
 	bool		dead_end;		/* is it going to send an error and quit? */
-	Dlelem		elem;			/* list link in BackendList */
+	ilist_d_node		elem;			/* list link in BackendList */
 } Backend;
 
-static Dllist *BackendList;
+static ilist_d_head BackendList;
 
 #ifdef EXEC_BACKEND
 static Backend *ShmemBackendArray;
@@ -976,7 +976,7 @@ PostmasterMain(int argc, char *argv[])
 	/*
 	 * Initialize the list of active backends.
 	 */
-	BackendList = DLNewList();
+	ilist_d_init(&BackendList);
 
 	/*
 	 * Initialize pipe (or process handle on Windows) that allows children to
@@ -1797,7 +1797,7 @@ processCancelRequest(Port *port, void *pkt)
 	Backend    *bp;
 
 #ifndef EXEC_BACKEND
-	Dlelem	   *curr;
+	ilist_d_node *curr;
 #else
 	int			i;
 #endif
@@ -1811,9 +1811,9 @@ processCancelRequest(Port *port, void *pkt)
 	 * duplicate array in shared memory.
 	 */
 #ifndef EXEC_BACKEND
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	ilist_d_foreach(curr, &BackendList)
 	{
-		bp = (Backend *) DLE_VAL(curr);
+		bp = ilist_container(Backend, elem, curr);
 #else
 	for (i = MaxLivePostmasterChildren() - 1; i >= 0; i--)
 	{
@@ -2591,8 +2591,7 @@ static void
 CleanupBackend(int pid,
 			   int exitstatus)	/* child's exit status. */
 {
-	Dlelem	   *curr;
-
+	ilist_d_node *curr, *next;
 	LogChildExit(DEBUG2, _("server process"), pid, exitstatus);
 
 	/*
@@ -2623,9 +2622,9 @@ CleanupBackend(int pid,
 		return;
 	}
 
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	ilist_d_foreach_modify(curr, next, &BackendList)
 	{
-		Backend    *bp = (Backend *) DLE_VAL(curr);
+		Backend    *bp = ilist_container(Backend, elem, curr);
 
 		if (bp->pid == pid)
 		{
@@ -2644,7 +2643,7 @@ CleanupBackend(int pid,
 				ShmemBackendArrayRemove(bp);
 #endif
 			}
-			DLRemove(curr);
+			ilist_d_delete(&BackendList, curr);
 			free(bp);
 			break;
 		}
@@ -2661,7 +2660,7 @@ CleanupBackend(int pid,
 static void
 HandleChildCrash(int pid, int exitstatus, const char *procname)
 {
-	Dlelem	   *curr,
+	ilist_d_node  *curr,
 			   *next;
 	Backend    *bp;
 
@@ -2677,10 +2676,10 @@ HandleChildCrash(int pid, int exitstatus, const char *procname)
 	}
 
 	/* Process regular backends */
-	for (curr = DLGetHead(BackendList); curr; curr = next)
+	ilist_d_foreach_modify(curr, next, &BackendList)
 	{
-		next = DLGetSucc(curr);
-		bp = (Backend *) DLE_VAL(curr);
+		bp = ilist_container(Backend, elem, curr);
+
 		if (bp->pid == pid)
 		{
 			/*
@@ -2693,7 +2692,7 @@ HandleChildCrash(int pid, int exitstatus, const char *procname)
 				ShmemBackendArrayRemove(bp);
 #endif
 			}
-			DLRemove(curr);
+			ilist_d_delete(&BackendList, curr);
 			free(bp);
 			/* Keep looping so we can signal remaining backends */
 		}
@@ -3056,7 +3055,7 @@ PostmasterStateMachine(void)
 		 * normal state transition leading up to PM_WAIT_DEAD_END, or during
 		 * FatalError processing.
 		 */
-		if (DLGetHead(BackendList) == NULL &&
+		if (ilist_d_is_empty(&BackendList) &&
 			PgArchPID == 0 && PgStatPID == 0)
 		{
 			/* These other guys should be dead already */
@@ -3182,12 +3181,12 @@ signal_child(pid_t pid, int signal)
 static bool
 SignalSomeChildren(int signal, int target)
 {
-	Dlelem	   *curr;
+	ilist_d_node *curr;
 	bool		signaled = false;
 
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	ilist_d_foreach(curr, &BackendList)
 	{
-		Backend    *bp = (Backend *) DLE_VAL(curr);
+		Backend    *bp = ilist_container(Backend, elem, curr);
 
 		if (bp->dead_end)
 			continue;
@@ -3325,8 +3324,8 @@ BackendStartup(Port *port)
 	 */
 	bn->pid = pid;
 	bn->is_autovacuum = false;
-	DLInitElem(&bn->elem, bn);
-	DLAddHead(BackendList, &bn->elem);
+	ilist_d_push_head(&BackendList, &bn->elem);
+
 #ifdef EXEC_BACKEND
 	if (!bn->dead_end)
 		ShmemBackendArrayAdd(bn);
@@ -4422,12 +4421,12 @@ PostmasterRandom(void)
 static int
 CountChildren(int target)
 {
-	Dlelem	   *curr;
+	ilist_d_node *curr;
 	int			cnt = 0;
 
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	ilist_d_foreach(curr, &BackendList)
 	{
-		Backend    *bp = (Backend *) DLE_VAL(curr);
+		Backend    *bp = ilist_container(Backend, elem, curr);
 
 		if (bp->dead_end)
 			continue;
@@ -4606,8 +4605,7 @@ StartAutovacuumWorker(void)
 			if (bn->pid > 0)
 			{
 				bn->is_autovacuum = true;
-				DLInitElem(&bn->elem, bn);
-				DLAddHead(BackendList, &bn->elem);
+				ilist_d_push_head(&BackendList, &bn->elem);
 #ifdef EXEC_BACKEND
 				ShmemBackendArrayAdd(bn);
 #endif
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index 0307b96..efe34d9 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -353,6 +353,8 @@ CatCachePrintStats(int code, Datum arg)
 static void
 CatCacheRemoveCTup(CatCache *cache, CatCTup *ct)
 {
+	Index		hashIndex;
+
 	Assert(ct->refcount == 0);
 	Assert(ct->my_cache == cache);
 
@@ -369,7 +371,9 @@ CatCacheRemoveCTup(CatCache *cache, CatCTup *ct)
 	}
 
 	/* delink from linked list */
-	DLRemove(&ct->cache_elem);
+	hashIndex = HASH_INDEX(ct->hash_value, cache->cc_nbuckets);
+
+	ilist_d_delete(&cache->cc_bucket[hashIndex], &ct->cache_elem);
 
 	/* free associated tuple data */
 	if (ct->tuple.t_data != NULL)
@@ -412,7 +416,7 @@ CatCacheRemoveCList(CatCache *cache, CatCList *cl)
 	}
 
 	/* delink from linked list */
-	DLRemove(&cl->cache_elem);
+	ilist_d_delete(&cache->cc_lists, &cl->cache_elem);
 
 	/* free associated tuple data */
 	if (cl->tuple.t_data != NULL)
@@ -452,8 +456,9 @@ CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
 	{
 		Index		hashIndex;
-		Dlelem	   *elt,
+		ilist_d_node *elt,
 				   *nextelt;
+		ilist_d_head *bucket;
 
 		if (cacheId != ccp->id)
 			continue;
@@ -468,11 +473,9 @@ CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 		 * Invalidate *all* CatCLists in this cache; it's too hard to tell
 		 * which searches might still be correct, so just zap 'em all.
 		 */
-		for (elt = DLGetHead(&ccp->cc_lists); elt; elt = nextelt)
+		ilist_d_foreach_modify(elt, nextelt, &ccp->cc_lists)
 		{
-			CatCList   *cl = (CatCList *) DLE_VAL(elt);
-
-			nextelt = DLGetSucc(elt);
+			CatCList   *cl = ilist_container(CatCList, cache_elem, elt);
 
 			if (cl->refcount > 0)
 				cl->dead = true;
@@ -484,12 +487,10 @@ CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 		 * inspect the proper hash bucket for tuple matches
 		 */
 		hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets);
-
-		for (elt = DLGetHead(&ccp->cc_bucket[hashIndex]); elt; elt = nextelt)
+		bucket = &ccp->cc_bucket[hashIndex];
+		ilist_d_foreach_modify(elt, nextelt, bucket)
 		{
-			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
-
-			nextelt = DLGetSucc(elt);
+			CatCTup    *ct = ilist_container(CatCTup, cache_elem, elt);
 
 			if (hashValue == ct->hash_value)
 			{
@@ -561,13 +562,13 @@ AtEOXact_CatCache(bool isCommit)
 
 		for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
 		{
-			Dlelem	   *elt;
+			ilist_d_node *elt;
 			int			i;
 
 			/* Check CatCLists */
-			for (elt = DLGetHead(&ccp->cc_lists); elt; elt = DLGetSucc(elt))
+			ilist_d_foreach(elt, &ccp->cc_lists)
 			{
-				CatCList   *cl = (CatCList *) DLE_VAL(elt);
+				CatCList   *cl = ilist_container(CatCList, cache_elem, elt);
 
 				Assert(cl->cl_magic == CL_MAGIC);
 				Assert(cl->refcount == 0);
@@ -577,11 +578,10 @@ AtEOXact_CatCache(bool isCommit)
 			/* Check individual tuples */
 			for (i = 0; i < ccp->cc_nbuckets; i++)
 			{
-				for (elt = DLGetHead(&ccp->cc_bucket[i]);
-					 elt;
-					 elt = DLGetSucc(elt))
+				ilist_d_head *bucket =  &ccp->cc_bucket[i];
+				ilist_d_foreach(elt, bucket)
 				{
-					CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
+					CatCTup    *ct = ilist_container(CatCTup, cache_elem, elt);
 
 					Assert(ct->ct_magic == CT_MAGIC);
 					Assert(ct->refcount == 0);
@@ -604,16 +604,14 @@ AtEOXact_CatCache(bool isCommit)
 static void
 ResetCatalogCache(CatCache *cache)
 {
-	Dlelem	   *elt,
+	ilist_d_node *elt,
 			   *nextelt;
 	int			i;
 
 	/* Remove each list in this cache, or at least mark it dead */
-	for (elt = DLGetHead(&cache->cc_lists); elt; elt = nextelt)
+	ilist_d_foreach_modify(elt, nextelt, &cache->cc_lists)
 	{
-		CatCList   *cl = (CatCList *) DLE_VAL(elt);
-
-		nextelt = DLGetSucc(elt);
+		CatCList   *cl = ilist_container(CatCList, cache_elem, elt);
 
 		if (cl->refcount > 0)
 			cl->dead = true;
@@ -624,11 +622,10 @@ ResetCatalogCache(CatCache *cache)
 	/* Remove each tuple in this cache, or at least mark it dead */
 	for (i = 0; i < cache->cc_nbuckets; i++)
 	{
-		for (elt = DLGetHead(&cache->cc_bucket[i]); elt; elt = nextelt)
+		ilist_d_head *bucket =  &cache->cc_bucket[i];
+		ilist_d_foreach_modify(elt, nextelt, bucket)
 		{
-			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
-
-			nextelt = DLGetSucc(elt);
+			CatCTup    *ct = ilist_container(CatCTup, cache_elem, elt);
 
 			if (ct->refcount > 0 ||
 				(ct->c_list && ct->c_list->refcount > 0))
@@ -770,10 +767,8 @@ InitCatCache(int id,
 
 	/*
 	 * allocate a new cache structure
-	 *
-	 * Note: we assume zeroing initializes the Dllist headers correctly
 	 */
-	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(Dllist));
+	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(ilist_d_node));
 
 	/*
 	 * initialize the cache's relation information for the relation
@@ -792,6 +787,12 @@ InitCatCache(int id,
 	for (i = 0; i < nkeys; ++i)
 		cp->cc_key[i] = key[i];
 
+	ilist_d_init(&cp->cc_lists);
+
+	for (i = 0; i < nbuckets; i++){
+		ilist_d_init(&cp->cc_bucket[i]);
+	}
+
 	/*
 	 * new cache is initialized as far as we can go for now. print some
 	 * debugging information, if appropriate.
@@ -1060,7 +1061,8 @@ SearchCatCache(CatCache *cache,
 	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
 	uint32		hashValue;
 	Index		hashIndex;
-	Dlelem	   *elt;
+	ilist_d_node *elt;
+	ilist_d_head *bucket;
 	CatCTup    *ct;
 	Relation	relation;
 	SysScanDesc scandesc;
@@ -1094,13 +1096,11 @@ SearchCatCache(CatCache *cache,
 	/*
 	 * scan the hash bucket until we find a match or exhaust our tuples
 	 */
-	for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
-		 elt;
-		 elt = DLGetSucc(elt))
-	{
+	bucket = &cache->cc_bucket[hashIndex];
+	ilist_d_foreach(elt, bucket){
 		bool		res;
 
-		ct = (CatCTup *) DLE_VAL(elt);
+		ct = ilist_container(CatCTup, cache_elem, elt);
 
 		if (ct->dead)
 			continue;			/* ignore dead entries */
@@ -1125,7 +1125,7 @@ SearchCatCache(CatCache *cache,
 		 * most frequently accessed elements in any hashbucket will tend to be
 		 * near the front of the hashbucket's list.)
 		 */
-		DLMoveToFront(&ct->cache_elem);
+		ilist_d_move_head(bucket, &ct->cache_elem);
 
 		/*
 		 * If it's a positive entry, bump its refcount and return it. If it's
@@ -1340,7 +1340,7 @@ SearchCatCacheList(CatCache *cache,
 {
 	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
 	uint32		lHashValue;
-	Dlelem	   *elt;
+	ilist_d_node *elt;
 	CatCList   *cl;
 	CatCTup    *ct;
 	List	   *volatile ctlist;
@@ -1382,13 +1382,11 @@ SearchCatCacheList(CatCache *cache,
 	/*
 	 * scan the items until we find a match or exhaust our list
 	 */
-	for (elt = DLGetHead(&cache->cc_lists);
-		 elt;
-		 elt = DLGetSucc(elt))
+	ilist_d_foreach(elt, &cache->cc_lists)
 	{
 		bool		res;
 
-		cl = (CatCList *) DLE_VAL(elt);
+		cl = ilist_container(CatCList, cache_elem, elt);
 
 		if (cl->dead)
 			continue;			/* ignore dead entries */
@@ -1416,7 +1414,7 @@ SearchCatCacheList(CatCache *cache,
 		 * since there's no point in that unless they are searched for
 		 * individually.)
 		 */
-		DLMoveToFront(&cl->cache_elem);
+		ilist_d_move_head(&cache->cc_lists, &cl->cache_elem);
 
 		/* Bump the list's refcount and return it */
 		ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
@@ -1468,7 +1466,8 @@ SearchCatCacheList(CatCache *cache,
 		{
 			uint32		hashValue;
 			Index		hashIndex;
-
+			bool        found = false;
+			ilist_d_head *bucket;
 			/*
 			 * See if there's an entry for this tuple already.
 			 */
@@ -1476,11 +1475,10 @@ SearchCatCacheList(CatCache *cache,
 			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);
 			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
 
-			for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
-				 elt;
-				 elt = DLGetSucc(elt))
+			bucket = &cache->cc_bucket[hashIndex];
+			ilist_d_foreach(elt, bucket)
 			{
-				ct = (CatCTup *) DLE_VAL(elt);
+				ct = ilist_container(CatCTup, cache_elem, elt);
 
 				if (ct->dead || ct->negative)
 					continue;	/* ignore dead and negative entries */
@@ -1498,10 +1496,11 @@ SearchCatCacheList(CatCache *cache,
 				if (ct->c_list)
 					continue;
 
+				found = true;
 				break;			/* A-OK */
 			}
 
-			if (elt == NULL)
+			if (!found)
 			{
 				/* We didn't find a usable entry, so make a new one */
 				ct = CatalogCacheCreateEntry(cache, ntp,
@@ -1564,7 +1563,6 @@ SearchCatCacheList(CatCache *cache,
 
 	cl->cl_magic = CL_MAGIC;
 	cl->my_cache = cache;
-	DLInitElem(&cl->cache_elem, cl);
 	cl->refcount = 0;			/* for the moment */
 	cl->dead = false;
 	cl->ordered = ordered;
@@ -1587,7 +1585,7 @@ SearchCatCacheList(CatCache *cache,
 	}
 	Assert(i == nmembers);
 
-	DLAddHead(&cache->cc_lists, &cl->cache_elem);
+	ilist_d_push_head(&cache->cc_lists, &cl->cache_elem);
 
 	/* Finally, bump the list's refcount and return it */
 	cl->refcount++;
@@ -1664,14 +1662,14 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp,
 	 */
 	ct->ct_magic = CT_MAGIC;
 	ct->my_cache = cache;
-	DLInitElem(&ct->cache_elem, (void *) ct);
+
 	ct->c_list = NULL;
 	ct->refcount = 0;			/* for the moment */
 	ct->dead = false;
 	ct->negative = negative;
 	ct->hash_value = hashValue;
 
-	DLAddHead(&cache->cc_bucket[hashIndex], &ct->cache_elem);
+	ilist_d_push_head(&cache->cc_bucket[hashIndex], &ct->cache_elem);
 
 	cache->cc_ntup++;
 	CacheHdr->ch_ntup++;
diff --git a/src/include/utils/catcache.h b/src/include/utils/catcache.h
index d91700a..20f2fa8 100644
--- a/src/include/utils/catcache.h
+++ b/src/include/utils/catcache.h
@@ -22,7 +22,7 @@
 
 #include "access/htup.h"
 #include "access/skey.h"
-#include "lib/dllist.h"
+#include "lib/ilist.h"
 #include "utils/relcache.h"
 
 /*
@@ -51,7 +51,7 @@ typedef struct catcache
 	ScanKeyData cc_skey[CATCACHE_MAXKEYS];		/* precomputed key info for
 												 * heap scans */
 	bool		cc_isname[CATCACHE_MAXKEYS];	/* flag "name" key columns */
-	Dllist		cc_lists;		/* list of CatCList structs */
+	ilist_d_head cc_lists;		/* list of CatCList structs */
 #ifdef CATCACHE_STATS
 	long		cc_searches;	/* total # searches against this cache */
 	long		cc_hits;		/* # of matches against existing entry */
@@ -66,7 +66,7 @@ typedef struct catcache
 	long		cc_lsearches;	/* total # list-searches */
 	long		cc_lhits;		/* # of matches against existing lists */
 #endif
-	Dllist		cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
+	ilist_d_head cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
 } CatCache;						/* VARIABLE LENGTH STRUCT */
 
 
@@ -77,11 +77,11 @@ typedef struct catctup
 	CatCache   *my_cache;		/* link to owning catcache */
 
 	/*
-	 * Each tuple in a cache is a member of a Dllist that stores the elements
-	 * of its hash bucket.	We keep each Dllist in LRU order to speed repeated
+	 * Each tuple in a cache is a member of a ilist_d that stores the elements
+	 * of its hash bucket.	We keep each ilist_d in LRU order to speed repeated
 	 * lookups.
 	 */
-	Dlelem		cache_elem;		/* list member of per-bucket list */
+	ilist_d_node cache_elem;		/* list member of per-bucket list */
 
 	/*
 	 * The tuple may also be a member of at most one CatCList.	(If a single
@@ -139,7 +139,7 @@ typedef struct catclist
 	 * might not be true during bootstrap or recovery operations. (namespace.c
 	 * is able to save some cycles when it is true.)
 	 */
-	Dlelem		cache_elem;		/* list member of per-catcache list */
+	ilist_d_node cache_elem;		/* list member of per-catcache list */
 	int			refcount;		/* number of active references */
 	bool		dead;			/* dead but not yet removed? */
 	bool		ordered;		/* members listed in index order? */
-- 
1.7.10.rc3.3.g19a6c.dirty

From 45e2c358e6a21e837f13731981da2644bcb57a88 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Thu, 28 Jun 2012 23:03:44 +0200
Subject: [PATCH] Stop including catcache.h from syscache.h

syscache.h used to not rely on catcache.h and even today ships with the comment
"Users of this must import catcache.h too" for the one function requiring
catcache.h knowledge.

This was changed in a series of commits including:
b85a965f5fc7243d0386085e12f7a6c836503b42
b43ebe5f83b28e06a3fd933b989aeccf0df7844a
e0522505bd13bc5aae993fc50b8f420665d78e96

Change it back.
---
 src/backend/access/transam/xact.c     |    1 +
 src/backend/catalog/namespace.c       |    1 +
 src/backend/catalog/pg_conversion.c   |    1 +
 src/backend/catalog/pg_enum.c         |    1 +
 src/backend/utils/adt/acl.c           |    1 +
 src/backend/utils/cache/attoptcache.c |    1 +
 src/backend/utils/cache/catcache.c    |    1 +
 src/backend/utils/cache/inval.c       |    1 +
 src/backend/utils/cache/lsyscache.c   |    1 +
 src/backend/utils/cache/relcache.c    |    1 +
 src/backend/utils/cache/spccache.c    |    1 +
 src/backend/utils/cache/syscache.c    |    1 +
 src/backend/utils/cache/ts_cache.c    |    1 +
 src/backend/utils/cache/typcache.c    |    1 +
 src/backend/utils/resowner/resowner.c |    5 +++--
 src/include/utils/resowner.h          |   10 ++++++----
 src/include/utils/snapmgr.h           |    1 +
 src/include/utils/syscache.h          |    2 +-
 18 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
index 4755ee6..1f743f7 100644
--- a/src/backend/access/transam/xact.c
+++ b/src/backend/access/transam/xact.c
@@ -44,6 +44,7 @@
 #include "storage/procarray.h"
 #include "storage/sinvaladt.h"
 #include "storage/smgr.h"
+#include "utils/catcache.h"
 #include "utils/combocid.h"
 #include "utils/guc.h"
 #include "utils/inval.h"
diff --git a/src/backend/catalog/namespace.c b/src/backend/catalog/namespace.c
index 20850ab..10ad82b 100644
--- a/src/backend/catalog/namespace.c
+++ b/src/backend/catalog/namespace.c
@@ -46,6 +46,7 @@
 #include "storage/sinval.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
+#include "utils/catcache.h"
 #include "utils/guc.h"
 #include "utils/inval.h"
 #include "utils/lsyscache.h"
diff --git a/src/backend/catalog/pg_conversion.c b/src/backend/catalog/pg_conversion.c
index f86c84f..358bd39 100644
--- a/src/backend/catalog/pg_conversion.c
+++ b/src/backend/catalog/pg_conversion.c
@@ -25,6 +25,7 @@
 #include "catalog/pg_proc.h"
 #include "mb/pg_wchar.h"
 #include "utils/builtins.h"
+#include "utils/catcache.h"
 #include "utils/fmgroids.h"
 #include "utils/rel.h"
 #include "utils/syscache.h"
diff --git a/src/backend/catalog/pg_enum.c b/src/backend/catalog/pg_enum.c
index 41665c1..20e26c4 100644
--- a/src/backend/catalog/pg_enum.c
+++ b/src/backend/catalog/pg_enum.c
@@ -23,6 +23,7 @@
 #include "storage/lmgr.h"
 #include "miscadmin.h"
 #include "utils/builtins.h"
+#include "utils/catcache.h"
 #include "utils/fmgroids.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
diff --git a/src/backend/utils/adt/acl.c b/src/backend/utils/adt/acl.c
index 77322a1..2cc87d8 100644
--- a/src/backend/utils/adt/acl.c
+++ b/src/backend/utils/adt/acl.c
@@ -29,6 +29,7 @@
 #include "miscadmin.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
+#include "utils/catcache.h"
 #include "utils/inval.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
diff --git a/src/backend/utils/cache/attoptcache.c b/src/backend/utils/cache/attoptcache.c
index e01ae21..5d872ba 100644
--- a/src/backend/utils/cache/attoptcache.c
+++ b/src/backend/utils/cache/attoptcache.c
@@ -18,6 +18,7 @@
 
 #include "access/reloptions.h"
 #include "utils/attoptcache.h"
+#include "utils/catcache.h"
 #include "utils/hsearch.h"
 #include "utils/inval.h"
 #include "utils/syscache.h"
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index 0307b96..f27d90d 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -29,6 +29,7 @@
 #endif
 #include "storage/lmgr.h"
 #include "utils/builtins.h"
+#include "utils/catcache.h"
 #include "utils/fmgroids.h"
 #include "utils/inval.h"
 #include "utils/memutils.h"
diff --git a/src/backend/utils/cache/inval.c b/src/backend/utils/cache/inval.c
index 34802ee..15b1711 100644
--- a/src/backend/utils/cache/inval.c
+++ b/src/backend/utils/cache/inval.c
@@ -100,6 +100,7 @@
 #include "miscadmin.h"
 #include "storage/sinval.h"
 #include "storage/smgr.h"
+#include "utils/catcache.h"
 #include "utils/inval.h"
 #include "utils/memutils.h"
 #include "utils/rel.h"
diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c
index 64b413b..0e479e8 100644
--- a/src/backend/utils/cache/lsyscache.c
+++ b/src/backend/utils/cache/lsyscache.c
@@ -33,6 +33,7 @@
 #include "nodes/makefuncs.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
+#include "utils/catcache.h"
 #include "utils/datum.h"
 #include "utils/fmgroids.h"
 #include "utils/lsyscache.h"
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 2e6776e..8d7e766 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -64,6 +64,7 @@
 #include "storage/smgr.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
+#include "utils/catcache.h"
 #include "utils/fmgroids.h"
 #include "utils/inval.h"
 #include "utils/lsyscache.h"
diff --git a/src/backend/utils/cache/spccache.c b/src/backend/utils/cache/spccache.c
index cf18ee1..0b8cc39 100644
--- a/src/backend/utils/cache/spccache.c
+++ b/src/backend/utils/cache/spccache.c
@@ -23,6 +23,7 @@
 #include "commands/tablespace.h"
 #include "miscadmin.h"
 #include "optimizer/cost.h"
+#include "utils/catcache.h"
 #include "utils/hsearch.h"
 #include "utils/inval.h"
 #include "utils/spccache.h"
diff --git a/src/backend/utils/cache/syscache.c b/src/backend/utils/cache/syscache.c
index c365ec7..bf96678 100644
--- a/src/backend/utils/cache/syscache.c
+++ b/src/backend/utils/cache/syscache.c
@@ -54,6 +54,7 @@
 #include "catalog/pg_ts_template.h"
 #include "catalog/pg_type.h"
 #include "catalog/pg_user_mapping.h"
+#include "utils/catcache.h"
 #include "utils/rel.h"
 #include "utils/syscache.h"
 
diff --git a/src/backend/utils/cache/ts_cache.c b/src/backend/utils/cache/ts_cache.c
index b408de0..b369790 100644
--- a/src/backend/utils/cache/ts_cache.c
+++ b/src/backend/utils/cache/ts_cache.c
@@ -39,6 +39,7 @@
 #include "commands/defrem.h"
 #include "tsearch/ts_cache.h"
 #include "utils/builtins.h"
+#include "utils/catcache.h"
 #include "utils/fmgroids.h"
 #include "utils/inval.h"
 #include "utils/lsyscache.h"
diff --git a/src/backend/utils/cache/typcache.c b/src/backend/utils/cache/typcache.c
index 72798ef..8726dba 100644
--- a/src/backend/utils/cache/typcache.c
+++ b/src/backend/utils/cache/typcache.c
@@ -55,6 +55,7 @@
 #include "catalog/pg_type.h"
 #include "commands/defrem.h"
 #include "utils/builtins.h"
+#include "utils/catcache.h"
 #include "utils/fmgroids.h"
 #include "utils/inval.h"
 #include "utils/lsyscache.h"
diff --git a/src/backend/utils/resowner/resowner.c b/src/backend/utils/resowner/resowner.c
index 3ded469..f7a658f 100644
--- a/src/backend/utils/resowner/resowner.c
+++ b/src/backend/utils/resowner/resowner.c
@@ -23,6 +23,7 @@
 #include "access/hash.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "utils/catcache.h"
 #include "utils/memutils.h"
 #include "utils/rel.h"
 #include "utils/snapmgr.h"
@@ -787,7 +788,7 @@ ResourceOwnerEnlargeCatCacheListRefs(ResourceOwner owner)
  * Caller must have previously done ResourceOwnerEnlargeCatCacheListRefs()
  */
 void
-ResourceOwnerRememberCatCacheListRef(ResourceOwner owner, CatCList *list)
+ResourceOwnerRememberCatCacheListRef(ResourceOwner owner, struct catclist *list)
 {
 	Assert(owner->ncatlistrefs < owner->maxcatlistrefs);
 	owner->catlistrefs[owner->ncatlistrefs] = list;
@@ -798,7 +799,7 @@ ResourceOwnerRememberCatCacheListRef(ResourceOwner owner, CatCList *list)
  * Forget that a catcache-list reference is owned by a ResourceOwner
  */
 void
-ResourceOwnerForgetCatCacheListRef(ResourceOwner owner, CatCList *list)
+ResourceOwnerForgetCatCacheListRef(ResourceOwner owner, struct catclist *list)
 {
 	CatCList  **catlistrefs = owner->catlistrefs;
 	int			nc1 = owner->ncatlistrefs - 1;
diff --git a/src/include/utils/resowner.h b/src/include/utils/resowner.h
index e1c992e..30c8444 100644
--- a/src/include/utils/resowner.h
+++ b/src/include/utils/resowner.h
@@ -21,10 +21,9 @@
 
 #include "storage/fd.h"
 #include "storage/lock.h"
-#include "utils/catcache.h"
 #include "utils/plancache.h"
 #include "utils/snapshot.h"
-
+#include "utils/relcache.h"
 
 /*
  * ResourceOwner objects are an opaque data structure known only within
@@ -64,6 +63,8 @@ typedef void (*ResourceReleaseCallback) (ResourceReleasePhase phase,
 													 bool isTopLevel,
 													 void *arg);
 
+/* forward declare to avoid including catcache.h everywhere */
+struct catclist;
 
 /*
  * Functions in resowner.c
@@ -101,10 +102,11 @@ extern void ResourceOwnerRememberCatCacheRef(ResourceOwner owner,
 extern void ResourceOwnerForgetCatCacheRef(ResourceOwner owner,
 							   HeapTuple tuple);
 extern void ResourceOwnerEnlargeCatCacheListRefs(ResourceOwner owner);
+/* Users of these must import catcache.h too */
 extern void ResourceOwnerRememberCatCacheListRef(ResourceOwner owner,
-									 CatCList *list);
+									 struct catclist *list);
 extern void ResourceOwnerForgetCatCacheListRef(ResourceOwner owner,
-								   CatCList *list);
+								   struct catclist *list);
 
 /* support for relcache refcount management */
 extern void ResourceOwnerEnlargeRelationRefs(ResourceOwner owner);
diff --git a/src/include/utils/snapmgr.h b/src/include/utils/snapmgr.h
index f195981..54bf602 100644
--- a/src/include/utils/snapmgr.h
+++ b/src/include/utils/snapmgr.h
@@ -13,6 +13,7 @@
 #ifndef SNAPMGR_H
 #define SNAPMGR_H
 
+#include "fmgr.h"
 #include "utils/resowner.h"
 
 
diff --git a/src/include/utils/syscache.h b/src/include/utils/syscache.h
index d59dd4e..37dc9ed 100644
--- a/src/include/utils/syscache.h
+++ b/src/include/utils/syscache.h
@@ -16,7 +16,7 @@
 #ifndef SYSCACHE_H
 #define SYSCACHE_H
 
-#include "utils/catcache.h"
+#include "access/htup.h"
 
 /*
  *		SysCache identifiers.
-- 
1.7.10.rc3.3.g19a6c.dirty

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 2e1061e..c94297a 100644
*** a/src/backend/lib/Makefile
--- b/src/backend/lib/Makefile
***************
*** 12,17 **** subdir = src/backend/lib
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = dllist.o stringinfo.o
  
  include $(top_srcdir)/src/backend/common.mk
--- 12,17 ----
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = dllist.o stringinfo.o ilist.o
  
  include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/REnew file mode 100644
index 0000000..3a3d8a8
*** /dev/null
--- b/src/backend/lib/README.ilist
***************
*** 0 ****
--- 1,43 ----
+ his is intended to be used in the following manner:
+ 
+ #include "lib/ilist.h"
+ 
+ typedef struct something_in_a_list
+ {
+ 	int value;
+ 	int somethingelse;
+ 	Dlist_head values;
+ } something_in_a_list;
+ 
+ typedef struct value_in_a_list
+ {
+ 	int data;
+ 	int somethingelse;
+ 	Dlist_node list_node;
+ } value_in_a_list;
+ 
+ something_in_a_list *somelist = get_blarg();
+ 
+ Dlist_push_head(somelist, &get_value_in_a_list()->list_node);
+ ...
+ Dlist_push_head(somelist, &get_value_in_a_list()->list_node);
+ ...
+ ...
+ Dlist_node *node,
+ 		   *next;
+ 
+ Dlist_foreach(node, somelist)
+ {
+ 	value_in_a_list *val = ilist_container(value_in_a_list, list_node, node);
+ 	do_something_with_val(val);
+ }
+ 
+ Dlist_foreach_modify(node, next, somelist)
+ {
+ 	/*
+ 	 * here we can inspect the node and maybe delete it.  Any other
+ 	 * manipulation is forbidden.
+ 	 */
+ 	if (node is to be deleted)
+ 		Dlist_delete(node);
+ }
diff --git a/src/backend/lib/ilist.new file mode 100644
index 0000000..239c538
*** /dev/null
--- b/src/backend/lib/ilist.c
***************
*** 0 ****
--- 1,117 ----
+ /*-------------------------------------------------------------------------
+  *
+  * ilist.c
+  *	  support for integrated/inline doubly- and singly- linked lists
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *
+  * IDENTIFICATION
+  *	  src/backend/lib/ilist.c
+  *
+  * NOTES
+  *	  This file only contains functions that are too big to be considered
+  *	  for inlining.  See ilist.h for most of the goodies.
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ /*
+  * If inlines are in use, include the header normally which will get us only
+  * the function definitions as inlines.  But if inlines aren't available,
+  * include the header with ILIST_USE_DEFINITION defined; this makes it pour in
+  * regular (not inline) function declarations and their definitions.
+  */
+ #ifdef USE_INLINE
+ #include "lib/ilist.h"
+ #else /* USE_INLINE */
+ #define ILIST_USE_DEFINITION
+ #include "lib/ilist.h"
+ #undef ILIST_USE_DEFINITION
+ #endif
+ 
+ /*
+  * removes a node from a list
+  *
+  * Attention: O(n)
+  */
+ void
+ Slist_delete(Slist_head *head, Slist_node *node)
+ {
+ 	Slist_node *last = &head->head;
+ 	Slist_node *cur;
+ 	bool		found PG_USED_FOR_ASSERTS_ONLY = false;
+ 
+ 	while ((cur = last->next) != NULL)
+ 	{
+ 		if (cur == node)
+ 		{
+ 			last->next = cur->next;
+ #ifdef USE_ASSERT_CHECKING
+ 			found = true;
+ #endif
+ 			break;
+ 		}
+ 		last = cur;
+ 	}
+ 
+ 	Slist_check(head);
+ 	Assert(found);
+ }
+ 
+ #ifdef ILIST_DEBUG
+ /*
+  * Verify integrity of a doubly linked list
+  */
+ void
+ Dlist_check(Dlist_head *head)
+ {
+ 	Dlist_node *cur;
+ 
+ 	if (!head || !(&head->head))
+ 		elog(ERROR, "doubly linked list head is not properly initialized");
+ 
+ 	for (cur = head->head.next; cur != &head->head; cur = cur->next)
+ 	{
+ 		if (!(cur) ||
+ 			!(cur->next) ||
+ 			!(cur->prev) ||
+ 			!(cur->prev->next == cur) ||
+ 			!(cur->next->prev == cur))
+ 			elog(ERROR, "doubly linked list is corrupted");
+ 	}
+ 
+ 	for (cur = head->head.prev; cur != &head->head; cur = cur->prev)
+ 	{
+ 		if (!(cur) ||
+ 			!(cur->next) ||
+ 			!(cur->prev) ||
+ 			!(cur->prev->next == cur) ||
+ 			!(cur->next->prev == cur))
+ 			elog(ERROR, "doubly linked list is corrupted");
+ 	}
+ }
+ 
+ /*
+  * Verify integrity of a singly linked list
+  */
+ void
+ Slist_check(Slist_head *head)
+ {
+ 	Slist_node *cur;
+ 
+ 	if (!head || !(&head->head))
+ 		elog(ERROR, "singly linked list head is not properly initialized");
+ 
+ 	/*
+ 	 * there isn't much we can test in a singly linked list except that its
+ 	 * really circular
+ 	 */
+ 	for (cur = head->head.next; cur != &head->head; cur = cur->next)
+ 		if (!cur)
+ 			elog(ERROR, "singly linked list is corrupted");
+ }
+ 
+ #endif   /* ILIST_DEBUG */
diff --git a/src/include/lib/inew file mode 100644
index 0000000..27c5dba
*** /dev/null
--- b/src/include/lib/ilist.h
***************
*** 0 ****
--- 1,453 ----
+ /*-------------------------------------------------------------------------
+  *
+  * ilist.h
+  *		integrated/inline doubly- and singly-linked lists
+  *
+  * This implementation is as efficient as possible: the lists don't have
+  * any memory management overhead, because the list pointers are embedded
+  * within some larger structure.  Also, they are always circularly linked, even
+  * when empty; this enables many manipulations to be done without branches,
+  * which is beneficial performance-wise.
+  *
+  * See src/backend/lib/README.ilist for intended usage.
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  * IDENTIFICATION
+  *		src/include/lib/ilist.h
+  *-------------------------------------------------------------------------
+  */
+ #ifndef ILIST_H
+ #define ILIST_H
+ 
+ /*
+  * enable for extra debugging. This is rather expensive, so it's not enabled by
+  * default even with --enable-cassert.
+ */
+ #undef ILIST_DEBUG
+ 
+ /*
+  * gcc warns about unused parameters if -Wunused-parameter is specified (part
+  * of -Wextra). In the cases below its perfectly fine not to use those
+  * parameters because they are just passed to make the interface consistent and
+  * to allow debugging in case of ILIST_DEBUG.
+  *
+  * FIXME -- this should be part of c.h.
+  */
+ #ifdef __GNUC__
+ #define unused_attr __attribute__((unused))
+ #else
+ #define unused_attr
+ #endif
+ 
+ /*
+  * struct to embed in other structs that need to be part of a doubly linked
+  * list.
+  */
+ typedef struct Dlist_node Dlist_node;
+ struct Dlist_node
+ {
+ 	Dlist_node *prev;
+ 	Dlist_node *next;
+ };
+ 
+ /*
+  * Head of a doubly linked list.
+  *
+  * Lists are internally *always* circularly linked, even when empty.
+  */
+ typedef struct Dlist_head
+ {
+ 	Dlist_node	head;
+ } Dlist_head;
+ 
+ /*
+  * struct to embed in other structs that need to be part of a singly linked
+  * list.
+  */
+ typedef struct Slist_node Slist_node;
+ struct Slist_node
+ {
+ 	Slist_node *next;
+ };
+ 
+ /*
+  * Head of a singly linked list.
+  *
+  * Lists are internally *always* circularly linked, even when empty.
+  */
+ typedef struct Slist_head
+ {
+ 	Slist_node	head;
+ } Slist_head;
+ 
+ #ifdef USE_INLINE
+ #define INLINE_IF_POSSIBLE static inline
+ #define ILIST_USE_DEFINITION
+ #else
+ #define INLINE_IF_POSSIBLE
+ 
+ /* Prototypes for functions we want to be inlined if possible */
+ extern void Dlist_check(unused_attr Dlist_head *head);
+ extern void Dlist_init(Dlist_head *head);
+ extern void Dlist_push_head(Dlist_head *head, Dlist_node *node);
+ extern void Dlist_push_tail(Dlist_head *head, Dlist_node *node);
+ extern void Dlist_insert_after(unused_attr Dlist_head *head,
+ 				   Dlist_node *after, Dlist_node *node);
+ extern void Dlist_insert_before(unused_attr Dlist_head *head,
+ 					Dlist_node *before, Dlist_node *node);
+ extern void Dlist_delete(unused_attr Dlist_head *head, Dlist_node *node);
+ extern Dlist_node *Dlist_pop_head(Dlist_head *head);
+ extern void Dlist_move_head(Dlist_head *head, Dlist_node *node);
+ extern bool Dlist_has_next(Dlist_head *head, Dlist_node *node);
+ extern bool Dlist_has_prev(Dlist_head *head, Dlist_node *node);
+ extern bool Dlist_is_empty(Dlist_head *head);
+ extern void Dlist_check(Dlist_head *head);
+ 
+ extern void Slist_init(Slist_head *head);
+ extern void Slist_push_head(Slist_head *head, Slist_node *node);
+ extern Slist_node *Slist_pop_head(Slist_head *head);
+ extern void Slist_insert_after(unused_attr Slist_head *head,
+ 				   Slist_node *after, Slist_node *node);
+ extern bool Slist_is_empty(Slist_head *head);
+ extern bool Slist_has_next(unused_attr Slist_head *head,
+ 			   Slist_node *node);
+ #endif   /* USE_INLINE */
+ 
+ /* These functions are too big to be inline, so they are in the C file always */
+ extern void Slist_delete(Slist_head *head, Slist_node *node);
+ 
+ #ifdef ILIST_DEBUG
+ extern void Dlist_check(Dlist_head *head);
+ extern void Slist_check(Slist_head *head);
+ #else
+ #define Dlist_check(head)
+ #define Slist_check(head)
+ #endif   /* ILIST_DEBUG */
+ 
+ /*
+  * Return a pointer to the struct 'type' when the passed 'ptr' points to the
+  * element 'membername'.
+  */
+ #define ilist_container(type, membername, ptr)								\
+ 	((type*)((char*)(ptr) - offsetof(type, membername)))
+ 
+ /*
+  * The following function definitions are only used if inlining is supported by
+  * the compiler, or when included from a file that explicitly declares
+  * ILIST_USE_DEFINITION.
+  */
+ #ifdef ILIST_USE_DEFINITION
+ 
+ /*
+  * Initialize the head of a list. Previous state will be thrown away without
+  * any cleanup.
+  */
+ INLINE_IF_POSSIBLE void
+ Dlist_init(Dlist_head *head)
+ {
+ 	head->head.next = head->head.prev = &head->head;
+ 
+ 	Dlist_check(head);
+ }
+ 
+ /*
+  * inserts a node at the beginning of the list
+  */
+ INLINE_IF_POSSIBLE void
+ Dlist_push_head(Dlist_head *head, Dlist_node *node)
+ {
+ 	node->next = head->head.next;
+ 	node->prev = &head->head;
+ 	node->next->prev = node;
+ 	head->head.next = node;
+ 
+ 	Dlist_check(head);
+ }
+ 
+ /*
+  * inserts a node at the end of the list
+  */
+ INLINE_IF_POSSIBLE void
+ Dlist_push_tail(Dlist_head *head, Dlist_node *node)
+ {
+ 	node->next = &head->head;
+ 	node->prev = head->head.prev;
+ 	node->prev->next = node;
+ 	head->head.prev = node;
+ 
+ 	Dlist_check(head);
+ }
+ 
+ /*
+  * insert a node after another *in the same list*
+  */
+ INLINE_IF_POSSIBLE void
+ Dlist_insert_after(unused_attr Dlist_head *head, Dlist_node *after,
+ 				   Dlist_node *node)
+ {
+ 	Dlist_check(head);
+ 
+ 	node->prev = after;
+ 	node->next = after->next;
+ 	after->next = node;
+ 	node->next->prev = node;
+ 
+ 	Dlist_check(head);
+ }
+ 
+ /*
+  * insert a node after another *in the same list*
+  */
+ INLINE_IF_POSSIBLE void
+ Dlist_insert_before(unused_attr Dlist_head *head, Dlist_node *before,
+ 					Dlist_node *node)
+ {
+ 	Dlist_check(head);
+ 
+ 	node->prev = before->prev;
+ 	node->next = before;
+ 	before->prev = node;
+ 	node->prev->next = node;
+ 
+ 	Dlist_check(head);
+ }
+ 
+ /*
+  * deletes a node from a list
+  */
+ INLINE_IF_POSSIBLE void
+ Dlist_delete(unused_attr Dlist_head *head, Dlist_node *node)
+ {
+ 	Dlist_check(head);
+ 
+ 	node->prev->next = node->next;
+ 	node->next->prev = node->prev;
+ 
+ 	Dlist_check(head);
+ }
+ 
+ /*
+  * deletes the first node from a list or returns NULL
+  */
+ INLINE_IF_POSSIBLE Dlist_node *
+ Dlist_pop_head(Dlist_head *head)
+ {
+ 	Dlist_node *ret;
+ 
+ 	if (&head->head == head->head.next)
+ 		return NULL;
+ 
+ 	ret = head->head.next;
+ 	Dlist_delete(head, head->head.next);
+ 	return ret;
+ }
+ 
+ /*
+  * moves an element (that has to be in the list) to the head of the list
+  */
+ INLINE_IF_POSSIBLE void
+ Dlist_move_head(Dlist_head *head, Dlist_node *node)
+ {
+ 	/* fast path if it's already at the head */
+ 	if (&head->head == node)
+ 		return;
+ 
+ 	Dlist_delete(head, node);
+ 	Dlist_push_head(head, node);
+ 
+ 	Dlist_check(head);
+ }
+ 
+ /*
+  * Check whether the passed node is the last element in the list
+  */
+ INLINE_IF_POSSIBLE bool
+ Dlist_has_next(Dlist_head *head, Dlist_node *node)
+ {
+ 	return node->next != &head->head;
+ }
+ 
+ /*
+  * Check whether the passed node is the first element in the list
+  */
+ INLINE_IF_POSSIBLE bool
+ Dlist_has_prev(Dlist_head *head, Dlist_node *node)
+ {
+ 	return node->prev != &head->head;
+ }
+ 
+ /*
+  * Check whether the list is empty.
+  */
+ INLINE_IF_POSSIBLE bool
+ Dlist_is_empty(Dlist_head *head)
+ {
+ 	return head->head.next == head->head.prev;
+ }
+ #endif   /* ILIST_USE_DEFINITION */
+ 
+ /*
+  * Return the value of first element in the list if there is one, return NULL
+  * otherwise.
+  *
+  * ptr *will* be evaluated multiple times.
+  */
+ #define Dlist_head(type, membername, ptr)									\
+ (																			\
+ 	(&((ptr)->head) == (ptr)->head.next) ?									\
+ 		NULL : ilist_container(type, membername, (ptr)->head.next)			\
+ )
+ 
+ /*
+  * Return the value of the first element. This will return corrupt data if
+  * there is no element in the list.
+  */
+ #define Dlist_head_unchecked(type, membername, ptr)							\
+ 	ilist_container(type, membername, (ptr)->head.next)
+ 
+ /*
+  * Return the value of the last element in the list if there is one, return
+  * NULL otherwise.
+  *
+  * ptr *will* be evaluated multiple times.
+  */
+ #define Dlist_tail(type, membername, ptr)									\
+ (																			\
+ 	(&((ptr)->head) == (ptr)->head.prev) ?									\
+ 		NULL : ilist_container(type, membername, (ptr)->head.prev)			\
+ )
+ 
+ /*
+  * Iterate through the list storing the current element in the variable
+  * 'name'. 'ptr' will be evaluated repeatedly.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define Dlist_foreach(name, ptr)											\
+ 	for (name = (ptr)->head.next; name != &(ptr)->head; name = name->next)
+ 
+ /*
+  * Iterate through the list storing the current element in the variable 'name'
+  * and also storing the next list element in the variable 'nxt'.
+  *
+  * It is allowed to delete the current element from the list. Every other
+  * manipulation can lead to corruption.
+  */
+ #define Dlist_foreach_modify(name, nxt, ptr)								\
+ 	for (name = (ptr)->head.next, nxt = name->next;							\
+ 		 name != &(ptr)->head;												\
+ 		 name = nxt, nxt = name->next)
+ 
+ /*
+  * Iterate through the list in reverse order storing the current element in the
+  * variable 'name'. 'ptr' will be evaluated repeatedly.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define Dlist_reverse_foreach(name, ptr)									\
+ 	for (name = (ptr)->head.prev; name != &(ptr)->head; name = name->prev)
+ 
+ 
+ #ifdef ILIST_USE_DEFINITION
+ 
+ /*
+  * Initialize a singly linked list.
+  */
+ INLINE_IF_POSSIBLE void
+ Slist_init(Slist_head *head)
+ {
+ 	head->head.next = NULL;
+ 
+ 	Slist_check(head);
+ }
+ 
+ /*
+  * Install a new element as head of the list, pushing the original head to the
+  * second position.
+  */
+ INLINE_IF_POSSIBLE void
+ Slist_push_head(Slist_head *head, Slist_node *node)
+ {
+ 	node->next = head->head.next;
+ 	head->head.next = node;
+ 
+ 	Slist_check(head);
+ }
+ 
+ /*
+  * Returns the first element of the list, removing it.
+  * Fails if the list is empty
+  */
+ INLINE_IF_POSSIBLE Slist_node *
+ Slist_pop_head(Slist_head *head)
+ {
+ 	Slist_node *node;
+ 
+ 	node = head->head.next;
+ 	head->head.next = head->head.next->next;
+ 
+ 	Slist_check(head);
+ 
+ 	return node;
+ }
+ 
+ /*
+  * Insert a new element after the listed one.
+  */
+ INLINE_IF_POSSIBLE void
+ Slist_insert_after(unused_attr Slist_head *head, Slist_node *after,
+ 				   Slist_node *node)
+ {
+ 	node->next = after->next;
+ 	after->next = node;
+ 
+ 	Slist_check(head);
+ }
+ 
+ /*
+  * Is the list empty?
+  */
+ INLINE_IF_POSSIBLE bool
+ Slist_is_empty(Slist_head *head)
+ {
+ 	return head->head.next == NULL;
+ }
+ 
+ /*
+  * Is there at least one more element in the list?
+  */
+ INLINE_IF_POSSIBLE bool
+ Slist_has_next(unused_attr Slist_head *head,
+ 			   Slist_node *node)
+ {
+ 	return node->next != NULL;
+ }
+ #endif   /* ILIST_USE_DEFINITION */
+ 
+ #define Slist_get_head(type, membername, ptr)								\
+ (																			\
+ 	Slist_is_empty(ptr) ? NULL :											\
+ 		ilist_container(type, membername, (ptr).next) 						\
+ )
+ 
+ #define Slist_get_head_unchecked(type, membername, ptr)						\
+ 	ilist_container(type, membername, (ptr)->head.next)
+ 
+ #define Slist_foreach(name, ptr)											\
+ 	for (name = (ptr)->head.next; name != NULL; name = name->next)
+ 
+ #define Slist_foreach_modify(name, nxt, ptr)								\
+ 	for (name = (ptr)->head.next, nxt = name ? name->next : NULL;			\
+ 		name != NULL;														\
+ 		name = nxt, nxt = name ? name->next : NULL)
+ 
+ /*
+  * Get rid of ILIST_USE_DEFINITION; it's not interesting outside this file.
+  */
+ #ifdef USE_INLINE
+ #undef ILIST_USE_DEFINITION
+ #endif
+ 
+ #endif   /* ILIST_H */
diff --git a/src/tools/pgindenindex a831a1e..0aa3e3c 100644

From 5f72be6b33b43f9615700305e469e3e3698417dd Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Tue, 4 Sep 2012 19:07:38 -0300
Subject: [PATCH 1/3] initial ilist stuff from Andres

---
 src/backend/lib/Makefile     |    2 +-
 src/backend/lib/README.ilist |   43 ++++
 src/backend/lib/ilist.c      |  115 +++++++++++
 src/include/lib/ilist.h      |  454 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 613 insertions(+), 1 deletions(-)
 create mode 100644 src/backend/lib/README.ilist
 create mode 100644 src/backend/lib/ilist.c
 create mode 100644 src/include/lib/ilist.h

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 2e1061e..c94297a 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/lib
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = dllist.o stringinfo.o
+OBJS = dllist.o stringinfo.o ilist.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/README.ilist b/src/backend/lib/README.ilist
new file mode 100644
index 0000000..3a3d8a8
--- /dev/null
+++ b/src/backend/lib/README.ilist
@@ -0,0 +1,43 @@
+his is intended to be used in the following manner:
+
+#include "lib/ilist.h"
+
+typedef struct something_in_a_list
+{
+	int value;
+	int somethingelse;
+	Dlist_head values;
+} something_in_a_list;
+
+typedef struct value_in_a_list
+{
+	int data;
+	int somethingelse;
+	Dlist_node list_node;
+} value_in_a_list;
+
+something_in_a_list *somelist = get_blarg();
+
+Dlist_push_head(somelist, &get_value_in_a_list()->list_node);
+...
+Dlist_push_head(somelist, &get_value_in_a_list()->list_node);
+...
+...
+Dlist_node *node,
+		   *next;
+
+Dlist_foreach(node, somelist)
+{
+	value_in_a_list *val = ilist_container(value_in_a_list, list_node, node);
+	do_something_with_val(val);
+}
+
+Dlist_foreach_modify(node, next, somelist)
+{
+	/*
+	 * here we can inspect the node and maybe delete it.  Any other
+	 * manipulation is forbidden.
+	 */
+	if (node is to be deleted)
+		Dlist_delete(node);
+}
diff --git a/src/backend/lib/ilist.c b/src/backend/lib/ilist.c
new file mode 100644
index 0000000..d8bd4f3
--- /dev/null
+++ b/src/backend/lib/ilist.c
@@ -0,0 +1,115 @@
+/*-------------------------------------------------------------------------
+ *
+ * ilist.c
+ *	  support for integrated/inline doubly- and singly- linked lists
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/lib/ilist.c
+ *
+ * NOTES
+ *	  This file only contains functions that are too big to be considered
+ *	  for inlining.  See ilist.h for most of the goodies.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+/*
+ * If inlines are in use, include the header normally which will get us only
+ * the function definitions as inlines.  But if inlines aren't available,
+ * include the header with ILIST_USE_DEFINITION defined; this makes it pour in
+ * regular (not inline) function declarations and the corresponding (non
+ * inline) definitions.
+ */
+#ifndef USE_INLINE
+#define ILIST_USE_DEFINITION
+#endif
+#include "lib/ilist.h"
+
+/*
+ * removes a node from a list
+ *
+ * Attention: O(n)
+ */
+void
+slist_delete(slist_head *head, slist_node *node)
+{
+	slist_node *last = &head->head;
+	slist_node *cur;
+	bool		found PG_USED_FOR_ASSERTS_ONLY = false;
+
+	while ((cur = last->next) != NULL)
+	{
+		if (cur == node)
+		{
+			last->next = cur->next;
+#ifdef USE_ASSERT_CHECKING
+			found = true;
+#endif
+			break;
+		}
+		last = cur;
+	}
+
+	slist_check(head);
+	Assert(found);
+}
+
+#ifdef ILIST_DEBUG
+/*
+ * Verify integrity of a doubly linked list
+ */
+void
+dlist_check(dlist_head *head)
+{
+	dlist_node *cur;
+
+	if (!head || !(&head->head))
+		elog(ERROR, "doubly linked list head is not properly initialized");
+
+	for (cur = head->head.next; cur != &head->head; cur = cur->next)
+	{
+		if (!(cur) ||
+			!(cur->next) ||
+			!(cur->prev) ||
+			!(cur->prev->next == cur) ||
+			!(cur->next->prev == cur))
+			elog(ERROR, "doubly linked list is corrupted");
+	}
+
+	for (cur = head->head.prev; cur != &head->head; cur = cur->prev)
+	{
+		if (!(cur) ||
+			!(cur->next) ||
+			!(cur->prev) ||
+			!(cur->prev->next == cur) ||
+			!(cur->next->prev == cur))
+			elog(ERROR, "doubly linked list is corrupted");
+	}
+}
+
+/*
+ * Verify integrity of a singly linked list
+ */
+void
+slist_check(slist_head *head)
+{
+	slist_node *cur;
+
+	if (!head || !(&head->head))
+		elog(ERROR, "singly linked list head is not properly initialized");
+
+	/*
+	 * there isn't much we can test in a singly linked list except that its
+	 * really circular
+	 */
+	for (cur = head->head.next; cur != &head->head; cur = cur->next)
+		if (!cur)
+			elog(ERROR, "singly linked list is corrupted");
+}
+
+#endif   /* ILIST_DEBUG */
diff --git a/src/include/lib/ilist.h b/src/include/lib/ilist.h
new file mode 100644
index 0000000..2c29902
--- /dev/null
+++ b/src/include/lib/ilist.h
@@ -0,0 +1,454 @@
+/*-------------------------------------------------------------------------
+ *
+ * ilist.h
+ *		integrated/inline doubly- and singly-linked lists
+ *
+ * This implementation is as efficient as possible: the lists don't have
+ * any memory management overhead, because the list pointers are embedded
+ * within some larger structure.  Also, they are always circularly linked, even
+ * when empty; this enables many manipulations to be done without branches,
+ * which is beneficial performance-wise.
+ *
+ * See src/backend/lib/README.ilist for intended usage.
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *		src/include/lib/ilist.h
+ *-------------------------------------------------------------------------
+ */
+#ifndef ILIST_H
+#define ILIST_H
+
+/*
+ * enable for extra debugging. This is rather expensive, so it's not enabled by
+ * default even with --enable-cassert.
+*/
+#undef ILIST_DEBUG
+
+/*
+ * struct to embed in other structs that need to be part of a doubly linked
+ * list.
+ */
+typedef struct dlist_node dlist_node;
+struct dlist_node
+{
+	dlist_node *prev;
+	dlist_node *next;
+};
+
+/*
+ * Head of a doubly linked list.
+ *
+ * Lists are internally *always* circularly linked, even when empty.
+ */
+typedef struct dlist_head
+{
+	dlist_node	head;
+} dlist_head;
+
+/*
+ * struct to embed in other structs that need to be part of a singly linked
+ * list.
+ */
+typedef struct slist_node slist_node;
+struct slist_node
+{
+	slist_node *next;
+};
+
+/*
+ * Head of a singly linked list.
+ *
+ * Lists are internally *always* circularly linked, even when empty.
+ */
+typedef struct slist_head
+{
+	slist_node	head;
+} slist_head;
+
+#ifdef USE_INLINE
+#define INLINE_IF_POSSIBLE static inline
+#define ILIST_USE_DEFINITION
+#else
+#define INLINE_IF_POSSIBLE
+
+/* Prototypes for functions we want to be inlined if possible */
+extern void dlist_init(dlist_head *head);
+extern void dlist_push_head(dlist_head *head, dlist_node *node);
+extern void dlist_push_tail(dlist_head *head, dlist_node *node);
+extern void dlist_insert_after(dlist_head *head,
+				   dlist_node *after, dlist_node *node);
+extern void dlist_insert_before(dlist_head *head,
+					dlist_node *before, dlist_node *node);
+extern void dlist_delete(dlist_head *head, dlist_node *node);
+extern dlist_node *dlist_pop_head(dlist_head *head);
+extern void dlist_move_head(dlist_head *head, dlist_node *node);
+extern bool dlist_has_next(dlist_head *head, dlist_node *node);
+extern bool dlist_has_prev(dlist_head *head, dlist_node *node);
+extern bool dlist_is_empty(dlist_head *head);
+extern void dlist_check(dlist_head *head);
+
+extern void slist_init(slist_head *head);
+extern void slist_push_head(slist_head *head, slist_node *node);
+extern slist_node *slist_pop_head(slist_head *head);
+extern void slist_insert_after(slist_head *head,
+				   slist_node *after, slist_node *node);
+extern bool slist_is_empty(slist_head *head);
+extern bool slist_has_next(slist_head *head,
+			   slist_node *node);
+#endif   /* USE_INLINE */
+
+/* These functions are too big to be inline, so they are in the C file always */
+extern void slist_delete(slist_head *head, slist_node *node);
+
+#ifdef ILIST_DEBUG
+extern void dlist_check(dlist_head *head);
+extern void slist_check(slist_head *head);
+#else
+/*
+ * These seemingly useless casts to void are here to keep the compiler quiet
+ * about the argument being unused in many functions in a non-debug compile,
+ * in which functions the only point of passing the list head pointer is to be
+ * able to run these checks.
+ */
+#define dlist_check(head)	(void) (head)
+#define slist_check(head)	(void) (head)
+#endif   /* ILIST_DEBUG */
+
+/*
+ * Return a pointer to the struct 'type' when the passed 'ptr' points to the
+ * element 'membername'.
+ */
+#define ilist_container(type, membername, ptr)								\
+	((type *)((char *)(ptr) - offsetof(type, membername)))
+
+/*
+ * The following function definitions are only used if inlining is supported by
+ * the compiler, or when included from a file that explicitly declares
+ * ILIST_USE_DEFINITION.
+ */
+#ifdef ILIST_USE_DEFINITION
+
+/*
+ * Initialize the head of a list. Previous state will be thrown away without
+ * any cleanup.
+ */
+INLINE_IF_POSSIBLE void
+dlist_init(dlist_head *head)
+{
+	head->head.next = head->head.prev = &head->head;
+
+	dlist_check(head);
+}
+
+/*
+ * inserts a node at the beginning of the list
+ */
+INLINE_IF_POSSIBLE void
+dlist_push_head(dlist_head *head, dlist_node *node)
+{
+	node->next = head->head.next;
+	node->prev = &head->head;
+	node->next->prev = node;
+	head->head.next = node;
+
+	dlist_check(head);
+}
+
+/*
+ * inserts a node at the end of the list
+ */
+INLINE_IF_POSSIBLE void
+dlist_push_tail(dlist_head *head, dlist_node *node)
+{
+	node->next = &head->head;
+	node->prev = head->head.prev;
+	node->prev->next = node;
+	head->head.prev = node;
+
+	dlist_check(head);
+}
+
+/*
+ * insert a node after another *in the same list*
+ */
+INLINE_IF_POSSIBLE void
+dlist_insert_after(dlist_head *head, dlist_node *after,
+				   dlist_node *node)
+{
+	dlist_check(head);
+
+	node->prev = after;
+	node->next = after->next;
+	after->next = node;
+	node->next->prev = node;
+
+	dlist_check(head);
+}
+
+/*
+ * insert a node after another *in the same list*
+ */
+INLINE_IF_POSSIBLE void
+dlist_insert_before(dlist_head *head, dlist_node *before,
+					dlist_node *node)
+{
+	dlist_check(head);
+
+	node->prev = before->prev;
+	node->next = before;
+	before->prev = node;
+	node->prev->next = node;
+
+	dlist_check(head);
+}
+
+/*
+ * deletes a node from a list
+ */
+INLINE_IF_POSSIBLE void
+dlist_delete(dlist_head *head, dlist_node *node)
+{
+	dlist_check(head);
+
+	node->prev->next = node->next;
+	node->next->prev = node->prev;
+
+	dlist_check(head);
+}
+
+/*
+ * deletes the first node from a list or returns NULL
+ */
+INLINE_IF_POSSIBLE dlist_node *
+dlist_pop_head(dlist_head *head)
+{
+	dlist_node *ret;
+
+	if (&head->head == head->head.next)
+		return NULL;
+
+	ret = head->head.next;
+	dlist_delete(head, head->head.next);
+	return ret;
+}
+
+/*
+ * moves an element (that has to be in the list) to the head of the list
+ */
+INLINE_IF_POSSIBLE void
+dlist_move_head(dlist_head *head, dlist_node *node)
+{
+	/* fast path if it's already at the head */
+	if (&head->head == node)
+		return;
+
+	dlist_delete(head, node);
+	dlist_push_head(head, node);
+
+	dlist_check(head);
+}
+
+/*
+ * Check whether the passed node is the last element in the list
+ */
+INLINE_IF_POSSIBLE bool
+dlist_has_next(dlist_head *head, dlist_node *node)
+{
+	return node->next != &head->head;
+}
+
+/*
+ * Check whether the passed node is the first element in the list
+ */
+INLINE_IF_POSSIBLE bool
+dlist_has_prev(dlist_head *head, dlist_node *node)
+{
+	return node->prev != &head->head;
+}
+
+/*
+ * Check whether the list is empty.
+ */
+INLINE_IF_POSSIBLE bool
+dlist_is_empty(dlist_head *head)
+{
+	return head->head.next == &head->head;
+}
+#endif   /* ILIST_USE_DEFINITION */
+
+/*
+ * Return the value of first element in the list if there is one, return NULL
+ * otherwise.
+ *
+ * ptr *will* be evaluated multiple times.
+ */
+#define dlist_get_head(type, membername, ptr)								\
+(																			\
+	(&((ptr)->head) == (ptr)->head.next) ?									\
+		NULL : ilist_container(type, membername, (ptr)->head.next)			\
+)
+
+/*
+ * Return the value of the first element. This will return corrupt data if
+ * there is no element in the list.
+ */
+#define dlist_get_head_unchecked(type, membername, ptr)						\
+	ilist_container(type, membername, (ptr)->head.next)
+
+/*
+ * Return the value of the last element in the list if there is one, return
+ * NULL otherwise.
+ *
+ * ptr *will* be evaluated multiple times.
+ */
+#define dlist_get_tail(type, membername, ptr)								\
+(																			\
+	(&((ptr)->head) == (ptr)->head.prev) ?									\
+		NULL : ilist_container(type, membername, (ptr)->head.prev)			\
+)
+
+/*
+ * Iterate through the list storing the current element in the variable
+ * 'name'. 'ptr' will be evaluated repeatedly.
+ *
+ * It is *not* allowed to manipulate the list during iteration.
+ */
+#define dlist_foreach(name, ptr)											\
+	for (name = (ptr)->head.next; name != &(ptr)->head; name = name->next)
+
+/*
+ * Iterate through the list storing the current element in the variable 'name'
+ * and also storing the next list element in the variable 'nxt'.
+ *
+ * It is allowed to delete the current element from the list. Every other
+ * manipulation can lead to corruption.
+ */
+#define dlist_foreach_modify(name, nxt, ptr)								\
+	for (name = (ptr)->head.next, nxt = name->next;							\
+		 name != &(ptr)->head;												\
+		 name = nxt, nxt = name->next)
+
+/*
+ * Iterate through the list in reverse order storing the current element in the
+ * variable 'name'. 'ptr' will be evaluated repeatedly.
+ *
+ * It is *not* allowed to manipulate the list during iteration.
+ */
+#define dlist_reverse_foreach(name, ptr)									\
+	for (name = (ptr)->head.prev; name != &(ptr)->head; name = name->prev)
+
+
+#ifdef ILIST_USE_DEFINITION
+
+/*
+ * Initialize a singly linked list.
+ */
+INLINE_IF_POSSIBLE void
+slist_init(slist_head *head)
+{
+	head->head.next = NULL;
+
+	slist_check(head);
+}
+
+/*
+ * Install a new element as head of the list, pushing the original head to the
+ * second position.
+ */
+INLINE_IF_POSSIBLE void
+slist_push_head(slist_head *head, slist_node *node)
+{
+	node->next = head->head.next;
+	head->head.next = node;
+
+	slist_check(head);
+}
+
+/*
+ * Returns the first element of the list, removing it.
+ * Fails if the list is empty
+ */
+INLINE_IF_POSSIBLE slist_node *
+slist_pop_head(slist_head *head)
+{
+	slist_node *node;
+
+	node = head->head.next;
+	head->head.next = head->head.next->next;
+
+	slist_check(head);
+
+	return node;
+}
+
+/*
+ * Insert a new element after the listed one.
+ */
+INLINE_IF_POSSIBLE void
+slist_insert_after(slist_head *head, slist_node *after,
+				   slist_node *node)
+{
+	node->next = after->next;
+	after->next = node;
+
+	slist_check(head);
+}
+
+/*
+ * Is the list empty?
+ */
+INLINE_IF_POSSIBLE bool
+slist_is_empty(slist_head *head)
+{
+	slist_check(head);
+
+	return head->head.next == NULL;
+}
+
+/*
+ * Is there at least one more element in the list?
+ */
+INLINE_IF_POSSIBLE bool
+slist_has_next(slist_head *head,
+			   slist_node *node)
+{
+	slist_check(head);
+
+	return node->next != NULL;
+}
+#endif   /* ILIST_USE_DEFINITION */
+
+#define slist_get_head(type, membername, ptr)								\
+(																			\
+	slist_is_empty(ptr) ? NULL :											\
+		ilist_container(type, membername, (ptr).next) 						\
+)
+
+#define slist_get_head_unchecked(type, membername, ptr)						\
+	ilist_container(type, membername, (ptr)->head.next)
+
+/*
+ * Iterate through the list storing the current element in the variable
+ * 'name'. 'ptr' will be evaluated repeatedly.
+ *
+ * It is *not* allowed to manipulate the list during iteration.
+ */
+#define slist_foreach(name, ptr)											\
+	for (name = (ptr)->head.next; name != NULL; name = name->next)
+
+/*
+ * Iterate through the list storing the current element in the variable 'name'
+ * and also storing the next list element in the variable 'nxt'.
+ *
+ * It is allowed to delete the current element from the list. Every other
+ * manipulation can lead to corruption.
+ */
+#define slist_foreach_modify(name, nxt, ptr)								\
+	for (name = (ptr)->head.next, nxt = name ? name->next : NULL;			\
+		name != NULL;														\
+		name = nxt, nxt = name ? name->next : NULL)
+
+#endif   /* ILIST_H */
-- 
1.7.2.5

From 5d2e23c6dc346b9f277869f4e4f1e048faaa574d Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Tue, 26 Jun 2012 19:53:24 +0200
Subject: [PATCH 2/2] Remove usage of lib/dllist.h and replace it by the new
 lib/ilist.h interface

---
 src/backend/postmaster/autovacuum.c |   91 +++++++++++++-----------------
 src/backend/postmaster/postmaster.c |   54 +++++++++---------
 src/backend/utils/cache/catcache.c  |  106 +++++++++++++++++------------------
 src/include/utils/catcache.h        |   14 ++---
 4 files changed, 125 insertions(+), 140 deletions(-)

diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index dade5cc..1f0886c 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -76,6 +76,7 @@
 #include "catalog/pg_database.h"
 #include "commands/dbcommands.h"
 #include "commands/vacuum.h"
+#include "lib/ilist.h"
 #include "libpq/pqsignal.h"
 #include "miscadmin.h"
 #include "pgstat.h"
@@ -149,6 +150,7 @@ typedef struct avl_dbase
 	Oid			adl_datid;		/* hash key -- must be first */
 	TimestampTz adl_next_worker;
 	int			adl_score;
+	ilist_d_node adl_node;
 } avl_dbase;
 
 /* struct to keep track of databases in worker */
@@ -256,7 +258,7 @@ typedef struct
 static AutoVacuumShmemStruct *AutoVacuumShmem;
 
 /* the database list in the launcher, and the context that contains it */
-static Dllist *DatabaseList = NULL;
+static ilist_d_head DatabaseList;
 static MemoryContext DatabaseListCxt = NULL;
 
 /* Pointer to my own WorkerInfo, valid on each worker */
@@ -403,6 +405,9 @@ AutoVacLauncherMain(int argc, char *argv[])
 	/* Identify myself via ps */
 	init_ps_display("autovacuum launcher process", "", "", "");
 
+	/* initialize to be empty */
+	ilist_d_init(&DatabaseList);
+
 	ereport(LOG,
 			(errmsg("autovacuum launcher started")));
 
@@ -505,7 +510,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 
 		/* don't leave dangling pointers to freed memory */
 		DatabaseListCxt = NULL;
-		DatabaseList = NULL;
+		ilist_d_init(&DatabaseList);
 
 		/*
 		 * Make sure pgstat also considers our stat data as gone.  Note: we
@@ -573,7 +578,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 		struct timeval nap;
 		TimestampTz current_time = 0;
 		bool		can_launch;
-		Dlelem	   *elem;
+		avl_dbase   *avdb;
 		int			rc;
 
 		/*
@@ -735,11 +740,9 @@ AutoVacLauncherMain(int argc, char *argv[])
 
 		/* We're OK to start a new worker */
 
-		elem = DLGetTail(DatabaseList);
-		if (elem != NULL)
+		avdb = ilist_d_head(avl_dbase, adl_node, &DatabaseList);
+		if (avdb != NULL)
 		{
-			avl_dbase  *avdb = DLE_VAL(elem);
-
 			/*
 			 * launch a worker if next_worker is right now or it is in the
 			 * past
@@ -780,7 +783,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 static void
 launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
 {
-	Dlelem	   *elem;
+	avl_dbase  *avdb;
 
 	/*
 	 * We sleep until the next scheduled vacuum.  We trust that when the
@@ -793,9 +796,8 @@ launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
 		nap->tv_sec = autovacuum_naptime;
 		nap->tv_usec = 0;
 	}
-	else if ((elem = DLGetTail(DatabaseList)) != NULL)
+	else if ((avdb = ilist_d_tail(avl_dbase, adl_node, &DatabaseList)) != NULL)
 	{
-		avl_dbase  *avdb = DLE_VAL(elem);
 		TimestampTz current_time = GetCurrentTimestamp();
 		TimestampTz next_wakeup;
 		long		secs;
@@ -864,6 +866,7 @@ rebuild_database_list(Oid newdb)
 	int			score;
 	int			nelems;
 	HTAB	   *dbhash;
+	ilist_d_node *elem;
 
 	/* use fresh stats */
 	autovac_refresh_stats();
@@ -924,36 +927,28 @@ rebuild_database_list(Oid newdb)
 	}
 
 	/* Now insert the databases from the existing list */
-	if (DatabaseList != NULL)
+	ilist_d_foreach(elem, &DatabaseList)
 	{
-		Dlelem	   *elem;
-
-		elem = DLGetHead(DatabaseList);
-		while (elem != NULL)
-		{
-			avl_dbase  *avdb = DLE_VAL(elem);
-			avl_dbase  *db;
-			bool		found;
-			PgStat_StatDBEntry *entry;
-
-			elem = DLGetSucc(elem);
+		avl_dbase  *avdb = ilist_container(avl_dbase, adl_node, elem);
+		avl_dbase  *db;
+		bool		found;
+		PgStat_StatDBEntry *entry;
 
-			/*
-			 * skip databases with no stat entries -- in particular, this gets
-			 * rid of dropped databases
-			 */
-			entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
-			if (entry == NULL)
-				continue;
+		/*
+		 * skip databases with no stat entries -- in particular, this gets
+		 * rid of dropped databases
+		 */
+		entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
+		if (entry == NULL)
+			continue;
 
-			db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
+		db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
 
-			if (!found)
-			{
-				/* hash_search already filled in the key */
-				db->adl_score = score++;
-				/* next_worker is filled in later */
-			}
+		if (!found)
+		{
+			/* hash_search already filled in the key */
+			db->adl_score = score++;
+			/* next_worker is filled in later */
 		}
 	}
 
@@ -984,7 +979,7 @@ rebuild_database_list(Oid newdb)
 
 	/* from here on, the allocated memory belongs to the new list */
 	MemoryContextSwitchTo(newcxt);
-	DatabaseList = DLNewList();
+	ilist_d_init(&DatabaseList);
 
 	if (nelems > 0)
 	{
@@ -1026,15 +1021,13 @@ rebuild_database_list(Oid newdb)
 		for (i = 0; i < nelems; i++)
 		{
 			avl_dbase  *db = &(dbary[i]);
-			Dlelem	   *elem;
 
 			current_time = TimestampTzPlusMilliseconds(current_time,
 													   millis_increment);
 			db->adl_next_worker = current_time;
 
-			elem = DLNewElem(db);
 			/* later elements should go closer to the head of the list */
-			DLAddHead(DatabaseList, elem);
+			ilist_d_push_head(&DatabaseList, &db->adl_node);
 		}
 	}
 
@@ -1144,7 +1137,7 @@ do_start_worker(void)
 	foreach(cell, dblist)
 	{
 		avw_dbase  *tmp = lfirst(cell);
-		Dlelem	   *elem;
+		ilist_d_node *elem;
 
 		/* Check to see if this one is at risk of wraparound */
 		if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
@@ -1176,11 +1169,10 @@ do_start_worker(void)
 		 * autovacuum time yet.
 		 */
 		skipit = false;
-		elem = DatabaseList ? DLGetTail(DatabaseList) : NULL;
 
-		while (elem != NULL)
+		ilist_d_reverse_foreach(elem, &DatabaseList)
 		{
-			avl_dbase  *dbp = DLE_VAL(elem);
+			avl_dbase  *dbp = ilist_container(avl_dbase, adl_node, elem);
 
 			if (dbp->adl_datid == tmp->adw_datid)
 			{
@@ -1197,7 +1189,6 @@ do_start_worker(void)
 
 				break;
 			}
-			elem = DLGetPred(elem);
 		}
 		if (skipit)
 			continue;
@@ -1271,7 +1262,7 @@ static void
 launch_worker(TimestampTz now)
 {
 	Oid			dbid;
-	Dlelem	   *elem;
+	ilist_d_node *elem;
 
 	dbid = do_start_worker();
 	if (OidIsValid(dbid))
@@ -1280,10 +1271,9 @@ launch_worker(TimestampTz now)
 		 * Walk the database list and update the corresponding entry.  If the
 		 * database is not on the list, we'll recreate the list.
 		 */
-		elem = (DatabaseList == NULL) ? NULL : DLGetHead(DatabaseList);
-		while (elem != NULL)
+		ilist_d_foreach(elem, &DatabaseList)
 		{
-			avl_dbase  *avdb = DLE_VAL(elem);
+			avl_dbase  *avdb = ilist_container(avl_dbase, adl_node, elem);
 
 			if (avdb->adl_datid == dbid)
 			{
@@ -1294,10 +1284,9 @@ launch_worker(TimestampTz now)
 				avdb->adl_next_worker =
 					TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000);
 
-				DLMoveToFront(elem);
+				ilist_d_move_head(&DatabaseList, elem);
 				break;
 			}
-			elem = DLGetSucc(elem);
 		}
 
 		/*
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index 913734f..36e9b0b 100644
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -95,7 +95,7 @@
 #include "access/xlog.h"
 #include "bootstrap/bootstrap.h"
 #include "catalog/pg_control.h"
-#include "lib/dllist.h"
+#include "lib/ilist.h"
 #include "libpq/auth.h"
 #include "libpq/ip.h"
 #include "libpq/libpq.h"
@@ -145,10 +145,10 @@ typedef struct bkend
 	int			child_slot;		/* PMChildSlot for this backend, if any */
 	bool		is_autovacuum;	/* is it an autovacuum process? */
 	bool		dead_end;		/* is it going to send an error and quit? */
-	Dlelem		elem;			/* list link in BackendList */
+	ilist_d_node		elem;			/* list link in BackendList */
 } Backend;
 
-static Dllist *BackendList;
+static ilist_d_head BackendList;
 
 #ifdef EXEC_BACKEND
 static Backend *ShmemBackendArray;
@@ -976,7 +976,7 @@ PostmasterMain(int argc, char *argv[])
 	/*
 	 * Initialize the list of active backends.
 	 */
-	BackendList = DLNewList();
+	ilist_d_init(&BackendList);
 
 	/*
 	 * Initialize pipe (or process handle on Windows) that allows children to
@@ -1797,7 +1797,7 @@ processCancelRequest(Port *port, void *pkt)
 	Backend    *bp;
 
 #ifndef EXEC_BACKEND
-	Dlelem	   *curr;
+	ilist_d_node *curr;
 #else
 	int			i;
 #endif
@@ -1811,9 +1811,9 @@ processCancelRequest(Port *port, void *pkt)
 	 * duplicate array in shared memory.
 	 */
 #ifndef EXEC_BACKEND
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	ilist_d_foreach(curr, &BackendList)
 	{
-		bp = (Backend *) DLE_VAL(curr);
+		bp = ilist_container(Backend, elem, curr);
 #else
 	for (i = MaxLivePostmasterChildren() - 1; i >= 0; i--)
 	{
@@ -2591,8 +2591,7 @@ static void
 CleanupBackend(int pid,
 			   int exitstatus)	/* child's exit status. */
 {
-	Dlelem	   *curr;
-
+	ilist_d_node *curr, *next;
 	LogChildExit(DEBUG2, _("server process"), pid, exitstatus);
 
 	/*
@@ -2623,9 +2622,9 @@ CleanupBackend(int pid,
 		return;
 	}
 
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	ilist_d_foreach_modify(curr, next, &BackendList)
 	{
-		Backend    *bp = (Backend *) DLE_VAL(curr);
+		Backend    *bp = ilist_container(Backend, elem, curr);
 
 		if (bp->pid == pid)
 		{
@@ -2644,7 +2643,7 @@ CleanupBackend(int pid,
 				ShmemBackendArrayRemove(bp);
 #endif
 			}
-			DLRemove(curr);
+			ilist_d_delete(&BackendList, curr);
 			free(bp);
 			break;
 		}
@@ -2661,7 +2660,7 @@ CleanupBackend(int pid,
 static void
 HandleChildCrash(int pid, int exitstatus, const char *procname)
 {
-	Dlelem	   *curr,
+	ilist_d_node  *curr,
 			   *next;
 	Backend    *bp;
 
@@ -2677,10 +2676,10 @@ HandleChildCrash(int pid, int exitstatus, const char *procname)
 	}
 
 	/* Process regular backends */
-	for (curr = DLGetHead(BackendList); curr; curr = next)
+	ilist_d_foreach_modify(curr, next, &BackendList)
 	{
-		next = DLGetSucc(curr);
-		bp = (Backend *) DLE_VAL(curr);
+		bp = ilist_container(Backend, elem, curr);
+
 		if (bp->pid == pid)
 		{
 			/*
@@ -2693,7 +2692,7 @@ HandleChildCrash(int pid, int exitstatus, const char *procname)
 				ShmemBackendArrayRemove(bp);
 #endif
 			}
-			DLRemove(curr);
+			ilist_d_delete(&BackendList, curr);
 			free(bp);
 			/* Keep looping so we can signal remaining backends */
 		}
@@ -3056,7 +3055,7 @@ PostmasterStateMachine(void)
 		 * normal state transition leading up to PM_WAIT_DEAD_END, or during
 		 * FatalError processing.
 		 */
-		if (DLGetHead(BackendList) == NULL &&
+		if (ilist_d_is_empty(&BackendList) &&
 			PgArchPID == 0 && PgStatPID == 0)
 		{
 			/* These other guys should be dead already */
@@ -3182,12 +3181,12 @@ signal_child(pid_t pid, int signal)
 static bool
 SignalSomeChildren(int signal, int target)
 {
-	Dlelem	   *curr;
+	ilist_d_node *curr;
 	bool		signaled = false;
 
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	ilist_d_foreach(curr, &BackendList)
 	{
-		Backend    *bp = (Backend *) DLE_VAL(curr);
+		Backend    *bp = ilist_container(Backend, elem, curr);
 
 		if (bp->dead_end)
 			continue;
@@ -3325,8 +3324,8 @@ BackendStartup(Port *port)
 	 */
 	bn->pid = pid;
 	bn->is_autovacuum = false;
-	DLInitElem(&bn->elem, bn);
-	DLAddHead(BackendList, &bn->elem);
+	ilist_d_push_head(&BackendList, &bn->elem);
+
 #ifdef EXEC_BACKEND
 	if (!bn->dead_end)
 		ShmemBackendArrayAdd(bn);
@@ -4422,12 +4421,12 @@ PostmasterRandom(void)
 static int
 CountChildren(int target)
 {
-	Dlelem	   *curr;
+	ilist_d_node *curr;
 	int			cnt = 0;
 
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	ilist_d_foreach(curr, &BackendList)
 	{
-		Backend    *bp = (Backend *) DLE_VAL(curr);
+		Backend    *bp = ilist_container(Backend, elem, curr);
 
 		if (bp->dead_end)
 			continue;
@@ -4606,8 +4605,7 @@ StartAutovacuumWorker(void)
 			if (bn->pid > 0)
 			{
 				bn->is_autovacuum = true;
-				DLInitElem(&bn->elem, bn);
-				DLAddHead(BackendList, &bn->elem);
+				ilist_d_push_head(&BackendList, &bn->elem);
 #ifdef EXEC_BACKEND
 				ShmemBackendArrayAdd(bn);
 #endif
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index 0307b96..efe34d9 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -353,6 +353,8 @@ CatCachePrintStats(int code, Datum arg)
 static void
 CatCacheRemoveCTup(CatCache *cache, CatCTup *ct)
 {
+	Index		hashIndex;
+
 	Assert(ct->refcount == 0);
 	Assert(ct->my_cache == cache);
 
@@ -369,7 +371,9 @@ CatCacheRemoveCTup(CatCache *cache, CatCTup *ct)
 	}
 
 	/* delink from linked list */
-	DLRemove(&ct->cache_elem);
+	hashIndex = HASH_INDEX(ct->hash_value, cache->cc_nbuckets);
+
+	ilist_d_delete(&cache->cc_bucket[hashIndex], &ct->cache_elem);
 
 	/* free associated tuple data */
 	if (ct->tuple.t_data != NULL)
@@ -412,7 +416,7 @@ CatCacheRemoveCList(CatCache *cache, CatCList *cl)
 	}
 
 	/* delink from linked list */
-	DLRemove(&cl->cache_elem);
+	ilist_d_delete(&cache->cc_lists, &cl->cache_elem);
 
 	/* free associated tuple data */
 	if (cl->tuple.t_data != NULL)
@@ -452,8 +456,9 @@ CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
 	{
 		Index		hashIndex;
-		Dlelem	   *elt,
+		ilist_d_node *elt,
 				   *nextelt;
+		ilist_d_head *bucket;
 
 		if (cacheId != ccp->id)
 			continue;
@@ -468,11 +473,9 @@ CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 		 * Invalidate *all* CatCLists in this cache; it's too hard to tell
 		 * which searches might still be correct, so just zap 'em all.
 		 */
-		for (elt = DLGetHead(&ccp->cc_lists); elt; elt = nextelt)
+		ilist_d_foreach_modify(elt, nextelt, &ccp->cc_lists)
 		{
-			CatCList   *cl = (CatCList *) DLE_VAL(elt);
-
-			nextelt = DLGetSucc(elt);
+			CatCList   *cl = ilist_container(CatCList, cache_elem, elt);
 
 			if (cl->refcount > 0)
 				cl->dead = true;
@@ -484,12 +487,10 @@ CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 		 * inspect the proper hash bucket for tuple matches
 		 */
 		hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets);
-
-		for (elt = DLGetHead(&ccp->cc_bucket[hashIndex]); elt; elt = nextelt)
+		bucket = &ccp->cc_bucket[hashIndex];
+		ilist_d_foreach_modify(elt, nextelt, bucket)
 		{
-			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
-
-			nextelt = DLGetSucc(elt);
+			CatCTup    *ct = ilist_container(CatCTup, cache_elem, elt);
 
 			if (hashValue == ct->hash_value)
 			{
@@ -561,13 +562,13 @@ AtEOXact_CatCache(bool isCommit)
 
 		for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
 		{
-			Dlelem	   *elt;
+			ilist_d_node *elt;
 			int			i;
 
 			/* Check CatCLists */
-			for (elt = DLGetHead(&ccp->cc_lists); elt; elt = DLGetSucc(elt))
+			ilist_d_foreach(elt, &ccp->cc_lists)
 			{
-				CatCList   *cl = (CatCList *) DLE_VAL(elt);
+				CatCList   *cl = ilist_container(CatCList, cache_elem, elt);
 
 				Assert(cl->cl_magic == CL_MAGIC);
 				Assert(cl->refcount == 0);
@@ -577,11 +578,10 @@ AtEOXact_CatCache(bool isCommit)
 			/* Check individual tuples */
 			for (i = 0; i < ccp->cc_nbuckets; i++)
 			{
-				for (elt = DLGetHead(&ccp->cc_bucket[i]);
-					 elt;
-					 elt = DLGetSucc(elt))
+				ilist_d_head *bucket =  &ccp->cc_bucket[i];
+				ilist_d_foreach(elt, bucket)
 				{
-					CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
+					CatCTup    *ct = ilist_container(CatCTup, cache_elem, elt);
 
 					Assert(ct->ct_magic == CT_MAGIC);
 					Assert(ct->refcount == 0);
@@ -604,16 +604,14 @@ AtEOXact_CatCache(bool isCommit)
 static void
 ResetCatalogCache(CatCache *cache)
 {
-	Dlelem	   *elt,
+	ilist_d_node *elt,
 			   *nextelt;
 	int			i;
 
 	/* Remove each list in this cache, or at least mark it dead */
-	for (elt = DLGetHead(&cache->cc_lists); elt; elt = nextelt)
+	ilist_d_foreach_modify(elt, nextelt, &cache->cc_lists)
 	{
-		CatCList   *cl = (CatCList *) DLE_VAL(elt);
-
-		nextelt = DLGetSucc(elt);
+		CatCList   *cl = ilist_container(CatCList, cache_elem, elt);
 
 		if (cl->refcount > 0)
 			cl->dead = true;
@@ -624,11 +622,10 @@ ResetCatalogCache(CatCache *cache)
 	/* Remove each tuple in this cache, or at least mark it dead */
 	for (i = 0; i < cache->cc_nbuckets; i++)
 	{
-		for (elt = DLGetHead(&cache->cc_bucket[i]); elt; elt = nextelt)
+		ilist_d_head *bucket =  &cache->cc_bucket[i];
+		ilist_d_foreach_modify(elt, nextelt, bucket)
 		{
-			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
-
-			nextelt = DLGetSucc(elt);
+			CatCTup    *ct = ilist_container(CatCTup, cache_elem, elt);
 
 			if (ct->refcount > 0 ||
 				(ct->c_list && ct->c_list->refcount > 0))
@@ -770,10 +767,8 @@ InitCatCache(int id,
 
 	/*
 	 * allocate a new cache structure
-	 *
-	 * Note: we assume zeroing initializes the Dllist headers correctly
 	 */
-	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(Dllist));
+	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(ilist_d_node));
 
 	/*
 	 * initialize the cache's relation information for the relation
@@ -792,6 +787,12 @@ InitCatCache(int id,
 	for (i = 0; i < nkeys; ++i)
 		cp->cc_key[i] = key[i];
 
+	ilist_d_init(&cp->cc_lists);
+
+	for (i = 0; i < nbuckets; i++){
+		ilist_d_init(&cp->cc_bucket[i]);
+	}
+
 	/*
 	 * new cache is initialized as far as we can go for now. print some
 	 * debugging information, if appropriate.
@@ -1060,7 +1061,8 @@ SearchCatCache(CatCache *cache,
 	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
 	uint32		hashValue;
 	Index		hashIndex;
-	Dlelem	   *elt;
+	ilist_d_node *elt;
+	ilist_d_head *bucket;
 	CatCTup    *ct;
 	Relation	relation;
 	SysScanDesc scandesc;
@@ -1094,13 +1096,11 @@ SearchCatCache(CatCache *cache,
 	/*
 	 * scan the hash bucket until we find a match or exhaust our tuples
 	 */
-	for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
-		 elt;
-		 elt = DLGetSucc(elt))
-	{
+	bucket = &cache->cc_bucket[hashIndex];
+	ilist_d_foreach(elt, bucket){
 		bool		res;
 
-		ct = (CatCTup *) DLE_VAL(elt);
+		ct = ilist_container(CatCTup, cache_elem, elt);
 
 		if (ct->dead)
 			continue;			/* ignore dead entries */
@@ -1125,7 +1125,7 @@ SearchCatCache(CatCache *cache,
 		 * most frequently accessed elements in any hashbucket will tend to be
 		 * near the front of the hashbucket's list.)
 		 */
-		DLMoveToFront(&ct->cache_elem);
+		ilist_d_move_head(bucket, &ct->cache_elem);
 
 		/*
 		 * If it's a positive entry, bump its refcount and return it. If it's
@@ -1340,7 +1340,7 @@ SearchCatCacheList(CatCache *cache,
 {
 	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
 	uint32		lHashValue;
-	Dlelem	   *elt;
+	ilist_d_node *elt;
 	CatCList   *cl;
 	CatCTup    *ct;
 	List	   *volatile ctlist;
@@ -1382,13 +1382,11 @@ SearchCatCacheList(CatCache *cache,
 	/*
 	 * scan the items until we find a match or exhaust our list
 	 */
-	for (elt = DLGetHead(&cache->cc_lists);
-		 elt;
-		 elt = DLGetSucc(elt))
+	ilist_d_foreach(elt, &cache->cc_lists)
 	{
 		bool		res;
 
-		cl = (CatCList *) DLE_VAL(elt);
+		cl = ilist_container(CatCList, cache_elem, elt);
 
 		if (cl->dead)
 			continue;			/* ignore dead entries */
@@ -1416,7 +1414,7 @@ SearchCatCacheList(CatCache *cache,
 		 * since there's no point in that unless they are searched for
 		 * individually.)
 		 */
-		DLMoveToFront(&cl->cache_elem);
+		ilist_d_move_head(&cache->cc_lists, &cl->cache_elem);
 
 		/* Bump the list's refcount and return it */
 		ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
@@ -1468,7 +1466,8 @@ SearchCatCacheList(CatCache *cache,
 		{
 			uint32		hashValue;
 			Index		hashIndex;
-
+			bool        found = false;
+			ilist_d_head *bucket;
 			/*
 			 * See if there's an entry for this tuple already.
 			 */
@@ -1476,11 +1475,10 @@ SearchCatCacheList(CatCache *cache,
 			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);
 			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
 
-			for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
-				 elt;
-				 elt = DLGetSucc(elt))
+			bucket = &cache->cc_bucket[hashIndex];
+			ilist_d_foreach(elt, bucket)
 			{
-				ct = (CatCTup *) DLE_VAL(elt);
+				ct = ilist_container(CatCTup, cache_elem, elt);
 
 				if (ct->dead || ct->negative)
 					continue;	/* ignore dead and negative entries */
@@ -1498,10 +1496,11 @@ SearchCatCacheList(CatCache *cache,
 				if (ct->c_list)
 					continue;
 
+				found = true;
 				break;			/* A-OK */
 			}
 
-			if (elt == NULL)
+			if (!found)
 			{
 				/* We didn't find a usable entry, so make a new one */
 				ct = CatalogCacheCreateEntry(cache, ntp,
@@ -1564,7 +1563,6 @@ SearchCatCacheList(CatCache *cache,
 
 	cl->cl_magic = CL_MAGIC;
 	cl->my_cache = cache;
-	DLInitElem(&cl->cache_elem, cl);
 	cl->refcount = 0;			/* for the moment */
 	cl->dead = false;
 	cl->ordered = ordered;
@@ -1587,7 +1585,7 @@ SearchCatCacheList(CatCache *cache,
 	}
 	Assert(i == nmembers);
 
-	DLAddHead(&cache->cc_lists, &cl->cache_elem);
+	ilist_d_push_head(&cache->cc_lists, &cl->cache_elem);
 
 	/* Finally, bump the list's refcount and return it */
 	cl->refcount++;
@@ -1664,14 +1662,14 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp,
 	 */
 	ct->ct_magic = CT_MAGIC;
 	ct->my_cache = cache;
-	DLInitElem(&ct->cache_elem, (void *) ct);
+
 	ct->c_list = NULL;
 	ct->refcount = 0;			/* for the moment */
 	ct->dead = false;
 	ct->negative = negative;
 	ct->hash_value = hashValue;
 
-	DLAddHead(&cache->cc_bucket[hashIndex], &ct->cache_elem);
+	ilist_d_push_head(&cache->cc_bucket[hashIndex], &ct->cache_elem);
 
 	cache->cc_ntup++;
 	CacheHdr->ch_ntup++;
diff --git a/src/include/utils/catcache.h b/src/include/utils/catcache.h
index d91700a..20f2fa8 100644
--- a/src/include/utils/catcache.h
+++ b/src/include/utils/catcache.h
@@ -22,7 +22,7 @@
 
 #include "access/htup.h"
 #include "access/skey.h"
-#include "lib/dllist.h"
+#include "lib/ilist.h"
 #include "utils/relcache.h"
 
 /*
@@ -51,7 +51,7 @@ typedef struct catcache
 	ScanKeyData cc_skey[CATCACHE_MAXKEYS];		/* precomputed key info for
 												 * heap scans */
 	bool		cc_isname[CATCACHE_MAXKEYS];	/* flag "name" key columns */
-	Dllist		cc_lists;		/* list of CatCList structs */
+	ilist_d_head cc_lists;		/* list of CatCList structs */
 #ifdef CATCACHE_STATS
 	long		cc_searches;	/* total # searches against this cache */
 	long		cc_hits;		/* # of matches against existing entry */
@@ -66,7 +66,7 @@ typedef struct catcache
 	long		cc_lsearches;	/* total # list-searches */
 	long		cc_lhits;		/* # of matches against existing lists */
 #endif
-	Dllist		cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
+	ilist_d_head cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
 } CatCache;						/* VARIABLE LENGTH STRUCT */
 
 
@@ -77,11 +77,11 @@ typedef struct catctup
 	CatCache   *my_cache;		/* link to owning catcache */
 
 	/*
-	 * Each tuple in a cache is a member of a Dllist that stores the elements
-	 * of its hash bucket.	We keep each Dllist in LRU order to speed repeated
+	 * Each tuple in a cache is a member of a ilist_d that stores the elements
+	 * of its hash bucket.	We keep each ilist_d in LRU order to speed repeated
 	 * lookups.
 	 */
-	Dlelem		cache_elem;		/* list member of per-bucket list */
+	ilist_d_node cache_elem;		/* list member of per-bucket list */
 
 	/*
 	 * The tuple may also be a member of at most one CatCList.	(If a single
@@ -139,7 +139,7 @@ typedef struct catclist
 	 * might not be true during bootstrap or recovery operations. (namespace.c
 	 * is able to save some cycles when it is true.)
 	 */
-	Dlelem		cache_elem;		/* list member of per-catcache list */
+	ilist_d_node cache_elem;		/* list member of per-catcache list */
 	int			refcount;		/* number of active references */
 	bool		dead;			/* dead but not yet removed? */
 	bool		ordered;		/* members listed in index order? */
-- 
1.7.10.rc3.3.g19a6c.dirty

From d670675371644e8905944e65b56b967d5b01f572 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 7 Sep 2012 13:24:52 -0300
Subject: [PATCH 3/3] convert catcache.h cc_next into an slist

---
 src/backend/utils/cache/catcache.c |   40 ++++++++++++++++++++++-------------
 src/include/utils/catcache.h       |    4 +-
 2 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index 6ebb3ce..14ddcb0 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -291,7 +291,7 @@ CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple)
 static void
 CatCachePrintStats(int code, Datum arg)
 {
-	CatCache   *cache;
+	slist_node *elem;
 	long		cc_searches = 0;
 	long		cc_hits = 0;
 	long		cc_neg_hits = 0;
@@ -300,8 +300,10 @@ CatCachePrintStats(int code, Datum arg)
 	long		cc_lsearches = 0;
 	long		cc_lhits = 0;
 
-	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
+	slist_foreach(elem, &CacheHdr->ch_caches)
 	{
+		CatCache   *cache = ilist_container(CatCache, cc_next, elem);
+
 		if (cache->cc_ntup == 0 && cache->cc_searches == 0)
 			continue;			/* don't print unused caches */
 		elog(DEBUG2, "catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld lsrch, %ld lhits",
@@ -441,19 +443,20 @@ CatCacheRemoveCList(CatCache *cache, CatCList *cl)
 void
 CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 {
-	CatCache   *ccp;
+	slist_node *elem;
 
 	CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
 
 	/*
 	 * inspect caches to find the proper cache
 	 */
-	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
+	slist_foreach(elem, &CacheHdr->ch_caches)
 	{
 		Index		hashIndex;
 		dlist_node *elt,
 				   *nextelt;
 		dlist_head *bucket;
+		CatCache   *ccp = ilist_container(CatCache, cc_next, elem);
 
 		if (cacheId != ccp->id)
 			continue;
@@ -553,10 +556,11 @@ AtEOXact_CatCache(bool isCommit)
 #ifdef USE_ASSERT_CHECKING
 	if (assert_enabled)
 	{
-		CatCache   *ccp;
+		slist_node *elem;
 
-		for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
+		slist_foreach(elem, &(CacheHdr->ch_caches))
 		{
+			CatCache   *ccp = ilist_container(CatCache, cc_next, elem);
 			dlist_node *elt;
 			int			i;
 
@@ -648,12 +652,16 @@ ResetCatalogCache(CatCache *cache)
 void
 ResetCatalogCaches(void)
 {
-	CatCache   *cache;
+	slist_node   *elem;
 
 	CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
 
-	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
+	slist_foreach(elem, &CacheHdr->ch_caches)
+	{
+		CatCache   *cache = ilist_container(CatCache, cc_next, elem);
+
 		ResetCatalogCache(cache);
+	}
 
 	CACHE1_elog(DEBUG2, "end of ResetCatalogCaches call");
 }
@@ -674,12 +682,14 @@ ResetCatalogCaches(void)
 void
 CatalogCacheFlushCatalog(Oid catId)
 {
-	CatCache   *cache;
+	slist_node *elem;
 
 	CACHE2_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
 
-	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
+	slist_foreach(elem, &(CacheHdr->ch_caches))
 	{
+		CatCache   *cache = ilist_container(CatCache, cc_next, elem);
+
 		/* Does this cache store tuples of the target catalog? */
 		if (cache->cc_reloid == catId)
 		{
@@ -754,7 +764,7 @@ InitCatCache(int id,
 	if (CacheHdr == NULL)
 	{
 		CacheHdr = (CatCacheHeader *) palloc(sizeof(CatCacheHeader));
-		CacheHdr->ch_caches = NULL;
+		slist_init(&CacheHdr->ch_caches);
 		CacheHdr->ch_ntup = 0;
 #ifdef CATCACHE_STATS
 		/* set up to dump stats at backend exit */
@@ -798,8 +808,7 @@ InitCatCache(int id,
 	/*
 	 * add completed cache to top of group header's list
 	 */
-	cp->cc_next = CacheHdr->ch_caches;
-	CacheHdr->ch_caches = cp;
+	slist_push_head(&CacheHdr->ch_caches, &cp->cc_next);
 
 	/*
 	 * back to the old context before we return...
@@ -1782,7 +1791,7 @@ PrepareToInvalidateCacheTuple(Relation relation,
 							  HeapTuple newtuple,
 							  void (*function) (int, uint32, Oid))
 {
-	CatCache   *ccp;
+	slist_node *elem;
 	Oid			reloid;
 
 	CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
@@ -1805,10 +1814,11 @@ PrepareToInvalidateCacheTuple(Relation relation,
 	 * ----------------
 	 */
 
-	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
+	slist_foreach(elem, &(CacheHdr->ch_caches))
 	{
 		uint32		hashvalue;
 		Oid			dbid;
+		CatCache   *ccp = ilist_container(CatCache, cc_next, elem);
 
 		if (ccp->cc_reloid != reloid)
 			continue;
diff --git a/src/include/utils/catcache.h b/src/include/utils/catcache.h
index 1e59ea4..cc6dab2 100644
--- a/src/include/utils/catcache.h
+++ b/src/include/utils/catcache.h
@@ -37,7 +37,7 @@
 typedef struct catcache
 {
 	int			id;				/* cache identifier --- see syscache.h */
-	struct catcache *cc_next;	/* link to next catcache */
+	slist_node	cc_next;		/* list link */
 	const char *cc_relname;		/* name of relation the tuples come from */
 	Oid			cc_reloid;		/* OID of relation the tuples come from */
 	Oid			cc_indexoid;	/* OID of index matching cache keys */
@@ -154,7 +154,7 @@ typedef struct catclist
 
 typedef struct catcacheheader
 {
-	CatCache   *ch_caches;		/* head of list of CatCache structs */
+	slist_head	ch_caches;		/* head of list of CatCache structs */
 	int			ch_ntup;		/* # of tuples in all caches */
 } CatCacheHeader;
 
-- 
1.7.2.5

From 52a9d3740158c00a19d3939dc91c2a88afca3480 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Fri, 28 Sep 2012 13:18:26 +0200
Subject: [PATCH 1/4] Add compile time checked assert_compatible_types macro
 to c.h

Useful for generating better error messages in other macros.
---
 src/include/c.h | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/src/include/c.h b/src/include/c.h
index 50e1ecf..024ed5c 100644
--- a/src/include/c.h
+++ b/src/include/c.h
@@ -857,4 +857,31 @@ extern int	fdatasync(int fildes);
 /* /port compatibility functions */
 #include "port.h"
 
+/*
+ * Macro that makes sure two types are the same at compile time
+ *
+ * Used only to emit better error messages, we support compilers without
+ * support for _Static_assert and without support for
+ * __builtin_types_compatible_p and compound expressions which are a gcc
+ * extensions
+ */
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#define assert_compatible_types(a, b)									 \
+	do {																 \
+		_Static_assert(												 \
+			__builtin_types_compatible_p(a, __typeof__ (b) ),			 \
+			"variable `" #b "` is not compatible to type `" #a "`" );	 \
+	} while(0)
+
+#define assert_compatible_types_bool(a, b)								 \
+	({																	 \
+		assert_compatible_types(a, b);									 \
+		true;															 \
+	})
+#else
+#define assert_compatible_types(a, b) (void)0
+#define assert_compatible_types_bool(a, b) true
+#endif
+
+
 #endif   /* C_H */
-- 
1.7.12.289.g0ce9864.dirty

From 5274d608523393cb849044b629513d5680fd572a Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Fri, 28 Sep 2012 16:41:20 +0200
Subject: [PATCH 2/4] Add [ds]list's which can be used to embed lists in
 bigger data structures without additional memory
 management

Alvaro, Andres, Review by Peter G. and Tom

Changes since last submission:
* naming is now [ds]list_*
* README is split back into the header
* README is rewritten
* much improved comments
* no error checking for empty lists anymore, Asserts added everywhere
* no multiple evaluation at all anymore
* introduction of [ds]list_iterator structs
* typechecking added to macros
* DLIST_STATIC_INIT added to initialize list elements at declaration time.
* added some more functions (symetry, new users)
* s/ILIST_USE_DEFINITION/ILIST_DEFINE_FUNCTIONS/
* don't declare ILIST_DEFINE_FUNCTIONS in the header, rely on USE_INLINE
* pgindent compatible styling
---
 src/backend/lib/Makefile |   2 +-
 src/backend/lib/ilist.c  | 117 ++++++++
 src/include/lib/ilist.h  | 760 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 878 insertions(+), 1 deletion(-)
 create mode 100644 src/backend/lib/ilist.c
 create mode 100644 src/include/lib/ilist.h

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 2e1061e..c94297a 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/lib
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = dllist.o stringinfo.o
+OBJS = dllist.o stringinfo.o ilist.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/ilist.c b/src/backend/lib/ilist.c
new file mode 100644
index 0000000..de4a27d
--- /dev/null
+++ b/src/backend/lib/ilist.c
@@ -0,0 +1,117 @@
+/*-------------------------------------------------------------------------
+ *
+ * ilist.c
+ *	  support for integrated/inline doubly- and singly- linked lists
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/lib/ilist.c
+ *
+ * NOTES
+ *	  This file only contains functions that are too big to be considered
+ *	  for inlining.  See ilist.h for most of the goodies.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+/*
+ * If inlines are in use, include the header normally which will get us only
+ * the function definitions as inlines.  But if inlines aren't available,
+ * include the header with ILIST_DEFINE_FUNCTIONS defined; this makes it pour
+ * in regular (not inline) function declarations and the corresponding (non
+ * inline) definitions.
+ */
+#ifndef USE_INLINE
+#define ILIST_DEFINE_FUNCTIONS
+#endif
+
+#include "lib/ilist.h"
+
+/*
+ * removes a node from a list
+ *
+ * Attention: O(n)
+ */
+void
+slist_delete(slist_head *head, slist_node *node)
+{
+	slist_node *last = &head->head;
+	slist_node *cur;
+	bool found	PG_USED_FOR_ASSERTS_ONLY = false;
+
+	while ((cur = last->next) != NULL)
+	{
+		if (cur == node)
+		{
+			last->next = cur->next;
+#ifdef USE_ASSERT_CHECKING
+			found = true;
+#endif
+			break;
+		}
+		last = cur;
+	}
+
+	slist_check(head);
+	Assert(found);
+}
+
+#ifdef ILIST_DEBUG
+/*
+ * Verify integrity of a doubly linked list
+ */
+void
+dlist_check(dlist_head *head)
+{
+	dlist_node *cur;
+
+	if (head == NULL || !(&head->head))
+		elog(ERROR, "doubly linked list head is not properly initialized");
+
+	/* iterate in forward direction */
+	for (cur = head->head.next; cur != &head->head; cur = cur->next)
+	{
+		if (cur == NULL ||
+			cur->next == NULL ||
+			cur->prev == NULL ||
+			cur->prev->next != cur ||
+			cur->next->prev != cur)
+			elog(ERROR, "doubly linked list is corrupted");
+	}
+
+	/* iterate in backward direction */
+	for (cur = head->head.prev; cur != &head->head; cur = cur->prev)
+	{
+		if (cur == NULL ||
+			cur->next == NULL ||
+			cur->prev == NULL ||
+			cur->prev->next != cur ||
+			cur->next->prev != cur)
+			elog(ERROR, "doubly linked list is corrupted");
+	}
+}
+
+/*
+ * Verify integrity of a singly linked list
+ */
+void
+slist_check(slist_head *head)
+{
+	slist_node *cur;
+
+	if (head == NULL)
+		elog(ERROR, "singly linked is NULL");
+
+	/*
+	 * there isn't much we can test in a singly linked list other that it
+	 * actually ends sometime, i.e. hasn't introduced a circle or similar
+	 */
+	for (cur = head->head.next; cur != NULL; cur = cur->next)
+		;
+}
+
+#endif   /* ILIST_DEBUG */
diff --git a/src/include/lib/ilist.h b/src/include/lib/ilist.h
new file mode 100644
index 0000000..388e953
--- /dev/null
+++ b/src/include/lib/ilist.h
@@ -0,0 +1,760 @@
+/*-------------------------------------------------------------------------
+ *
+ * ilist.h
+ *		integrated/inline doubly- and singly-linked lists
+ *
+ * This implementation is as efficient as possible: the lists don't have
+ * any memory management overhead, because the list pointers are embedded
+ * within some larger structure.
+
+ * Also, the circular lists are always circularly linked, even when empty; this
+ * enables many manipulations to be done without branches, which is beneficial
+ * performance-wise.
+ *
+ * NOTES:
+ *
+ * This is intended to be used in situations where memory for a struct and its
+ * contents already needs to be allocated and the overhead of allocating extra
+ * list cells for every list element is noticeable. The API for singly/doubly
+ * linked lists is identical as far as capabilities of both allow.
+ *
+ * // A oversimplified example demonstrating how this can be used:
+ *
+ * #include "lib/ilist.h"
+ *
+ * // Lets assume we want to store information about the tables contained in a
+ * // database.
+ *
+ * // Define struct for the databases including a list header that will be used
+ * // to access the nodes in the list later on.
+ * typedef struct my_database
+ * {
+ *	   char* datname;
+ *	   dlist_head tables;
+ *	   ...
+ * } my_database;
+ *
+ * // Define struct for the tables. Note the list_node element which stores
+ * // information about prev/next list nodes.
+ * typedef struct my_table
+ * {
+ *	   char* tablename;
+ *	   dlist_node list_node;
+ *	   perm_t permissions;
+ *	   ...
+ * } value_in_a_list;
+ *
+ * // create a database
+ * my_database *db = create_database();
+ *
+ * // and a few tables
+ * dlist_push_head(&db->tables, &create_table(db, "a")->list_node);
+ * ...
+ * dlist_push_head(&db->tables, &create_table(db, "b")->list_node);
+ * ...
+ * ...
+ * // to iterate over the table we allocate an iterator element to store
+ * // information about the current position
+ * dlist_iter iter;
+ *
+ * dlist_foreach (iter, &db->tables)
+ * {
+ *	   // inside an *_foreach the iterator's .cur field can be used to access
+ *	   // the current element
+ *	   // iter.cur points to a 'dlist_node', but we want the actual table
+ *	   // information, use dlist_container to convert
+ *	   my_table *tbl = dlist_container(my_table, list_node, iter->cur);
+ *	   elog(NOTICE, 'we have a table: %s in database %s',
+ *			val->tablename, db->datname);
+ * }
+ *
+ * // while a simple iteration is useful we sometimes also want to manipulate
+ * // the list while iterating. Say, we want to delete all tables!
+ *
+ * // declare an iterator that allows some list manipulations
+ * dlist_mutable_iter miter;
+ *
+ * // iterate
+ * dlist_foreach_modify(miter, &db->tables)
+ * {
+ *	   my_table *tbl = dlist_container(my_table, list_node, iter->cur);
+ *	   // unlink the current table from the linked list
+ *	   dlist_delete(&db->tables, iter->cur);
+ *	   // as ilists never manage memory, we can freely access the table
+ *	   drop_table(db, tbl);
+ * }
+ *
+ * // Note that none of the dlist_* functions did do any memory
+ * // management. They just manipulated externally managed memory.
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *		src/include/lib/ilist.h
+ *-------------------------------------------------------------------------
+ */
+#ifndef ILIST_H
+#define ILIST_H
+
+/*
+ * enable for extra debugging. This is rather expensive, so it's not enabled by
+ * default even with --enable-cassert.
+ */
+/* #define ILIST_DEBUG */
+
+/*
+ * Node of a doubly linked list.
+ *
+ * Embed this in structs that need to be part of a doubly linked list.
+ */
+typedef struct dlist_node dlist_node;
+struct dlist_node
+{
+	dlist_node *prev;
+	dlist_node *next;
+};
+
+/*
+ * Head of a doubly linked list.
+ *
+ * Lists are internally *always* circularly linked, even when empty. Circular
+ * lists have the advantage of not needing any branches in the most common list
+ * manipulations.
+ */
+typedef struct dlist_head
+{
+	/*
+	 * head->next either points to the first element of the list or to &head
+	 * if empty.
+	 *
+	 * head->prev either points to the last element of the list or to &head if
+	 * empty.
+	 */
+	dlist_node	head;
+} dlist_head;
+
+
+/*
+ * Doubly linked list iterator.
+ *
+ * Used as state in dlist_foreach() and dlist_reverse_foreach(). To get the
+ * current element of the iteration use the 'cur' member.
+ *
+ * Iterations using this are *not* allowed to change the list while iterating!
+ *
+ * NB: We use an extra type for this to make it possible to avoid multiple
+ * evaluations of arguments in the dlist_foreach() macro.
+ */
+typedef struct dlist_iter
+{
+	dlist_node *end;			/* last node we iterate to */
+	dlist_node *cur;			/* current element */
+} dlist_iter;
+
+/*
+ * Doubly linked list iterator allowing some modifications while iterating
+ *
+ * Used as state in dlist_foreach_modify(). To get the current element of the
+ * iteration use the 'cur' member.
+ *
+ * Iterations using this are only allowed to change the list *at the current
+ * point of iteration*. It is fine to delete the current node, but it is *not*
+ * fine to modify other nodes.
+ *
+ * NB: We need a separate type for mutable iterations to avoid having to pass
+ * in two iterators or some other state variable as we need to store the
+ * '->next' node of the current node so it can be deleted or modified by the
+ * user.
+ */
+typedef struct dlist_mutable_iter
+{
+	dlist_node *end;			/* last node we iterate to */
+	dlist_node *cur;			/* current element */
+	dlist_node *next;			/* next node we iterate to, so we can delete
+								 * cur */
+} dlist_mutable_iter;
+
+/*
+ * Node of a singly linked list.
+ *
+ * Embed this in structs that need to be part of a singly linked list.
+ */
+typedef struct slist_node slist_node;
+struct slist_node
+{
+	slist_node *next;
+};
+
+/*
+ * Head of a singly linked list.
+ *
+ * Singly linked lists are *not* circularly linked (how could they be?) in
+ * contrast to the doubly linked lists. As no pointer to the last list element
+ * and to the previous node needs to be maintained this doesn't incur any
+ * additional branches in the usual manipulations.
+ */
+typedef struct slist_head
+{
+	slist_node	head;
+} slist_head;
+
+/*
+ * Singly linked list iterator
+ *
+ * Used in slist_foreach(). To get the current element of the iteration use the
+ * 'cur' member.
+ *
+ * Do *not* manipulate the list while iterating!
+ *
+ * NB: this wouldn't really need to be an extra struct, we could use a
+ * slist_node * directly. For consistency reasons with dlist_*iter and
+ * slist_mutable_iter we still use a separate type.
+ */
+typedef struct slist_iter
+{
+	slist_node *cur;
+} slist_iter;
+
+/*
+ * Singly linked list iterator allowing some modifications while iterating
+ *
+ * Used in slist_foreach_modify.
+ *
+ * Iterations using this are allowed to remove the current node and to add more
+ * nodes to the beginning of the list.
+ */
+typedef struct slist_mutable_iter
+{
+	slist_node *cur;
+	slist_node *next;
+} slist_mutable_iter;
+
+
+/*
+ * We take quite some pain to allow this 'module' to be used on compilers
+ * without usable 'static inline' support. If configure detects its not
+ * available all the inline functions will be defined in ilist.c instead by
+ * #define'ing ILIST_USE_DEFINITION there.
+ */
+#ifdef USE_INLINE
+#define INLINE_IF_POSSIBLE static inline
+#else
+/* hide inline declarations from compiler */
+#define INLINE_IF_POSSIBLE
+
+/* Prototypes for functions we want to be inlined if possible */
+extern void dlist_init(dlist_head *head);
+extern bool dlist_is_empty(dlist_head *head);
+extern void dlist_push_head(dlist_head *head, dlist_node *node);
+extern void dlist_push_tail(dlist_head *head, dlist_node *node);
+extern void dlist_insert_after(dlist_head *head,
+				   dlist_node *after, dlist_node *node);
+extern void dlist_insert_before(dlist_head *head,
+					dlist_node *before, dlist_node *node);
+extern void dlist_delete(dlist_head *head, dlist_node *node);
+extern dlist_node *dlist_pop_head_node(dlist_head *head);
+extern void dlist_move_head(dlist_head *head, dlist_node *node);
+extern bool dlist_has_next(dlist_head *head, dlist_node *node);
+extern bool dlist_has_prev(dlist_head *head, dlist_node *node);
+extern dlist_node *dlist_next_node(dlist_head *head, dlist_node *node);
+extern dlist_node *dlist_prev_node(dlist_head *head, dlist_node *node);
+extern dlist_node *dlist_head_node(dlist_head *head);
+extern dlist_node *dlist_tail_node(dlist_head *head);
+
+/* dlist macro support functions */
+extern void *dlist_tail_element_off(dlist_head *head, size_t off);
+extern void *dlist_head_element_off(dlist_head *head, size_t off);
+
+extern void slist_init(slist_head *head);
+extern bool slist_is_empty(slist_head *head);
+extern slist_node *slist_head_node(slist_head *head);
+extern void slist_push_head(slist_head *head, slist_node *node);
+extern slist_node *slist_pop_head_node(slist_head *head);
+extern void slist_insert_after(slist_head *head,
+				   slist_node *after, slist_node *node);
+extern bool slist_has_next(slist_head *head, slist_node *node);
+extern slist_node *slist_next_node(slist_head *head, slist_node *node);
+
+/* slist macro support function */
+extern void *slist_head_element_off(slist_head *head, size_t off);
+#endif   /* !USE_INLINE */
+
+/* These functions are too big to be inline, so they are in the C file always */
+
+/* Attention: O(n) */
+extern void slist_delete(slist_head *head, slist_node *node);
+
+#ifdef ILIST_DEBUG
+extern void dlist_check(dlist_head *head);
+extern void slist_check(slist_head *head);
+#else
+/*
+ * These seemingly useless casts to void are here to keep the compiler quiet
+ * about the argument being unused in many functions in a non-debug compile,
+ * in which functions the only point of passing the list head pointer is to be
+ * able to run these checks.
+ */
+#define dlist_check(head)	(void) (head)
+#define slist_check(head)	(void) (head)
+#endif   /* ILIST_DEBUG */
+
+#define DLIST_STATIC_INIT(name) {{&name.head, &name.head}}
+#define SLIST_STATIC_INIT(name) {{NULL}}
+
+/*
+ * The following function definitions are only used if inlining is supported by
+ * the compiler, or when included from a file that explicitly declares
+ * ILIST_USE_DEFINITION.
+ */
+#if defined(USE_INLINE) || defined(ILIST_DEFINE_FUNCTIONS)
+
+/*
+ * Initialize the head of a list. Previous state will be thrown away without
+ * any cleanup.
+ */
+INLINE_IF_POSSIBLE void
+dlist_init(dlist_head *head)
+{
+	head->head.next = head->head.prev = &head->head;
+
+	dlist_check(head);
+}
+
+/*
+ * Insert a node at the beginning of the list.
+ */
+INLINE_IF_POSSIBLE void
+dlist_push_head(dlist_head *head, dlist_node *node)
+{
+	node->next = head->head.next;
+	node->prev = &head->head;
+	node->next->prev = node;
+	head->head.next = node;
+
+	dlist_check(head);
+}
+
+/*
+ * Inserts a node at the end of the list.
+ */
+INLINE_IF_POSSIBLE void
+dlist_push_tail(dlist_head *head, dlist_node *node)
+{
+	node->next = &head->head;
+	node->prev = head->head.prev;
+	node->prev->next = node;
+	head->head.prev = node;
+
+	dlist_check(head);
+}
+
+/*
+ * Insert a node after another *in the same list*
+ */
+INLINE_IF_POSSIBLE void
+dlist_insert_after(dlist_head *head, dlist_node *after,
+				   dlist_node *node)
+{
+	dlist_check(head);
+	/* XXX: assert 'after' is in 'head'? */
+
+	node->prev = after;
+	node->next = after->next;
+	after->next = node;
+	node->next->prev = node;
+
+	dlist_check(head);
+}
+
+/*
+ * Insert a node before another *in the same list*
+ */
+INLINE_IF_POSSIBLE void
+dlist_insert_before(dlist_head *head, dlist_node *before,
+					dlist_node *node)
+{
+	dlist_check(head);
+	/* XXX: assert 'after' is in 'head'? */
+
+	node->prev = before->prev;
+	node->next = before;
+	before->prev = node;
+	node->prev->next = node;
+
+	dlist_check(head);
+}
+
+/*
+ * Delete 'node' from list.
+ *
+ * It is not allowed to delete a 'node' which is is not in the list 'head'
+ */
+INLINE_IF_POSSIBLE void
+dlist_delete(dlist_head *head, dlist_node *node)
+{
+	dlist_check(head);
+
+	node->prev->next = node->next;
+	node->next->prev = node->prev;
+
+	dlist_check(head);
+}
+
+/*
+ * Delete and return the first node from a list.
+ *
+ * Undefined behaviour when the list is empty, check with dlist_is_empty if
+ * necessary.
+ */
+INLINE_IF_POSSIBLE dlist_node *
+dlist_pop_head_node(dlist_head *head)
+{
+	dlist_node *ret;
+
+	Assert(&head->head != head->head.next);
+
+	ret = head->head.next;
+	dlist_delete(head, head->head.next);
+	return ret;
+}
+
+/*
+ * Move element from any position in the list to the head position in the same
+ * list.
+ *
+ * Undefined behaviour if 'node' is not already part of the list.
+ */
+INLINE_IF_POSSIBLE void
+dlist_move_head(dlist_head *head, dlist_node *node)
+{
+	/* fast path if it's already at the head */
+	if (&head->head == node)
+		return;
+
+	dlist_delete(head, node);
+	dlist_push_head(head, node);
+
+	dlist_check(head);
+}
+
+/*
+ * Check whether the passed node is the last element in the list.
+ */
+INLINE_IF_POSSIBLE bool
+dlist_has_next(dlist_head *head, dlist_node *node)
+{
+	return node->next != &head->head;
+}
+
+/*
+ * Check whether the passed node is the first element in the list.
+ */
+INLINE_IF_POSSIBLE bool
+dlist_has_prev(dlist_head *head, dlist_node *node)
+{
+	return node->prev != &head->head;
+}
+
+/*
+ * Return the next node in the list.
+ *
+ * Undefined bheaviour when no next node exists, use dlist_has_next to make
+ * sure.
+ */
+INLINE_IF_POSSIBLE dlist_node *
+dlist_next_node(dlist_head *head, dlist_node *node)
+{
+	Assert(dlist_has_next(head, node));
+	return node->next;
+}
+
+/*
+ * Return previous node if there is one, NULL otherwise
+ *
+ * Undefined bheaviour when no prev node exists, use dlist_has_prev to make
+ * sure.
+ */
+INLINE_IF_POSSIBLE dlist_node *
+dlist_prev_node(dlist_head *head, dlist_node *node)
+{
+	Assert(dlist_has_prev(head, node));
+	return node->prev;
+}
+
+/*
+ * Return whether the list is empty.
+ */
+INLINE_IF_POSSIBLE bool
+dlist_is_empty(dlist_head *head)
+{
+	return head->head.next == &(head->head);
+}
+
+/* internal support function */
+INLINE_IF_POSSIBLE void *
+dlist_head_element_off(dlist_head *head, size_t off)
+{
+	Assert(!dlist_is_empty(head));
+	return (char *) head->head.next - off;
+}
+
+/*
+ * Return the first node in the list.
+ *
+ * Use dlist_is_empty to make sure the list is not empty if not sure.
+ */
+INLINE_IF_POSSIBLE dlist_node *
+dlist_head_node(dlist_head *head)
+{
+	return dlist_head_element_off(head, 0);
+}
+
+/* internal support function */
+INLINE_IF_POSSIBLE void *
+dlist_tail_element_off(dlist_head *head, size_t off)
+{
+	Assert(!dlist_is_empty(head));
+	return (char *) head->head.prev - off;
+}
+
+/*
+ * Return the last node in the list.
+ *
+ * Use dlist_is_empty to make sure the list is not empty if not sure.
+ */
+INLINE_IF_POSSIBLE dlist_node *
+dlist_tail_node(dlist_head *head)
+{
+	return dlist_tail_element_off(head, 0);
+}
+#endif   /* defined(USE_INLINE) ||
+								 * defined(ILIST_DEFINE_FUNCTIONS) */
+
+/*
+ * Return the containing struct of 'type' where 'membername' is the dlist_node
+ * pointed at by 'ptr'.
+ *
+ * This is used to convert a dlist_node* returned by some list
+ * navigation/manipulation back to its content.
+ *
+ * Note that assert_compatible_types is a compile time only check, so we don't
+ * have multiple evaluation dangers here.
+ */
+#define dlist_container(type, membername, ptr)								 \
+	(assert_compatible_types_bool(dlist_node *, ptr),						 \
+	 assert_compatible_types_bool(dlist_node, ((type *)NULL)->membername),	 \
+	 ((type *)((char *)(ptr) - offsetof(type, membername)))					 \
+	 )
+/*
+ * Return the value of first element in the list.
+ *
+ * The list may not be empty.
+ *
+ * Note that assert_compatible_types is a compile time only check, so we don't
+ * have multiple evaluation dangers here.
+ */
+#define dlist_head_element(type, membername, ptr)							 \
+	(assert_compatible_types_bool(dlist_node, ((type*)NULL)->membername),	 \
+	 ((type *)dlist_get_head_off(ptr, offsetof(type, membername))))
+
+/*
+ * Return the value of first element in the list.
+ *
+ * The list may not be empty.
+ *
+ * Note that assert_compatible_types is a compile time only check, so we don't
+ * have multiple evaluation dangers here.
+ */
+#define dlist_tail_element(type, membername, ptr)							 \
+	(assert_compatible_types_bool(dlist_node, ((type*)NULL)->membername),	 \
+	 ((type *)dlist_tail_element_off(ptr, offsetof(type, membername))))
+
+/*
+ * Iterate through the list pointed at by 'ptr' storing the state in 'iter'.
+ *
+ * Access the current element with iter.cur.
+ *
+ * It is *not* allowed to manipulate the list during iteration.
+ */
+#define dlist_foreach(iter, ptr)											 \
+	assert_compatible_types(dlist_iter, iter);								 \
+	assert_compatible_types(dlist_head *, ptr);								 \
+	for (iter.end = &(ptr)->head, iter.cur = iter.end->next;				 \
+		 iter.cur != iter.end;												 \
+		 iter.cur = iter.cur->next)
+
+
+/*
+ * Iterate through the list pointed at by 'ptr' storing the state in 'iter'.
+ *
+ * Access the current element with iter.cur.
+ *
+ * It is allowed to delete the current element from the list. Every other
+ * manipulation can lead to corruption.
+ */
+#define dlist_foreach_modify(iter, ptr)										 \
+	assert_compatible_types(dlist_mutable_iter, iter);						 \
+	assert_compatible_types(dlist_head *, ptr);								 \
+	for (iter.end = &(ptr)->head, iter.cur = iter.end->next,				 \
+			 iter.next = iter.cur->next;									 \
+		 iter.cur != iter.end;												 \
+		 iter.cur = iter.next, iter.next = iter.cur->next)
+
+/*
+ * Iterate through the list in reverse order.
+ *
+ * It is *not* allowed to manipulate the list during iteration.
+ */
+#define dlist_reverse_foreach(iter, ptr)									 \
+	assert_compatible_types(dlist_iter, iter);								 \
+	assert_compatible_types(dlist_head *, ptr);								 \
+	for (iter.end = &(ptr)->head, iter.cur = iter.end->prev;				 \
+		 iter.cur != iter.end;												 \
+		 iter.cur = iter.cur->prev)
+
+#if defined(USE_INLINE) || defined(ILIST_DEFINE_FUNCTIONS)
+
+/*
+ * Initialize a singly linked list.
+ */
+INLINE_IF_POSSIBLE void
+slist_init(slist_head *head)
+{
+	head->head.next = NULL;
+
+	slist_check(head);
+}
+
+/*
+ * Is the list empty?
+ */
+INLINE_IF_POSSIBLE bool
+slist_is_empty(slist_head *head)
+{
+	slist_check(head);
+
+	return head->head.next == NULL;
+}
+
+/* internal support function */
+INLINE_IF_POSSIBLE void *
+slist_head_element_off(slist_head *head, size_t off)
+{
+	Assert(!slist_is_empty(head));
+	return (char *) head->head.next - off;
+}
+
+/*
+ * Push 'node' as the new first node in the list, pushing the original head to
+ * the second position.
+ */
+INLINE_IF_POSSIBLE void
+slist_push_head(slist_head *head, slist_node *node)
+{
+	node->next = head->head.next;
+	head->head.next = node;
+
+	slist_check(head);
+}
+
+/*
+ * Remove and return the first node in the list
+ *
+ * Undefined behaviour if the list is empty.
+ */
+INLINE_IF_POSSIBLE slist_node *
+slist_pop_head_node(slist_head *head)
+{
+	slist_node *node;
+
+	Assert(!slist_is_empty(head));
+
+	node = head->head.next;
+	head->head.next = head->head.next->next;
+
+	slist_check(head);
+
+	return node;
+}
+
+/*
+ * Insert a new node after another one
+ *
+ * Undefined behaviour if 'after' is not part of the list already.
+ */
+INLINE_IF_POSSIBLE void
+slist_insert_after(slist_head *head, slist_node *after,
+				   slist_node *node)
+{
+	node->next = after->next;
+	after->next = node;
+
+	slist_check(head);
+}
+
+/*
+ * Return whether 'node' has a following node
+ */
+INLINE_IF_POSSIBLE bool
+slist_has_next(slist_head *head,
+			   slist_node *node)
+{
+	slist_check(head);
+
+	return node->next != NULL;
+}
+#endif   /*-- defined(USE_INLINE || ILIST_DEFINE_FUNCTIONS) --*/
+
+/*
+ * Return the containing struct of 'type' where 'membername' is the slist_node
+ * pointed at by 'ptr'.
+ *
+ * This is used to convert a slist_node* returned by some list
+ * navigation/manipulation back to its content.
+ *
+ * Note that assert_compatible_types is a compile time only check, so we don't
+ * have multiple evaluation dangers here.
+ */
+#define slist_container(type, membername, ptr)								 \
+	(assert_compatible_types_bool(slist_node *, ptr),						 \
+	 assert_compatible_types_bool(slist_node, ((type*)NULL)->membername),	 \
+	 ((type *)((char *)(ptr) - offsetof(type, membername)))					 \
+	 )
+/*
+ * Return the value of first element in the list.
+ */
+#define slist_head_element(type, membername, ptr)							 \
+	(assert_compatible_types_bool(slist_node, ((type*)NULL)->membername),	 \
+	 slist_head_element_off(ptr, offsetoff(type, membername)))
+
+/*
+ * Iterate through the list 'ptr' using the iterator 'iter'.
+ *
+ * It is *not* allowed to manipulate the list during iteration.
+ */
+#define slist_foreach(iter, ptr)											 \
+	assert_compatible_types(slist_iter, iter);								 \
+	assert_compatible_types(slist_head *, ptr);								 \
+	for (iter.cur = (ptr)->head.next;										 \
+		 iter.cur != NULL;													 \
+		 iter.cur = iter.cur->next)
+
+/*
+ * Iterate through the list 'ptr' using the iterator 'iter' allowing some
+ * modifications.
+ *
+ * It is allowed to delete the current element from the list and add new nodes
+ * before the current position. Every other manipulation can lead to
+ * corruption.
+ */
+#define slist_foreach_modify(iter, ptr)										 \
+	assert_compatible_types(slist_mutable_iter, iter);						 \
+	assert_compatible_types(slist_head *, ptr);								 \
+	for (iter.cur = (ptr)->head.next,										 \
+			 iter.next = iter.cur ? iter.cur->next : NULL;					 \
+		iter.cur != NULL;													 \
+		iter.cur = iter.next, iter.next = iter.next ? iter.next->next : NULL)
+
+#endif   /* ILIST_H */
-- 
1.7.12.289.g0ce9864.dirty

From 610e58e256ca6240fbfbdc78e527d4f1c4de6882 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Fri, 28 Sep 2012 16:42:03 +0200
Subject: [PATCH 3/4] Remove current users of dllist.h

Alvaro, Andres
---
 src/backend/postmaster/autovacuum.c | 128 ++++++++++++++++----------------
 src/backend/postmaster/postmaster.c |  59 +++++++--------
 src/backend/utils/cache/catcache.c  | 144 ++++++++++++++++++------------------
 src/include/utils/catcache.h        |  19 ++---
 4 files changed, 175 insertions(+), 175 deletions(-)

diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index 74db821..c3ac219 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -77,7 +77,7 @@
 #include "catalog/pg_database.h"
 #include "commands/dbcommands.h"
 #include "commands/vacuum.h"
-#include "lib/dllist.h"
+#include "lib/ilist.h"
 #include "libpq/pqsignal.h"
 #include "miscadmin.h"
 #include "pgstat.h"
@@ -152,6 +152,7 @@ typedef struct avl_dbase
 	Oid			adl_datid;		/* hash key -- must be first */
 	TimestampTz adl_next_worker;
 	int			adl_score;
+	dlist_node	adl_node;
 } avl_dbase;
 
 /* struct to keep track of databases in worker */
@@ -258,8 +259,11 @@ typedef struct
 
 static AutoVacuumShmemStruct *AutoVacuumShmem;
 
-/* the database list in the launcher, and the context that contains it */
-static Dllist *DatabaseList = NULL;
+/*
+ * the database list (of avl_dbase elements) in the launcher, and the context
+ * that contains it
+ */
+static dlist_head DatabaseList = DLIST_STATIC_INIT(DatabaseList);
 static MemoryContext DatabaseListCxt = NULL;
 
 /* Pointer to my own WorkerInfo, valid on each worker */
@@ -508,7 +512,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 
 		/* don't leave dangling pointers to freed memory */
 		DatabaseListCxt = NULL;
-		DatabaseList = NULL;
+		dlist_init(&DatabaseList);
 
 		/*
 		 * Make sure pgstat also considers our stat data as gone.  Note: we
@@ -576,7 +580,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 		struct timeval nap;
 		TimestampTz current_time = 0;
 		bool		can_launch;
-		Dlelem	   *elem;
+		avl_dbase  *avdb;
 		int			rc;
 
 		/*
@@ -738,20 +742,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 
 		/* We're OK to start a new worker */
 
-		elem = DLGetTail(DatabaseList);
-		if (elem != NULL)
-		{
-			avl_dbase  *avdb = DLE_VAL(elem);
-
-			/*
-			 * launch a worker if next_worker is right now or it is in the
-			 * past
-			 */
-			if (TimestampDifferenceExceeds(avdb->adl_next_worker,
-										   current_time, 0))
-				launch_worker(current_time);
-		}
-		else
+		if (dlist_is_empty(&DatabaseList))
 		{
 			/*
 			 * Special case when the list is empty: start a worker right away.
@@ -763,6 +754,23 @@ AutoVacLauncherMain(int argc, char *argv[])
 			 */
 			launch_worker(current_time);
 		}
+		else
+		{
+			/*
+			 * because rebuild_database_list constructs a list with most
+			 * distant adl_next_worker first, we obtain our database from the
+			 * tail of the list.
+			 */
+			avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
+
+			/*
+			 * launch a worker if next_worker is right now or it is in the
+			 * past
+			 */
+			if (TimestampDifferenceExceeds(avdb->adl_next_worker,
+										   current_time, 0))
+				launch_worker(current_time);
+		}
 	}
 
 	/* Normal exit from the autovac launcher is here */
@@ -783,7 +791,7 @@ AutoVacLauncherMain(int argc, char *argv[])
 static void
 launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
 {
-	Dlelem	   *elem;
+	avl_dbase  *avdb;
 
 	/*
 	 * We sleep until the next scheduled vacuum.  We trust that when the
@@ -796,14 +804,15 @@ launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
 		nap->tv_sec = autovacuum_naptime;
 		nap->tv_usec = 0;
 	}
-	else if ((elem = DLGetTail(DatabaseList)) != NULL)
+	else if (!dlist_is_empty(&DatabaseList))
 	{
-		avl_dbase  *avdb = DLE_VAL(elem);
 		TimestampTz current_time = GetCurrentTimestamp();
 		TimestampTz next_wakeup;
 		long		secs;
 		int			usecs;
 
+		avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
+
 		next_wakeup = avdb->adl_next_worker;
 		TimestampDifference(current_time, next_wakeup, &secs, &usecs);
 
@@ -867,6 +876,7 @@ rebuild_database_list(Oid newdb)
 	int			score;
 	int			nelems;
 	HTAB	   *dbhash;
+	dlist_iter  iter;
 
 	/* use fresh stats */
 	autovac_refresh_stats();
@@ -927,36 +937,28 @@ rebuild_database_list(Oid newdb)
 	}
 
 	/* Now insert the databases from the existing list */
-	if (DatabaseList != NULL)
+	dlist_foreach(iter, &DatabaseList)
 	{
-		Dlelem	   *elem;
-
-		elem = DLGetHead(DatabaseList);
-		while (elem != NULL)
-		{
-			avl_dbase  *avdb = DLE_VAL(elem);
-			avl_dbase  *db;
-			bool		found;
-			PgStat_StatDBEntry *entry;
-
-			elem = DLGetSucc(elem);
+		avl_dbase  *avdb = dlist_container(avl_dbase, adl_node, iter.cur);
+		avl_dbase  *db;
+		bool		found;
+		PgStat_StatDBEntry *entry;
 
-			/*
-			 * skip databases with no stat entries -- in particular, this gets
-			 * rid of dropped databases
-			 */
-			entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
-			if (entry == NULL)
-				continue;
+		/*
+		 * skip databases with no stat entries -- in particular, this gets
+		 * rid of dropped databases
+		 */
+		entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
+		if (entry == NULL)
+			continue;
 
-			db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
+		db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
 
-			if (!found)
-			{
-				/* hash_search already filled in the key */
-				db->adl_score = score++;
-				/* next_worker is filled in later */
-			}
+		if (!found)
+		{
+			/* hash_search already filled in the key */
+			db->adl_score = score++;
+			/* next_worker is filled in later */
 		}
 	}
 
@@ -987,7 +989,7 @@ rebuild_database_list(Oid newdb)
 
 	/* from here on, the allocated memory belongs to the new list */
 	MemoryContextSwitchTo(newcxt);
-	DatabaseList = DLNewList();
+	dlist_init(&DatabaseList);
 
 	if (nelems > 0)
 	{
@@ -1029,15 +1031,13 @@ rebuild_database_list(Oid newdb)
 		for (i = 0; i < nelems; i++)
 		{
 			avl_dbase  *db = &(dbary[i]);
-			Dlelem	   *elem;
 
 			current_time = TimestampTzPlusMilliseconds(current_time,
 													   millis_increment);
 			db->adl_next_worker = current_time;
 
-			elem = DLNewElem(db);
 			/* later elements should go closer to the head of the list */
-			DLAddHead(DatabaseList, elem);
+			dlist_push_head(&DatabaseList, &db->adl_node);
 		}
 	}
 
@@ -1147,7 +1147,7 @@ do_start_worker(void)
 	foreach(cell, dblist)
 	{
 		avw_dbase  *tmp = lfirst(cell);
-		Dlelem	   *elem;
+		dlist_iter iter;
 
 		/* Check to see if this one is at risk of wraparound */
 		if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
@@ -1179,11 +1179,10 @@ do_start_worker(void)
 		 * autovacuum time yet.
 		 */
 		skipit = false;
-		elem = DatabaseList ? DLGetTail(DatabaseList) : NULL;
 
-		while (elem != NULL)
+		dlist_reverse_foreach(iter, &DatabaseList)
 		{
-			avl_dbase  *dbp = DLE_VAL(elem);
+			avl_dbase  *dbp = dlist_container(avl_dbase, adl_node, iter.cur);
 
 			if (dbp->adl_datid == tmp->adw_datid)
 			{
@@ -1200,7 +1199,6 @@ do_start_worker(void)
 
 				break;
 			}
-			elem = DLGetPred(elem);
 		}
 		if (skipit)
 			continue;
@@ -1274,22 +1272,25 @@ static void
 launch_worker(TimestampTz now)
 {
 	Oid			dbid;
-	Dlelem	   *elem;
+	dlist_iter  iter;
 
 	dbid = do_start_worker();
 	if (OidIsValid(dbid))
 	{
+		bool found = false;
+
 		/*
 		 * Walk the database list and update the corresponding entry.  If the
 		 * database is not on the list, we'll recreate the list.
 		 */
-		elem = (DatabaseList == NULL) ? NULL : DLGetHead(DatabaseList);
-		while (elem != NULL)
+		dlist_foreach(iter, &DatabaseList)
 		{
-			avl_dbase  *avdb = DLE_VAL(elem);
+			avl_dbase  *avdb = dlist_container(avl_dbase, adl_node, iter.cur);
 
 			if (avdb->adl_datid == dbid)
 			{
+				found = true;
+
 				/*
 				 * add autovacuum_naptime seconds to the current time, and use
 				 * that as the new "next_worker" field for this database.
@@ -1297,10 +1298,9 @@ launch_worker(TimestampTz now)
 				avdb->adl_next_worker =
 					TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000);
 
-				DLMoveToFront(elem);
+				dlist_move_head(&DatabaseList, iter.cur);
 				break;
 			}
-			elem = DLGetSucc(elem);
 		}
 
 		/*
@@ -1310,7 +1310,7 @@ launch_worker(TimestampTz now)
 		 * pgstat entry, but this is not a problem because we don't want to
 		 * schedule workers regularly into those in any case.
 		 */
-		if (elem == NULL)
+		if (!found)
 			rebuild_database_list(dbid);
 	}
 }
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index dff4c71..7060a1f 100644
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -95,7 +95,7 @@
 #include "access/xlog.h"
 #include "bootstrap/bootstrap.h"
 #include "catalog/pg_control.h"
-#include "lib/dllist.h"
+#include "lib/ilist.h"
 #include "libpq/auth.h"
 #include "libpq/ip.h"
 #include "libpq/libpq.h"
@@ -146,10 +146,10 @@ typedef struct bkend
 	int			child_slot;		/* PMChildSlot for this backend, if any */
 	bool		is_autovacuum;	/* is it an autovacuum process? */
 	bool		dead_end;		/* is it going to send an error and quit? */
-	Dlelem		elem;			/* list link in BackendList */
+	dlist_node	elem;			/* list link in BackendList */
 } Backend;
 
-static Dllist *BackendList;
+static dlist_head BackendList = DLIST_STATIC_INIT(BackendList);
 
 #ifdef EXEC_BACKEND
 static Backend *ShmemBackendArray;
@@ -157,8 +157,10 @@ static Backend *ShmemBackendArray;
 
 /* The socket number we are listening for connections on */
 int			PostPortNumber;
+
 /* The directory names for Unix socket(s) */
 char	   *Unix_socket_directories;
+
 /* The TCP listen address(es) */
 char	   *ListenAddresses;
 
@@ -1028,11 +1030,6 @@ PostmasterMain(int argc, char *argv[])
 	set_stack_base();
 
 	/*
-	 * Initialize the list of active backends.
-	 */
-	BackendList = DLNewList();
-
-	/*
 	 * Initialize pipe (or process handle on Windows) that allows children to
 	 * wake up from sleep on postmaster death.
 	 */
@@ -1872,7 +1869,7 @@ processCancelRequest(Port *port, void *pkt)
 	Backend    *bp;
 
 #ifndef EXEC_BACKEND
-	Dlelem	   *curr;
+	dlist_iter  iter;
 #else
 	int			i;
 #endif
@@ -1886,9 +1883,9 @@ processCancelRequest(Port *port, void *pkt)
 	 * duplicate array in shared memory.
 	 */
 #ifndef EXEC_BACKEND
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	dlist_foreach(iter, &BackendList)
 	{
-		bp = (Backend *) DLE_VAL(curr);
+		bp = dlist_container(Backend, elem, iter.cur);
 #else
 	for (i = MaxLivePostmasterChildren() - 1; i >= 0; i--)
 	{
@@ -2648,7 +2645,7 @@ static void
 CleanupBackend(int pid,
 			   int exitstatus)	/* child's exit status. */
 {
-	Dlelem	   *curr;
+	dlist_mutable_iter iter;
 
 	LogChildExit(DEBUG2, _("server process"), pid, exitstatus);
 
@@ -2680,9 +2677,9 @@ CleanupBackend(int pid,
 		return;
 	}
 
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	dlist_foreach_modify(iter, &BackendList)
 	{
-		Backend    *bp = (Backend *) DLE_VAL(curr);
+		Backend    *bp = dlist_container(Backend, elem, iter.cur);
 
 		if (bp->pid == pid)
 		{
@@ -2701,7 +2698,7 @@ CleanupBackend(int pid,
 				ShmemBackendArrayRemove(bp);
 #endif
 			}
-			DLRemove(curr);
+			dlist_delete(&BackendList, iter.cur);
 			free(bp);
 			break;
 		}
@@ -2718,8 +2715,7 @@ CleanupBackend(int pid,
 static void
 HandleChildCrash(int pid, int exitstatus, const char *procname)
 {
-	Dlelem	   *curr,
-			   *next;
+	dlist_mutable_iter iter;
 	Backend    *bp;
 
 	/*
@@ -2734,10 +2730,10 @@ HandleChildCrash(int pid, int exitstatus, const char *procname)
 	}
 
 	/* Process regular backends */
-	for (curr = DLGetHead(BackendList); curr; curr = next)
+	dlist_foreach_modify(iter, &BackendList)
 	{
-		next = DLGetSucc(curr);
-		bp = (Backend *) DLE_VAL(curr);
+		bp = dlist_container(Backend, elem, iter.cur);
+
 		if (bp->pid == pid)
 		{
 			/*
@@ -2750,7 +2746,7 @@ HandleChildCrash(int pid, int exitstatus, const char *procname)
 				ShmemBackendArrayRemove(bp);
 #endif
 			}
-			DLRemove(curr);
+			dlist_delete(&BackendList, iter.cur);
 			free(bp);
 			/* Keep looping so we can signal remaining backends */
 		}
@@ -3113,7 +3109,7 @@ PostmasterStateMachine(void)
 		 * normal state transition leading up to PM_WAIT_DEAD_END, or during
 		 * FatalError processing.
 		 */
-		if (DLGetHead(BackendList) == NULL &&
+		if (dlist_is_empty(&BackendList) &&
 			PgArchPID == 0 && PgStatPID == 0)
 		{
 			/* These other guys should be dead already */
@@ -3239,12 +3235,12 @@ signal_child(pid_t pid, int signal)
 static bool
 SignalSomeChildren(int signal, int target)
 {
-	Dlelem	   *curr;
+	dlist_iter  iter;
 	bool		signaled = false;
 
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	dlist_foreach(iter, &BackendList)
 	{
-		Backend    *bp = (Backend *) DLE_VAL(curr);
+		Backend    *bp = dlist_container(Backend, elem, iter.cur);
 
 		if (bp->dead_end)
 			continue;
@@ -3382,8 +3378,8 @@ BackendStartup(Port *port)
 	 */
 	bn->pid = pid;
 	bn->is_autovacuum = false;
-	DLInitElem(&bn->elem, bn);
-	DLAddHead(BackendList, &bn->elem);
+	dlist_push_head(&BackendList, &bn->elem);
+
 #ifdef EXEC_BACKEND
 	if (!bn->dead_end)
 		ShmemBackendArrayAdd(bn);
@@ -4498,12 +4494,12 @@ PostmasterRandom(void)
 static int
 CountChildren(int target)
 {
-	Dlelem	   *curr;
+	dlist_iter  iter;
 	int			cnt = 0;
 
-	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
+	dlist_foreach(iter, &BackendList)
 	{
-		Backend    *bp = (Backend *) DLE_VAL(curr);
+		Backend    *bp = dlist_container(Backend, elem, iter.cur);
 
 		if (bp->dead_end)
 			continue;
@@ -4682,8 +4678,7 @@ StartAutovacuumWorker(void)
 			if (bn->pid > 0)
 			{
 				bn->is_autovacuum = true;
-				DLInitElem(&bn->elem, bn);
-				DLAddHead(BackendList, &bn->elem);
+				dlist_push_head(&BackendList, &bn->elem);
 #ifdef EXEC_BACKEND
 				ShmemBackendArrayAdd(bn);
 #endif
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index d6f6b1c..230ddf4 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -291,7 +291,7 @@ CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple)
 static void
 CatCachePrintStats(int code, Datum arg)
 {
-	CatCache   *cache;
+	slist_iter  iter;
 	long		cc_searches = 0;
 	long		cc_hits = 0;
 	long		cc_neg_hits = 0;
@@ -300,8 +300,10 @@ CatCachePrintStats(int code, Datum arg)
 	long		cc_lsearches = 0;
 	long		cc_lhits = 0;
 
-	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
+	slist_foreach(iter, &CacheHdr->ch_caches)
 	{
+		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
+
 		if (cache->cc_ntup == 0 && cache->cc_searches == 0)
 			continue;			/* don't print unused caches */
 		elog(DEBUG2, "catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld lsrch, %ld lhits",
@@ -368,8 +370,7 @@ CatCacheRemoveCTup(CatCache *cache, CatCTup *ct)
 		return;					/* nothing left to do */
 	}
 
-	/* delink from linked list */
-	DLRemove(&ct->cache_elem);
+	dlist_delete(ct->cache_bucket, &ct->cache_elem);
 
 	/* free associated tuple data */
 	if (ct->tuple.t_data != NULL)
@@ -412,7 +413,7 @@ CatCacheRemoveCList(CatCache *cache, CatCList *cl)
 	}
 
 	/* delink from linked list */
-	DLRemove(&cl->cache_elem);
+	dlist_delete(&cache->cc_lists, &cl->cache_elem);
 
 	/* free associated tuple data */
 	if (cl->tuple.t_data != NULL)
@@ -442,18 +443,18 @@ CatCacheRemoveCList(CatCache *cache, CatCList *cl)
 void
 CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 {
-	CatCache   *ccp;
+	slist_iter cache_iter;
 
 	CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
 
 	/*
 	 * inspect caches to find the proper cache
 	 */
-	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
+	slist_foreach(cache_iter, &CacheHdr->ch_caches)
 	{
 		Index		hashIndex;
-		Dlelem	   *elt,
-				   *nextelt;
+		dlist_mutable_iter iter;
+		CatCache   *ccp = slist_container(CatCache, cc_next, cache_iter.cur);
 
 		if (cacheId != ccp->id)
 			continue;
@@ -468,11 +469,9 @@ CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 		 * Invalidate *all* CatCLists in this cache; it's too hard to tell
 		 * which searches might still be correct, so just zap 'em all.
 		 */
-		for (elt = DLGetHead(&ccp->cc_lists); elt; elt = nextelt)
+		dlist_foreach_modify(iter, &ccp->cc_lists)
 		{
-			CatCList   *cl = (CatCList *) DLE_VAL(elt);
-
-			nextelt = DLGetSucc(elt);
+			CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
 
 			if (cl->refcount > 0)
 				cl->dead = true;
@@ -484,12 +483,9 @@ CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
 		 * inspect the proper hash bucket for tuple matches
 		 */
 		hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets);
-
-		for (elt = DLGetHead(&ccp->cc_bucket[hashIndex]); elt; elt = nextelt)
+		dlist_foreach_modify(iter, &ccp->cc_bucket[hashIndex])
 		{
-			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
-
-			nextelt = DLGetSucc(elt);
+			CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
 
 			if (hashValue == ct->hash_value)
 			{
@@ -557,17 +553,18 @@ AtEOXact_CatCache(bool isCommit)
 #ifdef USE_ASSERT_CHECKING
 	if (assert_enabled)
 	{
-		CatCache   *ccp;
+		slist_iter  cache_iter;
 
-		for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
+		slist_foreach(cache_iter, &(CacheHdr->ch_caches))
 		{
-			Dlelem	   *elt;
+			CatCache   *ccp = slist_container(CatCache, cc_next, cache_iter.cur);
+			dlist_iter  iter;
 			int			i;
 
 			/* Check CatCLists */
-			for (elt = DLGetHead(&ccp->cc_lists); elt; elt = DLGetSucc(elt))
+			dlist_foreach(iter, &ccp->cc_lists)
 			{
-				CatCList   *cl = (CatCList *) DLE_VAL(elt);
+				CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
 
 				Assert(cl->cl_magic == CL_MAGIC);
 				Assert(cl->refcount == 0);
@@ -577,11 +574,11 @@ AtEOXact_CatCache(bool isCommit)
 			/* Check individual tuples */
 			for (i = 0; i < ccp->cc_nbuckets; i++)
 			{
-				for (elt = DLGetHead(&ccp->cc_bucket[i]);
-					 elt;
-					 elt = DLGetSucc(elt))
+				dlist_head *bucket = &ccp->cc_bucket[i];
+
+				dlist_foreach(iter, bucket)
 				{
-					CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
+					CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
 
 					Assert(ct->ct_magic == CT_MAGIC);
 					Assert(ct->refcount == 0);
@@ -604,16 +601,13 @@ AtEOXact_CatCache(bool isCommit)
 static void
 ResetCatalogCache(CatCache *cache)
 {
-	Dlelem	   *elt,
-			   *nextelt;
+	dlist_mutable_iter iter;
 	int			i;
 
 	/* Remove each list in this cache, or at least mark it dead */
-	for (elt = DLGetHead(&cache->cc_lists); elt; elt = nextelt)
+	dlist_foreach_modify(iter, &cache->cc_lists)
 	{
-		CatCList   *cl = (CatCList *) DLE_VAL(elt);
-
-		nextelt = DLGetSucc(elt);
+		CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
 
 		if (cl->refcount > 0)
 			cl->dead = true;
@@ -624,11 +618,11 @@ ResetCatalogCache(CatCache *cache)
 	/* Remove each tuple in this cache, or at least mark it dead */
 	for (i = 0; i < cache->cc_nbuckets; i++)
 	{
-		for (elt = DLGetHead(&cache->cc_bucket[i]); elt; elt = nextelt)
-		{
-			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
+		dlist_head *bucket = &cache->cc_bucket[i];
 
-			nextelt = DLGetSucc(elt);
+		dlist_foreach_modify(iter, bucket)
+		{
+			CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
 
 			if (ct->refcount > 0 ||
 				(ct->c_list && ct->c_list->refcount > 0))
@@ -654,12 +648,16 @@ ResetCatalogCache(CatCache *cache)
 void
 ResetCatalogCaches(void)
 {
-	CatCache   *cache;
+	slist_iter    iter;
 
 	CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
 
-	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
+	slist_foreach(iter, &CacheHdr->ch_caches)
+	{
+		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
+
 		ResetCatalogCache(cache);
+	}
 
 	CACHE1_elog(DEBUG2, "end of ResetCatalogCaches call");
 }
@@ -680,12 +678,14 @@ ResetCatalogCaches(void)
 void
 CatalogCacheFlushCatalog(Oid catId)
 {
-	CatCache   *cache;
+	slist_iter  iter;
 
 	CACHE2_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
 
-	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
+	slist_foreach(iter, &(CacheHdr->ch_caches))
 	{
+		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
+
 		/* Does this cache store tuples of the target catalog? */
 		if (cache->cc_reloid == catId)
 		{
@@ -760,7 +760,7 @@ InitCatCache(int id,
 	if (CacheHdr == NULL)
 	{
 		CacheHdr = (CatCacheHeader *) palloc(sizeof(CatCacheHeader));
-		CacheHdr->ch_caches = NULL;
+		slist_init(&CacheHdr->ch_caches);
 		CacheHdr->ch_ntup = 0;
 #ifdef CATCACHE_STATS
 		/* set up to dump stats at backend exit */
@@ -770,10 +770,8 @@ InitCatCache(int id,
 
 	/*
 	 * allocate a new cache structure
-	 *
-	 * Note: we assume zeroing initializes the Dllist headers correctly
 	 */
-	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(Dllist));
+	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(dlist_node));
 
 	/*
 	 * initialize the cache's relation information for the relation
@@ -792,6 +790,11 @@ InitCatCache(int id,
 	for (i = 0; i < nkeys; ++i)
 		cp->cc_key[i] = key[i];
 
+	dlist_init(&cp->cc_lists);
+
+	for (i = 0; i < nbuckets; i++)
+		dlist_init(&cp->cc_bucket[i]);
+
 	/*
 	 * new cache is initialized as far as we can go for now. print some
 	 * debugging information, if appropriate.
@@ -801,8 +804,7 @@ InitCatCache(int id,
 	/*
 	 * add completed cache to top of group header's list
 	 */
-	cp->cc_next = CacheHdr->ch_caches;
-	CacheHdr->ch_caches = cp;
+	slist_push_head(&CacheHdr->ch_caches, &cp->cc_next);
 
 	/*
 	 * back to the old context before we return...
@@ -1060,7 +1062,8 @@ SearchCatCache(CatCache *cache,
 	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
 	uint32		hashValue;
 	Index		hashIndex;
-	Dlelem	   *elt;
+	dlist_mutable_iter  iter;
+	dlist_head *bucket;
 	CatCTup    *ct;
 	Relation	relation;
 	SysScanDesc scandesc;
@@ -1094,13 +1097,13 @@ SearchCatCache(CatCache *cache,
 	/*
 	 * scan the hash bucket until we find a match or exhaust our tuples
 	 */
-	for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
-		 elt;
-		 elt = DLGetSucc(elt))
+	bucket = &cache->cc_bucket[hashIndex];
+
+	dlist_foreach_modify(iter, bucket)
 	{
 		bool		res;
 
-		ct = (CatCTup *) DLE_VAL(elt);
+		ct = dlist_container(CatCTup, cache_elem, iter.cur);
 
 		if (ct->dead)
 			continue;			/* ignore dead entries */
@@ -1125,7 +1128,7 @@ SearchCatCache(CatCache *cache,
 		 * most frequently accessed elements in any hashbucket will tend to be
 		 * near the front of the hashbucket's list.)
 		 */
-		DLMoveToFront(&ct->cache_elem);
+		dlist_move_head(bucket, &ct->cache_elem);
 
 		/*
 		 * If it's a positive entry, bump its refcount and return it. If it's
@@ -1340,7 +1343,7 @@ SearchCatCacheList(CatCache *cache,
 {
 	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
 	uint32		lHashValue;
-	Dlelem	   *elt;
+	dlist_iter  iter;
 	CatCList   *cl;
 	CatCTup    *ct;
 	List	   *volatile ctlist;
@@ -1382,13 +1385,11 @@ SearchCatCacheList(CatCache *cache,
 	/*
 	 * scan the items until we find a match or exhaust our list
 	 */
-	for (elt = DLGetHead(&cache->cc_lists);
-		 elt;
-		 elt = DLGetSucc(elt))
+	dlist_foreach(iter, &cache->cc_lists)
 	{
 		bool		res;
 
-		cl = (CatCList *) DLE_VAL(elt);
+		cl = dlist_container(CatCList, cache_elem, iter.cur);
 
 		if (cl->dead)
 			continue;			/* ignore dead entries */
@@ -1416,7 +1417,7 @@ SearchCatCacheList(CatCache *cache,
 		 * since there's no point in that unless they are searched for
 		 * individually.)
 		 */
-		DLMoveToFront(&cl->cache_elem);
+		dlist_move_head(&cache->cc_lists, &cl->cache_elem);
 
 		/* Bump the list's refcount and return it */
 		ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
@@ -1468,6 +1469,8 @@ SearchCatCacheList(CatCache *cache,
 		{
 			uint32		hashValue;
 			Index		hashIndex;
+			bool		found = false;
+			dlist_head *bucket;
 
 			/*
 			 * See if there's an entry for this tuple already.
@@ -1476,11 +1479,10 @@ SearchCatCacheList(CatCache *cache,
 			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);
 			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
 
-			for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
-				 elt;
-				 elt = DLGetSucc(elt))
+			bucket = &cache->cc_bucket[hashIndex];
+			dlist_foreach(iter, bucket)
 			{
-				ct = (CatCTup *) DLE_VAL(elt);
+				ct = dlist_container(CatCTup, cache_elem, iter.cur);
 
 				if (ct->dead || ct->negative)
 					continue;	/* ignore dead and negative entries */
@@ -1498,10 +1500,11 @@ SearchCatCacheList(CatCache *cache,
 				if (ct->c_list)
 					continue;
 
+				found = true;
 				break;			/* A-OK */
 			}
 
-			if (elt == NULL)
+			if (!found)
 			{
 				/* We didn't find a usable entry, so make a new one */
 				ct = CatalogCacheCreateEntry(cache, ntp,
@@ -1564,7 +1567,6 @@ SearchCatCacheList(CatCache *cache,
 
 	cl->cl_magic = CL_MAGIC;
 	cl->my_cache = cache;
-	DLInitElem(&cl->cache_elem, cl);
 	cl->refcount = 0;			/* for the moment */
 	cl->dead = false;
 	cl->ordered = ordered;
@@ -1587,7 +1589,7 @@ SearchCatCacheList(CatCache *cache,
 	}
 	Assert(i == nmembers);
 
-	DLAddHead(&cache->cc_lists, &cl->cache_elem);
+	dlist_push_head(&cache->cc_lists, &cl->cache_elem);
 
 	/* Finally, bump the list's refcount and return it */
 	cl->refcount++;
@@ -1664,14 +1666,15 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp,
 	 */
 	ct->ct_magic = CT_MAGIC;
 	ct->my_cache = cache;
-	DLInitElem(&ct->cache_elem, (void *) ct);
+	ct->cache_bucket = &cache->cc_bucket[hashIndex];
+
 	ct->c_list = NULL;
 	ct->refcount = 0;			/* for the moment */
 	ct->dead = false;
 	ct->negative = negative;
 	ct->hash_value = hashValue;
 
-	DLAddHead(&cache->cc_bucket[hashIndex], &ct->cache_elem);
+	dlist_push_head(ct->cache_bucket, &ct->cache_elem);
 
 	cache->cc_ntup++;
 	CacheHdr->ch_ntup++;
@@ -1785,7 +1788,7 @@ PrepareToInvalidateCacheTuple(Relation relation,
 							  HeapTuple newtuple,
 							  void (*function) (int, uint32, Oid))
 {
-	CatCache   *ccp;
+	slist_iter  iter;
 	Oid			reloid;
 
 	CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
@@ -1808,10 +1811,11 @@ PrepareToInvalidateCacheTuple(Relation relation,
 	 * ----------------
 	 */
 
-	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
+	slist_foreach(iter, &(CacheHdr->ch_caches))
 	{
 		uint32		hashvalue;
 		Oid			dbid;
+		CatCache   *ccp = slist_container(CatCache, cc_next, iter.cur);
 
 		if (ccp->cc_reloid != reloid)
 			continue;
diff --git a/src/include/utils/catcache.h b/src/include/utils/catcache.h
index d91700a..cc6dab2 100644
--- a/src/include/utils/catcache.h
+++ b/src/include/utils/catcache.h
@@ -22,7 +22,7 @@
 
 #include "access/htup.h"
 #include "access/skey.h"
-#include "lib/dllist.h"
+#include "lib/ilist.h"
 #include "utils/relcache.h"
 
 /*
@@ -37,7 +37,7 @@
 typedef struct catcache
 {
 	int			id;				/* cache identifier --- see syscache.h */
-	struct catcache *cc_next;	/* link to next catcache */
+	slist_node	cc_next;		/* list link */
 	const char *cc_relname;		/* name of relation the tuples come from */
 	Oid			cc_reloid;		/* OID of relation the tuples come from */
 	Oid			cc_indexoid;	/* OID of index matching cache keys */
@@ -51,7 +51,7 @@ typedef struct catcache
 	ScanKeyData cc_skey[CATCACHE_MAXKEYS];		/* precomputed key info for
 												 * heap scans */
 	bool		cc_isname[CATCACHE_MAXKEYS];	/* flag "name" key columns */
-	Dllist		cc_lists;		/* list of CatCList structs */
+	dlist_head	cc_lists;		/* list of CatCList structs */
 #ifdef CATCACHE_STATS
 	long		cc_searches;	/* total # searches against this cache */
 	long		cc_hits;		/* # of matches against existing entry */
@@ -66,7 +66,7 @@ typedef struct catcache
 	long		cc_lsearches;	/* total # list-searches */
 	long		cc_lhits;		/* # of matches against existing lists */
 #endif
-	Dllist		cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
+	dlist_head	cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
 } CatCache;						/* VARIABLE LENGTH STRUCT */
 
 
@@ -77,11 +77,12 @@ typedef struct catctup
 	CatCache   *my_cache;		/* link to owning catcache */
 
 	/*
-	 * Each tuple in a cache is a member of a Dllist that stores the elements
-	 * of its hash bucket.	We keep each Dllist in LRU order to speed repeated
+	 * Each tuple in a cache is a member of a dlist that stores the elements
+	 * of its hash bucket.	We keep each dlist in LRU order to speed repeated
 	 * lookups.
 	 */
-	Dlelem		cache_elem;		/* list member of per-bucket list */
+	dlist_node	cache_elem;		/* list member of per-bucket list */
+	dlist_head *cache_bucket;	/* containing bucket dlist */
 
 	/*
 	 * The tuple may also be a member of at most one CatCList.	(If a single
@@ -139,7 +140,7 @@ typedef struct catclist
 	 * might not be true during bootstrap or recovery operations. (namespace.c
 	 * is able to save some cycles when it is true.)
 	 */
-	Dlelem		cache_elem;		/* list member of per-catcache list */
+	dlist_node	cache_elem;		/* list member of per-catcache list */
 	int			refcount;		/* number of active references */
 	bool		dead;			/* dead but not yet removed? */
 	bool		ordered;		/* members listed in index order? */
@@ -153,7 +154,7 @@ typedef struct catclist
 
 typedef struct catcacheheader
 {
-	CatCache   *ch_caches;		/* head of list of CatCache structs */
+	slist_head	ch_caches;		/* head of list of CatCache structs */
 	int			ch_ntup;		/* # of tuples in all caches */
 } CatCacheHeader;
 
-- 
1.7.12.289.g0ce9864.dirty

From 0a7ccf3e72d9a2a3a4d5e11fdadf5be6d1d4840b Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Fri, 28 Sep 2012 16:44:16 +0200
Subject: [PATCH 4/4] Remove dllist.[ch]

---
 src/backend/lib/Makefile |   2 +-
 src/backend/lib/dllist.c | 214 -----------------------------------------------
 src/include/lib/dllist.h |  85 -------------------
 3 files changed, 1 insertion(+), 300 deletions(-)
 delete mode 100644 src/backend/lib/dllist.c
 delete mode 100644 src/include/lib/dllist.h

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index c94297a..7da1c45 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/lib
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = dllist.o stringinfo.o ilist.o
+OBJS = stringinfo.o ilist.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/dllist.c b/src/backend/lib/dllist.c
deleted file mode 100644
index 52af56a..0000000
--- a/src/backend/lib/dllist.c
+++ /dev/null
@@ -1,214 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * dllist.c
- *	  this is a simple doubly linked list implementation
- *	  the elements of the lists are void*
- *
- * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/lib/dllist.c
- *
- *-------------------------------------------------------------------------
- */
-#include "postgres.h"
-
-#include "lib/dllist.h"
-
-
-Dllist *
-DLNewList(void)
-{
-	Dllist	   *l;
-
-	l = (Dllist *) palloc(sizeof(Dllist));
-
-	l->dll_head = NULL;
-	l->dll_tail = NULL;
-
-	return l;
-}
-
-void
-DLInitList(Dllist *list)
-{
-	list->dll_head = NULL;
-	list->dll_tail = NULL;
-}
-
-/*
- * free up a list and all the nodes in it --- but *not* whatever the nodes
- * might point to!
- */
-void
-DLFreeList(Dllist *list)
-{
-	Dlelem	   *curr;
-
-	while ((curr = DLRemHead(list)) != NULL)
-		pfree(curr);
-
-	pfree(list);
-}
-
-Dlelem *
-DLNewElem(void *val)
-{
-	Dlelem	   *e;
-
-	e = (Dlelem *) palloc(sizeof(Dlelem));
-
-	e->dle_next = NULL;
-	e->dle_prev = NULL;
-	e->dle_val = val;
-	e->dle_list = NULL;
-	return e;
-}
-
-void
-DLInitElem(Dlelem *e, void *val)
-{
-	e->dle_next = NULL;
-	e->dle_prev = NULL;
-	e->dle_val = val;
-	e->dle_list = NULL;
-}
-
-void
-DLFreeElem(Dlelem *e)
-{
-	pfree(e);
-}
-
-void
-DLRemove(Dlelem *e)
-{
-	Dllist	   *l = e->dle_list;
-
-	if (e->dle_prev)
-		e->dle_prev->dle_next = e->dle_next;
-	else
-	{
-		/* must be the head element */
-		Assert(e == l->dll_head);
-		l->dll_head = e->dle_next;
-	}
-	if (e->dle_next)
-		e->dle_next->dle_prev = e->dle_prev;
-	else
-	{
-		/* must be the tail element */
-		Assert(e == l->dll_tail);
-		l->dll_tail = e->dle_prev;
-	}
-
-	e->dle_next = NULL;
-	e->dle_prev = NULL;
-	e->dle_list = NULL;
-}
-
-void
-DLAddHead(Dllist *l, Dlelem *e)
-{
-	e->dle_list = l;
-
-	if (l->dll_head)
-		l->dll_head->dle_prev = e;
-	e->dle_next = l->dll_head;
-	e->dle_prev = NULL;
-	l->dll_head = e;
-
-	if (l->dll_tail == NULL)	/* if this is first element added */
-		l->dll_tail = e;
-}
-
-void
-DLAddTail(Dllist *l, Dlelem *e)
-{
-	e->dle_list = l;
-
-	if (l->dll_tail)
-		l->dll_tail->dle_next = e;
-	e->dle_prev = l->dll_tail;
-	e->dle_next = NULL;
-	l->dll_tail = e;
-
-	if (l->dll_head == NULL)	/* if this is first element added */
-		l->dll_head = e;
-}
-
-Dlelem *
-DLRemHead(Dllist *l)
-{
-	/* remove and return the head */
-	Dlelem	   *result = l->dll_head;
-
-	if (result == NULL)
-		return result;
-
-	if (result->dle_next)
-		result->dle_next->dle_prev = NULL;
-
-	l->dll_head = result->dle_next;
-
-	if (result == l->dll_tail)	/* if the head is also the tail */
-		l->dll_tail = NULL;
-
-	result->dle_next = NULL;
-	result->dle_list = NULL;
-
-	return result;
-}
-
-Dlelem *
-DLRemTail(Dllist *l)
-{
-	/* remove and return the tail */
-	Dlelem	   *result = l->dll_tail;
-
-	if (result == NULL)
-		return result;
-
-	if (result->dle_prev)
-		result->dle_prev->dle_next = NULL;
-
-	l->dll_tail = result->dle_prev;
-
-	if (result == l->dll_head)	/* if the tail is also the head */
-		l->dll_head = NULL;
-
-	result->dle_prev = NULL;
-	result->dle_list = NULL;
-
-	return result;
-}
-
-/* Same as DLRemove followed by DLAddHead, but faster */
-void
-DLMoveToFront(Dlelem *e)
-{
-	Dllist	   *l = e->dle_list;
-
-	if (l->dll_head == e)
-		return;					/* Fast path if already at front */
-
-	Assert(e->dle_prev != NULL);	/* since it's not the head */
-	e->dle_prev->dle_next = e->dle_next;
-
-	if (e->dle_next)
-		e->dle_next->dle_prev = e->dle_prev;
-	else
-	{
-		/* must be the tail element */
-		Assert(e == l->dll_tail);
-		l->dll_tail = e->dle_prev;
-	}
-
-	l->dll_head->dle_prev = e;
-	e->dle_next = l->dll_head;
-	e->dle_prev = NULL;
-	l->dll_head = e;
-	/* We need not check dll_tail, since there must have been > 1 entry */
-}
diff --git a/src/include/lib/dllist.h b/src/include/lib/dllist.h
deleted file mode 100644
index 25ed64c..0000000
--- a/src/include/lib/dllist.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * dllist.h
- *		simple doubly linked list primitives
- *		the elements of the list are void* so the lists can contain anything
- *		Dlelem can only be in one list at a time
- *
- *
- *	 Here's a small example of how to use Dllists:
- *
- *	 Dllist *lst;
- *	 Dlelem *elt;
- *	 void	*in_stuff;	  -- stuff to stick in the list
- *	 void	*out_stuff
- *
- *	 lst = DLNewList();				   -- make a new dllist
- *	 DLAddHead(lst, DLNewElem(in_stuff)); -- add a new element to the list
- *											 with in_stuff as the value
- *	  ...
- *	 elt = DLGetHead(lst);			   -- retrieve the head element
- *	 out_stuff = (void*)DLE_VAL(elt);  -- get the stuff out
- *	 DLRemove(elt);					   -- removes the element from its list
- *	 DLFreeElem(elt);				   -- free the element since we don't
- *										  use it anymore
- *
- *
- * It is also possible to use Dllist objects that are embedded in larger
- * structures instead of being separately malloc'd.  To do this, use
- * DLInitElem() to initialize a Dllist field within a larger object.
- * Don't forget to DLRemove() each field from its list (if any) before
- * freeing the larger object!
- *
- *
- * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/lib/dllist.h
- *
- *-------------------------------------------------------------------------
- */
-
-#ifndef DLLIST_H
-#define DLLIST_H
-
-struct Dllist;
-struct Dlelem;
-
-typedef struct Dlelem
-{
-	struct Dlelem *dle_next;	/* next element */
-	struct Dlelem *dle_prev;	/* previous element */
-	void	   *dle_val;		/* value of the element */
-	struct Dllist *dle_list;	/* what list this element is in */
-} Dlelem;
-
-typedef struct Dllist
-{
-	Dlelem	   *dll_head;
-	Dlelem	   *dll_tail;
-} Dllist;
-
-extern Dllist *DLNewList(void); /* allocate and initialize a list header */
-extern void DLInitList(Dllist *list);	/* init a header alloced by caller */
-extern void DLFreeList(Dllist *list);	/* free up a list and all the nodes in
-										 * it */
-extern Dlelem *DLNewElem(void *val);
-extern void DLInitElem(Dlelem *e, void *val);
-extern void DLFreeElem(Dlelem *e);
-extern void DLRemove(Dlelem *e);	/* removes node from list */
-extern void DLAddHead(Dllist *list, Dlelem *node);
-extern void DLAddTail(Dllist *list, Dlelem *node);
-extern Dlelem *DLRemHead(Dllist *list); /* remove and return the head */
-extern Dlelem *DLRemTail(Dllist *list);
-extern void DLMoveToFront(Dlelem *e);	/* move node to front of its list */
-
-/* These are macros for speed */
-#define DLGetHead(list)  ((list)->dll_head)
-#define DLGetTail(list)  ((list)->dll_tail)
-#define DLGetSucc(elem)  ((elem)->dle_next)
-#define DLGetPred(elem)  ((elem)->dle_prev)
-#define DLGetListHdr(elem)	((elem)->dle_list)
-
-#define DLE_VAL(elem)	((elem)->dle_val)
-
-#endif   /* DLLIST_H */
-- 
1.7.12.289.g0ce9864.dirty

diff src/backend/lib/Makefile
index 2e1061e..7da1c45
*** a/src/backend/lib/Makefile
--- b/src/backend/lib/Makefile
*************** subdir = src/backend/lib
*** 12,17 ****
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = dllist.o stringinfo.o
  
  include $(top_srcdir)/src/backend/common.mk
--- 12,17 ----
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = stringinfo.o ilist.o
  
  include $(top_srcdir)/src/backend/common.mk
diff src/backend/lib/dllist.c
new file mode .
index 52af56a..e69de29
*** a/src/backend/lib/dllist.c
--- b/src/backend/lib/dllist.c
***************
*** 1,214 ****
- /*-------------------------------------------------------------------------
-  *
-  * dllist.c
-  *	  this is a simple doubly linked list implementation
-  *	  the elements of the lists are void*
-  *
-  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
-  * Portions Copyright (c) 1994, Regents of the University of California
-  *
-  *
-  * IDENTIFICATION
-  *	  src/backend/lib/dllist.c
-  *
-  *-------------------------------------------------------------------------
-  */
- #include "postgres.h"
- 
- #include "lib/dllist.h"
- 
- 
- Dllist *
- DLNewList(void)
- {
- 	Dllist	   *l;
- 
- 	l = (Dllist *) palloc(sizeof(Dllist));
- 
- 	l->dll_head = NULL;
- 	l->dll_tail = NULL;
- 
- 	return l;
- }
- 
- void
- DLInitList(Dllist *list)
- {
- 	list->dll_head = NULL;
- 	list->dll_tail = NULL;
- }
- 
- /*
-  * free up a list and all the nodes in it --- but *not* whatever the nodes
-  * might point to!
-  */
- void
- DLFreeList(Dllist *list)
- {
- 	Dlelem	   *curr;
- 
- 	while ((curr = DLRemHead(list)) != NULL)
- 		pfree(curr);
- 
- 	pfree(list);
- }
- 
- Dlelem *
- DLNewElem(void *val)
- {
- 	Dlelem	   *e;
- 
- 	e = (Dlelem *) palloc(sizeof(Dlelem));
- 
- 	e->dle_next = NULL;
- 	e->dle_prev = NULL;
- 	e->dle_val = val;
- 	e->dle_list = NULL;
- 	return e;
- }
- 
- void
- DLInitElem(Dlelem *e, void *val)
- {
- 	e->dle_next = NULL;
- 	e->dle_prev = NULL;
- 	e->dle_val = val;
- 	e->dle_list = NULL;
- }
- 
- void
- DLFreeElem(Dlelem *e)
- {
- 	pfree(e);
- }
- 
- void
- DLRemove(Dlelem *e)
- {
- 	Dllist	   *l = e->dle_list;
- 
- 	if (e->dle_prev)
- 		e->dle_prev->dle_next = e->dle_next;
- 	else
- 	{
- 		/* must be the head element */
- 		Assert(e == l->dll_head);
- 		l->dll_head = e->dle_next;
- 	}
- 	if (e->dle_next)
- 		e->dle_next->dle_prev = e->dle_prev;
- 	else
- 	{
- 		/* must be the tail element */
- 		Assert(e == l->dll_tail);
- 		l->dll_tail = e->dle_prev;
- 	}
- 
- 	e->dle_next = NULL;
- 	e->dle_prev = NULL;
- 	e->dle_list = NULL;
- }
- 
- void
- DLAddHead(Dllist *l, Dlelem *e)
- {
- 	e->dle_list = l;
- 
- 	if (l->dll_head)
- 		l->dll_head->dle_prev = e;
- 	e->dle_next = l->dll_head;
- 	e->dle_prev = NULL;
- 	l->dll_head = e;
- 
- 	if (l->dll_tail == NULL)	/* if this is first element added */
- 		l->dll_tail = e;
- }
- 
- void
- DLAddTail(Dllist *l, Dlelem *e)
- {
- 	e->dle_list = l;
- 
- 	if (l->dll_tail)
- 		l->dll_tail->dle_next = e;
- 	e->dle_prev = l->dll_tail;
- 	e->dle_next = NULL;
- 	l->dll_tail = e;
- 
- 	if (l->dll_head == NULL)	/* if this is first element added */
- 		l->dll_head = e;
- }
- 
- Dlelem *
- DLRemHead(Dllist *l)
- {
- 	/* remove and return the head */
- 	Dlelem	   *result = l->dll_head;
- 
- 	if (result == NULL)
- 		return result;
- 
- 	if (result->dle_next)
- 		result->dle_next->dle_prev = NULL;
- 
- 	l->dll_head = result->dle_next;
- 
- 	if (result == l->dll_tail)	/* if the head is also the tail */
- 		l->dll_tail = NULL;
- 
- 	result->dle_next = NULL;
- 	result->dle_list = NULL;
- 
- 	return result;
- }
- 
- Dlelem *
- DLRemTail(Dllist *l)
- {
- 	/* remove and return the tail */
- 	Dlelem	   *result = l->dll_tail;
- 
- 	if (result == NULL)
- 		return result;
- 
- 	if (result->dle_prev)
- 		result->dle_prev->dle_next = NULL;
- 
- 	l->dll_tail = result->dle_prev;
- 
- 	if (result == l->dll_head)	/* if the tail is also the head */
- 		l->dll_head = NULL;
- 
- 	result->dle_prev = NULL;
- 	result->dle_list = NULL;
- 
- 	return result;
- }
- 
- /* Same as DLRemove followed by DLAddHead, but faster */
- void
- DLMoveToFront(Dlelem *e)
- {
- 	Dllist	   *l = e->dle_list;
- 
- 	if (l->dll_head == e)
- 		return;					/* Fast path if already at front */
- 
- 	Assert(e->dle_prev != NULL);	/* since it's not the head */
- 	e->dle_prev->dle_next = e->dle_next;
- 
- 	if (e->dle_next)
- 		e->dle_next->dle_prev = e->dle_prev;
- 	else
- 	{
- 		/* must be the tail element */
- 		Assert(e == l->dll_tail);
- 		l->dll_tail = e->dle_prev;
- 	}
- 
- 	l->dll_head->dle_prev = e;
- 	e->dle_next = l->dll_head;
- 	e->dle_prev = NULL;
- 	l->dll_head = e;
- 	/* We need not check dll_tail, since there must have been > 1 entry */
- }
--- 0 ----
diff src/backend/lib/ilist.c
new file mode 100644
index ...de4a27d
*** a/src/backend/lib/ilist.c
--- b/src/backend/lib/ilist.c
***************
*** 0 ****
--- 1,117 ----
+ /*-------------------------------------------------------------------------
+  *
+  * ilist.c
+  *	  support for integrated/inline doubly- and singly- linked lists
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *
+  * IDENTIFICATION
+  *	  src/backend/lib/ilist.c
+  *
+  * NOTES
+  *	  This file only contains functions that are too big to be considered
+  *	  for inlining.  See ilist.h for most of the goodies.
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ /*
+  * If inlines are in use, include the header normally which will get us only
+  * the function definitions as inlines.  But if inlines aren't available,
+  * include the header with ILIST_DEFINE_FUNCTIONS defined; this makes it pour
+  * in regular (not inline) function declarations and the corresponding (non
+  * inline) definitions.
+  */
+ #ifndef USE_INLINE
+ #define ILIST_DEFINE_FUNCTIONS
+ #endif
+ 
+ #include "lib/ilist.h"
+ 
+ /*
+  * removes a node from a list
+  *
+  * Attention: O(n)
+  */
+ void
+ slist_delete(slist_head *head, slist_node *node)
+ {
+ 	slist_node *last = &head->head;
+ 	slist_node *cur;
+ 	bool found	PG_USED_FOR_ASSERTS_ONLY = false;
+ 
+ 	while ((cur = last->next) != NULL)
+ 	{
+ 		if (cur == node)
+ 		{
+ 			last->next = cur->next;
+ #ifdef USE_ASSERT_CHECKING
+ 			found = true;
+ #endif
+ 			break;
+ 		}
+ 		last = cur;
+ 	}
+ 
+ 	slist_check(head);
+ 	Assert(found);
+ }
+ 
+ #ifdef ILIST_DEBUG
+ /*
+  * Verify integrity of a doubly linked list
+  */
+ void
+ dlist_check(dlist_head *head)
+ {
+ 	dlist_node *cur;
+ 
+ 	if (head == NULL || !(&head->head))
+ 		elog(ERROR, "doubly linked list head is not properly initialized");
+ 
+ 	/* iterate in forward direction */
+ 	for (cur = head->head.next; cur != &head->head; cur = cur->next)
+ 	{
+ 		if (cur == NULL ||
+ 			cur->next == NULL ||
+ 			cur->prev == NULL ||
+ 			cur->prev->next != cur ||
+ 			cur->next->prev != cur)
+ 			elog(ERROR, "doubly linked list is corrupted");
+ 	}
+ 
+ 	/* iterate in backward direction */
+ 	for (cur = head->head.prev; cur != &head->head; cur = cur->prev)
+ 	{
+ 		if (cur == NULL ||
+ 			cur->next == NULL ||
+ 			cur->prev == NULL ||
+ 			cur->prev->next != cur ||
+ 			cur->next->prev != cur)
+ 			elog(ERROR, "doubly linked list is corrupted");
+ 	}
+ }
+ 
+ /*
+  * Verify integrity of a singly linked list
+  */
+ void
+ slist_check(slist_head *head)
+ {
+ 	slist_node *cur;
+ 
+ 	if (head == NULL)
+ 		elog(ERROR, "singly linked is NULL");
+ 
+ 	/*
+ 	 * there isn't much we can test in a singly linked list other that it
+ 	 * actually ends sometime, i.e. hasn't introduced a circle or similar
+ 	 */
+ 	for (cur = head->head.next; cur != NULL; cur = cur->next)
+ 		;
+ }
+ 
+ #endif   /* ILIST_DEBUG */
diff src/backend/postmaster/autovacuum.c
index 74db821..c3ac219
*** a/src/backend/postmaster/autovacuum.c
--- b/src/backend/postmaster/autovacuum.c
***************
*** 77,83 ****
  #include "catalog/pg_database.h"
  #include "commands/dbcommands.h"
  #include "commands/vacuum.h"
! #include "lib/dllist.h"
  #include "libpq/pqsignal.h"
  #include "miscadmin.h"
  #include "pgstat.h"
--- 77,83 ----
  #include "catalog/pg_database.h"
  #include "commands/dbcommands.h"
  #include "commands/vacuum.h"
! #include "lib/ilist.h"
  #include "libpq/pqsignal.h"
  #include "miscadmin.h"
  #include "pgstat.h"
*************** typedef struct avl_dbase
*** 152,157 ****
--- 152,158 ----
  	Oid			adl_datid;		/* hash key -- must be first */
  	TimestampTz adl_next_worker;
  	int			adl_score;
+ 	dlist_node	adl_node;
  } avl_dbase;
  
  /* struct to keep track of databases in worker */
*************** typedef struct
*** 258,265 ****
  
  static AutoVacuumShmemStruct *AutoVacuumShmem;
  
! /* the database list in the launcher, and the context that contains it */
! static Dllist *DatabaseList = NULL;
  static MemoryContext DatabaseListCxt = NULL;
  
  /* Pointer to my own WorkerInfo, valid on each worker */
--- 259,269 ----
  
  static AutoVacuumShmemStruct *AutoVacuumShmem;
  
! /*
!  * the database list (of avl_dbase elements) in the launcher, and the context
!  * that contains it
!  */
! static dlist_head DatabaseList = DLIST_STATIC_INIT(DatabaseList);
  static MemoryContext DatabaseListCxt = NULL;
  
  /* Pointer to my own WorkerInfo, valid on each worker */
*************** AutoVacLauncherMain(int argc, char *argv
*** 508,514 ****
  
  		/* don't leave dangling pointers to freed memory */
  		DatabaseListCxt = NULL;
! 		DatabaseList = NULL;
  
  		/*
  		 * Make sure pgstat also considers our stat data as gone.  Note: we
--- 512,518 ----
  
  		/* don't leave dangling pointers to freed memory */
  		DatabaseListCxt = NULL;
! 		dlist_init(&DatabaseList);
  
  		/*
  		 * Make sure pgstat also considers our stat data as gone.  Note: we
*************** AutoVacLauncherMain(int argc, char *argv
*** 576,582 ****
  		struct timeval nap;
  		TimestampTz current_time = 0;
  		bool		can_launch;
! 		Dlelem	   *elem;
  		int			rc;
  
  		/*
--- 580,586 ----
  		struct timeval nap;
  		TimestampTz current_time = 0;
  		bool		can_launch;
! 		avl_dbase  *avdb;
  		int			rc;
  
  		/*
*************** AutoVacLauncherMain(int argc, char *argv
*** 738,757 ****
  
  		/* We're OK to start a new worker */
  
! 		elem = DLGetTail(DatabaseList);
! 		if (elem != NULL)
! 		{
! 			avl_dbase  *avdb = DLE_VAL(elem);
! 
! 			/*
! 			 * launch a worker if next_worker is right now or it is in the
! 			 * past
! 			 */
! 			if (TimestampDifferenceExceeds(avdb->adl_next_worker,
! 										   current_time, 0))
! 				launch_worker(current_time);
! 		}
! 		else
  		{
  			/*
  			 * Special case when the list is empty: start a worker right away.
--- 742,748 ----
  
  		/* We're OK to start a new worker */
  
! 		if (dlist_is_empty(&DatabaseList))
  		{
  			/*
  			 * Special case when the list is empty: start a worker right away.
*************** AutoVacLauncherMain(int argc, char *argv
*** 763,768 ****
--- 754,776 ----
  			 */
  			launch_worker(current_time);
  		}
+ 		else
+ 		{
+ 			/*
+ 			 * because rebuild_database_list constructs a list with most
+ 			 * distant adl_next_worker first, we obtain our database from the
+ 			 * tail of the list.
+ 			 */
+ 			avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
+ 
+ 			/*
+ 			 * launch a worker if next_worker is right now or it is in the
+ 			 * past
+ 			 */
+ 			if (TimestampDifferenceExceeds(avdb->adl_next_worker,
+ 										   current_time, 0))
+ 				launch_worker(current_time);
+ 		}
  	}
  
  	/* Normal exit from the autovac launcher is here */
*************** AutoVacLauncherMain(int argc, char *argv
*** 783,789 ****
  static void
  launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
  {
! 	Dlelem	   *elem;
  
  	/*
  	 * We sleep until the next scheduled vacuum.  We trust that when the
--- 791,797 ----
  static void
  launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
  {
! 	avl_dbase  *avdb;
  
  	/*
  	 * We sleep until the next scheduled vacuum.  We trust that when the
*************** launcher_determine_sleep(bool canlaunch,
*** 796,809 ****
  		nap->tv_sec = autovacuum_naptime;
  		nap->tv_usec = 0;
  	}
! 	else if ((elem = DLGetTail(DatabaseList)) != NULL)
  	{
- 		avl_dbase  *avdb = DLE_VAL(elem);
  		TimestampTz current_time = GetCurrentTimestamp();
  		TimestampTz next_wakeup;
  		long		secs;
  		int			usecs;
  
  		next_wakeup = avdb->adl_next_worker;
  		TimestampDifference(current_time, next_wakeup, &secs, &usecs);
  
--- 804,818 ----
  		nap->tv_sec = autovacuum_naptime;
  		nap->tv_usec = 0;
  	}
! 	else if (!dlist_is_empty(&DatabaseList))
  	{
  		TimestampTz current_time = GetCurrentTimestamp();
  		TimestampTz next_wakeup;
  		long		secs;
  		int			usecs;
  
+ 		avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
+ 
  		next_wakeup = avdb->adl_next_worker;
  		TimestampDifference(current_time, next_wakeup, &secs, &usecs);
  
*************** rebuild_database_list(Oid newdb)
*** 867,872 ****
--- 876,882 ----
  	int			score;
  	int			nelems;
  	HTAB	   *dbhash;
+ 	dlist_iter  iter;
  
  	/* use fresh stats */
  	autovac_refresh_stats();
*************** rebuild_database_list(Oid newdb)
*** 927,962 ****
  	}
  
  	/* Now insert the databases from the existing list */
! 	if (DatabaseList != NULL)
  	{
! 		Dlelem	   *elem;
! 
! 		elem = DLGetHead(DatabaseList);
! 		while (elem != NULL)
! 		{
! 			avl_dbase  *avdb = DLE_VAL(elem);
! 			avl_dbase  *db;
! 			bool		found;
! 			PgStat_StatDBEntry *entry;
! 
! 			elem = DLGetSucc(elem);
  
! 			/*
! 			 * skip databases with no stat entries -- in particular, this gets
! 			 * rid of dropped databases
! 			 */
! 			entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
! 			if (entry == NULL)
! 				continue;
  
! 			db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
  
! 			if (!found)
! 			{
! 				/* hash_search already filled in the key */
! 				db->adl_score = score++;
! 				/* next_worker is filled in later */
! 			}
  		}
  	}
  
--- 937,964 ----
  	}
  
  	/* Now insert the databases from the existing list */
! 	dlist_foreach(iter, &DatabaseList)
  	{
! 		avl_dbase  *avdb = dlist_container(avl_dbase, adl_node, iter.cur);
! 		avl_dbase  *db;
! 		bool		found;
! 		PgStat_StatDBEntry *entry;
  
! 		/*
! 		 * skip databases with no stat entries -- in particular, this gets
! 		 * rid of dropped databases
! 		 */
! 		entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
! 		if (entry == NULL)
! 			continue;
  
! 		db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
  
! 		if (!found)
! 		{
! 			/* hash_search already filled in the key */
! 			db->adl_score = score++;
! 			/* next_worker is filled in later */
  		}
  	}
  
*************** rebuild_database_list(Oid newdb)
*** 987,993 ****
  
  	/* from here on, the allocated memory belongs to the new list */
  	MemoryContextSwitchTo(newcxt);
! 	DatabaseList = DLNewList();
  
  	if (nelems > 0)
  	{
--- 989,995 ----
  
  	/* from here on, the allocated memory belongs to the new list */
  	MemoryContextSwitchTo(newcxt);
! 	dlist_init(&DatabaseList);
  
  	if (nelems > 0)
  	{
*************** rebuild_database_list(Oid newdb)
*** 1029,1043 ****
  		for (i = 0; i < nelems; i++)
  		{
  			avl_dbase  *db = &(dbary[i]);
- 			Dlelem	   *elem;
  
  			current_time = TimestampTzPlusMilliseconds(current_time,
  													   millis_increment);
  			db->adl_next_worker = current_time;
  
- 			elem = DLNewElem(db);
  			/* later elements should go closer to the head of the list */
! 			DLAddHead(DatabaseList, elem);
  		}
  	}
  
--- 1031,1043 ----
  		for (i = 0; i < nelems; i++)
  		{
  			avl_dbase  *db = &(dbary[i]);
  
  			current_time = TimestampTzPlusMilliseconds(current_time,
  													   millis_increment);
  			db->adl_next_worker = current_time;
  
  			/* later elements should go closer to the head of the list */
! 			dlist_push_head(&DatabaseList, &db->adl_node);
  		}
  	}
  
*************** do_start_worker(void)
*** 1147,1153 ****
  	foreach(cell, dblist)
  	{
  		avw_dbase  *tmp = lfirst(cell);
! 		Dlelem	   *elem;
  
  		/* Check to see if this one is at risk of wraparound */
  		if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
--- 1147,1153 ----
  	foreach(cell, dblist)
  	{
  		avw_dbase  *tmp = lfirst(cell);
! 		dlist_iter iter;
  
  		/* Check to see if this one is at risk of wraparound */
  		if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
*************** do_start_worker(void)
*** 1179,1189 ****
  		 * autovacuum time yet.
  		 */
  		skipit = false;
- 		elem = DatabaseList ? DLGetTail(DatabaseList) : NULL;
  
! 		while (elem != NULL)
  		{
! 			avl_dbase  *dbp = DLE_VAL(elem);
  
  			if (dbp->adl_datid == tmp->adw_datid)
  			{
--- 1179,1188 ----
  		 * autovacuum time yet.
  		 */
  		skipit = false;
  
! 		dlist_reverse_foreach(iter, &DatabaseList)
  		{
! 			avl_dbase  *dbp = dlist_container(avl_dbase, adl_node, iter.cur);
  
  			if (dbp->adl_datid == tmp->adw_datid)
  			{
*************** do_start_worker(void)
*** 1200,1206 ****
  
  				break;
  			}
- 			elem = DLGetPred(elem);
  		}
  		if (skipit)
  			continue;
--- 1199,1204 ----
*************** static void
*** 1274,1295 ****
  launch_worker(TimestampTz now)
  {
  	Oid			dbid;
! 	Dlelem	   *elem;
  
  	dbid = do_start_worker();
  	if (OidIsValid(dbid))
  	{
  		/*
  		 * Walk the database list and update the corresponding entry.  If the
  		 * database is not on the list, we'll recreate the list.
  		 */
! 		elem = (DatabaseList == NULL) ? NULL : DLGetHead(DatabaseList);
! 		while (elem != NULL)
  		{
! 			avl_dbase  *avdb = DLE_VAL(elem);
  
  			if (avdb->adl_datid == dbid)
  			{
  				/*
  				 * add autovacuum_naptime seconds to the current time, and use
  				 * that as the new "next_worker" field for this database.
--- 1272,1296 ----
  launch_worker(TimestampTz now)
  {
  	Oid			dbid;
! 	dlist_iter  iter;
  
  	dbid = do_start_worker();
  	if (OidIsValid(dbid))
  	{
+ 		bool found = false;
+ 
  		/*
  		 * Walk the database list and update the corresponding entry.  If the
  		 * database is not on the list, we'll recreate the list.
  		 */
! 		dlist_foreach(iter, &DatabaseList)
  		{
! 			avl_dbase  *avdb = dlist_container(avl_dbase, adl_node, iter.cur);
  
  			if (avdb->adl_datid == dbid)
  			{
+ 				found = true;
+ 
  				/*
  				 * add autovacuum_naptime seconds to the current time, and use
  				 * that as the new "next_worker" field for this database.
*************** launch_worker(TimestampTz now)
*** 1297,1306 ****
  				avdb->adl_next_worker =
  					TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000);
  
! 				DLMoveToFront(elem);
  				break;
  			}
- 			elem = DLGetSucc(elem);
  		}
  
  		/*
--- 1298,1306 ----
  				avdb->adl_next_worker =
  					TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000);
  
! 				dlist_move_head(&DatabaseList, iter.cur);
  				break;
  			}
  		}
  
  		/*
*************** launch_worker(TimestampTz now)
*** 1310,1316 ****
  		 * pgstat entry, but this is not a problem because we don't want to
  		 * schedule workers regularly into those in any case.
  		 */
! 		if (elem == NULL)
  			rebuild_database_list(dbid);
  	}
  }
--- 1310,1316 ----
  		 * pgstat entry, but this is not a problem because we don't want to
  		 * schedule workers regularly into those in any case.
  		 */
! 		if (!found)
  			rebuild_database_list(dbid);
  	}
  }
diff src/backend/postmaster/postmaster.c
index dff4c71..7060a1f
*** a/src/backend/postmaster/postmaster.c
--- b/src/backend/postmaster/postmaster.c
***************
*** 95,101 ****
  #include "access/xlog.h"
  #include "bootstrap/bootstrap.h"
  #include "catalog/pg_control.h"
! #include "lib/dllist.h"
  #include "libpq/auth.h"
  #include "libpq/ip.h"
  #include "libpq/libpq.h"
--- 95,101 ----
  #include "access/xlog.h"
  #include "bootstrap/bootstrap.h"
  #include "catalog/pg_control.h"
! #include "lib/ilist.h"
  #include "libpq/auth.h"
  #include "libpq/ip.h"
  #include "libpq/libpq.h"
*************** typedef struct bkend
*** 146,155 ****
  	int			child_slot;		/* PMChildSlot for this backend, if any */
  	bool		is_autovacuum;	/* is it an autovacuum process? */
  	bool		dead_end;		/* is it going to send an error and quit? */
! 	Dlelem		elem;			/* list link in BackendList */
  } Backend;
  
! static Dllist *BackendList;
  
  #ifdef EXEC_BACKEND
  static Backend *ShmemBackendArray;
--- 146,155 ----
  	int			child_slot;		/* PMChildSlot for this backend, if any */
  	bool		is_autovacuum;	/* is it an autovacuum process? */
  	bool		dead_end;		/* is it going to send an error and quit? */
! 	dlist_node	elem;			/* list link in BackendList */
  } Backend;
  
! static dlist_head BackendList = DLIST_STATIC_INIT(BackendList);
  
  #ifdef EXEC_BACKEND
  static Backend *ShmemBackendArray;
*************** static Backend *ShmemBackendArray;
*** 157,164 ****
--- 157,166 ----
  
  /* The socket number we are listening for connections on */
  int			PostPortNumber;
+ 
  /* The directory names for Unix socket(s) */
  char	   *Unix_socket_directories;
+ 
  /* The TCP listen address(es) */
  char	   *ListenAddresses;
  
*************** PostmasterMain(int argc, char *argv[])
*** 1028,1038 ****
  	set_stack_base();
  
  	/*
- 	 * Initialize the list of active backends.
- 	 */
- 	BackendList = DLNewList();
- 
- 	/*
  	 * Initialize pipe (or process handle on Windows) that allows children to
  	 * wake up from sleep on postmaster death.
  	 */
--- 1030,1035 ----
*************** processCancelRequest(Port *port, void *p
*** 1872,1878 ****
  	Backend    *bp;
  
  #ifndef EXEC_BACKEND
! 	Dlelem	   *curr;
  #else
  	int			i;
  #endif
--- 1869,1875 ----
  	Backend    *bp;
  
  #ifndef EXEC_BACKEND
! 	dlist_iter  iter;
  #else
  	int			i;
  #endif
*************** processCancelRequest(Port *port, void *p
*** 1886,1894 ****
  	 * duplicate array in shared memory.
  	 */
  #ifndef EXEC_BACKEND
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		bp = (Backend *) DLE_VAL(curr);
  #else
  	for (i = MaxLivePostmasterChildren() - 1; i >= 0; i--)
  	{
--- 1883,1891 ----
  	 * duplicate array in shared memory.
  	 */
  #ifndef EXEC_BACKEND
! 	dlist_foreach(iter, &BackendList)
  	{
! 		bp = dlist_container(Backend, elem, iter.cur);
  #else
  	for (i = MaxLivePostmasterChildren() - 1; i >= 0; i--)
  	{
*************** static void
*** 2648,2654 ****
  CleanupBackend(int pid,
  			   int exitstatus)	/* child's exit status. */
  {
! 	Dlelem	   *curr;
  
  	LogChildExit(DEBUG2, _("server process"), pid, exitstatus);
  
--- 2645,2651 ----
  CleanupBackend(int pid,
  			   int exitstatus)	/* child's exit status. */
  {
! 	dlist_mutable_iter iter;
  
  	LogChildExit(DEBUG2, _("server process"), pid, exitstatus);
  
*************** CleanupBackend(int pid,
*** 2680,2688 ****
  		return;
  	}
  
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		Backend    *bp = (Backend *) DLE_VAL(curr);
  
  		if (bp->pid == pid)
  		{
--- 2677,2685 ----
  		return;
  	}
  
! 	dlist_foreach_modify(iter, &BackendList)
  	{
! 		Backend    *bp = dlist_container(Backend, elem, iter.cur);
  
  		if (bp->pid == pid)
  		{
*************** CleanupBackend(int pid,
*** 2701,2707 ****
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			DLRemove(curr);
  			free(bp);
  			break;
  		}
--- 2698,2704 ----
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			dlist_delete(&BackendList, iter.cur);
  			free(bp);
  			break;
  		}
*************** CleanupBackend(int pid,
*** 2718,2725 ****
  static void
  HandleChildCrash(int pid, int exitstatus, const char *procname)
  {
! 	Dlelem	   *curr,
! 			   *next;
  	Backend    *bp;
  
  	/*
--- 2715,2721 ----
  static void
  HandleChildCrash(int pid, int exitstatus, const char *procname)
  {
! 	dlist_mutable_iter iter;
  	Backend    *bp;
  
  	/*
*************** HandleChildCrash(int pid, int exitstatus
*** 2734,2743 ****
  	}
  
  	/* Process regular backends */
! 	for (curr = DLGetHead(BackendList); curr; curr = next)
  	{
! 		next = DLGetSucc(curr);
! 		bp = (Backend *) DLE_VAL(curr);
  		if (bp->pid == pid)
  		{
  			/*
--- 2730,2739 ----
  	}
  
  	/* Process regular backends */
! 	dlist_foreach_modify(iter, &BackendList)
  	{
! 		bp = dlist_container(Backend, elem, iter.cur);
! 
  		if (bp->pid == pid)
  		{
  			/*
*************** HandleChildCrash(int pid, int exitstatus
*** 2750,2756 ****
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			DLRemove(curr);
  			free(bp);
  			/* Keep looping so we can signal remaining backends */
  		}
--- 2746,2752 ----
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			dlist_delete(&BackendList, iter.cur);
  			free(bp);
  			/* Keep looping so we can signal remaining backends */
  		}
*************** PostmasterStateMachine(void)
*** 3113,3119 ****
  		 * normal state transition leading up to PM_WAIT_DEAD_END, or during
  		 * FatalError processing.
  		 */
! 		if (DLGetHead(BackendList) == NULL &&
  			PgArchPID == 0 && PgStatPID == 0)
  		{
  			/* These other guys should be dead already */
--- 3109,3115 ----
  		 * normal state transition leading up to PM_WAIT_DEAD_END, or during
  		 * FatalError processing.
  		 */
! 		if (dlist_is_empty(&BackendList) &&
  			PgArchPID == 0 && PgStatPID == 0)
  		{
  			/* These other guys should be dead already */
*************** signal_child(pid_t pid, int signal)
*** 3239,3250 ****
  static bool
  SignalSomeChildren(int signal, int target)
  {
! 	Dlelem	   *curr;
  	bool		signaled = false;
  
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		Backend    *bp = (Backend *) DLE_VAL(curr);
  
  		if (bp->dead_end)
  			continue;
--- 3235,3246 ----
  static bool
  SignalSomeChildren(int signal, int target)
  {
! 	dlist_iter  iter;
  	bool		signaled = false;
  
! 	dlist_foreach(iter, &BackendList)
  	{
! 		Backend    *bp = dlist_container(Backend, elem, iter.cur);
  
  		if (bp->dead_end)
  			continue;
*************** BackendStartup(Port *port)
*** 3382,3389 ****
  	 */
  	bn->pid = pid;
  	bn->is_autovacuum = false;
! 	DLInitElem(&bn->elem, bn);
! 	DLAddHead(BackendList, &bn->elem);
  #ifdef EXEC_BACKEND
  	if (!bn->dead_end)
  		ShmemBackendArrayAdd(bn);
--- 3378,3385 ----
  	 */
  	bn->pid = pid;
  	bn->is_autovacuum = false;
! 	dlist_push_head(&BackendList, &bn->elem);
! 
  #ifdef EXEC_BACKEND
  	if (!bn->dead_end)
  		ShmemBackendArrayAdd(bn);
*************** PostmasterRandom(void)
*** 4498,4509 ****
  static int
  CountChildren(int target)
  {
! 	Dlelem	   *curr;
  	int			cnt = 0;
  
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		Backend    *bp = (Backend *) DLE_VAL(curr);
  
  		if (bp->dead_end)
  			continue;
--- 4494,4505 ----
  static int
  CountChildren(int target)
  {
! 	dlist_iter  iter;
  	int			cnt = 0;
  
! 	dlist_foreach(iter, &BackendList)
  	{
! 		Backend    *bp = dlist_container(Backend, elem, iter.cur);
  
  		if (bp->dead_end)
  			continue;
*************** StartAutovacuumWorker(void)
*** 4682,4689 ****
  			if (bn->pid > 0)
  			{
  				bn->is_autovacuum = true;
! 				DLInitElem(&bn->elem, bn);
! 				DLAddHead(BackendList, &bn->elem);
  #ifdef EXEC_BACKEND
  				ShmemBackendArrayAdd(bn);
  #endif
--- 4678,4684 ----
  			if (bn->pid > 0)
  			{
  				bn->is_autovacuum = true;
! 				dlist_push_head(&BackendList, &bn->elem);
  #ifdef EXEC_BACKEND
  				ShmemBackendArrayAdd(bn);
  #endif
diff src/backend/utils/cache/catcache.c
index d6f6b1c..230ddf4
*** a/src/backend/utils/cache/catcache.c
--- b/src/backend/utils/cache/catcache.c
*************** CatalogCacheComputeTupleHashValue(CatCac
*** 291,297 ****
  static void
  CatCachePrintStats(int code, Datum arg)
  {
! 	CatCache   *cache;
  	long		cc_searches = 0;
  	long		cc_hits = 0;
  	long		cc_neg_hits = 0;
--- 291,297 ----
  static void
  CatCachePrintStats(int code, Datum arg)
  {
! 	slist_iter  iter;
  	long		cc_searches = 0;
  	long		cc_hits = 0;
  	long		cc_neg_hits = 0;
*************** CatCachePrintStats(int code, Datum arg)
*** 300,307 ****
  	long		cc_lsearches = 0;
  	long		cc_lhits = 0;
  
! 	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
  	{
  		if (cache->cc_ntup == 0 && cache->cc_searches == 0)
  			continue;			/* don't print unused caches */
  		elog(DEBUG2, "catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld lsrch, %ld lhits",
--- 300,309 ----
  	long		cc_lsearches = 0;
  	long		cc_lhits = 0;
  
! 	slist_foreach(iter, &CacheHdr->ch_caches)
  	{
+ 		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
+ 
  		if (cache->cc_ntup == 0 && cache->cc_searches == 0)
  			continue;			/* don't print unused caches */
  		elog(DEBUG2, "catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld lsrch, %ld lhits",
*************** CatCacheRemoveCTup(CatCache *cache, CatC
*** 368,375 ****
  		return;					/* nothing left to do */
  	}
  
! 	/* delink from linked list */
! 	DLRemove(&ct->cache_elem);
  
  	/* free associated tuple data */
  	if (ct->tuple.t_data != NULL)
--- 370,376 ----
  		return;					/* nothing left to do */
  	}
  
! 	dlist_delete(ct->cache_bucket, &ct->cache_elem);
  
  	/* free associated tuple data */
  	if (ct->tuple.t_data != NULL)
*************** CatCacheRemoveCList(CatCache *cache, Cat
*** 412,418 ****
  	}
  
  	/* delink from linked list */
! 	DLRemove(&cl->cache_elem);
  
  	/* free associated tuple data */
  	if (cl->tuple.t_data != NULL)
--- 413,419 ----
  	}
  
  	/* delink from linked list */
! 	dlist_delete(&cache->cc_lists, &cl->cache_elem);
  
  	/* free associated tuple data */
  	if (cl->tuple.t_data != NULL)
*************** CatCacheRemoveCList(CatCache *cache, Cat
*** 442,459 ****
  void
  CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  {
! 	CatCache   *ccp;
  
  	CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
  
  	/*
  	 * inspect caches to find the proper cache
  	 */
! 	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
  	{
  		Index		hashIndex;
! 		Dlelem	   *elt,
! 				   *nextelt;
  
  		if (cacheId != ccp->id)
  			continue;
--- 443,460 ----
  void
  CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  {
! 	slist_iter cache_iter;
  
  	CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
  
  	/*
  	 * inspect caches to find the proper cache
  	 */
! 	slist_foreach(cache_iter, &CacheHdr->ch_caches)
  	{
  		Index		hashIndex;
! 		dlist_mutable_iter iter;
! 		CatCache   *ccp = slist_container(CatCache, cc_next, cache_iter.cur);
  
  		if (cacheId != ccp->id)
  			continue;
*************** CatalogCacheIdInvalidate(int cacheId, ui
*** 468,478 ****
  		 * Invalidate *all* CatCLists in this cache; it's too hard to tell
  		 * which searches might still be correct, so just zap 'em all.
  		 */
! 		for (elt = DLGetHead(&ccp->cc_lists); elt; elt = nextelt)
  		{
! 			CatCList   *cl = (CatCList *) DLE_VAL(elt);
! 
! 			nextelt = DLGetSucc(elt);
  
  			if (cl->refcount > 0)
  				cl->dead = true;
--- 469,477 ----
  		 * Invalidate *all* CatCLists in this cache; it's too hard to tell
  		 * which searches might still be correct, so just zap 'em all.
  		 */
! 		dlist_foreach_modify(iter, &ccp->cc_lists)
  		{
! 			CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  			if (cl->refcount > 0)
  				cl->dead = true;
*************** CatalogCacheIdInvalidate(int cacheId, ui
*** 484,495 ****
  		 * inspect the proper hash bucket for tuple matches
  		 */
  		hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets);
! 
! 		for (elt = DLGetHead(&ccp->cc_bucket[hashIndex]); elt; elt = nextelt)
  		{
! 			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
! 
! 			nextelt = DLGetSucc(elt);
  
  			if (hashValue == ct->hash_value)
  			{
--- 483,491 ----
  		 * inspect the proper hash bucket for tuple matches
  		 */
  		hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets);
! 		dlist_foreach_modify(iter, &ccp->cc_bucket[hashIndex])
  		{
! 			CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  			if (hashValue == ct->hash_value)
  			{
*************** AtEOXact_CatCache(bool isCommit)
*** 557,573 ****
  #ifdef USE_ASSERT_CHECKING
  	if (assert_enabled)
  	{
! 		CatCache   *ccp;
  
! 		for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
  		{
! 			Dlelem	   *elt;
  			int			i;
  
  			/* Check CatCLists */
! 			for (elt = DLGetHead(&ccp->cc_lists); elt; elt = DLGetSucc(elt))
  			{
! 				CatCList   *cl = (CatCList *) DLE_VAL(elt);
  
  				Assert(cl->cl_magic == CL_MAGIC);
  				Assert(cl->refcount == 0);
--- 553,570 ----
  #ifdef USE_ASSERT_CHECKING
  	if (assert_enabled)
  	{
! 		slist_iter  cache_iter;
  
! 		slist_foreach(cache_iter, &(CacheHdr->ch_caches))
  		{
! 			CatCache   *ccp = slist_container(CatCache, cc_next, cache_iter.cur);
! 			dlist_iter  iter;
  			int			i;
  
  			/* Check CatCLists */
! 			dlist_foreach(iter, &ccp->cc_lists)
  			{
! 				CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  				Assert(cl->cl_magic == CL_MAGIC);
  				Assert(cl->refcount == 0);
*************** AtEOXact_CatCache(bool isCommit)
*** 577,587 ****
  			/* Check individual tuples */
  			for (i = 0; i < ccp->cc_nbuckets; i++)
  			{
! 				for (elt = DLGetHead(&ccp->cc_bucket[i]);
! 					 elt;
! 					 elt = DLGetSucc(elt))
  				{
! 					CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
  
  					Assert(ct->ct_magic == CT_MAGIC);
  					Assert(ct->refcount == 0);
--- 574,584 ----
  			/* Check individual tuples */
  			for (i = 0; i < ccp->cc_nbuckets; i++)
  			{
! 				dlist_head *bucket = &ccp->cc_bucket[i];
! 
! 				dlist_foreach(iter, bucket)
  				{
! 					CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  					Assert(ct->ct_magic == CT_MAGIC);
  					Assert(ct->refcount == 0);
*************** AtEOXact_CatCache(bool isCommit)
*** 604,619 ****
  static void
  ResetCatalogCache(CatCache *cache)
  {
! 	Dlelem	   *elt,
! 			   *nextelt;
  	int			i;
  
  	/* Remove each list in this cache, or at least mark it dead */
! 	for (elt = DLGetHead(&cache->cc_lists); elt; elt = nextelt)
  	{
! 		CatCList   *cl = (CatCList *) DLE_VAL(elt);
! 
! 		nextelt = DLGetSucc(elt);
  
  		if (cl->refcount > 0)
  			cl->dead = true;
--- 601,613 ----
  static void
  ResetCatalogCache(CatCache *cache)
  {
! 	dlist_mutable_iter iter;
  	int			i;
  
  	/* Remove each list in this cache, or at least mark it dead */
! 	dlist_foreach_modify(iter, &cache->cc_lists)
  	{
! 		CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  		if (cl->refcount > 0)
  			cl->dead = true;
*************** ResetCatalogCache(CatCache *cache)
*** 624,634 ****
  	/* Remove each tuple in this cache, or at least mark it dead */
  	for (i = 0; i < cache->cc_nbuckets; i++)
  	{
! 		for (elt = DLGetHead(&cache->cc_bucket[i]); elt; elt = nextelt)
! 		{
! 			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
  
! 			nextelt = DLGetSucc(elt);
  
  			if (ct->refcount > 0 ||
  				(ct->c_list && ct->c_list->refcount > 0))
--- 618,628 ----
  	/* Remove each tuple in this cache, or at least mark it dead */
  	for (i = 0; i < cache->cc_nbuckets; i++)
  	{
! 		dlist_head *bucket = &cache->cc_bucket[i];
  
! 		dlist_foreach_modify(iter, bucket)
! 		{
! 			CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  			if (ct->refcount > 0 ||
  				(ct->c_list && ct->c_list->refcount > 0))
*************** ResetCatalogCache(CatCache *cache)
*** 654,665 ****
  void
  ResetCatalogCaches(void)
  {
! 	CatCache   *cache;
  
  	CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
  
! 	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
  		ResetCatalogCache(cache);
  
  	CACHE1_elog(DEBUG2, "end of ResetCatalogCaches call");
  }
--- 648,663 ----
  void
  ResetCatalogCaches(void)
  {
! 	slist_iter    iter;
  
  	CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
  
! 	slist_foreach(iter, &CacheHdr->ch_caches)
! 	{
! 		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
! 
  		ResetCatalogCache(cache);
+ 	}
  
  	CACHE1_elog(DEBUG2, "end of ResetCatalogCaches call");
  }
*************** ResetCatalogCaches(void)
*** 680,691 ****
  void
  CatalogCacheFlushCatalog(Oid catId)
  {
! 	CatCache   *cache;
  
  	CACHE2_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
  
! 	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
  	{
  		/* Does this cache store tuples of the target catalog? */
  		if (cache->cc_reloid == catId)
  		{
--- 678,691 ----
  void
  CatalogCacheFlushCatalog(Oid catId)
  {
! 	slist_iter  iter;
  
  	CACHE2_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
  
! 	slist_foreach(iter, &(CacheHdr->ch_caches))
  	{
+ 		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
+ 
  		/* Does this cache store tuples of the target catalog? */
  		if (cache->cc_reloid == catId)
  		{
*************** InitCatCache(int id,
*** 760,766 ****
  	if (CacheHdr == NULL)
  	{
  		CacheHdr = (CatCacheHeader *) palloc(sizeof(CatCacheHeader));
! 		CacheHdr->ch_caches = NULL;
  		CacheHdr->ch_ntup = 0;
  #ifdef CATCACHE_STATS
  		/* set up to dump stats at backend exit */
--- 760,766 ----
  	if (CacheHdr == NULL)
  	{
  		CacheHdr = (CatCacheHeader *) palloc(sizeof(CatCacheHeader));
! 		slist_init(&CacheHdr->ch_caches);
  		CacheHdr->ch_ntup = 0;
  #ifdef CATCACHE_STATS
  		/* set up to dump stats at backend exit */
*************** InitCatCache(int id,
*** 770,779 ****
  
  	/*
  	 * allocate a new cache structure
- 	 *
- 	 * Note: we assume zeroing initializes the Dllist headers correctly
  	 */
! 	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(Dllist));
  
  	/*
  	 * initialize the cache's relation information for the relation
--- 770,777 ----
  
  	/*
  	 * allocate a new cache structure
  	 */
! 	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(dlist_node));
  
  	/*
  	 * initialize the cache's relation information for the relation
*************** InitCatCache(int id,
*** 792,797 ****
--- 790,800 ----
  	for (i = 0; i < nkeys; ++i)
  		cp->cc_key[i] = key[i];
  
+ 	dlist_init(&cp->cc_lists);
+ 
+ 	for (i = 0; i < nbuckets; i++)
+ 		dlist_init(&cp->cc_bucket[i]);
+ 
  	/*
  	 * new cache is initialized as far as we can go for now. print some
  	 * debugging information, if appropriate.
*************** InitCatCache(int id,
*** 801,808 ****
  	/*
  	 * add completed cache to top of group header's list
  	 */
! 	cp->cc_next = CacheHdr->ch_caches;
! 	CacheHdr->ch_caches = cp;
  
  	/*
  	 * back to the old context before we return...
--- 804,810 ----
  	/*
  	 * add completed cache to top of group header's list
  	 */
! 	slist_push_head(&CacheHdr->ch_caches, &cp->cc_next);
  
  	/*
  	 * back to the old context before we return...
*************** SearchCatCache(CatCache *cache,
*** 1060,1066 ****
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		hashValue;
  	Index		hashIndex;
! 	Dlelem	   *elt;
  	CatCTup    *ct;
  	Relation	relation;
  	SysScanDesc scandesc;
--- 1062,1069 ----
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		hashValue;
  	Index		hashIndex;
! 	dlist_mutable_iter  iter;
! 	dlist_head *bucket;
  	CatCTup    *ct;
  	Relation	relation;
  	SysScanDesc scandesc;
*************** SearchCatCache(CatCache *cache,
*** 1094,1106 ****
  	/*
  	 * scan the hash bucket until we find a match or exhaust our tuples
  	 */
! 	for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
! 		 elt;
! 		 elt = DLGetSucc(elt))
  	{
  		bool		res;
  
! 		ct = (CatCTup *) DLE_VAL(elt);
  
  		if (ct->dead)
  			continue;			/* ignore dead entries */
--- 1097,1109 ----
  	/*
  	 * scan the hash bucket until we find a match or exhaust our tuples
  	 */
! 	bucket = &cache->cc_bucket[hashIndex];
! 
! 	dlist_foreach_modify(iter, bucket)
  	{
  		bool		res;
  
! 		ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  		if (ct->dead)
  			continue;			/* ignore dead entries */
*************** SearchCatCache(CatCache *cache,
*** 1125,1131 ****
  		 * most frequently accessed elements in any hashbucket will tend to be
  		 * near the front of the hashbucket's list.)
  		 */
! 		DLMoveToFront(&ct->cache_elem);
  
  		/*
  		 * If it's a positive entry, bump its refcount and return it. If it's
--- 1128,1134 ----
  		 * most frequently accessed elements in any hashbucket will tend to be
  		 * near the front of the hashbucket's list.)
  		 */
! 		dlist_move_head(bucket, &ct->cache_elem);
  
  		/*
  		 * If it's a positive entry, bump its refcount and return it. If it's
*************** SearchCatCacheList(CatCache *cache,
*** 1340,1346 ****
  {
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		lHashValue;
! 	Dlelem	   *elt;
  	CatCList   *cl;
  	CatCTup    *ct;
  	List	   *volatile ctlist;
--- 1343,1349 ----
  {
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		lHashValue;
! 	dlist_iter  iter;
  	CatCList   *cl;
  	CatCTup    *ct;
  	List	   *volatile ctlist;
*************** SearchCatCacheList(CatCache *cache,
*** 1382,1394 ****
  	/*
  	 * scan the items until we find a match or exhaust our list
  	 */
! 	for (elt = DLGetHead(&cache->cc_lists);
! 		 elt;
! 		 elt = DLGetSucc(elt))
  	{
  		bool		res;
  
! 		cl = (CatCList *) DLE_VAL(elt);
  
  		if (cl->dead)
  			continue;			/* ignore dead entries */
--- 1385,1395 ----
  	/*
  	 * scan the items until we find a match or exhaust our list
  	 */
! 	dlist_foreach(iter, &cache->cc_lists)
  	{
  		bool		res;
  
! 		cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  		if (cl->dead)
  			continue;			/* ignore dead entries */
*************** SearchCatCacheList(CatCache *cache,
*** 1416,1422 ****
  		 * since there's no point in that unless they are searched for
  		 * individually.)
  		 */
! 		DLMoveToFront(&cl->cache_elem);
  
  		/* Bump the list's refcount and return it */
  		ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
--- 1417,1423 ----
  		 * since there's no point in that unless they are searched for
  		 * individually.)
  		 */
! 		dlist_move_head(&cache->cc_lists, &cl->cache_elem);
  
  		/* Bump the list's refcount and return it */
  		ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
*************** SearchCatCacheList(CatCache *cache,
*** 1468,1473 ****
--- 1469,1476 ----
  		{
  			uint32		hashValue;
  			Index		hashIndex;
+ 			bool		found = false;
+ 			dlist_head *bucket;
  
  			/*
  			 * See if there's an entry for this tuple already.
*************** SearchCatCacheList(CatCache *cache,
*** 1476,1486 ****
  			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);
  			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
  
! 			for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
! 				 elt;
! 				 elt = DLGetSucc(elt))
  			{
! 				ct = (CatCTup *) DLE_VAL(elt);
  
  				if (ct->dead || ct->negative)
  					continue;	/* ignore dead and negative entries */
--- 1479,1488 ----
  			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);
  			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
  
! 			bucket = &cache->cc_bucket[hashIndex];
! 			dlist_foreach(iter, bucket)
  			{
! 				ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  				if (ct->dead || ct->negative)
  					continue;	/* ignore dead and negative entries */
*************** SearchCatCacheList(CatCache *cache,
*** 1498,1507 ****
  				if (ct->c_list)
  					continue;
  
  				break;			/* A-OK */
  			}
  
! 			if (elt == NULL)
  			{
  				/* We didn't find a usable entry, so make a new one */
  				ct = CatalogCacheCreateEntry(cache, ntp,
--- 1500,1510 ----
  				if (ct->c_list)
  					continue;
  
+ 				found = true;
  				break;			/* A-OK */
  			}
  
! 			if (!found)
  			{
  				/* We didn't find a usable entry, so make a new one */
  				ct = CatalogCacheCreateEntry(cache, ntp,
*************** SearchCatCacheList(CatCache *cache,
*** 1564,1570 ****
  
  	cl->cl_magic = CL_MAGIC;
  	cl->my_cache = cache;
- 	DLInitElem(&cl->cache_elem, cl);
  	cl->refcount = 0;			/* for the moment */
  	cl->dead = false;
  	cl->ordered = ordered;
--- 1567,1572 ----
*************** SearchCatCacheList(CatCache *cache,
*** 1587,1593 ****
  	}
  	Assert(i == nmembers);
  
! 	DLAddHead(&cache->cc_lists, &cl->cache_elem);
  
  	/* Finally, bump the list's refcount and return it */
  	cl->refcount++;
--- 1589,1595 ----
  	}
  	Assert(i == nmembers);
  
! 	dlist_push_head(&cache->cc_lists, &cl->cache_elem);
  
  	/* Finally, bump the list's refcount and return it */
  	cl->refcount++;
*************** CatalogCacheCreateEntry(CatCache *cache,
*** 1664,1677 ****
  	 */
  	ct->ct_magic = CT_MAGIC;
  	ct->my_cache = cache;
! 	DLInitElem(&ct->cache_elem, (void *) ct);
  	ct->c_list = NULL;
  	ct->refcount = 0;			/* for the moment */
  	ct->dead = false;
  	ct->negative = negative;
  	ct->hash_value = hashValue;
  
! 	DLAddHead(&cache->cc_bucket[hashIndex], &ct->cache_elem);
  
  	cache->cc_ntup++;
  	CacheHdr->ch_ntup++;
--- 1666,1680 ----
  	 */
  	ct->ct_magic = CT_MAGIC;
  	ct->my_cache = cache;
! 	ct->cache_bucket = &cache->cc_bucket[hashIndex];
! 
  	ct->c_list = NULL;
  	ct->refcount = 0;			/* for the moment */
  	ct->dead = false;
  	ct->negative = negative;
  	ct->hash_value = hashValue;
  
! 	dlist_push_head(ct->cache_bucket, &ct->cache_elem);
  
  	cache->cc_ntup++;
  	CacheHdr->ch_ntup++;
*************** PrepareToInvalidateCacheTuple(Relation r
*** 1785,1791 ****
  							  HeapTuple newtuple,
  							  void (*function) (int, uint32, Oid))
  {
! 	CatCache   *ccp;
  	Oid			reloid;
  
  	CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
--- 1788,1794 ----
  							  HeapTuple newtuple,
  							  void (*function) (int, uint32, Oid))
  {
! 	slist_iter  iter;
  	Oid			reloid;
  
  	CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
*************** PrepareToInvalidateCacheTuple(Relation r
*** 1808,1817 ****
  	 * ----------------
  	 */
  
! 	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
  	{
  		uint32		hashvalue;
  		Oid			dbid;
  
  		if (ccp->cc_reloid != reloid)
  			continue;
--- 1811,1821 ----
  	 * ----------------
  	 */
  
! 	slist_foreach(iter, &(CacheHdr->ch_caches))
  	{
  		uint32		hashvalue;
  		Oid			dbid;
+ 		CatCache   *ccp = slist_container(CatCache, cc_next, iter.cur);
  
  		if (ccp->cc_reloid != reloid)
  			continue;
diff src/include/lib/dllist.h
new file mode .
index 25ed64c..e69de29
*** a/src/include/lib/dllist.h
--- b/src/include/lib/dllist.h
***************
*** 1,85 ****
- /*-------------------------------------------------------------------------
-  *
-  * dllist.h
-  *		simple doubly linked list primitives
-  *		the elements of the list are void* so the lists can contain anything
-  *		Dlelem can only be in one list at a time
-  *
-  *
-  *	 Here's a small example of how to use Dllists:
-  *
-  *	 Dllist *lst;
-  *	 Dlelem *elt;
-  *	 void	*in_stuff;	  -- stuff to stick in the list
-  *	 void	*out_stuff
-  *
-  *	 lst = DLNewList();				   -- make a new dllist
-  *	 DLAddHead(lst, DLNewElem(in_stuff)); -- add a new element to the list
-  *											 with in_stuff as the value
-  *	  ...
-  *	 elt = DLGetHead(lst);			   -- retrieve the head element
-  *	 out_stuff = (void*)DLE_VAL(elt);  -- get the stuff out
-  *	 DLRemove(elt);					   -- removes the element from its list
-  *	 DLFreeElem(elt);				   -- free the element since we don't
-  *										  use it anymore
-  *
-  *
-  * It is also possible to use Dllist objects that are embedded in larger
-  * structures instead of being separately malloc'd.  To do this, use
-  * DLInitElem() to initialize a Dllist field within a larger object.
-  * Don't forget to DLRemove() each field from its list (if any) before
-  * freeing the larger object!
-  *
-  *
-  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
-  * Portions Copyright (c) 1994, Regents of the University of California
-  *
-  * src/include/lib/dllist.h
-  *
-  *-------------------------------------------------------------------------
-  */
- 
- #ifndef DLLIST_H
- #define DLLIST_H
- 
- struct Dllist;
- struct Dlelem;
- 
- typedef struct Dlelem
- {
- 	struct Dlelem *dle_next;	/* next element */
- 	struct Dlelem *dle_prev;	/* previous element */
- 	void	   *dle_val;		/* value of the element */
- 	struct Dllist *dle_list;	/* what list this element is in */
- } Dlelem;
- 
- typedef struct Dllist
- {
- 	Dlelem	   *dll_head;
- 	Dlelem	   *dll_tail;
- } Dllist;
- 
- extern Dllist *DLNewList(void); /* allocate and initialize a list header */
- extern void DLInitList(Dllist *list);	/* init a header alloced by caller */
- extern void DLFreeList(Dllist *list);	/* free up a list and all the nodes in
- 										 * it */
- extern Dlelem *DLNewElem(void *val);
- extern void DLInitElem(Dlelem *e, void *val);
- extern void DLFreeElem(Dlelem *e);
- extern void DLRemove(Dlelem *e);	/* removes node from list */
- extern void DLAddHead(Dllist *list, Dlelem *node);
- extern void DLAddTail(Dllist *list, Dlelem *node);
- extern Dlelem *DLRemHead(Dllist *list); /* remove and return the head */
- extern Dlelem *DLRemTail(Dllist *list);
- extern void DLMoveToFront(Dlelem *e);	/* move node to front of its list */
- 
- /* These are macros for speed */
- #define DLGetHead(list)  ((list)->dll_head)
- #define DLGetTail(list)  ((list)->dll_tail)
- #define DLGetSucc(elem)  ((elem)->dle_next)
- #define DLGetPred(elem)  ((elem)->dle_prev)
- #define DLGetListHdr(elem)	((elem)->dle_list)
- 
- #define DLE_VAL(elem)	((elem)->dle_val)
- 
- #endif   /* DLLIST_H */
--- 0 ----
diff src/include/lib/ilist.h
new file mode 100644
index ...9bc97dc
*** a/src/include/lib/ilist.h
--- b/src/include/lib/ilist.h
***************
*** 0 ****
--- 1,760 ----
+ /*-------------------------------------------------------------------------
+  *
+  * ilist.h
+  *		integrated/inline doubly- and singly-linked lists
+  *
+  * This implementation is as efficient as possible: the lists don't have
+  * any memory management overhead, because the list pointers are embedded
+  * within some larger structure.
+ 
+  * Also, the circular lists are always circularly linked, even when empty; this
+  * enables many manipulations to be done without branches, which is beneficial
+  * performance-wise.
+  *
+  * NOTES:
+  *
+  * This is intended to be used in situations where memory for a struct and its
+  * contents already needs to be allocated and the overhead of allocating extra
+  * list cells for every list element is noticeable. The API for singly/doubly
+  * linked lists is identical as far as capabilities of both allow.
+  *
+  * // A oversimplified example demonstrating how this can be used:
+  *
+  * #include "lib/ilist.h"
+  *
+  * // Lets assume we want to store information about the tables contained in a
+  * // database.
+  *
+  * // Define struct for the databases including a list header that will be used
+  * // to access the nodes in the list later on.
+  * typedef struct my_database
+  * {
+  *	   char* datname;
+  *	   dlist_head tables;
+  *	   ...
+  * } my_database;
+  *
+  * // Define struct for the tables. Note the list_node element which stores
+  * // information about prev/next list nodes.
+  * typedef struct my_table
+  * {
+  *	   char* tablename;
+  *	   dlist_node list_node;
+  *	   perm_t permissions;
+  *	   ...
+  * } value_in_a_list;
+  *
+  * // create a database
+  * my_database *db = create_database();
+  *
+  * // and a few tables
+  * dlist_push_head(&db->tables, &create_table(db, "a")->list_node);
+  * ...
+  * dlist_push_head(&db->tables, &create_table(db, "b")->list_node);
+  * ...
+  * ...
+  * // to iterate over the table we allocate an iterator element to store
+  * // information about the current position
+  * dlist_iter iter;
+  *
+  * dlist_foreach (iter, &db->tables)
+  * {
+  *	   // inside an *_foreach the iterator's .cur field can be used to access
+  *	   // the current element
+  *	   // iter.cur points to a 'dlist_node', but we want the actual table
+  *	   // information, use dlist_container to convert
+  *	   my_table *tbl = dlist_container(my_table, list_node, iter->cur);
+  *	   elog(NOTICE, 'we have a table: %s in database %s',
+  *			val->tablename, db->datname);
+  * }
+  *
+  * // while a simple iteration is useful we sometimes also want to manipulate
+  * // the list while iterating. Say, we want to delete all tables!
+  *
+  * // declare an iterator that allows some list manipulations
+  * dlist_mutable_iter miter;
+  *
+  * // iterate
+  * dlist_foreach_modify(miter, &db->tables)
+  * {
+  *	   my_table *tbl = dlist_container(my_table, list_node, iter->cur);
+  *	   // unlink the current table from the linked list
+  *	   dlist_delete(&db->tables, iter->cur);
+  *	   // as ilists never manage memory, we can freely access the table
+  *	   drop_table(db, tbl);
+  * }
+  *
+  * // Note that none of the dlist_* functions did do any memory
+  * // management. They just manipulated externally managed memory.
+  *
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  * IDENTIFICATION
+  *		src/include/lib/ilist.h
+  *-------------------------------------------------------------------------
+  */
+ #ifndef ILIST_H
+ #define ILIST_H
+ 
+ /*
+  * enable for extra debugging. This is rather expensive, so it's not enabled by
+  * default even with --enable-cassert.
+  */
+ /* #define ILIST_DEBUG */
+ 
+ /*
+  * Node of a doubly linked list.
+  *
+  * Embed this in structs that need to be part of a doubly linked list.
+  */
+ typedef struct dlist_node dlist_node;
+ struct dlist_node
+ {
+ 	dlist_node *prev;
+ 	dlist_node *next;
+ };
+ 
+ /*
+  * Head of a doubly linked list.
+  *
+  * Lists are internally *always* circularly linked, even when empty. Circular
+  * lists have the advantage of not needing any branches in the most common list
+  * manipulations.
+  */
+ typedef struct dlist_head
+ {
+ 	/*
+ 	 * head->next either points to the first element of the list or to &head
+ 	 * if empty.
+ 	 *
+ 	 * head->prev either points to the last element of the list or to &head if
+ 	 * empty.
+ 	 */
+ 	dlist_node	head;
+ } dlist_head;
+ 
+ 
+ /*
+  * Doubly linked list iterator.
+  *
+  * Used as state in dlist_foreach() and dlist_reverse_foreach(). To get the
+  * current element of the iteration use the 'cur' member.
+  *
+  * Iterations using this are *not* allowed to change the list while iterating!
+  *
+  * NB: We use an extra type for this to make it possible to avoid multiple
+  * evaluations of arguments in the dlist_foreach() macro.
+  */
+ typedef struct dlist_iter
+ {
+ 	dlist_node *end;			/* last node we iterate to */
+ 	dlist_node *cur;			/* current element */
+ } dlist_iter;
+ 
+ /*
+  * Doubly linked list iterator allowing some modifications while iterating
+  *
+  * Used as state in dlist_foreach_modify(). To get the current element of the
+  * iteration use the 'cur' member.
+  *
+  * Iterations using this are only allowed to change the list *at the current
+  * point of iteration*. It is fine to delete the current node, but it is *not*
+  * fine to modify other nodes.
+  *
+  * NB: We need a separate type for mutable iterations to avoid having to pass
+  * in two iterators or some other state variable as we need to store the
+  * '->next' node of the current node so it can be deleted or modified by the
+  * user.
+  */
+ typedef struct dlist_mutable_iter
+ {
+ 	dlist_node *end;			/* last node we iterate to */
+ 	dlist_node *cur;			/* current element */
+ 	dlist_node *next;			/* next node we iterate to, so we can delete
+ 								 * cur */
+ } dlist_mutable_iter;
+ 
+ /*
+  * Node of a singly linked list.
+  *
+  * Embed this in structs that need to be part of a singly linked list.
+  */
+ typedef struct slist_node slist_node;
+ struct slist_node
+ {
+ 	slist_node *next;
+ };
+ 
+ /*
+  * Head of a singly linked list.
+  *
+  * Singly linked lists are *not* circularly linked (how could they be?) in
+  * contrast to the doubly linked lists. As no pointer to the last list element
+  * and to the previous node needs to be maintained this doesn't incur any
+  * additional branches in the usual manipulations.
+  */
+ typedef struct slist_head
+ {
+ 	slist_node	head;
+ } slist_head;
+ 
+ /*
+  * Singly linked list iterator
+  *
+  * Used in slist_foreach(). To get the current element of the iteration use the
+  * 'cur' member.
+  *
+  * Do *not* manipulate the list while iterating!
+  *
+  * NB: this wouldn't really need to be an extra struct, we could use a
+  * slist_node * directly. For consistency reasons with dlist_*iter and
+  * slist_mutable_iter we still use a separate type.
+  */
+ typedef struct slist_iter
+ {
+ 	slist_node *cur;
+ } slist_iter;
+ 
+ /*
+  * Singly linked list iterator allowing some modifications while iterating
+  *
+  * Used in slist_foreach_modify.
+  *
+  * Iterations using this are allowed to remove the current node and to add more
+  * nodes to the beginning of the list.
+  */
+ typedef struct slist_mutable_iter
+ {
+ 	slist_node *cur;
+ 	slist_node *next;
+ } slist_mutable_iter;
+ 
+ 
+ /*
+  * We take quite some pain to allow this 'module' to be used on compilers
+  * without usable 'static inline' support. If configure detects its not
+  * available all the inline functions will be defined in ilist.c instead by
+  * #define'ing ILIST_USE_DEFINITION there.
+  */
+ #ifdef USE_INLINE
+ #define INLINE_IF_POSSIBLE static inline
+ #else
+ /* hide inline declarations from compiler */
+ #define INLINE_IF_POSSIBLE
+ 
+ /* Prototypes for functions we want to be inlined if possible */
+ extern void dlist_init(dlist_head *head);
+ extern bool dlist_is_empty(dlist_head *head);
+ extern void dlist_push_head(dlist_head *head, dlist_node *node);
+ extern void dlist_push_tail(dlist_head *head, dlist_node *node);
+ extern void dlist_insert_after(dlist_head *head,
+ 				   dlist_node *after, dlist_node *node);
+ extern void dlist_insert_before(dlist_head *head,
+ 					dlist_node *before, dlist_node *node);
+ extern void dlist_delete(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_pop_head_node(dlist_head *head);
+ extern void dlist_move_head(dlist_head *head, dlist_node *node);
+ extern bool dlist_has_next(dlist_head *head, dlist_node *node);
+ extern bool dlist_has_prev(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_next_node(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_prev_node(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_head_node(dlist_head *head);
+ extern dlist_node *dlist_tail_node(dlist_head *head);
+ 
+ /* dlist macro support functions */
+ extern void *dlist_tail_element_off(dlist_head *head, size_t off);
+ extern void *dlist_head_element_off(dlist_head *head, size_t off);
+ 
+ extern void slist_init(slist_head *head);
+ extern bool slist_is_empty(slist_head *head);
+ extern slist_node *slist_head_node(slist_head *head);
+ extern void slist_push_head(slist_head *head, slist_node *node);
+ extern slist_node *slist_pop_head_node(slist_head *head);
+ extern void slist_insert_after(slist_head *head,
+ 				   slist_node *after, slist_node *node);
+ extern bool slist_has_next(slist_head *head, slist_node *node);
+ extern slist_node *slist_next_node(slist_head *head, slist_node *node);
+ 
+ /* slist macro support function */
+ extern void *slist_head_element_off(slist_head *head, size_t off);
+ #endif   /* !USE_INLINE */
+ 
+ /* These functions are too big to be inline, so they are in the C file always */
+ 
+ /* Attention: O(n) */
+ extern void slist_delete(slist_head *head, slist_node *node);
+ 
+ #ifdef ILIST_DEBUG
+ extern void dlist_check(dlist_head *head);
+ extern void slist_check(slist_head *head);
+ #else
+ /*
+  * These seemingly useless casts to void are here to keep the compiler quiet
+  * about the argument being unused in many functions in a non-debug compile,
+  * in which functions the only point of passing the list head pointer is to be
+  * able to run these checks.
+  */
+ #define dlist_check(head)	(void) (head)
+ #define slist_check(head)	(void) (head)
+ #endif   /* ILIST_DEBUG */
+ 
+ #define DLIST_STATIC_INIT(name) {{&name.head, &name.head}}
+ #define SLIST_STATIC_INIT(name) {{NULL}}
+ 
+ /*
+  * The following function definitions are only used if inlining is supported by
+  * the compiler, or when included from a file that explicitly declares
+  * ILIST_USE_DEFINITION.
+  */
+ #if defined(USE_INLINE) || defined(ILIST_DEFINE_FUNCTIONS)
+ 
+ /*
+  * Initialize the head of a list. Previous state will be thrown away without
+  * any cleanup.
+  */
+ INLINE_IF_POSSIBLE void
+ dlist_init(dlist_head *head)
+ {
+ 	head->head.next = head->head.prev = &head->head;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Insert a node at the beginning of the list.
+  */
+ INLINE_IF_POSSIBLE void
+ dlist_push_head(dlist_head *head, dlist_node *node)
+ {
+ 	node->next = head->head.next;
+ 	node->prev = &head->head;
+ 	node->next->prev = node;
+ 	head->head.next = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Inserts a node at the end of the list.
+  */
+ INLINE_IF_POSSIBLE void
+ dlist_push_tail(dlist_head *head, dlist_node *node)
+ {
+ 	node->next = &head->head;
+ 	node->prev = head->head.prev;
+ 	node->prev->next = node;
+ 	head->head.prev = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Insert a node after another *in the same list*
+  */
+ INLINE_IF_POSSIBLE void
+ dlist_insert_after(dlist_head *head, dlist_node *after,
+ 				   dlist_node *node)
+ {
+ 	dlist_check(head);
+ 	/* XXX: assert 'after' is in 'head'? */
+ 
+ 	node->prev = after;
+ 	node->next = after->next;
+ 	after->next = node;
+ 	node->next->prev = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Insert a node before another *in the same list*
+  */
+ INLINE_IF_POSSIBLE void
+ dlist_insert_before(dlist_head *head, dlist_node *before,
+ 					dlist_node *node)
+ {
+ 	dlist_check(head);
+ 	/* XXX: assert 'after' is in 'head'? */
+ 
+ 	node->prev = before->prev;
+ 	node->next = before;
+ 	before->prev = node;
+ 	node->prev->next = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Delete 'node' from list.
+  *
+  * It is not allowed to delete a 'node' which is is not in the list 'head'
+  */
+ INLINE_IF_POSSIBLE void
+ dlist_delete(dlist_head *head, dlist_node *node)
+ {
+ 	dlist_check(head);
+ 
+ 	node->prev->next = node->next;
+ 	node->next->prev = node->prev;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Delete and return the first node from a list.
+  *
+  * Undefined behaviour when the list is empty, check with dlist_is_empty if
+  * necessary.
+  */
+ INLINE_IF_POSSIBLE dlist_node *
+ dlist_pop_head_node(dlist_head *head)
+ {
+ 	dlist_node *ret;
+ 
+ 	Assert(&head->head != head->head.next);
+ 
+ 	ret = head->head.next;
+ 	dlist_delete(head, head->head.next);
+ 	return ret;
+ }
+ 
+ /*
+  * Move element from any position in the list to the head position in the same
+  * list.
+  *
+  * Undefined behaviour if 'node' is not already part of the list.
+  */
+ INLINE_IF_POSSIBLE void
+ dlist_move_head(dlist_head *head, dlist_node *node)
+ {
+ 	/* fast path if it's already at the head */
+ 	if (&head->head == node)
+ 		return;
+ 
+ 	dlist_delete(head, node);
+ 	dlist_push_head(head, node);
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Check whether the passed node is the last element in the list.
+  */
+ INLINE_IF_POSSIBLE bool
+ dlist_has_next(dlist_head *head, dlist_node *node)
+ {
+ 	return node->next != &head->head;
+ }
+ 
+ /*
+  * Check whether the passed node is the first element in the list.
+  */
+ INLINE_IF_POSSIBLE bool
+ dlist_has_prev(dlist_head *head, dlist_node *node)
+ {
+ 	return node->prev != &head->head;
+ }
+ 
+ /*
+  * Return the next node in the list.
+  *
+  * Undefined bheaviour when no next node exists, use dlist_has_next to make
+  * sure.
+  */
+ INLINE_IF_POSSIBLE dlist_node *
+ dlist_next_node(dlist_head *head, dlist_node *node)
+ {
+ 	Assert(dlist_has_next(head, node));
+ 	return node->next;
+ }
+ 
+ /*
+  * Return previous node if there is one, NULL otherwise
+  *
+  * Undefined bheaviour when no prev node exists, use dlist_has_prev to make
+  * sure.
+  */
+ INLINE_IF_POSSIBLE dlist_node *
+ dlist_prev_node(dlist_head *head, dlist_node *node)
+ {
+ 	Assert(dlist_has_prev(head, node));
+ 	return node->prev;
+ }
+ 
+ /*
+  * Return whether the list is empty.
+  */
+ INLINE_IF_POSSIBLE bool
+ dlist_is_empty(dlist_head *head)
+ {
+ 	return head->head.next == &(head->head);
+ }
+ 
+ /* internal support function */
+ INLINE_IF_POSSIBLE void *
+ dlist_head_element_off(dlist_head *head, size_t off)
+ {
+ 	Assert(!dlist_is_empty(head));
+ 	return (char *) head->head.next - off;
+ }
+ 
+ /*
+  * Return the first node in the list.
+  *
+  * Use dlist_is_empty to make sure the list is not empty if not sure.
+  */
+ INLINE_IF_POSSIBLE dlist_node *
+ dlist_head_node(dlist_head *head)
+ {
+ 	return dlist_head_element_off(head, 0);
+ }
+ 
+ /* internal support function */
+ INLINE_IF_POSSIBLE void *
+ dlist_tail_element_off(dlist_head *head, size_t off)
+ {
+ 	Assert(!dlist_is_empty(head));
+ 	return (char *) head->head.prev - off;
+ }
+ 
+ /*
+  * Return the last node in the list.
+  *
+  * Use dlist_is_empty to make sure the list is not empty if not sure.
+  */
+ INLINE_IF_POSSIBLE dlist_node *
+ dlist_tail_node(dlist_head *head)
+ {
+ 	return dlist_tail_element_off(head, 0);
+ }
+ #endif   /* defined(USE_INLINE) ||
+ 								 * defined(ILIST_DEFINE_FUNCTIONS) */
+ 
+ /*
+  * Return the containing struct of 'type' where 'membername' is the dlist_node
+  * pointed at by 'ptr'.
+  *
+  * This is used to convert a dlist_node* returned by some list
+  * navigation/manipulation back to its content.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define dlist_container(type, membername, ptr)								 \
+ 	(AssertVariableIsOfTypeMacro(ptr, dlist_node *),						 \
+ 	 AssertVariableIsOfTypeMacro(((type *) NULL)->membername, dlist_node),	 \
+ 	 ((type *)((char *)(ptr) - offsetof(type, membername)))					 \
+ 	 )
+ /*
+  * Return the value of first element in the list.
+  *
+  * The list may not be empty.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define dlist_head_element(type, membername, ptr)							 \
+ 	(AssertVariableIsOfTypeMacro(((type*) NULL)->membername, dlist_node),	 \
+ 	 ((type *)dlist_get_head_off(ptr, offsetof(type, membername))))
+ 
+ /*
+  * Return the value of first element in the list.
+  *
+  * The list may not be empty.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define dlist_tail_element(type, membername, ptr)							 \
+ 	(AssertVariableIsOfTypeMacro(((type*) NULL)->membername, dlist_node),	 \
+ 	 ((type *)dlist_tail_element_off(ptr, offsetof(type, membername))))
+ 
+ /*
+  * Iterate through the list pointed at by 'ptr' storing the state in 'iter'.
+  *
+  * Access the current element with iter.cur.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define dlist_foreach(iter, ptr)											 \
+ 	AssertVariableIsOfType(iter, dlist_iter);								 \
+ 	AssertVariableIsOfType(ptr, dlist_head *);								 \
+ 	for (iter.end = &(ptr)->head, iter.cur = iter.end->next;				 \
+ 		 iter.cur != iter.end;												 \
+ 		 iter.cur = iter.cur->next)
+ 
+ 
+ /*
+  * Iterate through the list pointed at by 'ptr' storing the state in 'iter'.
+  *
+  * Access the current element with iter.cur.
+  *
+  * It is allowed to delete the current element from the list. Every other
+  * manipulation can lead to corruption.
+  */
+ #define dlist_foreach_modify(iter, ptr)										 \
+ 	AssertVariableIsOfType(iter, dlist_mutable_iter);						 \
+ 	AssertVariableIsOfType(ptr, dlist_head *);								 \
+ 	for (iter.end = &(ptr)->head, iter.cur = iter.end->next,				 \
+ 			 iter.next = iter.cur->next;									 \
+ 		 iter.cur != iter.end;												 \
+ 		 iter.cur = iter.next, iter.next = iter.cur->next)
+ 
+ /*
+  * Iterate through the list in reverse order.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define dlist_reverse_foreach(iter, ptr)									 \
+ 	AssertVariableIsOfType(iter, dlist_iter);								 \
+ 	AssertVariableIsOfType(ptr, dlist_head *);								 \
+ 	for (iter.end = &(ptr)->head, iter.cur = iter.end->prev;				 \
+ 		 iter.cur != iter.end;												 \
+ 		 iter.cur = iter.cur->prev)
+ 
+ #if defined(USE_INLINE) || defined(ILIST_DEFINE_FUNCTIONS)
+ 
+ /*
+  * Initialize a singly linked list.
+  */
+ INLINE_IF_POSSIBLE void
+ slist_init(slist_head *head)
+ {
+ 	head->head.next = NULL;
+ 
+ 	slist_check(head);
+ }
+ 
+ /*
+  * Is the list empty?
+  */
+ INLINE_IF_POSSIBLE bool
+ slist_is_empty(slist_head *head)
+ {
+ 	slist_check(head);
+ 
+ 	return head->head.next == NULL;
+ }
+ 
+ /* internal support function */
+ INLINE_IF_POSSIBLE void *
+ slist_head_element_off(slist_head *head, size_t off)
+ {
+ 	Assert(!slist_is_empty(head));
+ 	return (char *) head->head.next - off;
+ }
+ 
+ /*
+  * Push 'node' as the new first node in the list, pushing the original head to
+  * the second position.
+  */
+ INLINE_IF_POSSIBLE void
+ slist_push_head(slist_head *head, slist_node *node)
+ {
+ 	node->next = head->head.next;
+ 	head->head.next = node;
+ 
+ 	slist_check(head);
+ }
+ 
+ /*
+  * Remove and return the first node in the list
+  *
+  * Undefined behaviour if the list is empty.
+  */
+ INLINE_IF_POSSIBLE slist_node *
+ slist_pop_head_node(slist_head *head)
+ {
+ 	slist_node *node;
+ 
+ 	Assert(!slist_is_empty(head));
+ 
+ 	node = head->head.next;
+ 	head->head.next = head->head.next->next;
+ 
+ 	slist_check(head);
+ 
+ 	return node;
+ }
+ 
+ /*
+  * Insert a new node after another one
+  *
+  * Undefined behaviour if 'after' is not part of the list already.
+  */
+ INLINE_IF_POSSIBLE void
+ slist_insert_after(slist_head *head, slist_node *after,
+ 				   slist_node *node)
+ {
+ 	node->next = after->next;
+ 	after->next = node;
+ 
+ 	slist_check(head);
+ }
+ 
+ /*
+  * Return whether 'node' has a following node
+  */
+ INLINE_IF_POSSIBLE bool
+ slist_has_next(slist_head *head,
+ 			   slist_node *node)
+ {
+ 	slist_check(head);
+ 
+ 	return node->next != NULL;
+ }
+ #endif   /*-- defined(USE_INLINE || ILIST_DEFINE_FUNCTIONS) --*/
+ 
+ /*
+  * Return the containing struct of 'type' where 'membername' is the slist_node
+  * pointed at by 'ptr'.
+  *
+  * This is used to convert a slist_node* returned by some list
+  * navigation/manipulation back to its content.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define slist_container(type, membername, ptr)								 \
+ 	(AssertVariableIsOfTypeMacro(ptr, slist_node *),						 \
+ 	 AssertVariableIsOfTypeMacro(((type*)NULL)->membername, slist_node),	 \
+ 	 ((type *)((char *)(ptr) - offsetof(type, membername)))					 \
+ 	 )
+ /*
+  * Return the value of first element in the list.
+  */
+ #define slist_head_element(type, membername, ptr)							 \
+ 	(AssertVariableIsOfTypeMacro(((type*)NULL)->membername, slist_node),	 \
+ 	 slist_head_element_off(ptr, offsetoff(type, membername)))
+ 
+ /*
+  * Iterate through the list 'ptr' using the iterator 'iter'.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define slist_foreach(iter, ptr)											 \
+ 	AssertVariableIsOfType(iter, slist_iter);								 \
+ 	AssertVariableIsOfType(ptr, slist_head *);								 \
+ 	for (iter.cur = (ptr)->head.next;										 \
+ 		 iter.cur != NULL;													 \
+ 		 iter.cur = iter.cur->next)
+ 
+ /*
+  * Iterate through the list 'ptr' using the iterator 'iter' allowing some
+  * modifications.
+  *
+  * It is allowed to delete the current element from the list and add new nodes
+  * before the current position. Every other manipulation can lead to
+  * corruption.
+  */
+ #define slist_foreach_modify(iter, ptr)										 \
+ 	AssertVariableIsOfType(iter, slist_mutable_iter);						 \
+ 	AssertVariableIsOfType(ptr, slist_head *);								 \
+ 	for (iter.cur = (ptr)->head.next,										 \
+ 			 iter.next = iter.cur ? iter.cur->next : NULL;					 \
+ 		iter.cur != NULL;													 \
+ 		iter.cur = iter.next, iter.next = iter.next ? iter.next->next : NULL)
+ 
+ #endif   /* ILIST_H */
diff src/include/utils/catcache.h
index d91700a..cc6dab2
*** a/src/include/utils/catcache.h
--- b/src/include/utils/catcache.h
***************
*** 22,28 ****
  
  #include "access/htup.h"
  #include "access/skey.h"
! #include "lib/dllist.h"
  #include "utils/relcache.h"
  
  /*
--- 22,28 ----
  
  #include "access/htup.h"
  #include "access/skey.h"
! #include "lib/ilist.h"
  #include "utils/relcache.h"
  
  /*
***************
*** 37,43 ****
  typedef struct catcache
  {
  	int			id;				/* cache identifier --- see syscache.h */
! 	struct catcache *cc_next;	/* link to next catcache */
  	const char *cc_relname;		/* name of relation the tuples come from */
  	Oid			cc_reloid;		/* OID of relation the tuples come from */
  	Oid			cc_indexoid;	/* OID of index matching cache keys */
--- 37,43 ----
  typedef struct catcache
  {
  	int			id;				/* cache identifier --- see syscache.h */
! 	slist_node	cc_next;		/* list link */
  	const char *cc_relname;		/* name of relation the tuples come from */
  	Oid			cc_reloid;		/* OID of relation the tuples come from */
  	Oid			cc_indexoid;	/* OID of index matching cache keys */
*************** typedef struct catcache
*** 51,57 ****
  	ScanKeyData cc_skey[CATCACHE_MAXKEYS];		/* precomputed key info for
  												 * heap scans */
  	bool		cc_isname[CATCACHE_MAXKEYS];	/* flag "name" key columns */
! 	Dllist		cc_lists;		/* list of CatCList structs */
  #ifdef CATCACHE_STATS
  	long		cc_searches;	/* total # searches against this cache */
  	long		cc_hits;		/* # of matches against existing entry */
--- 51,57 ----
  	ScanKeyData cc_skey[CATCACHE_MAXKEYS];		/* precomputed key info for
  												 * heap scans */
  	bool		cc_isname[CATCACHE_MAXKEYS];	/* flag "name" key columns */
! 	dlist_head	cc_lists;		/* list of CatCList structs */
  #ifdef CATCACHE_STATS
  	long		cc_searches;	/* total # searches against this cache */
  	long		cc_hits;		/* # of matches against existing entry */
*************** typedef struct catcache
*** 66,72 ****
  	long		cc_lsearches;	/* total # list-searches */
  	long		cc_lhits;		/* # of matches against existing lists */
  #endif
! 	Dllist		cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
  } CatCache;						/* VARIABLE LENGTH STRUCT */
  
  
--- 66,72 ----
  	long		cc_lsearches;	/* total # list-searches */
  	long		cc_lhits;		/* # of matches against existing lists */
  #endif
! 	dlist_head	cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
  } CatCache;						/* VARIABLE LENGTH STRUCT */
  
  
*************** typedef struct catctup
*** 77,87 ****
  	CatCache   *my_cache;		/* link to owning catcache */
  
  	/*
! 	 * Each tuple in a cache is a member of a Dllist that stores the elements
! 	 * of its hash bucket.	We keep each Dllist in LRU order to speed repeated
  	 * lookups.
  	 */
! 	Dlelem		cache_elem;		/* list member of per-bucket list */
  
  	/*
  	 * The tuple may also be a member of at most one CatCList.	(If a single
--- 77,88 ----
  	CatCache   *my_cache;		/* link to owning catcache */
  
  	/*
! 	 * Each tuple in a cache is a member of a dlist that stores the elements
! 	 * of its hash bucket.	We keep each dlist in LRU order to speed repeated
  	 * lookups.
  	 */
! 	dlist_node	cache_elem;		/* list member of per-bucket list */
! 	dlist_head *cache_bucket;	/* containing bucket dlist */
  
  	/*
  	 * The tuple may also be a member of at most one CatCList.	(If a single
*************** typedef struct catclist
*** 139,145 ****
  	 * might not be true during bootstrap or recovery operations. (namespace.c
  	 * is able to save some cycles when it is true.)
  	 */
! 	Dlelem		cache_elem;		/* list member of per-catcache list */
  	int			refcount;		/* number of active references */
  	bool		dead;			/* dead but not yet removed? */
  	bool		ordered;		/* members listed in index order? */
--- 140,146 ----
  	 * might not be true during bootstrap or recovery operations. (namespace.c
  	 * is able to save some cycles when it is true.)
  	 */
! 	dlist_node	cache_elem;		/* list member of per-catcache list */
  	int			refcount;		/* number of active references */
  	bool		dead;			/* dead but not yet removed? */
  	bool		ordered;		/* members listed in index order? */
*************** typedef struct catclist
*** 153,159 ****
  
  typedef struct catcacheheader
  {
! 	CatCache   *ch_caches;		/* head of list of CatCache structs */
  	int			ch_ntup;		/* # of tuples in all caches */
  } CatCacheHeader;
  
--- 154,160 ----
  
  typedef struct catcacheheader
  {
! 	slist_head	ch_caches;		/* head of list of CatCache structs */
  	int			ch_ntup;		/* # of tuples in all caches */
  } CatCacheHeader;
  

*** a/src/backend/lib/Makefile
--- b/src/backend/lib/Makefile
***************
*** 12,17 **** subdir = src/backend/lib
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = dllist.o stringinfo.o
  
  include $(top_srcdir)/src/backend/common.mk
--- 12,17 ----
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = ilist.o stringinfo.o
  
  include $(top_srcdir)/src/backend/common.mk
*** a/src/backend/lib/dllist.c
--- /dev/null
***************
*** 1,214 ****
- /*-------------------------------------------------------------------------
-  *
-  * dllist.c
-  *	  this is a simple doubly linked list implementation
-  *	  the elements of the lists are void*
-  *
-  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
-  * Portions Copyright (c) 1994, Regents of the University of California
-  *
-  *
-  * IDENTIFICATION
-  *	  src/backend/lib/dllist.c
-  *
-  *-------------------------------------------------------------------------
-  */
- #include "postgres.h"
- 
- #include "lib/dllist.h"
- 
- 
- Dllist *
- DLNewList(void)
- {
- 	Dllist	   *l;
- 
- 	l = (Dllist *) palloc(sizeof(Dllist));
- 
- 	l->dll_head = NULL;
- 	l->dll_tail = NULL;
- 
- 	return l;
- }
- 
- void
- DLInitList(Dllist *list)
- {
- 	list->dll_head = NULL;
- 	list->dll_tail = NULL;
- }
- 
- /*
-  * free up a list and all the nodes in it --- but *not* whatever the nodes
-  * might point to!
-  */
- void
- DLFreeList(Dllist *list)
- {
- 	Dlelem	   *curr;
- 
- 	while ((curr = DLRemHead(list)) != NULL)
- 		pfree(curr);
- 
- 	pfree(list);
- }
- 
- Dlelem *
- DLNewElem(void *val)
- {
- 	Dlelem	   *e;
- 
- 	e = (Dlelem *) palloc(sizeof(Dlelem));
- 
- 	e->dle_next = NULL;
- 	e->dle_prev = NULL;
- 	e->dle_val = val;
- 	e->dle_list = NULL;
- 	return e;
- }
- 
- void
- DLInitElem(Dlelem *e, void *val)
- {
- 	e->dle_next = NULL;
- 	e->dle_prev = NULL;
- 	e->dle_val = val;
- 	e->dle_list = NULL;
- }
- 
- void
- DLFreeElem(Dlelem *e)
- {
- 	pfree(e);
- }
- 
- void
- DLRemove(Dlelem *e)
- {
- 	Dllist	   *l = e->dle_list;
- 
- 	if (e->dle_prev)
- 		e->dle_prev->dle_next = e->dle_next;
- 	else
- 	{
- 		/* must be the head element */
- 		Assert(e == l->dll_head);
- 		l->dll_head = e->dle_next;
- 	}
- 	if (e->dle_next)
- 		e->dle_next->dle_prev = e->dle_prev;
- 	else
- 	{
- 		/* must be the tail element */
- 		Assert(e == l->dll_tail);
- 		l->dll_tail = e->dle_prev;
- 	}
- 
- 	e->dle_next = NULL;
- 	e->dle_prev = NULL;
- 	e->dle_list = NULL;
- }
- 
- void
- DLAddHead(Dllist *l, Dlelem *e)
- {
- 	e->dle_list = l;
- 
- 	if (l->dll_head)
- 		l->dll_head->dle_prev = e;
- 	e->dle_next = l->dll_head;
- 	e->dle_prev = NULL;
- 	l->dll_head = e;
- 
- 	if (l->dll_tail == NULL)	/* if this is first element added */
- 		l->dll_tail = e;
- }
- 
- void
- DLAddTail(Dllist *l, Dlelem *e)
- {
- 	e->dle_list = l;
- 
- 	if (l->dll_tail)
- 		l->dll_tail->dle_next = e;
- 	e->dle_prev = l->dll_tail;
- 	e->dle_next = NULL;
- 	l->dll_tail = e;
- 
- 	if (l->dll_head == NULL)	/* if this is first element added */
- 		l->dll_head = e;
- }
- 
- Dlelem *
- DLRemHead(Dllist *l)
- {
- 	/* remove and return the head */
- 	Dlelem	   *result = l->dll_head;
- 
- 	if (result == NULL)
- 		return result;
- 
- 	if (result->dle_next)
- 		result->dle_next->dle_prev = NULL;
- 
- 	l->dll_head = result->dle_next;
- 
- 	if (result == l->dll_tail)	/* if the head is also the tail */
- 		l->dll_tail = NULL;
- 
- 	result->dle_next = NULL;
- 	result->dle_list = NULL;
- 
- 	return result;
- }
- 
- Dlelem *
- DLRemTail(Dllist *l)
- {
- 	/* remove and return the tail */
- 	Dlelem	   *result = l->dll_tail;
- 
- 	if (result == NULL)
- 		return result;
- 
- 	if (result->dle_prev)
- 		result->dle_prev->dle_next = NULL;
- 
- 	l->dll_tail = result->dle_prev;
- 
- 	if (result == l->dll_head)	/* if the tail is also the head */
- 		l->dll_head = NULL;
- 
- 	result->dle_prev = NULL;
- 	result->dle_list = NULL;
- 
- 	return result;
- }
- 
- /* Same as DLRemove followed by DLAddHead, but faster */
- void
- DLMoveToFront(Dlelem *e)
- {
- 	Dllist	   *l = e->dle_list;
- 
- 	if (l->dll_head == e)
- 		return;					/* Fast path if already at front */
- 
- 	Assert(e->dle_prev != NULL);	/* since it's not the head */
- 	e->dle_prev->dle_next = e->dle_next;
- 
- 	if (e->dle_next)
- 		e->dle_next->dle_prev = e->dle_prev;
- 	else
- 	{
- 		/* must be the tail element */
- 		Assert(e == l->dll_tail);
- 		l->dll_tail = e->dle_prev;
- 	}
- 
- 	l->dll_head->dle_prev = e;
- 	e->dle_next = l->dll_head;
- 	e->dle_prev = NULL;
- 	l->dll_head = e;
- 	/* We need not check dll_tail, since there must have been > 1 entry */
- }
--- 0 ----
*** /dev/null
--- b/src/backend/lib/ilist.c
***************
*** 0 ****
--- 1,109 ----
+ /*-------------------------------------------------------------------------
+  *
+  * ilist.c
+  *	  support for integrated/inline doubly- and singly- linked lists
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *
+  * IDENTIFICATION
+  *	  src/backend/lib/ilist.c
+  *
+  * NOTES
+  *	  This file only contains functions that are too big to be considered
+  *	  for inlining.  See ilist.h for most of the goodies.
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ /* See ilist.h */
+ #define ILIST_INCLUDE_DEFINITIONS
+ 
+ #include "lib/ilist.h"
+ 
+ /*
+  * removes a node from a list
+  *
+  * Attention: O(n)
+  */
+ void
+ slist_delete(slist_head *head, slist_node *node)
+ {
+ 	slist_node *last = &head->head;
+ 	slist_node *cur;
+ 	bool found	PG_USED_FOR_ASSERTS_ONLY = false;
+ 
+ 	while ((cur = last->next) != NULL)
+ 	{
+ 		if (cur == node)
+ 		{
+ 			last->next = cur->next;
+ #ifdef USE_ASSERT_CHECKING
+ 			found = true;
+ #endif
+ 			break;
+ 		}
+ 		last = cur;
+ 	}
+ 
+ 	slist_check(head);
+ 	Assert(found);
+ }
+ 
+ #ifdef ILIST_DEBUG
+ /*
+  * Verify integrity of a doubly linked list
+  */
+ void
+ dlist_check(dlist_head *head)
+ {
+ 	dlist_node *cur;
+ 
+ 	if (head == NULL || !(&head->head))
+ 		elog(ERROR, "doubly linked list head is not properly initialized");
+ 
+ 	/* iterate in forward direction */
+ 	for (cur = head->head.next; cur != &head->head; cur = cur->next)
+ 	{
+ 		if (cur == NULL ||
+ 			cur->next == NULL ||
+ 			cur->prev == NULL ||
+ 			cur->prev->next != cur ||
+ 			cur->next->prev != cur)
+ 			elog(ERROR, "doubly linked list is corrupted");
+ 	}
+ 
+ 	/* iterate in backward direction */
+ 	for (cur = head->head.prev; cur != &head->head; cur = cur->prev)
+ 	{
+ 		if (cur == NULL ||
+ 			cur->next == NULL ||
+ 			cur->prev == NULL ||
+ 			cur->prev->next != cur ||
+ 			cur->next->prev != cur)
+ 			elog(ERROR, "doubly linked list is corrupted");
+ 	}
+ }
+ 
+ /*
+  * Verify integrity of a singly linked list
+  */
+ void
+ slist_check(slist_head *head)
+ {
+ 	slist_node *cur;
+ 
+ 	if (head == NULL)
+ 		elog(ERROR, "singly linked is NULL");
+ 
+ 	/*
+ 	 * there isn't much we can test in a singly linked list other that it
+ 	 * actually ends sometime, i.e. hasn't introduced a cycle or similar
+ 	 */
+ 	for (cur = head->head.next; cur != NULL; cur = cur->next)
+ 		;
+ }
+ 
+ #endif   /* ILIST_DEBUG */
*** a/src/backend/postmaster/autovacuum.c
--- b/src/backend/postmaster/autovacuum.c
***************
*** 77,83 ****
  #include "catalog/pg_database.h"
  #include "commands/dbcommands.h"
  #include "commands/vacuum.h"
! #include "lib/dllist.h"
  #include "libpq/pqsignal.h"
  #include "miscadmin.h"
  #include "pgstat.h"
--- 77,83 ----
  #include "catalog/pg_database.h"
  #include "commands/dbcommands.h"
  #include "commands/vacuum.h"
! #include "lib/ilist.h"
  #include "libpq/pqsignal.h"
  #include "miscadmin.h"
  #include "pgstat.h"
***************
*** 152,157 **** typedef struct avl_dbase
--- 152,158 ----
  	Oid			adl_datid;		/* hash key -- must be first */
  	TimestampTz adl_next_worker;
  	int			adl_score;
+ 	dlist_node	adl_node;
  } avl_dbase;
  
  /* struct to keep track of databases in worker */
***************
*** 258,265 **** typedef struct
  
  static AutoVacuumShmemStruct *AutoVacuumShmem;
  
! /* the database list in the launcher, and the context that contains it */
! static Dllist *DatabaseList = NULL;
  static MemoryContext DatabaseListCxt = NULL;
  
  /* Pointer to my own WorkerInfo, valid on each worker */
--- 259,269 ----
  
  static AutoVacuumShmemStruct *AutoVacuumShmem;
  
! /*
!  * the database list (of avl_dbase elements) in the launcher, and the context
!  * that contains it
!  */
! static dlist_head DatabaseList = DLIST_STATIC_INIT(DatabaseList);
  static MemoryContext DatabaseListCxt = NULL;
  
  /* Pointer to my own WorkerInfo, valid on each worker */
***************
*** 508,514 **** AutoVacLauncherMain(int argc, char *argv[])
  
  		/* don't leave dangling pointers to freed memory */
  		DatabaseListCxt = NULL;
! 		DatabaseList = NULL;
  
  		/*
  		 * Make sure pgstat also considers our stat data as gone.  Note: we
--- 512,518 ----
  
  		/* don't leave dangling pointers to freed memory */
  		DatabaseListCxt = NULL;
! 		dlist_init(&DatabaseList);
  
  		/*
  		 * Make sure pgstat also considers our stat data as gone.  Note: we
***************
*** 576,582 **** AutoVacLauncherMain(int argc, char *argv[])
  		struct timeval nap;
  		TimestampTz current_time = 0;
  		bool		can_launch;
! 		Dlelem	   *elem;
  		int			rc;
  
  		/*
--- 580,586 ----
  		struct timeval nap;
  		TimestampTz current_time = 0;
  		bool		can_launch;
! 		avl_dbase  *avdb;
  		int			rc;
  
  		/*
***************
*** 738,757 **** AutoVacLauncherMain(int argc, char *argv[])
  
  		/* We're OK to start a new worker */
  
! 		elem = DLGetTail(DatabaseList);
! 		if (elem != NULL)
! 		{
! 			avl_dbase  *avdb = DLE_VAL(elem);
! 
! 			/*
! 			 * launch a worker if next_worker is right now or it is in the
! 			 * past
! 			 */
! 			if (TimestampDifferenceExceeds(avdb->adl_next_worker,
! 										   current_time, 0))
! 				launch_worker(current_time);
! 		}
! 		else
  		{
  			/*
  			 * Special case when the list is empty: start a worker right away.
--- 742,748 ----
  
  		/* We're OK to start a new worker */
  
! 		if (dlist_is_empty(&DatabaseList))
  		{
  			/*
  			 * Special case when the list is empty: start a worker right away.
***************
*** 763,768 **** AutoVacLauncherMain(int argc, char *argv[])
--- 754,776 ----
  			 */
  			launch_worker(current_time);
  		}
+ 		else
+ 		{
+ 			/*
+ 			 * because rebuild_database_list constructs a list with most
+ 			 * distant adl_next_worker first, we obtain our database from the
+ 			 * tail of the list.
+ 			 */
+ 			avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
+ 
+ 			/*
+ 			 * launch a worker if next_worker is right now or it is in the
+ 			 * past
+ 			 */
+ 			if (TimestampDifferenceExceeds(avdb->adl_next_worker,
+ 										   current_time, 0))
+ 				launch_worker(current_time);
+ 		}
  	}
  
  	/* Normal exit from the autovac launcher is here */
***************
*** 783,789 **** AutoVacLauncherMain(int argc, char *argv[])
  static void
  launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
  {
! 	Dlelem	   *elem;
  
  	/*
  	 * We sleep until the next scheduled vacuum.  We trust that when the
--- 791,797 ----
  static void
  launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
  {
! 	avl_dbase  *avdb;
  
  	/*
  	 * We sleep until the next scheduled vacuum.  We trust that when the
***************
*** 796,809 **** launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
  		nap->tv_sec = autovacuum_naptime;
  		nap->tv_usec = 0;
  	}
! 	else if ((elem = DLGetTail(DatabaseList)) != NULL)
  	{
- 		avl_dbase  *avdb = DLE_VAL(elem);
  		TimestampTz current_time = GetCurrentTimestamp();
  		TimestampTz next_wakeup;
  		long		secs;
  		int			usecs;
  
  		next_wakeup = avdb->adl_next_worker;
  		TimestampDifference(current_time, next_wakeup, &secs, &usecs);
  
--- 804,818 ----
  		nap->tv_sec = autovacuum_naptime;
  		nap->tv_usec = 0;
  	}
! 	else if (!dlist_is_empty(&DatabaseList))
  	{
  		TimestampTz current_time = GetCurrentTimestamp();
  		TimestampTz next_wakeup;
  		long		secs;
  		int			usecs;
  
+ 		avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
+ 
  		next_wakeup = avdb->adl_next_worker;
  		TimestampDifference(current_time, next_wakeup, &secs, &usecs);
  
***************
*** 867,872 **** rebuild_database_list(Oid newdb)
--- 876,882 ----
  	int			score;
  	int			nelems;
  	HTAB	   *dbhash;
+ 	dlist_iter  iter;
  
  	/* use fresh stats */
  	autovac_refresh_stats();
***************
*** 927,962 **** rebuild_database_list(Oid newdb)
  	}
  
  	/* Now insert the databases from the existing list */
! 	if (DatabaseList != NULL)
  	{
! 		Dlelem	   *elem;
! 
! 		elem = DLGetHead(DatabaseList);
! 		while (elem != NULL)
! 		{
! 			avl_dbase  *avdb = DLE_VAL(elem);
! 			avl_dbase  *db;
! 			bool		found;
! 			PgStat_StatDBEntry *entry;
! 
! 			elem = DLGetSucc(elem);
  
! 			/*
! 			 * skip databases with no stat entries -- in particular, this gets
! 			 * rid of dropped databases
! 			 */
! 			entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
! 			if (entry == NULL)
! 				continue;
  
! 			db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
  
! 			if (!found)
! 			{
! 				/* hash_search already filled in the key */
! 				db->adl_score = score++;
! 				/* next_worker is filled in later */
! 			}
  		}
  	}
  
--- 937,964 ----
  	}
  
  	/* Now insert the databases from the existing list */
! 	dlist_foreach(iter, &DatabaseList)
  	{
! 		avl_dbase  *avdb = dlist_container(avl_dbase, adl_node, iter.cur);
! 		avl_dbase  *db;
! 		bool		found;
! 		PgStat_StatDBEntry *entry;
  
! 		/*
! 		 * skip databases with no stat entries -- in particular, this gets
! 		 * rid of dropped databases
! 		 */
! 		entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
! 		if (entry == NULL)
! 			continue;
  
! 		db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
  
! 		if (!found)
! 		{
! 			/* hash_search already filled in the key */
! 			db->adl_score = score++;
! 			/* next_worker is filled in later */
  		}
  	}
  
***************
*** 987,993 **** rebuild_database_list(Oid newdb)
  
  	/* from here on, the allocated memory belongs to the new list */
  	MemoryContextSwitchTo(newcxt);
! 	DatabaseList = DLNewList();
  
  	if (nelems > 0)
  	{
--- 989,995 ----
  
  	/* from here on, the allocated memory belongs to the new list */
  	MemoryContextSwitchTo(newcxt);
! 	dlist_init(&DatabaseList);
  
  	if (nelems > 0)
  	{
***************
*** 1029,1043 **** rebuild_database_list(Oid newdb)
  		for (i = 0; i < nelems; i++)
  		{
  			avl_dbase  *db = &(dbary[i]);
- 			Dlelem	   *elem;
  
  			current_time = TimestampTzPlusMilliseconds(current_time,
  													   millis_increment);
  			db->adl_next_worker = current_time;
  
- 			elem = DLNewElem(db);
  			/* later elements should go closer to the head of the list */
! 			DLAddHead(DatabaseList, elem);
  		}
  	}
  
--- 1031,1043 ----
  		for (i = 0; i < nelems; i++)
  		{
  			avl_dbase  *db = &(dbary[i]);
  
  			current_time = TimestampTzPlusMilliseconds(current_time,
  													   millis_increment);
  			db->adl_next_worker = current_time;
  
  			/* later elements should go closer to the head of the list */
! 			dlist_push_head(&DatabaseList, &db->adl_node);
  		}
  	}
  
***************
*** 1147,1153 **** do_start_worker(void)
  	foreach(cell, dblist)
  	{
  		avw_dbase  *tmp = lfirst(cell);
! 		Dlelem	   *elem;
  
  		/* Check to see if this one is at risk of wraparound */
  		if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
--- 1147,1153 ----
  	foreach(cell, dblist)
  	{
  		avw_dbase  *tmp = lfirst(cell);
! 		dlist_iter iter;
  
  		/* Check to see if this one is at risk of wraparound */
  		if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
***************
*** 1179,1189 **** do_start_worker(void)
  		 * autovacuum time yet.
  		 */
  		skipit = false;
- 		elem = DatabaseList ? DLGetTail(DatabaseList) : NULL;
  
! 		while (elem != NULL)
  		{
! 			avl_dbase  *dbp = DLE_VAL(elem);
  
  			if (dbp->adl_datid == tmp->adw_datid)
  			{
--- 1179,1188 ----
  		 * autovacuum time yet.
  		 */
  		skipit = false;
  
! 		dlist_reverse_foreach(iter, &DatabaseList)
  		{
! 			avl_dbase  *dbp = dlist_container(avl_dbase, adl_node, iter.cur);
  
  			if (dbp->adl_datid == tmp->adw_datid)
  			{
***************
*** 1200,1206 **** do_start_worker(void)
  
  				break;
  			}
- 			elem = DLGetPred(elem);
  		}
  		if (skipit)
  			continue;
--- 1199,1204 ----
***************
*** 1274,1295 **** static void
  launch_worker(TimestampTz now)
  {
  	Oid			dbid;
! 	Dlelem	   *elem;
  
  	dbid = do_start_worker();
  	if (OidIsValid(dbid))
  	{
  		/*
  		 * Walk the database list and update the corresponding entry.  If the
  		 * database is not on the list, we'll recreate the list.
  		 */
! 		elem = (DatabaseList == NULL) ? NULL : DLGetHead(DatabaseList);
! 		while (elem != NULL)
  		{
! 			avl_dbase  *avdb = DLE_VAL(elem);
  
  			if (avdb->adl_datid == dbid)
  			{
  				/*
  				 * add autovacuum_naptime seconds to the current time, and use
  				 * that as the new "next_worker" field for this database.
--- 1272,1296 ----
  launch_worker(TimestampTz now)
  {
  	Oid			dbid;
! 	dlist_iter  iter;
  
  	dbid = do_start_worker();
  	if (OidIsValid(dbid))
  	{
+ 		bool found = false;
+ 
  		/*
  		 * Walk the database list and update the corresponding entry.  If the
  		 * database is not on the list, we'll recreate the list.
  		 */
! 		dlist_foreach(iter, &DatabaseList)
  		{
! 			avl_dbase  *avdb = dlist_container(avl_dbase, adl_node, iter.cur);
  
  			if (avdb->adl_datid == dbid)
  			{
+ 				found = true;
+ 
  				/*
  				 * add autovacuum_naptime seconds to the current time, and use
  				 * that as the new "next_worker" field for this database.
***************
*** 1297,1306 **** launch_worker(TimestampTz now)
  				avdb->adl_next_worker =
  					TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000);
  
! 				DLMoveToFront(elem);
  				break;
  			}
- 			elem = DLGetSucc(elem);
  		}
  
  		/*
--- 1298,1306 ----
  				avdb->adl_next_worker =
  					TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000);
  
! 				dlist_move_head(&DatabaseList, iter.cur);
  				break;
  			}
  		}
  
  		/*
***************
*** 1310,1316 **** launch_worker(TimestampTz now)
  		 * pgstat entry, but this is not a problem because we don't want to
  		 * schedule workers regularly into those in any case.
  		 */
! 		if (elem == NULL)
  			rebuild_database_list(dbid);
  	}
  }
--- 1310,1316 ----
  		 * pgstat entry, but this is not a problem because we don't want to
  		 * schedule workers regularly into those in any case.
  		 */
! 		if (!found)
  			rebuild_database_list(dbid);
  	}
  }
*** a/src/backend/postmaster/postmaster.c
--- b/src/backend/postmaster/postmaster.c
***************
*** 95,101 ****
  #include "access/xlog.h"
  #include "bootstrap/bootstrap.h"
  #include "catalog/pg_control.h"
! #include "lib/dllist.h"
  #include "libpq/auth.h"
  #include "libpq/ip.h"
  #include "libpq/libpq.h"
--- 95,101 ----
  #include "access/xlog.h"
  #include "bootstrap/bootstrap.h"
  #include "catalog/pg_control.h"
! #include "lib/ilist.h"
  #include "libpq/auth.h"
  #include "libpq/ip.h"
  #include "libpq/libpq.h"
***************
*** 146,155 **** typedef struct bkend
  	int			child_slot;		/* PMChildSlot for this backend, if any */
  	bool		is_autovacuum;	/* is it an autovacuum process? */
  	bool		dead_end;		/* is it going to send an error and quit? */
! 	Dlelem		elem;			/* list link in BackendList */
  } Backend;
  
! static Dllist *BackendList;
  
  #ifdef EXEC_BACKEND
  static Backend *ShmemBackendArray;
--- 146,155 ----
  	int			child_slot;		/* PMChildSlot for this backend, if any */
  	bool		is_autovacuum;	/* is it an autovacuum process? */
  	bool		dead_end;		/* is it going to send an error and quit? */
! 	dlist_node	elem;			/* list link in BackendList */
  } Backend;
  
! static dlist_head BackendList = DLIST_STATIC_INIT(BackendList);
  
  #ifdef EXEC_BACKEND
  static Backend *ShmemBackendArray;
***************
*** 1028,1038 **** PostmasterMain(int argc, char *argv[])
  	set_stack_base();
  
  	/*
- 	 * Initialize the list of active backends.
- 	 */
- 	BackendList = DLNewList();
- 
- 	/*
  	 * Initialize pipe (or process handle on Windows) that allows children to
  	 * wake up from sleep on postmaster death.
  	 */
--- 1028,1033 ----
***************
*** 1872,1878 **** processCancelRequest(Port *port, void *pkt)
  	Backend    *bp;
  
  #ifndef EXEC_BACKEND
! 	Dlelem	   *curr;
  #else
  	int			i;
  #endif
--- 1867,1873 ----
  	Backend    *bp;
  
  #ifndef EXEC_BACKEND
! 	dlist_iter  iter;
  #else
  	int			i;
  #endif
***************
*** 1886,1894 **** processCancelRequest(Port *port, void *pkt)
  	 * duplicate array in shared memory.
  	 */
  #ifndef EXEC_BACKEND
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		bp = (Backend *) DLE_VAL(curr);
  #else
  	for (i = MaxLivePostmasterChildren() - 1; i >= 0; i--)
  	{
--- 1881,1889 ----
  	 * duplicate array in shared memory.
  	 */
  #ifndef EXEC_BACKEND
! 	dlist_foreach(iter, &BackendList)
  	{
! 		bp = dlist_container(Backend, elem, iter.cur);
  #else
  	for (i = MaxLivePostmasterChildren() - 1; i >= 0; i--)
  	{
***************
*** 2648,2654 **** static void
  CleanupBackend(int pid,
  			   int exitstatus)	/* child's exit status. */
  {
! 	Dlelem	   *curr;
  
  	LogChildExit(DEBUG2, _("server process"), pid, exitstatus);
  
--- 2643,2649 ----
  CleanupBackend(int pid,
  			   int exitstatus)	/* child's exit status. */
  {
! 	dlist_mutable_iter iter;
  
  	LogChildExit(DEBUG2, _("server process"), pid, exitstatus);
  
***************
*** 2680,2688 **** CleanupBackend(int pid,
  		return;
  	}
  
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		Backend    *bp = (Backend *) DLE_VAL(curr);
  
  		if (bp->pid == pid)
  		{
--- 2675,2683 ----
  		return;
  	}
  
! 	dlist_foreach_modify(iter, &BackendList)
  	{
! 		Backend    *bp = dlist_container(Backend, elem, iter.cur);
  
  		if (bp->pid == pid)
  		{
***************
*** 2701,2707 **** CleanupBackend(int pid,
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			DLRemove(curr);
  			free(bp);
  			break;
  		}
--- 2696,2702 ----
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			dlist_delete(&BackendList, iter.cur);
  			free(bp);
  			break;
  		}
***************
*** 2718,2725 **** CleanupBackend(int pid,
  static void
  HandleChildCrash(int pid, int exitstatus, const char *procname)
  {
! 	Dlelem	   *curr,
! 			   *next;
  	Backend    *bp;
  
  	/*
--- 2713,2719 ----
  static void
  HandleChildCrash(int pid, int exitstatus, const char *procname)
  {
! 	dlist_mutable_iter iter;
  	Backend    *bp;
  
  	/*
***************
*** 2734,2743 **** HandleChildCrash(int pid, int exitstatus, const char *procname)
  	}
  
  	/* Process regular backends */
! 	for (curr = DLGetHead(BackendList); curr; curr = next)
  	{
! 		next = DLGetSucc(curr);
! 		bp = (Backend *) DLE_VAL(curr);
  		if (bp->pid == pid)
  		{
  			/*
--- 2728,2737 ----
  	}
  
  	/* Process regular backends */
! 	dlist_foreach_modify(iter, &BackendList)
  	{
! 		bp = dlist_container(Backend, elem, iter.cur);
! 
  		if (bp->pid == pid)
  		{
  			/*
***************
*** 2750,2756 **** HandleChildCrash(int pid, int exitstatus, const char *procname)
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			DLRemove(curr);
  			free(bp);
  			/* Keep looping so we can signal remaining backends */
  		}
--- 2744,2750 ----
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			dlist_delete(&BackendList, iter.cur);
  			free(bp);
  			/* Keep looping so we can signal remaining backends */
  		}
***************
*** 3113,3119 **** PostmasterStateMachine(void)
  		 * normal state transition leading up to PM_WAIT_DEAD_END, or during
  		 * FatalError processing.
  		 */
! 		if (DLGetHead(BackendList) == NULL &&
  			PgArchPID == 0 && PgStatPID == 0)
  		{
  			/* These other guys should be dead already */
--- 3107,3113 ----
  		 * normal state transition leading up to PM_WAIT_DEAD_END, or during
  		 * FatalError processing.
  		 */
! 		if (dlist_is_empty(&BackendList) &&
  			PgArchPID == 0 && PgStatPID == 0)
  		{
  			/* These other guys should be dead already */
***************
*** 3239,3250 **** signal_child(pid_t pid, int signal)
  static bool
  SignalSomeChildren(int signal, int target)
  {
! 	Dlelem	   *curr;
  	bool		signaled = false;
  
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		Backend    *bp = (Backend *) DLE_VAL(curr);
  
  		if (bp->dead_end)
  			continue;
--- 3233,3244 ----
  static bool
  SignalSomeChildren(int signal, int target)
  {
! 	dlist_iter  iter;
  	bool		signaled = false;
  
! 	dlist_foreach(iter, &BackendList)
  	{
! 		Backend    *bp = dlist_container(Backend, elem, iter.cur);
  
  		if (bp->dead_end)
  			continue;
***************
*** 3382,3389 **** BackendStartup(Port *port)
  	 */
  	bn->pid = pid;
  	bn->is_autovacuum = false;
! 	DLInitElem(&bn->elem, bn);
! 	DLAddHead(BackendList, &bn->elem);
  #ifdef EXEC_BACKEND
  	if (!bn->dead_end)
  		ShmemBackendArrayAdd(bn);
--- 3376,3383 ----
  	 */
  	bn->pid = pid;
  	bn->is_autovacuum = false;
! 	dlist_push_head(&BackendList, &bn->elem);
! 
  #ifdef EXEC_BACKEND
  	if (!bn->dead_end)
  		ShmemBackendArrayAdd(bn);
***************
*** 4491,4502 **** PostmasterRandom(void)
  static int
  CountChildren(int target)
  {
! 	Dlelem	   *curr;
  	int			cnt = 0;
  
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		Backend    *bp = (Backend *) DLE_VAL(curr);
  
  		if (bp->dead_end)
  			continue;
--- 4485,4496 ----
  static int
  CountChildren(int target)
  {
! 	dlist_iter  iter;
  	int			cnt = 0;
  
! 	dlist_foreach(iter, &BackendList)
  	{
! 		Backend    *bp = dlist_container(Backend, elem, iter.cur);
  
  		if (bp->dead_end)
  			continue;
***************
*** 4675,4682 **** StartAutovacuumWorker(void)
  			if (bn->pid > 0)
  			{
  				bn->is_autovacuum = true;
! 				DLInitElem(&bn->elem, bn);
! 				DLAddHead(BackendList, &bn->elem);
  #ifdef EXEC_BACKEND
  				ShmemBackendArrayAdd(bn);
  #endif
--- 4669,4675 ----
  			if (bn->pid > 0)
  			{
  				bn->is_autovacuum = true;
! 				dlist_push_head(&BackendList, &bn->elem);
  #ifdef EXEC_BACKEND
  				ShmemBackendArrayAdd(bn);
  #endif
*** a/src/backend/utils/cache/catcache.c
--- b/src/backend/utils/cache/catcache.c
***************
*** 291,297 **** CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple)
  static void
  CatCachePrintStats(int code, Datum arg)
  {
! 	CatCache   *cache;
  	long		cc_searches = 0;
  	long		cc_hits = 0;
  	long		cc_neg_hits = 0;
--- 291,297 ----
  static void
  CatCachePrintStats(int code, Datum arg)
  {
! 	slist_iter  iter;
  	long		cc_searches = 0;
  	long		cc_hits = 0;
  	long		cc_neg_hits = 0;
***************
*** 300,307 **** CatCachePrintStats(int code, Datum arg)
  	long		cc_lsearches = 0;
  	long		cc_lhits = 0;
  
! 	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
  	{
  		if (cache->cc_ntup == 0 && cache->cc_searches == 0)
  			continue;			/* don't print unused caches */
  		elog(DEBUG2, "catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld lsrch, %ld lhits",
--- 300,309 ----
  	long		cc_lsearches = 0;
  	long		cc_lhits = 0;
  
! 	slist_foreach(iter, &CacheHdr->ch_caches)
  	{
+ 		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
+ 
  		if (cache->cc_ntup == 0 && cache->cc_searches == 0)
  			continue;			/* don't print unused caches */
  		elog(DEBUG2, "catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld lsrch, %ld lhits",
***************
*** 368,375 **** CatCacheRemoveCTup(CatCache *cache, CatCTup *ct)
  		return;					/* nothing left to do */
  	}
  
! 	/* delink from linked list */
! 	DLRemove(&ct->cache_elem);
  
  	/* free associated tuple data */
  	if (ct->tuple.t_data != NULL)
--- 370,376 ----
  		return;					/* nothing left to do */
  	}
  
! 	dlist_delete(ct->cache_bucket, &ct->cache_elem);
  
  	/* free associated tuple data */
  	if (ct->tuple.t_data != NULL)
***************
*** 412,418 **** CatCacheRemoveCList(CatCache *cache, CatCList *cl)
  	}
  
  	/* delink from linked list */
! 	DLRemove(&cl->cache_elem);
  
  	/* free associated tuple data */
  	if (cl->tuple.t_data != NULL)
--- 413,419 ----
  	}
  
  	/* delink from linked list */
! 	dlist_delete(&cache->cc_lists, &cl->cache_elem);
  
  	/* free associated tuple data */
  	if (cl->tuple.t_data != NULL)
***************
*** 442,459 **** CatCacheRemoveCList(CatCache *cache, CatCList *cl)
  void
  CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  {
! 	CatCache   *ccp;
  
  	CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
  
  	/*
  	 * inspect caches to find the proper cache
  	 */
! 	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
  	{
  		Index		hashIndex;
! 		Dlelem	   *elt,
! 				   *nextelt;
  
  		if (cacheId != ccp->id)
  			continue;
--- 443,460 ----
  void
  CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  {
! 	slist_iter cache_iter;
  
  	CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
  
  	/*
  	 * inspect caches to find the proper cache
  	 */
! 	slist_foreach(cache_iter, &CacheHdr->ch_caches)
  	{
  		Index		hashIndex;
! 		dlist_mutable_iter iter;
! 		CatCache   *ccp = slist_container(CatCache, cc_next, cache_iter.cur);
  
  		if (cacheId != ccp->id)
  			continue;
***************
*** 468,478 **** CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  		 * Invalidate *all* CatCLists in this cache; it's too hard to tell
  		 * which searches might still be correct, so just zap 'em all.
  		 */
! 		for (elt = DLGetHead(&ccp->cc_lists); elt; elt = nextelt)
  		{
! 			CatCList   *cl = (CatCList *) DLE_VAL(elt);
! 
! 			nextelt = DLGetSucc(elt);
  
  			if (cl->refcount > 0)
  				cl->dead = true;
--- 469,477 ----
  		 * Invalidate *all* CatCLists in this cache; it's too hard to tell
  		 * which searches might still be correct, so just zap 'em all.
  		 */
! 		dlist_foreach_modify(iter, &ccp->cc_lists)
  		{
! 			CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  			if (cl->refcount > 0)
  				cl->dead = true;
***************
*** 484,495 **** CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  		 * inspect the proper hash bucket for tuple matches
  		 */
  		hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets);
! 
! 		for (elt = DLGetHead(&ccp->cc_bucket[hashIndex]); elt; elt = nextelt)
  		{
! 			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
! 
! 			nextelt = DLGetSucc(elt);
  
  			if (hashValue == ct->hash_value)
  			{
--- 483,491 ----
  		 * inspect the proper hash bucket for tuple matches
  		 */
  		hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets);
! 		dlist_foreach_modify(iter, &ccp->cc_bucket[hashIndex])
  		{
! 			CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  			if (hashValue == ct->hash_value)
  			{
***************
*** 557,573 **** AtEOXact_CatCache(bool isCommit)
  #ifdef USE_ASSERT_CHECKING
  	if (assert_enabled)
  	{
! 		CatCache   *ccp;
  
! 		for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
  		{
! 			Dlelem	   *elt;
  			int			i;
  
  			/* Check CatCLists */
! 			for (elt = DLGetHead(&ccp->cc_lists); elt; elt = DLGetSucc(elt))
  			{
! 				CatCList   *cl = (CatCList *) DLE_VAL(elt);
  
  				Assert(cl->cl_magic == CL_MAGIC);
  				Assert(cl->refcount == 0);
--- 553,570 ----
  #ifdef USE_ASSERT_CHECKING
  	if (assert_enabled)
  	{
! 		slist_iter  cache_iter;
  
! 		slist_foreach(cache_iter, &(CacheHdr->ch_caches))
  		{
! 			CatCache   *ccp = slist_container(CatCache, cc_next, cache_iter.cur);
! 			dlist_iter  iter;
  			int			i;
  
  			/* Check CatCLists */
! 			dlist_foreach(iter, &ccp->cc_lists)
  			{
! 				CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  				Assert(cl->cl_magic == CL_MAGIC);
  				Assert(cl->refcount == 0);
***************
*** 577,587 **** AtEOXact_CatCache(bool isCommit)
  			/* Check individual tuples */
  			for (i = 0; i < ccp->cc_nbuckets; i++)
  			{
! 				for (elt = DLGetHead(&ccp->cc_bucket[i]);
! 					 elt;
! 					 elt = DLGetSucc(elt))
  				{
! 					CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
  
  					Assert(ct->ct_magic == CT_MAGIC);
  					Assert(ct->refcount == 0);
--- 574,584 ----
  			/* Check individual tuples */
  			for (i = 0; i < ccp->cc_nbuckets; i++)
  			{
! 				dlist_head *bucket = &ccp->cc_bucket[i];
! 
! 				dlist_foreach(iter, bucket)
  				{
! 					CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  					Assert(ct->ct_magic == CT_MAGIC);
  					Assert(ct->refcount == 0);
***************
*** 604,619 **** AtEOXact_CatCache(bool isCommit)
  static void
  ResetCatalogCache(CatCache *cache)
  {
! 	Dlelem	   *elt,
! 			   *nextelt;
  	int			i;
  
  	/* Remove each list in this cache, or at least mark it dead */
! 	for (elt = DLGetHead(&cache->cc_lists); elt; elt = nextelt)
  	{
! 		CatCList   *cl = (CatCList *) DLE_VAL(elt);
! 
! 		nextelt = DLGetSucc(elt);
  
  		if (cl->refcount > 0)
  			cl->dead = true;
--- 601,613 ----
  static void
  ResetCatalogCache(CatCache *cache)
  {
! 	dlist_mutable_iter iter;
  	int			i;
  
  	/* Remove each list in this cache, or at least mark it dead */
! 	dlist_foreach_modify(iter, &cache->cc_lists)
  	{
! 		CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  		if (cl->refcount > 0)
  			cl->dead = true;
***************
*** 624,634 **** ResetCatalogCache(CatCache *cache)
  	/* Remove each tuple in this cache, or at least mark it dead */
  	for (i = 0; i < cache->cc_nbuckets; i++)
  	{
! 		for (elt = DLGetHead(&cache->cc_bucket[i]); elt; elt = nextelt)
! 		{
! 			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
  
! 			nextelt = DLGetSucc(elt);
  
  			if (ct->refcount > 0 ||
  				(ct->c_list && ct->c_list->refcount > 0))
--- 618,628 ----
  	/* Remove each tuple in this cache, or at least mark it dead */
  	for (i = 0; i < cache->cc_nbuckets; i++)
  	{
! 		dlist_head *bucket = &cache->cc_bucket[i];
  
! 		dlist_foreach_modify(iter, bucket)
! 		{
! 			CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  			if (ct->refcount > 0 ||
  				(ct->c_list && ct->c_list->refcount > 0))
***************
*** 654,665 **** ResetCatalogCache(CatCache *cache)
  void
  ResetCatalogCaches(void)
  {
! 	CatCache   *cache;
  
  	CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
  
! 	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
  		ResetCatalogCache(cache);
  
  	CACHE1_elog(DEBUG2, "end of ResetCatalogCaches call");
  }
--- 648,663 ----
  void
  ResetCatalogCaches(void)
  {
! 	slist_iter    iter;
  
  	CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
  
! 	slist_foreach(iter, &CacheHdr->ch_caches)
! 	{
! 		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
! 
  		ResetCatalogCache(cache);
+ 	}
  
  	CACHE1_elog(DEBUG2, "end of ResetCatalogCaches call");
  }
***************
*** 680,691 **** ResetCatalogCaches(void)
  void
  CatalogCacheFlushCatalog(Oid catId)
  {
! 	CatCache   *cache;
  
  	CACHE2_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
  
! 	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
  	{
  		/* Does this cache store tuples of the target catalog? */
  		if (cache->cc_reloid == catId)
  		{
--- 678,691 ----
  void
  CatalogCacheFlushCatalog(Oid catId)
  {
! 	slist_iter  iter;
  
  	CACHE2_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
  
! 	slist_foreach(iter, &(CacheHdr->ch_caches))
  	{
+ 		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
+ 
  		/* Does this cache store tuples of the target catalog? */
  		if (cache->cc_reloid == catId)
  		{
***************
*** 760,766 **** InitCatCache(int id,
  	if (CacheHdr == NULL)
  	{
  		CacheHdr = (CatCacheHeader *) palloc(sizeof(CatCacheHeader));
! 		CacheHdr->ch_caches = NULL;
  		CacheHdr->ch_ntup = 0;
  #ifdef CATCACHE_STATS
  		/* set up to dump stats at backend exit */
--- 760,766 ----
  	if (CacheHdr == NULL)
  	{
  		CacheHdr = (CatCacheHeader *) palloc(sizeof(CatCacheHeader));
! 		slist_init(&CacheHdr->ch_caches);
  		CacheHdr->ch_ntup = 0;
  #ifdef CATCACHE_STATS
  		/* set up to dump stats at backend exit */
***************
*** 770,779 **** InitCatCache(int id,
  
  	/*
  	 * allocate a new cache structure
- 	 *
- 	 * Note: we assume zeroing initializes the Dllist headers correctly
  	 */
! 	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(Dllist));
  
  	/*
  	 * initialize the cache's relation information for the relation
--- 770,777 ----
  
  	/*
  	 * allocate a new cache structure
  	 */
! 	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(dlist_node));
  
  	/*
  	 * initialize the cache's relation information for the relation
***************
*** 792,797 **** InitCatCache(int id,
--- 790,800 ----
  	for (i = 0; i < nkeys; ++i)
  		cp->cc_key[i] = key[i];
  
+ 	dlist_init(&cp->cc_lists);
+ 
+ 	for (i = 0; i < nbuckets; i++)
+ 		dlist_init(&cp->cc_bucket[i]);
+ 
  	/*
  	 * new cache is initialized as far as we can go for now. print some
  	 * debugging information, if appropriate.
***************
*** 801,808 **** InitCatCache(int id,
  	/*
  	 * add completed cache to top of group header's list
  	 */
! 	cp->cc_next = CacheHdr->ch_caches;
! 	CacheHdr->ch_caches = cp;
  
  	/*
  	 * back to the old context before we return...
--- 804,810 ----
  	/*
  	 * add completed cache to top of group header's list
  	 */
! 	slist_push_head(&CacheHdr->ch_caches, &cp->cc_next);
  
  	/*
  	 * back to the old context before we return...
***************
*** 1060,1066 **** SearchCatCache(CatCache *cache,
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		hashValue;
  	Index		hashIndex;
! 	Dlelem	   *elt;
  	CatCTup    *ct;
  	Relation	relation;
  	SysScanDesc scandesc;
--- 1062,1069 ----
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		hashValue;
  	Index		hashIndex;
! 	dlist_mutable_iter  iter;
! 	dlist_head *bucket;
  	CatCTup    *ct;
  	Relation	relation;
  	SysScanDesc scandesc;
***************
*** 1094,1106 **** SearchCatCache(CatCache *cache,
  	/*
  	 * scan the hash bucket until we find a match or exhaust our tuples
  	 */
! 	for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
! 		 elt;
! 		 elt = DLGetSucc(elt))
  	{
  		bool		res;
  
! 		ct = (CatCTup *) DLE_VAL(elt);
  
  		if (ct->dead)
  			continue;			/* ignore dead entries */
--- 1097,1109 ----
  	/*
  	 * scan the hash bucket until we find a match or exhaust our tuples
  	 */
! 	bucket = &cache->cc_bucket[hashIndex];
! 
! 	dlist_foreach_modify(iter, bucket)
  	{
  		bool		res;
  
! 		ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  		if (ct->dead)
  			continue;			/* ignore dead entries */
***************
*** 1125,1131 **** SearchCatCache(CatCache *cache,
  		 * most frequently accessed elements in any hashbucket will tend to be
  		 * near the front of the hashbucket's list.)
  		 */
! 		DLMoveToFront(&ct->cache_elem);
  
  		/*
  		 * If it's a positive entry, bump its refcount and return it. If it's
--- 1128,1134 ----
  		 * most frequently accessed elements in any hashbucket will tend to be
  		 * near the front of the hashbucket's list.)
  		 */
! 		dlist_move_head(bucket, &ct->cache_elem);
  
  		/*
  		 * If it's a positive entry, bump its refcount and return it. If it's
***************
*** 1340,1346 **** SearchCatCacheList(CatCache *cache,
  {
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		lHashValue;
! 	Dlelem	   *elt;
  	CatCList   *cl;
  	CatCTup    *ct;
  	List	   *volatile ctlist;
--- 1343,1349 ----
  {
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		lHashValue;
! 	dlist_iter  iter;
  	CatCList   *cl;
  	CatCTup    *ct;
  	List	   *volatile ctlist;
***************
*** 1382,1394 **** SearchCatCacheList(CatCache *cache,
  	/*
  	 * scan the items until we find a match or exhaust our list
  	 */
! 	for (elt = DLGetHead(&cache->cc_lists);
! 		 elt;
! 		 elt = DLGetSucc(elt))
  	{
  		bool		res;
  
! 		cl = (CatCList *) DLE_VAL(elt);
  
  		if (cl->dead)
  			continue;			/* ignore dead entries */
--- 1385,1395 ----
  	/*
  	 * scan the items until we find a match or exhaust our list
  	 */
! 	dlist_foreach(iter, &cache->cc_lists)
  	{
  		bool		res;
  
! 		cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  		if (cl->dead)
  			continue;			/* ignore dead entries */
***************
*** 1416,1422 **** SearchCatCacheList(CatCache *cache,
  		 * since there's no point in that unless they are searched for
  		 * individually.)
  		 */
! 		DLMoveToFront(&cl->cache_elem);
  
  		/* Bump the list's refcount and return it */
  		ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
--- 1417,1423 ----
  		 * since there's no point in that unless they are searched for
  		 * individually.)
  		 */
! 		dlist_move_head(&cache->cc_lists, &cl->cache_elem);
  
  		/* Bump the list's refcount and return it */
  		ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
***************
*** 1468,1473 **** SearchCatCacheList(CatCache *cache,
--- 1469,1476 ----
  		{
  			uint32		hashValue;
  			Index		hashIndex;
+ 			bool		found = false;
+ 			dlist_head *bucket;
  
  			/*
  			 * See if there's an entry for this tuple already.
***************
*** 1476,1486 **** SearchCatCacheList(CatCache *cache,
  			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);
  			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
  
! 			for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
! 				 elt;
! 				 elt = DLGetSucc(elt))
  			{
! 				ct = (CatCTup *) DLE_VAL(elt);
  
  				if (ct->dead || ct->negative)
  					continue;	/* ignore dead and negative entries */
--- 1479,1488 ----
  			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);
  			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
  
! 			bucket = &cache->cc_bucket[hashIndex];
! 			dlist_foreach(iter, bucket)
  			{
! 				ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  				if (ct->dead || ct->negative)
  					continue;	/* ignore dead and negative entries */
***************
*** 1498,1507 **** SearchCatCacheList(CatCache *cache,
  				if (ct->c_list)
  					continue;
  
  				break;			/* A-OK */
  			}
  
! 			if (elt == NULL)
  			{
  				/* We didn't find a usable entry, so make a new one */
  				ct = CatalogCacheCreateEntry(cache, ntp,
--- 1500,1510 ----
  				if (ct->c_list)
  					continue;
  
+ 				found = true;
  				break;			/* A-OK */
  			}
  
! 			if (!found)
  			{
  				/* We didn't find a usable entry, so make a new one */
  				ct = CatalogCacheCreateEntry(cache, ntp,
***************
*** 1564,1570 **** SearchCatCacheList(CatCache *cache,
  
  	cl->cl_magic = CL_MAGIC;
  	cl->my_cache = cache;
- 	DLInitElem(&cl->cache_elem, cl);
  	cl->refcount = 0;			/* for the moment */
  	cl->dead = false;
  	cl->ordered = ordered;
--- 1567,1572 ----
***************
*** 1587,1593 **** SearchCatCacheList(CatCache *cache,
  	}
  	Assert(i == nmembers);
  
! 	DLAddHead(&cache->cc_lists, &cl->cache_elem);
  
  	/* Finally, bump the list's refcount and return it */
  	cl->refcount++;
--- 1589,1595 ----
  	}
  	Assert(i == nmembers);
  
! 	dlist_push_head(&cache->cc_lists, &cl->cache_elem);
  
  	/* Finally, bump the list's refcount and return it */
  	cl->refcount++;
***************
*** 1664,1677 **** CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp,
  	 */
  	ct->ct_magic = CT_MAGIC;
  	ct->my_cache = cache;
! 	DLInitElem(&ct->cache_elem, (void *) ct);
  	ct->c_list = NULL;
  	ct->refcount = 0;			/* for the moment */
  	ct->dead = false;
  	ct->negative = negative;
  	ct->hash_value = hashValue;
  
! 	DLAddHead(&cache->cc_bucket[hashIndex], &ct->cache_elem);
  
  	cache->cc_ntup++;
  	CacheHdr->ch_ntup++;
--- 1666,1680 ----
  	 */
  	ct->ct_magic = CT_MAGIC;
  	ct->my_cache = cache;
! 	ct->cache_bucket = &cache->cc_bucket[hashIndex];
! 
  	ct->c_list = NULL;
  	ct->refcount = 0;			/* for the moment */
  	ct->dead = false;
  	ct->negative = negative;
  	ct->hash_value = hashValue;
  
! 	dlist_push_head(ct->cache_bucket, &ct->cache_elem);
  
  	cache->cc_ntup++;
  	CacheHdr->ch_ntup++;
***************
*** 1785,1791 **** PrepareToInvalidateCacheTuple(Relation relation,
  							  HeapTuple newtuple,
  							  void (*function) (int, uint32, Oid))
  {
! 	CatCache   *ccp;
  	Oid			reloid;
  
  	CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
--- 1788,1794 ----
  							  HeapTuple newtuple,
  							  void (*function) (int, uint32, Oid))
  {
! 	slist_iter  iter;
  	Oid			reloid;
  
  	CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
***************
*** 1808,1817 **** PrepareToInvalidateCacheTuple(Relation relation,
  	 * ----------------
  	 */
  
! 	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
  	{
  		uint32		hashvalue;
  		Oid			dbid;
  
  		if (ccp->cc_reloid != reloid)
  			continue;
--- 1811,1821 ----
  	 * ----------------
  	 */
  
! 	slist_foreach(iter, &(CacheHdr->ch_caches))
  	{
  		uint32		hashvalue;
  		Oid			dbid;
+ 		CatCache   *ccp = slist_container(CatCache, cc_next, iter.cur);
  
  		if (ccp->cc_reloid != reloid)
  			continue;
*** a/src/include/lib/dllist.h
--- /dev/null
***************
*** 1,85 ****
- /*-------------------------------------------------------------------------
-  *
-  * dllist.h
-  *		simple doubly linked list primitives
-  *		the elements of the list are void* so the lists can contain anything
-  *		Dlelem can only be in one list at a time
-  *
-  *
-  *	 Here's a small example of how to use Dllists:
-  *
-  *	 Dllist *lst;
-  *	 Dlelem *elt;
-  *	 void	*in_stuff;	  -- stuff to stick in the list
-  *	 void	*out_stuff
-  *
-  *	 lst = DLNewList();				   -- make a new dllist
-  *	 DLAddHead(lst, DLNewElem(in_stuff)); -- add a new element to the list
-  *											 with in_stuff as the value
-  *	  ...
-  *	 elt = DLGetHead(lst);			   -- retrieve the head element
-  *	 out_stuff = (void*)DLE_VAL(elt);  -- get the stuff out
-  *	 DLRemove(elt);					   -- removes the element from its list
-  *	 DLFreeElem(elt);				   -- free the element since we don't
-  *										  use it anymore
-  *
-  *
-  * It is also possible to use Dllist objects that are embedded in larger
-  * structures instead of being separately malloc'd.  To do this, use
-  * DLInitElem() to initialize a Dllist field within a larger object.
-  * Don't forget to DLRemove() each field from its list (if any) before
-  * freeing the larger object!
-  *
-  *
-  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
-  * Portions Copyright (c) 1994, Regents of the University of California
-  *
-  * src/include/lib/dllist.h
-  *
-  *-------------------------------------------------------------------------
-  */
- 
- #ifndef DLLIST_H
- #define DLLIST_H
- 
- struct Dllist;
- struct Dlelem;
- 
- typedef struct Dlelem
- {
- 	struct Dlelem *dle_next;	/* next element */
- 	struct Dlelem *dle_prev;	/* previous element */
- 	void	   *dle_val;		/* value of the element */
- 	struct Dllist *dle_list;	/* what list this element is in */
- } Dlelem;
- 
- typedef struct Dllist
- {
- 	Dlelem	   *dll_head;
- 	Dlelem	   *dll_tail;
- } Dllist;
- 
- extern Dllist *DLNewList(void); /* allocate and initialize a list header */
- extern void DLInitList(Dllist *list);	/* init a header alloced by caller */
- extern void DLFreeList(Dllist *list);	/* free up a list and all the nodes in
- 										 * it */
- extern Dlelem *DLNewElem(void *val);
- extern void DLInitElem(Dlelem *e, void *val);
- extern void DLFreeElem(Dlelem *e);
- extern void DLRemove(Dlelem *e);	/* removes node from list */
- extern void DLAddHead(Dllist *list, Dlelem *node);
- extern void DLAddTail(Dllist *list, Dlelem *node);
- extern Dlelem *DLRemHead(Dllist *list); /* remove and return the head */
- extern Dlelem *DLRemTail(Dllist *list);
- extern void DLMoveToFront(Dlelem *e);	/* move node to front of its list */
- 
- /* These are macros for speed */
- #define DLGetHead(list)  ((list)->dll_head)
- #define DLGetTail(list)  ((list)->dll_tail)
- #define DLGetSucc(elem)  ((elem)->dle_next)
- #define DLGetPred(elem)  ((elem)->dle_prev)
- #define DLGetListHdr(elem)	((elem)->dle_list)
- 
- #define DLE_VAL(elem)	((elem)->dle_val)
- 
- #endif   /* DLLIST_H */
--- 0 ----
*** /dev/null
--- b/src/include/lib/ilist.h
***************
*** 0 ****
--- 1,749 ----
+ /*-------------------------------------------------------------------------
+  *
+  * ilist.h
+  *		integrated/inline doubly- and singly-linked lists
+  *
+  * This implementation is as efficient as possible: the lists don't have
+  * any memory management overhead, because the list pointers are embedded
+  * within some larger structure.
+ 
+  * Also, the doubly-linked lists are always circularly linked, even when empty;
+  * this enables many manipulations to be done without branches, which is
+  * beneficial performance-wise.
+  *
+  * NOTES
+  *		This is intended to be used in situations where memory for a struct and
+  *		its contents already needs to be allocated and the overhead of
+  *		allocating extra list cells for every list element is noticeable.  Thus,
+  *		none of the functions here allocate any memory; they just manipulate
+  *		externally managed memory.	The API for singly/doubly linked lists is
+  *		identical as far as capabilities of both allow.
+  *
+  * EXAMPLES
+  *
+  * An oversimplified example demonstrating how this can be used.  Let's assume
+  * we want to store information about the tables contained in a database.
+  *
+  * #include "lib/ilist.h"
+  *
+  * // Define struct for the databases including a list header that will be used
+  * // to access the nodes in the list later on.
+  * typedef struct my_database
+  * {
+  *		char	   *datname;
+  *		dlist_head	tables;
+  *		// ...
+  * } my_database;
+  *
+  * // Define struct for the tables. Note the list_node element which stores
+  * // information about prev/next list nodes.
+  * typedef struct my_table
+  * {
+  *		char	   *tablename;
+  *		dlist_node	list_node;
+  *		perm_t		permissions;
+  *		// ...
+  * } value_in_a_list;
+  *
+  * // create a database
+  * my_database *db = create_database();
+  *
+  * // and add a few tables to its table list
+  * dlist_push_head(&db->tables, &create_table(db, "a")->list_node);
+  * ...
+  * dlist_push_head(&db->tables, &create_table(db, "b")->list_node);
+  *
+  *
+  * To iterate over the table list, we allocate an iterator element and use
+  * a specialized looping construct.  Inside a dlist_foreach, the iterator's
+  * 'cur' field can be used to access the current element.  iter.cur points to a
+  * 'dlist_node', but most of the time what we want is the actual table
+  * information; dlist_container() gives us that, like so:
+  *
+  * dlist_iter	iter;
+  * dlist_foreach(iter, &db->tables)
+  * {
+  *		my_table   *tbl = dlist_container(my_table, list_node, iter.cur);
+  *		printf("we have a table: %s in database %s\n",
+  *			   val->tablename, db->datname);
+  * }
+  *
+  *
+  * While a simple iteration is useful, we sometimes also want to manipulate
+  * the list while iterating.  There is a different iterator element and looping
+  * construct for that.	Suppose we want to delete tables that meet a certain
+  * criterion:
+  *
+  * dlist_mutable_iter miter;
+  * dlist_foreach_modify(miter, &db->tables)
+  * {
+  *		my_table   *tbl = dlist_container(my_table, list_node, miter.cur);
+  *
+  *		if (!tbl->to_be_deleted)
+  *			continue;		// don't touch this one
+  *
+  *		// unlink the current table from the linked list
+  *		dlist_delete(&db->tables, miter.cur);
+  *		// as these lists never manage memory, we can freely access the table
+  *		// after it's been deleted
+  *		drop_table(db, tbl);
+  * }
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  * IDENTIFICATION
+  *		src/include/lib/ilist.h
+  *-------------------------------------------------------------------------
+  */
+ #ifndef ILIST_H
+ #define ILIST_H
+ 
+ /*
+  * Enable for extra debugging. This is rather expensive, so it's not enabled by
+  * default even when USE_ASSERT_CHECKING.
+  */
+ /* #define ILIST_DEBUG */
+ 
+ /*
+  * Node of a doubly linked list.
+  *
+  * Embed this in structs that need to be part of a doubly linked list.
+  */
+ typedef struct dlist_node dlist_node;
+ struct dlist_node
+ {
+ 	dlist_node *prev;
+ 	dlist_node *next;
+ };
+ 
+ /*
+  * Head of a doubly linked list.
+  *
+  * Lists are internally *always* circularly linked, even when empty. Circular
+  * lists have the advantage of not needing any branches in the most common list
+  * manipulations.
+  */
+ typedef struct dlist_head
+ {
+ 	/*
+ 	 * head->next either points to the first element of the list or to &head
+ 	 * if empty.
+ 	 *
+ 	 * head->prev either points to the last element of the list or to &head if
+ 	 * empty.
+ 	 */
+ 	dlist_node	head;
+ } dlist_head;
+ 
+ 
+ /*
+  * Doubly linked list iterator.
+  *
+  * Used as state in dlist_foreach() and dlist_reverse_foreach(). To get the
+  * current element of the iteration use the 'cur' member.
+  *
+  * Iterations using this are *not* allowed to change the list while iterating!
+  *
+  * NB: We use an extra type for this to make it possible to avoid multiple
+  * evaluations of arguments in the dlist_foreach() macro.
+  */
+ typedef struct dlist_iter
+ {
+ 	dlist_node *end;			/* last node we iterate to */
+ 	dlist_node *cur;			/* current element */
+ } dlist_iter;
+ 
+ /*
+  * Doubly linked list iterator allowing some modifications while iterating
+  *
+  * Used as state in dlist_foreach_modify(). To get the current element of the
+  * iteration use the 'cur' member.
+  *
+  * Iterations using this are only allowed to change the list *at the current
+  * point of iteration*. It is fine to delete the current node, but it is *not*
+  * fine to modify other nodes.
+  *
+  * NB: We need a separate type for mutable iterations to avoid having to pass
+  * in two iterators or some other state variable as we need to store the
+  * '->next' node of the current node so it can be deleted or modified by the
+  * user.
+  */
+ typedef struct dlist_mutable_iter
+ {
+ 	dlist_node *end;			/* last node we iterate to */
+ 	dlist_node *cur;			/* current element */
+ 	dlist_node *next;			/* next node we iterate to, so we can delete
+ 								 * cur */
+ } dlist_mutable_iter;
+ 
+ /*
+  * Node of a singly linked list.
+  *
+  * Embed this in structs that need to be part of a singly linked list.
+  */
+ typedef struct slist_node slist_node;
+ struct slist_node
+ {
+ 	slist_node *next;
+ };
+ 
+ /*
+  * Head of a singly linked list.
+  *
+  * Singly linked lists are not circularly linked, in contrast to doubly linked
+  * lists. As no pointer to the last list element and to the previous node needs
+  * to be maintained this doesn't incur any additional branches in the usual
+  * manipulations.
+  */
+ typedef struct slist_head
+ {
+ 	slist_node	head;
+ } slist_head;
+ 
+ /*
+  * Singly linked list iterator
+  *
+  * Used in slist_foreach(). To get the current element of the iteration use the
+  * 'cur' member.
+  *
+  * Do *not* manipulate the list while iterating!
+  *
+  * NB: this wouldn't really need to be an extra struct, we could use a
+  * slist_node * directly. We still use a separate type for consistency.
+  */
+ typedef struct slist_iter
+ {
+ 	slist_node *cur;
+ } slist_iter;
+ 
+ /*
+  * Singly linked list iterator allowing some modifications while iterating
+  *
+  * Used in slist_foreach_modify.
+  *
+  * Iterations using this are allowed to remove the current node and to add more
+  * nodes to the beginning of the list.
+  */
+ typedef struct slist_mutable_iter
+ {
+ 	slist_node *cur;
+ 	slist_node *next;
+ } slist_mutable_iter;
+ 
+ 
+ /* Prototypes for functions too big to be inline */
+ 
+ /* Attention: O(n) */
+ extern void slist_delete(slist_head *head, slist_node *node);
+ 
+ #ifdef ILIST_DEBUG
+ extern void dlist_check(dlist_head *head);
+ extern void slist_check(slist_head *head);
+ #else
+ /*
+  * These seemingly useless casts to void are here to keep the compiler quiet
+  * about the argument being unused in many functions in a non-debug compile,
+  * in which functions the only point of passing the list head pointer is to be
+  * able to run these checks.
+  */
+ #define dlist_check(head)	(void) (head)
+ #define slist_check(head)	(void) (head)
+ #endif   /* ILIST_DEBUG */
+ 
+ /* Static initializers */
+ #define DLIST_STATIC_INIT(name) {{&name.head, &name.head}}
+ #define SLIST_STATIC_INIT(name) {{NULL}}
+ 
+ 
+ /*
+  * We want the functions below to be inline; but if the compiler doesn't
+  * support that, fall back on providing them as regular functions.	See
+  * STATIC_IF_INLINE in c.h.
+  */
+ #ifndef PG_USE_INLINE
+ extern void dlist_init(dlist_head *head);
+ extern bool dlist_is_empty(dlist_head *head);
+ extern void dlist_push_head(dlist_head *head, dlist_node *node);
+ extern void dlist_push_tail(dlist_head *head, dlist_node *node);
+ extern void dlist_insert_after(dlist_head *head,
+ 				   dlist_node *after, dlist_node *node);
+ extern void dlist_insert_before(dlist_head *head,
+ 					dlist_node *before, dlist_node *node);
+ extern void dlist_delete(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_pop_head_node(dlist_head *head);
+ extern void dlist_move_head(dlist_head *head, dlist_node *node);
+ extern bool dlist_has_next(dlist_head *head, dlist_node *node);
+ extern bool dlist_has_prev(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_next_node(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_prev_node(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_head_node(dlist_head *head);
+ extern dlist_node *dlist_tail_node(dlist_head *head);
+ 
+ /* dlist macro support functions */
+ extern void *dlist_tail_element_off(dlist_head *head, size_t off);
+ extern void *dlist_head_element_off(dlist_head *head, size_t off);
+ #endif   /* !PG_USE_INLINE */
+ 
+ #if defined(PG_USE_INLINE) || defined(ILIST_INCLUDE_DEFINITIONS)
+ /*
+  * Initialize the head of a list. Previous state will be thrown away without
+  * any cleanup.
+  */
+ STATIC_IF_INLINE void
+ dlist_init(dlist_head *head)
+ {
+ 	head->head.next = head->head.prev = &head->head;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Insert a node at the beginning of the list.
+  */
+ STATIC_IF_INLINE void
+ dlist_push_head(dlist_head *head, dlist_node *node)
+ {
+ 	node->next = head->head.next;
+ 	node->prev = &head->head;
+ 	node->next->prev = node;
+ 	head->head.next = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Inserts a node at the end of the list.
+  */
+ STATIC_IF_INLINE void
+ dlist_push_tail(dlist_head *head, dlist_node *node)
+ {
+ 	node->next = &head->head;
+ 	node->prev = head->head.prev;
+ 	node->prev->next = node;
+ 	head->head.prev = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Insert a node after another *in the same list*
+  */
+ STATIC_IF_INLINE void
+ dlist_insert_after(dlist_head *head, dlist_node *after, dlist_node *node)
+ {
+ 	dlist_check(head);
+ 	/* XXX: assert 'after' is in 'head'? */
+ 
+ 	node->prev = after;
+ 	node->next = after->next;
+ 	after->next = node;
+ 	node->next->prev = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Insert a node before another *in the same list*
+  */
+ STATIC_IF_INLINE void
+ dlist_insert_before(dlist_head *head, dlist_node *before, dlist_node *node)
+ {
+ 	dlist_check(head);
+ 	/* XXX: assert 'before' is in 'head'? */
+ 
+ 	node->prev = before->prev;
+ 	node->next = before;
+ 	before->prev = node;
+ 	node->prev->next = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Delete 'node' from list.
+  *
+  * It is not allowed to delete a 'node' which is is not in the list 'head'
+  */
+ STATIC_IF_INLINE void
+ dlist_delete(dlist_head *head, dlist_node *node)
+ {
+ 	dlist_check(head);
+ 
+ 	node->prev->next = node->next;
+ 	node->next->prev = node->prev;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Delete and return the first node from a list.
+  *
+  * Undefined behaviour when the list is empty.  Check with dlist_is_empty if
+  * necessary.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_pop_head_node(dlist_head *head)
+ {
+ 	dlist_node *ret;
+ 
+ 	Assert(&head->head != head->head.next);
+ 
+ 	ret = head->head.next;
+ 	dlist_delete(head, head->head.next);
+ 	return ret;
+ }
+ 
+ /*
+  * Move element from its current position in the list to the head position in
+  * the same list.
+  *
+  * Undefined behaviour if 'node' is not already part of the list.
+  */
+ STATIC_IF_INLINE void
+ dlist_move_head(dlist_head *head, dlist_node *node)
+ {
+ 	/* fast path if it's already at the head */
+ 	if (head->head.next == node)
+ 		return;
+ 
+ 	dlist_delete(head, node);
+ 	dlist_push_head(head, node);
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Check whether the passed node is the last element in the list.
+  */
+ STATIC_IF_INLINE bool
+ dlist_has_next(dlist_head *head, dlist_node *node)
+ {
+ 	return node->next != &head->head;
+ }
+ 
+ /*
+  * Check whether the passed node is the first element in the list.
+  */
+ STATIC_IF_INLINE bool
+ dlist_has_prev(dlist_head *head, dlist_node *node)
+ {
+ 	return node->prev != &head->head;
+ }
+ 
+ /*
+  * Return the next node in the list.
+  *
+  * Undefined behaviour when no next node exists.  Use dlist_has_next to make
+  * sure.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_next_node(dlist_head *head, dlist_node *node)
+ {
+ 	Assert(dlist_has_next(head, node));
+ 	return node->next;
+ }
+ 
+ /*
+  * Return previous node in the list.
+  *
+  * Undefined behaviour when no prev node exists.  Use dlist_has_prev to make
+  * sure.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_prev_node(dlist_head *head, dlist_node *node)
+ {
+ 	Assert(dlist_has_prev(head, node));
+ 	return node->prev;
+ }
+ 
+ /*
+  * Return whether the list is empty.
+  */
+ STATIC_IF_INLINE bool
+ dlist_is_empty(dlist_head *head)
+ {
+ 	return head->head.next == &(head->head);
+ }
+ 
+ /* internal support function */
+ STATIC_IF_INLINE void *
+ dlist_head_element_off(dlist_head *head, size_t off)
+ {
+ 	Assert(!dlist_is_empty(head));
+ 	return (char *) head->head.next - off;
+ }
+ 
+ /*
+  * Return the first node in the list.
+  *
+  * Use dlist_is_empty to make sure the list is not empty if not sure.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_head_node(dlist_head *head)
+ {
+ 	return dlist_head_element_off(head, 0);
+ }
+ 
+ /* internal support function */
+ STATIC_IF_INLINE void *
+ dlist_tail_element_off(dlist_head *head, size_t off)
+ {
+ 	Assert(!dlist_is_empty(head));
+ 	return (char *) head->head.prev - off;
+ }
+ 
+ /*
+  * Return the last node in the list.
+  *
+  * Use dlist_is_empty to make sure the list is not empty if not sure.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_tail_node(dlist_head *head)
+ {
+ 	return dlist_tail_element_off(head, 0);
+ }
+ #endif   /* PG_USE_INLINE || ILIST_INCLUDE_DEFINITIONS */
+ 
+ /*
+  * Return the containing struct of 'type' where 'membername' is the dlist_node
+  * pointed at by 'ptr'.
+  *
+  * This is used to convert a dlist_node * back to its containing struct.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define dlist_container(type, membername, ptr)								 \
+ 	(AssertVariableIsOfTypeMacro(ptr, dlist_node *),						 \
+ 	 AssertVariableIsOfTypeMacro(((type *) NULL)->membername, dlist_node),	 \
+ 	 ((type *)((char *)(ptr) - offsetof(type, membername))))
+ 
+ /*
+  * Return the value of first element in the list.
+  *
+  * The list must not be empty.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define dlist_head_element(type, membername, ptr)							 \
+ 	(AssertVariableIsOfTypeMacro(((type*) NULL)->membername, dlist_node),	 \
+ 	 ((type *)dlist_get_head_off(ptr, offsetof(type, membername))))
+ 
+ /*
+  * Return the value of first element in the list.
+  *
+  * The list must not be empty.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define dlist_tail_element(type, membername, ptr)							 \
+ 	(AssertVariableIsOfTypeMacro(((type*) NULL)->membername, dlist_node),	 \
+ 	 ((type *)dlist_tail_element_off(ptr, offsetof(type, membername))))
+ 
+ /*
+  * Iterate through the list pointed at by 'ptr' storing the state in 'iter'.
+  *
+  * Access the current element with iter.cur.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define dlist_foreach(iter, ptr)											 \
+ 	AssertVariableIsOfType(iter, dlist_iter);								 \
+ 	AssertVariableIsOfType(ptr, dlist_head *);								 \
+ 	for (iter.end = &(ptr)->head, iter.cur = iter.end->next;				 \
+ 		 iter.cur != iter.end;												 \
+ 		 iter.cur = iter.cur->next)
+ 
+ /*
+  * Iterate through the list pointed at by 'ptr' storing the state in 'iter'.
+  *
+  * Access the current element with iter.cur.
+  *
+  * It is allowed to delete the current element from the list. Every other
+  * manipulation can lead to corruption.
+  */
+ #define dlist_foreach_modify(iter, ptr)										 \
+ 	AssertVariableIsOfType(iter, dlist_mutable_iter);						 \
+ 	AssertVariableIsOfType(ptr, dlist_head *);								 \
+ 	for (iter.end = &(ptr)->head, iter.cur = iter.end->next,				 \
+ 			 iter.next = iter.cur->next;									 \
+ 		 iter.cur != iter.end;												 \
+ 		 iter.cur = iter.next, iter.next = iter.cur->next)
+ 
+ /*
+  * Iterate through the list in reverse order.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define dlist_reverse_foreach(iter, ptr)									 \
+ 	AssertVariableIsOfType(iter, dlist_iter);								 \
+ 	AssertVariableIsOfType(ptr, dlist_head *);								 \
+ 	for (iter.end = &(ptr)->head, iter.cur = iter.end->prev;				 \
+ 		 iter.cur != iter.end;												 \
+ 		 iter.cur = iter.cur->prev)
+ 
+ 
+ /*
+  * We want the functions below to be inline; but if the compiler doesn't
+  * support that, fall back on providing them as regular functions.	See
+  * STATIC_IF_INLINE in c.h.
+  */
+ #ifndef PG_USE_INLINE
+ extern void slist_init(slist_head *head);
+ extern bool slist_is_empty(slist_head *head);
+ extern slist_node *slist_head_node(slist_head *head);
+ extern void slist_push_head(slist_head *head, slist_node *node);
+ extern slist_node *slist_pop_head_node(slist_head *head);
+ extern void slist_insert_after(slist_head *head,
+ 				   slist_node *after, slist_node *node);
+ extern bool slist_has_next(slist_head *head, slist_node *node);
+ extern slist_node *slist_next_node(slist_head *head, slist_node *node);
+ 
+ /* slist macro support function */
+ extern void *slist_head_element_off(slist_head *head, size_t off);
+ #endif
+ 
+ #if defined(PG_USE_INLINE) || defined(ILIST_INCLUDE_DEFINITIONS)
+ /*
+  * Initialize a singly linked list.
+  */
+ STATIC_IF_INLINE void
+ slist_init(slist_head *head)
+ {
+ 	head->head.next = NULL;
+ 
+ 	slist_check(head);
+ }
+ 
+ /*
+  * Is the list empty?
+  */
+ STATIC_IF_INLINE bool
+ slist_is_empty(slist_head *head)
+ {
+ 	slist_check(head);
+ 
+ 	return head->head.next == NULL;
+ }
+ 
+ /* internal support function */
+ STATIC_IF_INLINE void *
+ slist_head_element_off(slist_head *head, size_t off)
+ {
+ 	Assert(!slist_is_empty(head));
+ 	return (char *) head->head.next - off;
+ }
+ 
+ /*
+  * Push 'node' as the new first node in the list, pushing the original head to
+  * the second position.
+  */
+ STATIC_IF_INLINE void
+ slist_push_head(slist_head *head, slist_node *node)
+ {
+ 	node->next = head->head.next;
+ 	head->head.next = node;
+ 
+ 	slist_check(head);
+ }
+ 
+ /*
+  * Remove and return the first node in the list
+  *
+  * Undefined behaviour if the list is empty.
+  */
+ STATIC_IF_INLINE slist_node *
+ slist_pop_head_node(slist_head *head)
+ {
+ 	slist_node *node;
+ 
+ 	Assert(!slist_is_empty(head));
+ 
+ 	node = head->head.next;
+ 	head->head.next = head->head.next->next;
+ 
+ 	slist_check(head);
+ 
+ 	return node;
+ }
+ 
+ /*
+  * Insert a new node after another one
+  *
+  * Undefined behaviour if 'after' is not part of the list already.
+  */
+ STATIC_IF_INLINE void
+ slist_insert_after(slist_head *head, slist_node *after,
+ 				   slist_node *node)
+ {
+ 	node->next = after->next;
+ 	after->next = node;
+ 
+ 	slist_check(head);
+ }
+ 
+ /*
+  * Return whether 'node' has a following node
+  */
+ STATIC_IF_INLINE bool
+ slist_has_next(slist_head *head,
+ 			   slist_node *node)
+ {
+ 	slist_check(head);
+ 
+ 	return node->next != NULL;
+ }
+ #endif   /* PG_USE_INLINE || ILIST_INCLUDE_DEFINITIONS */
+ 
+ /*
+  * Return the containing struct of 'type' where 'membername' is the slist_node
+  * pointed at by 'ptr'.
+  *
+  * This is used to convert a slist_node * back to its containing struct.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define slist_container(type, membername, ptr)								 \
+ 	(AssertVariableIsOfTypeMacro(ptr, slist_node *),						 \
+ 	 AssertVariableIsOfTypeMacro(((type*)NULL)->membername, slist_node),	 \
+ 	 ((type *)((char *)(ptr) - offsetof(type, membername))))
+ 
+ /*
+  * Return the value of first element in the list.
+  */
+ #define slist_head_element(type, membername, ptr)							 \
+ 	(AssertVariableIsOfTypeMacro(((type*)NULL)->membername, slist_node),	 \
+ 	 slist_head_element_off(ptr, offsetoff(type, membername)))
+ 
+ /*
+  * Iterate through the list 'ptr' using the iterator 'iter'.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define slist_foreach(iter, ptr)											 \
+ 	AssertVariableIsOfType(iter, slist_iter);								 \
+ 	AssertVariableIsOfType(ptr, slist_head *);								 \
+ 	for (iter.cur = (ptr)->head.next;										 \
+ 		 iter.cur != NULL;													 \
+ 		 iter.cur = iter.cur->next)
+ 
+ /*
+  * Iterate through the list 'ptr' using the iterator 'iter' allowing some
+  * modifications.
+  *
+  * It is allowed to delete the current element from the list and add new nodes
+  * before the current position. Other manipulations can lead to corruption.
+  */
+ #define slist_foreach_modify(iter, ptr)										 \
+ 	AssertVariableIsOfType(iter, slist_mutable_iter);						 \
+ 	AssertVariableIsOfType(ptr, slist_head *);								 \
+ 	for (iter.cur = (ptr)->head.next,										 \
+ 			 iter.next = iter.cur ? iter.cur->next : NULL;					 \
+ 		iter.cur != NULL;													 \
+ 		iter.cur = iter.next, iter.next = iter.next ? iter.next->next : NULL)
+ 
+ #endif   /* ILIST_H */
*** a/src/include/utils/catcache.h
--- b/src/include/utils/catcache.h
***************
*** 22,28 ****
  
  #include "access/htup.h"
  #include "access/skey.h"
! #include "lib/dllist.h"
  #include "utils/relcache.h"
  
  /*
--- 22,28 ----
  
  #include "access/htup.h"
  #include "access/skey.h"
! #include "lib/ilist.h"
  #include "utils/relcache.h"
  
  /*
***************
*** 37,43 ****
  typedef struct catcache
  {
  	int			id;				/* cache identifier --- see syscache.h */
! 	struct catcache *cc_next;	/* link to next catcache */
  	const char *cc_relname;		/* name of relation the tuples come from */
  	Oid			cc_reloid;		/* OID of relation the tuples come from */
  	Oid			cc_indexoid;	/* OID of index matching cache keys */
--- 37,43 ----
  typedef struct catcache
  {
  	int			id;				/* cache identifier --- see syscache.h */
! 	slist_node	cc_next;		/* list link */
  	const char *cc_relname;		/* name of relation the tuples come from */
  	Oid			cc_reloid;		/* OID of relation the tuples come from */
  	Oid			cc_indexoid;	/* OID of index matching cache keys */
***************
*** 51,57 **** typedef struct catcache
  	ScanKeyData cc_skey[CATCACHE_MAXKEYS];		/* precomputed key info for
  												 * heap scans */
  	bool		cc_isname[CATCACHE_MAXKEYS];	/* flag "name" key columns */
! 	Dllist		cc_lists;		/* list of CatCList structs */
  #ifdef CATCACHE_STATS
  	long		cc_searches;	/* total # searches against this cache */
  	long		cc_hits;		/* # of matches against existing entry */
--- 51,57 ----
  	ScanKeyData cc_skey[CATCACHE_MAXKEYS];		/* precomputed key info for
  												 * heap scans */
  	bool		cc_isname[CATCACHE_MAXKEYS];	/* flag "name" key columns */
! 	dlist_head	cc_lists;		/* list of CatCList structs */
  #ifdef CATCACHE_STATS
  	long		cc_searches;	/* total # searches against this cache */
  	long		cc_hits;		/* # of matches against existing entry */
***************
*** 66,72 **** typedef struct catcache
  	long		cc_lsearches;	/* total # list-searches */
  	long		cc_lhits;		/* # of matches against existing lists */
  #endif
! 	Dllist		cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
  } CatCache;						/* VARIABLE LENGTH STRUCT */
  
  
--- 66,72 ----
  	long		cc_lsearches;	/* total # list-searches */
  	long		cc_lhits;		/* # of matches against existing lists */
  #endif
! 	dlist_head	cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
  } CatCache;						/* VARIABLE LENGTH STRUCT */
  
  
***************
*** 77,87 **** typedef struct catctup
  	CatCache   *my_cache;		/* link to owning catcache */
  
  	/*
! 	 * Each tuple in a cache is a member of a Dllist that stores the elements
! 	 * of its hash bucket.	We keep each Dllist in LRU order to speed repeated
  	 * lookups.
  	 */
! 	Dlelem		cache_elem;		/* list member of per-bucket list */
  
  	/*
  	 * The tuple may also be a member of at most one CatCList.	(If a single
--- 77,88 ----
  	CatCache   *my_cache;		/* link to owning catcache */
  
  	/*
! 	 * Each tuple in a cache is a member of a dlist that stores the elements
! 	 * of its hash bucket.	We keep each dlist in LRU order to speed repeated
  	 * lookups.
  	 */
! 	dlist_node	cache_elem;		/* list member of per-bucket list */
! 	dlist_head *cache_bucket;	/* containing bucket dlist */
  
  	/*
  	 * The tuple may also be a member of at most one CatCList.	(If a single
***************
*** 139,145 **** typedef struct catclist
  	 * might not be true during bootstrap or recovery operations. (namespace.c
  	 * is able to save some cycles when it is true.)
  	 */
! 	Dlelem		cache_elem;		/* list member of per-catcache list */
  	int			refcount;		/* number of active references */
  	bool		dead;			/* dead but not yet removed? */
  	bool		ordered;		/* members listed in index order? */
--- 140,146 ----
  	 * might not be true during bootstrap or recovery operations. (namespace.c
  	 * is able to save some cycles when it is true.)
  	 */
! 	dlist_node	cache_elem;		/* list member of per-catcache list */
  	int			refcount;		/* number of active references */
  	bool		dead;			/* dead but not yet removed? */
  	bool		ordered;		/* members listed in index order? */
***************
*** 153,159 **** typedef struct catclist
  
  typedef struct catcacheheader
  {
! 	CatCache   *ch_caches;		/* head of list of CatCache structs */
  	int			ch_ntup;		/* # of tuples in all caches */
  } CatCacheHeader;
  
--- 154,160 ----
  
  typedef struct catcacheheader
  {
! 	slist_head	ch_caches;		/* head of list of CatCache structs */
  	int			ch_ntup;		/* # of tuples in all caches */
  } CatCacheHeader;
  

*** a/src/backend/utils/cache/catcache.c
--- b/src/backend/utils/cache/catcache.c
***************
*** 791,799 **** InitCatCache(int id,
  		cp->cc_key[i] = key[i];
  
  	dlist_init(&cp->cc_lists);
! 
! 	for (i = 0; i < nbuckets; i++)
! 		dlist_init(&cp->cc_bucket[i]);
  
  	/*
  	 * new cache is initialized as far as we can go for now. print some
--- 791,797 ----
  		cp->cc_key[i] = key[i];
  
  	dlist_init(&cp->cc_lists);
! 	MemSet(&cp->cc_bucket, 0, nbuckets * sizeof(dlist_head));
  
  	/*
  	 * new cache is initialized as far as we can go for now. print some
*** a/src/include/lib/ilist.h
--- b/src/include/lib/ilist.h
***************
*** 6,15 ****
   * This implementation is as efficient as possible: the lists don't have
   * any memory management overhead, because the list pointers are embedded
   * within some larger structure.
! 
!  * Also, the doubly-linked lists are always circularly linked, even when empty;
!  * this enables many manipulations to be done without branches, which is
!  * beneficial performance-wise.
   *
   * NOTES
   *		This is intended to be used in situations where memory for a struct and
--- 6,18 ----
   * This implementation is as efficient as possible: the lists don't have
   * any memory management overhead, because the list pointers are embedded
   * within some larger structure.
!  *
!  * There are two kinds of empty doubly linked lists: those that have been
!  * initialized to NULL, and those that have been initialized to circularity.
!  * The second kind is useful for tight optimization, because there are some
!  * operations that can be done without branches (and thus faster) on lists that
!  * have been initialized to circularity.  Most users don't care all that much,
!  * and so can skip the initialization step until really required.
   *
   * NOTES
   *		This is intended to be used in situations where memory for a struct and
***************
*** 120,137 **** struct dlist_node
  /*
   * Head of a doubly linked list.
   *
!  * Lists are internally *always* circularly linked, even when empty. Circular
!  * lists have the advantage of not needing any branches in the most common list
!  * manipulations.
   */
  typedef struct dlist_head
  {
  	/*
! 	 * head->next either points to the first element of the list or to &head
! 	 * if empty.
  	 *
! 	 * head->prev either points to the last element of the list or to &head if
! 	 * empty.
  	 */
  	dlist_node	head;
  } dlist_head;
--- 123,141 ----
  /*
   * Head of a doubly linked list.
   *
!  * Non-empty lists are internally circularly linked.  Circular lists have the
!  * advantage of not needing any branches in the most common list manipulations.
!  * An empty list can also be represented as a pair of NULL pointers, making
!  * initialization easier.
   */
  typedef struct dlist_head
  {
  	/*
! 	 * head->next either points to the first element of the list; to &head if
! 	 * it's a circular empty list; or to NULL if empty and not circular.
  	 *
! 	 * head->prev either points to the last element of the list; to &head if
! 	 * it's a circular empty list; or to NULL if empty and not circular.
  	 */
  	dlist_node	head;
  } dlist_head;
***************
*** 265,271 **** extern void slist_check(slist_head *head);
--- 269,277 ----
  extern void dlist_init(dlist_head *head);
  extern bool dlist_is_empty(dlist_head *head);
  extern void dlist_push_head(dlist_head *head, dlist_node *node);
+ extern void dlisti_push_head(dlist_head *head, dlist_node *node);
  extern void dlist_push_tail(dlist_head *head, dlist_node *node);
+ extern void dlisti_push_tail(dlist_head *head, dlist_node *node);
  extern void dlist_insert_after(dlist_head *head,
  				   dlist_node *after, dlist_node *node);
  extern void dlist_insert_before(dlist_head *head,
***************
*** 304,309 **** dlist_init(dlist_head *head)
--- 310,334 ----
  STATIC_IF_INLINE void
  dlist_push_head(dlist_head *head, dlist_node *node)
  {
+ 	if (head->head.next == NULL)
+ 		dlist_init(head);
+ 
+ 	node->next = head->head.next;
+ 	node->prev = &head->head;
+ 	node->next->prev = node;
+ 	head->head.next = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * As above, except assume the list has been initialized to circularity.
+  */
+ STATIC_IF_INLINE void
+ dlisti_push_head(dlist_head *head, dlist_node *node)
+ {
+ 	Assert(head->head.next != NULL);
+ 
  	node->next = head->head.next;
  	node->prev = &head->head;
  	node->next->prev = node;
***************
*** 318,323 **** dlist_push_head(dlist_head *head, dlist_node *node)
--- 343,367 ----
  STATIC_IF_INLINE void
  dlist_push_tail(dlist_head *head, dlist_node *node)
  {
+ 	if (head->head.next == NULL)
+ 		dlist_init(head);
+ 
+ 	node->next = &head->head;
+ 	node->prev = head->head.prev;
+ 	node->prev->next = node;
+ 	head->head.prev = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * As above, except assume the list has been initialized to circularity.
+  */
+ STATIC_IF_INLINE void
+ dlisti_push_tail(dlist_head *head, dlist_node *node)
+ {
+ 	Assert(head->head.next != NULL);
+ 
  	node->next = &head->head;
  	node->prev = head->head.prev;
  	node->prev->next = node;
***************
*** 379,385 **** dlist_delete(dlist_head *head, dlist_node *node)
  /*
   * Delete and return the first node from a list.
   *
!  * Undefined behaviour when the list is empty.  Check with dlist_is_empty if
   * necessary.
   */
  STATIC_IF_INLINE dlist_node *
--- 423,429 ----
  /*
   * Delete and return the first node from a list.
   *
!  * Undefined behaviour when the list is empty.	Check with dlist_is_empty if
   * necessary.
   */
  STATIC_IF_INLINE dlist_node *
***************
*** 459,469 **** dlist_prev_node(dlist_head *head, dlist_node *node)
  
  /*
   * Return whether the list is empty.
   */
  STATIC_IF_INLINE bool
  dlist_is_empty(dlist_head *head)
  {
! 	return head->head.next == &(head->head);
  }
  
  /* internal support function */
--- 503,517 ----
  
  /*
   * Return whether the list is empty.
+  *
+  * An empty list has either its first 'next' pointer set to NULL, or to itself.
   */
  STATIC_IF_INLINE bool
  dlist_is_empty(dlist_head *head)
  {
! 	dlist_check(head);
! 
! 	return head->head.next == NULL || head->head.next == &(head->head);
  }
  
  /* internal support function */
***************
*** 553,559 **** dlist_tail_node(dlist_head *head)
  #define dlist_foreach(iter, ptr)											 \
  	AssertVariableIsOfType(iter, dlist_iter);								 \
  	AssertVariableIsOfType(ptr, dlist_head *);								 \
! 	for (iter.end = &(ptr)->head, iter.cur = iter.end->next;				 \
  		 iter.cur != iter.end;												 \
  		 iter.cur = iter.cur->next)
  
--- 601,608 ----
  #define dlist_foreach(iter, ptr)											 \
  	AssertVariableIsOfType(iter, dlist_iter);								 \
  	AssertVariableIsOfType(ptr, dlist_head *);								 \
! 	for (iter.end = &(ptr)->head,											 \
! 		 iter.cur = iter.end->next ? iter.end->next : iter.end;				 \
  		 iter.cur != iter.end;												 \
  		 iter.cur = iter.cur->next)
  
***************
*** 568,575 **** dlist_tail_node(dlist_head *head)
  #define dlist_foreach_modify(iter, ptr)										 \
  	AssertVariableIsOfType(iter, dlist_mutable_iter);						 \
  	AssertVariableIsOfType(ptr, dlist_head *);								 \
! 	for (iter.end = &(ptr)->head, iter.cur = iter.end->next,				 \
! 			 iter.next = iter.cur->next;									 \
  		 iter.cur != iter.end;												 \
  		 iter.cur = iter.next, iter.next = iter.cur->next)
  
--- 617,625 ----
  #define dlist_foreach_modify(iter, ptr)										 \
  	AssertVariableIsOfType(iter, dlist_mutable_iter);						 \
  	AssertVariableIsOfType(ptr, dlist_head *);								 \
! 	for (iter.end = &(ptr)->head,											 \
! 		 iter.cur = iter.end->next ? iter.end->next : iter.end,				 \
! 		 iter.next = iter.cur->next;										 \
  		 iter.cur != iter.end;												 \
  		 iter.cur = iter.next, iter.next = iter.cur->next)
  

*** a/src/backend/lib/Makefile
--- b/src/backend/lib/Makefile
***************
*** 12,17 **** subdir = src/backend/lib
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = dllist.o stringinfo.o
  
  include $(top_srcdir)/src/backend/common.mk
--- 12,17 ----
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = ilist.o stringinfo.o
  
  include $(top_srcdir)/src/backend/common.mk
*** a/src/backend/lib/dllist.c
--- /dev/null
***************
*** 1,214 ****
- /*-------------------------------------------------------------------------
-  *
-  * dllist.c
-  *	  this is a simple doubly linked list implementation
-  *	  the elements of the lists are void*
-  *
-  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
-  * Portions Copyright (c) 1994, Regents of the University of California
-  *
-  *
-  * IDENTIFICATION
-  *	  src/backend/lib/dllist.c
-  *
-  *-------------------------------------------------------------------------
-  */
- #include "postgres.h"
- 
- #include "lib/dllist.h"
- 
- 
- Dllist *
- DLNewList(void)
- {
- 	Dllist	   *l;
- 
- 	l = (Dllist *) palloc(sizeof(Dllist));
- 
- 	l->dll_head = NULL;
- 	l->dll_tail = NULL;
- 
- 	return l;
- }
- 
- void
- DLInitList(Dllist *list)
- {
- 	list->dll_head = NULL;
- 	list->dll_tail = NULL;
- }
- 
- /*
-  * free up a list and all the nodes in it --- but *not* whatever the nodes
-  * might point to!
-  */
- void
- DLFreeList(Dllist *list)
- {
- 	Dlelem	   *curr;
- 
- 	while ((curr = DLRemHead(list)) != NULL)
- 		pfree(curr);
- 
- 	pfree(list);
- }
- 
- Dlelem *
- DLNewElem(void *val)
- {
- 	Dlelem	   *e;
- 
- 	e = (Dlelem *) palloc(sizeof(Dlelem));
- 
- 	e->dle_next = NULL;
- 	e->dle_prev = NULL;
- 	e->dle_val = val;
- 	e->dle_list = NULL;
- 	return e;
- }
- 
- void
- DLInitElem(Dlelem *e, void *val)
- {
- 	e->dle_next = NULL;
- 	e->dle_prev = NULL;
- 	e->dle_val = val;
- 	e->dle_list = NULL;
- }
- 
- void
- DLFreeElem(Dlelem *e)
- {
- 	pfree(e);
- }
- 
- void
- DLRemove(Dlelem *e)
- {
- 	Dllist	   *l = e->dle_list;
- 
- 	if (e->dle_prev)
- 		e->dle_prev->dle_next = e->dle_next;
- 	else
- 	{
- 		/* must be the head element */
- 		Assert(e == l->dll_head);
- 		l->dll_head = e->dle_next;
- 	}
- 	if (e->dle_next)
- 		e->dle_next->dle_prev = e->dle_prev;
- 	else
- 	{
- 		/* must be the tail element */
- 		Assert(e == l->dll_tail);
- 		l->dll_tail = e->dle_prev;
- 	}
- 
- 	e->dle_next = NULL;
- 	e->dle_prev = NULL;
- 	e->dle_list = NULL;
- }
- 
- void
- DLAddHead(Dllist *l, Dlelem *e)
- {
- 	e->dle_list = l;
- 
- 	if (l->dll_head)
- 		l->dll_head->dle_prev = e;
- 	e->dle_next = l->dll_head;
- 	e->dle_prev = NULL;
- 	l->dll_head = e;
- 
- 	if (l->dll_tail == NULL)	/* if this is first element added */
- 		l->dll_tail = e;
- }
- 
- void
- DLAddTail(Dllist *l, Dlelem *e)
- {
- 	e->dle_list = l;
- 
- 	if (l->dll_tail)
- 		l->dll_tail->dle_next = e;
- 	e->dle_prev = l->dll_tail;
- 	e->dle_next = NULL;
- 	l->dll_tail = e;
- 
- 	if (l->dll_head == NULL)	/* if this is first element added */
- 		l->dll_head = e;
- }
- 
- Dlelem *
- DLRemHead(Dllist *l)
- {
- 	/* remove and return the head */
- 	Dlelem	   *result = l->dll_head;
- 
- 	if (result == NULL)
- 		return result;
- 
- 	if (result->dle_next)
- 		result->dle_next->dle_prev = NULL;
- 
- 	l->dll_head = result->dle_next;
- 
- 	if (result == l->dll_tail)	/* if the head is also the tail */
- 		l->dll_tail = NULL;
- 
- 	result->dle_next = NULL;
- 	result->dle_list = NULL;
- 
- 	return result;
- }
- 
- Dlelem *
- DLRemTail(Dllist *l)
- {
- 	/* remove and return the tail */
- 	Dlelem	   *result = l->dll_tail;
- 
- 	if (result == NULL)
- 		return result;
- 
- 	if (result->dle_prev)
- 		result->dle_prev->dle_next = NULL;
- 
- 	l->dll_tail = result->dle_prev;
- 
- 	if (result == l->dll_head)	/* if the tail is also the head */
- 		l->dll_head = NULL;
- 
- 	result->dle_prev = NULL;
- 	result->dle_list = NULL;
- 
- 	return result;
- }
- 
- /* Same as DLRemove followed by DLAddHead, but faster */
- void
- DLMoveToFront(Dlelem *e)
- {
- 	Dllist	   *l = e->dle_list;
- 
- 	if (l->dll_head == e)
- 		return;					/* Fast path if already at front */
- 
- 	Assert(e->dle_prev != NULL);	/* since it's not the head */
- 	e->dle_prev->dle_next = e->dle_next;
- 
- 	if (e->dle_next)
- 		e->dle_next->dle_prev = e->dle_prev;
- 	else
- 	{
- 		/* must be the tail element */
- 		Assert(e == l->dll_tail);
- 		l->dll_tail = e->dle_prev;
- 	}
- 
- 	l->dll_head->dle_prev = e;
- 	e->dle_next = l->dll_head;
- 	e->dle_prev = NULL;
- 	l->dll_head = e;
- 	/* We need not check dll_tail, since there must have been > 1 entry */
- }
--- 0 ----
*** /dev/null
--- b/src/backend/lib/ilist.c
***************
*** 0 ****
--- 1,109 ----
+ /*-------------------------------------------------------------------------
+  *
+  * ilist.c
+  *	  support for integrated/inline doubly- and singly- linked lists
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *
+  * IDENTIFICATION
+  *	  src/backend/lib/ilist.c
+  *
+  * NOTES
+  *	  This file only contains functions that are too big to be considered
+  *	  for inlining.  See ilist.h for most of the goodies.
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ /* See ilist.h */
+ #define ILIST_INCLUDE_DEFINITIONS
+ 
+ #include "lib/ilist.h"
+ 
+ /*
+  * removes a node from a list
+  *
+  * Attention: O(n)
+  */
+ void
+ slist_delete(slist_head *head, slist_node *node)
+ {
+ 	slist_node *last = &head->head;
+ 	slist_node *cur;
+ 	bool found	PG_USED_FOR_ASSERTS_ONLY = false;
+ 
+ 	while ((cur = last->next) != NULL)
+ 	{
+ 		if (cur == node)
+ 		{
+ 			last->next = cur->next;
+ #ifdef USE_ASSERT_CHECKING
+ 			found = true;
+ #endif
+ 			break;
+ 		}
+ 		last = cur;
+ 	}
+ 
+ 	slist_check(head);
+ 	Assert(found);
+ }
+ 
+ #ifdef ILIST_DEBUG
+ /*
+  * Verify integrity of a doubly linked list
+  */
+ void
+ dlist_check(dlist_head *head)
+ {
+ 	dlist_node *cur;
+ 
+ 	if (head == NULL || !(&head->head))
+ 		elog(ERROR, "doubly linked list head is not properly initialized");
+ 
+ 	/* iterate in forward direction */
+ 	for (cur = head->head.next; cur != &head->head; cur = cur->next)
+ 	{
+ 		if (cur == NULL ||
+ 			cur->next == NULL ||
+ 			cur->prev == NULL ||
+ 			cur->prev->next != cur ||
+ 			cur->next->prev != cur)
+ 			elog(ERROR, "doubly linked list is corrupted");
+ 	}
+ 
+ 	/* iterate in backward direction */
+ 	for (cur = head->head.prev; cur != &head->head; cur = cur->prev)
+ 	{
+ 		if (cur == NULL ||
+ 			cur->next == NULL ||
+ 			cur->prev == NULL ||
+ 			cur->prev->next != cur ||
+ 			cur->next->prev != cur)
+ 			elog(ERROR, "doubly linked list is corrupted");
+ 	}
+ }
+ 
+ /*
+  * Verify integrity of a singly linked list
+  */
+ void
+ slist_check(slist_head *head)
+ {
+ 	slist_node *cur;
+ 
+ 	if (head == NULL)
+ 		elog(ERROR, "singly linked is NULL");
+ 
+ 	/*
+ 	 * there isn't much we can test in a singly linked list other that it
+ 	 * actually ends sometime, i.e. hasn't introduced a cycle or similar
+ 	 */
+ 	for (cur = head->head.next; cur != NULL; cur = cur->next)
+ 		;
+ }
+ 
+ #endif   /* ILIST_DEBUG */
*** a/src/backend/postmaster/autovacuum.c
--- b/src/backend/postmaster/autovacuum.c
***************
*** 77,83 ****
  #include "catalog/pg_database.h"
  #include "commands/dbcommands.h"
  #include "commands/vacuum.h"
! #include "lib/dllist.h"
  #include "libpq/pqsignal.h"
  #include "miscadmin.h"
  #include "pgstat.h"
--- 77,83 ----
  #include "catalog/pg_database.h"
  #include "commands/dbcommands.h"
  #include "commands/vacuum.h"
! #include "lib/ilist.h"
  #include "libpq/pqsignal.h"
  #include "miscadmin.h"
  #include "pgstat.h"
***************
*** 152,157 **** typedef struct avl_dbase
--- 152,158 ----
  	Oid			adl_datid;		/* hash key -- must be first */
  	TimestampTz adl_next_worker;
  	int			adl_score;
+ 	dlist_node	adl_node;
  } avl_dbase;
  
  /* struct to keep track of databases in worker */
***************
*** 258,265 **** typedef struct
  
  static AutoVacuumShmemStruct *AutoVacuumShmem;
  
! /* the database list in the launcher, and the context that contains it */
! static Dllist *DatabaseList = NULL;
  static MemoryContext DatabaseListCxt = NULL;
  
  /* Pointer to my own WorkerInfo, valid on each worker */
--- 259,269 ----
  
  static AutoVacuumShmemStruct *AutoVacuumShmem;
  
! /*
!  * the database list (of avl_dbase elements) in the launcher, and the context
!  * that contains it
!  */
! static dlist_head DatabaseList = DLIST_STATIC_INIT(DatabaseList);
  static MemoryContext DatabaseListCxt = NULL;
  
  /* Pointer to my own WorkerInfo, valid on each worker */
***************
*** 508,514 **** AutoVacLauncherMain(int argc, char *argv[])
  
  		/* don't leave dangling pointers to freed memory */
  		DatabaseListCxt = NULL;
! 		DatabaseList = NULL;
  
  		/*
  		 * Make sure pgstat also considers our stat data as gone.  Note: we
--- 512,518 ----
  
  		/* don't leave dangling pointers to freed memory */
  		DatabaseListCxt = NULL;
! 		dlist_init(&DatabaseList);
  
  		/*
  		 * Make sure pgstat also considers our stat data as gone.  Note: we
***************
*** 576,582 **** AutoVacLauncherMain(int argc, char *argv[])
  		struct timeval nap;
  		TimestampTz current_time = 0;
  		bool		can_launch;
! 		Dlelem	   *elem;
  		int			rc;
  
  		/*
--- 580,586 ----
  		struct timeval nap;
  		TimestampTz current_time = 0;
  		bool		can_launch;
! 		avl_dbase  *avdb;
  		int			rc;
  
  		/*
***************
*** 738,757 **** AutoVacLauncherMain(int argc, char *argv[])
  
  		/* We're OK to start a new worker */
  
! 		elem = DLGetTail(DatabaseList);
! 		if (elem != NULL)
! 		{
! 			avl_dbase  *avdb = DLE_VAL(elem);
! 
! 			/*
! 			 * launch a worker if next_worker is right now or it is in the
! 			 * past
! 			 */
! 			if (TimestampDifferenceExceeds(avdb->adl_next_worker,
! 										   current_time, 0))
! 				launch_worker(current_time);
! 		}
! 		else
  		{
  			/*
  			 * Special case when the list is empty: start a worker right away.
--- 742,748 ----
  
  		/* We're OK to start a new worker */
  
! 		if (dlist_is_empty(&DatabaseList))
  		{
  			/*
  			 * Special case when the list is empty: start a worker right away.
***************
*** 763,768 **** AutoVacLauncherMain(int argc, char *argv[])
--- 754,776 ----
  			 */
  			launch_worker(current_time);
  		}
+ 		else
+ 		{
+ 			/*
+ 			 * because rebuild_database_list constructs a list with most
+ 			 * distant adl_next_worker first, we obtain our database from the
+ 			 * tail of the list.
+ 			 */
+ 			avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
+ 
+ 			/*
+ 			 * launch a worker if next_worker is right now or it is in the
+ 			 * past
+ 			 */
+ 			if (TimestampDifferenceExceeds(avdb->adl_next_worker,
+ 										   current_time, 0))
+ 				launch_worker(current_time);
+ 		}
  	}
  
  	/* Normal exit from the autovac launcher is here */
***************
*** 783,789 **** AutoVacLauncherMain(int argc, char *argv[])
  static void
  launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
  {
! 	Dlelem	   *elem;
  
  	/*
  	 * We sleep until the next scheduled vacuum.  We trust that when the
--- 791,797 ----
  static void
  launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
  {
! 	avl_dbase  *avdb;
  
  	/*
  	 * We sleep until the next scheduled vacuum.  We trust that when the
***************
*** 796,809 **** launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
  		nap->tv_sec = autovacuum_naptime;
  		nap->tv_usec = 0;
  	}
! 	else if ((elem = DLGetTail(DatabaseList)) != NULL)
  	{
- 		avl_dbase  *avdb = DLE_VAL(elem);
  		TimestampTz current_time = GetCurrentTimestamp();
  		TimestampTz next_wakeup;
  		long		secs;
  		int			usecs;
  
  		next_wakeup = avdb->adl_next_worker;
  		TimestampDifference(current_time, next_wakeup, &secs, &usecs);
  
--- 804,818 ----
  		nap->tv_sec = autovacuum_naptime;
  		nap->tv_usec = 0;
  	}
! 	else if (!dlist_is_empty(&DatabaseList))
  	{
  		TimestampTz current_time = GetCurrentTimestamp();
  		TimestampTz next_wakeup;
  		long		secs;
  		int			usecs;
  
+ 		avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
+ 
  		next_wakeup = avdb->adl_next_worker;
  		TimestampDifference(current_time, next_wakeup, &secs, &usecs);
  
***************
*** 867,872 **** rebuild_database_list(Oid newdb)
--- 876,882 ----
  	int			score;
  	int			nelems;
  	HTAB	   *dbhash;
+ 	dlist_iter  iter;
  
  	/* use fresh stats */
  	autovac_refresh_stats();
***************
*** 927,962 **** rebuild_database_list(Oid newdb)
  	}
  
  	/* Now insert the databases from the existing list */
! 	if (DatabaseList != NULL)
  	{
! 		Dlelem	   *elem;
! 
! 		elem = DLGetHead(DatabaseList);
! 		while (elem != NULL)
! 		{
! 			avl_dbase  *avdb = DLE_VAL(elem);
! 			avl_dbase  *db;
! 			bool		found;
! 			PgStat_StatDBEntry *entry;
! 
! 			elem = DLGetSucc(elem);
  
! 			/*
! 			 * skip databases with no stat entries -- in particular, this gets
! 			 * rid of dropped databases
! 			 */
! 			entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
! 			if (entry == NULL)
! 				continue;
  
! 			db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
  
! 			if (!found)
! 			{
! 				/* hash_search already filled in the key */
! 				db->adl_score = score++;
! 				/* next_worker is filled in later */
! 			}
  		}
  	}
  
--- 937,964 ----
  	}
  
  	/* Now insert the databases from the existing list */
! 	dlist_foreach(iter, &DatabaseList)
  	{
! 		avl_dbase  *avdb = dlist_container(avl_dbase, adl_node, iter.cur);
! 		avl_dbase  *db;
! 		bool		found;
! 		PgStat_StatDBEntry *entry;
  
! 		/*
! 		 * skip databases with no stat entries -- in particular, this gets
! 		 * rid of dropped databases
! 		 */
! 		entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
! 		if (entry == NULL)
! 			continue;
  
! 		db = hash_search(dbhash, &(avdb->adl_datid), HASH_ENTER, &found);
  
! 		if (!found)
! 		{
! 			/* hash_search already filled in the key */
! 			db->adl_score = score++;
! 			/* next_worker is filled in later */
  		}
  	}
  
***************
*** 987,993 **** rebuild_database_list(Oid newdb)
  
  	/* from here on, the allocated memory belongs to the new list */
  	MemoryContextSwitchTo(newcxt);
! 	DatabaseList = DLNewList();
  
  	if (nelems > 0)
  	{
--- 989,995 ----
  
  	/* from here on, the allocated memory belongs to the new list */
  	MemoryContextSwitchTo(newcxt);
! 	dlist_init(&DatabaseList);
  
  	if (nelems > 0)
  	{
***************
*** 1029,1043 **** rebuild_database_list(Oid newdb)
  		for (i = 0; i < nelems; i++)
  		{
  			avl_dbase  *db = &(dbary[i]);
- 			Dlelem	   *elem;
  
  			current_time = TimestampTzPlusMilliseconds(current_time,
  													   millis_increment);
  			db->adl_next_worker = current_time;
  
- 			elem = DLNewElem(db);
  			/* later elements should go closer to the head of the list */
! 			DLAddHead(DatabaseList, elem);
  		}
  	}
  
--- 1031,1043 ----
  		for (i = 0; i < nelems; i++)
  		{
  			avl_dbase  *db = &(dbary[i]);
  
  			current_time = TimestampTzPlusMilliseconds(current_time,
  													   millis_increment);
  			db->adl_next_worker = current_time;
  
  			/* later elements should go closer to the head of the list */
! 			dlist_push_head(&DatabaseList, &db->adl_node);
  		}
  	}
  
***************
*** 1147,1153 **** do_start_worker(void)
  	foreach(cell, dblist)
  	{
  		avw_dbase  *tmp = lfirst(cell);
! 		Dlelem	   *elem;
  
  		/* Check to see if this one is at risk of wraparound */
  		if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
--- 1147,1153 ----
  	foreach(cell, dblist)
  	{
  		avw_dbase  *tmp = lfirst(cell);
! 		dlist_iter iter;
  
  		/* Check to see if this one is at risk of wraparound */
  		if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
***************
*** 1179,1189 **** do_start_worker(void)
  		 * autovacuum time yet.
  		 */
  		skipit = false;
- 		elem = DatabaseList ? DLGetTail(DatabaseList) : NULL;
  
! 		while (elem != NULL)
  		{
! 			avl_dbase  *dbp = DLE_VAL(elem);
  
  			if (dbp->adl_datid == tmp->adw_datid)
  			{
--- 1179,1188 ----
  		 * autovacuum time yet.
  		 */
  		skipit = false;
  
! 		dlist_reverse_foreach(iter, &DatabaseList)
  		{
! 			avl_dbase  *dbp = dlist_container(avl_dbase, adl_node, iter.cur);
  
  			if (dbp->adl_datid == tmp->adw_datid)
  			{
***************
*** 1200,1206 **** do_start_worker(void)
  
  				break;
  			}
- 			elem = DLGetPred(elem);
  		}
  		if (skipit)
  			continue;
--- 1199,1204 ----
***************
*** 1274,1295 **** static void
  launch_worker(TimestampTz now)
  {
  	Oid			dbid;
! 	Dlelem	   *elem;
  
  	dbid = do_start_worker();
  	if (OidIsValid(dbid))
  	{
  		/*
  		 * Walk the database list and update the corresponding entry.  If the
  		 * database is not on the list, we'll recreate the list.
  		 */
! 		elem = (DatabaseList == NULL) ? NULL : DLGetHead(DatabaseList);
! 		while (elem != NULL)
  		{
! 			avl_dbase  *avdb = DLE_VAL(elem);
  
  			if (avdb->adl_datid == dbid)
  			{
  				/*
  				 * add autovacuum_naptime seconds to the current time, and use
  				 * that as the new "next_worker" field for this database.
--- 1272,1296 ----
  launch_worker(TimestampTz now)
  {
  	Oid			dbid;
! 	dlist_iter  iter;
  
  	dbid = do_start_worker();
  	if (OidIsValid(dbid))
  	{
+ 		bool found = false;
+ 
  		/*
  		 * Walk the database list and update the corresponding entry.  If the
  		 * database is not on the list, we'll recreate the list.
  		 */
! 		dlist_foreach(iter, &DatabaseList)
  		{
! 			avl_dbase  *avdb = dlist_container(avl_dbase, adl_node, iter.cur);
  
  			if (avdb->adl_datid == dbid)
  			{
+ 				found = true;
+ 
  				/*
  				 * add autovacuum_naptime seconds to the current time, and use
  				 * that as the new "next_worker" field for this database.
***************
*** 1297,1306 **** launch_worker(TimestampTz now)
  				avdb->adl_next_worker =
  					TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000);
  
! 				DLMoveToFront(elem);
  				break;
  			}
- 			elem = DLGetSucc(elem);
  		}
  
  		/*
--- 1298,1306 ----
  				avdb->adl_next_worker =
  					TimestampTzPlusMilliseconds(now, autovacuum_naptime * 1000);
  
! 				dlist_move_head(&DatabaseList, iter.cur);
  				break;
  			}
  		}
  
  		/*
***************
*** 1310,1316 **** launch_worker(TimestampTz now)
  		 * pgstat entry, but this is not a problem because we don't want to
  		 * schedule workers regularly into those in any case.
  		 */
! 		if (elem == NULL)
  			rebuild_database_list(dbid);
  	}
  }
--- 1310,1316 ----
  		 * pgstat entry, but this is not a problem because we don't want to
  		 * schedule workers regularly into those in any case.
  		 */
! 		if (!found)
  			rebuild_database_list(dbid);
  	}
  }
*** a/src/backend/postmaster/postmaster.c
--- b/src/backend/postmaster/postmaster.c
***************
*** 95,101 ****
  #include "access/xlog.h"
  #include "bootstrap/bootstrap.h"
  #include "catalog/pg_control.h"
! #include "lib/dllist.h"
  #include "libpq/auth.h"
  #include "libpq/ip.h"
  #include "libpq/libpq.h"
--- 95,101 ----
  #include "access/xlog.h"
  #include "bootstrap/bootstrap.h"
  #include "catalog/pg_control.h"
! #include "lib/ilist.h"
  #include "libpq/auth.h"
  #include "libpq/ip.h"
  #include "libpq/libpq.h"
***************
*** 146,155 **** typedef struct bkend
  	int			child_slot;		/* PMChildSlot for this backend, if any */
  	bool		is_autovacuum;	/* is it an autovacuum process? */
  	bool		dead_end;		/* is it going to send an error and quit? */
! 	Dlelem		elem;			/* list link in BackendList */
  } Backend;
  
! static Dllist *BackendList;
  
  #ifdef EXEC_BACKEND
  static Backend *ShmemBackendArray;
--- 146,155 ----
  	int			child_slot;		/* PMChildSlot for this backend, if any */
  	bool		is_autovacuum;	/* is it an autovacuum process? */
  	bool		dead_end;		/* is it going to send an error and quit? */
! 	dlist_node	elem;			/* list link in BackendList */
  } Backend;
  
! static dlist_head BackendList = DLIST_STATIC_INIT(BackendList);
  
  #ifdef EXEC_BACKEND
  static Backend *ShmemBackendArray;
***************
*** 1028,1038 **** PostmasterMain(int argc, char *argv[])
  	set_stack_base();
  
  	/*
- 	 * Initialize the list of active backends.
- 	 */
- 	BackendList = DLNewList();
- 
- 	/*
  	 * Initialize pipe (or process handle on Windows) that allows children to
  	 * wake up from sleep on postmaster death.
  	 */
--- 1028,1033 ----
***************
*** 1872,1878 **** processCancelRequest(Port *port, void *pkt)
  	Backend    *bp;
  
  #ifndef EXEC_BACKEND
! 	Dlelem	   *curr;
  #else
  	int			i;
  #endif
--- 1867,1873 ----
  	Backend    *bp;
  
  #ifndef EXEC_BACKEND
! 	dlist_iter  iter;
  #else
  	int			i;
  #endif
***************
*** 1886,1894 **** processCancelRequest(Port *port, void *pkt)
  	 * duplicate array in shared memory.
  	 */
  #ifndef EXEC_BACKEND
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		bp = (Backend *) DLE_VAL(curr);
  #else
  	for (i = MaxLivePostmasterChildren() - 1; i >= 0; i--)
  	{
--- 1881,1889 ----
  	 * duplicate array in shared memory.
  	 */
  #ifndef EXEC_BACKEND
! 	dlist_foreach(iter, &BackendList)
  	{
! 		bp = dlist_container(Backend, elem, iter.cur);
  #else
  	for (i = MaxLivePostmasterChildren() - 1; i >= 0; i--)
  	{
***************
*** 2648,2654 **** static void
  CleanupBackend(int pid,
  			   int exitstatus)	/* child's exit status. */
  {
! 	Dlelem	   *curr;
  
  	LogChildExit(DEBUG2, _("server process"), pid, exitstatus);
  
--- 2643,2649 ----
  CleanupBackend(int pid,
  			   int exitstatus)	/* child's exit status. */
  {
! 	dlist_mutable_iter iter;
  
  	LogChildExit(DEBUG2, _("server process"), pid, exitstatus);
  
***************
*** 2680,2688 **** CleanupBackend(int pid,
  		return;
  	}
  
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		Backend    *bp = (Backend *) DLE_VAL(curr);
  
  		if (bp->pid == pid)
  		{
--- 2675,2683 ----
  		return;
  	}
  
! 	dlist_foreach_modify(iter, &BackendList)
  	{
! 		Backend    *bp = dlist_container(Backend, elem, iter.cur);
  
  		if (bp->pid == pid)
  		{
***************
*** 2701,2707 **** CleanupBackend(int pid,
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			DLRemove(curr);
  			free(bp);
  			break;
  		}
--- 2696,2702 ----
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			dlist_delete(&BackendList, iter.cur);
  			free(bp);
  			break;
  		}
***************
*** 2718,2725 **** CleanupBackend(int pid,
  static void
  HandleChildCrash(int pid, int exitstatus, const char *procname)
  {
! 	Dlelem	   *curr,
! 			   *next;
  	Backend    *bp;
  
  	/*
--- 2713,2719 ----
  static void
  HandleChildCrash(int pid, int exitstatus, const char *procname)
  {
! 	dlist_mutable_iter iter;
  	Backend    *bp;
  
  	/*
***************
*** 2734,2743 **** HandleChildCrash(int pid, int exitstatus, const char *procname)
  	}
  
  	/* Process regular backends */
! 	for (curr = DLGetHead(BackendList); curr; curr = next)
  	{
! 		next = DLGetSucc(curr);
! 		bp = (Backend *) DLE_VAL(curr);
  		if (bp->pid == pid)
  		{
  			/*
--- 2728,2737 ----
  	}
  
  	/* Process regular backends */
! 	dlist_foreach_modify(iter, &BackendList)
  	{
! 		bp = dlist_container(Backend, elem, iter.cur);
! 
  		if (bp->pid == pid)
  		{
  			/*
***************
*** 2750,2756 **** HandleChildCrash(int pid, int exitstatus, const char *procname)
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			DLRemove(curr);
  			free(bp);
  			/* Keep looping so we can signal remaining backends */
  		}
--- 2744,2750 ----
  				ShmemBackendArrayRemove(bp);
  #endif
  			}
! 			dlist_delete(&BackendList, iter.cur);
  			free(bp);
  			/* Keep looping so we can signal remaining backends */
  		}
***************
*** 3113,3119 **** PostmasterStateMachine(void)
  		 * normal state transition leading up to PM_WAIT_DEAD_END, or during
  		 * FatalError processing.
  		 */
! 		if (DLGetHead(BackendList) == NULL &&
  			PgArchPID == 0 && PgStatPID == 0)
  		{
  			/* These other guys should be dead already */
--- 3107,3113 ----
  		 * normal state transition leading up to PM_WAIT_DEAD_END, or during
  		 * FatalError processing.
  		 */
! 		if (dlist_is_empty(&BackendList) &&
  			PgArchPID == 0 && PgStatPID == 0)
  		{
  			/* These other guys should be dead already */
***************
*** 3239,3250 **** signal_child(pid_t pid, int signal)
  static bool
  SignalSomeChildren(int signal, int target)
  {
! 	Dlelem	   *curr;
  	bool		signaled = false;
  
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		Backend    *bp = (Backend *) DLE_VAL(curr);
  
  		if (bp->dead_end)
  			continue;
--- 3233,3244 ----
  static bool
  SignalSomeChildren(int signal, int target)
  {
! 	dlist_iter  iter;
  	bool		signaled = false;
  
! 	dlist_foreach(iter, &BackendList)
  	{
! 		Backend    *bp = dlist_container(Backend, elem, iter.cur);
  
  		if (bp->dead_end)
  			continue;
***************
*** 3382,3389 **** BackendStartup(Port *port)
  	 */
  	bn->pid = pid;
  	bn->is_autovacuum = false;
! 	DLInitElem(&bn->elem, bn);
! 	DLAddHead(BackendList, &bn->elem);
  #ifdef EXEC_BACKEND
  	if (!bn->dead_end)
  		ShmemBackendArrayAdd(bn);
--- 3376,3383 ----
  	 */
  	bn->pid = pid;
  	bn->is_autovacuum = false;
! 	dlist_push_head(&BackendList, &bn->elem);
! 
  #ifdef EXEC_BACKEND
  	if (!bn->dead_end)
  		ShmemBackendArrayAdd(bn);
***************
*** 4491,4502 **** PostmasterRandom(void)
  static int
  CountChildren(int target)
  {
! 	Dlelem	   *curr;
  	int			cnt = 0;
  
! 	for (curr = DLGetHead(BackendList); curr; curr = DLGetSucc(curr))
  	{
! 		Backend    *bp = (Backend *) DLE_VAL(curr);
  
  		if (bp->dead_end)
  			continue;
--- 4485,4496 ----
  static int
  CountChildren(int target)
  {
! 	dlist_iter  iter;
  	int			cnt = 0;
  
! 	dlist_foreach(iter, &BackendList)
  	{
! 		Backend    *bp = dlist_container(Backend, elem, iter.cur);
  
  		if (bp->dead_end)
  			continue;
***************
*** 4675,4682 **** StartAutovacuumWorker(void)
  			if (bn->pid > 0)
  			{
  				bn->is_autovacuum = true;
! 				DLInitElem(&bn->elem, bn);
! 				DLAddHead(BackendList, &bn->elem);
  #ifdef EXEC_BACKEND
  				ShmemBackendArrayAdd(bn);
  #endif
--- 4669,4675 ----
  			if (bn->pid > 0)
  			{
  				bn->is_autovacuum = true;
! 				dlist_push_head(&BackendList, &bn->elem);
  #ifdef EXEC_BACKEND
  				ShmemBackendArrayAdd(bn);
  #endif
*** a/src/backend/utils/cache/catcache.c
--- b/src/backend/utils/cache/catcache.c
***************
*** 291,297 **** CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple)
  static void
  CatCachePrintStats(int code, Datum arg)
  {
! 	CatCache   *cache;
  	long		cc_searches = 0;
  	long		cc_hits = 0;
  	long		cc_neg_hits = 0;
--- 291,297 ----
  static void
  CatCachePrintStats(int code, Datum arg)
  {
! 	slist_iter  iter;
  	long		cc_searches = 0;
  	long		cc_hits = 0;
  	long		cc_neg_hits = 0;
***************
*** 300,307 **** CatCachePrintStats(int code, Datum arg)
  	long		cc_lsearches = 0;
  	long		cc_lhits = 0;
  
! 	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
  	{
  		if (cache->cc_ntup == 0 && cache->cc_searches == 0)
  			continue;			/* don't print unused caches */
  		elog(DEBUG2, "catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld lsrch, %ld lhits",
--- 300,309 ----
  	long		cc_lsearches = 0;
  	long		cc_lhits = 0;
  
! 	slist_foreach(iter, &CacheHdr->ch_caches)
  	{
+ 		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
+ 
  		if (cache->cc_ntup == 0 && cache->cc_searches == 0)
  			continue;			/* don't print unused caches */
  		elog(DEBUG2, "catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld lsrch, %ld lhits",
***************
*** 368,375 **** CatCacheRemoveCTup(CatCache *cache, CatCTup *ct)
  		return;					/* nothing left to do */
  	}
  
! 	/* delink from linked list */
! 	DLRemove(&ct->cache_elem);
  
  	/* free associated tuple data */
  	if (ct->tuple.t_data != NULL)
--- 370,376 ----
  		return;					/* nothing left to do */
  	}
  
! 	dlist_delete(ct->cache_bucket, &ct->cache_elem);
  
  	/* free associated tuple data */
  	if (ct->tuple.t_data != NULL)
***************
*** 412,418 **** CatCacheRemoveCList(CatCache *cache, CatCList *cl)
  	}
  
  	/* delink from linked list */
! 	DLRemove(&cl->cache_elem);
  
  	/* free associated tuple data */
  	if (cl->tuple.t_data != NULL)
--- 413,419 ----
  	}
  
  	/* delink from linked list */
! 	dlist_delete(&cache->cc_lists, &cl->cache_elem);
  
  	/* free associated tuple data */
  	if (cl->tuple.t_data != NULL)
***************
*** 442,459 **** CatCacheRemoveCList(CatCache *cache, CatCList *cl)
  void
  CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  {
! 	CatCache   *ccp;
  
  	CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
  
  	/*
  	 * inspect caches to find the proper cache
  	 */
! 	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
  	{
  		Index		hashIndex;
! 		Dlelem	   *elt,
! 				   *nextelt;
  
  		if (cacheId != ccp->id)
  			continue;
--- 443,460 ----
  void
  CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  {
! 	slist_iter cache_iter;
  
  	CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
  
  	/*
  	 * inspect caches to find the proper cache
  	 */
! 	slist_foreach(cache_iter, &CacheHdr->ch_caches)
  	{
  		Index		hashIndex;
! 		dlist_mutable_iter iter;
! 		CatCache   *ccp = slist_container(CatCache, cc_next, cache_iter.cur);
  
  		if (cacheId != ccp->id)
  			continue;
***************
*** 468,478 **** CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  		 * Invalidate *all* CatCLists in this cache; it's too hard to tell
  		 * which searches might still be correct, so just zap 'em all.
  		 */
! 		for (elt = DLGetHead(&ccp->cc_lists); elt; elt = nextelt)
  		{
! 			CatCList   *cl = (CatCList *) DLE_VAL(elt);
! 
! 			nextelt = DLGetSucc(elt);
  
  			if (cl->refcount > 0)
  				cl->dead = true;
--- 469,477 ----
  		 * Invalidate *all* CatCLists in this cache; it's too hard to tell
  		 * which searches might still be correct, so just zap 'em all.
  		 */
! 		dlist_foreach_modify(iter, &ccp->cc_lists)
  		{
! 			CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  			if (cl->refcount > 0)
  				cl->dead = true;
***************
*** 484,495 **** CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
  		 * inspect the proper hash bucket for tuple matches
  		 */
  		hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets);
! 
! 		for (elt = DLGetHead(&ccp->cc_bucket[hashIndex]); elt; elt = nextelt)
  		{
! 			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
! 
! 			nextelt = DLGetSucc(elt);
  
  			if (hashValue == ct->hash_value)
  			{
--- 483,491 ----
  		 * inspect the proper hash bucket for tuple matches
  		 */
  		hashIndex = HASH_INDEX(hashValue, ccp->cc_nbuckets);
! 		dlist_foreach_modify(iter, &ccp->cc_bucket[hashIndex])
  		{
! 			CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  			if (hashValue == ct->hash_value)
  			{
***************
*** 557,573 **** AtEOXact_CatCache(bool isCommit)
  #ifdef USE_ASSERT_CHECKING
  	if (assert_enabled)
  	{
! 		CatCache   *ccp;
  
! 		for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
  		{
! 			Dlelem	   *elt;
  			int			i;
  
  			/* Check CatCLists */
! 			for (elt = DLGetHead(&ccp->cc_lists); elt; elt = DLGetSucc(elt))
  			{
! 				CatCList   *cl = (CatCList *) DLE_VAL(elt);
  
  				Assert(cl->cl_magic == CL_MAGIC);
  				Assert(cl->refcount == 0);
--- 553,570 ----
  #ifdef USE_ASSERT_CHECKING
  	if (assert_enabled)
  	{
! 		slist_iter  cache_iter;
  
! 		slist_foreach(cache_iter, &(CacheHdr->ch_caches))
  		{
! 			CatCache   *ccp = slist_container(CatCache, cc_next, cache_iter.cur);
! 			dlist_iter  iter;
  			int			i;
  
  			/* Check CatCLists */
! 			dlist_foreach(iter, &ccp->cc_lists)
  			{
! 				CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  				Assert(cl->cl_magic == CL_MAGIC);
  				Assert(cl->refcount == 0);
***************
*** 577,587 **** AtEOXact_CatCache(bool isCommit)
  			/* Check individual tuples */
  			for (i = 0; i < ccp->cc_nbuckets; i++)
  			{
! 				for (elt = DLGetHead(&ccp->cc_bucket[i]);
! 					 elt;
! 					 elt = DLGetSucc(elt))
  				{
! 					CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
  
  					Assert(ct->ct_magic == CT_MAGIC);
  					Assert(ct->refcount == 0);
--- 574,584 ----
  			/* Check individual tuples */
  			for (i = 0; i < ccp->cc_nbuckets; i++)
  			{
! 				dlist_head *bucket = &ccp->cc_bucket[i];
! 
! 				dlist_foreach(iter, bucket)
  				{
! 					CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  					Assert(ct->ct_magic == CT_MAGIC);
  					Assert(ct->refcount == 0);
***************
*** 604,619 **** AtEOXact_CatCache(bool isCommit)
  static void
  ResetCatalogCache(CatCache *cache)
  {
! 	Dlelem	   *elt,
! 			   *nextelt;
  	int			i;
  
  	/* Remove each list in this cache, or at least mark it dead */
! 	for (elt = DLGetHead(&cache->cc_lists); elt; elt = nextelt)
  	{
! 		CatCList   *cl = (CatCList *) DLE_VAL(elt);
! 
! 		nextelt = DLGetSucc(elt);
  
  		if (cl->refcount > 0)
  			cl->dead = true;
--- 601,613 ----
  static void
  ResetCatalogCache(CatCache *cache)
  {
! 	dlist_mutable_iter iter;
  	int			i;
  
  	/* Remove each list in this cache, or at least mark it dead */
! 	dlist_foreach_modify(iter, &cache->cc_lists)
  	{
! 		CatCList   *cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  		if (cl->refcount > 0)
  			cl->dead = true;
***************
*** 624,634 **** ResetCatalogCache(CatCache *cache)
  	/* Remove each tuple in this cache, or at least mark it dead */
  	for (i = 0; i < cache->cc_nbuckets; i++)
  	{
! 		for (elt = DLGetHead(&cache->cc_bucket[i]); elt; elt = nextelt)
! 		{
! 			CatCTup    *ct = (CatCTup *) DLE_VAL(elt);
  
! 			nextelt = DLGetSucc(elt);
  
  			if (ct->refcount > 0 ||
  				(ct->c_list && ct->c_list->refcount > 0))
--- 618,628 ----
  	/* Remove each tuple in this cache, or at least mark it dead */
  	for (i = 0; i < cache->cc_nbuckets; i++)
  	{
! 		dlist_head *bucket = &cache->cc_bucket[i];
  
! 		dlist_foreach_modify(iter, bucket)
! 		{
! 			CatCTup    *ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  			if (ct->refcount > 0 ||
  				(ct->c_list && ct->c_list->refcount > 0))
***************
*** 654,665 **** ResetCatalogCache(CatCache *cache)
  void
  ResetCatalogCaches(void)
  {
! 	CatCache   *cache;
  
  	CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
  
! 	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
  		ResetCatalogCache(cache);
  
  	CACHE1_elog(DEBUG2, "end of ResetCatalogCaches call");
  }
--- 648,663 ----
  void
  ResetCatalogCaches(void)
  {
! 	slist_iter    iter;
  
  	CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
  
! 	slist_foreach(iter, &CacheHdr->ch_caches)
! 	{
! 		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
! 
  		ResetCatalogCache(cache);
+ 	}
  
  	CACHE1_elog(DEBUG2, "end of ResetCatalogCaches call");
  }
***************
*** 680,691 **** ResetCatalogCaches(void)
  void
  CatalogCacheFlushCatalog(Oid catId)
  {
! 	CatCache   *cache;
  
  	CACHE2_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
  
! 	for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
  	{
  		/* Does this cache store tuples of the target catalog? */
  		if (cache->cc_reloid == catId)
  		{
--- 678,691 ----
  void
  CatalogCacheFlushCatalog(Oid catId)
  {
! 	slist_iter  iter;
  
  	CACHE2_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
  
! 	slist_foreach(iter, &(CacheHdr->ch_caches))
  	{
+ 		CatCache   *cache = slist_container(CatCache, cc_next, iter.cur);
+ 
  		/* Does this cache store tuples of the target catalog? */
  		if (cache->cc_reloid == catId)
  		{
***************
*** 760,766 **** InitCatCache(int id,
  	if (CacheHdr == NULL)
  	{
  		CacheHdr = (CatCacheHeader *) palloc(sizeof(CatCacheHeader));
! 		CacheHdr->ch_caches = NULL;
  		CacheHdr->ch_ntup = 0;
  #ifdef CATCACHE_STATS
  		/* set up to dump stats at backend exit */
--- 760,766 ----
  	if (CacheHdr == NULL)
  	{
  		CacheHdr = (CatCacheHeader *) palloc(sizeof(CatCacheHeader));
! 		slist_init(&CacheHdr->ch_caches);
  		CacheHdr->ch_ntup = 0;
  #ifdef CATCACHE_STATS
  		/* set up to dump stats at backend exit */
***************
*** 770,779 **** InitCatCache(int id,
  
  	/*
  	 * allocate a new cache structure
- 	 *
- 	 * Note: we assume zeroing initializes the Dllist headers correctly
  	 */
! 	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(Dllist));
  
  	/*
  	 * initialize the cache's relation information for the relation
--- 770,777 ----
  
  	/*
  	 * allocate a new cache structure
  	 */
! 	cp = (CatCache *) palloc0(sizeof(CatCache) + nbuckets * sizeof(dlist_node));
  
  	/*
  	 * initialize the cache's relation information for the relation
***************
*** 792,797 **** InitCatCache(int id,
--- 790,798 ----
  	for (i = 0; i < nkeys; ++i)
  		cp->cc_key[i] = key[i];
  
+ 	dlist_init(&cp->cc_lists);
+ 	MemSet(&cp->cc_bucket, 0, nbuckets * sizeof(dlist_head));
+ 
  	/*
  	 * new cache is initialized as far as we can go for now. print some
  	 * debugging information, if appropriate.
***************
*** 801,808 **** InitCatCache(int id,
  	/*
  	 * add completed cache to top of group header's list
  	 */
! 	cp->cc_next = CacheHdr->ch_caches;
! 	CacheHdr->ch_caches = cp;
  
  	/*
  	 * back to the old context before we return...
--- 802,808 ----
  	/*
  	 * add completed cache to top of group header's list
  	 */
! 	slist_push_head(&CacheHdr->ch_caches, &cp->cc_next);
  
  	/*
  	 * back to the old context before we return...
***************
*** 1060,1066 **** SearchCatCache(CatCache *cache,
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		hashValue;
  	Index		hashIndex;
! 	Dlelem	   *elt;
  	CatCTup    *ct;
  	Relation	relation;
  	SysScanDesc scandesc;
--- 1060,1067 ----
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		hashValue;
  	Index		hashIndex;
! 	dlist_mutable_iter  iter;
! 	dlist_head *bucket;
  	CatCTup    *ct;
  	Relation	relation;
  	SysScanDesc scandesc;
***************
*** 1094,1106 **** SearchCatCache(CatCache *cache,
  	/*
  	 * scan the hash bucket until we find a match or exhaust our tuples
  	 */
! 	for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
! 		 elt;
! 		 elt = DLGetSucc(elt))
  	{
  		bool		res;
  
! 		ct = (CatCTup *) DLE_VAL(elt);
  
  		if (ct->dead)
  			continue;			/* ignore dead entries */
--- 1095,1107 ----
  	/*
  	 * scan the hash bucket until we find a match or exhaust our tuples
  	 */
! 	bucket = &cache->cc_bucket[hashIndex];
! 
! 	dlist_foreach_modify(iter, bucket)
  	{
  		bool		res;
  
! 		ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  		if (ct->dead)
  			continue;			/* ignore dead entries */
***************
*** 1125,1131 **** SearchCatCache(CatCache *cache,
  		 * most frequently accessed elements in any hashbucket will tend to be
  		 * near the front of the hashbucket's list.)
  		 */
! 		DLMoveToFront(&ct->cache_elem);
  
  		/*
  		 * If it's a positive entry, bump its refcount and return it. If it's
--- 1126,1132 ----
  		 * most frequently accessed elements in any hashbucket will tend to be
  		 * near the front of the hashbucket's list.)
  		 */
! 		dlist_move_head(bucket, &ct->cache_elem);
  
  		/*
  		 * If it's a positive entry, bump its refcount and return it. If it's
***************
*** 1340,1346 **** SearchCatCacheList(CatCache *cache,
  {
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		lHashValue;
! 	Dlelem	   *elt;
  	CatCList   *cl;
  	CatCTup    *ct;
  	List	   *volatile ctlist;
--- 1341,1347 ----
  {
  	ScanKeyData cur_skey[CATCACHE_MAXKEYS];
  	uint32		lHashValue;
! 	dlist_iter  iter;
  	CatCList   *cl;
  	CatCTup    *ct;
  	List	   *volatile ctlist;
***************
*** 1382,1394 **** SearchCatCacheList(CatCache *cache,
  	/*
  	 * scan the items until we find a match or exhaust our list
  	 */
! 	for (elt = DLGetHead(&cache->cc_lists);
! 		 elt;
! 		 elt = DLGetSucc(elt))
  	{
  		bool		res;
  
! 		cl = (CatCList *) DLE_VAL(elt);
  
  		if (cl->dead)
  			continue;			/* ignore dead entries */
--- 1383,1393 ----
  	/*
  	 * scan the items until we find a match or exhaust our list
  	 */
! 	dlist_foreach(iter, &cache->cc_lists)
  	{
  		bool		res;
  
! 		cl = dlist_container(CatCList, cache_elem, iter.cur);
  
  		if (cl->dead)
  			continue;			/* ignore dead entries */
***************
*** 1416,1422 **** SearchCatCacheList(CatCache *cache,
  		 * since there's no point in that unless they are searched for
  		 * individually.)
  		 */
! 		DLMoveToFront(&cl->cache_elem);
  
  		/* Bump the list's refcount and return it */
  		ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
--- 1415,1421 ----
  		 * since there's no point in that unless they are searched for
  		 * individually.)
  		 */
! 		dlist_move_head(&cache->cc_lists, &cl->cache_elem);
  
  		/* Bump the list's refcount and return it */
  		ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
***************
*** 1468,1473 **** SearchCatCacheList(CatCache *cache,
--- 1467,1474 ----
  		{
  			uint32		hashValue;
  			Index		hashIndex;
+ 			bool		found = false;
+ 			dlist_head *bucket;
  
  			/*
  			 * See if there's an entry for this tuple already.
***************
*** 1476,1486 **** SearchCatCacheList(CatCache *cache,
  			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);
  			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
  
! 			for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);
! 				 elt;
! 				 elt = DLGetSucc(elt))
  			{
! 				ct = (CatCTup *) DLE_VAL(elt);
  
  				if (ct->dead || ct->negative)
  					continue;	/* ignore dead and negative entries */
--- 1477,1486 ----
  			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);
  			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
  
! 			bucket = &cache->cc_bucket[hashIndex];
! 			dlist_foreach(iter, bucket)
  			{
! 				ct = dlist_container(CatCTup, cache_elem, iter.cur);
  
  				if (ct->dead || ct->negative)
  					continue;	/* ignore dead and negative entries */
***************
*** 1498,1507 **** SearchCatCacheList(CatCache *cache,
  				if (ct->c_list)
  					continue;
  
  				break;			/* A-OK */
  			}
  
! 			if (elt == NULL)
  			{
  				/* We didn't find a usable entry, so make a new one */
  				ct = CatalogCacheCreateEntry(cache, ntp,
--- 1498,1508 ----
  				if (ct->c_list)
  					continue;
  
+ 				found = true;
  				break;			/* A-OK */
  			}
  
! 			if (!found)
  			{
  				/* We didn't find a usable entry, so make a new one */
  				ct = CatalogCacheCreateEntry(cache, ntp,
***************
*** 1564,1570 **** SearchCatCacheList(CatCache *cache,
  
  	cl->cl_magic = CL_MAGIC;
  	cl->my_cache = cache;
- 	DLInitElem(&cl->cache_elem, cl);
  	cl->refcount = 0;			/* for the moment */
  	cl->dead = false;
  	cl->ordered = ordered;
--- 1565,1570 ----
***************
*** 1587,1593 **** SearchCatCacheList(CatCache *cache,
  	}
  	Assert(i == nmembers);
  
! 	DLAddHead(&cache->cc_lists, &cl->cache_elem);
  
  	/* Finally, bump the list's refcount and return it */
  	cl->refcount++;
--- 1587,1593 ----
  	}
  	Assert(i == nmembers);
  
! 	dlist_push_head(&cache->cc_lists, &cl->cache_elem);
  
  	/* Finally, bump the list's refcount and return it */
  	cl->refcount++;
***************
*** 1664,1677 **** CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp,
  	 */
  	ct->ct_magic = CT_MAGIC;
  	ct->my_cache = cache;
! 	DLInitElem(&ct->cache_elem, (void *) ct);
  	ct->c_list = NULL;
  	ct->refcount = 0;			/* for the moment */
  	ct->dead = false;
  	ct->negative = negative;
  	ct->hash_value = hashValue;
  
! 	DLAddHead(&cache->cc_bucket[hashIndex], &ct->cache_elem);
  
  	cache->cc_ntup++;
  	CacheHdr->ch_ntup++;
--- 1664,1678 ----
  	 */
  	ct->ct_magic = CT_MAGIC;
  	ct->my_cache = cache;
! 	ct->cache_bucket = &cache->cc_bucket[hashIndex];
! 
  	ct->c_list = NULL;
  	ct->refcount = 0;			/* for the moment */
  	ct->dead = false;
  	ct->negative = negative;
  	ct->hash_value = hashValue;
  
! 	dlist_push_head(ct->cache_bucket, &ct->cache_elem);
  
  	cache->cc_ntup++;
  	CacheHdr->ch_ntup++;
***************
*** 1785,1791 **** PrepareToInvalidateCacheTuple(Relation relation,
  							  HeapTuple newtuple,
  							  void (*function) (int, uint32, Oid))
  {
! 	CatCache   *ccp;
  	Oid			reloid;
  
  	CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
--- 1786,1792 ----
  							  HeapTuple newtuple,
  							  void (*function) (int, uint32, Oid))
  {
! 	slist_iter  iter;
  	Oid			reloid;
  
  	CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
***************
*** 1808,1817 **** PrepareToInvalidateCacheTuple(Relation relation,
  	 * ----------------
  	 */
  
! 	for (ccp = CacheHdr->ch_caches; ccp; ccp = ccp->cc_next)
  	{
  		uint32		hashvalue;
  		Oid			dbid;
  
  		if (ccp->cc_reloid != reloid)
  			continue;
--- 1809,1819 ----
  	 * ----------------
  	 */
  
! 	slist_foreach(iter, &(CacheHdr->ch_caches))
  	{
  		uint32		hashvalue;
  		Oid			dbid;
+ 		CatCache   *ccp = slist_container(CatCache, cc_next, iter.cur);
  
  		if (ccp->cc_reloid != reloid)
  			continue;
*** a/src/include/lib/dllist.h
--- /dev/null
***************
*** 1,85 ****
- /*-------------------------------------------------------------------------
-  *
-  * dllist.h
-  *		simple doubly linked list primitives
-  *		the elements of the list are void* so the lists can contain anything
-  *		Dlelem can only be in one list at a time
-  *
-  *
-  *	 Here's a small example of how to use Dllists:
-  *
-  *	 Dllist *lst;
-  *	 Dlelem *elt;
-  *	 void	*in_stuff;	  -- stuff to stick in the list
-  *	 void	*out_stuff
-  *
-  *	 lst = DLNewList();				   -- make a new dllist
-  *	 DLAddHead(lst, DLNewElem(in_stuff)); -- add a new element to the list
-  *											 with in_stuff as the value
-  *	  ...
-  *	 elt = DLGetHead(lst);			   -- retrieve the head element
-  *	 out_stuff = (void*)DLE_VAL(elt);  -- get the stuff out
-  *	 DLRemove(elt);					   -- removes the element from its list
-  *	 DLFreeElem(elt);				   -- free the element since we don't
-  *										  use it anymore
-  *
-  *
-  * It is also possible to use Dllist objects that are embedded in larger
-  * structures instead of being separately malloc'd.  To do this, use
-  * DLInitElem() to initialize a Dllist field within a larger object.
-  * Don't forget to DLRemove() each field from its list (if any) before
-  * freeing the larger object!
-  *
-  *
-  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
-  * Portions Copyright (c) 1994, Regents of the University of California
-  *
-  * src/include/lib/dllist.h
-  *
-  *-------------------------------------------------------------------------
-  */
- 
- #ifndef DLLIST_H
- #define DLLIST_H
- 
- struct Dllist;
- struct Dlelem;
- 
- typedef struct Dlelem
- {
- 	struct Dlelem *dle_next;	/* next element */
- 	struct Dlelem *dle_prev;	/* previous element */
- 	void	   *dle_val;		/* value of the element */
- 	struct Dllist *dle_list;	/* what list this element is in */
- } Dlelem;
- 
- typedef struct Dllist
- {
- 	Dlelem	   *dll_head;
- 	Dlelem	   *dll_tail;
- } Dllist;
- 
- extern Dllist *DLNewList(void); /* allocate and initialize a list header */
- extern void DLInitList(Dllist *list);	/* init a header alloced by caller */
- extern void DLFreeList(Dllist *list);	/* free up a list and all the nodes in
- 										 * it */
- extern Dlelem *DLNewElem(void *val);
- extern void DLInitElem(Dlelem *e, void *val);
- extern void DLFreeElem(Dlelem *e);
- extern void DLRemove(Dlelem *e);	/* removes node from list */
- extern void DLAddHead(Dllist *list, Dlelem *node);
- extern void DLAddTail(Dllist *list, Dlelem *node);
- extern Dlelem *DLRemHead(Dllist *list); /* remove and return the head */
- extern Dlelem *DLRemTail(Dllist *list);
- extern void DLMoveToFront(Dlelem *e);	/* move node to front of its list */
- 
- /* These are macros for speed */
- #define DLGetHead(list)  ((list)->dll_head)
- #define DLGetTail(list)  ((list)->dll_tail)
- #define DLGetSucc(elem)  ((elem)->dle_next)
- #define DLGetPred(elem)  ((elem)->dle_prev)
- #define DLGetListHdr(elem)	((elem)->dle_list)
- 
- #define DLE_VAL(elem)	((elem)->dle_val)
- 
- #endif   /* DLLIST_H */
--- 0 ----
*** /dev/null
--- b/src/include/lib/ilist.h
***************
*** 0 ****
--- 1,766 ----
+ /*-------------------------------------------------------------------------
+  *
+  * ilist.h
+  *		integrated/inline doubly- and singly-linked lists
+  *
+  * This implementation is as efficient as possible: the lists don't have
+  * any memory management overhead, because the list pointers are embedded
+  * within some larger structure.
+  *
+  * There are two kinds of empty doubly linked lists: those that have been
+  * initialized to NULL, and those that have been initialized to circularity.
+  * The second kind is useful for tight optimization, because there are some
+  * operations that can be done without branches (and thus faster) on lists that
+  * have been initialized to circularity.  Most users don't care all that much,
+  * and so can skip the initialization step until really required.
+  *
+  * NOTES
+  *		This is intended to be used in situations where memory for a struct and
+  *		its contents already needs to be allocated and the overhead of
+  *		allocating extra list cells for every list element is noticeable.  Thus,
+  *		none of the functions here allocate any memory; they just manipulate
+  *		externally managed memory.	The API for singly/doubly linked lists is
+  *		identical as far as capabilities of both allow.
+  *
+  * EXAMPLES
+  *
+  * An oversimplified example demonstrating how this can be used.  Let's assume
+  * we want to store information about the tables contained in a database.
+  *
+  * #include "lib/ilist.h"
+  *
+  * // Define struct for the databases including a list header that will be used
+  * // to access the nodes in the list later on.
+  * typedef struct my_database
+  * {
+  *		char	   *datname;
+  *		dlist_head	tables;
+  *		// ...
+  * } my_database;
+  *
+  * // Define struct for the tables. Note the list_node element which stores
+  * // information about prev/next list nodes.
+  * typedef struct my_table
+  * {
+  *		char	   *tablename;
+  *		dlist_node	list_node;
+  *		perm_t		permissions;
+  *		// ...
+  * } value_in_a_list;
+  *
+  * // create a database
+  * my_database *db = create_database();
+  *
+  * // and add a few tables to its table list
+  * dlist_push_head(&db->tables, &create_table(db, "a")->list_node);
+  * ...
+  * dlist_push_head(&db->tables, &create_table(db, "b")->list_node);
+  *
+  *
+  * To iterate over the table list, we allocate an iterator element and use
+  * a specialized looping construct.  Inside a dlist_foreach, the iterator's
+  * 'cur' field can be used to access the current element.  iter.cur points to a
+  * 'dlist_node', but most of the time what we want is the actual table
+  * information; dlist_container() gives us that, like so:
+  *
+  * dlist_iter	iter;
+  * dlist_foreach(iter, &db->tables)
+  * {
+  *		my_table   *tbl = dlist_container(my_table, list_node, iter.cur);
+  *		printf("we have a table: %s in database %s\n",
+  *			   val->tablename, db->datname);
+  * }
+  *
+  *
+  * While a simple iteration is useful, we sometimes also want to manipulate
+  * the list while iterating.  There is a different iterator element and looping
+  * construct for that.	Suppose we want to delete tables that meet a certain
+  * criterion:
+  *
+  * dlist_mutable_iter miter;
+  * dlist_foreach_modify(miter, &db->tables)
+  * {
+  *		my_table   *tbl = dlist_container(my_table, list_node, miter.cur);
+  *
+  *		if (!tbl->to_be_deleted)
+  *			continue;		// don't touch this one
+  *
+  *		// unlink the current table from the linked list
+  *		dlist_delete(&db->tables, miter.cur);
+  *		// as these lists never manage memory, we can freely access the table
+  *		// after it's been deleted
+  *		drop_table(db, tbl);
+  * }
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  * IDENTIFICATION
+  *		src/include/lib/ilist.h
+  *-------------------------------------------------------------------------
+  */
+ #ifndef ILIST_H
+ #define ILIST_H
+ 
+ /*
+  * Enable for extra debugging. This is rather expensive, so it's not enabled by
+  * default even when USE_ASSERT_CHECKING.
+  */
+ /* #define ILIST_DEBUG */
+ 
+ /*
+  * Node of a doubly linked list.
+  *
+  * Embed this in structs that need to be part of a doubly linked list.
+  */
+ typedef struct dlist_node dlist_node;
+ struct dlist_node
+ {
+ 	dlist_node *prev;
+ 	dlist_node *next;
+ };
+ 
+ /*
+  * Head of a doubly linked list.
+  *
+  * Non-empty lists are internally circularly linked.  Circular lists have the
+  * advantage of not needing any branches in the most common list manipulations.
+  * An empty list can also be represented as a pair of NULL pointers, making
+  * initialization easier.
+  */
+ typedef struct dlist_head
+ {
+ 	/*
+ 	 * head->next either points to the first element of the list; to &head if
+ 	 * it's a circular empty list; or to NULL if empty and not circular.
+ 	 *
+ 	 * head->prev either points to the last element of the list; to &head if
+ 	 * it's a circular empty list; or to NULL if empty and not circular.
+ 	 */
+ 	dlist_node	head;
+ } dlist_head;
+ 
+ 
+ /*
+  * Doubly linked list iterator.
+  *
+  * Used as state in dlist_foreach() and dlist_reverse_foreach(). To get the
+  * current element of the iteration use the 'cur' member.
+  *
+  * Iterations using this are *not* allowed to change the list while iterating!
+  *
+  * NB: We use an extra type for this to make it possible to avoid multiple
+  * evaluations of arguments in the dlist_foreach() macro.
+  */
+ typedef struct dlist_iter
+ {
+ 	dlist_node *end;			/* last node we iterate to */
+ 	dlist_node *cur;			/* current element */
+ } dlist_iter;
+ 
+ /*
+  * Doubly linked list iterator allowing some modifications while iterating
+  *
+  * Used as state in dlist_foreach_modify(). To get the current element of the
+  * iteration use the 'cur' member.
+  *
+  * Iterations using this are only allowed to change the list *at the current
+  * point of iteration*. It is fine to delete the current node, but it is *not*
+  * fine to modify other nodes.
+  *
+  * NB: We need a separate type for mutable iterations to avoid having to pass
+  * in two iterators or some other state variable as we need to store the
+  * '->next' node of the current node so it can be deleted or modified by the
+  * user.
+  */
+ typedef struct dlist_mutable_iter
+ {
+ 	dlist_node *end;			/* last node we iterate to */
+ 	dlist_node *cur;			/* current element */
+ 	dlist_node *next;			/* next node we iterate to, so we can delete
+ 								 * cur */
+ } dlist_mutable_iter;
+ 
+ /*
+  * Node of a singly linked list.
+  *
+  * Embed this in structs that need to be part of a singly linked list.
+  */
+ typedef struct slist_node slist_node;
+ struct slist_node
+ {
+ 	slist_node *next;
+ };
+ 
+ /*
+  * Head of a singly linked list.
+  *
+  * Singly linked lists are not circularly linked, in contrast to doubly linked
+  * lists. As no pointer to the last list element and to the previous node needs
+  * to be maintained this doesn't incur any additional branches in the usual
+  * manipulations.
+  */
+ typedef struct slist_head
+ {
+ 	slist_node	head;
+ } slist_head;
+ 
+ /*
+  * Singly linked list iterator
+  *
+  * Used in slist_foreach(). To get the current element of the iteration use the
+  * 'cur' member.
+  *
+  * Do *not* manipulate the list while iterating!
+  *
+  * NB: this wouldn't really need to be an extra struct, we could use a
+  * slist_node * directly. We still use a separate type for consistency.
+  */
+ typedef struct slist_iter
+ {
+ 	slist_node *cur;
+ } slist_iter;
+ 
+ /*
+  * Singly linked list iterator allowing some modifications while iterating
+  *
+  * Used in slist_foreach_modify.
+  *
+  * Iterations using this are allowed to remove the current node and to add more
+  * nodes to the beginning of the list.
+  */
+ typedef struct slist_mutable_iter
+ {
+ 	slist_node *cur;
+ 	slist_node *next;
+ } slist_mutable_iter;
+ 
+ 
+ /* Prototypes for functions too big to be inline */
+ 
+ /* Attention: O(n) */
+ extern void slist_delete(slist_head *head, slist_node *node);
+ 
+ #ifdef ILIST_DEBUG
+ extern void dlist_check(dlist_head *head);
+ extern void slist_check(slist_head *head);
+ #else
+ /*
+  * These seemingly useless casts to void are here to keep the compiler quiet
+  * about the argument being unused in many functions in a non-debug compile,
+  * in which functions the only point of passing the list head pointer is to be
+  * able to run these checks.
+  */
+ #define dlist_check(head)	(void) (head)
+ #define slist_check(head)	(void) (head)
+ #endif   /* ILIST_DEBUG */
+ 
+ /* Static initializers */
+ #define DLIST_STATIC_INIT(name) {{&name.head, &name.head}}
+ #define SLIST_STATIC_INIT(name) {{NULL}}
+ 
+ 
+ /*
+  * We want the functions below to be inline; but if the compiler doesn't
+  * support that, fall back on providing them as regular functions.	See
+  * STATIC_IF_INLINE in c.h.
+  */
+ #ifndef PG_USE_INLINE
+ extern void dlist_init(dlist_head *head);
+ extern bool dlist_is_empty(dlist_head *head);
+ extern void dlist_push_head(dlist_head *head, dlist_node *node);
+ extern void dlist_push_tail(dlist_head *head, dlist_node *node);
+ extern void dlist_insert_after(dlist_head *head,
+ 				   dlist_node *after, dlist_node *node);
+ extern void dlist_insert_before(dlist_head *head,
+ 					dlist_node *before, dlist_node *node);
+ extern void dlist_delete(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_pop_head_node(dlist_head *head);
+ extern void dlist_move_head(dlist_head *head, dlist_node *node);
+ extern bool dlist_has_next(dlist_head *head, dlist_node *node);
+ extern bool dlist_has_prev(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_next_node(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_prev_node(dlist_head *head, dlist_node *node);
+ extern dlist_node *dlist_head_node(dlist_head *head);
+ extern dlist_node *dlist_tail_node(dlist_head *head);
+ 
+ /* dlist macro support functions */
+ extern void *dlist_tail_element_off(dlist_head *head, size_t off);
+ extern void *dlist_head_element_off(dlist_head *head, size_t off);
+ #endif   /* !PG_USE_INLINE */
+ 
+ #if defined(PG_USE_INLINE) || defined(ILIST_INCLUDE_DEFINITIONS)
+ /*
+  * Initialize the head of a list. Previous state will be thrown away without
+  * any cleanup.
+  */
+ STATIC_IF_INLINE void
+ dlist_init(dlist_head *head)
+ {
+ 	head->head.next = head->head.prev = &head->head;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Insert a node at the beginning of the list.
+  */
+ STATIC_IF_INLINE void
+ dlist_push_head(dlist_head *head, dlist_node *node)
+ {
+ 	if (head->head.next == NULL)
+ 		dlist_init(head);
+ 
+ 	node->next = head->head.next;
+ 	node->prev = &head->head;
+ 	node->next->prev = node;
+ 	head->head.next = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Inserts a node at the end of the list.
+  */
+ STATIC_IF_INLINE void
+ dlist_push_tail(dlist_head *head, dlist_node *node)
+ {
+ 	if (head->head.next == NULL)
+ 		dlist_init(head);
+ 
+ 	node->next = &head->head;
+ 	node->prev = head->head.prev;
+ 	node->prev->next = node;
+ 	head->head.prev = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Insert a node after another *in the same list*
+  */
+ STATIC_IF_INLINE void
+ dlist_insert_after(dlist_head *head, dlist_node *after, dlist_node *node)
+ {
+ 	dlist_check(head);
+ 	/* XXX: assert 'after' is in 'head'? */
+ 
+ 	node->prev = after;
+ 	node->next = after->next;
+ 	after->next = node;
+ 	node->next->prev = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Insert a node before another *in the same list*
+  */
+ STATIC_IF_INLINE void
+ dlist_insert_before(dlist_head *head, dlist_node *before, dlist_node *node)
+ {
+ 	dlist_check(head);
+ 	/* XXX: assert 'before' is in 'head'? */
+ 
+ 	node->prev = before->prev;
+ 	node->next = before;
+ 	before->prev = node;
+ 	node->prev->next = node;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Delete 'node' from list.
+  *
+  * It is not allowed to delete a 'node' which is is not in the list 'head'
+  */
+ STATIC_IF_INLINE void
+ dlist_delete(dlist_head *head, dlist_node *node)
+ {
+ 	dlist_check(head);
+ 
+ 	node->prev->next = node->next;
+ 	node->next->prev = node->prev;
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Delete and return the first node from a list.
+  *
+  * Undefined behaviour when the list is empty.	Check with dlist_is_empty if
+  * necessary.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_pop_head_node(dlist_head *head)
+ {
+ 	dlist_node *ret;
+ 
+ 	Assert(&head->head != head->head.next);
+ 
+ 	ret = head->head.next;
+ 	dlist_delete(head, head->head.next);
+ 	return ret;
+ }
+ 
+ /*
+  * Move element from its current position in the list to the head position in
+  * the same list.
+  *
+  * Undefined behaviour if 'node' is not already part of the list.
+  */
+ STATIC_IF_INLINE void
+ dlist_move_head(dlist_head *head, dlist_node *node)
+ {
+ 	/* fast path if it's already at the head */
+ 	if (head->head.next == node)
+ 		return;
+ 
+ 	dlist_delete(head, node);
+ 	dlist_push_head(head, node);
+ 
+ 	dlist_check(head);
+ }
+ 
+ /*
+  * Check whether the passed node is the last element in the list.
+  */
+ STATIC_IF_INLINE bool
+ dlist_has_next(dlist_head *head, dlist_node *node)
+ {
+ 	return node->next != &head->head;
+ }
+ 
+ /*
+  * Check whether the passed node is the first element in the list.
+  */
+ STATIC_IF_INLINE bool
+ dlist_has_prev(dlist_head *head, dlist_node *node)
+ {
+ 	return node->prev != &head->head;
+ }
+ 
+ /*
+  * Return the next node in the list.
+  *
+  * Undefined behaviour when no next node exists.  Use dlist_has_next to make
+  * sure.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_next_node(dlist_head *head, dlist_node *node)
+ {
+ 	Assert(dlist_has_next(head, node));
+ 	return node->next;
+ }
+ 
+ /*
+  * Return previous node in the list.
+  *
+  * Undefined behaviour when no prev node exists.  Use dlist_has_prev to make
+  * sure.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_prev_node(dlist_head *head, dlist_node *node)
+ {
+ 	Assert(dlist_has_prev(head, node));
+ 	return node->prev;
+ }
+ 
+ /*
+  * Return whether the list is empty.
+  *
+  * An empty list has either its first 'next' pointer set to NULL, or to itself.
+  */
+ STATIC_IF_INLINE bool
+ dlist_is_empty(dlist_head *head)
+ {
+ 	dlist_check(head);
+ 
+ 	return head->head.next == NULL || head->head.next == &(head->head);
+ }
+ 
+ /* internal support function */
+ STATIC_IF_INLINE void *
+ dlist_head_element_off(dlist_head *head, size_t off)
+ {
+ 	Assert(!dlist_is_empty(head));
+ 	return (char *) head->head.next - off;
+ }
+ 
+ /*
+  * Return the first node in the list.
+  *
+  * Use dlist_is_empty to make sure the list is not empty if not sure.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_head_node(dlist_head *head)
+ {
+ 	return dlist_head_element_off(head, 0);
+ }
+ 
+ /* internal support function */
+ STATIC_IF_INLINE void *
+ dlist_tail_element_off(dlist_head *head, size_t off)
+ {
+ 	Assert(!dlist_is_empty(head));
+ 	return (char *) head->head.prev - off;
+ }
+ 
+ /*
+  * Return the last node in the list.
+  *
+  * Use dlist_is_empty to make sure the list is not empty if not sure.
+  */
+ STATIC_IF_INLINE dlist_node *
+ dlist_tail_node(dlist_head *head)
+ {
+ 	return dlist_tail_element_off(head, 0);
+ }
+ #endif   /* PG_USE_INLINE || ILIST_INCLUDE_DEFINITIONS */
+ 
+ /*
+  * Return the containing struct of 'type' where 'membername' is the dlist_node
+  * pointed at by 'ptr'.
+  *
+  * This is used to convert a dlist_node * back to its containing struct.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define dlist_container(type, membername, ptr)								\
+ 	(AssertVariableIsOfTypeMacro(ptr, dlist_node *),						\
+ 	 AssertVariableIsOfTypeMacro(((type *) NULL)->membername, dlist_node),	\
+ 	 ((type *)((char *)(ptr) - offsetof(type, membername))))
+ 
+ /*
+  * Return the value of first element in the list.
+  *
+  * The list must not be empty.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define dlist_head_element(type, membername, ptr)							\
+ 	(AssertVariableIsOfTypeMacro(((type*) NULL)->membername, dlist_node),	\
+ 	 ((type *)dlist_head_element_off(ptr, offsetof(type, membername))))
+ 
+ /*
+  * Return the value of first element in the list.
+  *
+  * The list must not be empty.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define dlist_tail_element(type, membername, ptr)							\
+ 	(AssertVariableIsOfTypeMacro(((type*) NULL)->membername, dlist_node),	\
+ 	 ((type *)dlist_tail_element_off(ptr, offsetof(type, membername))))
+ 
+ /*
+  * Iterate through the list pointed at by 'ptr' storing the state in 'iter'.
+  *
+  * Access the current element with iter.cur.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define dlist_foreach(iter, ptr)											\
+ 	AssertVariableIsOfType(iter, dlist_iter);								\
+ 	AssertVariableIsOfType(ptr, dlist_head *);								\
+ 	for (iter.end = &(ptr)->head,											\
+ 		 iter.cur = iter.end->next ? iter.end->next : iter.end;				\
+ 		 iter.cur != iter.end;												\
+ 		 iter.cur = iter.cur->next)
+ 
+ /*
+  * Iterate through the list pointed at by 'ptr' storing the state in 'iter'.
+  *
+  * Access the current element with iter.cur.
+  *
+  * It is allowed to delete the current element from the list. Every other
+  * manipulation can lead to corruption.
+  */
+ #define dlist_foreach_modify(iter, ptr)										\
+ 	AssertVariableIsOfType(iter, dlist_mutable_iter);						\
+ 	AssertVariableIsOfType(ptr, dlist_head *);								\
+ 	for (iter.end = &(ptr)->head,											\
+ 		 iter.cur = iter.end->next ? iter.end->next : iter.end,				\
+ 		 iter.next = iter.cur->next;										\
+ 		 iter.cur != iter.end;												\
+ 		 iter.cur = iter.next, iter.next = iter.cur->next)
+ 
+ /*
+  * Iterate through the list in reverse order.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define dlist_reverse_foreach(iter, ptr)									\
+ 	AssertVariableIsOfType(iter, dlist_iter);								\
+ 	AssertVariableIsOfType(ptr, dlist_head *);								\
+ 	for (iter.end = &(ptr)->head,											\
+ 		 iter.cur = iter.end->prev ? iter.end->prev : iter.end;				\
+ 		 iter.cur != iter.end;												\
+ 		 iter.cur = iter.cur->prev)
+ 
+ 
+ /*
+  * We want the functions below to be inline; but if the compiler doesn't
+  * support that, fall back on providing them as regular functions.	See
+  * STATIC_IF_INLINE in c.h.
+  */
+ #ifndef PG_USE_INLINE
+ extern void slist_init(slist_head *head);
+ extern bool slist_is_empty(slist_head *head);
+ extern slist_node *slist_head_node(slist_head *head);
+ extern void slist_push_head(slist_head *head, slist_node *node);
+ extern slist_node *slist_pop_head_node(slist_head *head);
+ extern void slist_insert_after(slist_head *head,
+ 				   slist_node *after, slist_node *node);
+ extern bool slist_has_next(slist_head *head, slist_node *node);
+ extern slist_node *slist_next_node(slist_head *head, slist_node *node);
+ 
+ /* slist macro support function */
+ extern void *slist_head_element_off(slist_head *head, size_t off);
+ #endif
+ 
+ #if defined(PG_USE_INLINE) || defined(ILIST_INCLUDE_DEFINITIONS)
+ /*
+  * Initialize a singly linked list.
+  */
+ STATIC_IF_INLINE void
+ slist_init(slist_head *head)
+ {
+ 	head->head.next = NULL;
+ 
+ 	slist_check(head);
+ }
+ 
+ /*
+  * Is the list empty?
+  */
+ STATIC_IF_INLINE bool
+ slist_is_empty(slist_head *head)
+ {
+ 	slist_check(head);
+ 
+ 	return head->head.next == NULL;
+ }
+ 
+ /* internal support function */
+ STATIC_IF_INLINE void *
+ slist_head_element_off(slist_head *head, size_t off)
+ {
+ 	Assert(!slist_is_empty(head));
+ 	return (char *) head->head.next - off;
+ }
+ 
+ /*
+  * Push 'node' as the new first node in the list, pushing the original head to
+  * the second position.
+  */
+ STATIC_IF_INLINE void
+ slist_push_head(slist_head *head, slist_node *node)
+ {
+ 	node->next = head->head.next;
+ 	head->head.next = node;
+ 
+ 	slist_check(head);
+ }
+ 
+ /*
+  * Remove and return the first node in the list
+  *
+  * Undefined behaviour if the list is empty.
+  */
+ STATIC_IF_INLINE slist_node *
+ slist_pop_head_node(slist_head *head)
+ {
+ 	slist_node *node;
+ 
+ 	Assert(!slist_is_empty(head));
+ 
+ 	node = head->head.next;
+ 	head->head.next = head->head.next->next;
+ 
+ 	slist_check(head);
+ 
+ 	return node;
+ }
+ 
+ /*
+  * Insert a new node after another one
+  *
+  * Undefined behaviour if 'after' is not part of the list already.
+  */
+ STATIC_IF_INLINE void
+ slist_insert_after(slist_head *head, slist_node *after,
+ 				   slist_node *node)
+ {
+ 	node->next = after->next;
+ 	after->next = node;
+ 
+ 	slist_check(head);
+ }
+ 
+ /*
+  * Return whether 'node' has a following node
+  */
+ STATIC_IF_INLINE bool
+ slist_has_next(slist_head *head,
+ 			   slist_node *node)
+ {
+ 	slist_check(head);
+ 
+ 	return node->next != NULL;
+ }
+ #endif   /* PG_USE_INLINE || ILIST_INCLUDE_DEFINITIONS */
+ 
+ /*
+  * Return the containing struct of 'type' where 'membername' is the slist_node
+  * pointed at by 'ptr'.
+  *
+  * This is used to convert a slist_node * back to its containing struct.
+  *
+  * Note that AssertVariableIsOfTypeMacro is a compile time only check, so we
+  * don't have multiple evaluation dangers here.
+  */
+ #define slist_container(type, membername, ptr)								\
+ 	(AssertVariableIsOfTypeMacro(ptr, slist_node *),						\
+ 	 AssertVariableIsOfTypeMacro(((type*)NULL)->membername, slist_node),	\
+ 	 ((type *)((char *)(ptr) - offsetof(type, membername))))
+ 
+ /*
+  * Return the value of first element in the list.
+  */
+ #define slist_head_element(type, membername, ptr)							\
+ 	(AssertVariableIsOfTypeMacro(((type*)NULL)->membername, slist_node),	\
+ 	 slist_head_element_off(ptr, offsetoff(type, membername)))
+ 
+ /*
+  * Iterate through the list 'ptr' using the iterator 'iter'.
+  *
+  * It is *not* allowed to manipulate the list during iteration.
+  */
+ #define slist_foreach(iter, ptr)											\
+ 	AssertVariableIsOfType(iter, slist_iter);								\
+ 	AssertVariableIsOfType(ptr, slist_head *);								\
+ 	for (iter.cur = (ptr)->head.next;										\
+ 		 iter.cur != NULL;													\
+ 		 iter.cur = iter.cur->next)
+ 
+ /*
+  * Iterate through the list 'ptr' using the iterator 'iter' allowing some
+  * modifications.
+  *
+  * It is allowed to delete the current element from the list and add new nodes
+  * before the current position. Other manipulations can lead to corruption.
+  */
+ #define slist_foreach_modify(iter, ptr)										\
+ 	AssertVariableIsOfType(iter, slist_mutable_iter);						\
+ 	AssertVariableIsOfType(ptr, slist_head *);								\
+ 	for (iter.cur = (ptr)->head.next,										\
+ 			 iter.next = iter.cur ? iter.cur->next : NULL;					\
+ 		iter.cur != NULL;													\
+ 		iter.cur = iter.next, iter.next = iter.next ? iter.next->next : NULL)
+ 
+ #endif   /* ILIST_H */
*** a/src/include/utils/catcache.h
--- b/src/include/utils/catcache.h
***************
*** 22,28 ****
  
  #include "access/htup.h"
  #include "access/skey.h"
! #include "lib/dllist.h"
  #include "utils/relcache.h"
  
  /*
--- 22,28 ----
  
  #include "access/htup.h"
  #include "access/skey.h"
! #include "lib/ilist.h"
  #include "utils/relcache.h"
  
  /*
***************
*** 37,43 ****
  typedef struct catcache
  {
  	int			id;				/* cache identifier --- see syscache.h */
! 	struct catcache *cc_next;	/* link to next catcache */
  	const char *cc_relname;		/* name of relation the tuples come from */
  	Oid			cc_reloid;		/* OID of relation the tuples come from */
  	Oid			cc_indexoid;	/* OID of index matching cache keys */
--- 37,43 ----
  typedef struct catcache
  {
  	int			id;				/* cache identifier --- see syscache.h */
! 	slist_node	cc_next;		/* list link */
  	const char *cc_relname;		/* name of relation the tuples come from */
  	Oid			cc_reloid;		/* OID of relation the tuples come from */
  	Oid			cc_indexoid;	/* OID of index matching cache keys */
***************
*** 51,57 **** typedef struct catcache
  	ScanKeyData cc_skey[CATCACHE_MAXKEYS];		/* precomputed key info for
  												 * heap scans */
  	bool		cc_isname[CATCACHE_MAXKEYS];	/* flag "name" key columns */
! 	Dllist		cc_lists;		/* list of CatCList structs */
  #ifdef CATCACHE_STATS
  	long		cc_searches;	/* total # searches against this cache */
  	long		cc_hits;		/* # of matches against existing entry */
--- 51,57 ----
  	ScanKeyData cc_skey[CATCACHE_MAXKEYS];		/* precomputed key info for
  												 * heap scans */
  	bool		cc_isname[CATCACHE_MAXKEYS];	/* flag "name" key columns */
! 	dlist_head	cc_lists;		/* list of CatCList structs */
  #ifdef CATCACHE_STATS
  	long		cc_searches;	/* total # searches against this cache */
  	long		cc_hits;		/* # of matches against existing entry */
***************
*** 66,72 **** typedef struct catcache
  	long		cc_lsearches;	/* total # list-searches */
  	long		cc_lhits;		/* # of matches against existing lists */
  #endif
! 	Dllist		cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
  } CatCache;						/* VARIABLE LENGTH STRUCT */
  
  
--- 66,72 ----
  	long		cc_lsearches;	/* total # list-searches */
  	long		cc_lhits;		/* # of matches against existing lists */
  #endif
! 	dlist_head	cc_bucket[1];	/* hash buckets --- VARIABLE LENGTH ARRAY */
  } CatCache;						/* VARIABLE LENGTH STRUCT */
  
  
***************
*** 77,87 **** typedef struct catctup
  	CatCache   *my_cache;		/* link to owning catcache */
  
  	/*
! 	 * Each tuple in a cache is a member of a Dllist that stores the elements
! 	 * of its hash bucket.	We keep each Dllist in LRU order to speed repeated
  	 * lookups.
  	 */
! 	Dlelem		cache_elem;		/* list member of per-bucket list */
  
  	/*
  	 * The tuple may also be a member of at most one CatCList.	(If a single
--- 77,88 ----
  	CatCache   *my_cache;		/* link to owning catcache */
  
  	/*
! 	 * Each tuple in a cache is a member of a dlist that stores the elements
! 	 * of its hash bucket.	We keep each dlist in LRU order to speed repeated
  	 * lookups.
  	 */
! 	dlist_node	cache_elem;		/* list member of per-bucket list */
! 	dlist_head *cache_bucket;	/* containing bucket dlist */
  
  	/*
  	 * The tuple may also be a member of at most one CatCList.	(If a single
***************
*** 139,145 **** typedef struct catclist
  	 * might not be true during bootstrap or recovery operations. (namespace.c
  	 * is able to save some cycles when it is true.)
  	 */
! 	Dlelem		cache_elem;		/* list member of per-catcache list */
  	int			refcount;		/* number of active references */
  	bool		dead;			/* dead but not yet removed? */
  	bool		ordered;		/* members listed in index order? */
--- 140,146 ----
  	 * might not be true during bootstrap or recovery operations. (namespace.c
  	 * is able to save some cycles when it is true.)
  	 */
! 	dlist_node	cache_elem;		/* list member of per-catcache list */
  	int			refcount;		/* number of active references */
  	bool		dead;			/* dead but not yet removed? */
  	bool		ordered;		/* members listed in index order? */
***************
*** 153,159 **** typedef struct catclist
  
  typedef struct catcacheheader
  {
! 	CatCache   *ch_caches;		/* head of list of CatCache structs */
  	int			ch_ntup;		/* # of tuples in all caches */
  } CatCacheHeader;
  
--- 154,160 ----
  
  typedef struct catcacheheader
  {
! 	slist_head	ch_caches;		/* head of list of CatCache structs */
  	int			ch_ntup;		/* # of tuples in all caches */
  } CatCacheHeader;