llvm.org GIT mirror llvm / ed5ec7b
Polly subproject release notes By Tobias Grosser! git-svn-id: https://llvm.org/svn/llvm-project/llvm/branches/release_37@246053 91177308-0d34-0410-b5e6-96231b3b80d8 Hans Wennborg 4 years ago
1 changed file(s) with 108 addition(s) and 0 deletion(s). Raw diff Collapse all Expand all
245245 encouraged to try ORC out for their projects. (A good place to start is the
246246 new ORC tutorials under llvm/examples/kaleidoscope/orc).
247247
248 Sub-project Status Update
249 =========================
250
251 In addition to the core LLVM 3.7 distribution of production-quality compiler
252 infrastructure, the LLVM project includes sub-projects that use the LLVM core
253 and share the same distribution license. This section provides updates on these
254 sub-projects.
255
256 Polly - The Polyhedral Loop Optimizer in LLVM
257 ---------------------------------------------
258
259 `Polly `_ is a polyhedral loop optimization
260 infrastructure that provides data-locality optimizations to LLVM-based
261 compilers. When compiled as part of clang or loaded as a module into clang,
262 it can perform loop optimizations such as tiling, loop fusion or outer-loop
263 vectorization. As a generic loop optimization infrastructure it allows
264 developers to get a per-loop-iteration model of a loop nest on which detailed
265 analysis and transformations can be performed.
266
267 Changes since the last release:
268
269 * isl imported into Polly distribution
270
271 `isl `_, the math library Polly uses, has been
272 imported into the source code repository of Polly and is now distributed as part
273 of Polly. As this was the last external library dependency of Polly, Polly can
274 now be compiled right after checking out the Polly source code without the need
275 for any additional libraries to be pre-installed.
276
277 * Small integer optimization of isl
278
279 The MIT licensed imath backend using in `isl `_ for
280 arbitrary width integer computations has been optimized to use native integer
281 operations for the common case where the operands of a computation fit into 32
282 bit and to only fall back to large arbitrary precision integers for the
283 remaining cases. This optimization has greatly improved the compile-time
284 performance of Polly, both due to faster native operations also due to a
285 reduction in malloc traffic and pointer indirections. As a result, computations
286 that use arbitrary precision integers heavily have been speed up by almost 6x.
287 As a result, the compile-time of Polly on the Polybench test kernels in the LNT
288 suite has been reduced by 20% on average with compile time reductions between
289 9-43%.
290
291 * Schedule Trees
292
293 Polly now uses internally so-called > Schedule Trees < to model the loop
294 structure it optimizes. Schedule trees are an easy to understand tree structure
295 that describes a loop nest using integer constraint sets to keep track of
296 execution constraints. It allows the developer to use per-tree-node operations
297 to modify the loop tree. Programatic analysis that work on the schedule tree
298 (e.g., as dependence analysis) also show a visible speedup as they can exploit
299 the tree structure of the schedule and need to fall back to ILP based
300 optimization problems less often. Section 6 of `Polyhedral AST generation is
301 more than scanning polyhedra
302 `_ gives a detailed
303 explanation of this schedule trees.
304
305 * Scalar and PHI node modeling - Polly as an analysis
306
307 Polly now requires almost no preprocessing to analyse LLVM-IR, which makes it
308 easier to use Polly as a pure analysis pass e.g. to provide more precise
309 dependence information to non-polyhedral transformation passes. Originally,
310 Polly required the input LLVM-IR to be preprocessed such that all scalar and
311 PHI-node dependences are translated to in-memory operations. Since this release,
312 Polly has full support for scalar and PHI node dependences and requires no
313 scalar-to-memory translation for such kind of dependences.
314
315 * Modeling of modulo and non-affine conditions
316
317 Polly can now supports modulo operations such as A[t%2][i][j] as they appear
318 often in stencil computations and also allows data-dependent conditional
319 branches as they result e.g. from ternary conditions ala A[i] > 255 ? 255 :
320 A[i].
321
322 * Delinearization
323
324 Polly now support the analysis of manually linearized multi-dimensional arrays
325 as they result form macros such as
326 "#define 2DARRAY(A,i,j) (A.data[(i) * A.size + (j)]". Similar constructs appear
327 in old C code written before C99, C++ code such as boost::ublas, LLVM exported
328 from Julia, Matlab generated code and many others. Our work titled
329 `Optimistic Delinearization of Parametrically Sized Arrays
330 `_ gives details.
331
332 * Compile time improvements
333
334 Pratik Bahtu worked on compile-time performance tuning of Polly. His work
335 together with the support for schedule trees and the small integer optimization
336 in isl notably reduced the compile time.
337
338 * Increased compute timeouts
339
340 As Polly's compile time has been notabily improved, we were able to increase
341 the compile time saveguards in Polly. As a result, the default configuration
342 of Polly can now analyze larger loop nests without running into compile time
343 restrictions.
344
345 * Export Debug Locations via JSCoP file
346
347 Polly's JSCoP import/export format gained support for debug locations that show
348 to the user the source code location of detected scops.
349
350 * Improved windows support
351
352 The compilation of Polly on windows using cmake has been improved and several
353 visual studio build issues have been addressed.
354
355 * Many bug fixes
248356
249357 External Open Source Projects Using LLVM 3.7
250358 ============================================