This is an archive of the discontinued LLVM Phabricator instance.

Differential D37833

[TargetTransformInfo] Detect 0 latency instructions
ClosedPublic

Authored by Carrot on Sep 13 2017, 4:26 PM.

Details

Reviewers
hfinkel
Commits
rG21f8fad909bf: [TargetTransformInfo] Detect 0 latency instructions
rL313288: [TargetTransformInfo] Detect 0 latency instructions
Summary

For instructions that unlikely generate machine instructions, they should also have 0 latency.

Diff Detail

Repository
rL LLVM

Event Timeline

Carrot created this revision.Sep 13 2017, 4:26 PM
hfinkel accepted this revision.Sep 14 2017, 7:59 AM

LGTM

This revision is now accepted and ready to land.Sep 14 2017, 7:59 AM
Closed by commit rL313288: [TargetTransformInfo] Detect 0 latency instructions (authored by Carrot). · Explain WhySep 14 2017, 12:21 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
Analysis/
4 lines
test/
Analysis/
CostModel/
X86/
18 lines

Diff 115258

llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h

Show First 20 Lines • Show All 769 Lines • ▼ Show 20 Lines unsigned getUserCost(const User *U, ArrayRef<const Value *> Operands) {
} }
return static_cast<T *>(this)->getOperationCost( return static_cast<T *>(this)->getOperationCost(
Operator::getOpcode(U), U->getType(), Operator::getOpcode(U), U->getType(),
U->getNumOperands() == 1 ? U->getOperand(0)->getType() : nullptr); U->getNumOperands() == 1 ? U->getOperand(0)->getType() : nullptr);
} }
int getInstructionLatency(const Instruction *I) { int getInstructionLatency(const Instruction *I) {
if (isa<PHINode>(I)) SmallVector<const Value *, 4> Operands(I->value_op_begin(),
I->value_op_end());
if (getUserCost(I, Operands) == TTI::TCC_Free)
return 0; return 0;
if (isa<CallInst>(I)) if (isa<CallInst>(I))
return 40; return 40;
if (isa<LoadInst>(I)) if (isa<LoadInst>(I))
return 4; return 4;
Show All 12 Lines

llvm/trunk/test/Analysis/CostModel/X86/costmodel.ll

; RUN: opt < %s -cost-model -cost-kind=latency -analyze -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 | FileCheck %s --check-prefix=LATENCY ; RUN: opt < %s -cost-model -cost-kind=latency -analyze -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 | FileCheck %s --check-prefix=LATENCY
; RUN: opt < %s -cost-model -cost-kind=code-size -analyze -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 | FileCheck %s --check-prefix=CODESIZE ; RUN: opt < %s -cost-model -cost-kind=code-size -analyze -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 | FileCheck %s --check-prefix=CODESIZE
; Tests if the interface TargetTransformInfo::getInstructionCost() works correctly. ; Tests if the interface TargetTransformInfo::getInstructionCost() works correctly.
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"
define i64 @foo(i64 %arg) { define i64 @foo(i64 %arg) {
; LATENCY: cost of 1 {{.*}} %I64 = add ; LATENCY: cost of 1 {{.*}} %I64 = add
; CODESIZE: cost of 1 {{.*}} %I64 = add ; CODESIZE: cost of 1 {{.*}} %I64 = add
%I64 = add i64 undef, undef %I64 = add i64 undef, undef
; LATENCY: cost of 4 {{.*}} load ; LATENCY: cost of 4 {{.*}} load
; CODESIZE: cost of 1 {{.*}} load ; CODESIZE: cost of 1 {{.*}} load
load i64, i64* undef, align 4 load i64, i64* undef, align 4
; LATENCY: cost of 0 {{.*}} bitcast
; CODESIZE: cost of 0 {{.*}} bitcast
%BC = bitcast i8* undef to i32*
; LATENCY: cost of 0 {{.*}} inttoptr
; CODESIZE: cost of 0 {{.*}} inttoptr
%I2P = inttoptr i64 undef to i8*
; LATENCY: cost of 0 {{.*}} ptrtoint
; CODESIZE: cost of 0 {{.*}} ptrtoint
%P2I = ptrtoint i8* undef to i64
; LATENCY: cost of 0 {{.*}} trunc
; CODESIZE: cost of 0 {{.*}} trunc
%TC = trunc i64 undef to i32
; LATENCY: cost of 1 {{.*}} ret ; LATENCY: cost of 1 {{.*}} ret
; CODESIZE: cost of 1 {{.*}} ret ; CODESIZE: cost of 1 {{.*}} ret
ret i64 undef ret i64 undef
} }