Restoring authorship annotation for <msherbakov@yandex-team.ru>. Commit 2 of 2.

5 files changed, 325 insertions, 325 deletions

diff --git a/library/cpp/monlib/dynamic_counters/percentile/percentile.h b/library/cpp/monlib/dynamic_counters/percentile/percentile.h
index 08b7ec5f0f..73c482bce9 100644
--- a/library/cpp/monlib/dynamic_counters/percentile/percentile.h
+++ b/library/cpp/monlib/dynamic_counters/percentile/percentile.h
@@ -1,59 +1,59 @@
-#pragma once 
- 
+#pragma once
+
 #include "percentile_base.h"
- 
-namespace NMonitoring { 
- 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
-// Percentile tracker for monitoring 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
- 
-template <size_t BUCKET_SIZE, size_t BUCKET_COUNT, size_t FRAME_COUNT> 
+
+namespace NMonitoring {
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Percentile tracker for monitoring
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <size_t BUCKET_SIZE, size_t BUCKET_COUNT, size_t FRAME_COUNT>
 struct TPercentileTracker : public TPercentileBase {
-    TAtomic Items[BUCKET_COUNT]; 
-    TAtomicBase Frame[FRAME_COUNT][BUCKET_COUNT]; 
-    size_t CurrentFrame; 
- 
-    TPercentileTracker() 
-        : CurrentFrame(0) 
-    { 
-        for (size_t i = 0; i < BUCKET_COUNT; ++i) { 
-            AtomicSet(Items[i], 0); 
-        } 
-        for (size_t frame = 0; frame < FRAME_COUNT; ++frame) { 
-            for (size_t bucket = 0; bucket < BUCKET_COUNT; ++bucket) { 
-                Frame[frame][bucket] = 0; 
-            } 
-        } 
-    } 
- 
-    void Increment(size_t value) { 
-        AtomicIncrement(Items[Min((value + BUCKET_SIZE - 1) / BUCKET_SIZE, BUCKET_COUNT - 1)]); 
-    } 
- 
-    // shift frame (call periodically) 
-    void Update() { 
-        TVector<TAtomicBase> totals(BUCKET_COUNT); 
-        totals.resize(BUCKET_COUNT); 
-        TAtomicBase total = 0; 
-        for (size_t i = 0; i < BUCKET_COUNT; ++i) { 
-            TAtomicBase item = AtomicGet(Items[i]); 
-            TAtomicBase prevItem = Frame[CurrentFrame][i]; 
-            Frame[CurrentFrame][i] = item; 
-            total += item - prevItem; 
-            totals[i] = total; 
-        } 
- 
-        for (size_t i = 0; i < Percentiles.size(); ++i) { 
-            TPercentile &percentile = Percentiles[i]; 
-            auto threshold = (TAtomicBase)(percentile.first * (float)total); 
-            threshold = Min(threshold, total); 
-            auto it = LowerBound(totals.begin(), totals.end(), threshold); 
-            size_t index = it - totals.begin(); 
-            (*percentile.second) = index * BUCKET_SIZE; 
-        } 
-        CurrentFrame = (CurrentFrame + 1) % FRAME_COUNT; 
-    } 
-}; 
- 
-} // NMonitoring 
+    TAtomic Items[BUCKET_COUNT];
+    TAtomicBase Frame[FRAME_COUNT][BUCKET_COUNT];
+    size_t CurrentFrame;
+
+    TPercentileTracker()
+        : CurrentFrame(0)
+    {
+        for (size_t i = 0; i < BUCKET_COUNT; ++i) {
+            AtomicSet(Items[i], 0);
+        }
+        for (size_t frame = 0; frame < FRAME_COUNT; ++frame) {
+            for (size_t bucket = 0; bucket < BUCKET_COUNT; ++bucket) {
+                Frame[frame][bucket] = 0;
+            }
+        }
+    }
+
+    void Increment(size_t value) {
+        AtomicIncrement(Items[Min((value + BUCKET_SIZE - 1) / BUCKET_SIZE, BUCKET_COUNT - 1)]);
+    }
+
+    // shift frame (call periodically)
+    void Update() {
+        TVector<TAtomicBase> totals(BUCKET_COUNT);
+        totals.resize(BUCKET_COUNT);
+        TAtomicBase total = 0;
+        for (size_t i = 0; i < BUCKET_COUNT; ++i) {
+            TAtomicBase item = AtomicGet(Items[i]);
+            TAtomicBase prevItem = Frame[CurrentFrame][i];
+            Frame[CurrentFrame][i] = item;
+            total += item - prevItem;
+            totals[i] = total;
+        }
+
+        for (size_t i = 0; i < Percentiles.size(); ++i) {
+            TPercentile &percentile = Percentiles[i];
+            auto threshold = (TAtomicBase)(percentile.first * (float)total);
+            threshold = Min(threshold, total);
+            auto it = LowerBound(totals.begin(), totals.end(), threshold);
+            size_t index = it - totals.begin();
+            (*percentile.second) = index * BUCKET_SIZE;
+        }
+        CurrentFrame = (CurrentFrame + 1) % FRAME_COUNT;
+    }
+};
+
+} // NMonitoring
diff --git a/library/cpp/monlib/dynamic_counters/percentile/percentile_lg.h b/library/cpp/monlib/dynamic_counters/percentile/percentile_lg.h
index b39c53e3df..0042cd9a6a 100644
--- a/library/cpp/monlib/dynamic_counters/percentile/percentile_lg.h
+++ b/library/cpp/monlib/dynamic_counters/percentile/percentile_lg.h
@@ -1,182 +1,182 @@
-#pragma once 
- 
+#pragma once
+
 #include <library/cpp/containers/stack_vector/stack_vec.h>
