Speed up CREATE INDEX CONCURRENTLY's TID sort.

Encode TIDs as 64-bit integers to speed up comparisons.  This seems to
speed things up on all platforms, but is even more beneficial when
8-byte integers are passed by value.

Peter Geoghegan.  Design suggestions and review by Tom Lane.  Review
also by Simon Riggs and by me.

diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index e59b163173c611f0605ed8e255debcfec0225f5b..c10be3d6996aa74d27881827643bdc2a814f0a63 100644 (file)
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -109,6 +109,8 @@ static void index_update_stats(Relation rel,
 static void IndexCheckExclusion(Relation heapRelation,
                    Relation indexRelation,
                    IndexInfo *indexInfo);
+static inline int64 itemptr_encode(ItemPointer itemptr);
+static inline void itemptr_decode(ItemPointer itemptr, int64 encoded);
 static bool validate_index_callback(ItemPointer itemptr, void *opaque);
 static void validate_index_heapscan(Relation heapRelation,
                        Relation indexRelation,
@@ -2832,7 +2834,13 @@ validate_index(Oid heapId, Oid indexId, Snapshot snapshot)
    ivinfo.num_heap_tuples = heapRelation->rd_rel->reltuples;
    ivinfo.strategy = NULL;
 
-   state.tuplesort = tuplesort_begin_datum(TIDOID, TIDLessOperator,
+   /*
+    * Encode TIDs as int8 values for the sort, rather than directly sorting
+    * item pointers.  This can be significantly faster, primarily because TID
+    * is a pass-by-reference type on all platforms, whereas int8 is
+    * pass-by-value on most platforms.
+    */
+   state.tuplesort = tuplesort_begin_datum(INT8OID, Int8LessOperator,
                                            InvalidOid, false,
                                            maintenance_work_mem,
                                            false);
@@ -2871,6 +2879,46 @@ validate_index(Oid heapId, Oid indexId, Snapshot snapshot)
    heap_close(heapRelation, NoLock);
 }
 
+/*
+ * itemptr_encode - Encode ItemPointer as int64/int8
+ *
+ * This representation must produce values encoded as int64 that sort in the
+ * same order as their corresponding original TID values would (using the
+ * default int8 opclass to produce a result equivalent to the default TID
+ * opclass).
+ *
+ * As noted in validate_index(), this can be significantly faster.
+ */
+static inline int64
+itemptr_encode(ItemPointer itemptr)
+{
+   BlockNumber     block = ItemPointerGetBlockNumber(itemptr);
+   OffsetNumber    offset = ItemPointerGetOffsetNumber(itemptr);
+   int64           encoded;
+
+   /*
+    * Use the 16 least significant bits for the offset.  32 adjacent bits are
+    * used for the block number.  Since remaining bits are unused, there
+    * cannot be negative encoded values (We assume a two's complement
+    * representation).
+    */
+   encoded = ((uint64) block << 16) | (uint16) offset;
+
+   return encoded;
+}
+
+/*
+ * itemptr_decode - Decode int64/int8 representation back to ItemPointer
+ */
+static inline void
+itemptr_decode(ItemPointer itemptr, int64 encoded)
+{
+   BlockNumber     block = (BlockNumber) (encoded >> 16);
+   OffsetNumber    offset = (OffsetNumber) (encoded & 0xFFFF);
+
+   ItemPointerSet(itemptr, block, offset);
+}
+
 /*
  * validate_index_callback - bulkdelete callback to collect the index TIDs
  */
@@ -2878,8 +2926,9 @@ static bool
 validate_index_callback(ItemPointer itemptr, void *opaque)
 {
    v_i_state  *state = (v_i_state *) opaque;
+   int64       encoded = itemptr_encode(itemptr);
 
-   tuplesort_putdatum(state->tuplesort, PointerGetDatum(itemptr), false);
+   tuplesort_putdatum(state->tuplesort, Int64GetDatum(encoded), false);
    state->itups += 1;
    return false;               /* never actually delete anything */
 }
@@ -2911,6 +2960,7 @@ validate_index_heapscan(Relation heapRelation,
 
    /* state variables for the merge */
    ItemPointer indexcursor = NULL;
+   ItemPointerData     decoded;
    bool        tuplesort_empty = false;
 
    /*
@@ -3020,13 +3070,26 @@ validate_index_heapscan(Relation heapRelation,
                 */
                if (ItemPointerGetBlockNumber(indexcursor) == root_blkno)
                    in_index[ItemPointerGetOffsetNumber(indexcursor) - 1] = true;
-               pfree(indexcursor);
            }
 
            tuplesort_empty = !tuplesort_getdatum(state->tuplesort, true,
                                                  &ts_val, &ts_isnull);
            Assert(tuplesort_empty || !ts_isnull);
-           indexcursor = (ItemPointer) DatumGetPointer(ts_val);
+           if (!tuplesort_empty)
+           {
+               itemptr_decode(&decoded, DatumGetInt64(ts_val));
+               indexcursor = &decoded;
+
+               /* If int8 is pass-by-ref, free (encoded) TID Datum memory */
+#ifndef USE_FLOAT8_BYVAL
+               pfree(DatumGetPointer(ts_val));
+#endif
+           }
+           else
+           {
+               /* Be tidy */
+               indexcursor = NULL;
+           }
        }
 
        /*