Statistics code.

diff --git a/src/backend/utils/hash/chash.c b/src/backend/utils/hash/chash.c
index f44b65009f3a1a50ff4b8810a6560b12f26908e7..bfcf809d3648fe3636a3f353778a116381ae3578 100644 (file)
--- a/src/backend/utils/hash/chash.c
+++ b/src/backend/utils/hash/chash.c
@@ -158,10 +158,24 @@ typedef struct CHashTableData
    char           *arena;          /* arena */
 
    /*
-    * This field will be different in each backend; the shared copy is
+    * These fields will be different in each backend; the shared copy is
     * unused.
     */
    uint32          gc_next;        /* next garbage list to reclaim */
+   uint64          s_insert_retry; /* insert point concurrently updated */
+   uint64          s_delete_retry; /* delete point concurrently updated */
+   uint64          s_cleanup_scan; /* expunge-after-delete failed */
+   uint64          s_scan_expunge_ok;      /* scan did expunge */
+   uint64          s_scan_expunge_fail;    /* expunge failed */
+   uint64          s_scan_restart;         /* scan restarted */
+   uint64          s_cleanup_expunge_ok;   /* cleanup scan did expunge */
+   uint64          s_cleanup_expunge_fail; /* cleanup scan expunge failed */
+   uint64          s_cleanup_restart;      /* cleanup scan restarted */
+   uint64          s_allocate_pop_fail;    /* freelist pop failed */
+   uint64          s_gc_pop_fail;      /* garbage list pop failed */
+   uint64          s_gc_reclaim_retry; /* failed to return GC'd nodes */
+   uint64          s_garbage_retry;    /* failed to enqueue garbage */
+   uint64          s_free_retry;       /* failed to perform immediate free */
 } CHashTableData;
 
 #define CHashTableGetRaw(table, offset) \
@@ -225,7 +239,7 @@ CHashBootstrap(CHashDescriptor *desc)
    uint32          bucket_shift;
 
    /* Allocate table and copy descriptor. */
-   table = MemoryContextAlloc(TopMemoryContext, sizeof(CHashTableData));
+   table = MemoryContextAllocZero(TopMemoryContext, sizeof(CHashTableData));
    memcpy(&table->desc, desc, sizeof(CHashDescriptor)); 
 
    /* Sanity checks. */
@@ -474,7 +488,10 @@ retry:
        nnew->next = scan.target;
        if (!__sync_bool_compare_and_swap(scan.pointer_to_target,
                                          scan.target, new))
+       {
+           table->s_insert_retry++;
            goto retry;
+       }
    }
 
    /* Allow garbage collection for this bucket. */
@@ -536,6 +553,7 @@ CHashDelete(CHashTable table, void *entry)
                cleanup_scan = true;
            break;
        }
+       table->s_delete_retry++;
    }
 
    /*
@@ -543,7 +561,10 @@ CHashDelete(CHashTable table, void *entry)
     * to make sure it's really gone.
     */
    if (cleanup_scan)
+   {
+       table->s_cleanup_scan++;
        CHashBucketCleanup(table, &table->bucket[bucket], hashcode);
+   }
 
    /* Allow garbage collection for this bucket. */
    CHashTableUnsuppressGC();
@@ -631,6 +652,7 @@ zap:
                 * all non-deleted items (and possibly some deleted items)
                 * that were present at the time we began the scan.
                 */
+               table->s_scan_expunge_ok++;
                CHashAddToGarbage(table, hashcode & table->bucket_mask,
                                  target);
                target = CHashPtrUnmark(next);
@@ -658,9 +680,13 @@ zap:
                 * have to be pretty unlucky to have it happen even twice in
                 * a row.
                 */
+               table->s_scan_expunge_fail++;
                target = *pointer_to_target;
                if (CHashPtrIsMarked(target))
+               {
+                   table->s_scan_restart++;
                    goto retry;
+               }
                continue;
            }
        }
@@ -771,6 +797,7 @@ retry:
                                             CHashPtrUnmark(next)))
            {
                /* We removed the item. */
+               table->s_cleanup_expunge_ok++;
                CHashAddToGarbage(table, hashcode & table->bucket_mask,
                                  target);
                target = CHashPtrUnmark(next);
@@ -845,14 +872,18 @@ CHashAllocate(CHashTable table)
            pg_read_barrier_depends();
            if (__sync_bool_compare_and_swap(b, new, n->un.gcnext))
                return new;
+           table->s_allocate_pop_fail++;
        }
 
        /* If next garbage list is non-empty, empty it via compare-and-swap. */
        table->gc_next = (table->gc_next + 1) % table->ngarbage;
        b = &table->garbage[table->gc_next];
        garbage = *b;
-       if (!CHashPtrIsInvalid(garbage) &&
-           __sync_bool_compare_and_swap(b, garbage, InvalidCHashPtr))
+       if (CHashPtrIsInvalid(garbage))
+           ;
+       else if (!__sync_bool_compare_and_swap(b, garbage, InvalidCHashPtr))
+           ++table->s_gc_pop_fail;
+       else
        {
            uint64      chash_bucket;
            uint32      i;
@@ -905,11 +936,14 @@ CHashAllocate(CHashTable table)
 
                /* Push reclaimed elements onto home free list. */
                b = &table->freelist[f_home];
-               do
+               for (;;)
                {
                    oldhead = *b;
                    n->un.gcnext = oldhead;
-               } while (!__sync_bool_compare_and_swap(b, oldhead, fhead));
+                   if (__sync_bool_compare_and_swap(b, oldhead, fhead))
+                       break;
+                   ++table->s_gc_reclaim_retry;
+               }
            }
 
            /* Return the element we saved for ourselves. */
@@ -943,11 +977,14 @@ CHashAddToGarbage(CHashTable table, uint32 bucket, CHashPtr c)
    n = CHashTableGetNode(table, c);
    garbage = &table->garbage[garbage_bucket];
 
-   do
+   while (1)
    {
        g = *garbage;
        n->un.gcnext = g;
-   } while (!__sync_bool_compare_and_swap(garbage, g, c));
+       if (__sync_bool_compare_and_swap(garbage, g, c))
+           break;
+       ++table->s_garbage_retry;
+   }
 }
 
 /*
@@ -970,9 +1007,12 @@ CHashImmediateFree(CHashTable table, CHashPtr c)
    n = CHashTableGetNode(table, c);
    free = &table->freelist[f_home];
 
-   do
+   for (;;)
    {
        f = *free;
        n->un.gcnext = f;
-   } while (!__sync_bool_compare_and_swap(free, f, c));
+       if (__sync_bool_compare_and_swap(free, f, c))
+           break;
+       ++table->s_free_retry;
+   }
 }