[XRay] Add a helper function sortByKey to simplify code

[MaskRay]

.

[MaskRay]

Use specific type

[dberris]

LGTM -- Thanks @MaskRay!

tools/llvm-xray/xray-account.cpp

ResultRow getStats(std::vector<uint64_t> &Timings) {
   auto Pct99Off = std::floor(Timings.size() * 0.99);
   std::nth_element(Timings.begin(), Timings.begin() + Pct99Off, Timings.end());
   R.Pct99 = Timings[Pct99Off];
   return R;
 }
 
 } // namespace
 
+using TupleType = std::tuple<int32_t, uint64_t, ResultRow>;
+
+template <typename Container, typename F>
+static void sortByKey(Container &C, F Fn) {
+  SortDirection ASO = AccountSortOrder;
+  llvm::sort(C, [=](const TupleType &L, const TupleType &R) -> bool {
+    switch (ASO) {
+    case SortDirection::ASCENDING:
+      return Fn(L) < Fn(R);
+    case SortDirection::DESCENDING:
+      return Fn(L) > Fn(R);
+    }
+    llvm_unreachable("Unknown sort direction");
+  });
+}
+
 template <class F>
 void LatencyAccountant::exportStats(const XRayFileHeader &Header, F Fn) const {
-  using TupleType = std::tuple<int32_t, uint64_t, ResultRow>;
   std::vector<TupleType> Results;
   Results.reserve(FunctionLatencies.size());
   for (auto FT : FunctionLatencies) {
     const auto &FuncId = FT.first;
     auto &Timings = FT.second;
     Results.emplace_back(FuncId, Timings.size(), getStats(Timings));
     auto &Row = std::get<2>(Results.back());
     if (Header.CycleFrequency) {
       double CycleFrequency = Header.CycleFrequency;
       Row.Min /= CycleFrequency;
       Row.Median /= CycleFrequency;
       Row.Pct90 /= CycleFrequency;
       Row.Pct99 /= CycleFrequency;
       Row.Max /= CycleFrequency;
       Row.Sum /= CycleFrequency;
     }
 
     Row.Function = FuncIdHelper.SymbolOrNumber(FuncId);
     Row.DebugInfo = FuncIdHelper.FileLineAndColumn(FuncId);
   }
 
   // Sort the data according to user-provided flags.
   switch (AccountSortOutput) {
   case SortField::FUNCID:
-    llvm::sort(Results, [](const TupleType &L, const TupleType &R) {
-      if (AccountSortOrder == SortDirection::ASCENDING)
-        return std::get<0>(L) < std::get<0>(R);
-      if (AccountSortOrder == SortDirection::DESCENDING)
-        return std::get<0>(L) > std::get<0>(R);
-      llvm_unreachable("Unknown sort direction");
-    });
+    sortByKey(Results, [](const TupleType &X) { return std::get<0>(X); });
     break;
   case SortField::COUNT:
-    llvm::sort(Results, [](const TupleType &L, const TupleType &R) {
-      if (AccountSortOrder == SortDirection::ASCENDING)
-        return std::get<1>(L) < std::get<1>(R);
-      if (AccountSortOrder == SortDirection::DESCENDING)
-        return std::get<1>(L) > std::get<1>(R);
-      llvm_unreachable("Unknown sort direction");
-    });
+    sortByKey(Results, [](const TupleType &X) { return std::get<1>(X); });
     break;
-  default:
-    // Here we need to look into the ResultRow for the rest of the data that
-    // we want to sort by.
-    llvm::sort(Results, [&](const TupleType &L, const TupleType &R) {
-      auto &LR = std::get<2>(L);
-      auto &RR = std::get<2>(R);
-      switch (AccountSortOutput) {
-      case SortField::COUNT:
-        if (AccountSortOrder == SortDirection::ASCENDING)
-          return LR.Count < RR.Count;
-        if (AccountSortOrder == SortDirection::DESCENDING)
-          return LR.Count > RR.Count;
-        llvm_unreachable("Unknown sort direction");
-      case SortField::MIN:
-        if (AccountSortOrder == SortDirection::ASCENDING)
-          return LR.Min < RR.Min;
-        if (AccountSortOrder == SortDirection::DESCENDING)
-          return LR.Min > RR.Min;
-        llvm_unreachable("Unknown sort direction");
-      case SortField::MED:
-        if (AccountSortOrder == SortDirection::ASCENDING)
-          return LR.Median < RR.Median;
-        if (AccountSortOrder == SortDirection::DESCENDING)
-          return LR.Median > RR.Median;
-        llvm_unreachable("Unknown sort direction");
-      case SortField::PCT90:
-        if (AccountSortOrder == SortDirection::ASCENDING)
-          return LR.Pct90 < RR.Pct90;
-        if (AccountSortOrder == SortDirection::DESCENDING)
-          return LR.Pct90 > RR.Pct90;
-        llvm_unreachable("Unknown sort direction");
-      case SortField::PCT99:
-        if (AccountSortOrder == SortDirection::ASCENDING)
-          return LR.Pct99 < RR.Pct99;
-        if (AccountSortOrder == SortDirection::DESCENDING)
-          return LR.Pct99 > RR.Pct99;
-        llvm_unreachable("Unknown sort direction");
-      case SortField::MAX:
-        if (AccountSortOrder == SortDirection::ASCENDING)
-          return LR.Max < RR.Max;
-        if (AccountSortOrder == SortDirection::DESCENDING)
-          return LR.Max > RR.Max;
-        llvm_unreachable("Unknown sort direction");
-      case SortField::SUM:
-        if (AccountSortOrder == SortDirection::ASCENDING)
-          return LR.Sum < RR.Sum;
-        if (AccountSortOrder == SortDirection::DESCENDING)
-          return LR.Sum > RR.Sum;
-        llvm_unreachable("Unknown sort direction");
-      default:
-        llvm_unreachable("Unsupported sort order");
-      }
-    });
+    sortByKey(Results, [](const TupleType &X) { return std::get<2>(X).Min; });
+    break;
+    sortByKey(Results, [](const TupleType &X) { return std::get<2>(X).Median; });
+    break;
+    sortByKey(Results, [](const TupleType &X) { return std::get<2>(X).Pct90; });
+    break;
+    sortByKey(Results, [](const TupleType &X) { return std::get<2>(X).Pct99; });
+    break;
+    sortByKey(Results, [](const TupleType &X) { return std::get<2>(X).Max; });
+    break;
+    sortByKey(Results, [](const TupleType &X) { return std::get<2>(X).Sum; });
     break;
+  case SortField::FUNC:
+    llvm_unreachable("Not implemented");
   }
 
   if (AccountTop > 0) {
     auto MaxTop =
         std::min(AccountTop.getValue(), static_cast<int>(Results.size()));
     Results.erase(Results.begin() + MaxTop, Results.end());
   }