1
0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-21 20:12:56 +02:00
llvm-mirror/test/Transforms/LoopLoadElim/multiple-stores-same-block.ll

49 lines
1.7 KiB
LLVM
Raw Normal View History

LLE 6/6: Add LoopLoadElimination pass Summary: The goal of this pass is to perform store-to-load forwarding across the backedge of a loop. E.g.: for (i) A[i + 1] = A[i] + B[i] => T = A[0] for (i) T = T + B[i] A[i + 1] = T The pass relies on loop dependence analysis via LoopAccessAnalisys to find opportunities of loop-carried dependences with a distance of one between a store and a load. Since it's using LoopAccessAnalysis, it was easy to also add support for versioning away may-aliasing intervening stores that would otherwise prevent this transformation. This optimization is also performed by Load-PRE in GVN without the option of multi-versioning. As was discussed with Daniel Berlin in http://reviews.llvm.org/D9548, this is inferior to a more loop-aware solution applied here. Hopefully, we will be able to remove some complexity from GVN/MemorySSA as a consequence. In the long run, we may want to extend this pass (or create a new one if there is little overlap) to also eliminate loop-indepedent redundant loads and store that *require* versioning due to may-aliasing intervening stores/loads. I have some motivating cases for store elimination. My plan right now is to wait for MemorySSA to come online first rather than using memdep for this. The main motiviation for this pass is the 456.hmmer loop in SPECint2006 where after distributing the original loop and vectorizing the top part, we are left with the critical path exposed in the bottom loop. Being able to promote the memory dependence into a register depedence (even though the HW does perform store-to-load fowarding as well) results in a major gain (~20%). This gain also transfers over to x86: it's around 8-10%. Right now the pass is off by default and can be enabled with -enable-loop-load-elim. On the LNT testsuite, there are two performance changes (negative number -> improvement): 1. -28% in Polybench/linear-algebra/solvers/dynprog: the length of the critical paths is reduced 2. +2% in Polybench/stencils/adi: Unfortunately, I couldn't reproduce this outside of LNT The pass is scheduled after the loop vectorizer (which is after loop distribution). The rational is to try to reuse LAA state, rather than recomputing it. The order between LV and LLE is not critical because normally LV does not touch scalar st->ld forwarding cases where vectorizing would inhibit the CPU's st->ld forwarding to kick in. LoopLoadElimination requires LAA to provide the full set of dependences (including forward dependences). LAA is known to omit loop-independent dependences in certain situations. The big comment before removeDependencesFromMultipleStores explains why this should not occur for the cases that we're interested in. Reviewers: dberlin, hfinkel Subscribers: junbuml, dberlin, mssimpso, rengolin, sanjoy, llvm-commits Differential Revision: http://reviews.llvm.org/D13259 llvm-svn: 252017
2015-11-04 00:50:08 +01:00
; RUN: opt -basicaa -loop-load-elim -S < %s | FileCheck %s
; In this case the later store forward to the load:
;
; for (unsigned i = 0; i < 100; i++) {
; B[i] = A[i] + 1;
; A[i+1] = C[i] + 2;
; A[i+1] = D[i] + 3;
; }
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* noalias nocapture %A, i32* noalias nocapture readonly %B,
i32* noalias nocapture %C, i32* noalias nocapture readonly %D,
i64 %N) {
entry:
; CHECK: %load_initial = load i32, i32* %A
br label %for.body
for.body: ; preds = %for.body, %entry
; CHECK: %store_forwarded = phi i32 [ %load_initial, %entry ], [ %addD, %for.body ]
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
%arrayidxA = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
%loadA = load i32, i32* %arrayidxA, align 4
; CHECK: %addA = add i32 %store_forwarded, 1
%addA = add i32 %loadA, 1
%arrayidxB = getelementptr inbounds i32, i32* %B, i64 %indvars.iv
store i32 %addA, i32* %arrayidxB, align 4
%arrayidxC = getelementptr inbounds i32, i32* %C, i64 %indvars.iv
%loadC = load i32, i32* %arrayidxC, align 4
%addC = add i32 %loadC, 2
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
%arrayidxA_next = getelementptr inbounds i32, i32* %A, i64 %indvars.iv.next
store i32 %addC, i32* %arrayidxA_next, align 4
%arrayidxD = getelementptr inbounds i32, i32* %D, i64 %indvars.iv
%loadD = load i32, i32* %arrayidxD, align 4
%addD = add i32 %loadD, 3
store i32 %addD, i32* %arrayidxA_next, align 4
%exitcond = icmp eq i64 %indvars.iv.next, %N
br i1 %exitcond, label %for.end, label %for.body
for.end: ; preds = %for.body
ret void
}