Optimize Query jumble

f31aad9b0 adjusted query jumbling so it no longer ignores NULL nodes
during the jumble.  This added some overhead.  Here we tune a few
things to make jumbling faster again.  This makes jumbling perform
similar or even slightly faster than prior to that change.

Author: David Rowley <dgrowleyml@gmail.com>
Reviewed-by: Michael Paquier <michael@paquier.xyz>
Discussion: https://postgr.es/m/CAApHDvreP04nhTKuYsPw0F-YN+4nr4f=L72SPeFb81jfv+2c7w@mail.gmail.com

diff --git a/src/backend/nodes/queryjumblefuncs.c b/src/backend/nodes/queryjumblefuncs.c
index c1d7276556756f79dfea780f729593eeabc081df..1d9abd890288aa0fb472cebcb1fb157754346278 100644 (file)
--- a/src/backend/nodes/queryjumblefuncs.c
+++ b/src/backend/nodes/queryjumblefuncs.c
@@ -218,6 +218,8 @@ DoJumble(JumbleState *jstate, Node *node)
 
 /*
  * AppendJumbleInternal: Internal function for appending to the jumble buffer
+ *
+ * Note: Callers must ensure that size > 0.
  */
 static pg_attribute_always_inline void
 AppendJumbleInternal(JumbleState *jstate, const unsigned char *item,
@@ -226,16 +228,36 @@ AppendJumbleInternal(JumbleState *jstate, const unsigned char *item,
    unsigned char *jumble = jstate->jumble;
    Size        jumble_len = jstate->jumble_len;
 
+   /* Ensure the caller didn't mess up */
+   Assert(size > 0);
+
+   /*
+    * Fast path for when there's enough space left in the buffer.  This is
+    * worthwhile as means the memcpy can be inlined into very efficient code
+    * when 'size' is a compile-time constant.
+    */
+   if (likely(size <= JUMBLE_SIZE - jumble_len))
+   {
+       memcpy(jumble + jumble_len, item, size);
+       jstate->jumble_len += size;
+
+#ifdef USE_ASSERT_CHECKING
+       jstate->total_jumble_len += size;
+#endif
+
+       return;
+   }
+
    /*
     * Whenever the jumble buffer is full, we hash the current contents and
     * reset the buffer to contain just that hash value, thus relying on the
     * hash to summarize everything so far.
     */
-   while (size > 0)
+   do
    {
        Size        part_size;
 
-       if (jumble_len >= JUMBLE_SIZE)
+       if (unlikely(jumble_len >= JUMBLE_SIZE))
        {
            uint64      start_hash;
 
@@ -253,7 +275,7 @@ AppendJumbleInternal(JumbleState *jstate, const unsigned char *item,
 #ifdef USE_ASSERT_CHECKING
        jstate->total_jumble_len += part_size;
 #endif
-   }
+   } while (size > 0);
 
    jstate->jumble_len = jumble_len;
 }
@@ -281,6 +303,61 @@ AppendJumbleNull(JumbleState *jstate)
    jstate->pending_nulls++;
 }
 
+/*
+ * AppendJumble8
+ *     Add the first byte from the given 'value' pointer to the jumble state
+ */
+static pg_noinline void
+AppendJumble8(JumbleState *jstate, const unsigned char *value)
+{
+   if (jstate->pending_nulls > 0)
+       FlushPendingNulls(jstate);
+
+   AppendJumbleInternal(jstate, value, 1);
+}
+
+/*
+ * AppendJumble16
+ *     Add the first 2 bytes from the given 'value' pointer to the jumble
+ *     state.
+ */
+static pg_noinline void
+AppendJumble16(JumbleState *jstate, const unsigned char *value)
+{
+   if (jstate->pending_nulls > 0)
+       FlushPendingNulls(jstate);
+
+   AppendJumbleInternal(jstate, value, 2);
+}
+
+/*
+ * AppendJumble32
+ *     Add the first 4 bytes from the given 'value' pointer to the jumble
+ *     state.
+ */
+static pg_noinline void
+AppendJumble32(JumbleState *jstate, const unsigned char *value)
+{
+   if (jstate->pending_nulls > 0)
+       FlushPendingNulls(jstate);
+
+   AppendJumbleInternal(jstate, value, 4);
+}
+
+/*
+ * AppendJumble64
+ *     Add the first 8 bytes from the given 'value' pointer to the jumble
+ *     state.
+ */
+static pg_noinline void
+AppendJumble64(JumbleState *jstate, const unsigned char *value)
+{
+   if (jstate->pending_nulls > 0)
+       FlushPendingNulls(jstate);
+
+   AppendJumbleInternal(jstate, value, 8);
+}
+
 /*
  * FlushPendingNulls
  *     Incorporate the pending_null value into the jumble buffer.
@@ -417,9 +494,18 @@ IsSquashableConstList(List *elements, Node **firstExpr, Node **lastExpr)
 #define JUMBLE_LOCATION(location) \
    RecordConstLocation(jstate, expr->location, false)
 #define JUMBLE_FIELD(item) \
-   AppendJumble(jstate, (const unsigned char *) &(expr->item), sizeof(expr->item))
-#define JUMBLE_FIELD_SINGLE(item) \
-   AppendJumble(jstate, (const unsigned char *) &(item), sizeof(item))
+do { \
+   if (sizeof(expr->item) == 8) \
+       AppendJumble64(jstate, (const unsigned char *) &(expr->item)); \
+   else if (sizeof(expr->item) == 4) \
+       AppendJumble32(jstate, (const unsigned char *) &(expr->item)); \
+   else if (sizeof(expr->item) == 2) \
+       AppendJumble16(jstate, (const unsigned char *) &(expr->item)); \
+   else if (sizeof(expr->item) == 1) \
+       AppendJumble8(jstate, (const unsigned char *) &(expr->item)); \
+   else \
+       AppendJumble(jstate, (const unsigned char *) &(expr->item), sizeof(expr->item)); \
+} while (0)
 #define JUMBLE_STRING(str) \
 do { \
    if (expr->str) \
@@ -551,15 +637,15 @@ _jumbleList(JumbleState *jstate, Node *node)
            break;
        case T_IntList:
            foreach(l, expr)
-               JUMBLE_FIELD_SINGLE(lfirst_int(l));
+               AppendJumble32(jstate, (const unsigned char *) &lfirst_int(l));
            break;
        case T_OidList:
            foreach(l, expr)
-               JUMBLE_FIELD_SINGLE(lfirst_oid(l));
+               AppendJumble32(jstate, (const unsigned char *) &lfirst_oid(l));
            break;
        case T_XidList:
            foreach(l, expr)
-               JUMBLE_FIELD_SINGLE(lfirst_xid(l));
+               AppendJumble32(jstate, (const unsigned char *) &lfirst_xid(l));
            break;
        default:
            elog(ERROR, "unrecognized list node type: %d",