pg.ddx.io pgsql-committers@postgresql.org mailing list archive
help / color / mirror / Atom feedpgsql: llvmjit: Use explicit LLVMContextRef for inlining
11+ messages / 3 participants
[nested] [flat]
Commits from this thread:
2023-12-11 c922b24106 jit: Create void type in the right context
* pgsql: llvmjit: Use explicit LLVMContextRef for inlining
@ 2023-09-27 11:08 Daniel Gustafsson <dgustafsson@postgresql.org>
0 siblings, 0 replies; 11+ messages in thread
From: Daniel Gustafsson @ 2023-09-27 11:08 UTC (permalink / raw)
To: pgsql-committers@lists.postgresql.org
llvmjit: Use explicit LLVMContextRef for inlining
When performing inlining LLVM unfortunately "leaks" types (the
types survive and are usable, but a new round of inlining will
recreate new structurally equivalent types). This accumulation
will over time amount to a memory leak which for some queries
can be large enough to trigger the OOM process killer.
To avoid accumulation of types, all IR related data is stored
in an LLVMContextRef which is dropped and recreated in order
to release all types. Dropping and recreating incurs overhead,
so it will be done only after 100 queries. This is a heuristic
which might be revisited, but until we can get the size of the
context from LLVM we are flying a bit blind.
This issue has been reported several times, there may be more
references to it in the archives on top of the threads linked
below.
Backpatching of this fix will be handled once it has matured
in master for a bit.
Reported-By: Justin Pryzby <pryzby@telsasoft.com>
Reported-By: Kurt Roeckx <kurt@roeckx.be>
Reported-By: Jaime Casanova <jcasanov@systemguards.com.ec>
Reported-By: Lauri Laanmets <pcspets@gmail.com>
Author: Andres Freund and Daniel Gustafsson
Discussion: https://postgr.es/m/7acc8678-df5f-4923-9cf6-e843131ae89d@www.fastmail.com
Discussion: https://postgr.es/m/20201218235607.GC30237@telsasoft.com
Discussion: https://postgr.es/m/CAPH-tTxLf44s3CvUUtQpkDr1D8Hxqc2NGDzGXS1ODsfiJ6WSqA@mail.gmail.com
Branch
------
master
Details
-------
https://git.postgresql.org/pg/commitdiff/9dce22033d5d2813e9f8e7d595f57ee5a38b3f8e
Modified Files
--------------
src/backend/jit/llvm/llvmjit.c | 139 ++++++++++++++++++++++++++++----
src/backend/jit/llvm/llvmjit_deform.c | 60 +++++++-------
src/backend/jit/llvm/llvmjit_expr.c | 58 +++++++------
src/backend/jit/llvm/llvmjit_inline.cpp | 33 +++++---
src/include/jit/llvmjit.h | 8 ++
src/include/jit/llvmjit_emit.h | 30 ++++---
6 files changed, 234 insertions(+), 94 deletions(-)
^ permalink raw reply [nested|flat] 11+ messages in thread
* pgsql: llvmjit: Use explicit LLVMContextRef for inlining
@ 2023-11-17 10:19 Daniel Gustafsson <dgustafsson@postgresql.org>
0 siblings, 0 replies; 11+ messages in thread
From: Daniel Gustafsson @ 2023-11-17 10:19 UTC (permalink / raw)
To: pgsql-committers@lists.postgresql.org
llvmjit: Use explicit LLVMContextRef for inlining
When performing inlining LLVM unfortunately "leaks" types (the
types survive and are usable, but a new round of inlining will
recreate new structurally equivalent types). This accumulation
will over time amount to a memory leak which for some queries
can be large enough to trigger the OOM process killer.
To avoid accumulation of types, all IR related data is stored
in an LLVMContextRef which is dropped and recreated in order
to release all types. Dropping and recreating incurs overhead,
so it will be done only after 100 queries. This is a heuristic
which might be revisited, but until we can get the size of the
context from LLVM we are flying a bit blind.
This issue has been reported several times, there may be more
references to it in the archives on top of the threads linked
below.
This is a backpatch of 9dce22033d5 to all supported branches.
Reported-By: Justin Pryzby <pryzby@telsasoft.com>
Reported-By: Kurt Roeckx <kurt@roeckx.be>
Reported-By: Jaime Casanova <jcasanov@systemguards.com.ec>
Reported-By: Lauri Laanmets <pcspets@gmail.com>
Author: Andres Freund and Daniel Gustafsson
Discussion: https://postgr.es/m/7acc8678-df5f-4923-9cf6-e843131ae89d@www.fastmail.com
Discussion: https://postgr.es/m/20201218235607.GC30237@telsasoft.com
Discussion: https://postgr.es/m/CAPH-tTxLf44s3CvUUtQpkDr1D8Hxqc2NGDzGXS1ODsfiJ6WSqA@mail.gmail.com
Backpatch-through: v12
Branch
------
REL_16_STABLE
Details
-------
https://git.postgresql.org/pg/commitdiff/2cf50585e54a7b0c6bc62a087c69043ae57e4252
Modified Files
--------------
src/backend/jit/llvm/llvmjit.c | 139 ++++++++++++++++++++++++++++----
src/backend/jit/llvm/llvmjit_deform.c | 77 +++++++++---------
src/backend/jit/llvm/llvmjit_expr.c | 60 +++++++-------
src/backend/jit/llvm/llvmjit_inline.cpp | 33 +++++---
src/include/jit/llvmjit.h | 8 ++
src/include/jit/llvmjit_emit.h | 30 ++++---
6 files changed, 244 insertions(+), 103 deletions(-)
^ permalink raw reply [nested|flat] 11+ messages in thread
* pgsql: llvmjit: Use explicit LLVMContextRef for inlining
@ 2023-11-17 10:29 Daniel Gustafsson <dgustafsson@postgresql.org>
0 siblings, 0 replies; 11+ messages in thread
From: Daniel Gustafsson @ 2023-11-17 10:29 UTC (permalink / raw)
To: pgsql-committers@lists.postgresql.org
llvmjit: Use explicit LLVMContextRef for inlining
When performing inlining LLVM unfortunately "leaks" types (the
types survive and are usable, but a new round of inlining will
recreate new structurally equivalent types). This accumulation
will over time amount to a memory leak which for some queries
can be large enough to trigger the OOM process killer.
To avoid accumulation of types, all IR related data is stored
in an LLVMContextRef which is dropped and recreated in order
to release all types. Dropping and recreating incurs overhead,
so it will be done only after 100 queries. This is a heuristic
which might be revisited, but until we can get the size of the
context from LLVM we are flying a bit blind.
This issue has been reported several times, there may be more
references to it in the archives on top of the threads linked
below.
This is a backpatch of 9dce22033d5 to all supported branches.
Reported-By: Justin Pryzby <pryzby@telsasoft.com>
Reported-By: Kurt Roeckx <kurt@roeckx.be>
Reported-By: Jaime Casanova <jcasanov@systemguards.com.ec>
Reported-By: Lauri Laanmets <pcspets@gmail.com>
Author: Andres Freund and Daniel Gustafsson
Discussion: https://postgr.es/m/7acc8678-df5f-4923-9cf6-e843131ae89d@www.fastmail.com
Discussion: https://postgr.es/m/20201218235607.GC30237@telsasoft.com
Discussion: https://postgr.es/m/CAPH-tTxLf44s3CvUUtQpkDr1D8Hxqc2NGDzGXS1ODsfiJ6WSqA@mail.gmail.com
Backpatch-through: v12
Branch
------
REL_15_STABLE
Details
-------
https://git.postgresql.org/pg/commitdiff/aef521849b68d1eeb63c3dfbc4e92d66dc94a636
Modified Files
--------------
src/backend/jit/llvm/llvmjit.c | 139 ++++++++++++++++++++++++++++----
src/backend/jit/llvm/llvmjit_deform.c | 77 +++++++++---------
src/backend/jit/llvm/llvmjit_expr.c | 60 +++++++-------
src/backend/jit/llvm/llvmjit_inline.cpp | 33 +++++---
src/include/jit/llvmjit.h | 8 ++
src/include/jit/llvmjit_emit.h | 30 ++++---
6 files changed, 244 insertions(+), 103 deletions(-)
^ permalink raw reply [nested|flat] 11+ messages in thread
* pgsql: llvmjit: Use explicit LLVMContextRef for inlining
@ 2023-11-17 10:44 Daniel Gustafsson <dgustafsson@postgresql.org>
0 siblings, 0 replies; 11+ messages in thread
From: Daniel Gustafsson @ 2023-11-17 10:44 UTC (permalink / raw)
To: pgsql-committers@lists.postgresql.org
llvmjit: Use explicit LLVMContextRef for inlining
When performing inlining LLVM unfortunately "leaks" types (the
types survive and are usable, but a new round of inlining will
recreate new structurally equivalent types). This accumulation
will over time amount to a memory leak which for some queries
can be large enough to trigger the OOM process killer.
To avoid accumulation of types, all IR related data is stored
in an LLVMContextRef which is dropped and recreated in order
to release all types. Dropping and recreating incurs overhead,
so it will be done only after 100 queries. This is a heuristic
which might be revisited, but until we can get the size of the
context from LLVM we are flying a bit blind.
This issue has been reported several times, there may be more
references to it in the archives on top of the threads linked
below.
This is a backpatch of 9dce22033d5 to all supported branches.
Reported-By: Justin Pryzby <pryzby@telsasoft.com>
Reported-By: Kurt Roeckx <kurt@roeckx.be>
Reported-By: Jaime Casanova <jcasanov@systemguards.com.ec>
Reported-By: Lauri Laanmets <pcspets@gmail.com>
Author: Andres Freund and Daniel Gustafsson
Discussion: https://postgr.es/m/7acc8678-df5f-4923-9cf6-e843131ae89d@www.fastmail.com
Discussion: https://postgr.es/m/20201218235607.GC30237@telsasoft.com
Discussion: https://postgr.es/m/CAPH-tTxLf44s3CvUUtQpkDr1D8Hxqc2NGDzGXS1ODsfiJ6WSqA@mail.gmail.com
Backpatch-through: v12
Branch
------
REL_14_STABLE
Details
-------
https://git.postgresql.org/pg/commitdiff/75a20a4b4b4485f76158719bcdb48310cf2552d4
Modified Files
--------------
src/backend/jit/llvm/llvmjit.c | 139 ++++++++++++++++++++++++++++----
src/backend/jit/llvm/llvmjit_deform.c | 77 +++++++++---------
src/backend/jit/llvm/llvmjit_expr.c | 60 +++++++-------
src/backend/jit/llvm/llvmjit_inline.cpp | 33 +++++---
src/include/jit/llvmjit.h | 8 ++
src/include/jit/llvmjit_emit.h | 30 ++++---
6 files changed, 244 insertions(+), 103 deletions(-)
^ permalink raw reply [nested|flat] 11+ messages in thread
* pgsql: llvmjit: Use explicit LLVMContextRef for inlining
@ 2023-11-17 10:49 Daniel Gustafsson <dgustafsson@postgresql.org>
0 siblings, 0 replies; 11+ messages in thread
From: Daniel Gustafsson @ 2023-11-17 10:49 UTC (permalink / raw)
To: pgsql-committers@lists.postgresql.org
llvmjit: Use explicit LLVMContextRef for inlining
When performing inlining LLVM unfortunately "leaks" types (the
types survive and are usable, but a new round of inlining will
recreate new structurally equivalent types). This accumulation
will over time amount to a memory leak which for some queries
can be large enough to trigger the OOM process killer.
To avoid accumulation of types, all IR related data is stored
in an LLVMContextRef which is dropped and recreated in order
to release all types. Dropping and recreating incurs overhead,
so it will be done only after 100 queries. This is a heuristic
which might be revisited, but until we can get the size of the
context from LLVM we are flying a bit blind.
This issue has been reported several times, there may be more
references to it in the archives on top of the threads linked
below.
This is a backpatch of 9dce22033d5 to all supported branches.
Reported-By: Justin Pryzby <pryzby@telsasoft.com>
Reported-By: Kurt Roeckx <kurt@roeckx.be>
Reported-By: Jaime Casanova <jcasanov@systemguards.com.ec>
Reported-By: Lauri Laanmets <pcspets@gmail.com>
Author: Andres Freund and Daniel Gustafsson
Discussion: https://postgr.es/m/7acc8678-df5f-4923-9cf6-e843131ae89d@www.fastmail.com
Discussion: https://postgr.es/m/20201218235607.GC30237@telsasoft.com
Discussion: https://postgr.es/m/CAPH-tTxLf44s3CvUUtQpkDr1D8Hxqc2NGDzGXS1ODsfiJ6WSqA@mail.gmail.com
Backpatch-through: v12
Branch
------
REL_13_STABLE
Details
-------
https://git.postgresql.org/pg/commitdiff/10912f7d4ff0e343e714a1703752c0d8c5b71306
Modified Files
--------------
src/backend/jit/llvm/llvmjit.c | 139 ++++++++++++++++++++++++++++----
src/backend/jit/llvm/llvmjit_deform.c | 77 +++++++++---------
src/backend/jit/llvm/llvmjit_expr.c | 62 +++++++-------
src/backend/jit/llvm/llvmjit_inline.cpp | 33 +++++---
src/include/jit/llvmjit.h | 8 ++
src/include/jit/llvmjit_emit.h | 30 ++++---
6 files changed, 245 insertions(+), 104 deletions(-)
^ permalink raw reply [nested|flat] 11+ messages in thread
* pgsql: llvmjit: Use explicit LLVMContextRef for inlining
@ 2023-11-17 10:52 Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-19 16:05 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Tom Lane <tgl@sss.pgh.pa.us>
0 siblings, 1 reply; 11+ messages in thread
From: Daniel Gustafsson @ 2023-11-17 10:52 UTC (permalink / raw)
To: pgsql-committers@lists.postgresql.org
llvmjit: Use explicit LLVMContextRef for inlining
When performing inlining LLVM unfortunately "leaks" types (the
types survive and are usable, but a new round of inlining will
recreate new structurally equivalent types). This accumulation
will over time amount to a memory leak which for some queries
can be large enough to trigger the OOM process killer.
To avoid accumulation of types, all IR related data is stored
in an LLVMContextRef which is dropped and recreated in order
to release all types. Dropping and recreating incurs overhead,
so it will be done only after 100 queries. This is a heuristic
which might be revisited, but until we can get the size of the
context from LLVM we are flying a bit blind.
This issue has been reported several times, there may be more
references to it in the archives on top of the threads linked
below.
This is a backpatch of 9dce22033d5 to all supported branches.
Reported-By: Justin Pryzby <pryzby@telsasoft.com>
Reported-By: Kurt Roeckx <kurt@roeckx.be>
Reported-By: Jaime Casanova <jcasanov@systemguards.com.ec>
Reported-By: Lauri Laanmets <pcspets@gmail.com>
Author: Andres Freund and Daniel Gustafsson
Discussion: https://postgr.es/m/7acc8678-df5f-4923-9cf6-e843131ae89d@www.fastmail.com
Discussion: https://postgr.es/m/20201218235607.GC30237@telsasoft.com
Discussion: https://postgr.es/m/CAPH-tTxLf44s3CvUUtQpkDr1D8Hxqc2NGDzGXS1ODsfiJ6WSqA@mail.gmail.com
Backpatch-through: v12
Branch
------
REL_12_STABLE
Details
-------
https://git.postgresql.org/pg/commitdiff/3b991f81c45720515144b928bb8d1f03577628f1
Modified Files
--------------
src/backend/jit/llvm/llvmjit.c | 141 ++++++++++++++++++++++++++++----
src/backend/jit/llvm/llvmjit_deform.c | 77 ++++++++---------
src/backend/jit/llvm/llvmjit_expr.c | 72 ++++++++--------
src/backend/jit/llvm/llvmjit_inline.cpp | 33 +++++---
src/include/jit/llvmjit.h | 8 ++
src/include/jit/llvmjit_emit.h | 30 ++++---
6 files changed, 252 insertions(+), 109 deletions(-)
^ permalink raw reply [nested|flat] 11+ messages in thread
* Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining
2023-11-17 10:52 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
@ 2023-11-19 16:05 ` Tom Lane <tgl@sss.pgh.pa.us>
2023-11-19 20:08 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
0 siblings, 1 reply; 11+ messages in thread
From: Tom Lane @ 2023-11-19 16:05 UTC (permalink / raw)
To: Daniel Gustafsson <dgustafsson@postgresql.org>; +Cc: pgsql-committers@lists.postgresql.org, Andres Freund <andres@anarazel.de>
Daniel Gustafsson <dgustafsson@postgresql.org> writes:
> llvmjit: Use explicit LLVMContextRef for inlining
It looks like the v12 back-port of this wasn't quite right:
canebrake and urutu have both been showing assertion failures
down inside LLVMContextDispose since it went in. They aren't
complaining about v13 and later, though.
No idea what the cause may be, but perhaps the right answer
is just to revert this and not try to fix the bug in v12?
regards, tom lane
^ permalink raw reply [nested|flat] 11+ messages in thread
* Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining
2023-11-17 10:52 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-19 16:05 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Tom Lane <tgl@sss.pgh.pa.us>
@ 2023-11-19 20:08 ` Daniel Gustafsson <daniel@yesql.se>
2023-11-20 21:53 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
0 siblings, 1 reply; 11+ messages in thread
From: Daniel Gustafsson @ 2023-11-19 20:08 UTC (permalink / raw)
To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: pgsql-committers@lists.postgresql.org, Andres Freund <andres@anarazel.de>
> On 19 Nov 2023, at 17:05, Tom Lane <tgl@sss.pgh.pa.us> wrote:
>
> Daniel Gustafsson <dgustafsson@postgresql.org> writes:
>> llvmjit: Use explicit LLVMContextRef for inlining
>
> It looks like the v12 back-port of this wasn't quite right:
> canebrake and urutu have both been showing assertion failures
> down inside LLVMContextDispose since it went in. They aren't
> complaining about v13 and later, though.
Ugh, I had missed these =/ Thanks for the heads up!
> No idea what the cause may be, but perhaps the right answer
> is just to revert this and not try to fix the bug in v12?
I'll have a look with fresh eyes in the morning, and hopefully it will be
fixable. If it get's messy it's quite possible that skipping v12 is the best
option.
--
Daniel Gustafsson
^ permalink raw reply [nested|flat] 11+ messages in thread
* Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining
2023-11-17 10:52 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-19 16:05 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Tom Lane <tgl@sss.pgh.pa.us>
2023-11-19 20:08 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
@ 2023-11-20 21:53 ` Daniel Gustafsson <daniel@yesql.se>
2023-12-08 13:38 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
0 siblings, 1 reply; 11+ messages in thread
From: Daniel Gustafsson @ 2023-11-20 21:53 UTC (permalink / raw)
To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: pgsql-committers@lists.postgresql.org, Andres Freund <andres@anarazel.de>
> On 19 Nov 2023, at 21:08, Daniel Gustafsson <daniel@yesql.se> wrote:
> I'll have a look with fresh eyes in the morning, and hopefully it will be
> fixable. If it get's messy it's quite possible that skipping v12 is the best
> option.
As an update, discussing with Andres off-list I have a potential patch for
this, need to rebuild LLVM debug builds tomorrow to test further but there
should be either a fix or a revert soon.
--
Daniel Gustafsson
^ permalink raw reply [nested|flat] 11+ messages in thread
* Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining
2023-11-17 10:52 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-19 16:05 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Tom Lane <tgl@sss.pgh.pa.us>
2023-11-19 20:08 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
2023-11-20 21:53 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
@ 2023-12-08 13:38 ` Daniel Gustafsson <daniel@yesql.se>
2023-12-11 19:24 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
0 siblings, 1 reply; 11+ messages in thread
From: Daniel Gustafsson @ 2023-12-08 13:38 UTC (permalink / raw)
To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: pgsql-committers@lists.postgresql.org, Andres Freund <andres@anarazel.de>
> On 20 Nov 2023, at 22:53, Daniel Gustafsson <daniel@yesql.se> wrote:
>
>> On 19 Nov 2023, at 21:08, Daniel Gustafsson <daniel@yesql.se> wrote:
>
>> I'll have a look with fresh eyes in the morning, and hopefully it will be
>> fixable. If it get's messy it's quite possible that skipping v12 is the best
>> option.
>
> As an update, discussing with Andres off-list I have a potential patch for
> this, need to rebuild LLVM debug builds tomorrow to test further but there
> should be either a fix or a revert soon.
After some more work with Andres, the bug was found to be a void pointer not
created in the referenced context. The attached diff fixes the issue (which is
related to code refactored in v13 hence why it only affects v12). I will apply
that to v12 shortly after a little more testing.
--
Daniel Gustafsson
Attachments:
llvmcontext_v12_fix.diff (application/octet-stream, 900B) download
diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index c25960a82b..f2cf2fadaa 100644
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -2620,7 +2620,9 @@ build_EvalXFunc(LLVMBuilderRef b, LLVMModuleRef mod, const char *funcname,
LLVMValueRef v_fn;
LLVMTypeRef param_types[3];
LLVMValueRef params[3];
+ LLVMContextRef lc;
+ lc = LLVMGetModuleContext(mod);
v_fn = LLVMGetNamedFunction(mod, funcname);
if (!v_fn)
{
@@ -2628,7 +2630,7 @@ build_EvalXFunc(LLVMBuilderRef b, LLVMModuleRef mod, const char *funcname,
param_types[1] = l_ptr(StructExprEvalStep);
param_types[2] = l_ptr(StructExprContext);
- sig = LLVMFunctionType(LLVMVoidType(),
+ sig = LLVMFunctionType(LLVMVoidTypeInContext(lc),
param_types, lengthof(param_types),
false);
v_fn = LLVMAddFunction(mod, funcname, sig);
* Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining
2023-11-17 10:52 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-19 16:05 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Tom Lane <tgl@sss.pgh.pa.us>
2023-11-19 20:08 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
2023-11-20 21:53 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
2023-12-08 13:38 ` Re: pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <daniel@yesql.se>
@ 2023-12-11 19:24 ` Daniel Gustafsson <daniel@yesql.se>
0 siblings, 0 replies; 11+ messages in thread
From: Daniel Gustafsson @ 2023-12-11 19:24 UTC (permalink / raw)
To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: pgsql-committers@lists.postgresql.org, Andres Freund <andres@anarazel.de>
> On 8 Dec 2023, at 14:38, Daniel Gustafsson <daniel@yesql.se> wrote:
> I will apply that to v12 shortly after a little more testing.
Done, and canebrake/urutu has since turned green.
--
Daniel Gustafsson
^ permalink raw reply [nested|flat] 11+ messages in thread
end of thread, other threads:[~2023-12-11 19:24 UTC | newest]
Thread overview: 11+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2023-09-27 11:08 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-17 10:19 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-17 10:29 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-17 10:44 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-17 10:49 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-17 10:52 pgsql: llvmjit: Use explicit LLVMContextRef for inlining Daniel Gustafsson <dgustafsson@postgresql.org>
2023-11-19 16:05 ` Tom Lane <tgl@sss.pgh.pa.us>
2023-11-19 20:08 ` Daniel Gustafsson <daniel@yesql.se>
2023-11-20 21:53 ` Daniel Gustafsson <daniel@yesql.se>
2023-12-08 13:38 ` Daniel Gustafsson <daniel@yesql.se>
2023-12-11 19:24 ` Daniel Gustafsson <daniel@yesql.se>
This inbox is served by DDX for PostgreSQL; see mirroring instructions
for how to clone and mirror all data and code used for this inbox