From 2567f3d0fb1f2812f99111ecd67d228ccae42c49 Mon Sep 17 00:00:00 2001 From: Diego Novillo Date: Wed, 13 May 2015 15:13:45 +0000 Subject: [PATCH] Add function entry count metadata. Summary: This adds three Function methods to handle function entry counts: setEntryCount() and getEntryCount(). Entry counts are stored under the MD_prof metadata node with the name "function_entry_count". They are unsigned 64 bit values set by profilers (instrumentation and sample profiler changes coming up). Added documentation for new profile metadata and tests. Reviewers: dexonsmith, bogner Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D9628 llvm-svn: 237260 --- llvm/docs/BranchWeightMetadata.rst | 23 +++++++++++++ llvm/include/llvm/IR/Function.h | 7 ++++ llvm/include/llvm/IR/MDBuilder.h | 3 ++ llvm/lib/IR/Function.cpp | 19 +++++++++++ llvm/lib/IR/MDBuilder.cpp | 10 ++++++ llvm/lib/IR/Verifier.cpp | 33 ++++++++++++++++++ llvm/test/Verifier/function-metadata-bad.ll | 35 ++++++++++++++++++++ llvm/test/Verifier/function-metadata-good.ll | 8 +++++ llvm/unittests/IR/MetadataTest.cpp | 8 +++++ 9 files changed, 146 insertions(+) create mode 100644 llvm/test/Verifier/function-metadata-bad.ll create mode 100644 llvm/test/Verifier/function-metadata-good.ll diff --git a/llvm/docs/BranchWeightMetadata.rst b/llvm/docs/BranchWeightMetadata.rst index aff7923d18656..2ebc6c32416ea 100644 --- a/llvm/docs/BranchWeightMetadata.rst +++ b/llvm/docs/BranchWeightMetadata.rst @@ -115,3 +115,26 @@ CFG Modifications Branch Weight Metatada is not proof against CFG changes. If terminator operands' are changed some action should be taken. In other case some misoptimizations may occur due to incorrent branch prediction information. + +Function Entry Counts +===================== + +To allow comparing different functions durint inter-procedural analysis and +optimization, ``MD_prof`` nodes can also be assigned to a function definition. +The first operand is a string indicating the name of the associated counter. + +Currently, one counter is supported: "function_entry_count". This is a 64-bit +counter that indicates the number of times that this function was invoked (in +the case of instrumentation-based profiles). In the case of sampling-based +profiles, this counter is an approximation of how many times the function was +invoked. + +For example, in the code below, the instrumentation for function foo() +indicates that it was called 2,590 times at runtime. + +.. code-block:: llvm + + define i32 @foo() !prof !1 { + ret i32 0 + } + !1 = !{!"function_entry_count", i64 2590} diff --git a/llvm/include/llvm/IR/Function.h b/llvm/include/llvm/IR/Function.h index 3ec080aeb0608..33602a3a8c194 100644 --- a/llvm/include/llvm/IR/Function.h +++ b/llvm/include/llvm/IR/Function.h @@ -19,6 +19,7 @@ #define LLVM_IR_FUNCTION_H #include "llvm/ADT/iterator_range.h" +#include "llvm/ADT/Optional.h" #include "llvm/IR/Argument.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/BasicBlock.h" @@ -194,6 +195,12 @@ class Function : public GlobalObject, public ilist_node { AttributeSet::FunctionIndex, Kind, Value)); } + /// Set the entry count for this function. + void setEntryCount(uint64_t Count); + + /// Get the entry count for this function. + Optional getEntryCount() const; + /// @brief Return true if the function has the attribute. bool hasFnAttribute(Attribute::AttrKind Kind) const { return AttributeSets.hasAttribute(AttributeSet::FunctionIndex, Kind); diff --git a/llvm/include/llvm/IR/MDBuilder.h b/llvm/include/llvm/IR/MDBuilder.h index 51b8b02d8e6d0..ba14457f71855 100644 --- a/llvm/include/llvm/IR/MDBuilder.h +++ b/llvm/include/llvm/IR/MDBuilder.h @@ -60,6 +60,9 @@ class MDBuilder { /// \brief Return metadata containing a number of branch weights. MDNode *createBranchWeights(ArrayRef Weights); + /// Return metadata containing the entry count for a function. + MDNode *createFunctionEntryCount(uint64_t Count); + //===------------------------------------------------------------------===// // Range metadata. //===------------------------------------------------------------------===// diff --git a/llvm/lib/IR/Function.cpp b/llvm/lib/IR/Function.cpp index f312f711c60c2..a5d4d1c4b1e15 100644 --- a/llvm/lib/IR/Function.cpp +++ b/llvm/lib/IR/Function.cpp @@ -19,10 +19,13 @@ #include "llvm/ADT/StringExtras.h" #include "llvm/CodeGen/ValueTypes.h" #include "llvm/IR/CallSite.h" +#include "llvm/IR/Constants.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/InstIterator.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/LLVMContext.h" +#include "llvm/IR/MDBuilder.h" +#include "llvm/IR/Metadata.h" #include "llvm/IR/Module.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/RWMutex.h" @@ -986,3 +989,19 @@ void llvm::overrideFunctionAttribute(StringRef Kind, StringRef Value, Attrs = Attrs.addAttribute(Ctx, AttributeSet::FunctionIndex, Kind, Value); F.setAttributes(Attrs); } + +void Function::setEntryCount(uint64_t Count) { + MDBuilder MDB(getContext()); + setMetadata(LLVMContext::MD_prof, MDB.createFunctionEntryCount(Count)); +} + +Optional Function::getEntryCount() const { + MDNode *MD = getMetadata(LLVMContext::MD_prof); + if (MD && MD->getOperand(0)) + if (MDString *MDS = dyn_cast(MD->getOperand(0))) + if (MDS->getString().equals("function_entry_count")) { + ConstantInt *CI = mdconst::extract(MD->getOperand(1)); + return CI->getValue().getZExtValue(); + } + return None; +} diff --git a/llvm/lib/IR/MDBuilder.cpp b/llvm/lib/IR/MDBuilder.cpp index a9010114044a4..354592df4c967 100644 --- a/llvm/lib/IR/MDBuilder.cpp +++ b/llvm/lib/IR/MDBuilder.cpp @@ -53,6 +53,16 @@ MDNode *MDBuilder::createBranchWeights(ArrayRef Weights) { return MDNode::get(Context, Vals); } +MDNode *MDBuilder::createFunctionEntryCount(uint64_t Count) { + SmallVector Vals(2); + Vals[0] = createString("function_entry_count"); + + Type *Int64Ty = Type::getInt64Ty(Context); + Vals[1] = createConstant(ConstantInt::get(Int64Ty, Count)); + + return MDNode::get(Context, Vals); +} + MDNode *MDBuilder::createRange(const APInt &Lo, const APInt &Hi) { assert(Lo.getBitWidth() == Hi.getBitWidth() && "Mismatched bitwidths!"); diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp index 003b6064cbe2f..4e863cb99b5cd 100644 --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -400,6 +400,8 @@ class Verifier : public InstVisitor, VerifierSupport { bool isReturnValue, const Value *V); void VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, const Value *V); + void VerifyFunctionMetadata( + const SmallVector, 4> MDs); void VerifyConstantExprBitcastType(const ConstantExpr *CE); void VerifyStatepoint(ImmutableCallSite CS); @@ -1463,6 +1465,36 @@ void Verifier::VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, } } +void Verifier::VerifyFunctionMetadata( + const SmallVector, 4> MDs) { + if (MDs.empty()) + return; + + for (unsigned i = 0; i < MDs.size(); i++) { + if (MDs[i].first == LLVMContext::MD_prof) { + MDNode *MD = MDs[i].second; + Assert(MD->getNumOperands() == 2, + "!prof annotations should have exactly 2 operands", MD); + + // Check first operand. + Assert(MD->getOperand(0) != nullptr, "first operand should not be null", + MD); + Assert(isa(MD->getOperand(0)), + "expected string with name of the !prof annotation", MD); + MDString *MDS = cast(MD->getOperand(0)); + StringRef ProfName = MDS->getString(); + Assert(ProfName.equals("function_entry_count"), + "first operand should be 'function_entry_count'", MD); + + // Check second operand. + Assert(MD->getOperand(1) != nullptr, "second operand should not be null", + MD); + Assert(isa(MD->getOperand(1)), + "expected integer argument to function_entry_count", MD); + } + } +} + void Verifier::VerifyConstantExprBitcastType(const ConstantExpr *CE) { if (CE->getOpcode() != Instruction::BitCast) return; @@ -1713,6 +1745,7 @@ void Verifier::visitFunction(const Function &F) { SmallVector, 4> MDs; F.getAllMetadata(MDs); assert(F.hasMetadata() != MDs.empty() && "Bit out-of-sync"); + VerifyFunctionMetadata(MDs); if (F.isMaterializable()) { // Function has a body somewhere we can't see. diff --git a/llvm/test/Verifier/function-metadata-bad.ll b/llvm/test/Verifier/function-metadata-bad.ll new file mode 100644 index 0000000000000..9e7ba225408e5 --- /dev/null +++ b/llvm/test/Verifier/function-metadata-bad.ll @@ -0,0 +1,35 @@ +; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s + +define i32 @bad1() !prof !0 { + ret i32 0 +} + +!0 = !{i32 123, i32 3} +; CHECK: assembly parsed, but does not verify as correct! +; CHECK-NEXT: expected string with name of the !prof annotation +; CHECK-NEXT: !0 = !{i32 123, i32 3} + +define i32 @bad2() !prof !1 { + ret i32 0 +} + +!1 = !{!"function_entry_count"} +; CHECK-NEXT: !prof annotations should have exactly 2 operands +; CHECK-NEXT: !1 = !{!"function_entry_count"} + + +define i32 @bad3() !prof !2 { + ret i32 0 +} + +!2 = !{!"some_other_count", i64 200} +; CHECK-NEXT: first operand should be 'function_entry_count' +; CHECK-NEXT: !2 = !{!"some_other_count", i64 200} + +define i32 @bad4() !prof !3 { + ret i32 0 +} + +!3 = !{!"function_entry_count", !"string"} +; CHECK-NEXT: expected integer argument to function_entry_count +; CHECK-NEXT: !3 = !{!"function_entry_count", !"string"} diff --git a/llvm/test/Verifier/function-metadata-good.ll b/llvm/test/Verifier/function-metadata-good.ll new file mode 100644 index 0000000000000..3d73a1c06945d --- /dev/null +++ b/llvm/test/Verifier/function-metadata-good.ll @@ -0,0 +1,8 @@ +; RUN: llvm-as < %s -o /dev/null 2>&1 + +; Function foo() is called 2,304 times at runtime. +define i32 @foo() !prof !0 { + ret i32 0 +} + +!0 = !{!"function_entry_count", i32 2304} diff --git a/llvm/unittests/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp index 4b35f19ccc6a8..baba3e5bc5253 100644 --- a/llvm/unittests/IR/MetadataTest.cpp +++ b/llvm/unittests/IR/MetadataTest.cpp @@ -2272,4 +2272,12 @@ TEST_F(FunctionAttachmentTest, Verifier) { EXPECT_FALSE(verifyFunction(*F)); } +TEST_F(FunctionAttachmentTest, EntryCount) { + Function *F = getFunction("foo"); + EXPECT_FALSE(F->getEntryCount().hasValue()); + F->setEntryCount(12304); + EXPECT_TRUE(F->getEntryCount().hasValue()); + EXPECT_EQ(12304u, *F->getEntryCount()); +} + }