From d35d32d7112bc632c6a305e9dffdec0082bbdf00 Mon Sep 17 00:00:00 2001 From: Daniel Gustafsson Date: Tue, 11 Mar 2025 12:02:42 +0100 Subject: [PATCH] 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 Co-authored-by: Daniel Gustafsson Reviewed-by: Andreas Karlsson Discussion: https://postgr.es/m/415721CE-7D2E-4B74-B5D9-1950083BA03E@yesql.se Discussion: https://postgr.es/m/20191023163849.sosqbfs5yenocez3@alap3.anarazel.de --- src/backend/executor/execExpr.c | 13 ++++- src/backend/executor/execExprInterp.c | 74 ++++++++++++++++++++++++++- src/backend/jit/llvm/llvmjit_expr.c | 7 ++- src/include/executor/execExpr.h | 7 ++- 4 files changed, 96 insertions(+), 5 deletions(-) diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c index 0175b152980..f1569879b52 100644 --- 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 491ecad8dc6..8a72b5e70a4 100644 --- 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 4080b01c17e..890bcb0b0a7 100644 --- 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 fabdf145a8e..75366203706 100644 --- 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, -- 2.30.2