Add special case fast-paths for strict functions

Many STRICT function calls will have one or two arguments, in which
case we can speed up checking for NULL input by avoiding setting up
a loop over the arguments. This adds EEOP_FUNCEXPR_STRICT_1 and the
corresponding EEOP_FUNCEXPR_STRICT_2 for functions with one and two
arguments respectively.

Author: Andres Freund <[email protected]>
Co-authored-by: Daniel Gustafsson <[email protected]>
Reviewed-by: Andreas Karlsson <[email protected]>
Discussion: https://postgr.es/m/415721CE-7D2E-4B74-B5D9-1950083BA03E@yesql.se
Discussion: https://postgr.es/m/20191023163849[email protected]

diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c
index 0175b152980194c7db498d276d4635135a964d9d..f1569879b529d5390dc5c43f4ff3c045a64de11b 100644 (file)
--- a/src/backend/executor/execExpr.c
+++ b/src/backend/executor/execExpr.c
@@ -2788,7 +2788,15 @@ ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args, Oid funcid,
    if (pgstat_track_functions <= flinfo->fn_stats)
    {
        if (flinfo->fn_strict && nargs > 0)
-           scratch->opcode = EEOP_FUNCEXPR_STRICT;
+       {
+           /* Choose nargs optimized implementation if available. */
+           if (nargs == 1)
+               scratch->opcode = EEOP_FUNCEXPR_STRICT_1;
+           else if (nargs == 2)
+               scratch->opcode = EEOP_FUNCEXPR_STRICT_2;
+           else
+               scratch->opcode = EEOP_FUNCEXPR_STRICT;
+       }
        else
            scratch->opcode = EEOP_FUNCEXPR;
    }
@@ -3892,6 +3900,8 @@ ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
        {
            if (strictnulls)
                scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_NULLS;
+           else if (strictargs && pertrans->numTransInputs == 1)
+               scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1;
            else
                scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_ARGS;
            scratch.d.agg_strict_input_check.nulls = strictnulls;
@@ -3968,6 +3978,7 @@ ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
                as->d.jump.jumpdone = state->steps_len;
            }
            else if (as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_ARGS ||
+                    as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1 ||
                     as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
            {
                Assert(as->d.agg_strict_input_check.jumpnull == -1);

diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index 491ecad8dc664c8e12f8269a51432a4cb4bbbcc6..8a72b5e70a4ec7c09a5ddb29b1eb4b6dd05b0c80 100644 (file)
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -366,7 +366,9 @@ ExecReadyInterpretedExpr(ExprState *state)
            return;
        }
        else if (step0 == EEOP_CASE_TESTVAL &&
-                step1 == EEOP_FUNCEXPR_STRICT)
+                (step1 == EEOP_FUNCEXPR_STRICT ||
+                 step1 == EEOP_FUNCEXPR_STRICT_1 ||
+                 step1 == EEOP_FUNCEXPR_STRICT_2))
        {
            state->evalfunc_private = ExecJustApplyFuncToCase;
            return;
@@ -498,6 +500,8 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
        &&CASE_EEOP_CONST,
        &&CASE_EEOP_FUNCEXPR,
        &&CASE_EEOP_FUNCEXPR_STRICT,
+       &&CASE_EEOP_FUNCEXPR_STRICT_1,
+       &&CASE_EEOP_FUNCEXPR_STRICT_2,
        &&CASE_EEOP_FUNCEXPR_FUSAGE,
        &&CASE_EEOP_FUNCEXPR_STRICT_FUSAGE,
        &&CASE_EEOP_BOOL_AND_STEP_FIRST,
@@ -575,6 +579,7 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
        &&CASE_EEOP_AGG_STRICT_DESERIALIZE,
        &&CASE_EEOP_AGG_DESERIALIZE,
        &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_ARGS,
+       &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1,
        &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_NULLS,
        &&CASE_EEOP_AGG_PLAIN_PERGROUP_NULLCHECK,
        &&CASE_EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL,
@@ -925,6 +930,7 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
            EEO_NEXT();
        }
 
