[llvm-dev] [GSoC 2016] Enabling Polyhedral Optimizations in Julia - Midterm Report
Matthias Reisinger via llvm-dev
llvm-dev at lists.llvm.org
Tue Jun 21 17:15:30 PDT 2016
in an earlier post, students working on LLVM were asked to provide a short
their GSoC project. in the following I want to give an overview on the
current status of my
GSoC project and outline my next planned activities. Since my mentoring
organization is Julia,
I also send this to the according mailing list.
*1. Activities so far:*
As described in my proposal , I am working on making available Polly's
optimizations on Julia.
Within the pull-requests  and  I integrated Polly into Julia's
LLVM-based JIT infrastructure.
Polly can now be explicitly used to optimize Julia functions that are
annotated with the newly
introduced `@polly` macro. You may also read my blog post  on this
topic, which illustrates how
these new features can be used in Julia. In a next step I used first micro
benchmarks to analyze
the LLVM code that Julia produces internally and tried to determine
characteristics of the produced
code that prevents Polly from applying its optimizations. For a more
I ported the PolyBench benchmark suite to Julia. My recent blog post 
provides more details on this.
These benchmarks helped to identify Julia constructs which hinder Polly's
SCoP detection. `for`-loops
for which both the lower and the upper bound are parametric are lowered to
LLVM code that restrain
ScalarEvolution analysis and has been discussed in the bug report at .
It was possible to solve
this problem and I will shortly supply a patch for this. Another language
construct that is lowered to
LLVM IR that limits the optimization potential are Julia's `StepRange`s.
More concretely, this regards
loops of the form `for i = lower_bound:step:upper_bound`. They will prevent
when occurring inside other loops.
*2. Next steps:*
It is planned to complete the analysis of Polly on Julia code on the
existing benchmarks and solve the
problems mentioned above. Furthermore, I plan to extend the analysis to
find critical code
parts. Therefore I plan to use computation kernels from Julia's base
library to detect further regions that
cause Polly to fail to perform optimizations.
When the necessary corrections make it possible to apply Polly to a
reasonably large amount of Julia
programs it is furthermore planned to enhance Polly's
bound-check-elimination to work in Julia. So far
it is only possible to optimize Julia code that does not contain
bound-checks, that means currently they
have to be turned off explicitly (either through the `@inbounds` macro or
via Julia's `--check-bounds=no`
command-line switch). The aim is to be able to use Polly in the presence of
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the llvm-dev