Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

9 files changed, 314 insertions, 314 deletions

diff --git a/library/cpp/testing/benchmark/bench.cpp b/library/cpp/testing/benchmark/bench.cpp
index 08d8708005a..dc7f8b7856f 100644
--- a/library/cpp/testing/benchmark/bench.cpp
+++ b/library/cpp/testing/benchmark/bench.cpp
@@ -1,7 +1,7 @@
 #include "bench.h"
 
-#include <contrib/libs/re2/re2/re2.h>
-
+#include <contrib/libs/re2/re2/re2.h> 
+ 
 #include <library/cpp/colorizer/output.h>
 #include <library/cpp/getopt/small/last_getopt.h>
 #include <library/cpp/json/json_value.h>
@@ -9,7 +9,7 @@
 #include <library/cpp/threading/poor_man_openmp/thread_helper.h>
 
 #include <util/system/hp_timer.h>
-#include <util/system/info.h>
+#include <util/system/info.h> 
 #include <util/stream/output.h>
 #include <util/datetime/base.h>
 #include <util/random/random.h>
@@ -26,7 +26,7 @@
 #include <util/system/yield.h>
 
 using re2::RE2;
-
+ 
 using namespace NBench;
 using namespace NColorizer;
 using namespace NLastGetopt;
@@ -47,7 +47,7 @@ namespace {
     };
 
     struct ITestRunner: public TIntrusiveListItem<ITestRunner> {
-        virtual ~ITestRunner() = default;
+        virtual ~ITestRunner() = default; 
         void Register();
 
         virtual TStringBuf Name() const noexcept = 0;
@@ -278,115 +278,115 @@ namespace {
             F(params);
         }, opts.TimeBudget, *this);
     }
-
-    enum EOutFormat {
-        F_CONSOLE = 0 /* "console" */,
+ 
+    enum EOutFormat { 
+        F_CONSOLE = 0 /* "console" */, 
         F_CSV /* "csv" */,
         F_JSON /* "json" */
-    };
-
+    }; 
+ 
     TAdaptiveLock STDOUT_LOCK;
