1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/*-------------------------------------------------------------------------
*
* jit.c
* Provider independent JIT infrastructure.
*
* Code related to loading JIT providers, redirecting calls into JIT providers
* and error handling. No code specific to a specific JIT implementation
* should end up here.
*
*
* Copyright (c) 2016-2021, PostgreSQL Global Development Group
*
* IDENTIFICATION
* src/backend/jit/jit.c
*
*-------------------------------------------------------------------------
*/
#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"
/* GUCs */
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;
static bool provider_init(void);
static bool file_exists(const char *name);
/*
* SQL level function returning whether JIT is available in the current
* backend. Will attempt to load JIT provider if necessary.
*/
Datum
pg_jit_available(PG_FUNCTION_ARGS)
{
PG_RETURN_BOOL(provider_init());
}
/*
* Return whether a JIT provider has successfully been loaded, caching the
* result.
*/
static bool
provider_init(void)
{
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;
}
/*
* Reset JIT provider's error handling. This'll be called after an error has
* been thrown and the main-loop has re-established control.
*/
void
jit_reset_after_error(void)
{
if (provider_successfully_loaded)
provider.reset_after_error();
}
/*
* Release resources required by one JIT context.
*/
void
jit_release_context(JitContext *context)
{
if (provider_successfully_loaded)
provider.release_context(context);
ResourceOwnerForgetJIT(context->resowner, PointerGetDatum(context));
pfree(context);
}
/*
* Ask provider to JIT compile an expression.
*
* Returns true if successful, false if not.
*/
bool
jit_compile_expr(struct ExprState *state)
{
/*
* 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;
}
/* Aggregate JIT instrumentation information */
void
InstrJitAgg(JitInstrumentation *dst, JitInstrumentation *add)
{
dst->created_functions += add->created_functions;
INSTR_TIME_ADD(dst->generation_counter, add->generation_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);
}
static bool
file_exists(const char *name)
{
struct stat st;
AssertArg(name != NULL);
if (stat(name, &st) == 0)
return S_ISDIR(st.st_mode) ? false : true;
else if (!(errno == ENOENT || errno == ENOTDIR))
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not access file \"%s\": %m", name)));
return false;
}
|
