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

4 files changed, 271 insertions, 271 deletions

diff --git a/util/string/benchmark/float_to_string/main.cpp b/util/string/benchmark/float_to_string/main.cpp
index c15b6009ad..1c7c0684a3 100644
--- a/util/string/benchmark/float_to_string/main.cpp
+++ b/util/string/benchmark/float_to_string/main.cpp
@@ -1,253 +1,253 @@
 #include <library/cpp/testing/benchmark/bench.h>
- 
-#include <util/generic/singleton.h> 
-#include <util/generic/vector.h> 
-#include <util/generic/xrange.h> 
-#include <util/generic/ymath.h> 
-#include <util/random/fast.h> 
-#include <util/string/cast.h> 
-#include <util/string/printf.h> 
- 
-#include <limits> 
- 
-#include <cmath> 
- 
-/* Please be careful before making any decisions based on this benchmark. 
- * 
- * Only `Sprintf("%.<decimals>f", x)` and `FloatToString(x, PREC_POINT_DIGITS, decimals` produce 
- * equal results in general case. However, results for cases when x \in [0, 1) must be equal for 
- * both `Sprintf` and `FloatToString`. 
- * 
- * Read more about formatting in STL [1, 2] and Yandex Util formatting [3] 
- * 
- * [1] http://www.cplusplus.com/reference/cstdio/printf/ 
- * [2] http://en.cppreference.com/w/c/io/fprintf 
- * [3] https://a.yandex-team.ru/arc/trunk/arcadia/util/string/cast.h?rev=2432660#L29 
- */ 
- 
-namespace { 
-    template <typename T> 
-    struct TExample { 
-        T Value{}; 
-        int DigitsCount{}; 
-    }; 
- 
-    template <typename T, size_t N> 
-    struct TExamplesHolder { 
+
+#include <util/generic/singleton.h>
+#include <util/generic/vector.h>
+#include <util/generic/xrange.h>
+#include <util/generic/ymath.h>
+#include <util/random/fast.h>
+#include <util/string/cast.h>
+#include <util/string/printf.h>
+
+#include <limits>
+
+#include <cmath>
+
+/* Please be careful before making any decisions based on this benchmark.
+ *
+ * Only `Sprintf("%.<decimals>f", x)` and `FloatToString(x, PREC_POINT_DIGITS, decimals` produce
+ * equal results in general case. However, results for cases when x \in [0, 1) must be equal for
+ * both `Sprintf` and `FloatToString`.
+ *
+ * Read more about formatting in STL [1, 2] and Yandex Util formatting [3]
+ *
+ * [1] http://www.cplusplus.com/reference/cstdio/printf/
+ * [2] http://en.cppreference.com/w/c/io/fprintf
+ * [3] https://a.yandex-team.ru/arc/trunk/arcadia/util/string/cast.h?rev=2432660#L29
+ */
+
+namespace {
+    template <typename T>
+    struct TExample {
+        T Value{};
+        int DigitsCount{};
+    };
+
+    template <typename T, size_t N>
+    struct TExamplesHolder {
         TVector<TExample<T>> Examples;
- 
-        TExamplesHolder() 
+
+        TExamplesHolder()
             : Examples(N)
         {
-            TFastRng<ui64> prng{N * sizeof(T) * 42}; 
-            for (auto& x : Examples) { 
-                x.Value = prng.GenRandReal4() + prng.Uniform(Max<ui16>()); 
-                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1); 
-            } 
-        } 
-    }; 
- 
-    template <typename T, size_t N> 
-    struct TNearZeroExamplesHolder { 
+            TFastRng<ui64> prng{N * sizeof(T) * 42};
+            for (auto& x : Examples) {
+                x.Value = prng.GenRandReal4() + prng.Uniform(Max<ui16>());
+                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1);
+            }
+        }
+    };
+
+    template <typename T, size_t N>
+    struct TNearZeroExamplesHolder {
         TVector<TExample<T>> Examples;
- 
-        TNearZeroExamplesHolder() 
+
+        TNearZeroExamplesHolder()
             : Examples(N)
         {
-            TFastRng<ui64> prng{N * sizeof(T) * 42}; 
-            for (auto& x : Examples) { 
-                x.Value = prng.GenRandReal4(); 
-                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1); 
-            } 
-        } 
-    }; 
-} 
- 
-static const char* FORMAT_FIXED[] = { 
-    "%.0f", 
-    "%.1f", 
-    "%.2f", 
-    "%.3f", 
-    "%.4f", 
-    "%.5f", 
-    "%.6f", 
-    "%.7f", 
-    "%.8f", 
-    "%.9f", 
-    "%.10f", 
-    "%.11f", 
-    "%.12f", 
-    "%.13f", 
-    "%.14f", 
-    "%.15f", 
-    "%.16f", 
-    "%.17f", 
-}; 
- 
-static const char* FORMAT_SIGNIFICANT[] = { 
-    "%.0g", 
-    "%.1g", 
-    "%.2g", 
-    "%.3g", 
-    "%.4g", 
-    "%.5g", 
-    "%.6g", 
-    "%.7g", 
-    "%.8g", 
-    "%.9g", 
-    "%.10g", 
-    "%.11g", 
-    "%.12g", 
-    "%.13g", 
-    "%.14g", 
-    "%.15g", 
-    "%.16g", 
-    "%.17g", 
-}; 
- 
-#define DEFINE_BENCHMARK(type, count)                                                                \ 
-    Y_CPU_BENCHMARK(SprintfAuto_##type##_##count, iface) {                                           \ 
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \ 
-                /* than FloatToString(e.Value) */                                                    \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(FloatToStringAuto_##type##_##count, iface) {                                     \ 
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(SprintfFixed_##type##_##count, iface) {                                          \ 
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(FloatToStringFixed_##type##_##count, iface) {                                    \ 
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(SprintfSignificant_##type##_##count, iface) {                                    \ 
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(FloatToStringSignificant_##type##_##count, iface) {                              \ 
-        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(NearZeroSprintfAuto_##type##_##count, iface) {                                   \ 
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \ 
-                /* than FloatToString(e.Value) */                                                    \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(NearZeroFloatToStringAuto_##type##_##count, iface) {                             \ 
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(NearZeroSprintfFixed_##type##_##count, iface) {                                  \ 
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(NearZeroFloatToStringFixed_##type##_##count, iface) {                            \ 
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(NearZeroSprintfSignificant_##type##_##count, iface) {                            \ 
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    }                                                                                                \ 
-                                                                                                     \ 
-    Y_CPU_BENCHMARK(NearZeroFloatToStringSignificant_##type##_##count, iface) {                      \ 
-        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \ 
-        for (const auto i : xrange(iface.Iterations())) {                                            \ 
-            Y_UNUSED(i);                                                                             \ 
-            for (const auto e : examples) {                                                          \ 
-                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \ 
-            }                                                                                        \ 
-        }                                                                                            \ 
-    } 
- 
-DEFINE_BENCHMARK(float, 1); 
-DEFINE_BENCHMARK(float, 2); 
-DEFINE_BENCHMARK(float, 4); 
-DEFINE_BENCHMARK(float, 8); 
-DEFINE_BENCHMARK(float, 16); 
-DEFINE_BENCHMARK(float, 32); 
-DEFINE_BENCHMARK(float, 64); 
-DEFINE_BENCHMARK(float, 128); 
-DEFINE_BENCHMARK(float, 256); 
- 
-DEFINE_BENCHMARK(double, 1); 
-DEFINE_BENCHMARK(double, 2); 
-DEFINE_BENCHMARK(double, 4); 
-DEFINE_BENCHMARK(double, 8); 
-DEFINE_BENCHMARK(double, 16); 
-DEFINE_BENCHMARK(double, 32); 
-DEFINE_BENCHMARK(double, 64); 
-DEFINE_BENCHMARK(double, 128); 
-DEFINE_BENCHMARK(double, 256); 
- 
-#undef DEFINE_BENCHMARK 
+            TFastRng<ui64> prng{N * sizeof(T) * 42};
+            for (auto& x : Examples) {
+                x.Value = prng.GenRandReal4();
+                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1);
+            }
+        }
+    };
+}
+
+static const char* FORMAT_FIXED[] = {
+    "%.0f",
+    "%.1f",
+    "%.2f",
+    "%.3f",
+    "%.4f",
+    "%.5f",
+    "%.6f",
+    "%.7f",
+    "%.8f",
+    "%.9f",
+    "%.10f",
+    "%.11f",
+    "%.12f",
+    "%.13f",
+    "%.14f",
+    "%.15f",
+    "%.16f",
+    "%.17f",
+};
+
+static const char* FORMAT_SIGNIFICANT[] = {
+    "%.0g",
+    "%.1g",
+    "%.2g",
+    "%.3g",
+    "%.4g",
+    "%.5g",
+    "%.6g",
+    "%.7g",
+    "%.8g",
+    "%.9g",
+    "%.10g",
+    "%.11g",
+    "%.12g",
+    "%.13g",
+    "%.14g",
+    "%.15g",
+    "%.16g",
+    "%.17g",
+};
+
+#define DEFINE_BENCHMARK(type, count)                                                                \
+    Y_CPU_BENCHMARK(SprintfAuto_##type##_##count, iface) {                                           \
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \
+                /* than FloatToString(e.Value) */                                                    \
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(FloatToStringAuto_##type##_##count, iface) {                                     \
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(SprintfFixed_##type##_##count, iface) {                                          \
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(FloatToStringFixed_##type##_##count, iface) {                                    \
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(SprintfSignificant_##type##_##count, iface) {                                    \
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(FloatToStringSignificant_##type##_##count, iface) {                              \
+        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(NearZeroSprintfAuto_##type##_##count, iface) {                                   \
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \
+                /* than FloatToString(e.Value) */                                                    \
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(NearZeroFloatToStringAuto_##type##_##count, iface) {                             \
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(NearZeroSprintfFixed_##type##_##count, iface) {                                  \
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(NearZeroFloatToStringFixed_##type##_##count, iface) {                            \
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(NearZeroSprintfSignificant_##type##_##count, iface) {                            \
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \
+            }                                                                                        \
+        }                                                                                            \
+    }                                                                                                \
+                                                                                                     \
+    Y_CPU_BENCHMARK(NearZeroFloatToStringSignificant_##type##_##count, iface) {                      \
+        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
+        for (const auto i : xrange(iface.Iterations())) {                                            \
+            Y_UNUSED(i);                                                                             \
+            for (const auto e : examples) {                                                          \
+                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \
+            }                                                                                        \
+        }                                                                                            \
+    }
+
+DEFINE_BENCHMARK(float, 1);
+DEFINE_BENCHMARK(float, 2);
+DEFINE_BENCHMARK(float, 4);
+DEFINE_BENCHMARK(float, 8);
+DEFINE_BENCHMARK(float, 16);
+DEFINE_BENCHMARK(float, 32);
+DEFINE_BENCHMARK(float, 64);
+DEFINE_BENCHMARK(float, 128);
+DEFINE_BENCHMARK(float, 256);
+
+DEFINE_BENCHMARK(double, 1);
+DEFINE_BENCHMARK(double, 2);
+DEFINE_BENCHMARK(double, 4);
+DEFINE_BENCHMARK(double, 8);
+DEFINE_BENCHMARK(double, 16);
+DEFINE_BENCHMARK(double, 32);
+DEFINE_BENCHMARK(double, 64);
+DEFINE_BENCHMARK(double, 128);
+DEFINE_BENCHMARK(double, 256);
+
+#undef DEFINE_BENCHMARK
diff --git a/util/string/benchmark/float_to_string/metrics/main.py b/util/string/benchmark/float_to_string/metrics/main.py
index fdcfd71b0b..e9d4b7ac1d 100644
--- a/util/string/benchmark/float_to_string/metrics/main.py
+++ b/util/string/benchmark/float_to_string/metrics/main.py
@@ -1,5 +1,5 @@
-import yatest.common as yc 
- 
- 
-def test_export_metrics(metrics): 
+import yatest.common as yc
+
+
+def test_export_metrics(metrics):
     metrics.set_benchmark(yc.execute_benchmark('util/string/benchmark/float_to_string/float_to_string', threads=8))
diff --git a/util/string/benchmark/float_to_string/metrics/ya.make b/util/string/benchmark/float_to_string/metrics/ya.make
index 3081301d1d..4b8c4cc07d 100644
--- a/util/string/benchmark/float_to_string/metrics/ya.make
+++ b/util/string/benchmark/float_to_string/metrics/ya.make
@@ -1,21 +1,21 @@
-OWNER( 
-    yazevnul 
+OWNER(
+    yazevnul
     g:util
-) 
+)
 SUBSCRIBER(g:util-subscribers)
- 
+
 PY2TEST()
- 
+
 SIZE(LARGE)
- 
-TAG( 
+
+TAG(
     ya:force_sandbox
-    sb:intel_e5_2660v1 
+    sb:intel_e5_2660v1
     ya:fat
-) 
- 
+)
+
 TEST_SRCS(main.py)
- 
+
 DEPENDS(util/string/benchmark/float_to_string)
- 
-END() 
+
+END()
diff --git a/util/string/benchmark/float_to_string/ya.make b/util/string/benchmark/float_to_string/ya.make
index 30955f3189..8136ad34f0 100644
--- a/util/string/benchmark/float_to_string/ya.make
+++ b/util/string/benchmark/float_to_string/ya.make
@@ -1,12 +1,12 @@
 OWNER(yazevnul)
- 
+
 Y_BENCHMARK()
- 
+
 # to minimize allocations overhead
 ALLOCATOR(B)
- 
-SRCS( 
-    main.cpp 
-) 
- 
-END() 
+
+SRCS(
+    main.cpp
+)
+
+END()