Add new function properties to FunctionPropertiesAnalysis

[tarinduj]

Summary

Added LoadInstCount, StoreInstCount, MaxLoopDepth, LoopCount

[mtrofin]

lgtm

[jdoerfert]

llvm/lib/Analysis/ML/FunctionPropertiesAnalysis.cpp

27 ↗

(On Diff #272327)

move down to line 53 please, short lifetimes are better :)

50 ↗

(On Diff #272327)

Style: clang format the code please.

59 ↗

(On Diff #272327)

This will not count all loops, only top-level loops. Unclear if we want either or both.
To get all you need to iterate over subloops. Probably you want a worklist approach.

Style: you should prefer range loops, e.g., for (Loop &L : LI) :)

[tarinduj]

fixed formatting and renamed the LoopCount to TopLevelLoopCount.

[jdoerfert]

LGTM

[uenoku]

What happened to this patch?

[tarinduj]

[rebased] can someone upstream this? I do not have commit access.

llvm/include/llvm/Analysis/FunctionPropertiesAnalysis.h

 //=- FunctionPropertiesAnalysis.h - Function Properties Analysis --*- C++ -*-=//
 //
 // 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 FunctionPropertiesInfo and FunctionPropertiesAnalysis
 // classes used to extract function properties.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_FUNCTIONPROPERTIESANALYSIS_H_
 #define LLVM_FUNCTIONPROPERTIESANALYSIS_H_
 
+#include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 class Function;
 
 class FunctionPropertiesInfo {
 public:
+  static FunctionPropertiesInfo getFunctionPropertiesInfo(const Function &F,
+                                                          const LoopInfo &LI);
+
+  void print(raw_ostream &OS) const;
+
   /// Number of basic blocks
   int64_t BasicBlockCount = 0;
 
   /// Number of blocks reached from a conditional instruction, or that are
   /// 'cases' of a SwitchInstr.
   // FIXME: We may want to replace this with a more meaningful metric, like
   // number of conditionally executed blocks:
   // 'if (a) s();' would be counted here as 2 blocks, just like
   // 'if (a) s(); else s2(); s3();' would.
   int64_t BlocksReachedFromConditionalInstruction = 0;
 
   /// Number of uses of this function, plus 1 if the function is callable
   /// outside the module.
   int64_t Uses = 0;
 
   /// Number of direct calls made from this function to other functions
   /// defined in this module.
   int64_t DirectCallsToDefinedFunctions = 0;
 
-  static FunctionPropertiesInfo getFunctionPropertiesInfo(const Function &F);
+  // Load Instruction Count
+  int64_t LoadInstCount = 0;
 
-  void print(raw_ostream &OS) const;
+  // Store Instruction Count
+  int64_t StoreInstCount = 0;
+
+  // Maximum Loop Depth in the Function
+  int64_t MaxLoopDepth = 0;
+
+  // Number of Top Level Loops in the Function
+  int64_t TopLevelLoopCount = 0;
 };
 
 // Analysis pass
 class FunctionPropertiesAnalysis
     : public AnalysisInfoMixin<FunctionPropertiesAnalysis> {
 
 public:
   static AnalysisKey Key;

 public:
   explicit FunctionPropertiesPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
 } // namespace llvm
 #endif // LLVM_FUNCTIONPROPERTIESANALYSIS_H_
 No newline at end of file

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/FunctionPropertiesAnalysis.h"
 #include "llvm/IR/Instructions.h"
 
 using namespace llvm;
 
 FunctionPropertiesInfo
-FunctionPropertiesInfo::getFunctionPropertiesInfo(const Function &F) {
+FunctionPropertiesInfo::getFunctionPropertiesInfo(const Function &F,
+                                                  const LoopInfo &LI) {
 
   FunctionPropertiesInfo FPI;
 
   FPI.Uses = ((!F.hasLocalLinkage()) ? 1 : 0) + F.getNumUses();
 
   for (const auto &BB : F) {
     ++FPI.BasicBlockCount;
 
     if (const auto *BI = dyn_cast<BranchInst>(BB.getTerminator())) {
       if (BI->isConditional())
         FPI.BlocksReachedFromConditionalInstruction += BI->getNumSuccessors();
     } else if (const auto *SI = dyn_cast<SwitchInst>(BB.getTerminator())) {
       FPI.BlocksReachedFromConditionalInstruction +=
           (SI->getNumCases() + (nullptr != SI->getDefaultDest()));
     }
 
     for (const auto &I : BB) {
       if (auto *CS = dyn_cast<CallBase>(&I)) {
         const auto *Callee = CS->getCalledFunction();
         if (Callee && !Callee->isIntrinsic() && !Callee->isDeclaration())
           ++FPI.DirectCallsToDefinedFunctions;
       }
+      if (I.getOpcode() == Instruction::Load) {
+        ++FPI.LoadInstCount;
+      } else if (I.getOpcode() == Instruction::Store) {
+        ++FPI.StoreInstCount;
       }
     }
+    // Loop Depth of the Basic Block
+    int64_t LoopDepth;
+    LoopDepth = LI.getLoopDepth(&BB);
+    if (FPI.MaxLoopDepth < LoopDepth)
+      FPI.MaxLoopDepth = LoopDepth;
+  }
+  for (Loop *L : LI) {
+    ++FPI.TopLevelLoopCount;
+  }
   return FPI;
 }
 
 void FunctionPropertiesInfo::print(raw_ostream &OS) const {
   OS << "BasicBlockCount: " << BasicBlockCount << "\n"
      << "BlocksReachedFromConditionalInstruction: "
      << BlocksReachedFromConditionalInstruction << "\n"
      << "Uses: " << Uses << "\n"
      << "DirectCallsToDefinedFunctions: " << DirectCallsToDefinedFunctions
-     << "\n\n";
+     << "\n"
+     << "LoadInstCount: " << LoadInstCount << "\n"
+     << "StoreInstCount: " << StoreInstCount << "\n"
+     << "MaxLoopDepth: " << MaxLoopDepth << "\n"
+     << "TopLevelLoopCount: " << TopLevelLoopCount << "\n\n";
 }
 
 AnalysisKey FunctionPropertiesAnalysis::Key;
 
 FunctionPropertiesInfo
 FunctionPropertiesAnalysis::run(Function &F, FunctionAnalysisManager &FAM) {
-  return FunctionPropertiesInfo::getFunctionPropertiesInfo(F);
+  return FunctionPropertiesInfo::getFunctionPropertiesInfo(
+      F, FAM.getResult<LoopAnalysis>(F));
 }
 
 PreservedAnalyses
 FunctionPropertiesPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
   OS << "Printing analysis results of CFA for function "
      << "'" << F.getName() << "':"
      << "\n";
   AM.getResult<FunctionPropertiesAnalysis>(F).print(OS);
   return PreservedAnalyses::all();
 }
 No newline at end of file

llvm/test/Analysis/FunctionPropertiesAnalysis/matmul.ll

entry:
   %arraydecay2 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %res, i64 0, i64 0
   call void @multiply([2 x i32]* %arraydecay, [2 x i32]* %arraydecay1, [2 x i32]* %arraydecay2)
   ret i32 0
 }
 ; CHECK-DAG: BasicBlockCount: 1
 ; CHECK-DAG: BlocksReachedFromConditionalInstruction: 0
 ; CHECK-DAG: Uses: 1
 ; CHECK-DAG: DirectCallsToDefinedFunctions: 1
