[polly] Fixed a number of typos

[GabrielRavier]

Summary

I went over the output of the following mess of a command:

(ulimit -m 2000000; ulimit -v 2000000; git ls-files -z | parallel --xargs -0 cat | aspell list --mode=none --ignore-case | grep -E '^[A-Za-z][a-z]*$' | sort | uniq -c | sort -n | grep -vE '.{25}' | aspell pipe -W3 | grep : | cut -d' ' -f2 | less)

and proceeded to spend a few days looking at it to find probable typos
and fixed a few hundred of them in all of the llvm project (note, the
ones I found are not anywhere near all of them, but it seems like a
good start).

[inclyc]

LGTM. However I think it is a good idea that we can leave these typos here, and create good first issues for some who doesn't have commit access. And perhaps we also need other reviewers' opinion (those who write these document etc.). You can add reviewers by searching git blame.

[GabrielRavier]

Well, I myself do not have commit access to LLVM, so I suppose this serves as a "good first issue" for me 😅

[inclyc]

Okay, could you provide your real name and email address? like "My Name <[e-mail]>", so that I can commit this for you. Also feel free to ask for commit access.

[inclyc]

I noticed that your github account seems to be a member of llvm, do you already have the commit access? If so, you can just commit this yourself.

[GabrielRavier]

In D131167#3704733, @inclyc wrote:

Okay, could you provide your real name and email address? like "My Name <[e-mail]>", so that I can commit this for you. Also feel free to ask for commit access.

Gabriel Ravier <[e-mail]>

In D131167#3704734, @inclyc wrote:

I noticed that your github account seems to be a member of llvm, do you already have the commit access? If so, you can just commit this yourself.

I believe the reason my GitHub account is a member of the LLVM organization is that it had to be in order to migrate my comments on the Bugzilla properly

[GabrielRavier]

In D131167#3704734, @inclyc wrote:

I noticed that your github account seems to be a member of llvm, do you already have the commit access? If so, you can just commit this yourself.

(PS: just to be clear, no I do not have commit access and have tried to push to check if I did (and was unsuccessful))

polly/docs/HowToManuallyUseTheIndividualPiecesOfPolly.rst

-------------------------------------
                 clang -S -emit-llvm matmul.c -Xclang -disable-O0-optnone -o matmul.ll
 
 
 2. **Prepare the LLVM-IR for Polly**
 ------------------------------------
 
         Polly is only able to work with code that matches a canonical form.
         To translate the LLVM-IR into this form we use a set of
-        canonicalication passes. They are scheduled by using
+        canonicalization passes. They are scheduled by using
         '-polly-canonicalize'.
 
         .. code-block:: console
 
                 opt -S -polly-canonicalize matmul.ll -o matmul.preopt.ll
 
 3. **Show the SCoPs detected by Polly (optional)**
 --------------------------------------------------

polly/include/polly/Support/VirtualInstruction.h

 
 public:
   /// Get a VirtualUse for an llvm::Use.
   ///
   /// @param S       The Scop object.
   /// @param U       The llvm::Use the get information for.
   /// @param LI      The LoopInfo analysis. Needed to determine whether the
   ///                value is synthesizable.
-  /// @param Virtual Whether to ignore existing MemoryAcccess.
+  /// @param Virtual Whether to ignore existing MemoryAccess.
   ///
   /// @return The VirtualUse representing the same use as @p U.
   static VirtualUse create(Scop *S, const Use &U, LoopInfo *LI, bool Virtual);
 
   /// Get a VirtualUse for uses within statements.
   ///
   /// It is assumed that the user is not a PHINode. Such uses are always
   /// VirtualUse::Inter unless in a regions statement.

polly/lib/CodeGen/ManagedMemoryRewrite.cpp

static void rewriteOldValToNew(Instruction *Inst, Value *OldVal, Value *NewVal,
   for (Instruction *I : InstsToVisit)
     I->replaceUsesOfWith(OldVal, NewVal);
 }
 
 // Given a value `Current`, return all Instructions that may contain `Current`
 // in an expression.
 // We need this auxiliary function, because if we have a
 // `Constant` that is a user of `V`, we need to recurse into the
