Basic planner and executor integration for JIT.

This adds simple cost based plan time decision about whether JIT
should be performed. jit_above_cost, jit_optimize_above_cost are
compared with the total cost of a plan, and if the cost is above them
JIT is performed / optimization is performed respectively.

For that PlannedStmt and EState have a jitFlags (es_jit_flags) field
that stores information about what JIT operations should be performed.

EState now also has a new es_jit field, which can store a
JitContext. When there are no errors the context is released in
standard_ExecutorEnd().

It is likely that the default values for jit_[optimize_]above_cost
will need to be adapted further, but in my test these values seem to
work reasonably.

Author: Andres Freund, with feedback by Peter Eisentraut
Discussion: https://postgr.es/m/20170901064131.tazjxwus3k2w3ybh@alap3.anarazel.de

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 91ba939bdcade9e58db4f246abdcc215b89da908..890067757c0c8f71de5b7511e0ecf17155481847 100644 (file)
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -48,6 +48,7 @@
 #include "commands/trigger.h"
 #include "executor/execdebug.h"
 #include "foreign/fdwapi.h"
+#include "jit/jit.h"
 #include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "optimizer/clauses.h"
@@ -249,6 +250,9 @@ standard_ExecutorStart(QueryDesc *queryDesc, int eflags)
        estate->es_top_eflags = eflags;
        estate->es_instrument = queryDesc->instrument_options;
 
+       if (queryDesc->plannedstmt)
+               estate->es_jit_flags = queryDesc->plannedstmt->jitFlags;
+
        /*
         * Set up an AFTER-trigger statement context, unless told not to, or
         * unless it's EXPLAIN-only mode (when ExecutorFinish won't be called).
@@ -496,6 +500,10 @@ standard_ExecutorEnd(QueryDesc *queryDesc)
        UnregisterSnapshot(estate->es_snapshot);
        UnregisterSnapshot(estate->es_crosscheck_snapshot);
 
+       /* release JIT context, if allocated */
+       if (estate->es_jit)
+               jit_release_context(estate->es_jit);
+
        /*
         * Must switch out of context before destroying it
         */

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index 14b0b89463cd67fb0a21147301a299bb58620806..52f1a96db5faf24c7c954a9f7182a8929c2e0511 100644 (file)
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -73,6 +73,7 @@ typedef struct FixedParallelExecutorState
        int64           tuples_needed;  /* tuple bound, see ExecSetTupleBound */
        dsa_pointer param_exec;
        int                     eflags;
+       int                     jit_flags;
 } FixedParallelExecutorState;
 
 /*
@@ -680,6 +681,7 @@ ExecInitParallelPlan(PlanState *planstate, EState *estate,
        fpes->tuples_needed = tuples_needed;
        fpes->param_exec = InvalidDsaPointer;
        fpes->eflags = estate->es_top_eflags;
+       fpes->jit_flags = estate->es_jit_flags;
        shm_toc_insert(pcxt->toc, PARALLEL_KEY_EXECUTOR_FIXED, fpes);
 
        /* Store query string */
@@ -1287,6 +1289,7 @@ ParallelQueryMain(dsm_segment *seg, shm_toc *toc)
        area = dsa_attach_in_place(area_space, seg);
 
        /* Start up the executor */
+       queryDesc->plannedstmt->jitFlags = fpes->jit_flags;
        ExecutorStart(queryDesc, fpes->eflags);
 
        /* Special executor initialization steps for parallel workers */

diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index a8ae37ebc80c2af75f3e255e67d77737ae3cd1ed..14b07b5d449ce0d2f3975d2b85ecf61bd45d3545 100644 (file)
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -158,6 +158,9 @@ CreateExecutorState(void)
 
        estate->es_use_parallel_mode = false;
 
+       estate->es_jit_flags = 0;
+       estate->es_jit = NULL;
+
        /*
         * Return the executor state structure
         */

diff --git a/src/backend/jit/jit.c b/src/backend/jit/jit.c
index c17df1c985e1eeafb26ed7f7c2eabfea5854f190..1d74ec8c91a3c21cd94998934a19baa011b3dcfc 100644 (file)
--- a/src/backend/jit/jit.c
+++ b/src/backend/jit/jit.c
@@ -36,6 +36,8 @@ char     *jit_provider = "llvmjit";
 bool           jit_debugging_support = false;
 bool           jit_dump_bitcode = false;
 bool           jit_profiling_support = false;
+double         jit_above_cost = 100000;
+double         jit_optimize_above_cost = 500000;
 
 static JitProviderCallbacks provider;
 static bool provider_successfully_loaded = false;

diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 3ad4da64aafd8ce4ada56652ddf2009dfb826968..c7293a60d7863abd4ea05b05729610d8409ae6ee 100644 (file)
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -87,6 +87,7 @@ _copyPlannedStmt(const PlannedStmt *from)
        COPY_SCALAR_FIELD(transientPlan);
        COPY_SCALAR_FIELD(dependsOnRole);
        COPY_SCALAR_FIELD(parallelModeNeeded);
+       COPY_SCALAR_FIELD(jitFlags);
        COPY_NODE_FIELD(planTree);
        COPY_NODE_FIELD(rtable);
        COPY_NODE_FIELD(resultRelations);

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index fd8089195484f3536cc56a479ac698e246bac7c3..f61ae03ac505b475bcb7ee54941bf880bf289607 100644 (file)
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -272,6 +272,7 @@ _outPlannedStmt(StringInfo str, const PlannedStmt *node)
        WRITE_BOOL_FIELD(transientPlan);
        WRITE_BOOL_FIELD(dependsOnRole);
        WRITE_BOOL_FIELD(parallelModeNeeded);
