Setup infrastructure at LLVM
We are currently moving to the LLVM infrastructure
Task | Status | Owner |
---|---|---|
Move to LLVM SVN | done http://llvm.org/svn/llvm-project/polly | Tobias |
Git mirror | done git://llvm.org/git/polly.git | Tobias |
Commit mails | done llvm-commits@cs.uiuc.edu | Tobias |
LLVM Bugzilla category | done LLVM Bugzilla (Product is 'Projects', Component is 'Polly') | Tobias |
Website | in progress
http://polly.grosser.es, later maybe polly.llvm.org | Tobias |
Buildbot that runs 'make polly-test' |
done http://google1.osuosl.org:8011/console | Tobias, Raghesh, Andreas |
Nightly performance/coverage tests (with the llvm test-suite) | Andreas |
Phase 2
The second phase of Polly can build on a robust, but very limited framework. In this phase work on removing limitations and extending the framework is planned. Also we plan the first very simple transformations. Furthermore the build system will be improved to simplify deployment.
Frontend | |||
---|---|---|---|
Task | Status | Owner | |
Support for casts in expressions | |||
Support multi dimensional arrays. | planning | Tobias | |
Alias sets | |||
Middle end | |||
Task | Status | Owner | |
Implement ISL dependency analysis pass | working | Tobias | |
Connect pocc/pluto | working | Tobias | |
Finish OpenSCoP support | Blocked (waiting for OpenSCoP) | ||
Add SCoPLib 0.2 support to connect pocc | done | Tobias | |
Write simple loop blocking | |||
Backend | |||
Task | Status | Owner | |
Code generation for non 64bit targets | |||
Add write support for data access functions | Still open | ||
Create vector loops | 70% done | Tobias | |
Create OpenMP loops | 90% done | Raghesh & Tobias | |
General tasks | |||
Task | Status | Owner | |
Commit RegionPass patch upstream | done | Tobias | |
Build against an installed LLVM | Partial (cmake build without tests) | ether | |
Setup buildbot regression testers using LNT | Still open |
Phase 1 - Get something working (Finished October 2010)
The first iteration of this project aims to create a minimal working version of this framework, that is capable to transform an LLVM-IR program to the polyhedral model and back to LLVM-IR without applying any transformations.
Frontend | |||
---|---|---|---|
Task | Status | Owner | |
Region detection | Working + Committed upstream | Ether | |
Access Functions | Working | John + Ether | |
Alias sets | Still open | ||
Scalar evolution to affine expression | Done | Ether | |
SCoP extraction | Working | Tobias + Ether | |
SCoPs to polyhedral model | Working | Tobias + Ether | |
Middle end | |||
Task | Status | Owner | |
Define polyhedral description | Working | Tobias | |
Import/Export using current openscop version | Working | Tobias | |
Backend | |||
Task | Status | Owner | |
Create LLVM-IR using CLooG | Working | Tobias | |
General tasks | |||
Task | Status | Owner | |
Setup git repositories | Done | Tobias | |
Add CLooG/isl to build system | Works on Unix | Tobias |
Further projects
There are several great projects related to polly that can already be started or are possible in the near future.
Extend the post dominance analysis for infinite loops (small)
At the moment the post dominance analysis cannot handle infinite loops. All basic blocks in the CFG that do not return are - at the moment - not part of the post dominance tree. However by adding some virtual edges, they could be added to the post dominator tree. Where to add the edges needs some research.
This is a small project, that is is well defined. As it is directly in LLVM it can be easily committed upstream. It is useful for polly, as the RegionInfo pass will be able to detect regions in parts of the CFG that never return.
A good starter to get into LLVM
Vectorization
It is planned to use Polly to support vectorization in LLVM.
The basic idea is to use Polly and the polyhedral tools to transform code such that the innermost loops can be executed in parallel. Afterwards during code generation in LLVM the loops will be created using vector instructions.
To start we plan to use Pluto to transform the loop nests. Pluto can generate vector parallel code and annotate the vector parallel loops. Some impressive results were shown on code that was afterwards vectorized by the icc enforcing vectorization. We believe LLVM can do even better, as it can interact directly with the polyhedral information.
As an example simple matrix multiplication:
for(i=0; i<M; i++) for(j=0; j<N; j++) for(k=0; k<K; k++) C[i][j] = beta*C[i][j] + alpha*A[i][k] * B[k][j];
After plutos transformations with added tiling and vectorization hints:
if ((K >= 1) && (M >= 1) && (N >= 1)) for (t1=0;t1<=floord(M-1,32);t1++) for (t2=0;t2<=floord(N-1,32);t2++) for (t3=0;t3<=floord(K-1,32);t3++) for (t4=32*t1;t4<=min(M-1,32*t1+31);t4++) for (t5=32*t3;t5<=min(K-1,32*t3+31);t5++) { lbv=32*t2; ubv=min(N-1,32*t2+31); #pragma ivdep #pragma vector always for (t6=lbv; t6<=ubv; t6++) C[t4][t6]=beta*C[t4][t6]+alpha*A[t4][t5]*B[t5][t6];; }
In this example the innermost loop is parallel without any dependencies.