-// `Constant`s uses to gather the root instruciton.
+// `Constant`s uses to gather the root instruction.
 static void getInstructionUsersOfValue(Value *V,
                                        SmallVector<Instruction *, 4> &Owners) {
   if (auto *I = dyn_cast<Instruction>(V)) {
     Owners.push_back(I);
   } else {
     // Anything that is a `User` must be a constant or an instruction.
     auto *C = cast<Constant>(V);
     for (Use &CUse : C->uses())

polly/lib/Transform/ManualOptimizer.cpp

if (ORE) {
                                                   TransformLoc, CodeRegion)
                 << (Twine("not applying ") + TransformationName +
                     ": cannot ensure semantic equivalence due to possible "
                     "dependency violations")
                        .str());
     }
 
     // If illegal, revert and remove the transformation to not risk re-trying
-    // indefintely.
+    // indefinitely.
     MDNode *NewLoopMD =
         makePostTransformationMetadata(Ctx, LoopMD, {TransPrefix}, {});
     BandAttr *Attr = getBandAttr(OrigBand);
     Attr->Metadata = NewLoopMD;
 
     // Roll back old schedule.
     return OrigBand.get_schedule();
   }

polly/lib/Transform/ScheduleTreeTransform.cpp

 
 public:
   isl::schedule visitBand(isl::schedule_node_band RootBand) {
     isl::schedule_node_band Band = RootBand;
     isl::ctx Ctx = Band.ctx();
 
     // Do not merge permutable band to avoid loosing the permutability property.
     // Cannot collapse even two permutable loops, they might be permutable
-    // individually, but not necassarily accross.
+    // individually, but not necassarily across.
     if (unsignedFromIslSize(Band.n_member()) > 1u && Band.permutable())
       return getBase().visitBand(Band);
 
     // Find collapsable bands.
     SmallVector<isl::schedule_node_band> Nest;
     int NumTotalLoops = 0;
     isl::schedule_node Body;
     while (true) {

polly/test/CodeGen/non-affine-update.ll

 ; RUN: opt %loadPolly -polly-import-jscop \
 ; RUN:     -polly-codegen -S < %s | FileCheck %s
 ;
 ;    void non-affine-update(double A[], double C[], double B[]) {
 ;      for (int i = 0; i < 10; i++) {
 ;        if (A[i] >= 6)
 ;          B[i] += 42;
 ;        else
 ;          C[i] += 3;
 ;      }
 ;    }
 
-; Verify that all changed memory access functions are corectly code generated.
+; Verify that all changed memory access functions are correctly code generated.
 ; At some point this did not work due to memory access identifiers not being
 ; unique within non-affine scop statements.
 
 ; CHECK: polly.stmt.bb2:
 ; CHECK:   %scevgep = getelementptr double, double* %A, i64 %polly.indvar
 
 ; CHECK: polly.stmt.bb9:
 ; CHECK:   %polly.access.C{{.*}} = getelementptr double, double* %C, i64 42

polly/test/ForwardOpTree/changed-kind.ll

 ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
 
 ; In the code below, %0 is known to be equal to the content of @c (constant 0).
 ; Thus, in order to save a scalar dependency, forward-optree replaces
 ; the use of %0 in Stmt_lor_end93 by a load from @c by changing the
 ; access find from a scalar access to a array accesses.
-; llvm.org/PR48034 decribes a crash caused by the mid-processing change.
+; llvm.org/PR48034 describes a crash caused by the mid-processing change.
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @c = external dso_local global i64, align 8
 
 define void @func()  {
 entry:

polly/test/ScopDetect/non-affine-loop.ll

 ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false                                                          -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
 ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true                                                           -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
 ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-allow-nonaffine                                   -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINEREGIONSANDACCESSES
 ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true  -polly-allow-nonaffine                                   -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
 ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true  -polly-allow-nonaffine -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=PROFIT
 ;
 ; This function/region does contain a loop, however it is non-affine, hence the access
 ; A[i] is also. Furthermore, it is the only loop, thus when we over approximate
-; non-affine loops __and__ accesses __and__ allow regins without a (affine) loop we will
+; non-affine loops __and__ accesses __and__ allow regions without a (affine) loop we will
 ; detect it, otherwise we won't.
 ;
 ;    void f(int *A) {
 ;      for (int i = 0; i < A[i]; i++)
 ;        A[-1]++;
 ;    }
 ;
 ; REJECTNONAFFINELOOPS-NOT:              Valid

polly/test/ScopDetectionDiagnostics/ReportVariantBasePtr-01.ll

 ; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -disable-output < %s 2>&1| FileCheck %s
 
 ; struct b {
 ;   double **b;
 ; };
 ;
 ; void a(struct b *A) {
 ;   for (int i=0; i<32; i++)
 ;     A[i].b[i] = 0;
 ; }
 
 ; The loads are currently just adds %7 to the list of required invariant loads
 ; and only -polly-scops checks whether it is actionally possible the be load
 ; hoisted. The SCoP is still rejected by -polly-detect because it may alias
-; with %A and is not considered to be eligble for runtime alias checking.
+; with %A and is not considered to be eligible for runtime alias checking.
 
 ; CHECK: remark: ReportVariantBasePtr01.c:6:8: The following errors keep this region from being a Scop.
 ; CHECK: remark: ReportVariantBasePtr01.c:7:5: Accesses to the arrays "A", " <unknown> " may access the same memory.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 %struct.b = type { double** }
 

polly/test/ScopInfo/aliasing_conditional_alias_groups_2.ll

 ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
 ;
-; Check that we create two alias groups since the mininmal/maximal accesses
+; Check that we create two alias groups since the minimal/maximal accesses
 ; depend on %b.
 ;
 ; CHECK: Alias Groups (2):
 ;
 ;    void jd(int b, int *A, int *B) {
 ;      for (int i = 0; i < 1024; i++) {
 ;        if (b)
 ;          A[i] = B[5];

polly/test/ScopInfo/aliasing_many_parameters_not_all_involved.ll

 ; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-print-scops -polly-rtc-max-parameters=8 -disable-output < %s | FileCheck %s --check-prefix=MAX8
 ; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-print-scops -polly-rtc-max-parameters=7 -disable-output < %s | FileCheck %s --check-prefix=MAX7
 ;
-; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses.
+; Check that we allow this SCoP even though it has 10 parameters involved in possibly aliasing accesses.
 ; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A.
 ;
 ; MAX8-LABEL:  Function: jd
 ; MAX8-NEXT: Region: %for.cond---%for.end
 
 ; MAX7:  Invalid Scop!
 ;
 ;    void jd(int *A, int *B, int *C, long p1, long p2, long p3, long p4, long p5,

polly/test/ScopInfo/extract_constant_factor_introduces_new_parameter.ll

 ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
 ; RUN: opt %loadPolly -polly-scops -disable-output < %s
 
 ; CHECK: Valid Region for Scop: bb10 => bb16
 
 ; Verify that -polly-scops does not crash. At some point this piece of
 ; code crashed as we extracted from the SCEV expression:
 ;
 ;    ((8 * ((%a * %b) + %c)) + (-8 * %a))'
 ;
 ; the constant 8, which resulted in the new expression:
 ;
 ;    (((-1 + %b) * %a) + %c)
 ;
 ; which introduced a new parameter (-1 + %b) * %a which was not registered
 ; correctly and consequently caused a crash due to an expression not being
-; regiustered as a parameter.
+; registered as a parameter.
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 define void @barney(i32* %arg, i32* %arg1, double* %arg2, i32* %arg3, i32 %a, i32 %b, i32 %c) {
 bb:
   br label %bb10
 
 bb10:                                             ; preds = %bb

polly/test/ScopInfo/invalid_add_rec_after_invariant_load_remapping.ll

 ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s
 ;
-; This crased at some point as we place %1 and %4 in the same equivalence class
+; This crashed at some point as we place %1 and %4 in the same equivalence class
 ; for invariant loads and when we remap SCEVs to use %4 instead of %1 AddRec SCEVs
 ; for the for.body.10 loop caused a crash as their operands were not invariant
 ; in the loop. While we know they are, ScalarEvolution does not. However, we can simply
 ; rewrite the AddRecs to hoist everything from the "start" out of the AddRec.
 ;
 ; Check we do not crash.
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_3.ll

 ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
 ; RUN:  -polly-invariant-load-hoisting \
 ; RUN:  | FileCheck %s
 
 ; Verify that we canonicalize accesses even tough one of the accesses (even
 ; the canonical base) has a partial execution context. This is correct as
-; the combined execution context still coveres both accesses.
+; the combined execution context still covers both accesses.
 
 ; CHECK:      Invariant Accesses: {
 ; CHECK-NEXT:         ReadAccess := [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             { Stmt_body2[i0] -> MemRef_A[0] };
 ; CHECK-NEXT:         Execution Context: {  :  }
 ; CHECK-NEXT: }
 
 ; CHECK:      Stmt_body1

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_4.ll

 ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
 ; RUN:  -polly-invariant-load-hoisting \
 ; RUN:  | FileCheck %s
 
 ; Verify that a delinearized and a not delinearized access are not
-; canonizalized.
+; canonicalized.
 
 ; CHECK:      Stmt_body1
 ; CHECK-NEXT:   Domain :=
 ; CHECK-NEXT:       [n] -> { Stmt_body1[i0] : 0 <= i0 <= 1022 };
 ; CHECK-NEXT:   Schedule :=
 ; CHECK-NEXT:       [n] -> { Stmt_body1[i0] -> [i0, 0] };
 ; CHECK-NEXT:   MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:       [n] -> { Stmt_body1[i0] -> MemRef_baseB[0] };

polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll

 ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -debug -disable-output < %s 2>&1 | FileCheck %s
 
 ; REQUIRES: asserts
 
 ; This test case at some point crashed Polly due to a 'division by zero'
 ; when trying to fold the constant dimension into outer dimension.
 ; We verify that this scop is detected without crash. We also test the
-; output to undertand that the scop has been analyzed, but has also been
+; output to understand that the scop has been analyzed, but has also been
 ; invalidated due to the zero size dimension.
 
 ; CHECK: Assumed Context:
 ; CHECK-NEXT: {  : false }
 ; CHECK-NEXT: Invalid Context:
 ; CHECK-NEXT: {  : false }
 ; CHECK:      Arrays {
 ; CHECK-NEXT:     i8 MemRef_arg[*][0]; // Element size 1

polly/test/ScopInfo/multidim_many_references.ll

 ;         for(k = 1 ; k < a1->deps-1; k++)
 ;           M(a19,i,j,k) = M(a1,i,j,k) + ... + M(a18,i,j,k);
 ; }
 ;
 ; We applied some loop invariant code motion to ensure the loads from m->data,
 ; m->rows, m->cols and m->deps happen before the scop.
 
 ; This test case verifies that the construction of the assumed context finishes
-; successfully. Depending on how constraineds are accummulated in the assumed
+; successfully. Depending on how constrained are accumulated in the assumed
 ; context, this test case can take even for a smaller number of arrays over a
 ; minute to complete. With the unrolling choosen in this test, an inefficient
 ; formulation of the assumption tracking cause LLVM to crash due to excessive
 ; memory usage due to an overly large number of disjuncts being formed.
 
 %struct.Mat = type { float*, i64, i64, i64 }
 
 ; CHECK: Assumed Context:

polly/test/ScopInfo/ranged_parameter.ll

 ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
 ;
-; Check that the contstraints on the paramater derived from the
+; Check that the constraints on the parameter derived from the
 ; range metadata (see bottom of the file) are present:
 ;
 ; CHECK: Context:
 ; CHECK:   [tmp] -> {  : 0 <= tmp <= 255 }
 ;
 ;    void jd(int *A, int *p /* in [0,256) */) {
 ;      for (int i = 0; i < 1024; i++)
 ;        A[i + *p] = i;

polly/test/ScopInfo/redundant_parameter_constraint.ll

 ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
 ;
-; The constraint that r2 has to be bigger than r1 is implicitly containted in
+; The constraint that r2 has to be bigger than r1 is implicitly contained in
 ; the domain, hence we do not want to see it explicitly.
 ;
 ; CHECK-NOT:  r2 >= 1 + r1
 ;
 ;    void wraps(int *A, int p, short q, char r1, char r2) {
 ;      for (char i = r1; i < r2; i++)
 ;        A[p + q] = A[(int)r1 + (int)r2];
 ;    }

polly/test/ScopInfo/scalar_to_array.ll

 ; RUN: opt %loadPolly -basic-aa -polly-print-scops -disable-output < %s | FileCheck %s
 ; RUN: opt %loadPolly -basic-aa -polly-print-function-scops -disable-output < %s | FileCheck %s
 
 ; ModuleID = 'scalar_to_array.ll'
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 
 @A = common global [1024 x float] zeroinitializer, align 8
 
-; Terminating loops without side-effects will be optimzied away, hence
+; Terminating loops without side-effects will be optimized away, hence
 ; detecting a scop would be pointless.
 ; CHECK-NOT: Function: empty
 ; Function Attrs: nounwind
 define i32 @empty() #0 {
 entry:
   fence seq_cst
   br label %for.cond
 

polly/test/Simplify/out-of-scop-use-in-region-entry-phi-node.ll

 ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -polly-print-simplify -disable-output < %s | FileCheck %s
 ;
 ; %tmp5 must keep the Value WRITE MemoryAccess, because as an incoming value of
 ; %tmp4, it is an "external use".
 ;
 ; A common mistake is to assume that %tmp5 is used by %tmp4 in bb3, when
-; practially it's the incoming block %bb9 which is the user.
+; practically it's the incoming block %bb9 which is the user.
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @hoge() {
 bb:
   br label %bb2
 
 bb2:                                              ; preds = %bb

polly/tools/GPURuntime/GPUJIT.h

 /*                                                                            */
 /******************************************************************************/
 
 #ifndef GPUJIT_H_
 #define GPUJIT_H_
 #include "stddef.h"
 
 /*
- * The following demostrates how we can use the GPURuntime library to
+ * The following demonstrates how we can use the GPURuntime library to
  * execute a GPU kernel.
  *
  * char KernelString[] = "\n\
  *   .version 1.4\n\
  *   .target sm_10, map_f64_to_f32\n\
  *   .entry _Z8myKernelPi (\n\
  *   .param .u64 __cudaparm__Z8myKernelPi_data)\n\
  *   {\n\

polly/www/documentation/gpgpucodegen.html

 </tr>
 <tr>
 <th align="left">GPU Runtime Library Implementation</th>
 <td align="center" class='inprogress'>Coding Finished, In Reviewing</td>
 <td></td>
 </tr>
 <tr>
 <th align="left">llvm.codegen Intrinsic Implementation</th>
-<td align="center" class='inprogress'>Codeing Finished, To Be Reviewed</td>
+<td align="center" class='inprogress'>Coding Finished, To Be Reviewed</td>
 <td></td>
 </tr>
 <tr>
 <th align="left">Code Generation For Host</th>
 <td align="center" class='inprogress'>50% Done</td>
 <td></td>
 </tr>
 

polly/www/index.html

<ul>
       <li><b>Isolation for full/partial tile separation:</b> We discuss native
       support for handling full/partial tile separation and -- in general --
       native support for isolation of boundary cases to enable smooth code
       generation for core computations.
       <li><b>AST generation with modulo constraints:</b> We discuss how modulo
       mappings are lowered to efficient C/LLVM code.
       <li><b>User-defined constraint sets for run-time checks</b> We discuss how
       arbitrary sets of constraints can be used to automatically create run-time
-      checks that ensure a set of constrainst actually hold. This feature is
+      checks that ensure a set of constraints actually hold. This feature is
       very useful to verify at run-time various assumptions that have been taken
       program optimization.
     </ul>
 
    <a href="https://www.grosser.es#pub-polyhedral-AST-generation">
    <em>Polyhedral AST generation is more than scanning polyhedra</em></a><br />
     Tobias Grosser, Sven Verdoolaege, Albert Cohen<br />
     ACM Transations on Programming Languages and Systems (TOPLAS), 37(4),
<div id="content">
   </tr>
   <tr><td><b>2014</b></td></tr>
   <tr><td width="120"><p>August</p></td>
   <td>
   <h4>Polly drops the support of ScopLib and the external optimizer PoCC</h4>
   The support for ScopLib as an exchange format has been removed as recent
   versions of clan, candl and pluto all support the OpenScop exchange format.
 
-  The support of the external optmizer PoCC has been dropped in favor of the
+  The support of the external optimizer PoCC has been dropped in favor of the
   isl optimizer (default) and the still available pluto support.
   </td>
   </tr>
   <tr><td><b>2014</b></td></tr>
   <tr><td width="120"><p>June</p></td>
   <td>
   <h4>Polly can be built without GPL licensed software</h4> After Sebastian
   Pop's
   and David Peixotto's (both Qualcomm) recent <a
   href="https://repo.or.cz/w/isl.git/commit/60703e3ee89b9d5d4d1afb6a3f611292c0884574">commit</a>
   to isl, isl's latest development version can be built with imath instead of
-  GMP. With both CLooG and gmp having become optional, the last obilgatory
+  GMP. With both CLooG and gmp having become optional, the last obligatory
   dependency to GPL licensed software has been removed. Now Polly only depends
   on isl (and the included imath), which are both MIT licensed.
   </td>
   </tr>
   <tr><td width="120"><p>April</p></td>
   <td>
   <h4>Polly Phone Call - 23April</h4>
   We had a polly phone call about delinearizing array accesses (II)<a
research tool.<br \>
   <tr>
   <td><p> Januar</p></td>
   <td><p> Basic OpenMP support, Alias analysis integration,
   Pluto/POCC support </p></td>
   </tr>
 
   <tr><td><b><br>2010</b></td></tr>
   <tr>
-  <td><p> Dezember </p></td>
+  <td><p> December </p></td>
   <td><p>Basic vectorization support </p></td>
   </tr>
 
   <tr>
   <td><p> November </p></td>
   <td><p>Talk at the <a
   href="https://llvm.org/devmtg/2010-11/">LLVM Developer Meeting</a> </p></td>
   </tr>

polly/www/performance.html

 point values on an Intel Core Xeon X5670 CPU @ 2.93GHz (12 cores, 24 thread)
 system. We used <a href="https://sourceforge.net/projects/pocc/files/">PoCC</a> and the included <a
 href="http://pluto-compiler.sf.net">Pluto</a> transformations to optimize the
 code. The source code of Polly and LLVM/clang was checked out on
 25/03/2011.</p>
 
 <p>The results shown were created fully automatically without manual
 interaction. We did not yet spend any time to tune the results. Hence
-further improvments may be achieved by tuning the code generated by Polly, the
+further improvements may be achieved by tuning the code generated by Polly, the
 heuristics used by Pluto or by investigating if more code could be optimized.
 As Pluto was never used at such a low level, its heuristics are probably
 far from perfect. Another area where we expect larger performance improvements
 is the SIMD vector code generation. At the moment, it rarely yields to
 performance improvements, as we did not yet include vectorization in our
 heuristics. By changing this we should be able to significantly increase the
 number of test cases that show improvements.</p>
 
 <p>The polybench test suite contains computation kernels from linear algebra
 routines, stencil computations, image processing and data mining. Polly
-recognices the majority of them and is able to show good speedup. However,
+recognizes the majority of them and is able to show good speedup. However,
 to show similar speedup on larger examples like the SPEC CPU benchmarks Polly
 still misses support for integer casts, variable-sized multi-dimensional arrays
-and probably several other construts. This support is necessary as such
+and probably several other constructs. This support is necessary as such
 constructs appear in larger programs, but not in our limited test suite.
 
 <h2> Sequential runs</h2>
 
 For the sequential runs we used Polly to create a program structure that is
 optimized for data-locality. One of the major optimizations performed is tiling.
 The speedups shown are without the use of any multi-core parallelism. No
 additional hardware is used, but the single available core is used more

polly/www/projects.html

 <div id="content">
   <!--*********************************************************************-->
   <h1>Open Projects</h1>
   <!--*********************************************************************-->
 
   LLVM Polly keeps here a list of open projects which each of themselves would
   be a great contribution to Polly. All of these projects are meant to be self
   contained and should take a newcomer around 3-4 months of work. The projects
-  we propose are all suiteable as <a
+  we propose are all suitable as <a
   href="https://developers.google.com/open-source/gsoc/">Google Summer of
   Code</a> projects. In case you are interested in a Google Summer of code
   project make sure to reach out via the Polly <a
   href="https://groups.google.com/group/polly-dev">mailing list</a> early to
   discuss your project proposal.
 
   <h3>Integrate Polly with the LLVM vectorizers</h3>
   Polly is not only a self-contained optimizer, but also provides a powerful

polly/www/todo.html

 <tr>
 <th align="left">
 Unsigned Integers
 </th><td align="center" class='done'> Done
 </td><td> Johannes
 </td></tr>
 <tr>
 <th align="left">
-Pointer Comparisions
+Pointer Comparisons
 </th><td align="center" class='done'> Done
 </td><td> Johannes
 </td></tr>
 <tr>
 <th align="left">
 Non-affine subregions
 </th><td align="center" class='done'> Done
 </td><td> Johannes

 </th><td>
 
 </td></tr>
 </tbody></table>
 <h3 id="phase2"> Phase 2 - First Optimizations and Enhanced User Experience (Finished
 February 2012)</h3>
 <p>
 
-First optimizations to show the usefullness of Polly and enhance the user
+First optimizations to show the usefulness of Polly and enhance the user
 experience. We also try to increase the amount of code we can optimize.
 </p>
 <table class="wikitable" cellpadding="2">
 
 <tbody>
 <tr><th colspan="3" style="background: rgb(239, 239, 239);"> Frontend </th></tr>
 <tr style="background: rgb(239, 239, 239)">
   <th width="400px"> Task </th>