[Polly][DOC] Add fine-grain dependences analysis to release notes.

[etherzhhb]

Summary

Later I will try to add the document about how to extract LLVM IR based dependences result from the fine-grain dependences analysis.

[grosser]

LGTM besides a mire typo.

dence"
+pass provides dependences analysis at memory reference level and memory access level.
+The memory reference level analysis distinguishes the accessed references in the
+same statement, and generates depednences relationships between (statement, reference)
+pairs. The memory acccess level analysis distinguishes accesses in the same statement,
+and generates depednences relationships between (statement, access) pairs. These
+fine-grain depednences are enabled by "-polly-dependences-analysis-level=reference-level"

dependences.

[etherzhhb]

In D17905#368446, @grosser wrote:

LGTM besides a mire typo.

dence"
+pass provides dependences analysis at memory reference level and memory access level.
+The memory reference level analysis distinguishes the accessed references in the
+same statement, and generates depednences relationships between (statement, reference)
+pairs. The memory acccess level analysis distinguishes accesses in the same statement,
+and generates depednences relationships between (statement, access) pairs. These
+fine-grain depednences are enabled by "-polly-dependences-analysis-level=reference-level"

dependences.

ah ... stupid copy & paste ...

[etherzhhb]

depednences -> dependences
acccess -> access

Also:
reference-level -> reference-wise
access-level -> access-wise

[grosser]

This seems still open, even though this patch got a LGTM? Ether, are you waiting for sth?

[llvm-commits]

waiting for some one to accept :) Next time will push when I got a LGTM

• msg-4787-335.txt162 BDownload

docs/ReleaseNotes.rst

 supported before, we now allow and model two other kinds. The first are
 intrinsic calls to ``memcpy``, ``memmove`` and ``memset``. These calls can be
 represented precisely if the pointers involved are known and the given length
 is affine. Additionally, we allow to over-approximate function calls that are
 known only to read memory, read memory accessible through pointer arguments or
 access only memory accessible through pointer arguments. See also the function
 attributes ``readonly`` and ``argmemonly`` for more information.
 
+Fine-grain dependences analysis
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In addition of the ScopStmt wise dependences analysis, now the "polly-dependence"
+pass provides dependences analysis at memory reference wise and memory access wise.
+The memory reference wise analysis distinguishes the accessed references in the
+same statement, and generates dependences relationships between (statement, reference)
+pairs. The memory access wise analysis distinguishes accesses in the same statement,
+and generates dependences relationships between (statement, access) pairs. These
+fine-grain dependences are enabled by "-polly-dependences-analysis-level=reference-wise"
+and "-polly-dependences-analysis-level=access-wise", respectively.
 
 
 Update of the isl math library
 ------------------------------
 
 We imported the latest version of the isl math library into Polly.
 

lib/Analysis/DependenceInfo.cpp

