osd: make use of osd perf query's limit param

Signed-off-by: Mykola Golub <mgolub@suse.com>

diff --git a/src/osd/DynamicPerfStats.h b/src/osd/DynamicPerfStats.h
index 049451575c29d8f7c766137e65d66396ee65db3f..923649fdedd4326ea73e9cc67fe7cf638455787c 100644 (file)
--- a/src/osd/DynamicPerfStats.h
+++ b/src/osd/DynamicPerfStats.h
@@ -152,22 +152,84 @@ public:
   }
 
   void add_to_reports(
+      const std::map<OSDPerfMetricQuery, OSDPerfMetricLimits> & limits,
       std::map<OSDPerfMetricQuery, OSDPerfMetricReport> *reports) {
     for (auto &it : data) {
       auto &query = it.first;
+      auto &counters = it.second;
       auto &report = (*reports)[query];
 
       query.get_performance_counter_descriptors(
           &report.performance_counter_descriptors);
 
-      for (auto &it_counters : it.second) {
-        auto &bl = report.group_packed_performance_counters[it_counters.first];
-        query.pack_counters(it_counters.second, &bl);
+      auto &descriptors = report.performance_counter_descriptors;
+      ceph_assert(descriptors.size() > 0);
+
+      if (!is_limited(limits.at(query), counters.size())) {
+        for (auto &it_counters : counters) {
+          auto &bl = report.group_packed_performance_counters[it_counters.first];
+          query.pack_counters(it_counters.second, &bl);
+        }
+        continue;
+      }
+
+      for (auto &limit : limits.at(query)) {
+        size_t index = 0;
+        for (; index < descriptors.size(); index++) {
+          if (descriptors[index] == limit.order_by) {
+            break;
+          }
+        }
+        if (index == descriptors.size()) {
+          // should not happen
+          continue;
+        }
+
+        typedef std::map<OSDPerfMetricKey, PerformanceCounters>::iterator
+            Iterator;
+        std::vector<Iterator> counter_iterators;
+        counter_iterators.reserve(counters.size());
+        for (Iterator it_counters = counters.begin();
+             it_counters != counters.end(); it_counters++) {
+          counter_iterators.push_back(it_counters);
+        }
+        std::sort(counter_iterators.begin(), counter_iterators.end(),
+                  [index](const Iterator &a, const Iterator &b) -> bool {
+                    return a->second[index].first > b->second[index].first;
+                  });
+
+        uint64_t count = 0;
+        for (auto it_counters : counter_iterators) {
+          if (count == limit.max_count) {
+            break;
+          }
+          auto &bl =
+              report.group_packed_performance_counters[it_counters->first];
+          if (bl.length() == 0) {
+            query.pack_counters(it_counters->second, &bl);
+          }
+          count++;
+        }
       }
     }
   }
 
 private:
+  static bool is_limited(const OSDPerfMetricLimits &limits,
+                         size_t counters_size) {
+    if (limits.empty()) {
+      return false;
+    }
+
+    for (auto &limit : limits) {
+      if (limit.max_count >= counters_size) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   std::map<OSDPerfMetricQuery,
            std::map<OSDPerfMetricKey, PerformanceCounters>> data;
 };

diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index 0eeab719b4d0f4b86a9c3287239ed7ff88357e0a..ab72399122375b23ab460e54b05325c47eb09e0d 100644 (file)
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -9819,6 +9819,7 @@ void OSD::set_perf_queries(
   {
     Mutex::Locker locker(m_perf_queries_lock);
     m_perf_queries = supported_queries;
+    m_perf_limits = queries;
   }
 
   std::vector<PGRef> pgs;
@@ -9850,7 +9851,7 @@ void OSD::get_perf_reports(
       dps.merge(pg_dps);
     }
   }
-  dps.add_to_reports(reports);
+  dps.add_to_reports(m_perf_limits, reports);
   dout(20) << "reports for " << reports->size() << " queries" << dendl;
 }
 

diff --git a/src/osd/OSD.h b/src/osd/OSD.h
index 49d689b588c4698b7f0ff577b8348ff5d7b5e837..1aaf19b134daff58ed18e8ef56aa04cdb771e411 100644 (file)
--- a/src/osd/OSD.h
+++ b/src/osd/OSD.h
@@ -2317,6 +2317,7 @@ private:
 
   Mutex m_perf_queries_lock = {"OSD::m_perf_queries_lock"};
   std::list<OSDPerfMetricQuery> m_perf_queries;
+  std::map<OSDPerfMetricQuery, OSDPerfMetricLimits> m_perf_limits;
 };