LLVM 19.0.0git
MLInlineAdvisor.h
Go to the documentation of this file.
1//===- MLInlineAdvisor.h - ML - based InlineAdvisor factories ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_ANALYSIS_MLINLINEADVISOR_H
10#define LLVM_ANALYSIS_MLINLINEADVISOR_H
11
16#include "llvm/IR/PassManager.h"
17
18#include <deque>
19#include <map>
20#include <memory>
21#include <optional>
22
23namespace llvm {
24class DiagnosticInfoOptimizationBase;
25class Module;
26class MLInlineAdvice;
27
29public:
31 std::unique_ptr<MLModelRunner> ModelRunner,
32 std::function<bool(CallBase &)> GetDefaultAdvice);
33
34 virtual ~MLInlineAdvisor() = default;
35
36 void onPassEntry(LazyCallGraph::SCC *SCC) override;
37 void onPassExit(LazyCallGraph::SCC *SCC) override;
38
39 int64_t getIRSize(Function &F) const {
41 }
42 void onSuccessfulInlining(const MLInlineAdvice &Advice,
43 bool CalleeWasDeleted);
44
45 bool isForcedToStop() const { return ForceStop; }
46 int64_t getLocalCalls(Function &F);
47 const MLModelRunner &getModelRunner() const { return *ModelRunner.get(); }
49
50protected:
51 std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) override;
52
53 std::unique_ptr<InlineAdvice> getMandatoryAdvice(CallBase &CB,
54 bool Advice) override;
55
56 virtual std::unique_ptr<MLInlineAdvice> getMandatoryAdviceImpl(CallBase &CB);
57
58 virtual std::unique_ptr<MLInlineAdvice>
60
61 // Get the initial 'level' of the function, or 0 if the function has been
62 // introduced afterwards.
63 // TODO: should we keep this updated?
64 unsigned getInitialFunctionLevel(const Function &F) const;
65
66 std::unique_ptr<MLModelRunner> ModelRunner;
67 std::function<bool(CallBase &)> GetDefaultAdvice;
68
69private:
70 int64_t getModuleIRSize() const;
71 std::unique_ptr<InlineAdvice>
72 getSkipAdviceIfUnreachableCallsite(CallBase &CB);
73 void print(raw_ostream &OS) const override;
74
75 // Using std::map to benefit from its iterator / reference non-invalidating
76 // semantics, which make it easy to use `getCachedFPI` results from multiple
77 // calls without needing to copy to avoid invalidation effects.
78 mutable std::map<const Function *, FunctionPropertiesInfo> FPICache;
79
80 LazyCallGraph &CG;
81
82 int64_t NodeCount = 0;
83 int64_t EdgeCount = 0;
84 int64_t EdgesOfLastSeenNodes = 0;
85
86 std::map<const LazyCallGraph::Node *, unsigned> FunctionLevels;
87 const int32_t InitialIRSize = 0;
88 int32_t CurrentIRSize = 0;
91 bool ForceStop = false;
92};
93
94/// InlineAdvice that tracks changes post inlining. For that reason, it only
95/// overrides the "successful inlining" extension points.
97public:
99 OptimizationRemarkEmitter &ORE, bool Recommendation);
100 virtual ~MLInlineAdvice() = default;
101
102 void recordInliningImpl() override;
104 void recordUnsuccessfulInliningImpl(const InlineResult &Result) override;
105 void recordUnattemptedInliningImpl() override;
106
107 Function *getCaller() const { return Caller; }
108 Function *getCallee() const { return Callee; }
109
110 const int64_t CallerIRSize;
111 const int64_t CalleeIRSize;
112 const int64_t CallerAndCalleeEdges;
114
115private:
116 void reportContextForRemark(DiagnosticInfoOptimizationBase &OR);
117 MLInlineAdvisor *getAdvisor() const {
118 return static_cast<MLInlineAdvisor *>(Advisor);
119 };
120 // Make a copy of the FPI of the caller right before inlining. If inlining
121 // fails, we can just update the cache with that value.
122 const FunctionPropertiesInfo PreInlineCallerFPI;
123 std::optional<FunctionPropertiesUpdater> FPU;
124};
125
126} // namespace llvm
127
128#endif // LLVM_ANALYSIS_MLINLINEADVISOR_H
Implements a lazy call graph analysis and related passes for the new pass manager.
#define F(x, y, z)
Definition: MD5.cpp:55
Machine Check Debug Module
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
This header defines various interfaces for pass management in LLVM.
raw_pwrite_stream & OS
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:348
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1259
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
Common features for diagnostics dealing with optimization remarks that are used by both IR and MIR pa...
Capture state between an inlining decision having had been made, and its impact being observable.
Definition: InlineAdvisor.h:75
Function *const Callee
Function *const Caller
Caller and Callee are pre-inlining.
OptimizationRemarkEmitter & ORE
InlineAdvisor *const Advisor
Interface for deciding whether to inline a call site or not.
InlineResult is basically true or false.
Definition: InlineCost.h:179
An SCC of the call graph.
A lazily constructed view of the call graph of a module.
InlineAdvice that tracks changes post inlining.
void updateCachedCallerFPI(FunctionAnalysisManager &FAM) const
virtual ~MLInlineAdvice()=default
const int64_t CallerIRSize
const int64_t CalleeIRSize
void recordInliningImpl() override
Function * getCaller() const
const int64_t CallerAndCalleeEdges
void recordUnsuccessfulInliningImpl(const InlineResult &Result) override
Function * getCallee() const
void recordInliningWithCalleeDeletedImpl() override
void recordUnattemptedInliningImpl() override
std::unique_ptr< MLModelRunner > ModelRunner
FunctionPropertiesInfo & getCachedFPI(Function &) const
void onPassExit(LazyCallGraph::SCC *SCC) override
This must be called when the Inliner pass is exited, as function passes may be run subsequently.
const MLModelRunner & getModelRunner() const
void onSuccessfulInlining(const MLInlineAdvice &Advice, bool CalleeWasDeleted)
virtual std::unique_ptr< MLInlineAdvice > getMandatoryAdviceImpl(CallBase &CB)
void onPassEntry(LazyCallGraph::SCC *SCC) override
This must be called when the Inliner pass is entered, to allow the InlineAdvisor update internal stat...
int64_t getLocalCalls(Function &F)
virtual std::unique_ptr< MLInlineAdvice > getAdviceFromModel(CallBase &CB, OptimizationRemarkEmitter &ORE)
int64_t getIRSize(Function &F) const
std::function< bool(CallBase &)> GetDefaultAdvice
std::unique_ptr< InlineAdvice > getAdviceImpl(CallBase &CB) override
std::unique_ptr< InlineAdvice > getMandatoryAdvice(CallBase &CB, bool Advice) override
virtual ~MLInlineAdvisor()=default
bool isForcedToStop() const
unsigned getInitialFunctionLevel(const Function &F) const
MLModelRunner interface: abstraction of a mechanism for evaluating a ML model.
Definition: MLModelRunner.h:26
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
The optimization diagnostic interface.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:427
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18