|From:||Andres Freund <andres(at)anarazel(dot)de>|
|To:||Konstantin Knizhnik <k(dot)knizhnik(at)postgrespro(dot)ru>|
|Subject:||Re: JIT compiling with LLVM v9.0|
|Views:||Raw Message | Whole Thread | Download mbox | Resend email|
On 2018-01-25 18:40:53 +0300, Konstantin Knizhnik wrote:
> As far as I understand generation of native code is now always done for all
> supported expressions and individually by each backend.
Mostly, yes. It's done "always" done, because there's cost based checks
whether to do so or not.
> I wonder it will be useful to do more efforts to understand when compilation
> to native code should be done and when interpretation is better.
> For example many JIT-able languages like Lua are using traces, i.e. query is
> first interpreted and trace is generated. If the same trace is followed
> more than N times, then native code is generated for it.
Right. That's where I actually had started out, but my experimentation
showed that that's not that interesting a path to pursue. Emitting code
in much smaller increments (as you'd do so for individual expressions)
has considerable overhead. We also have a planner that allows us
reasonable guesses when to JIT and when not - something not available in
many other languages.
That said, nothing in the infrastructure would preent you from pursuing
that, it'd just be a wrapper function for the generated exprs that
> Another question is whether it is sensible to redundantly do expensive work
> (llvm compilation) in all backends.
Right now we kinda have to, but I really want to get rid of
that. There's some pointers included as constants in the generated
code. I plan to work on getting rid of that requirement, but after
getting the basics in (i.e. realistically not this release). Even after
that I'm personally much more interested in caching the generated code
inside a backend, rather than across backends. Function addresses et
al being different between backends would add some complications, can be
overcome, but I'm doubtful it's immediately worth it.
> So before starting code generation, ExecReadyCompiledExpr can first
> build signature and check if correspondent library is already present.
> Also it will be easier to control space used by compiled libraries in
Right, I definitely think we want to do that at some point not too far
away in the future. That makes the applicability of JITing much broader.
More advanced forms of this are that you JIT in the background for
frequently executed code (so not to incur latency the first time
somebody executes). Aand/or that you emit unoptimized code the first
time through, which is quite quick, and run the optimizer after the
query has been executed a number of times.
|Next Message||Alvaro Herrera||2018-01-25 19:24:21||Re: [HACKERS] Proposal: Local indexes for partitioned table|
|Previous Message||Andres Freund||2018-01-25 19:12:42||Re: JIT compiling with LLVM v9.0|