[Analysis] Add OpCount Analysis

include/circt/Analysis/OpCountAnalysis.h

@@ -0,0 +1,43 @@
+//===- OpCountAnalysis.h - operation count analyses -----------------------===//
+//
+// 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 header file defines prototypes for methods that perform analysis
+// involving the frequency of different kinds of operations found in a
+// builtin.module.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CIRCT_ANALYSIS_OPCOUNT_ANALYSIS_H
+#define CIRCT_ANALYSIS_OPCOUNT_ANALYSIS_H
+
+#include "circt/Support/LLVM.h"
+#include "mlir/IR/Operation.h"
+#include "llvm/ADT/DenseMap.h"
+
+namespace mlir {
+class AnalysisManager;
+} // namespace mlir
+namespace circt {
+namespace analysis {
+
+struct OpCountAnalysis {
+  OpCountAnalysis(Operation *moduleOp, mlir::AnalysisManager &am);
+
+  size_t getOpCount(OperationName opName);
+  SmallVector<OperationName> getFoundOpNames();
+  DenseMap<size_t, size_t> getOperandCountMap(OperationName opName);
+
+private:
+  DenseMap<OperationName, size_t> opCounts;
+  DenseMap<OperationName, DenseMap<size_t, size_t>> operandCounts;
+};
+
+} // namespace analysis
+} // namespace circt
+
+#endif // CIRCT_ANALYSIS_SCHEDULING_ANALYSIS_H

lib/Analysis/CMakeLists.txt

@@ -3,6 +3,7 @@ set(LLVM_OPTIONAL_SOURCES
   DebugInfo.cpp
   DependenceAnalysis.cpp
   FIRRTLInstanceInfo.cpp
+  OpCountAnalysis.cpp
   SchedulingAnalysis.cpp
   TestPasses.cpp
 )
@@ -27,6 +28,13 @@ add_circt_library(CIRCTDependenceAnalysis
   MLIRTransformUtils
 )
 
+add_circt_library(CIRCTOpCountAnalysis
+  OpCountAnalysis.cpp
+
+  LINK_LIBS PUBLIC
+  MLIRPass
+)
+
 add_circt_library(CIRCTSchedulingAnalysis
   SchedulingAnalysis.cpp
 
@@ -50,6 +58,7 @@ add_circt_library(CIRCTAnalysisTestPasses
   LINK_LIBS PUBLIC
   CIRCTDebugAnalysis
   CIRCTDependenceAnalysis
+  CIRCTOpCountAnalysis
   CIRCTFIRRTLAnalysis
   CIRCTSchedulingAnalysis
   CIRCTHW

lib/Analysis/OpCountAnalysis.cpp

@@ -0,0 +1,62 @@
+//===- OpCountAnalysis.cpp - operation count analyses -----------*- 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 op count analysis.  This is an analysis that
+// provides information about the frequency of different kinds of operations
+// found in a builtin.module.
+//
+//===----------------------------------------------------------------------===//
+
+#include "circt/Analysis/OpCountAnalysis.h"
+#include "mlir/IR/Operation.h"
+
+using namespace circt;
+using namespace analysis;
+
+OpCountAnalysis::OpCountAnalysis(Operation *moduleOp,
+                                 mlir::AnalysisManager &am) {
+  moduleOp->walk([&](Operation *op) {
+    auto opName = op->getName();
+    // Update opCounts
+    if (opCounts.find(opName) == opCounts.end())
+      opCounts[opName] = 1;
+    else
+      opCounts[op->getName()]++;
+
+    // Update operandCounts
+    if (operandCounts.find(opName) == operandCounts.end())
+      operandCounts[opName] = DenseMap<size_t, size_t>();
+    if (operandCounts[opName].find(op->getNumOperands()) ==
+        operandCounts[opName].end())
+      operandCounts[opName][op->getNumOperands()] = 1;
+    else
+      operandCounts[opName][op->getNumOperands()]++;
+  });
+}
+
+SmallVector<OperationName> OpCountAnalysis::getFoundOpNames() {
+  SmallVector<OperationName> opNames;
+  for (auto pair : opCounts)
+    opNames.push_back(pair.first);
+  return opNames;
+}
+
+size_t OpCountAnalysis::getOpCount(OperationName opName) {
+  size_t count = 0;
+  if (opCounts.find(opName) != opCounts.end())
+    count = opCounts[opName];
+  return count;
+}
+
+DenseMap<size_t, size_t>
+OpCountAnalysis::getOperandCountMap(OperationName opName) {
+  auto map = DenseMap<size_t, size_t>();
+  if (operandCounts.find(opName) != operandCounts.end())
+    map = operandCounts[opName];
+  return map;
+}

lib/Analysis/TestPasses.cpp

@@ -13,6 +13,7 @@
 #include "circt/Analysis/DebugAnalysis.h"
 #include "circt/Analysis/DependenceAnalysis.h"
 #include "circt/Analysis/FIRRTLInstanceInfo.h"
+#include "circt/Analysis/OpCountAnalysis.h"
 #include "circt/Analysis/SchedulingAnalysis.h"
 #include "circt/Dialect/FIRRTL/FIRRTLInstanceGraph.h"
 #include "circt/Dialect/HW/HWInstanceGraph.h"
@@ -250,6 +251,49 @@ void FIRRTLInstanceInfoPass::runOnOperation() {
     printModuleInfo(op, iInfo);
 }
 
+//===----------------------------------------------------------------------===//
+// Op Count
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TestOpCountAnalysisPass
+    : public PassWrapper<TestOpCountAnalysisPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestOpCountAnalysisPass)
+
+  void runOnOperation() override;
+  StringRef getArgument() const override { return "test-op-count-analysis"; }
+  StringRef getDescription() const override {
+    return "Run OpCountAnalysis and show the results.  This pass "
+           "is intended to be used for testing purposes only.";
+  }
+};
+} // namespace
+
+void printOpAndOperandCounts(OpCountAnalysis &opCount) {
+  auto opNames = opCount.getFoundOpNames();
+  // Sort to account for non-deterministic DenseMap ordering
+  llvm::sort(opNames, [](OperationName name1, OperationName name2) {
+    return name1.getStringRef() < name2.getStringRef();
+  });
+  for (auto opName : opNames) {
+    llvm::errs() << opName << ": " << opCount.getOpCount(opName) << "\n";
+    auto operandMap = opCount.getOperandCountMap(opName);
+    // Sort for determinism again
+    llvm::SmallVector<size_t> keys;
+    for (auto pair : operandMap)
+      keys.push_back(pair.first);
+    llvm::sort(keys);
+    for (auto num : keys)
+      llvm::errs() << " with " << num << " operands: " << operandMap[num]
+                   << "\n";
+  }
+}
+
+void TestOpCountAnalysisPass::runOnOperation() {
+  auto &opCount = getAnalysis<OpCountAnalysis>();
+  printOpAndOperandCounts(opCount);
+}
+
 //===----------------------------------------------------------------------===//
 // Pass registration
 //===----------------------------------------------------------------------===//
