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-2020, 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 "executor/execExpr.h"
25 #include "fmgr.h"
26 #include "jit/jit.h"
27 #include "miscadmin.h"
28 #include "utils/fmgrprotos.h"
29 #include "utils/resowner_private.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 static bool file_exists(const char *name);
50
51
52 /*
53 * SQL level function returning whether JIT is available in the current
54 * backend. Will attempt to load JIT provider if necessary.
55 */
56 Datum
pg_jit_available(PG_FUNCTION_ARGS)57 pg_jit_available(PG_FUNCTION_ARGS)
58 {
59 PG_RETURN_BOOL(provider_init());
60 }
61
62
63 /*
64 * Return whether a JIT provider has successfully been loaded, caching the
65 * result.
66 */
67 static bool
provider_init(void)68 provider_init(void)
69 {
70 char path[MAXPGPATH];
71 JitProviderInit init;
72
73 /* don't even try to load if not enabled */
74 if (!jit_enabled)
75 return false;
76
77 /*
78 * Don't retry loading after failing - attempting to load JIT provider
79 * isn't cheap.
80 */
81 if (provider_failed_loading)
82 return false;
83 if (provider_successfully_loaded)
84 return true;
85
86 /*
87 * Check whether shared library exists. We do that check before actually
88 * attempting to load the shared library (via load_external_function()),
89 * because that'd error out in case the shlib isn't available.
90 */
91 snprintf(path, MAXPGPATH, "%s/%s%s", pkglib_path, jit_provider, DLSUFFIX);
92 elog(DEBUG1, "probing availability of JIT provider at %s", path);
93 if (!file_exists(path))
94 {
95 elog(DEBUG1,
96 "provider not available, disabling JIT for current session");
97 provider_failed_loading = true;
98 return false;
99 }
100
101 /*
102 * If loading functions fails, signal failure. We do so because
103 * load_external_function() might error out despite the above check if
104 * e.g. the library's dependencies aren't installed. We want to signal
105 * ERROR in that case, so the user is notified, but we don't want to
106 * continually retry.
107 */
108 provider_failed_loading = true;
109
110 /* and initialize */
111 init = (JitProviderInit)
112 load_external_function(path, "_PG_jit_provider_init", true, NULL);
113 init(&provider);
114
115 provider_successfully_loaded = true;
116 provider_failed_loading = false;
117
118 elog(DEBUG1, "successfully loaded JIT provider in current session");
119
120 return true;
121 }
122
123 /*
124 * Reset JIT provider's error handling. This'll be called after an error has
125 * been thrown and the main-loop has re-established control.
126 */
127 void
jit_reset_after_error(void)128 jit_reset_after_error(void)
129 {
130 if (provider_successfully_loaded)
131 provider.reset_after_error();
132 }
133
134 /*
135 * Release resources required by one JIT context.
136 */
137 void
jit_release_context(JitContext * context)138 jit_release_context(JitContext *context)
139 {
140 if (provider_successfully_loaded)
141 provider.release_context(context);
142
143 ResourceOwnerForgetJIT(context->resowner, PointerGetDatum(context));
144 pfree(context);
145 }
146
147 /*
148 * Ask provider to JIT compile an expression.
149 *
150 * Returns true if successful, false if not.
151 */
152 bool
jit_compile_expr(struct ExprState * state)153 jit_compile_expr(struct ExprState *state)
154 {
155 /*
156 * We can easily create a one-off context for functions without an
157 * associated PlanState (and thus EState). But because there's no executor
158 * shutdown callback that could deallocate the created function, they'd
159 * live to the end of the transactions, where they'd be cleaned up by the
160 * resowner machinery. That can lead to a noticeable amount of memory
161 * usage, and worse, trigger some quadratic behaviour in gdb. Therefore,
162 * at least for now, don't create a JITed function in those circumstances.
163 */
164 if (!state->parent)
165 return false;
166
167 /* if no jitting should be performed at all */
168 if (!(state->parent->state->es_jit_flags & PGJIT_PERFORM))
169 return false;
170
171 /* or if expressions aren't JITed */
172 if (!(state->parent->state->es_jit_flags & PGJIT_EXPR))
173 return false;
174
175 /* this also takes !jit_enabled into account */
176 if (provider_init())
177 return provider.compile_expr(state);
178
179 return false;
180 }
181
182 /* Aggregate JIT instrumentation information */
183 void
InstrJitAgg(JitInstrumentation * dst,JitInstrumentation * add)184 InstrJitAgg(JitInstrumentation *dst, JitInstrumentation *add)
185 {
186 dst->created_functions += add->created_functions;
187 INSTR_TIME_ADD(dst->generation_counter, add->generation_counter);
188 INSTR_TIME_ADD(dst->inlining_counter, add->inlining_counter);
189 INSTR_TIME_ADD(dst->optimization_counter, add->optimization_counter);
190 INSTR_TIME_ADD(dst->emission_counter, add->emission_counter);
191 }
192
193 static bool
file_exists(const char * name)194 file_exists(const char *name)
195 {
196 struct stat st;
197
198 AssertArg(name != NULL);
199
200 if (stat(name, &st) == 0)
201 return S_ISDIR(st.st_mode) ? false : true;
202 else if (!(errno == ENOENT || errno == ENOTDIR))
203 ereport(ERROR,
204 (errcode_for_file_access(),
205 errmsg("could not access file \"%s\": %m", name)));
206
207 return false;
208 }
209