src/backend/jit/jit.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * jit.c
   4  *        Provider independent JIT infrastructure.
   5  *
   6  * Code related to loading JIT providers, redirecting calls into JIT providers
   7  * and error handling.  No code specific to a specific JIT implementation
   8  * should end up here.
   9  *
  10  *
  11  * Copyright (c) 2016-2024, PostgreSQL Global Development Group
  12  *
  13  * IDENTIFICATION
  14  *        src/backend/jit/jit.c
  15  *
  16  *-------------------------------------------------------------------------
  17  */
  18 #include "postgres.h"
  19
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22 #include <unistd.h>
  23
  24 #include "fmgr.h"
  25 #include "jit/jit.h"
  26 #include "miscadmin.h"
  27 #include "nodes/execnodes.h"
  28 #include "portability/instr_time.h"
  29 #include "utils/fmgrprotos.h"
  30
  31 /* GUCs */
  32 bool            jit_enabled = true;
  33 char       *jit_provider = NULL;
  34 bool            jit_debugging_support = false;
  35 bool            jit_dump_bitcode = false;
  36 bool            jit_expressions = true;
  37 bool            jit_profiling_support = false;
  38 bool            jit_tuple_deforming = true;
  39 double          jit_above_cost = 100000;
  40 double          jit_inline_above_cost = 500000;
  41 double          jit_optimize_above_cost = 500000;
  42
  43 static JitProviderCallbacks provider;
  44 static bool provider_successfully_loaded = false;
  45 static bool provider_failed_loading = false;
  46
  47
  48 static bool provider_init(void);
  49
  50
  51 /*
  52  * SQL level function returning whether JIT is available in the current
  53  * backend. Will attempt to load JIT provider if necessary.
  54  */
  55 Datum
  56 pg_jit_available(PG_FUNCTION_ARGS)
  57 {
  58         PG_RETURN_BOOL(provider_init());
  59 }
  60
  61
  62 /*
  63  * Return whether a JIT provider has successfully been loaded, caching the
  64  * result.
  65  */
  66 static bool
  67 provider_init(void)
  68 {
  69         char            path[MAXPGPATH];
  70         JitProviderInit init;
  71
  72         /* don't even try to load if not enabled */
  73         if (!jit_enabled)
  74                 return false;
  75
  76         /*
  77          * Don't retry loading after failing - attempting to load JIT provider
  78          * isn't cheap.
  79          */
  80         if (provider_failed_loading)
  81                 return false;
  82         if (provider_successfully_loaded)
  83                 return true;
  84
  85         /*
  86          * Check whether shared library exists. We do that check before actually
  87          * attempting to load the shared library (via load_external_function()),
  88          * because that'd error out in case the shlib isn't available.
  89          */
  90         snprintf(path, MAXPGPATH, "%s/%s%s", pkglib_path, jit_provider, DLSUFFIX);
  91         elog(DEBUG1, "probing availability of JIT provider at %s", path);
  92         if (!pg_file_exists(path))
  93         {
  94                 elog(DEBUG1,
  95                          "provider not available, disabling JIT for current session");
  96                 provider_failed_loading = true;
  97                 return false;
  98         }
  99
 100         /*
 101          * If loading functions fails, signal failure. We do so because
 102          * load_external_function() might error out despite the above check if
 103          * e.g. the library's dependencies aren't installed. We want to signal
 104          * ERROR in that case, so the user is notified, but we don't want to
 105          * continually retry.
 106          */
 107         provider_failed_loading = true;
 108
 109         /* and initialize */
 110         init = (JitProviderInit)
 111                 load_external_function(path, "_PG_jit_provider_init", true, NULL);
 112         init(&provider);
 113
 114         provider_successfully_loaded = true;
 115         provider_failed_loading = false;
 116
 117         elog(DEBUG1, "successfully loaded JIT provider in current session");
 118
 119         return true;
 120 }
 121
 122 /*
 123  * Reset JIT provider's error handling. This'll be called after an error has
 124  * been thrown and the main-loop has re-established control.
 125  */
 126 void
 127 jit_reset_after_error(void)
 128 {
 129         if (provider_successfully_loaded)
 130                 provider.reset_after_error();
 131 }
 132
 133 /*
 134  * Release resources required by one JIT context.
 135  */
 136 void
 137 jit_release_context(JitContext *context)
 138 {
 139         if (provider_successfully_loaded)
 140                 provider.release_context(context);
 141
 142         pfree(context);
 143 }
 144
 145 /*
 146  * Ask provider to JIT compile an expression.
 147  *
 148  * Returns true if successful, false if not.
 149  */
 150 bool
 151 jit_compile_expr(struct ExprState *state)
 152 {
 153         /*
 154          * We can easily create a one-off context for functions without an
 155          * associated PlanState (and thus EState). But because there's no executor
 156          * shutdown callback that could deallocate the created function, they'd
 157          * live to the end of the transactions, where they'd be cleaned up by the
 158          * resowner machinery. That can lead to a noticeable amount of memory
 159          * usage, and worse, trigger some quadratic behaviour in gdb. Therefore,
 160          * at least for now, don't create a JITed function in those circumstances.
 161          */
 162         if (!state->parent)
 163                 return false;
 164
 165         /* if no jitting should be performed at all */
 166         if (!(state->parent->state->es_jit_flags & PGJIT_PERFORM))
 167                 return false;
 168
 169         /* or if expressions aren't JITed */
 170         if (!(state->parent->state->es_jit_flags & PGJIT_EXPR))
 171                 return false;
 172
 173         /* this also takes !jit_enabled into account */
 174         if (provider_init())
 175                 return provider.compile_expr(state);
 176
 177         return false;
 178 }
 179
 180 /* Aggregate JIT instrumentation information */
 181 void
 182 InstrJitAgg(JitInstrumentation *dst, JitInstrumentation *add)
 183 {
 184         dst->created_functions += add->created_functions;
 185         INSTR_TIME_ADD(dst->generation_counter, add->generation_counter);
 186         INSTR_TIME_ADD(dst->deform_counter, add->deform_counter);
 187         INSTR_TIME_ADD(dst->inlining_counter, add->inlining_counter);
 188         INSTR_TIME_ADD(dst->optimization_counter, add->optimization_counter);
 189         INSTR_TIME_ADD(dst->emission_counter, add->emission_counter);
 190 }