First attempt at CHashDelete - slightly incomplete, and untested.

diff --git a/src/backend/utils/hash/chash.c b/src/backend/utils/hash/chash.c
index dd40413694be6043230539afc8e929fc2325aad0..6893a36d81459c2529be51c3c0f5725656ed0632 100644 (file)
--- a/src/backend/utils/hash/chash.c
+++ b/src/backend/utils/hash/chash.c
@@ -548,6 +548,106 @@ retry:
        return !found;
 }
 
+/*
+ * Delete from a concurrent hash table.  entry need only contain the key field.
+ * Returns true if we find and delete a matching key and false otherwise.
+ */
+bool
+CHashDelete(CHashTable table, void *entry)
+{
+       uint32  hashcode = hash_any(entry, table->desc.key_size);
+       uint32  bucket = hashcode & table->bucket_mask;
+       CHashPtr        c;
+       volatile CHashPtr   *p;
+       volatile CHashNode  *n;
+       bool            found = false;
+
+       /* Suppress garbage collection for target bucket. */
+       CHashTableSuppressGC(table, bucket);
+
+       /* Scan bucket. */
+retry:
+       p = &table->bucket[bucket].head;
+       c = *p;
+       while (c != InvalidCHashPtr)
+       {
+               int             cmp;
+               uint32  h;
+
+               /* Compare current node by hashcode, then by memcmp. */
+               n = CHashTableGetNode(table, c);
+               pg_read_barrier_depends();
+               h = n->un.hashcode;
+               if (h == hashcode)
+                       cmp = memcmp(CHashNodeGetItem(n), entry, table->desc.key_size);
+               else if (h > hashcode)
+                       cmp = 1;
+               else
+                       cmp = -1;
+
+               /* If we found the key, or passed where it should be, we're done. */
+               if (cmp >= 0)
+               {
+                       found = (cmp == 0);
+                       break;
+               }
+
+               /* Move to next node. */
+               p = &n->next;
+               c = *p;
+
+               /*
+                * We can't safely update a delete-marked pointer, so remove any
+                * such pointers we find from the bucket chain.  Sometimes, concurrent
+                * activity may force us to restart the whole scan, but that should
+                * be rare.
+                */
+               if (CHashPtrIsMarked(c) && CHashRemoveMarked(table, bucket, &c, p))
+                       goto retry;
+       }
+
+       if (found)
+       {
+               CHashPtr        cc;
+               bool            needs_cleanup = false;
+
+               /*
+                * Really do the deletion.  Since we've held no lock up to this
+                * point, it may well be that someone else has deleted the item out
+                * from under us, so we recheck that after taking the lock.
+                */
+               SpinLockAcquire(&table->bucket[bucket].mutex);
+               cc = n->next;
+               if (CHashPtrIsMarked(cc))
+                       found = false;
+               else
+               {
+                       n->next = CHashPtrMark(cc);
+                       if (*p == c)
+                               *p = cc;
+                       else
+                               needs_cleanup = true;
+               }
+               SpinLockRelease(&table->bucket[bucket].mutex);
+
+               /*
+                * At this point the deletion is done.  However, it's possible that
+                * we weren't able to redirect the pointer that formerly addressed the
+                * deleted item.  If so, rescan the bucket chain and excise any deleted
+                * items in the chain.  We don't have to worry about not finding it;
+                * that just means someone else did the work for us.
+                */
+               if (needs_cleanup)
+               {
+                       /* XXX */
+               }
+       }
+
+       /* We're done. */
+       CHashTableUnsuppressGC();
+       return found;
+}
+
 /*
  * Allocate an arena slot for a new item to be inserted into a hash table.
  *