maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/polly/test/ScopInfo/multidim_nested_start_integ...

75 lines
2.3 KiB
LLVM
Raw Normal View History

Drop explicit -polly-delinearize parameter Delinearization is now enabled by default and does not need to explicitly need to be enabled in our tests. llvm-svn: 264154
2016-03-23 21:21:02 +08:00
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
[GSoC 2016]New function pass ScopInfoWrapperPass This patch adds a new function pass ScopInfoWrapperPass so that the polyhedral description of a region, the SCoP, can be constructed and used in a function pass. Patch by Utpal Bora <cs14mtech11017@iith.ac.in> Differential Revision: http://reviews.llvm.org/D20962 llvm-svn: 273856
2016-06-27 17:32:30 +08:00
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s
ScopInfo: Split start value from SCEVAddRecExpr to enable parameter sharing. SCoP invariant parameters with the different start value would deter parameter sharing. For example, when compiling the following C code: void foo(float *input) { for (long j = 0; j < 8; j++) { // SCoP begin for (long i = 0; i < 8; i++) { float x = input[j * 64 + i + 1]; input[j * 64 + i] = x * x; } } } Polly would creat two parameters for these memory accesses: p_0: {0,+,256} p_2: {4,+,256} [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 These parameters only differ from start value. To enable parameter sharing, we split the start value from SCEVAddRecExpr, so they would share a single parameter that always has zero start value: p0: {0,+,256}<%for.cond1.preheader> [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = 4 + p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 Such translation can make the polly-dependence much faster. Contributed-by: Star Tan <tanmx_star@yeah.net> llvm-svn: 187728
2013-08-05 23:14:15 +08:00
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-S128"
; void foo(long n, long m, long o, double A[n][m][o]) {
Adjust multidim test cases to not access out-of-bound memory We do this currently only for test cases where we have integer offsets that clearly access array dimensions out-of-bound. -; for (long i = 0; i < n; i++) -; for (long j = 0; j < m; j++) -; for (long k = 0; k < o; k++) +; for (long i = 0; i < n - 3; i++) +; for (long j = 4; j < m; j++) +; for (long k = 0; k < o - 7; k++) ; A[i+3][j-4][k+7] = 1.0; This will be helpful if we later want to simplify the access functions under the assumption that they do not access memory out of bounds. llvm-svn: 210179
2014-06-04 19:47:54 +08:00
; for (long i = 0; i < n - 3; i++)
; for (long j = 4; j < m; j++)
; for (long k = 0; k < o - 7; k++)
ScopInfo: Split start value from SCEVAddRecExpr to enable parameter sharing. SCoP invariant parameters with the different start value would deter parameter sharing. For example, when compiling the following C code: void foo(float *input) { for (long j = 0; j < 8; j++) { // SCoP begin for (long i = 0; i < 8; i++) { float x = input[j * 64 + i + 1]; input[j * 64 + i] = x * x; } } } Polly would creat two parameters for these memory accesses: p_0: {0,+,256} p_2: {4,+,256} [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 These parameters only differ from start value. To enable parameter sharing, we split the start value from SCEVAddRecExpr, so they would share a single parameter that always has zero start value: p0: {0,+,256}<%for.cond1.preheader> [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = 4 + p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 Such translation can make the polly-dependence much faster. Contributed-by: Star Tan <tanmx_star@yeah.net> llvm-svn: 187728
2013-08-05 23:14:15 +08:00
; A[i+3][j-4][k+7] = 1.0;
; }
;
Prepare unit tests for update to ISL 0.16 ISL 0.16 will change how sets are printed which breaks 117 unit tests that text-compare printed sets. This patch re-formats most of these unit tests using a script and small manual editing on top of that. When actually updating ISL, most work is done by just re-running the script to adapt to the changed output. Some tests that compare IR and tests with single CHECK-lines that can be easily updated manually are not included here. The re-format script will also be committed afterwards. The per-test formatter invocation command lines options will not be added in the near future because it is ad hoc and would overwrite the manual edits. Ideally it also shouldn't be required anymore because ISL's set printing has become more stable in 0.16. Differential Revision: http://reviews.llvm.org/D16095 llvm-svn: 257851
2016-01-15 08:48:42 +08:00
; CHECK: Assumed Context:
; CHECK-NEXT: [o, m, n] -> { : }
;
; CHECK: p0: %o
; CHECK-NEXT: p1: %m
; CHECK-NEXT: p2: %n
; CHECK-NOT: p3
;
; CHECK: Statements {
; CHECK-NEXT: Stmt_for_k
; CHECK-NEXT: Domain :=
Update to ISL 0.16.1 llvm-svn: 257898
2016-01-15 23:54:45 +08:00
; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] : 0 <= i0 <= -4 + n and 0 <= i1 <= -5 + m and 0 <= i2 <= -8 + o };
Prepare unit tests for update to ISL 0.16 ISL 0.16 will change how sets are printed which breaks 117 unit tests that text-compare printed sets. This patch re-formats most of these unit tests using a script and small manual editing on top of that. When actually updating ISL, most work is done by just re-running the script to adapt to the changed output. Some tests that compare IR and tests with single CHECK-lines that can be easily updated manually are not included here. The re-format script will also be committed afterwards. The per-test formatter invocation command lines options will not be added in the near future because it is ad hoc and would overwrite the manual edits. Ideally it also shouldn't be required anymore because ISL's set printing has become more stable in 0.16. Differential Revision: http://reviews.llvm.org/D16095 llvm-svn: 257851
2016-01-15 08:48:42 +08:00
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[3 + i0, i1, 7 + i2] };
; CHECK-NEXT: }
ScopInfo: Split start value from SCEVAddRecExpr to enable parameter sharing. SCoP invariant parameters with the different start value would deter parameter sharing. For example, when compiling the following C code: void foo(float *input) { for (long j = 0; j < 8; j++) { // SCoP begin for (long i = 0; i < 8; i++) { float x = input[j * 64 + i + 1]; input[j * 64 + i] = x * x; } } } Polly would creat two parameters for these memory accesses: p_0: {0,+,256} p_2: {4,+,256} [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 These parameters only differ from start value. To enable parameter sharing, we split the start value from SCEVAddRecExpr, so they would share a single parameter that always has zero start value: p0: {0,+,256}<%for.cond1.preheader> [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = 4 + p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 Such translation can make the polly-dependence much faster. Contributed-by: Star Tan <tanmx_star@yeah.net> llvm-svn: 187728
2013-08-05 23:14:15 +08:00
define void @foo(i64 %n, i64 %m, i64 %o, double* %A) {
entry:
br label %for.i
for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
br label %for.j
for.j:
Adjust multidim test cases to not access out-of-bound memory We do this currently only for test cases where we have integer offsets that clearly access array dimensions out-of-bound. -; for (long i = 0; i < n; i++) -; for (long j = 0; j < m; j++) -; for (long k = 0; k < o; k++) +; for (long i = 0; i < n - 3; i++) +; for (long j = 4; j < m; j++) +; for (long k = 0; k < o - 7; k++) ; A[i+3][j-4][k+7] = 1.0; This will be helpful if we later want to simplify the access functions under the assumption that they do not access memory out of bounds. llvm-svn: 210179
2014-06-04 19:47:54 +08:00
%j = phi i64 [ 4, %for.i ], [ %j.inc, %for.j.inc ]
ScopInfo: Split start value from SCEVAddRecExpr to enable parameter sharing. SCoP invariant parameters with the different start value would deter parameter sharing. For example, when compiling the following C code: void foo(float *input) { for (long j = 0; j < 8; j++) { // SCoP begin for (long i = 0; i < 8; i++) { float x = input[j * 64 + i + 1]; input[j * 64 + i] = x * x; } } } Polly would creat two parameters for these memory accesses: p_0: {0,+,256} p_2: {4,+,256} [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 These parameters only differ from start value. To enable parameter sharing, we split the start value from SCEVAddRecExpr, so they would share a single parameter that always has zero start value: p0: {0,+,256}<%for.cond1.preheader> [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = 4 + p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 Such translation can make the polly-dependence much faster. Contributed-by: Star Tan <tanmx_star@yeah.net> llvm-svn: 187728
2013-08-05 23:14:15 +08:00
br label %for.k
for.k:
%k = phi i64 [ 0, %for.j ], [ %k.inc, %for.k.inc ]
%offset0 = add nsw i64 %i, 3
%subscript0 = mul i64 %offset0, %m
%offset1 = add nsw i64 %j, -4
%subscript1 = add i64 %offset1, %subscript0
%subscript2 = mul i64 %subscript1, %o
%offset2 = add nsw i64 %k, 7
%subscript = add i64 %subscript2, %offset2
Update Polly tests to handle explicitly typed gep changes in LLVM llvm-svn: 230784
2015-02-28 03:20:19 +08:00
%idx = getelementptr inbounds double, double* %A, i64 %subscript
ScopInfo: Split start value from SCEVAddRecExpr to enable parameter sharing. SCoP invariant parameters with the different start value would deter parameter sharing. For example, when compiling the following C code: void foo(float *input) { for (long j = 0; j < 8; j++) { // SCoP begin for (long i = 0; i < 8; i++) { float x = input[j * 64 + i + 1]; input[j * 64 + i] = x * x; } } } Polly would creat two parameters for these memory accesses: p_0: {0,+,256} p_2: {4,+,256} [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 These parameters only differ from start value. To enable parameter sharing, we split the start value from SCEVAddRecExpr, so they would share a single parameter that always has zero start value: p0: {0,+,256}<%for.cond1.preheader> [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = 4 + p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 Such translation can make the polly-dependence much faster. Contributed-by: Star Tan <tanmx_star@yeah.net> llvm-svn: 187728
2013-08-05 23:14:15 +08:00
store double 1.0, double* %idx
br label %for.k.inc
for.k.inc:
%k.inc = add nsw i64 %k, 1
Adjust multidim test cases to not access out-of-bound memory We do this currently only for test cases where we have integer offsets that clearly access array dimensions out-of-bound. -; for (long i = 0; i < n; i++) -; for (long j = 0; j < m; j++) -; for (long k = 0; k < o; k++) +; for (long i = 0; i < n - 3; i++) +; for (long j = 4; j < m; j++) +; for (long k = 0; k < o - 7; k++) ; A[i+3][j-4][k+7] = 1.0; This will be helpful if we later want to simplify the access functions under the assumption that they do not access memory out of bounds. llvm-svn: 210179
2014-06-04 19:47:54 +08:00
%osub = sub nsw i64 %o, 7
%k.exitcond = icmp eq i64 %k.inc, %osub
ScopInfo: Split start value from SCEVAddRecExpr to enable parameter sharing. SCoP invariant parameters with the different start value would deter parameter sharing. For example, when compiling the following C code: void foo(float *input) { for (long j = 0; j < 8; j++) { // SCoP begin for (long i = 0; i < 8; i++) { float x = input[j * 64 + i + 1]; input[j * 64 + i] = x * x; } } } Polly would creat two parameters for these memory accesses: p_0: {0,+,256} p_2: {4,+,256} [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 These parameters only differ from start value. To enable parameter sharing, we split the start value from SCEVAddRecExpr, so they would share a single parameter that always has zero start value: p0: {0,+,256}<%for.cond1.preheader> [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = 4 + p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 Such translation can make the polly-dependence much faster. Contributed-by: Star Tan <tanmx_star@yeah.net> llvm-svn: 187728
2013-08-05 23:14:15 +08:00
br i1 %k.exitcond, label %for.j.inc, label %for.k
for.j.inc:
%j.inc = add nsw i64 %j, 1
%j.exitcond = icmp eq i64 %j.inc, %m
br i1 %j.exitcond, label %for.i.inc, label %for.j
for.i.inc:
%i.inc = add nsw i64 %i, 1
Adjust multidim test cases to not access out-of-bound memory We do this currently only for test cases where we have integer offsets that clearly access array dimensions out-of-bound. -; for (long i = 0; i < n; i++) -; for (long j = 0; j < m; j++) -; for (long k = 0; k < o; k++) +; for (long i = 0; i < n - 3; i++) +; for (long j = 4; j < m; j++) +; for (long k = 0; k < o - 7; k++) ; A[i+3][j-4][k+7] = 1.0; This will be helpful if we later want to simplify the access functions under the assumption that they do not access memory out of bounds. llvm-svn: 210179
2014-06-04 19:47:54 +08:00
%nsub = sub nsw i64 %n, 3
%i.exitcond = icmp eq i64 %i.inc, %nsub
ScopInfo: Split start value from SCEVAddRecExpr to enable parameter sharing. SCoP invariant parameters with the different start value would deter parameter sharing. For example, when compiling the following C code: void foo(float *input) { for (long j = 0; j < 8; j++) { // SCoP begin for (long i = 0; i < 8; i++) { float x = input[j * 64 + i + 1]; input[j * 64 + i] = x * x; } } } Polly would creat two parameters for these memory accesses: p_0: {0,+,256} p_2: {4,+,256} [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 These parameters only differ from start value. To enable parameter sharing, we split the start value from SCEVAddRecExpr, so they would share a single parameter that always has zero start value: p0: {0,+,256}<%for.cond1.preheader> [j * 64 + i + 1] => MemRef_input[o0] : 4o0 = 4 + p_1 + 4i0 [j * 64 + i] => MemRef_input[o0] : 4o0 = p_0 + 4i0 Such translation can make the polly-dependence much faster. Contributed-by: Star Tan <tanmx_star@yeah.net> llvm-svn: 187728
2013-08-05 23:14:15 +08:00
br i1 %i.exitcond, label %end, label %for.i
end:
ret void
}