cl::values(clEnumValN(VALUE_BASED_ANALYSIS, "value-based",
                           "Overapproximation of dependences"),
                clEnumValEnd),
     cl::Hidden, cl::init(VALUE_BASED_ANALYSIS), cl::ZeroOrMore,
     cl::cat(PollyCategory));
 
 static cl::opt<Dependences::AnalyisLevel> OptAnalysisLevel(
     "polly-dependences-analysis-level",
     cl::desc("The level of dependence analysis"),
-    cl::values(clEnumValN(Dependences::AL_Statement, "statement-level",
+    cl::values(clEnumValN(Dependences::AL_Statement, "statement-wise",
                           "Statement-level analysis"),
-               clEnumValN(Dependences::AL_Reference, "reference-level",
+               clEnumValN(Dependences::AL_Reference, "reference-wise",
                           "Memory reference level analysis that distinguish"
                           " accessed references in the same statement"),
-               clEnumValN(Dependences::AL_Access, "access-level",
+               clEnumValN(Dependences::AL_Access, "access-wise",
                           "Memory reference level analysis that distinguish"
                           " access instructions in the same statement"),
                clEnumValEnd),
     cl::Hidden, cl::init(Dependences::AL_Statement), cl::ZeroOrMore,
     cl::cat(PollyCategory));
 
 //===----------------------------------------------------------------------===//
 

test/DependenceInfo/fine_grain_dep_0.ll

-; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=reference-level -analyze < %s | FileCheck %s --check-prefix=REF
-; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-level -analyze < %s | FileCheck %s --check-prefix=ACC
+; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=reference-wise -analyze < %s | FileCheck %s --check-prefix=REF
+; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-wise -analyze < %s | FileCheck %s --check-prefix=ACC
 ;
 ; REF:      RAW dependences:
 ; REF-NEXT:     [N] -> { [Stmt_for_body[i0] -> MemRef_a[]] -> [Stmt_for_body[4 + i0] -> MemRef_a[]] : 0 <= i0 <= -11 + N; [Stmt_for_body[i0] -> MemRef_b[]] -> [Stmt_for_body[6 + i0] -> MemRef_b[]] : 0 <= i0 <= -13 + N; Stmt_for_body[i0] -> Stmt_for_body[6 + i0] : 0 <= i0 <= -13 + N; Stmt_for_body[i0] -> Stmt_for_body[4 + i0] : 0 <= i0 <= -11 + N }
 ; REF-NEXT: WAR dependences:
 ; REF-NEXT:     {  }
 ; REF-NEXT: WAW dependences:
 ; REF-NEXT:     {  }
 ; REF-NEXT: Reduction dependences:

test/DependenceInfo/reduction_complex_location.ll

 ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-level=reference-level -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-level=access-level -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-level=reference-wise -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-level=access-wise -analyze < %s | FileCheck %s
 ;
 ; CHECK:      RAW dependences:
 ; CHECK-NEXT:     {  }
 ; CHECK-NEXT: WAR dependences:
 ; CHECK-NEXT:     {  }
 ; CHECK-NEXT: WAW dependences:
 ; CHECK-NEXT:     {  }
 ; CHECK-NEXT: Reduction dependences:

test/DependenceInfo/reduction_multiple_loops_array_sum.ll

 ; RUN: opt -basicaa %loadPolly -polly-dependences -analyze < %s | FileCheck %s
-; RUN: opt -basicaa %loadPolly -polly-dependences -polly-dependences-analysis-level=reference-level -analyze < %s | FileCheck %s
-; RUN: opt -basicaa %loadPolly -polly-dependences -polly-dependences-analysis-level=access-level -analyze < %s | FileCheck %s
+; RUN: opt -basicaa %loadPolly -polly-dependences -polly-dependences-analysis-level=reference-wise -analyze < %s | FileCheck %s
+; RUN: opt -basicaa %loadPolly -polly-dependences -polly-dependences-analysis-level=access-wise -analyze < %s | FileCheck %s
 ;
 ; Verify that only the inner reduction like accesses cause reduction dependences
 ;
 ; CHECK:      Reduction dependences:
 ; CHECK-NEXT:     { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : 0 <= i0 <= 99 and 0 <= i1 <= 98 }
 ;
 ; void f(int * restrict A, int * restrict sum) {
 ;   int i, j, k;

test/DependenceInfo/sequential_loops.ll

 ; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=VALUE
 ; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=memory-based < %s | FileCheck %s -check-prefix=MEMORY
-; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-level < %s | FileCheck %s -check-prefix=VALUE_ACCESS
+; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-wise < %s | FileCheck %s -check-prefix=VALUE_ACCESS
 
 ; VALUE-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.3' in function 'sequential_writes':
 ; VALUE-NEXT:      RAW dependences:
 ; VALUE-NEXT:          {  }
 ; VALUE-NEXT:      WAR dependences:
 ; VALUE-NEXT:          {  }
 ; VALUE-NEXT:      WAW dependences:
 ; VALUE-NEXT:          { Stmt_S1[i0] -> Stmt_S2[i0] : 0 <= i0 <= 9; Stmt_S2[i0] -> Stmt_S3[i0] : 0 <= i0 <= 9; Stmt_S1[i0] -> Stmt_S3[i0] : 10 <= i0 <= 99 }