+       WRITE_BOOL_FIELD(jitFlags);
        WRITE_NODE_FIELD(planTree);
        WRITE_NODE_FIELD(rtable);
        WRITE_NODE_FIELD(resultRelations);

diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index 068db353d70c590dfabae793cf15b5061e804580..fd4586e73d52d3a6fe865adf0dc6b95129e7270d 100644 (file)
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -1475,6 +1475,7 @@ _readPlannedStmt(void)
        READ_BOOL_FIELD(transientPlan);
        READ_BOOL_FIELD(dependsOnRole);
        READ_BOOL_FIELD(parallelModeNeeded);
+       READ_BOOL_FIELD(jitFlags);
        READ_NODE_FIELD(planTree);
        READ_NODE_FIELD(rtable);
        READ_NODE_FIELD(resultRelations);

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 54f2da70cb1c49b70f32e81a343a69a736221547..3668db4e09ee87cd96454a741a5eb69d2d922662 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -29,6 +29,7 @@
 #include "executor/nodeAgg.h"
 #include "foreign/fdwapi.h"
 #include "miscadmin.h"
+#include "jit/jit.h"
 #include "lib/bipartite_match.h"
 #include "lib/knapsack.h"
 #include "nodes/makefuncs.h"
@@ -531,6 +532,20 @@ standard_planner(Query *parse, int cursorOptions, ParamListInfo boundParams)
        result->stmt_location = parse->stmt_location;
        result->stmt_len = parse->stmt_len;
 
+       result->jitFlags = PGJIT_NONE;
+       if (jit_enabled && jit_above_cost >= 0 &&
+               top_plan->total_cost > jit_above_cost)
+       {
+               result->jitFlags |= PGJIT_PERFORM;
+
+               /*
+                * Decide how much effort should be put into generating better code.
+                */
+               if (jit_optimize_above_cost >= 0 &&
+                       top_plan->total_cost > jit_optimize_above_cost)
+                       result->jitFlags |= PGJIT_OPT3;
+       }
+
        return result;
 }
 

diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index 8e09e083069402d66b73b91ee3edff11e673a7a9..978c8757c64bc805f65f0cc94eeb39c020529801 100644 (file)
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -3075,6 +3075,26 @@ static struct config_real ConfigureNamesReal[] =
                NULL, NULL, NULL
        },
 
+       {
+               {"jit_above_cost", PGC_USERSET, QUERY_TUNING_COST,
+                       gettext_noop("Perform JIT compilation if query is more expensive."),
+                       gettext_noop("-1 disables JIT compilation.")
+               },
+               &jit_above_cost,
+               100000, -1, DBL_MAX,
+               NULL, NULL, NULL
+       },
+
+       {
+               {"jit_optimize_above_cost", PGC_USERSET, QUERY_TUNING_COST,
+                       gettext_noop("Optimize JITed functions if query is more expensive."),
+                       gettext_noop("-1 disables optimization.")
+               },
+               &jit_optimize_above_cost,
+               500000, -1, DBL_MAX,
+               NULL, NULL, NULL
+       },
+
        {
                {"cursor_tuple_fraction", PGC_USERSET, QUERY_TUNING_OTHER,
                        gettext_noop("Sets the planner's estimate of the fraction of "

diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index 1e0f411c4024fc2035aea48ae59ace67142af2b1..4b692dc3e5d1d992803f2166d7bc78816eef2d73 100644 (file)
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -318,6 +318,12 @@
 #cpu_operator_cost = 0.0025            # same scale as above
 #parallel_tuple_cost = 0.1             # same scale as above
 #parallel_setup_cost = 1000.0  # same scale as above
+
+#jit_above_cost = 100000               # perform JIT compilation if available
+                                       # and query more expensive, -1 disables
+#jit_optimize_above_cost = 500000      # optimize JITed functions if query is
+                                       # more expensive, -1 disables
+
 #min_parallel_table_scan_size = 8MB
 #min_parallel_index_scan_size = 512kB
 #effective_cache_size = 4GB

diff --git a/src/include/jit/jit.h b/src/include/jit/jit.h
index 2c21c2d27b7a5fdb8eb870378ece30a73e70ccde..dac8d593eb08cdf2caefc3d3dc9f47969ad4fe94 100644 (file)
--- a/src/include/jit/jit.h
+++ b/src/include/jit/jit.h
@@ -61,6 +61,8 @@ extern char *jit_provider;
 extern bool jit_debugging_support;
 extern bool jit_dump_bitcode;
 extern bool jit_profiling_support;
+extern double jit_above_cost;
+extern double jit_optimize_above_cost;
 
 
 extern void jit_reset_after_error(void);

diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index d9e591802fefafa8291d2119088b540fc34ba8ae..7b752560c60fdbad4fabdda6eed3593387d9f1d8 100644 (file)
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -528,6 +528,14 @@ typedef struct EState
 
        /* The per-query shared memory area to use for parallel execution. */
        struct dsa_area *es_query_dsa;
+
+       /*
+        * JIT information. es_jit_flags indicates whether JIT should be performed
+        * and with which options.  es_jit is created on-demand when JITing is
+        * performed.
+        */
+       int                     es_jit_flags;
+       struct JitContext *es_jit;
 } EState;
 
 

diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h
index f2e19eae68fceca81e12600e8c914d62eceb880e..c922216b7d152ecb2ef0f6771c2ea9e226bd9209 100644 (file)
--- a/src/include/nodes/plannodes.h
+++ b/src/include/nodes/plannodes.h
@@ -58,6 +58,8 @@ typedef struct PlannedStmt
 
        bool            parallelModeNeeded; /* parallel mode required to execute? */
 
+       int                     jitFlags;               /* which forms of JIT should be performed */
+
        struct Plan *planTree;          /* tree of Plan nodes */
 
        List       *rtable;                     /* list of RangeTblEntry nodes */