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_only_ivs_3d.ll

67 lines
1.9 KiB
LLVM
Raw Normal View History

delinearize memory access functions llvm-svn: 205799
2014-04-09 05:20:44 +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]) {
;
; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++)
; for (long k = 0; k < o; k++)
; A[i][j][k] = 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: [n, m, o] -> { : }
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
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
;
delinearize memory access functions llvm-svn: 205799
2014-04-09 05:20:44 +08:00
; CHECK: Domain
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + m and i2 >= 0 and i2 <= -1 + o };
; 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: WriteAccess
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, 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:
%j = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ]
br label %for.k
for.k:
%k = phi i64 [ 0, %for.j ], [ %k.inc, %for.k.inc ]
%subscript0 = mul i64 %i, %m
%subscript1 = add i64 %j, %subscript0
%subscript2 = mul i64 %subscript1, %o
%subscript = add i64 %subscript2, %k
%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
%k.exitcond = icmp eq i64 %k.inc, %o
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
%i.exitcond = icmp eq i64 %i.inc, %n
br i1 %i.exitcond, label %end, label %for.i
end:
ret void
}