+; CHECK-DAG: LoadInstCount: 0
+; CHECK-DAG: StoreInstCount: 1
+; CHECK-DAG: MaxLoopDepth: 0
+; CHECK-DAG: TopLevelLoopCount: 0
 
 define void @multiply([2 x i32]* %mat1, [2 x i32]* %mat2, [2 x i32]* %res) {
 ; CHECK-DAG: Printing analysis results of CFA for function 'multiply':
 entry:
   %mat1.addr = alloca [2 x i32]*, align 8
   %mat2.addr = alloca [2 x i32]*, align 8
   %res.addr = alloca [2 x i32]*, align 8
   %i = alloca i32, align 4

 
 for.end26:                                        ; preds = %for.cond
   ret void
 }
 
 ; CHECK-DAG: BasicBlockCount: 13
 ; CHECK-DAG: BlocksReachedFromConditionalInstruction: 6
 ; CHECK-DAG: Uses: 2
-; CHECK-DAG: DirectCallsToDefinedFunctions: 0
+; CHECK-DAG: DirectCallsToDefinedFunctions: 0
+; CHECK-DAG: LoadInstCount: 21
+; CHECK-DAG: StoreInstCount: 11
+; CHECK-DAG: MaxLoopDepth: 3
+; CHECK-DAG: TopLevelLoopCount: 1
 No newline at end of file

llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp

 //===- FunctionPropertiesAnalysisTest.cpp - Function Properties Unit Tests-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/FunctionPropertiesAnalysis.h"
 #include "llvm/AsmParser/Parser.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/SourceMgr.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
+namespace {
 
-static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
+class FunctionPropertiesAnalysisTest : public testing::Test {
+protected:
+  std::unique_ptr<DominatorTree> DT;
+  std::unique_ptr<LoopInfo> LI;
+
+  FunctionPropertiesInfo buildFPI(Function &F) {
+    DT.reset(new DominatorTree(F));
+    LI.reset(new LoopInfo(*DT));
+    return FunctionPropertiesInfo::getFunctionPropertiesInfo(F, *LI);
+  }
+
+  std::unique_ptr<Module> makeLLVMModule(LLVMContext &C, const char *IR) {
     SMDiagnostic Err;
     std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
     if (!Mod)
       Err.print("MLAnalysisTests", errs());
     return Mod;
   }
+};
 
-TEST(FunctionPropertiesTest, BasicTest) {
+TEST_F(FunctionPropertiesAnalysisTest, BasicTest) {
   LLVMContext C;
-  std::unique_ptr<Module> M = parseIR(C,
+  std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
-
 declare i32 @f1(i32)
 declare i32 @f2(i32)
-
 define i32 @branches(i32) {
   %cond = icmp slt i32 %0, 3
   br i1 %cond, label %then, label %else
-
 then:
   %ret.1 = call i32 @f1(i32 %0)
   br label %last.block
-
 else:
   %ret.2 = call i32 @f2(i32 %0)
   br label %last.block
-
 last.block:
   %ret = phi i32 [%ret.1, %then], [%ret.2, %else]
   ret i32 %ret
 }
-
 define internal i32 @top() {
   %1 = call i32 @branches(i32 2)
   %2 = call i32 @f1(i32 %1)
   ret i32 %2
 }
 )IR");
 
-  FunctionAnalysisManager FAM;
-  FunctionPropertiesAnalysis FPA;
-
-  auto BranchesFeatures = FPA.run(*M->getFunction("branches"), FAM);
+  Function *BranchesFunction = M->getFunction("branches");
+  FunctionPropertiesInfo BranchesFeatures = buildFPI(*BranchesFunction);
   EXPECT_EQ(BranchesFeatures.BasicBlockCount, 4);
   EXPECT_EQ(BranchesFeatures.BlocksReachedFromConditionalInstruction, 2);
-  EXPECT_EQ(BranchesFeatures.DirectCallsToDefinedFunctions, 0);
   // 2 Users: top is one. The other is added because @branches is not internal,
   // so it may have external callers.
   EXPECT_EQ(BranchesFeatures.Uses, 2);
+  EXPECT_EQ(BranchesFeatures.DirectCallsToDefinedFunctions, 0);
+  EXPECT_EQ(BranchesFeatures.LoadInstCount, 0);
+  EXPECT_EQ(BranchesFeatures.StoreInstCount, 0);
+  EXPECT_EQ(BranchesFeatures.MaxLoopDepth, 0);
+  EXPECT_EQ(BranchesFeatures.TopLevelLoopCount, 0);
 
-  auto TopFeatures = FPA.run(*M->getFunction("top"), FAM);
+  Function *TopFunction = M->getFunction("top");
+  FunctionPropertiesInfo TopFeatures = buildFPI(*TopFunction);
   EXPECT_EQ(TopFeatures.BasicBlockCount, 1);
   EXPECT_EQ(TopFeatures.BlocksReachedFromConditionalInstruction, 0);
-  EXPECT_EQ(TopFeatures.DirectCallsToDefinedFunctions, 1);
   EXPECT_EQ(TopFeatures.Uses, 0);
+  EXPECT_EQ(TopFeatures.DirectCallsToDefinedFunctions, 1);
+  EXPECT_EQ(BranchesFeatures.LoadInstCount, 0);
+  EXPECT_EQ(BranchesFeatures.StoreInstCount, 0);
+  EXPECT_EQ(BranchesFeatures.MaxLoopDepth, 0);
+  EXPECT_EQ(BranchesFeatures.TopLevelLoopCount, 0);
 }
+} // end anonymous namespace
 No newline at end of file