@@ -272,6 +316,9 @@ void registerAnalysisTestPasses() {
   registerPass([]() -> std::unique_ptr<Pass> {
     return std::make_unique<FIRRTLInstanceInfoPass>();
   });
+  registerPass([]() -> std::unique_ptr<Pass> {
+    return std::make_unique<TestOpCountAnalysisPass>();
+  });
 }
 } // namespace test
 } // namespace circt

test/Analysis/op-count-analysis.mlir

@@ -0,0 +1,36 @@
+// RUN: circt-opt -test-op-count-analysis %s 2>&1 | FileCheck %s
+
+// CHECK: builtin.module: 1
+// CHECK:  with 0 operands: 1
+// CHECK: comb.add: 4
+// CHECK:  with 1 operands: 1
+// CHECK:  with 2 operands: 1
+// CHECK:  with 3 operands: 2
+// CHECK: comb.icmp: 1
+// CHECK:  with 2 operands: 1
+// CHECK: comb.xor: 1
+// CHECK:  with 1 operands: 1
+// CHECK: hw.module: 1
+// CHECK:  with 0 operands: 1
+// CHECK: hw.output: 1
+// CHECK:  with 0 operands: 1
+// CHECK: scf.if: 1
+// CHECK:  with 1 operands: 1
+// CHECK: scf.yield: 2
+// CHECK:  with 1 operands: 2
+
+module {
+  hw.module @bar(in %in1: i8, in %in2: i8, in %in3: i8) {
+    %add2 = comb.add %in1, %in2 : i8
+    %add3 = comb.add %in1, %in2, %in3 : i8
+    %add3again = comb.add %in1, %in3, %in3 : i8
+    %gt = comb.icmp ult %in1, %in2 : i8
+    %x = scf.if %gt -> (i8) {
+        %add1 = comb.add %in1 : i8
+        scf.yield %add1 : i8
+    } else {
+        %xor = comb.xor %add2 : i8
+        scf.yield %xor : i8
+    }
+  }
+}