-
+ 
     struct IReporter {
-        virtual void Report(TResult&& result) = 0;
-
-        virtual void Finish() {
-        }
-
-        virtual ~IReporter() {
-        }
-    };
-
+        virtual void Report(TResult&& result) = 0; 
+ 
+        virtual void Finish() { 
+        } 
+ 
+        virtual ~IReporter() { 
+        } 
+    }; 
+ 
     class TConsoleReporter: public IReporter {
-    public:
+    public: 
         ~TConsoleReporter() override {
-        }
-
-        void Report(TResult&& r) override {
-            with_lock (STDOUT_LOCK) {
-                Cout << r;
-            }
-        }
-    };
-
+        } 
+ 
+        void Report(TResult&& r) override { 
+            with_lock (STDOUT_LOCK) { 
+                Cout << r; 
+            } 
+        } 
+    }; 
+ 
     class TCSVReporter: public IReporter {
-    public:
-        TCSVReporter() {
+    public: 
+        TCSVReporter() { 
             Cout << "Name\tSamples\tIterations\tRun_time\tPer_iteration_sec\tPer_iteration_cycles" << Endl;
-        }
-
+        } 
+ 
         ~TCSVReporter() override {
-        }
-
-        void Report(TResult&& r) override {
-            with_lock (STDOUT_LOCK) {
-                Cout << r.TestName
-                     << '\t' << r.Samples
-                     << '\t' << r.Iterations
-                     << '\t' << r.RunTime;
-
-                Cout << '\t';
-                if (r.CyclesPerIteration) {
-                    Cout << TCycleTimer::FmtTime(*r.CyclesPerIteration);
-                } else {
-                    Cout << '-';
-                }
-
-                Cout << '\t';
-                if (r.SecondsPerIteration) {
-                    Cout << DoFmtTime(*r.SecondsPerIteration);
-                } else {
-                    Cout << '-';
-                }
-
-                Cout << Endl;
-            }
-        }
-    };
-
+        } 
+ 
+        void Report(TResult&& r) override { 
+            with_lock (STDOUT_LOCK) { 
+                Cout << r.TestName 
+                     << '\t' << r.Samples 
+                     << '\t' << r.Iterations 
+                     << '\t' << r.RunTime; 
+ 
+                Cout << '\t'; 
+                if (r.CyclesPerIteration) { 
+                    Cout << TCycleTimer::FmtTime(*r.CyclesPerIteration); 
+                } else { 
+                    Cout << '-'; 
+                } 
+ 
+                Cout << '\t'; 
+                if (r.SecondsPerIteration) { 
+                    Cout << DoFmtTime(*r.SecondsPerIteration); 
+                } else { 
+                    Cout << '-'; 
+                } 
+ 
+                Cout << Endl; 
+            } 
+        } 
+    }; 
+ 
     class TJSONReporter: public IReporter {
-    public:
+    public: 
         ~TJSONReporter() override {
-        }
-
-        void Report(TResult&& r) override {
-            with_lock (ResultsLock_) {
-                Results_.emplace_back(std::move(r));
-            }
-        }
-
-        void Finish() override {
-            NJson::TJsonValue report;
-            auto& bench = report["benchmark"];
-            bench.SetType(NJson::JSON_ARRAY);
-
-            NJson::TJsonValue benchReport;
-
-            for (const auto& result : Results_) {
-                NJson::TJsonValue{}.Swap(benchReport);
-                benchReport["name"] = result.TestName;
-                benchReport["samples"] = result.Samples;
-                benchReport["run_time"] = result.RunTime;
-
-                if (result.CyclesPerIteration) {
-                    benchReport["per_iteration_cycles"] = *result.CyclesPerIteration;
-                }
-
-                if (result.SecondsPerIteration) {
-                    benchReport["per_iteration_secons"] = *result.SecondsPerIteration;
-                }
-
-                bench.AppendValue(benchReport);
-            }
-
-            Cout << report << Endl;
-        }
-
-    private:
-        TAdaptiveLock ResultsLock_;
+        } 
+ 
+        void Report(TResult&& r) override { 
+            with_lock (ResultsLock_) { 
+                Results_.emplace_back(std::move(r)); 
+            } 
+        } 
+ 
+        void Finish() override { 
+            NJson::TJsonValue report; 
+            auto& bench = report["benchmark"]; 
+            bench.SetType(NJson::JSON_ARRAY); 
+ 
+            NJson::TJsonValue benchReport; 
+ 
+            for (const auto& result : Results_) { 
+                NJson::TJsonValue{}.Swap(benchReport); 
+                benchReport["name"] = result.TestName; 
+                benchReport["samples"] = result.Samples; 
+                benchReport["run_time"] = result.RunTime; 
+ 
+                if (result.CyclesPerIteration) { 
+                    benchReport["per_iteration_cycles"] = *result.CyclesPerIteration; 
+                } 
+ 
+                if (result.SecondsPerIteration) { 
+                    benchReport["per_iteration_secons"] = *result.SecondsPerIteration; 
+                } 
+ 
+                bench.AppendValue(benchReport); 
+            } 
+ 
+            Cout << report << Endl; 
+        } 
+ 
+    private: 
+        TAdaptiveLock ResultsLock_; 
         TVector<TResult> Results_;
-    };
-
+    }; 
+ 
     class TOrderedReporter: public IReporter {
     public:
         TOrderedReporter(THolder<IReporter> slave)
@@ -421,22 +421,22 @@ namespace {
     };
 
     THolder<IReporter> MakeReporter(const EOutFormat type) {
-        switch (type) {
-            case F_CONSOLE:
-                return MakeHolder<TConsoleReporter>();
-
-            case F_CSV:
-                return MakeHolder<TCSVReporter>();
+        switch (type) { 
+            case F_CONSOLE: 
+                return MakeHolder<TConsoleReporter>(); 
+ 
+            case F_CSV: 
+                return MakeHolder<TCSVReporter>(); 
 
-            case F_JSON:
-                return MakeHolder<TJSONReporter>();
+            case F_JSON: 
+                return MakeHolder<TJSONReporter>(); 
 
             default:
                 break;
-        }
+        } 
 
         return MakeHolder<TConsoleReporter>(); // make compiler happy
-    }
+    } 
 
     THolder<IReporter> MakeOrderedReporter(const EOutFormat type) {
         return MakeHolder<TOrderedReporter>(MakeReporter(type));
@@ -448,24 +448,24 @@ namespace {
         }
     }
 }
