From a3bccceda7ca4d8e8fe8541675b594b4b7ba4148 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 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@237260 91177308-0d34-0410-b5e6-96231b3b80d8 --- docs/BranchWeightMetadata.rst | 23 ++++++++++++++++ include/llvm/IR/Function.h | 7 +++++ include/llvm/IR/MDBuilder.h | 3 +++ lib/IR/Function.cpp | 19 ++++++++++++++ lib/IR/MDBuilder.cpp | 10 +++++++ lib/IR/Verifier.cpp | 33 +++++++++++++++++++++++ test/Verifier/function-metadata-bad.ll | 35 +++++++++++++++++++++++++ test/Verifier/function-metadata-good.ll | 8 ++++++ unittests/IR/MetadataTest.cpp | 8 ++++++ 9 files changed, 146 insertions(+) create mode 100644 test/Verifier/function-metadata-bad.ll create mode 100644 test/Verifier/function-metadata-good.ll diff --git a/docs/BranchWeightMetadata.rst b/docs/BranchWeightMetadata.rst index aff7923d186..2ebc6c32416 100644 --- a/docs/BranchWeightMetadata.rst +++ b/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/include/llvm/IR/Function.h b/include/llvm/IR/Function.h index 3ec080aeb06..33602a3a8c1 100644 --- a/include/llvm/IR/Function.h +++ b/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 @@ public: 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/include/llvm/IR/MDBuilder.h b/include/llvm/IR/MDBuilder.h index 51b8b02d8e6..ba14457f718 100644 --- a/include/llvm/IR/MDBuilder.h +++ b/include/llvm/IR/MDBuilder.h @@ -60,6 +60,9 @@ public: /// \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/lib/IR/Function.cpp b/lib/IR/Function.cpp index f312f711c60..a5d4d1c4b1e 100644 --- a/lib/IR/Function.cpp +++ b/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/lib/IR/MDBuilder.cpp b/lib/IR/MDBuilder.cpp index a9010114044..354592df4c9 100644 --- a/lib/IR/MDBuilder.cpp +++ b/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/lib/IR/Verifier.cpp b/lib/IR/Verifier.cpp index 003b6064cbe..4e863cb99b5 100644 --- a/lib/IR/Verifier.cpp +++ b/lib/IR/Verifier.cpp @@ -400,6 +400,8 @@ private: 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/test/Verifier/function-metadata-bad.ll b/test/Verifier/function-metadata-bad.ll new file mode 100644 index 00000000000..9e7ba225408 --- /dev/null +++ b/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/test/Verifier/function-metadata-good.ll b/test/Verifier/function-metadata-good.ll new file mode 100644 index 00000000000..3d73a1c0694 --- /dev/null +++ b/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/unittests/IR/MetadataTest.cpp b/unittests/IR/MetadataTest.cpp index 4b35f19ccc6..baba3e5bc52 100644 --- a/unittests/IR/MetadataTest.cpp +++ b/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()); +} + }