[polly] r212925 - DeadCodeElimination: Fix liveout computation

[Johannes Doerfert]

Hey Tobias,

Could you give me a test case which we failed with the old method? 

Best regards,
  Johannes

--

Johannes Doerfert
Employee of Qualcomm Innovation Center, Inc.
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by
The Linux Foundation


-----Original Message-----
From: llvm-commits-bounces at cs.uiuc.edu
[mailto:llvm-commits-bounces at cs.uiuc.edu] On Behalf Of Tobias Grosser
Sent: Monday, July 14, 2014 1:32 AM
To: llvm-commits at cs.uiuc.edu
Subject: [polly] r212925 - DeadCodeElimination: Fix liveout computation

Author: grosser
Date: Mon Jul 14 03:32:01 2014
New Revision: 212925

URL: http://llvm.org/viewvc/llvm-project?rev=212925&view=rev
Log:
DeadCodeElimination: Fix liveout computation

We move back to a simple approach where the liveout is the last must-write
statement for a data-location plus all may-write statements. The previous
approach did not work out. We would have to consider per-data-access
dependences, instead of per-statement dependences to correct it. As this
adds complexity and it seems we would not gain anything over the simpler
approach that we implement in this commit, I moved us back to the old
approach of computing the liveout, but enhanced it to also add may-write
accesses.

We also fix the test case and explain why we can not perform dead code
elimination in this case.

Modified:
    polly/trunk/lib/Transform/DeadCodeElimination.cpp
    polly/trunk/test/DeadCodeElimination/non-affine-affine-mix.ll

Modified: polly/trunk/lib/Transform/DeadCodeElimination.cpp
URL:
http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Transform/DeadCodeElimin
ation.cpp?rev=212925&r1=212924&r2=212925&view=diff
============================================================================
==
--- polly/trunk/lib/Transform/DeadCodeElimination.cpp (original)
+++ polly/trunk/lib/Transform/DeadCodeElimination.cpp Mon Jul 14 
+++ 03:32:01 2014
@@ -78,21 +78,29 @@ private:
 
 char DeadCodeElim::ID = 0;
 
-// To compute the live outs, we first assume all must and may-writes are
exposed -// and then subtract the set of statements that are definitely
overwritten.
+// To compute the live outs, we compute for the data-locations that are 
+// must-written to the last statement that touches these locations. On 
+top of // this we add all statements that perform may-write accesses.
+//
+// We could be more precise by removing may-write accesses for which we 
+know // that they are overwritten by a must-write after. However, at 
+the moment the // only may-writes we introduce access the full 
+(unbounded) array, such that // bounded write accesses can not 
+overwrite all of the data-locations. As // this means may-writes are in 
+the current situation always live, there is // no point in trying to remove
them from the live-out set.
 isl_union_set *DeadCodeElim::getLiveOut(Scop &S) {
-  isl_union_map *Kills = S.getMustWrites();
-  isl_union_map *Empty = isl_union_map_empty(S.getParamSpace());
+  isl_union_map *Schedule = S.getSchedule();  isl_union_map 
+ *WriteIterations = isl_union_map_reverse(S.getMustWrites());
+  isl_union_map *WriteTimes =
+      isl_union_map_apply_range(WriteIterations, 
+ isl_union_map_copy(Schedule));
 
-  isl_union_map *Covering;
-  isl_union_map *Writes = S.getWrites();
-  isl_union_map_compute_flow(Kills, Empty, isl_union_map_copy(Writes),
-                             S.getSchedule(), NULL, &Covering, NULL, NULL);
+  isl_union_map *LastWriteTimes = isl_union_map_lexmax(WriteTimes);  
+ isl_union_map *LastWriteIterations = isl_union_map_apply_range(
+      LastWriteTimes, isl_union_map_reverse(Schedule));
 
-  isl_union_map *Exposed = Writes;
-  Exposed =
-      isl_union_map_subtract_domain(Exposed,
isl_union_map_domain(Covering));
-  return isl_union_map_domain(Exposed);
+  isl_union_set *Live = isl_union_map_range(LastWriteIterations);
+  Live = isl_union_set_union(Live, 
+ isl_union_map_domain(S.getMayWrites()));
+  return isl_union_set_coalesce(Live);
 }
 
 /// Performs polyhedral dead iteration elimination by:

Modified: polly/trunk/test/DeadCodeElimination/non-affine-affine-mix.ll
URL:
http://llvm.org/viewvc/llvm-project/polly/trunk/test/DeadCodeElimination/non
-affine-affine-mix.ll?rev=212925&r1=212924&r2=212925&view=diff
============================================================================
==
--- polly/trunk/test/DeadCodeElimination/non-affine-affine-mix.ll (original)
+++ polly/trunk/test/DeadCodeElimination/non-affine-affine-mix.ll Mon 
+++ Jul 14 03:32:01 2014
@@ -7,9 +7,13 @@
 ; S2:    A[i2] = i;
 ;    }
 
-; CHECK-NOT: Stmt_S1
+; We unfortunately do need to execute all iterations of S1, as we do 
+not know ; the size of A and as a result S1 may write for example to 
+A[1024], which ; is not overwritten by S2.
 
 ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
+; CHECK:   Stmt_S1(c1);
+; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
 ; CHECK:   Stmt_S2(c1);
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
@@ -21,7 +25,7 @@ entry:
 for.cond:
   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]
   %exitcond = icmp ne i32 %i.0, 1024
-  br i1 %exitcond, label %S1, label %for.cond.2
+  br i1 %exitcond, label %S1, label %next
 
 S1:
   %rem = srem i32 %i.0, 2
@@ -33,8 +37,11 @@ for.inc:
   %inc = add nsw i32 %i.0, 1
   br label %for.cond
 
+next:
+ br label %for.cond.2
+
 for.cond.2:
-  %i.2 = phi i32 [ 0, %for.cond ], [ %inc.2, %for.inc.2 ]
+  %i.2 = phi i32 [ 0, %next ], [ %inc.2, %for.inc.2 ]
   %exitcond.2 = icmp ne i32 %i.2, 1024
   br i1 %exitcond.2, label %S2, label %for.end
 


_______________________________________________
llvm-commits mailing list
llvm-commits at cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits