CS 515: Programming Languages and Compilers I
Fall 20011, Project 3
A Vectorizing Compiler
Due date: Saturday, December 17, at 11:59pm EST

Modifications and Clarifications

• Unfortunately, we will not be able to provide the API that will allow you to easily distribute the loop header around strongly connected components. Instead, please only reorder your SCC within the loop body, and mark statements as vector statements.

Project Description

The basic vectorization algorithm has the following steps

• Parsing: Convert input program into an internal representation of the for loop.
• Walk over the array references in each assignment statement of the for loop
  • Build a node in the statement-level dependence graph representing the assignment statement.
  • Perform dependence testing for each pair of array references within a statement and across statements; if a dependence exists enter a corresponding edge into the statement-level dependence graph.
  • Edges in the dependence graph are directed, and are either true, anti, or output dependences
• Find the strongly connected components (SCCs) in the statement-level dependence graph.
• Visit the SCCs in topological order
  • If there are two or more statements in the SCC, generate a sequential for loop nest. The reason for this is that there must be a recurrence between the statements that will prohibit vectorization.
  • If there is only a single statement in the SCC, check whether there is a (loop carried) true dependence on the statement. If yes, generate a sequential for loop nest. Otherwise, generate a vector loop nest (vector statement). Note that in vectorization, loop-carried anti-dependences on single statement SCCs do not inhibit vector execution and loop-carried output dependences cannot be generated given our restriction on the form of array index expressions.

1. Single statement SCC; no dependences

        for (i=0; i<100; i++) {
   S1:    a[i] = a[i] + 1      is transformed to      S1:   a[0:99] = a[0:99] + 1;
        }
   

   Since our system cannot generate vector statements, your compiler should generated the following code where vector statements are represented as single statement loops with the statement flagged as vectorizable. Sequential loops remain unchanged, i.e., are not flagged.

        for (i=0; i<100; i++) {
          /* vector statement */ a[i] = a[i] + 1;  
        }
   

2. Multipe statement SCC; loop carried dependences; code generation in topological order

        for (i=1; i<99; i++) {                                  S2:  b[1:98] = (c[1:98] + b[2:99]) / 2; 
   S1:    a[i] = b[i-1] + c[i-1] + 5;                                for (i=1; i<99; i++) {
   S2:    b[i] = (c[i] + b[i+1]) / 2;   is transformed to       S1:    a[i] = b[i-1] + c[i-1] + 5; 
   S3:    c[i] = a[i] + 1;                                      S3:    c[i] = a[i] + 1;
        }                                                            }
   

   UPDATED OUTPUT CODE - NO LOOP DISTRIBUTION
   The code that your compiler should generate is:

        for (i=1; i<99; i++) {
          /* vector statement */ b[i] = (c[i] + b[i+1]) / 2;
          a[i] = b[i-1] + c[i-1] + 5;
          c[i] = a[i] + 1;
        }
   

3. Dependence testing that considers loop bounds

        for (i=1; i<99; i++) {
   S1:    a[i] = a[i] + a[0] + a[99]     is transformed into      S1: a[1:98] = a[1:98] + a[0] + a[99];
        }
   

   The code that your compiler should generate is:

        for (i=1; i<99; i++) {
          /* vector statement */ a[i] = a[i] + a[0] + a[99];
        }
   

   
   

You will need to find strongly connected components (SCC) of the dependence graph and get a topological ordering of the SCC. For example, the topological ordering of SCC of the following graph is:

1. [ 1 ]
2. [ 2 3 4 ]
3. [ 5 6 ]
               __________
              /          v
1 --> 2 ---> 3 --> 5 --> 6
      ^     /      ^____/
      |    /
      4 <-'

Provided infrastructure

For this project, you are given C++ code that uses the LLVM libraries to traverse a C source file and extract information about a FOR loop. You will use this information to do your dependency analysis to determine if and how the assignment statements in the loop can be vectorized.

BUILD INSTRUCTIONS

You can copy all provided code files into your project subdirectory, for example "myProject", by using the following UNIX/Linux command on any ilab machine :

  cp -r  ~uli/cs515/projects/proj3 myProject 

To build the project, you need to add the path to the LLVM executables to your iLab PATH environment variable. In bash, this is done as follows:

  export PATH=$PATH:/ilab/users/jasperry/llvm-2.9/bin

  setenv PATH ${PATH}:/ilab/users/jasperry/llvm-2.9/bin

IMPORTANT: Make sure that your input source file contains no #includes, only one main() function, and a SINGLE for loop in the body. You can follow the pattern of the provided "in.c".

How to get started

The main function is found in "analyze.cpp". It creates an object of type LoopAnalyzer, which is derived from LLVM's ASTConsumer class. LoopAnalyzer has a method "processForLoop" that does most of the work. You don't need to know anything about the internals of LoopAnalyzer; you just call "parse" as in the sample code. After your analysis is finished, you need to call the method "writeSource" to write out the final result. This is also provided in the main function of "analyze.cpp".

You need to know primarily about two other classes: SubscriptExpr and LoopInfo. A SubscriptExpr represents one subscript expression for a single-dimensional array. A SubscriptExpr object, defined in SubscriptExpr.h, contains the name of the array, the number of the statement to which the subscript expression belongs, and a list of coefficients. You will not need to use the coefficients directly yourself; they are used by the dependency checking functions you are given. What you WILL need to know is which statement the reference is in, and the name of the arry it's in. You can get these by the public members "stmtIndex" and "arrayName".

To help your debugging, you can print a SubscriptExpr to the standard output using

    llvm::outs() << expr;

Integers in the object language are represented by the datatype llvm::APSInt. You can operate on these as normal integers and print them out using llvm::outs(), but their type is not compatible with C++ (metalanguage) ints.

After the LoopAnalyzer traverses the source, its member LoopInfo object will contain all the information you need to do the remainder of the project. The LoopInfo class stores information about a FOR loop structure, including its index variable and bounds, plus two vectors of SubscriptExpr's: "reads" and "writes". You should examine the header file "LoopInfo.h" to understand what data and methods are available to you.

The LoopInfo object also contains the methods "insertStatementComment" for inserting comments before each of the statements in the FOR loop, and "replaceStmt" which can be used to reorder the statements inside the loop. These are the methods you will use to generate the main output of the project. Because of the way the code rewriting architecture works, you MUST reorder the statements BEFORE inserting comments.