Code rearrangement. Cosmetic only.

diff --git a/src/backend/utils/hash/chash.c b/src/backend/utils/hash/chash.c
index 700a2e93278f34c131eec68fdaf39ac384cf7847..dd77ffaa85c5178a06b9e246fc8ce0c85ac1e49c 100644 (file)
--- a/src/backend/utils/hash/chash.c
+++ b/src/backend/utils/hash/chash.c
@@ -714,6 +714,76 @@ zap:
        res->target_node = target_node;
 }
 
+/*
+ * Scan one bucket of a concurrent hash table and clean up any delete-marked
+ * items by clipping them out of the chain.  This is basically the same logic
+ * as CHashBucketScan, except that we're not searching for an element; the
+ * only purpose is to make sure that there are no residual deleted elements
+ * in the chain.
+ *
+ * In practice this will usually not be necessary, because the next scan of
+ * the relevant bucket will clean it up anyway.  But we want to make sure we
+ * don't have deleted elements eating up our limited storage and making new
+ * inserts fail, so let's be safe.
+ */
+static void
+CHashBucketCleanup(CHashTable table, CHashPtr *start, uint32 hashcode)
+{
+       CHashPtr        target;
+       CHashPtr   *pointer_to_target;
+       CHashNode  *target_node;
+
+retry:
+       pointer_to_target = start;
+       target = *pointer_to_target;
+       for (;;)
+       {
+               CHashPtr        next;
+
+               /*
+                * If we've reached the end of the bucket chain, stop; otherwise,
+                * figure out the actual address of the next item.
+                */
+               if (CHashPtrIsInvalid(target))
+                       break;
+               target_node = CHashTableGetNode(table, target);
+
+               /*
+                * target may have been fetched from an arena entry that could be
+                * concurrently modified, so a dependency barrier is required before
+                * dereferencing the derived pointer.
+                */
+               pg_read_barrier_depends();
+               next = target_node->next;
+
+               /* If element is delete-marked, try to remove it. */
+               if (CHashPtrIsMarked(next))
+               {
+                       if (__sync_bool_compare_and_swap(pointer_to_target,
+                                                                                        target,
+                                                                                        CHashPtrUnmark(next)))
+                       {
+                               /* We removed the item. */
+                               CHashAddToGarbage(table, hashcode & table->bucket_mask,
+                                                                 target);
+                               target = CHashPtrUnmark(next);
+                               continue;
+                       }
+                       else
+                       {
+                               /* Someone else removed the item first. */
+                               target = *pointer_to_target;
+                               if (CHashPtrIsMarked(target))
+                                       goto retry;
+                               continue;
+                       }
+               }
+
+               pointer_to_target = &target_node->next;
+               target = next;
+       }
+}
+
 /*
  * Allocate an arena slot for a new item to be inserted into a hash table.
  *
@@ -899,73 +969,3 @@ CHashImmediateFree(CHashTable table, CHashPtr c)
                n->un.gcnext = f;
        } while (!__sync_bool_compare_and_swap(free, f, c));
 }
-
-/*
- * Scan one bucket of a concurrent hash table and clean up any delete-marked
- * items by clipping them out of the chain.  This is basically the same logic
- * as CHashBucketScan, except that we're not searching for an element; the
- * only purpose is to make sure that there are no residual deleted elements
- * in the chain.
- *
- * In practice this will usually not be necessary, because the next scan of
- * the relevant bucket will clean it up anyway.  But we want to make sure we
- * don't have deleted elements eating up our limited storage and making new
- * inserts fail, so let's be safe.
- */
-static void
-CHashBucketCleanup(CHashTable table, CHashPtr *start, uint32 hashcode)
-{
-       CHashPtr        target;
-       CHashPtr   *pointer_to_target;
-       CHashNode  *target_node;
-
-retry:
-       pointer_to_target = start;
-       target = *pointer_to_target;
-       for (;;)
-       {
-               CHashPtr        next;
-
-               /*
-                * If we've reached the end of the bucket chain, stop; otherwise,
-                * figure out the actual address of the next item.
-                */
-               if (CHashPtrIsInvalid(target))
-                       break;
-               target_node = CHashTableGetNode(table, target);
-
-               /*
-                * target may have been fetched from an arena entry that could be
-                * concurrently modified, so a dependency barrier is required before
-                * dereferencing the derived pointer.
-                */
-               pg_read_barrier_depends();
-               next = target_node->next;
-
-               /* If element is delete-marked, try to remove it. */
-               if (CHashPtrIsMarked(next))
-               {
-                       if (__sync_bool_compare_and_swap(pointer_to_target,
-                                                                                        target,
-                                                                                        CHashPtrUnmark(next)))
-                       {
-                               /* We removed the item. */
-                               CHashAddToGarbage(table, hashcode & table->bucket_mask,
-                                                                 target);
-                               target = CHashPtrUnmark(next);
-                               continue;
-                       }
-                       else
-                       {
-                               /* Someone else removed the item first. */
-                               target = *pointer_to_target;
-                               if (CHashPtrIsMarked(target))
-                                       goto retry;
-                               continue;
-                       }
-               }
-
-               pointer_to_target = &target_node->next;
-               target = next;
-       }
-}