-
-template <>
-EOutFormat FromStringImpl<EOutFormat>(const char* data, size_t len) {
-    const auto s = TStringBuf{data, len};
+ 
+template <> 
+EOutFormat FromStringImpl<EOutFormat>(const char* data, size_t len) { 
+    const auto s = TStringBuf{data, len}; 
 
     if (TStringBuf("console") == s) {
-        return F_CONSOLE;
+        return F_CONSOLE; 
     } else if (TStringBuf("csv") == s) {
-        return F_CSV;
+        return F_CSV; 
     } else if (TStringBuf("json") == s) {
-        return F_JSON;
-    }
-
-    ythrow TFromStringException{} << "failed to convert '" << s << '\'';
+        return F_JSON; 
+    } 
+ 
+    ythrow TFromStringException{} << "failed to convert '" << s << '\''; 
 }
 
 template <>
-void Out<TResult>(IOutputStream& out, const TResult& r) {
+void Out<TResult>(IOutputStream& out, const TResult& r) { 
     out << "----------- " << LightRed() << r.TestName << Old() << " ---------------" << Endl
         << " samples:       " << White() << r.Samples << Old() << Endl
         << " iterations:    " << White() << r.Iterations << Old() << Endl
@@ -482,9 +482,9 @@ void Out<TResult>(IOutputStream& out, const TResult& r) {
 }
 
 NCpu::TRegistar::TRegistar(const char* name, TUserFunc func) {
-    static_assert(sizeof(TCpuBenchmark) + alignof(TCpuBenchmark) < sizeof(Buf), "fix Buf size");
+    static_assert(sizeof(TCpuBenchmark) + alignof(TCpuBenchmark) < sizeof(Buf), "fix Buf size"); 
 
-    new (AlignUp(Buf, alignof(TCpuBenchmark))) TCpuBenchmark(name, func);
+    new (AlignUp(Buf, alignof(TCpuBenchmark))) TCpuBenchmark(name, func); 
 }
 
 namespace {
@@ -496,36 +496,36 @@ namespace {
 
             opts.AddLongOption('b', "budget")
                 .StoreResult(&TimeBudget)
-                .RequiredArgument("SEC")
+                .RequiredArgument("SEC") 
                 .Optional()
                 .Help("overall time budget");
 
             opts.AddLongOption('l', "list")
-                .NoArgument()
-                .StoreValue(&ListTests, true)
+                .NoArgument() 
+                .StoreValue(&ListTests, true) 
                 .Help("list all tests");
 
             opts.AddLongOption('t', "threads")
                 .StoreResult(&Threads)
-                .OptionalValue(ToString((NSystemInfo::CachedNumberOfCpus() + 1) / 2), "JOBS")
-                .DefaultValue("1")
+                .OptionalValue(ToString((NSystemInfo::CachedNumberOfCpus() + 1) / 2), "JOBS") 
+                .DefaultValue("1") 
                 .Help("run benchmarks in parallel");
 
-            opts.AddLongOption('f', "format")
+            opts.AddLongOption('f', "format") 
                 .AddLongName("benchmark_format")
-                .StoreResult(&OutFormat)
-                .RequiredArgument("FORMAT")
-                .DefaultValue("console")
-                .Help("output format (console|csv|json)");
-
-            opts.SetFreeArgDefaultTitle("REGEXP", "RE2 regular expression to filter tests");
-
-            const TOptsParseResult parseResult{&opts, argc, argv};
-
-            for (const auto& regexp : parseResult.GetFreeArgs()) {
+                .StoreResult(&OutFormat) 
+                .RequiredArgument("FORMAT") 
+                .DefaultValue("console") 
+                .Help("output format (console|csv|json)"); 
+ 
+            opts.SetFreeArgDefaultTitle("REGEXP", "RE2 regular expression to filter tests"); 
+ 
+            const TOptsParseResult parseResult{&opts, argc, argv}; 
+
+            for (const auto& regexp : parseResult.GetFreeArgs()) { 
                 Filters.push_back(MakeHolder<RE2>(regexp.data(), RE2::Quiet));
-                Y_ENSURE(Filters.back()->ok(), "incorrect RE2 expression '" << regexp << "'");
-            }
+                Y_ENSURE(Filters.back()->ok(), "incorrect RE2 expression '" << regexp << "'"); 
+            } 
         }
 
         bool MatchFilters(const TStringBuf& name) const {
@@ -533,72 +533,72 @@ namespace {
                 return true;
             }
 
-            for (auto&& re : Filters) {
+            for (auto&& re : Filters) { 
                 if (RE2::FullMatchN({name.data(), name.size()}, *re, nullptr, 0)) {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
+                    return true; 
+                } 
+            } 
+ 
+            return false; 
+        } 
+ 
         bool ListTests = false;
         double TimeBudget = -1.0;
         TVector<THolder<RE2>> Filters;
         size_t Threads = 0;
-        EOutFormat OutFormat;
+        EOutFormat OutFormat; 
     };
 }
 
-int NBench::Main(int argc, char** argv) {
-    const TProgOpts opts(argc, argv);
+int NBench::Main(int argc, char** argv) { 
+    const TProgOpts opts(argc, argv); 
 
     TVector<ITestRunner*> tests;
-
-    for (auto&& it : Tests()) {
-        if (opts.MatchFilters(it.Name())) {
-            tests.push_back(&it);
+ 
+    for (auto&& it : Tests()) { 
+        if (opts.MatchFilters(it.Name())) { 
+            tests.push_back(&it); 
         }
-    }
+    } 
     EnumerateTests(tests);
 
-    if (opts.ListTests) {
-        for (const auto* const it : tests) {
-            Cout << it->Name() << Endl;
+    if (opts.ListTests) { 
+        for (const auto* const it : tests) { 
+            Cout << it->Name() << Endl; 
         }
 
-        return 0;
-    }
+        return 0; 
+    } 
 
-    if (!tests) {
-        return 0;
-    }
+    if (!tests) { 
+        return 0; 
+    } 
 
-    double timeBudget = opts.TimeBudget;
+    double timeBudget = opts.TimeBudget; 
 
-    if (timeBudget < 0) {
+    if (timeBudget < 0) { 
         timeBudget = 5.0 * tests.size();
-    }
+    } 
 
     const TOptions testOpts = {timeBudget / tests.size()};
     const auto reporter = MakeOrderedReporter(opts.OutFormat);
 
     std::function<void(ITestRunner**)> func = [&](ITestRunner** it) {
-        auto&& res = (*it)->Run(testOpts);
+        auto&& res = (*it)->Run(testOpts); 
 
-        reporter->Report(std::move(res));
-    };
-
-    if (opts.Threads > 1) {
-        NYmp::SetThreadCount(opts.Threads);
+        reporter->Report(std::move(res)); 
+    }; 
+ 
+    if (opts.Threads > 1) { 
+        NYmp::SetThreadCount(opts.Threads); 
         NYmp::ParallelForStaticChunk(tests.data(), tests.data() + tests.size(), 1, func);
-    } else {
-        for (auto it : tests) {
-            func(&it);
-        }
+    } else { 
+        for (auto it : tests) { 
+            func(&it); 
+        } 
     }
-
-    reporter->Finish();
-
-    return 0;
+ 
+    reporter->Finish(); 
+ 
+    return 0; 
 }
diff --git a/library/cpp/testing/benchmark/bench.h b/library/cpp/testing/benchmark/bench.h
index 21551ad0dd4..5773fc1534f 100644
--- a/library/cpp/testing/benchmark/bench.h
+++ b/library/cpp/testing/benchmark/bench.h
@@ -26,62 +26,62 @@ namespace NBench {
 
     /**
      * Functions that states "I can read and write everywhere in memory".
-     *
-     * Use it to prevent optimizer from reordering or discarding memory writes prior to it's call,
-     * and force memory reads after it's call.
-     */
-    void Clobber();
-
+     * 
+     * Use it to prevent optimizer from reordering or discarding memory writes prior to it's call, 
+     * and force memory reads after it's call. 
+     */ 
+    void Clobber(); 
+ 
     /**
      * Forces whatever `p` points to be in memory and not in register.
-     *
-     * @param       Pointer to data.
-     */
-    template <typename T>
-    void Escape(T* p);
-
-#if defined(__GNUC__)
-    Y_FORCE_INLINE void Clobber() {
+     * 
+     * @param       Pointer to data. 
+     */ 
+    template <typename T> 
+    void Escape(T* p); 
+ 
+#if defined(__GNUC__) 
+    Y_FORCE_INLINE void Clobber() { 
         asm volatile(""
                      :
                      :
                      : "memory");
-    }
+    } 
 #elif defined(_MSC_VER)
     Y_FORCE_INLINE void Clobber() {
         _ReadWriteBarrier();
     }
 
-#else
-    Y_FORCE_INLINE void Clobber() {
-    }
-#endif
-
-#if defined(__GNUC__)
-    template <typename T>
-    Y_FORCE_INLINE void Escape(T* p) {
+#else 
+    Y_FORCE_INLINE void Clobber() { 
+    } 
+#endif 
+ 
+#if defined(__GNUC__) 
+    template <typename T> 
+    Y_FORCE_INLINE void Escape(T* p) { 
         asm volatile(""
                      :
                      : "g"(p)
                      : "memory");
-    }
-#else
-    template <typename T>
-    Y_FORCE_INLINE void Escape(T*) {
-    }
-#endif
-
+    } 
+#else 
+    template <typename T> 
+    Y_FORCE_INLINE void Escape(T*) { 
+    } 
+#endif 
+ 
     /**
      * Use this function to prevent unused variables elimination.
      *
      * @param       Unused variable (e.g. return value of benchmarked function).
      */
-    template <typename T>
+    template <typename T> 
     Y_FORCE_INLINE void DoNotOptimize(T&& datum) {
         ::DoNotOptimizeAway(std::forward<T>(datum));
     }
-
-    int Main(int argc, char** argv);
+ 
+    int Main(int argc, char** argv); 
 }
 
 #define Y_CPU_BENCHMARK(name, cnt)                              \
diff --git a/library/cpp/testing/benchmark/examples/main.cpp b/library/cpp/testing/benchmark/examples/main.cpp
index ddd8b05ffc7..745e636d4c8 100644
--- a/library/cpp/testing/benchmark/examples/main.cpp
+++ b/library/cpp/testing/benchmark/examples/main.cpp
@@ -120,9 +120,9 @@ Y_CPU_BENCHMARK(FunctionCallCost_StringBufVal1, iface) {
 
     for (auto i : xrange<size_t>(0, iface.Iterations())) {
         (void)i;
-        NBench::Escape(&x);
+        NBench::Escape(&x); 
         Y_DO_NOT_OPTIMIZE_AWAY(FS1(x));
-        NBench::Clobber();
+        NBench::Clobber(); 
     }
 }
 
@@ -131,9 +131,9 @@ Y_CPU_BENCHMARK(FunctionCallCost_StringBufRef1, iface) {
 
     for (auto i : xrange<size_t>(0, iface.Iterations())) {
         (void)i;
-        NBench::Escape(&x);
+        NBench::Escape(&x); 
         Y_DO_NOT_OPTIMIZE_AWAY(FS2(x));
-        NBench::Clobber();
+        NBench::Clobber(); 
     }
 }
 
@@ -143,10 +143,10 @@ Y_CPU_BENCHMARK(FunctionCallCost_StringBufVal2, iface) {
 
     for (auto i : xrange<size_t>(0, iface.Iterations())) {
         (void)i;
-        NBench::Escape(&x);
-        NBench::Escape(&y);
+        NBench::Escape(&x); 
+        NBench::Escape(&y); 
         Y_DO_NOT_OPTIMIZE_AWAY(FS1_2(x, y));
-        NBench::Clobber();
+        NBench::Clobber(); 
     }
 }
 
@@ -156,10 +156,10 @@ Y_CPU_BENCHMARK(FunctionCallCost_StringBufRef2, iface) {
 
     for (auto i : xrange<size_t>(0, iface.Iterations())) {
         (void)i;
-        NBench::Escape(&x);
-        NBench::Escape(&y);
+        NBench::Escape(&x); 
+        NBench::Escape(&y); 
         Y_DO_NOT_OPTIMIZE_AWAY(FS2_2(x, y));
-        NBench::Clobber();
+        NBench::Clobber(); 
     }
 }
 
@@ -181,35 +181,35 @@ Y_CPU_BENCHMARK(FunctionCallCost_TwoArg, iface) {
         Y_DO_NOT_OPTIMIZE_AWAY(FFF(i, i));
     }
 }
-
-/* An example of incorrect benchmark. As of r2581591 Clang 3.7 produced following assembly:
- * @code
- *        │      push   %rbp
- *        │      mov    %rsp,%rbp
- *        │      push   %rbx
- *        │      push   %rax
- *        │      mov    (%rdi),%rbx
- *        │      test   %rbx,%rbx
- *        │    ↓ je     25
- *        │      xor    %edi,%edi
- *        │      xor    %esi,%esi
+ 
+/* An example of incorrect benchmark. As of r2581591 Clang 3.7 produced following assembly: 
+ * @code 
+ *        │      push   %rbp 
+ *        │      mov    %rsp,%rbp 
+ *        │      push   %rbx 
+ *        │      push   %rax 
+ *        │      mov    (%rdi),%rbx 
+ *        │      test   %rbx,%rbx 
+ *        │    ↓ je     25 
+ *        │      xor    %edi,%edi 
+ *        │      xor    %esi,%esi 
  *        │    → callq  FS1(TBasicStringBuf<char, std::char_traits<char
- *        │      nop
- * 100.00 │20:┌─→dec    %rbx
- *        │   └──jne    20
- *        │25:   add    $0x8,%rsp
- *        │      pop    %rbx
- *        │      pop    %rbp
- *        │    ← retq
- * @endcode
- *
- * So, this benchmark is measuring empty loop!
- */
-Y_CPU_BENCHMARK(Incorrect_FunctionCallCost_StringBufVal1, iface) {
-    TStringBuf x;
-
-    for (auto i : xrange<size_t>(0, iface.Iterations())) {
-        (void)i;
-        Y_DO_NOT_OPTIMIZE_AWAY(FS1(x));
-    }
-}
+ *        │      nop 
+ * 100.00 │20:┌─→dec    %rbx 
+ *        │   └──jne    20 
+ *        │25:   add    $0x8,%rsp 
+ *        │      pop    %rbx 
+ *        │      pop    %rbp 
+ *        │    ← retq 
+ * @endcode 
+ * 
+ * So, this benchmark is measuring empty loop! 
+ */ 
+Y_CPU_BENCHMARK(Incorrect_FunctionCallCost_StringBufVal1, iface) { 
+    TStringBuf x; 
+ 
+    for (auto i : xrange<size_t>(0, iface.Iterations())) { 
+        (void)i; 
+        Y_DO_NOT_OPTIMIZE_AWAY(FS1(x)); 
+    } 
+} 
diff --git a/library/cpp/testing/benchmark/examples/metrics/main.py b/library/cpp/testing/benchmark/examples/metrics/main.py
index 8f9d9d06aeb..d8264504007 100644
--- a/library/cpp/testing/benchmark/examples/metrics/main.py
+++ b/library/cpp/testing/benchmark/examples/metrics/main.py
@@ -1,7 +1,7 @@
-import yatest.common as yc
-
-
-def test_export_metrics(metrics):
-    metrics.set_benchmark(yc.execute_benchmark(
+import yatest.common as yc 
+ 
+ 
+def test_export_metrics(metrics): 
+    metrics.set_benchmark(yc.execute_benchmark( 
         'library/cpp/testing/benchmark/examples/examples',
-        threads=8))
+        threads=8)) 
diff --git a/library/cpp/testing/benchmark/examples/metrics/ya.make b/library/cpp/testing/benchmark/examples/metrics/ya.make
index a9dbdca9fad..a2c773a2d04 100644
--- a/library/cpp/testing/benchmark/examples/metrics/ya.make
+++ b/library/cpp/testing/benchmark/examples/metrics/ya.make
@@ -1,20 +1,20 @@
-OWNER(
-    pg
-    yazevnul
-)
-
+OWNER( 
+    pg 
+    yazevnul 
+) 
+ 
 PY2TEST()
-
+ 
 SIZE(LARGE)
-
-TAG(
+ 
+TAG( 
     ya:force_sandbox
-    sb:intel_e5_2660v1
+    sb:intel_e5_2660v1 
     ya:fat
-)
-
+) 
+ 
 TEST_SRCS(main.py)
-
+ 
 DEPENDS(library/cpp/testing/benchmark/examples)
-
-END()
+ 
+END() 
diff --git a/library/cpp/testing/benchmark/examples/ya.make b/library/cpp/testing/benchmark/examples/ya.make
index 7e696e127ab..d0d5bdca2c4 100644
--- a/library/cpp/testing/benchmark/examples/ya.make
+++ b/library/cpp/testing/benchmark/examples/ya.make
@@ -1,8 +1,8 @@
-OWNER(
-    pg
-    yazevnul
-)
-
+OWNER( 
+    pg 
+    yazevnul 
+) 
+ 
 Y_BENCHMARK()
 
 SRCS(
diff --git a/library/cpp/testing/benchmark/main/main.cpp b/library/cpp/testing/benchmark/main/main.cpp
index aabcb89c435..b464c790233 100644
--- a/library/cpp/testing/benchmark/main/main.cpp
+++ b/library/cpp/testing/benchmark/main/main.cpp
@@ -1,16 +1,16 @@
 #include <library/cpp/testing/benchmark/bench.h>
-
-#include <util/generic/yexception.h>
-#include <util/stream/output.h>
-
-#include <cstdlib>
-
-int main(int argc, char** argv) {
-    try {
-        return NBench::Main(argc, argv);
+ 
+#include <util/generic/yexception.h> 
+#include <util/stream/output.h> 
+ 
+#include <cstdlib> 
+ 
+int main(int argc, char** argv) { 
+    try { 
+        return NBench::Main(argc, argv); 
     } catch (...) {
-        Cerr << CurrentExceptionMessage() << Endl;
-    }
+        Cerr << CurrentExceptionMessage() << Endl; 
+    } 
 
     return EXIT_FAILURE;
-}
+} 
diff --git a/library/cpp/testing/benchmark/main/ya.make b/library/cpp/testing/benchmark/main/ya.make
index d00cdcf9fca..a434d426750 100644
--- a/library/cpp/testing/benchmark/main/ya.make
+++ b/library/cpp/testing/benchmark/main/ya.make
@@ -1,16 +1,16 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 OWNER(
     pg
     yazevnul
 )
-
-SRCS(
+ 
+SRCS( 
     GLOBAL main.cpp
-)
-
-PEERDIR(
+) 
+ 
+PEERDIR( 
     library/cpp/testing/benchmark
-)
-
-END()
+) 
+ 
+END() 
diff --git a/library/cpp/testing/benchmark/ya.make b/library/cpp/testing/benchmark/ya.make
index f42be80698e..661e1602383 100644
--- a/library/cpp/testing/benchmark/ya.make
+++ b/library/cpp/testing/benchmark/ya.make
@@ -4,19 +4,19 @@ OWNER(
     pg
     yazevnul
 )
-
-SRCS(
+ 
+SRCS( 
     bench.cpp
     dummy.cpp
-)
-
-PEERDIR(
-    contrib/libs/re2
+) 
+ 
+PEERDIR( 
+    contrib/libs/re2 
     library/cpp/colorizer
     library/cpp/getopt/small
     library/cpp/json
     library/cpp/linear_regression
     library/cpp/threading/poor_man_openmp
-)
-
-END()
+) 
+ 
+END()