Functional compound hist

Author: komarevtsev-d

cloud/storage/core/libs/diagnostics/request_counters.cpp

@@ -151,21 +151,21 @@ class TCompoundTimeHist
         const TString& name,
         EHistogramCounterOptions counterOptions)
     {
-        const bool useMsUnitsForTimeHistogram =
-            counterOptions &
-            EHistogramCounterOption::UseMsUnitsForTimeHistogram;
         const bool useUsUnitsForTimeHistogram =
             counterOptions &
             EHistogramCounterOption::UseUsUnitsForTimeHistogram;
+        const bool useMsUnitsForTimeHistogram =
+            counterOptions &
+            EHistogramCounterOption::UseMsUnitsForTimeHistogram;
         Y_ABORT_UNLESS(
-            useMsUnitsForTimeHistogram || useUsUnitsForTimeHistogram,
+            useUsUnitsForTimeHistogram || useMsUnitsForTimeHistogram,
             "At least one of the units must be enabled");
-        if (useMsUnitsForTimeHistogram) {
-            MsTimeHist = std::make_unique<TMsTimeHist>(name, counterOptions);
-        }
         if (useUsUnitsForTimeHistogram) {
             UsTimeHist = std::make_unique<TUsTimeHist>(name, counterOptions);
         }
+        if (useMsUnitsForTimeHistogram) {
+            MsTimeHist = std::make_unique<TMsTimeHist>(name, counterOptions);
+        }
     }
     ~TCompoundTimeHist() = default;
 
@@ -176,47 +176,47 @@ class TCompoundTimeHist
 
     void Increment(TDuration requestTime, ui64 count = 1)
     {
-        if (MsTimeHist) {
-            MsTimeHist->Increment(requestTime, count);
-        }
         if (UsTimeHist) {
             UsTimeHist->Increment(requestTime, count);
         }
+        if (MsTimeHist) {
+            MsTimeHist->Increment(requestTime, count);
+        }
     }
 
     template <typename... Args>
     void Register(Args&&... args)
     {
-        if (MsTimeHist) {
-            MsTimeHist->Register(args...);
-        }
         if (UsTimeHist) {
-            UsTimeHist->Register(std::forward<Args>(args)...);
+            UsTimeHist->Register(args...);
+        }
+        if (MsTimeHist) {
+            MsTimeHist->Register(std::forward<Args>(args)...);
         }
     }
 
     [[nodiscard]] TVector<TBucketInfo> GetBuckets() const
     {
-        if (MsTimeHist) {
-            return MsTimeHist->GetBuckets();
+        if (UsTimeHist) {
+            return UsTimeHist->GetBuckets();
         }
-        return UsTimeHist->GetBuckets();
+        return MsTimeHist->GetBuckets();
     }
 
     [[nodiscard]] const TString& GetUnits() const
     {
-        if (MsTimeHist) {
-            return MsTimeHist->GetUnits();
+        if (UsTimeHist) {
+            return UsTimeHist->GetUnits();
         }
-        return UsTimeHist->GetUnits();
+        return MsTimeHist->GetUnits();
     }
 
     [[nodiscard]] const TString& GetName() const
     {
-        if (MsTimeHist) {
-            return MsTimeHist->GetName();
+        if (UsTimeHist) {
+            return UsTimeHist->GetName();
         }
-        return UsTimeHist->GetName();
+        return MsTimeHist->GetName();
     }
 };
 
@@ -274,11 +274,14 @@ class TRequestPercentiles
 
         TVector<TBucketInfo> delta(Reserve(update.size()));
         for (size_t i = 0; i < update.size(); ++i) {
+            // Cerr << "update [" << i << "] = " << update[i].first << ", " << update[i].second << Endl;
             const auto& [bound, value] = update[i];
             delta.emplace_back(bound, value - Prev[i]);
             Prev[i] = value;
         }
 
+        // Cerr << "-------------" << Endl;
+
         auto result = CalculateWeightedPercentiles(
             delta,
             GetDefaultPercentiles());

cloud/storage/core/libs/diagnostics/weighted_percentile.cpp

@@ -70,8 +70,8 @@ TVector<double> CalculateWeightedPercentiles(
             current = (double)(prevSum + bit->second) / totalSum;
         }
         if (current >= pit->first) {
-            const auto delta = pit->first * totalSum - prevSum;
-            const auto part = (bit->first - prevLimit)
+            const double delta = pit->first * totalSum - prevSum;
+            const double part = (bit->first - prevLimit)
                 * (delta / (bit->second ? bit->second : 1));
             result.push_back(std::min(prevLimit + part, greatestFiniteLimit));
             ++pit;