- 
-#include <util/generic/bitops.h> 
- 
-#include <cmath> 
- 
+
+#include <util/generic/bitops.h>
+
+#include <cmath>
+
 #include "percentile_base.h"
 
-namespace NMonitoring { 
- 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
-// Percentile tracker for monitoring 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
- 
-template <size_t BASE_BITS, size_t EXP_BITS, size_t FRAME_COUNT> 
+namespace NMonitoring {
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Percentile tracker for monitoring
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <size_t BASE_BITS, size_t EXP_BITS, size_t FRAME_COUNT>
 struct TPercentileTrackerLg : public TPercentileBase {
     static constexpr size_t BUCKET_COUNT = size_t(1) << EXP_BITS;
     static constexpr size_t BUCKET_SIZE = size_t(1) << BASE_BITS;
-    static constexpr size_t ITEMS_COUNT = BUCKET_COUNT * BUCKET_SIZE; 
+    static constexpr size_t ITEMS_COUNT = BUCKET_COUNT * BUCKET_SIZE;
     static constexpr size_t TRACKER_LIMIT = BUCKET_SIZE * ((size_t(1) << BUCKET_COUNT) - 1)
                                             - (size_t(1) << (BUCKET_COUNT - 1));
     static constexpr size_t MAX_GRANULARITY = size_t(1) << (BUCKET_COUNT - 1);
 
-    size_t Borders[BUCKET_COUNT]; 
-    TAtomic Items[ITEMS_COUNT]; 
-    TAtomicBase Frame[FRAME_COUNT][ITEMS_COUNT]; 
-    size_t CurrentFrame; 
- 
-    TPercentileTrackerLg() 
-        : CurrentFrame(0) 
-    { 
-        Borders[0] = 0; 
-        for (size_t i = 1; i < BUCKET_COUNT; ++i) { 
-            Borders[i] = Borders[i-1] + (BUCKET_SIZE << (i - 1)); 
-        } 
-        for (size_t i = 0; i < ITEMS_COUNT; ++i) { 
-            AtomicSet(Items[i], 0); 
-        } 
-        for (size_t frame = 0; frame < FRAME_COUNT; ++frame) { 
-            for (size_t bucket = 0; bucket < ITEMS_COUNT; ++bucket) { 
-                Frame[frame][bucket] = 0; 
-            } 
-        } 
-    } 
- 
-    size_t inline BucketIdxIf(size_t value) { 
-        static_assert(BASE_BITS == 5, "if-based bucket calculation cannot be used if BASE_BITS != 5"); 
-        size_t bucket_idx; 
-        if (value < 8160) { 
-            if (value < 480) { 
-                if (value < 96) { 
-                    if (value < 32) { 
-                        bucket_idx = 0; 
-                    } else { 
-                        bucket_idx = 1; 
-                    } 
-                } else { 
-                    if (value < 224) { 
-                        bucket_idx = 2; 
-                    } else { 
-                        bucket_idx = 3; 
-                    } 
-                } 
-            } else { 
-                if (value < 2016) { 
-                    if (value < 992) { 
-                        bucket_idx = 4; 
-                    } else { 
-                        bucket_idx = 5; 
-                    } 
-                } else { 
-                    if (value < 4064) { 
-                        bucket_idx = 6; 
-                    } else { 
-                        bucket_idx = 7; 
-                    } 
-                } 
-            } 
-        } else { 
-            if (value < 131040) { 
-                if (value < 32736) { 
-                    if (value < 16352) { 
-                        bucket_idx = 8; 
-                    } else { 
-                        bucket_idx = 9; 
-                    } 
-                } else { 
-                    if (value < 65504) { 
-                        bucket_idx = 10; 
-                    } else { 
-                        bucket_idx = 11; 
-                    } 
-                } 
-            } else { 
-                if (value < 524256) { 
-                    if (value < 262112) { 
-                        bucket_idx = 12; 
-                    } else { 
-                        bucket_idx = 13; 
-                    } 
-                } else { 
-                    if (value < 1048544) { 
-                        bucket_idx = 14; 
-                    } else { 
-                        bucket_idx = 15; 
-                    } 
-                } 
-            } 
-        } 
-        return Min(bucket_idx, BUCKET_COUNT - 1); 
-    } 
- 
-    size_t inline BucketIdxBinarySearch(size_t value) { 
-        size_t l = 0; 
-        size_t r = BUCKET_COUNT; 
-        while (l < r - 1) { 
-            size_t mid = (l + r) / 2; 
-            if (value < Borders[mid]) { 
-                r = mid; 
-            } else { 
-                l = mid; 
-            } 
-        } 
-        return l; 
-    } 
- 
-    size_t inline BucketIdxMostSignificantBit(size_t value) { 
-        size_t bucket_idx = MostSignificantBit(value + BUCKET_SIZE) - BASE_BITS; 
-        return Min(bucket_idx, BUCKET_COUNT - 1); 
-    } 
- 
-    void Increment(size_t value) { 
+    size_t Borders[BUCKET_COUNT];
+    TAtomic Items[ITEMS_COUNT];
+    TAtomicBase Frame[FRAME_COUNT][ITEMS_COUNT];
+    size_t CurrentFrame;
+
+    TPercentileTrackerLg()
+        : CurrentFrame(0)
+    {
+        Borders[0] = 0;
+        for (size_t i = 1; i < BUCKET_COUNT; ++i) {
+            Borders[i] = Borders[i-1] + (BUCKET_SIZE << (i - 1));
+        }
+        for (size_t i = 0; i < ITEMS_COUNT; ++i) {
+            AtomicSet(Items[i], 0);
+        }
+        for (size_t frame = 0; frame < FRAME_COUNT; ++frame) {
+            for (size_t bucket = 0; bucket < ITEMS_COUNT; ++bucket) {
+                Frame[frame][bucket] = 0;
+            }
+        }
+    }
+
+    size_t inline BucketIdxIf(size_t value) {
+        static_assert(BASE_BITS == 5, "if-based bucket calculation cannot be used if BASE_BITS != 5");
+        size_t bucket_idx;
+        if (value < 8160) {
+            if (value < 480) {
+                if (value < 96) {
+                    if (value < 32) {
+                        bucket_idx = 0;
+                    } else {
+                        bucket_idx = 1;
+                    }
+                } else {
+                    if (value < 224) {
+                        bucket_idx = 2;
+                    } else {
+                        bucket_idx = 3;
+                    }
+                }
+            } else {
+                if (value < 2016) {
+                    if (value < 992) {
+                        bucket_idx = 4;
+                    } else {
+                        bucket_idx = 5;
+                    }
+                } else {
+                    if (value < 4064) {
+                        bucket_idx = 6;
+                    } else {
+                        bucket_idx = 7;
+                    }
+                }
+            }
+        } else {
+            if (value < 131040) {
+                if (value < 32736) {
+                    if (value < 16352) {
+                        bucket_idx = 8;
+                    } else {
+                        bucket_idx = 9;
+                    }
+                } else {
+                    if (value < 65504) {
+                        bucket_idx = 10;
+                    } else {
+                        bucket_idx = 11;
+                    }
+                }
+            } else {
+                if (value < 524256) {
+                    if (value < 262112) {
+                        bucket_idx = 12;
+                    } else {
+                        bucket_idx = 13;
+                    }
+                } else {
+                    if (value < 1048544) {
+                        bucket_idx = 14;
+                    } else {
+                        bucket_idx = 15;
+                    }
+                }
+            }
+        }
+        return Min(bucket_idx, BUCKET_COUNT - 1);
+    }
+
+    size_t inline BucketIdxBinarySearch(size_t value) {
+        size_t l = 0;
+        size_t r = BUCKET_COUNT;
+        while (l < r - 1) {
+            size_t mid = (l + r) / 2;
+            if (value < Borders[mid]) {
+                r = mid;
+            } else {
+                l = mid;
+            }
+        }
+        return l;
+    }
+
+    size_t inline BucketIdxMostSignificantBit(size_t value) {
+        size_t bucket_idx = MostSignificantBit(value + BUCKET_SIZE) - BASE_BITS;
+        return Min(bucket_idx, BUCKET_COUNT - 1);
+    }
+
+    void Increment(size_t value) {
         size_t bucket_idx = BucketIdxMostSignificantBit(value);
-        size_t inside_bucket_idx = (value - Borders[bucket_idx] + (1 << bucket_idx) - 1) >> bucket_idx; 
-        size_t idx = bucket_idx * BUCKET_SIZE + inside_bucket_idx; 
-        AtomicIncrement(Items[Min(idx, ITEMS_COUNT - 1)]); 
-    } 
- 
-    // Needed only for tests 
-    size_t GetPercentile(float threshold) { 
-        TStackVec<TAtomicBase, ITEMS_COUNT> totals(ITEMS_COUNT); 
-        TAtomicBase total = 0; 
-        for (size_t i = 0; i < ITEMS_COUNT; ++i) { 
-            total += AtomicGet(Items[i]); 
-            totals[i] = total; 
-        } 
-        TAtomicBase item_threshold = std::llround(threshold * (float)total); 
-        item_threshold = Min(item_threshold, total); 
-        auto it = LowerBound(totals.begin(), totals.end(), item_threshold); 
-        size_t index = it - totals.begin(); 
-        size_t bucket_idx = index / BUCKET_SIZE; 
-        return Borders[bucket_idx] + ((index % BUCKET_SIZE) << bucket_idx); 
-    } 
- 
-    // shift frame (call periodically) 
-    void Update() { 
-        TStackVec<TAtomicBase, ITEMS_COUNT> totals(ITEMS_COUNT); 
-        TAtomicBase total = 0; 
-        for (size_t i = 0; i < ITEMS_COUNT; ++i) { 
-            TAtomicBase item = AtomicGet(Items[i]); 
-            TAtomicBase prevItem = Frame[CurrentFrame][i]; 
-            Frame[CurrentFrame][i] = item; 
-            total += item - prevItem; 
-            totals[i] = total; 
-        } 
- 
-        for (size_t i = 0; i < Percentiles.size(); ++i) { 
-            TPercentile &percentile = Percentiles[i]; 
-            TAtomicBase threshold = std::llround(percentile.first * (float)total); 
-            threshold = Min(threshold, total); 
-            auto it = LowerBound(totals.begin(), totals.end(), threshold); 
-            size_t index = it - totals.begin(); 
-            size_t bucket_idx = index / BUCKET_SIZE; 
-            (*percentile.second) = Borders[bucket_idx] + ((index % BUCKET_SIZE) << bucket_idx); 
-        } 
-        CurrentFrame = (CurrentFrame + 1) % FRAME_COUNT; 
-    } 
-}; 
- 
-} // NMonitoring 
+        size_t inside_bucket_idx = (value - Borders[bucket_idx] + (1 << bucket_idx) - 1) >> bucket_idx;
+        size_t idx = bucket_idx * BUCKET_SIZE + inside_bucket_idx;
+        AtomicIncrement(Items[Min(idx, ITEMS_COUNT - 1)]);
+    }
+
+    // Needed only for tests
+    size_t GetPercentile(float threshold) {
+        TStackVec<TAtomicBase, ITEMS_COUNT> totals(ITEMS_COUNT);
+        TAtomicBase total = 0;
+        for (size_t i = 0; i < ITEMS_COUNT; ++i) {
+            total += AtomicGet(Items[i]);
+            totals[i] = total;
+        }
+        TAtomicBase item_threshold = std::llround(threshold * (float)total);
+        item_threshold = Min(item_threshold, total);
+        auto it = LowerBound(totals.begin(), totals.end(), item_threshold);
+        size_t index = it - totals.begin();
+        size_t bucket_idx = index / BUCKET_SIZE;
+        return Borders[bucket_idx] + ((index % BUCKET_SIZE) << bucket_idx);
+    }
+
+    // shift frame (call periodically)
+    void Update() {
+        TStackVec<TAtomicBase, ITEMS_COUNT> totals(ITEMS_COUNT);
+        TAtomicBase total = 0;
+        for (size_t i = 0; i < ITEMS_COUNT; ++i) {
+            TAtomicBase item = AtomicGet(Items[i]);
+            TAtomicBase prevItem = Frame[CurrentFrame][i];
+            Frame[CurrentFrame][i] = item;
+            total += item - prevItem;
+            totals[i] = total;
+        }
+
+        for (size_t i = 0; i < Percentiles.size(); ++i) {
+            TPercentile &percentile = Percentiles[i];
+            TAtomicBase threshold = std::llround(percentile.first * (float)total);
+            threshold = Min(threshold, total);
+            auto it = LowerBound(totals.begin(), totals.end(), threshold);
+            size_t index = it - totals.begin();
+            size_t bucket_idx = index / BUCKET_SIZE;
+            (*percentile.second) = Borders[bucket_idx] + ((index % BUCKET_SIZE) << bucket_idx);
+        }
+        CurrentFrame = (CurrentFrame + 1) % FRAME_COUNT;
+    }
+};
+
+} // NMonitoring
diff --git a/library/cpp/monlib/dynamic_counters/percentile/percentile_ut.cpp b/library/cpp/monlib/dynamic_counters/percentile/percentile_ut.cpp
index b09004bd7f..6c8bb54ec9 100644
--- a/library/cpp/monlib/dynamic_counters/percentile/percentile_ut.cpp
+++ b/library/cpp/monlib/dynamic_counters/percentile/percentile_ut.cpp
@@ -1,10 +1,10 @@
-#include "percentile_lg.h" 
+#include "percentile_lg.h"
 #include <library/cpp/testing/unittest/registar.h>
- 
-using namespace NMonitoring; 
- 
-Y_UNIT_TEST_SUITE(PercentileTest) { 
- 
+
+using namespace NMonitoring;
+
+Y_UNIT_TEST_SUITE(PercentileTest) {
+
 template<size_t A, size_t B, size_t B_BEGIN>
 void printSizeAndLimit() {
     using TPerc = TPercentileTrackerLg<A, B, 15>;
@@ -57,73 +57,73 @@ void printSizeAndLimit() {
         }
     }
 
-    Y_UNIT_TEST(BucketIdxIfvsBucketIdxBinarySearch) { 
-        for (size_t var = 0; var < 5; var++) { 
-            if (var == 0) { 
-                TPercentileTrackerLg<3, 2, 15> tracker; 
-                for (size_t i = 0; i < 3000000; i += 1) { 
-                    size_t num1 = tracker.BucketIdxMostSignificantBit(i); 
-                    size_t num2 = tracker.BucketIdxBinarySearch(i); 
-                    UNIT_ASSERT_EQUAL(num1, num2); 
-                } 
-            } else if (var == 1) { 
-                TPercentileTrackerLg<4, 4, 15> tracker; 
-                for (size_t i = 0; i < 3000000; i += 1) { 
-                    size_t num1 = tracker.BucketIdxMostSignificantBit(i); 
-                    size_t num2 = tracker.BucketIdxBinarySearch(i); 
-                    UNIT_ASSERT_EQUAL(num1, num2); 
-                } 
-            } else if (var == 2) { 
-                TPercentileTrackerLg<5, 3, 15> tracker; 
-                for (size_t i = 0; i < 3000000; i += 1) { 
-                    size_t num1 = tracker.BucketIdxMostSignificantBit(i); 
-                    size_t num2 = tracker.BucketIdxBinarySearch(i); 
-                    size_t num3 = tracker.BucketIdxIf(i); 
-                    UNIT_ASSERT_EQUAL(num1, num2); 
-                    UNIT_ASSERT_EQUAL(num2, num3); 
-                } 
-            } else if (var == 3) { 
-                TPercentileTrackerLg<5, 4, 15> tracker; 
-                for (size_t i = 0; i < 3000000; i += 1) { 
-                    size_t num1 = tracker.BucketIdxMostSignificantBit(i); 
-                    size_t num2 = tracker.BucketIdxBinarySearch(i); 
-                    size_t num3 = tracker.BucketIdxIf(i); 
-                    UNIT_ASSERT_EQUAL(num1, num2); 
-                    UNIT_ASSERT_EQUAL(num2, num3); 
-                } 
-            } else if (var == 4) { 
-                TPercentileTrackerLg<6, 5, 15> tracker; 
-                for (size_t i = 0; i < 3000000; i += 1) { 
-                    size_t num1 = tracker.BucketIdxMostSignificantBit(i); 
-                    size_t num2 = tracker.BucketIdxBinarySearch(i); 
-                    UNIT_ASSERT_EQUAL(num1, num2); 
-                } 
-                for (size_t i = 0; i < 400000000000ul; i += 1303) { 
-                    size_t num1 = tracker.BucketIdxMostSignificantBit(i); 
-                    size_t num2 = tracker.BucketIdxBinarySearch(i); 
-                    UNIT_ASSERT_EQUAL(num1, num2); 
-                } 
-            } 
-        } 
-    } 
- 
-    Y_UNIT_TEST(DifferentPercentiles) { 
-        TPercentileTrackerLg<5, 4, 15> tracker; 
-        TVector<size_t> values({0, 115, 1216, 15, 3234567, 1234567, 216546, 263421, 751654, 96, 224, 223, 225}); 
-        TVector<size_t> percentiles50({0, 0, 116, 15, 116, 116, 1216, 1216, 217056, 1216, 1216, 224, 232}); 
-        TVector<size_t> percentiles75({0, 116, 116, 116, 1216, 1245152, 217056, 270304, 753632, 753632, 
-                270304, 270304, 270304}); 
-        TVector<size_t> percentiles90({ 0, 116, 1216, 1216, 2064352, 1245152, 1245152, 1245152, 1245152, 
-                1245152, 1245152, 1245152, 1245152}); 
-        TVector<size_t> percentiles100({ 0, 116, 1216, 1216, 2064352, 2064352, 2064352, 2064352, 2064352, 
-                2064352, 2064352, 2064352, 2064352 }); 
- 
-        for (size_t i = 0; i < values.size(); ++i) { 
-            tracker.Increment(values[i]); 
-            UNIT_ASSERT_EQUAL(tracker.GetPercentile(0.5), percentiles50[i]); 
-            UNIT_ASSERT_EQUAL(tracker.GetPercentile(0.75), percentiles75[i]); 
-            UNIT_ASSERT_EQUAL(tracker.GetPercentile(0.90), percentiles90[i]); 
-            UNIT_ASSERT_EQUAL(tracker.GetPercentile(1.0), percentiles100[i]); 
-        } 
-    } 
-} 
+    Y_UNIT_TEST(BucketIdxIfvsBucketIdxBinarySearch) {
+        for (size_t var = 0; var < 5; var++) {
+            if (var == 0) {
+                TPercentileTrackerLg<3, 2, 15> tracker;
+                for (size_t i = 0; i < 3000000; i += 1) {
+                    size_t num1 = tracker.BucketIdxMostSignificantBit(i);
+                    size_t num2 = tracker.BucketIdxBinarySearch(i);
+                    UNIT_ASSERT_EQUAL(num1, num2);
+                }
+            } else if (var == 1) {
+                TPercentileTrackerLg<4, 4, 15> tracker;
+                for (size_t i = 0; i < 3000000; i += 1) {
+                    size_t num1 = tracker.BucketIdxMostSignificantBit(i);
+                    size_t num2 = tracker.BucketIdxBinarySearch(i);
+                    UNIT_ASSERT_EQUAL(num1, num2);
+                }
+            } else if (var == 2) {
+                TPercentileTrackerLg<5, 3, 15> tracker;
+                for (size_t i = 0; i < 3000000; i += 1) {
+                    size_t num1 = tracker.BucketIdxMostSignificantBit(i);
+                    size_t num2 = tracker.BucketIdxBinarySearch(i);
+                    size_t num3 = tracker.BucketIdxIf(i);
+                    UNIT_ASSERT_EQUAL(num1, num2);
+                    UNIT_ASSERT_EQUAL(num2, num3);
+                }
+            } else if (var == 3) {
+                TPercentileTrackerLg<5, 4, 15> tracker;
+                for (size_t i = 0; i < 3000000; i += 1) {
+                    size_t num1 = tracker.BucketIdxMostSignificantBit(i);
+                    size_t num2 = tracker.BucketIdxBinarySearch(i);
+                    size_t num3 = tracker.BucketIdxIf(i);
+                    UNIT_ASSERT_EQUAL(num1, num2);
+                    UNIT_ASSERT_EQUAL(num2, num3);
+                }
+            } else if (var == 4) {
+                TPercentileTrackerLg<6, 5, 15> tracker;
+                for (size_t i = 0; i < 3000000; i += 1) {
+                    size_t num1 = tracker.BucketIdxMostSignificantBit(i);
+                    size_t num2 = tracker.BucketIdxBinarySearch(i);
+                    UNIT_ASSERT_EQUAL(num1, num2);
+                }
+                for (size_t i = 0; i < 400000000000ul; i += 1303) {
+                    size_t num1 = tracker.BucketIdxMostSignificantBit(i);
+                    size_t num2 = tracker.BucketIdxBinarySearch(i);
+                    UNIT_ASSERT_EQUAL(num1, num2);
+                }
+            }
+        }
+    }
+
+    Y_UNIT_TEST(DifferentPercentiles) {
+        TPercentileTrackerLg<5, 4, 15> tracker;
+        TVector<size_t> values({0, 115, 1216, 15, 3234567, 1234567, 216546, 263421, 751654, 96, 224, 223, 225});
+        TVector<size_t> percentiles50({0, 0, 116, 15, 116, 116, 1216, 1216, 217056, 1216, 1216, 224, 232});
+        TVector<size_t> percentiles75({0, 116, 116, 116, 1216, 1245152, 217056, 270304, 753632, 753632,
+                270304, 270304, 270304});
+        TVector<size_t> percentiles90({ 0, 116, 1216, 1216, 2064352, 1245152, 1245152, 1245152, 1245152,
+                1245152, 1245152, 1245152, 1245152});
+        TVector<size_t> percentiles100({ 0, 116, 1216, 1216, 2064352, 2064352, 2064352, 2064352, 2064352,
+                2064352, 2064352, 2064352, 2064352 });
+
+        for (size_t i = 0; i < values.size(); ++i) {
+            tracker.Increment(values[i]);
+            UNIT_ASSERT_EQUAL(tracker.GetPercentile(0.5), percentiles50[i]);
+            UNIT_ASSERT_EQUAL(tracker.GetPercentile(0.75), percentiles75[i]);
+            UNIT_ASSERT_EQUAL(tracker.GetPercentile(0.90), percentiles90[i]);
+            UNIT_ASSERT_EQUAL(tracker.GetPercentile(1.0), percentiles100[i]);
+        }
+    }
+}
diff --git a/library/cpp/monlib/dynamic_counters/percentile/ut/ya.make b/library/cpp/monlib/dynamic_counters/percentile/ut/ya.make
index 94faeee43d..f9f3564101 100644
--- a/library/cpp/monlib/dynamic_counters/percentile/ut/ya.make
+++ b/library/cpp/monlib/dynamic_counters/percentile/ut/ya.make
@@ -1,9 +1,9 @@
 UNITTEST_FOR(library/cpp/monlib/dynamic_counters/percentile)
