#include "postgres.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "executor/execExpr.h"
#include "fmgr.h"
#include "jit/jit.h"
#include "miscadmin.h"
#include "utils/fmgrprotos.h"
#include "utils/resowner_private.h"

Include dependency graph for jit.c:

Functions
static bool	provider_init (void)

static bool	file_exists (const char *name)

Datum	pg_jit_available (PG_FUNCTION_ARGS)

void	jit_reset_after_error (void)

void	jit_release_context (JitContext *context)

bool	jit_compile_expr (struct ExprState *state)

void	InstrJitAgg (JitInstrumentation dst, JitInstrumentation add)

Variables
bool	jit_enabled = true

char *	jit_provider = NULL

bool	jit_debugging_support = false

bool	jit_dump_bitcode = false

bool	jit_expressions = true

bool	jit_profiling_support = false

bool	jit_tuple_deforming = true

double	jit_above_cost = 100000

double	jit_inline_above_cost = 500000

double	jit_optimize_above_cost = 500000

static JitProviderCallbacks	provider

static bool	provider_successfully_loaded = false

static bool	provider_failed_loading = false

Function Documentation

◆ file_exists()

static bool file_exists ( const char * name )

static

Definition at line 195 of file jit.c.

 {
     struct stat st;
  
     Assert(name != NULL);
  
     if (stat(name, &st) == 0)
         return !S_ISDIR(st.st_mode);
     else if (!(errno == ENOENT || errno == ENOTDIR))
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not access file \"%s\": %m", name)));
  
     return false;
 }

References Assert(), ereport, errcode_for_file_access(), errmsg(), ERROR, name, S_ISDIR, stat::st_mode, and stat.

Referenced by isolation_start_test(), provider_init(), and psql_start_test().

◆ InstrJitAgg()

void InstrJitAgg	(	JitInstrumentation *	dst,
		JitInstrumentation *	add
	)

Definition at line 184 of file jit.c.

 {
     dst->created_functions += add->created_functions;
     INSTR_TIME_ADD(dst->generation_counter, add->generation_counter);
     INSTR_TIME_ADD(dst->deform_counter, add->deform_counter);
     INSTR_TIME_ADD(dst->inlining_counter, add->inlining_counter);
     INSTR_TIME_ADD(dst->optimization_counter, add->optimization_counter);
     INSTR_TIME_ADD(dst->emission_counter, add->emission_counter);
 }

References JitInstrumentation::created_functions, JitInstrumentation::deform_counter, JitInstrumentation::emission_counter, JitInstrumentation::generation_counter, JitInstrumentation::inlining_counter, INSTR_TIME_ADD, and JitInstrumentation::optimization_counter.

Referenced by ExecParallelRetrieveJitInstrumentation(), and ExplainPrintJITSummary().

◆ jit_compile_expr()

bool jit_compile_expr ( struct ExprState * state )

Definition at line 153 of file jit.c.

 {
     /*
      * We can easily create a one-off context for functions without an
      * associated PlanState (and thus EState). But because there's no executor
      * shutdown callback that could deallocate the created function, they'd
      * live to the end of the transactions, where they'd be cleaned up by the
      * resowner machinery. That can lead to a noticeable amount of memory
      * usage, and worse, trigger some quadratic behaviour in gdb. Therefore,
      * at least for now, don't create a JITed function in those circumstances.
      */
     if (!state->parent)
         return false;
  
     /* if no jitting should be performed at all */
     if (!(state->parent->state->es_jit_flags & PGJIT_PERFORM))
         return false;
  
     /* or if expressions aren't JITed */
     if (!(state->parent->state->es_jit_flags & PGJIT_EXPR))
         return false;
  
     /* this also takes !jit_enabled into account */
     if (provider_init())
         return provider.compile_expr(state);
  
     return false;
 }

References JitProviderCallbacks::compile_expr, PGJIT_EXPR, PGJIT_PERFORM, provider, and provider_init().

Referenced by ExecReadyExpr().

◆ jit_release_context()

void jit_release_context ( JitContext * context )

Definition at line 138 of file jit.c.

 {
     if (provider_successfully_loaded)
         provider.release_context(context);
  
     ResourceOwnerForgetJIT(context->resowner, PointerGetDatum(context));
     pfree(context);
 }

References pfree(), PointerGetDatum(), provider, provider_successfully_loaded, JitProviderCallbacks::release_context, ResourceOwnerForgetJIT(), and JitContext::resowner.

Referenced by FreeExecutorState(), and ResourceOwnerReleaseInternal().

◆ jit_reset_after_error()

void jit_reset_after_error ( void )

Definition at line 128 of file jit.c.

 {
     if (provider_successfully_loaded)
         provider.reset_after_error();
 }

References provider, provider_successfully_loaded, and JitProviderCallbacks::reset_after_error.

Referenced by PostgresMain().

◆ pg_jit_available()

Datum pg_jit_available ( PG_FUNCTION_ARGS )

Definition at line 57 of file jit.c.

 {
     PG_RETURN_BOOL(provider_init());
 }

References PG_RETURN_BOOL, and provider_init().

◆ provider_init()

static bool provider_init ( void )

static

Definition at line 68 of file jit.c.

 {
     char        path[MAXPGPATH];
     JitProviderInit init;
  
     /* don't even try to load if not enabled */
     if (!jit_enabled)
         return false;
  
     /*
      * Don't retry loading after failing - attempting to load JIT provider
      * isn't cheap.
      */
     if (provider_failed_loading)
         return false;
     if (provider_successfully_loaded)
         return true;
  
     /*
      * Check whether shared library exists. We do that check before actually
      * attempting to load the shared library (via load_external_function()),
      * because that'd error out in case the shlib isn't available.
      */
     snprintf(path, MAXPGPATH, "%s/%s%s", pkglib_path, jit_provider, DLSUFFIX);
     elog(DEBUG1, "probing availability of JIT provider at %s", path);
     if (!file_exists(path))
     {
         elog(DEBUG1,
              "provider not available, disabling JIT for current session");
         provider_failed_loading = true;
         return false;
     }
  
     /*
      * If loading functions fails, signal failure. We do so because
      * load_external_function() might error out despite the above check if
      * e.g. the library's dependencies aren't installed. We want to signal
      * ERROR in that case, so the user is notified, but we don't want to
      * continually retry.
      */
     provider_failed_loading = true;
  
     /* and initialize */
     init = (JitProviderInit)
         load_external_function(path, "_PG_jit_provider_init", true, NULL);
     init(&provider);
  
     provider_successfully_loaded = true;
     provider_failed_loading = false;
  
     elog(DEBUG1, "successfully loaded JIT provider in current session");
  
     return true;
 }