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_ivs_and_integer_of...

73 lines
2.1 KiB
LLVM
Raw Normal View History

Remove -polly-codegen-scev option and related code SCEV based code generation has been the default for two weeks after having been tested for a long time. We now drop the support the non-scev-based code generation. llvm-svn: 222978
2014-11-30 22:33:31 +08:00
; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
Add test cases for multi-dimensional variable lengths arrays At the moment we can handle such arrays only by conservatively assuming that each access to such an array may touch any element in the array. It would be great if we could improve Polly/LLVM at some point, such that we can recover the multi-dimensionality of the accesses. llvm-svn: 163619
2012-09-11 22:03:19 +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"
target triple = "x86_64-unknown-linux-gnu"
; 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++)
Add test cases for multi-dimensional variable lengths arrays At the moment we can handle such arrays only by conservatively assuming that each access to such an array may touch any element in the array. It would be great if we could improve Polly/LLVM at some point, such that we can recover the multi-dimensionality of the accesses. llvm-svn: 163619
2012-09-11 22:03:19 +08:00
; A[i+3][j-4][k+7] = 1.0;
; }
delinearize memory access functions llvm-svn: 205799
2014-04-09 05:20:44 +08:00
Derive run-time conditions for delinearization As our delinearization works optimistically, we need in some cases run-time checks that verify our optimistic assumptions. A simple example is the following code: void foo(long n, long m, long o, double A[n][m][o]) { for (long i = 0; i < 100; i++) for (long j = 0; j < 150; j++) for (long k = 0; k < 200; k++) A[i][j][k] = 1.0; } After clang linearized the access to A and we delinearized it again to A[i][j][k] we need to ensure that we do not access the delinearized array out of bounds (this information is not available in LLVM-IR). Hence, we need to verify the following constraints at run-time: CHECK: Assumed Context: CHECK: [o, m] -> { : m >= 150 and o >= 200 } llvm-svn: 212198
2014-07-03 01:47:48 +08:00
; CHECK: Assumed Context:
; CHECK: { : }
delinearize memory access functions llvm-svn: 205799
2014-04-09 05:20:44 +08:00
; CHECK: p0: %n
; CHECK: p1: %m
; CHECK: p2: %o
; CHECK-NOT: p3
; CHECK: Domain
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
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -4 + n and i1 >= 0 and i1 <= -5 + m and i2 >= 0 and i2 <= -8 + o };
delinearize memory access functions llvm-svn: 205799
2014-04-09 05:20:44 +08:00
; CHECK: Scattering
Drop all constant scheduling dimensions Schedule dimensions that have the same constant value accross all statements do not carry any information, but due to the increased dimensionality of the schedule cost compile time. To not pay this cost, we remove constant dimensions if possible. llvm-svn: 225067
2015-01-02 07:01:11 +08:00
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> scattering[i0, i1, i2] };
delinearize memory access functions llvm-svn: 205799
2014-04-09 05:20:44 +08:00
; CHECK: MustWriteAccess
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
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[3 + i0, i1, 7 + i2] };
Add test cases for multi-dimensional variable lengths arrays At the moment we can handle such arrays only by conservatively assuming that each access to such an array may touch any element in the array. It would be great if we could improve Polly/LLVM at some point, such that we can recover the multi-dimensionality of the accesses. llvm-svn: 163619
2012-09-11 22:03:19 +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 ]
Add test cases for multi-dimensional variable lengths arrays At the moment we can handle such arrays only by conservatively assuming that each access to such an array may touch any element in the array. It would be great if we could improve Polly/LLVM at some point, such that we can recover the multi-dimensionality of the accesses. llvm-svn: 163619
2012-09-11 22:03:19 +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
%idx = getelementptr inbounds double* %A, i64 %subscript
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
Add test cases for multi-dimensional variable lengths arrays At the moment we can handle such arrays only by conservatively assuming that each access to such an array may touch any element in the array. It would be great if we could improve Polly/LLVM at some point, such that we can recover the multi-dimensionality of the accesses. llvm-svn: 163619
2012-09-11 22:03:19 +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
Add test cases for multi-dimensional variable lengths arrays At the moment we can handle such arrays only by conservatively assuming that each access to such an array may touch any element in the array. It would be great if we could improve Polly/LLVM at some point, such that we can recover the multi-dimensionality of the accesses. llvm-svn: 163619
2012-09-11 22:03:19 +08:00
br i1 %i.exitcond, label %end, label %for.i
end:
ret void
}