- 
-    OWNER(alexvru g:kikimr g:solomon) 
- 
-    SRCS( 
-        percentile_ut.cpp 
-    ) 
- 
-END() 
+
+    OWNER(alexvru g:kikimr g:solomon)
+
+    SRCS(
+        percentile_ut.cpp
+    )
+
+END()
diff --git a/library/cpp/monlib/dynamic_counters/percentile/ya.make b/library/cpp/monlib/dynamic_counters/percentile/ya.make
index b255fc21fc..cb52cdd9ad 100644
--- a/library/cpp/monlib/dynamic_counters/percentile/ya.make
+++ b/library/cpp/monlib/dynamic_counters/percentile/ya.make
@@ -1,15 +1,15 @@
-LIBRARY() 
- 
-    OWNER(alexvru g:kikimr g:solomon) 
- 
-    SRCS( 
-        percentile.h 
-        percentile_lg.h 
-    ) 
- 
-    PEERDIR( 
+LIBRARY()
+
+    OWNER(alexvru g:kikimr g:solomon)
+
+    SRCS(
+        percentile.h
+        percentile_lg.h
+    )
+
+    PEERDIR(
         library/cpp/containers/stack_vector
         library/cpp/monlib/dynamic_counters
-    ) 
- 
-END() 
+    )
+
+END()