blob: 25e386f4cb3e78b2aa99c5d357ea474a627b721b [file] [edit]
//===- CostModel.cpp ------ Cost Model Analysis ---------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the cost model analysis. It provides a very basic cost
// estimation for LLVM-IR. This analysis uses the services of the codegen
// to approximate the cost of any IR instruction when lowered to machine
// instructions. The cost results are unit-less and the cost number represents
// the throughput of the machine assuming that all loads hit the cache, all
// branches are predicted, etc. The cost numbers can be added in order to
// compare two or more transformation alternatives.
//
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/CostModel.h"
#include "AnalysisOptions.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Pass.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
#define CM_NAME "cost-model"
#define DEBUG_TYPE CM_NAME
static InstructionCost getCost(const AnalysisOptions &Opts, Instruction &Inst,
TTI::TargetCostKind CostKind,
TargetTransformInfo &TTI) {
auto *II = dyn_cast<IntrinsicInst>(&Inst);
if (II &&
Opts.intrinsic_cost_strategy != IntrinsicCostStrategy::InstructionCost) {
IntrinsicCostAttributes ICA(
II->getIntrinsicID(), *II, InstructionCost::getInvalid(),
/*TypeBasedOnly=*/Opts.intrinsic_cost_strategy ==
IntrinsicCostStrategy::TypeBasedIntrinsicCost);
return TTI.getIntrinsicInstrCost(ICA, CostKind);
}
return TTI.getInstructionCost(&Inst, CostKind);
}
static TTI::TargetCostKind
OutputCostKindToTargetCostKind(OutputCostKind CostKind) {
switch (CostKind) {
case OutputCostKind::RecipThroughput:
return TTI::TCK_RecipThroughput;
case OutputCostKind::Latency:
return TTI::TCK_Latency;
case OutputCostKind::CodeSize:
return TTI::TCK_CodeSize;
case OutputCostKind::SizeAndLatency:
return TTI::TCK_SizeAndLatency;
default:
llvm_unreachable("Unexpected OutputCostKind!");
};
}
PreservedAnalyses CostModelPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) {
auto &TTI = AM.getResult<TargetIRAnalysis>(F);
const AnalysisOptions &Opts = getAnalysisOptions(F);
OS << "Printing analysis 'Cost Model Analysis' for function '" << F.getName() << "':\n";
for (BasicBlock &B : F) {
for (Instruction &Inst : B) {
OS << "Cost Model: ";
if (Opts.cost_kind == OutputCostKind::All) {
OS << "Found costs of ";
InstructionCost RThru =
getCost(Opts, Inst, TTI::TCK_RecipThroughput, TTI);
InstructionCost CodeSize = getCost(Opts, Inst, TTI::TCK_CodeSize, TTI);
InstructionCost Lat = getCost(Opts, Inst, TTI::TCK_Latency, TTI);
InstructionCost SizeLat =
getCost(Opts, Inst, TTI::TCK_SizeAndLatency, TTI);
if (RThru == CodeSize && RThru == Lat && RThru == SizeLat)
OS << RThru;
else
OS << "RThru:" << RThru << " CodeSize:" << CodeSize << " Lat:" << Lat
<< " SizeLat:" << SizeLat;
OS << " for: " << Inst << "\n";
} else {
InstructionCost Cost = getCost(
Opts, Inst, OutputCostKindToTargetCostKind(Opts.cost_kind), TTI);
if (Cost.isValid())
OS << "Found an estimated cost of " << Cost;
else
OS << "Invalid cost";
OS << " for instruction: " << Inst << "\n";
}
}
}
return PreservedAnalyses::all();
}