+       /* strict function call with more than two arguments */
        EEO_CASE(EEOP_FUNCEXPR_STRICT)
        {
            FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
@@ -932,6 +938,8 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
            int         nargs = op->d.func.nargs;
            Datum       d;
 
+           Assert(nargs > 2);
+
            /* strict function, so check for NULL args */
            for (int argno = 0; argno < nargs; argno++)
            {
@@ -950,6 +958,54 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
            EEO_NEXT();
        }
 
+       /* strict function call with one argument */
+       EEO_CASE(EEOP_FUNCEXPR_STRICT_1)
+       {
+           FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
+           NullableDatum *args = fcinfo->args;
+
+           Assert(op->d.func.nargs == 1);
+
+           /* strict function, so check for NULL args */
+           if (args[0].isnull)
+               *op->resnull = true;
+           else
+           {
+               Datum       d;
+
+               fcinfo->isnull = false;
+               d = op->d.func.fn_addr(fcinfo);
+               *op->resvalue = d;
+               *op->resnull = fcinfo->isnull;
+           }
+
+           EEO_NEXT();
+       }
+
+       /* strict function call with two arguments */
+       EEO_CASE(EEOP_FUNCEXPR_STRICT_2)
+       {
+           FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
+           NullableDatum *args = fcinfo->args;
+
+           Assert(op->d.func.nargs == 2);
+
+           /* strict function, so check for NULL args */
+           if (args[0].isnull || args[1].isnull)
+               *op->resnull = true;
+           else
+           {
+               Datum       d;
+
+               fcinfo->isnull = false;
+               d = op->d.func.fn_addr(fcinfo);
+               *op->resvalue = d;
+               *op->resnull = fcinfo->isnull;
+           }
+
+           EEO_NEXT();
+       }
+
        EEO_CASE(EEOP_FUNCEXPR_FUSAGE)
        {
            /* not common enough to inline */
@@ -1982,11 +2038,14 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
         * input is not NULL.
         */
 
+       /* when checking more than one argument */
        EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_ARGS)
        {
            NullableDatum *args = op->d.agg_strict_input_check.args;
            int         nargs = op->d.agg_strict_input_check.nargs;
 
+           Assert(nargs > 1);
+
            for (int argno = 0; argno < nargs; argno++)
            {
                if (args[argno].isnull)
@@ -1995,6 +2054,19 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
            EEO_NEXT();
        }
 
+       /* special case for just one argument */
+       EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1)
+       {
+           NullableDatum *args = op->d.agg_strict_input_check.args;
+           PG_USED_FOR_ASSERTS_ONLY int nargs = op->d.agg_strict_input_check.nargs;
+
+           Assert(nargs == 1);
+
+           if (args[0].isnull)
+               EEO_JUMP(op->d.agg_strict_input_check.jumpnull);
+           EEO_NEXT();
+       }
+
        EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
        {
            bool       *nulls = op->d.agg_strict_input_check.nulls;

diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index 4080b01c17e01cc8558fe1c6500d67a7781c1654..890bcb0b0a79dfd5f347e6f683300f4ba9afb217 100644 (file)
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -662,12 +662,16 @@ llvm_compile_expr(ExprState *state)
 
            case EEOP_FUNCEXPR:
            case EEOP_FUNCEXPR_STRICT:
+           case EEOP_FUNCEXPR_STRICT_1:
+           case EEOP_FUNCEXPR_STRICT_2:
                {
                    FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
                    LLVMValueRef v_fcinfo_isnull;
                    LLVMValueRef v_retval;
 
-                   if (opcode == EEOP_FUNCEXPR_STRICT)
+                   if (opcode == EEOP_FUNCEXPR_STRICT ||
+                       opcode == EEOP_FUNCEXPR_STRICT_1 ||
+                       opcode == EEOP_FUNCEXPR_STRICT_2)
                    {
                        LLVMBasicBlockRef b_nonull;
                        LLVMBasicBlockRef *b_checkargnulls;
@@ -2482,6 +2486,7 @@ llvm_compile_expr(ExprState *state)
                }
 
            case EEOP_AGG_STRICT_INPUT_CHECK_ARGS:
+           case EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1:
            case EEOP_AGG_STRICT_INPUT_CHECK_NULLS:
                {
                    int         nargs = op->d.agg_strict_input_check.nargs;

diff --git a/src/include/executor/execExpr.h b/src/include/executor/execExpr.h
index fabdf145a8ee6bb9a1507846b86d391fe7c5827a..75366203706cf45820fced8f41868024fd47b537 100644 (file)
--- a/src/include/executor/execExpr.h
+++ b/src/include/executor/execExpr.h
@@ -116,11 +116,13 @@ typedef enum ExprEvalOp
 
    /*
     * Evaluate function call (including OpExprs etc).  For speed, we
-    * distinguish in the opcode whether the function is strict and/or
-    * requires usage stats tracking.
+    * distinguish in the opcode whether the function is strict with 1, 2, or
+    * more arguments and/or requires usage stats tracking.
     */
    EEOP_FUNCEXPR,
    EEOP_FUNCEXPR_STRICT,
+   EEOP_FUNCEXPR_STRICT_1,
+   EEOP_FUNCEXPR_STRICT_2,
    EEOP_FUNCEXPR_FUSAGE,
    EEOP_FUNCEXPR_STRICT_FUSAGE,
 
@@ -276,6 +278,7 @@ typedef enum ExprEvalOp
    EEOP_AGG_STRICT_DESERIALIZE,
    EEOP_AGG_DESERIALIZE,
    EEOP_AGG_STRICT_INPUT_CHECK_ARGS,
+   EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1,
    EEOP_AGG_STRICT_INPUT_CHECK_NULLS,
    EEOP_AGG_PLAIN_PERGROUP_NULLCHECK,
    EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL,