[llvm-exegesis] Add a custom error for clustering

[mstojanovic]

Summary

All errors of type Failure are StringErrors. In order for exit code mapping to detect that specifically a clustering error has occurred it needs to have a different type.

This patch also prepares D74085 where termination report_fatal_error() will be replaced with emitting StringErrors.

[gchatelet]

LGTM

llvm/tools/llvm-exegesis/lib/CMakeLists.txt

 add_library(LLVMExegesis
   STATIC
   Analysis.cpp
   Assembler.cpp
   BenchmarkResult.cpp
   BenchmarkRunner.cpp
   Clustering.cpp
   CodeTemplate.cpp
+  Error.cpp
   LatencyBenchmarkRunner.cpp
   LlvmState.cpp
   MCInstrDescView.cpp
   ParallelSnippetGenerator.cpp
   PerfHelper.cpp
   RegisterAliasing.cpp
   RegisterValue.cpp
   SchedClassResolution.cpp

llvm/tools/llvm-exegesis/lib/Clustering.cpp

 //===-- Clustering.cpp ------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Clustering.h"
+#include "Error.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include <algorithm>
 #include <string>
 #include <vector>
 
 namespace llvm {
for (size_t P = 0, NumPoints = Points_.size(); P < NumPoints; ++P) {
     if (!Point.Error.empty()) {
       ClusterIdForPoint_[P] = ClusterId::error();
       ErrorCluster_.PointIndices.push_back(P);
       continue;
     }
     const auto *CurMeasurement = &Point.Measurements;
     if (LastMeasurement) {
       if (LastMeasurement->size() != CurMeasurement->size()) {
-        return make_error<StringError>("inconsistent measurement dimensions",
-                                       inconvertibleErrorCode());
+        return make_error<ClusteringError>(
+            "inconsistent measurement dimensions");
       }
       for (size_t I = 0, E = LastMeasurement->size(); I < E; ++I) {
         if (LastMeasurement->at(I).Key != CurMeasurement->at(I).Key) {
-          return make_error<StringError>(
-              "inconsistent measurement dimensions keys",
-              inconvertibleErrorCode());
+          return make_error<ClusteringError>(
+              "inconsistent measurement dimensions keys");
         }
       }
     }
     LastMeasurement = CurMeasurement;
   }
   if (LastMeasurement) {
     NumDimensions_ = LastMeasurement->size();
   }
Expected<InstructionBenchmarkClustering> InstructionBenchmarkClustering::create(
 
   if (Mode == ModeE::Dbscan) {
     Clustering.clusterizeDbScan(DbscanMinPts);
 
     if (NumOpcodes.hasValue())
       Clustering.stabilize(NumOpcodes.getValue());
   } else /*if(Mode == ModeE::Naive)*/ {
     if (!NumOpcodes.hasValue())
-      report_fatal_error(
+      return make_error<Failure>(
           "'naive' clustering mode requires opcode count to be specified");
     Clustering.clusterizeNaive(NumOpcodes.getValue());
   }
 
   return Clustering;
 }
 
 void SchedClassClusterCentroid::addPoint(ArrayRef<BenchmarkMeasure> Point) {

llvm/tools/llvm-exegesis/lib/Error.h

 
 // A class representing failures that happened within llvm-exegesis, they are
 // used to report informations to the user.
 class Failure : public StringError {
 public:
   Failure(const Twine &S) : StringError(S, inconvertibleErrorCode()) {}
 };
 
+// A class representing failures that happened during clustering calculations.
+class ClusteringError : public ErrorInfo<ClusteringError> {
+public:
+  static char ID;
+  ClusteringError(const Twine&S) : Msg(S.str()) {}
+
+  void log(raw_ostream &OS) const override;
+
+  std::error_code convertToErrorCode() const override;
+private:
+    std::string Msg;
+};
+
 } // namespace exegesis
 } // namespace llvm
 
 #endif

llvm/tools/llvm-exegesis/lib/Error.cpp

+//===-- Error.cpp -----------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Error.h"
+
+namespace llvm {
+namespace exegesis {
+
+char ClusteringError::ID;
+
+void ClusteringError::log(raw_ostream &OS) const {
+  OS << Msg;
+}
+
+std::error_code ClusteringError::convertToErrorCode() const {
+  return inconvertibleErrorCode();
+}
+
+} // namespace exegesis
+} // namespace llvm

llvm/tools/llvm-exegesis/llvm-exegesis.cpp

 } // namespace exegesis
 } // namespace llvm
 
 int main(int Argc, char **Argv) {
   using namespace llvm;
   cl::ParseCommandLineOptions(Argc, Argv, "");
 
   exegesis::ExitOnErr.setExitCodeMapper([](const Error &Err) {
-    if (Err.isA<StringError>())
+    if (Err.isA<exegesis::ClusteringError>())
       return EXIT_SUCCESS;
     return EXIT_FAILURE;
   });
 
   if (exegesis::BenchmarkMode == exegesis::InstructionBenchmark::Unknown) {
     exegesis::analysisMain();
   } else {
     exegesis::benchmarkMain();
   }
   return EXIT_SUCCESS;
 }