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

28 files changed, 1807 insertions, 1807 deletions

diff --git a/library/cpp/coroutine/engine/impl.cpp b/library/cpp/coroutine/engine/impl.cpp
index 7ae6f74051..10fc6d9052 100644
--- a/library/cpp/coroutine/engine/impl.cpp
+++ b/library/cpp/coroutine/engine/impl.cpp
@@ -1,8 +1,8 @@
 #include "impl.h"
 
-#include "stack/stack_allocator.h"
-#include "stack/stack_guards.h"
-
+#include "stack/stack_allocator.h" 
+#include "stack/stack_guards.h" 
+ 
 #include <util/generic/scope.h>
 #include <util/thread/singleton.h>
 #include <util/stream/format.h>
@@ -18,15 +18,15 @@ void TCont::TJoinWait::Wake() noexcept {
     Cont_.ReSchedule();
 }
 
-TCont::TCont(NCoro::NStack::IAllocator& allocator,
-             uint32_t stackSize,
-             TContExecutor& executor,
+TCont::TCont(NCoro::NStack::IAllocator& allocator, 
+             uint32_t stackSize, 
+             TContExecutor& executor, 
              NCoro::TTrampoline::TFunc func,
-             const char* name) noexcept
+             const char* name) noexcept 
     : Executor_(executor)
     , Name_(name)
     , Trampoline_(
-        allocator,
+        allocator, 
         stackSize,
         std::move(func),
         this
@@ -117,11 +117,11 @@ void TCont::ReSchedule() noexcept {
 
 
 TContExecutor::TContExecutor(
-    uint32_t defaultStackSize,
+    uint32_t defaultStackSize, 
     THolder<IPollerFace> poller,
     NCoro::IScheduleCallback* scheduleCallback,
     NCoro::IEnterPollerCallback* enterPollerCallback,
-    NCoro::NStack::EGuard defaultGuard,
+    NCoro::NStack::EGuard defaultGuard, 
     TMaybe<NCoro::NStack::TPoolAllocatorSettings> poolSettings,
     NCoro::ITime* time
 )
@@ -130,9 +130,9 @@ TContExecutor::TContExecutor(
     , DefaultStackSize_(defaultStackSize)
     , Poller_(std::move(poller))
     , Time_(time)
-{
-    StackAllocator_ = NCoro::NStack::GetAllocator(poolSettings, defaultGuard);
-}
+{ 
+    StackAllocator_ = NCoro::NStack::GetAllocator(poolSettings, defaultGuard); 
+} 
 
 TContExecutor::~TContExecutor() {
     Y_VERIFY(Allocated_ == 0, "leaked %u coroutines", (ui32)Allocated_);
@@ -253,10 +253,10 @@ TCont* TContExecutor::CreateOwned(
     return cont;
 }
 
-NCoro::NStack::TAllocatorStats TContExecutor::GetAllocatorStats() const noexcept {
-    return StackAllocator_->GetStackStats();
-}
-
+NCoro::NStack::TAllocatorStats TContExecutor::GetAllocatorStats() const noexcept { 
+    return StackAllocator_->GetStackStats(); 
+} 
+ 
 void TContExecutor::Release(TCont* cont) noexcept {
     delete cont;
     Allocated_ -= 1;
diff --git a/library/cpp/coroutine/engine/impl.h b/library/cpp/coroutine/engine/impl.h
index 283a96ecf1..4c33be254b 100644
--- a/library/cpp/coroutine/engine/impl.h
+++ b/library/cpp/coroutine/engine/impl.h
@@ -4,7 +4,7 @@
 #include "cont_poller.h"
 #include "iostatus.h"
 #include "poller.h"
-#include "stack/stack_common.h"
+#include "stack/stack_common.h" 
 #include "trampoline.h"
 #include "custom_time.h"
 
@@ -25,9 +25,9 @@ struct TContRep;
 class TContExecutor;
 class TContPollEvent;
 
-namespace NCoro::NStack {
-    class IAllocator;
-}
+namespace NCoro::NStack { 
+    class IAllocator; 
+} 
 
 class TCont : private TIntrusiveListItem<TCont> {
     struct TJoinWait: public TIntrusiveListItem<TJoinWait> {
@@ -46,8 +46,8 @@ class TCont : private TIntrusiveListItem<TCont> {
 
 private:
     TCont(
-        NCoro::NStack::IAllocator& allocator,
-        uint32_t stackSize,
+        NCoro::NStack::IAllocator& allocator, 
+        uint32_t stackSize, 
         TContExecutor& executor,
         NCoro::TTrampoline::TFunc func,
         const char* name
@@ -151,11 +151,11 @@ class TContExecutor {
 
 public:
     TContExecutor(
-        uint32_t defaultStackSize,
+        uint32_t defaultStackSize, 
         THolder<IPollerFace> poller = IPollerFace::Default(),
         NCoro::IScheduleCallback* = nullptr,
         NCoro::IEnterPollerCallback* = nullptr,
-        NCoro::NStack::EGuard stackGuard = NCoro::NStack::EGuard::Canary,
+        NCoro::NStack::EGuard stackGuard = NCoro::NStack::EGuard::Canary, 
         TMaybe<NCoro::NStack::TPoolAllocatorSettings> poolSettings = Nothing(),
         NCoro::ITime* time = nullptr
     );
@@ -236,8 +236,8 @@ public:
         return TotalConts() - TotalReadyConts();
     }
 
-    NCoro::NStack::TAllocatorStats GetAllocatorStats() const noexcept;
-
+    NCoro::NStack::TAllocatorStats GetAllocatorStats() const noexcept; 
+ 
     // TODO(velavokr): rename, it is just CancelAll actually
     void Abort() noexcept;
 
@@ -290,8 +290,8 @@ private:
 private:
     NCoro::IScheduleCallback* const ScheduleCallback_ = nullptr;
     NCoro::IEnterPollerCallback* const EnterPollerCallback_ = nullptr;
-    const uint32_t DefaultStackSize_;
-    THolder<NCoro::NStack::IAllocator> StackAllocator_;
+    const uint32_t DefaultStackSize_; 
+    THolder<NCoro::NStack::IAllocator> StackAllocator_; 
 
     TExceptionSafeContext SchedContext_;
 
diff --git a/library/cpp/coroutine/engine/stack/benchmark/alloc_bm.cpp b/library/cpp/coroutine/engine/stack/benchmark/alloc_bm.cpp
index 38d713d274..927bccb310 100644
--- a/library/cpp/coroutine/engine/stack/benchmark/alloc_bm.cpp
+++ b/library/cpp/coroutine/engine/stack/benchmark/alloc_bm.cpp
@@ -1,316 +1,316 @@
-#include <benchmark/benchmark.h>
-
-#include <util/generic/vector.h>
-#include <util/system/yassert.h>
-
-#include <library/cpp/coroutine/engine/stack/stack_allocator.h>
-#include <library/cpp/coroutine/engine/stack/stack_guards.h>
-#include <library/cpp/coroutine/engine/stack/stack_pool.h>
-#include <library/cpp/coroutine/engine/stack/stack_utils.h>
-
-
-namespace NCoro::NStack::NBenchmark {
-
-    const char* TestCoroName = "any_name";
-    constexpr uint64_t BigCoroSize = PageSize * 25;
-    constexpr uint64_t SmallCoroSize = PageSize * 4;
-    constexpr uint64_t ManyStacks = 4096;
-
-    void BasicOperations(TStackHolder& stack) {
-        Y_VERIFY(!stack.Get().empty());
-        stack.LowerCanaryOk();
-        stack.UpperCanaryOk();
-    }
-
-    void WriteStack(TStackHolder& stack) {
-        auto memory = stack.Get();
-        Y_VERIFY(!memory.empty());
-        stack.LowerCanaryOk();
-        stack.UpperCanaryOk();
-        for (uint64_t i = PageSize / 2; i < memory.size(); i += PageSize * 2) {
-            memory[i] = 42;
-        }
-    }
-
-    static void BM_GetAlignedMemory(benchmark::State& state) {
-        char* raw = nullptr;
-        char* aligned = nullptr;
-        for (auto _ : state) {
-            if (NCoro::NStack::GetAlignedMemory(state.range(0), raw, aligned)) {
-                free(raw);
-            }
-        }
-    }
-    BENCHMARK(BM_GetAlignedMemory)->RangeMultiplier(16)->Range(1, 1024 * 1024);
-
-    static void BM_GetAlignedMemoryReleaseRss(benchmark::State& state) {
-        char* raw = nullptr;
-        char* aligned = nullptr;
-        for (auto _ : state) {
-            if (NCoro::NStack::GetAlignedMemory(state.range(0), raw, aligned)) {
-                const auto toFree = state.range(0) > 2 ? state.range(0) - 2 : 1;
-                ReleaseRss(aligned, toFree);
-                free(raw);
-            }
-        }
-    }
-    BENCHMARK(BM_GetAlignedMemoryReleaseRss)->RangeMultiplier(16)->Range(1, 1024 * 1024);
-
-    static void BM_PoolAllocator(benchmark::State& state) {
-        auto allocator = GetAllocator(TPoolAllocatorSettings{}, (EGuard)state.range(0));
-        for (auto _ : state) {
-            TStackHolder stack(*allocator, state.range(1), TestCoroName);
-            BasicOperations(stack);
-        }
-    }
-    BENCHMARK(BM_PoolAllocator)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize});
-
-    static void BM_DefaultAllocator(benchmark::State& state) {
-        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0));
-        for (auto _ : state) {
-            TStackHolder stack(*allocator, state.range(1), TestCoroName);
-            BasicOperations(stack);
-        }
-    }
-    BENCHMARK(BM_DefaultAllocator)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize});
-
-    static void BM_PoolAllocatorManyStacksOneAtTime(benchmark::State& state) {
-        TPoolAllocatorSettings settings;
-        settings.StacksPerChunk = state.range(2);
-        auto allocator = GetAllocator(settings, (EGuard)state.range(0));
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                TStackHolder stack(*allocator, state.range(1), TestCoroName);
-                BasicOperations(stack);
-            }
-        }
-    }
-    BENCHMARK(BM_PoolAllocatorManyStacksOneAtTime)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024});
-
-    static void BM_DefaultAllocatorManyStacksOneAtTime(benchmark::State& state) {
-        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0));
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                TStackHolder stack(*allocator, state.range(1), TestCoroName);
-                BasicOperations(stack);
-            }
-        }
-    }
-    BENCHMARK(BM_DefaultAllocatorManyStacksOneAtTime)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize});
-
-    static void BM_PoolAllocatorManyStacks(benchmark::State& state) {
-        TPoolAllocatorSettings settings;
-        settings.StacksPerChunk = state.range(2);
-        auto allocator = GetAllocator(settings, (EGuard)state.range(0));
-        TVector<TStackHolder> stacks; // store stacks during benchmark
-        stacks.reserve(ManyStacks);
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.emplace_back(*allocator, state.range(1), TestCoroName);
-                BasicOperations(stacks.back());
-            }
-        }
-    }
-    BENCHMARK(BM_PoolAllocatorManyStacks)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024});
-
-    static void BM_DefaultAllocatorManyStacks(benchmark::State& state) {
-        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0));
-        TVector<TStackHolder> stacks; // store stacks during benchmark
-        stacks.reserve(ManyStacks);
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName));
-                BasicOperations(stacks.back());
-            }
-        }
-    }
-    BENCHMARK(BM_DefaultAllocatorManyStacks)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize});
-
-    // ------------------------------------------------------------------------
-    static void BM_PoolAllocatorManyStacksReleased(benchmark::State& state) {
-        TPoolAllocatorSettings settings;
-        settings.StacksPerChunk = state.range(2);
-        auto allocator = GetAllocator(settings, (EGuard)state.range(0));
-        TVector<TStackHolder> stacks; // store stacks during benchmark
-        stacks.reserve(ManyStacks);
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.emplace_back(*allocator, state.range(1), TestCoroName);
-                BasicOperations(stacks.back());
-            }
-            stacks.clear();
-        }
-    }
-    BENCHMARK(BM_PoolAllocatorManyStacksReleased)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024});
-
-    static void BM_DefaultAllocatorManyStacksReleased(benchmark::State& state) {
-        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0));
-        TVector<TStackHolder> stacks; // store stacks during benchmark
-        stacks.reserve(ManyStacks);
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName));
-                BasicOperations(stacks.back());
-            }
-            stacks.clear();
-        }
-    }
-    BENCHMARK(BM_DefaultAllocatorManyStacksReleased)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize});
-
-    // ------------------------------------------------------------------------
-    static void BM_PoolAllocatorManyStacksReleasedAndRealloc(benchmark::State& state) {
-        TPoolAllocatorSettings settings;
-        settings.StacksPerChunk = state.range(2);
-        auto allocator = GetAllocator(settings, (EGuard)state.range(0));
-        TVector<TStackHolder> stacks; // store stacks during benchmark
-        stacks.reserve(ManyStacks);
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.emplace_back(*allocator, state.range(1), TestCoroName);
-                BasicOperations(stacks.back());
-            }
-            stacks.clear();
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.emplace_back(*allocator, state.range(1), TestCoroName);
-                BasicOperations(stacks.back());
-            }
-        }
-    }
-    BENCHMARK(BM_PoolAllocatorManyStacksReleasedAndRealloc)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 8192})
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 8192})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 8192})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 8192});
-
-    static void BM_DefaultAllocatorManyStacksReleasedAndRealloc(benchmark::State& state) {
-        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0));
-        TVector<TStackHolder> stacks; // store stacks during benchmark
-        stacks.reserve(ManyStacks);
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName));
-                BasicOperations(stacks.back());
-            }
-            stacks.clear();
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName));
-                BasicOperations(stacks.back());
-            }
-        }
-    }
-    BENCHMARK(BM_DefaultAllocatorManyStacksReleasedAndRealloc)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize});
-
-    // ------------------------------------------------------------------------
-    static void BM_PoolAllocatorManyStacksMemoryWriteReleasedAndRealloc(benchmark::State& state) {
-        TPoolAllocatorSettings settings;
-        settings.StacksPerChunk = state.range(2);
-        auto allocator = GetAllocator(settings, (EGuard)state.range(0));
-        TVector<TStackHolder> stacks; // store stacks during benchmark
-        stacks.reserve(ManyStacks);
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.emplace_back(*allocator, state.range(1), TestCoroName);
-                WriteStack(stacks.back());
-            }
-            stacks.clear();
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.emplace_back(*allocator, state.range(1), TestCoroName);
-                WriteStack(stacks.back());
-            }
-        }
-    }
-    BENCHMARK(BM_PoolAllocatorManyStacksMemoryWriteReleasedAndRealloc)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1})
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024})
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 8192})
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 8192})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize, 8192})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 8192});
-
-    static void BM_DefaultAllocatorManyStacksMemoryWriteReleasedAndRealloc(benchmark::State& state) {
-        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0));
-        TVector<TStackHolder> stacks; // store stacks during benchmark
-        stacks.reserve(ManyStacks);
-        for (auto _ : state) {
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName));
-                WriteStack(stacks.back());
-            }
-            stacks.clear();
-            for (uint64_t i = 0; i < ManyStacks; ++i) {
-                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName));
-                WriteStack(stacks.back());
-            }
-        }
-    }
-    BENCHMARK(BM_DefaultAllocatorManyStacksMemoryWriteReleasedAndRealloc)
-        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported
-        ->Args({(int64_t)EGuard::Canary, SmallCoroSize})
-        ->Args({(int64_t)EGuard::Page, BigCoroSize})
-        ->Args({(int64_t)EGuard::Page, SmallCoroSize});
-
-}
-
-BENCHMARK_MAIN();
+#include <benchmark/benchmark.h> 
+ 
+#include <util/generic/vector.h> 
+#include <util/system/yassert.h> 
+ 
+#include <library/cpp/coroutine/engine/stack/stack_allocator.h> 
+#include <library/cpp/coroutine/engine/stack/stack_guards.h> 
+#include <library/cpp/coroutine/engine/stack/stack_pool.h> 
+#include <library/cpp/coroutine/engine/stack/stack_utils.h> 
+ 
+ 
+namespace NCoro::NStack::NBenchmark { 
+ 
+    const char* TestCoroName = "any_name"; 
+    constexpr uint64_t BigCoroSize = PageSize * 25; 
+    constexpr uint64_t SmallCoroSize = PageSize * 4; 
+    constexpr uint64_t ManyStacks = 4096; 
+ 
+    void BasicOperations(TStackHolder& stack) { 
+        Y_VERIFY(!stack.Get().empty()); 
+        stack.LowerCanaryOk(); 
+        stack.UpperCanaryOk(); 
+    } 
+ 
+    void WriteStack(TStackHolder& stack) { 
+        auto memory = stack.Get(); 
+        Y_VERIFY(!memory.empty()); 
+        stack.LowerCanaryOk(); 
+        stack.UpperCanaryOk(); 
+        for (uint64_t i = PageSize / 2; i < memory.size(); i += PageSize * 2) { 
+            memory[i] = 42; 
+        } 
+    } 
+ 
+    static void BM_GetAlignedMemory(benchmark::State& state) { 
+        char* raw = nullptr; 
+        char* aligned = nullptr; 
+        for (auto _ : state) { 
+            if (NCoro::NStack::GetAlignedMemory(state.range(0), raw, aligned)) { 
+                free(raw); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_GetAlignedMemory)->RangeMultiplier(16)->Range(1, 1024 * 1024); 
+ 
+    static void BM_GetAlignedMemoryReleaseRss(benchmark::State& state) { 
+        char* raw = nullptr; 
+        char* aligned = nullptr; 
+        for (auto _ : state) { 
+            if (NCoro::NStack::GetAlignedMemory(state.range(0), raw, aligned)) { 
+                const auto toFree = state.range(0) > 2 ? state.range(0) - 2 : 1; 
+                ReleaseRss(aligned, toFree); 
+                free(raw); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_GetAlignedMemoryReleaseRss)->RangeMultiplier(16)->Range(1, 1024 * 1024); 
+ 
+    static void BM_PoolAllocator(benchmark::State& state) { 
+        auto allocator = GetAllocator(TPoolAllocatorSettings{}, (EGuard)state.range(0)); 
+        for (auto _ : state) { 
+            TStackHolder stack(*allocator, state.range(1), TestCoroName); 
+            BasicOperations(stack); 
+        } 
+    } 
+    BENCHMARK(BM_PoolAllocator) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize}); 
+ 
+    static void BM_DefaultAllocator(benchmark::State& state) { 
+        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0)); 
+        for (auto _ : state) { 
+            TStackHolder stack(*allocator, state.range(1), TestCoroName); 
+            BasicOperations(stack); 
+        } 
+    } 
+    BENCHMARK(BM_DefaultAllocator) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize}); 
+ 
+    static void BM_PoolAllocatorManyStacksOneAtTime(benchmark::State& state) { 
+        TPoolAllocatorSettings settings; 
+        settings.StacksPerChunk = state.range(2); 
+        auto allocator = GetAllocator(settings, (EGuard)state.range(0)); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                TStackHolder stack(*allocator, state.range(1), TestCoroName); 
+                BasicOperations(stack); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_PoolAllocatorManyStacksOneAtTime) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024}); 
+ 
+    static void BM_DefaultAllocatorManyStacksOneAtTime(benchmark::State& state) { 
+        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0)); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                TStackHolder stack(*allocator, state.range(1), TestCoroName); 
+                BasicOperations(stack); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_DefaultAllocatorManyStacksOneAtTime) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize}); 
+ 
+    static void BM_PoolAllocatorManyStacks(benchmark::State& state) { 
+        TPoolAllocatorSettings settings; 
+        settings.StacksPerChunk = state.range(2); 
+        auto allocator = GetAllocator(settings, (EGuard)state.range(0)); 
+        TVector<TStackHolder> stacks; // store stacks during benchmark 
+        stacks.reserve(ManyStacks); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.emplace_back(*allocator, state.range(1), TestCoroName); 
+                BasicOperations(stacks.back()); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_PoolAllocatorManyStacks) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024}); 
+ 
+    static void BM_DefaultAllocatorManyStacks(benchmark::State& state) { 
+        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0)); 
+        TVector<TStackHolder> stacks; // store stacks during benchmark 
+        stacks.reserve(ManyStacks); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName)); 
+                BasicOperations(stacks.back()); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_DefaultAllocatorManyStacks) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize}); 
+ 
+    // ------------------------------------------------------------------------ 
+    static void BM_PoolAllocatorManyStacksReleased(benchmark::State& state) { 
+        TPoolAllocatorSettings settings; 
+        settings.StacksPerChunk = state.range(2); 
+        auto allocator = GetAllocator(settings, (EGuard)state.range(0)); 
+        TVector<TStackHolder> stacks; // store stacks during benchmark 
+        stacks.reserve(ManyStacks); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.emplace_back(*allocator, state.range(1), TestCoroName); 
+                BasicOperations(stacks.back()); 
+            } 
+            stacks.clear(); 
+        } 
+    } 
+    BENCHMARK(BM_PoolAllocatorManyStacksReleased) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024}); 
+ 
+    static void BM_DefaultAllocatorManyStacksReleased(benchmark::State& state) { 
+        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0)); 
+        TVector<TStackHolder> stacks; // store stacks during benchmark 
+        stacks.reserve(ManyStacks); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName)); 
+                BasicOperations(stacks.back()); 
+            } 
+            stacks.clear(); 
+        } 
+    } 
+    BENCHMARK(BM_DefaultAllocatorManyStacksReleased) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize}); 
+ 
+    // ------------------------------------------------------------------------ 
+    static void BM_PoolAllocatorManyStacksReleasedAndRealloc(benchmark::State& state) { 
+        TPoolAllocatorSettings settings; 
+        settings.StacksPerChunk = state.range(2); 
+        auto allocator = GetAllocator(settings, (EGuard)state.range(0)); 
+        TVector<TStackHolder> stacks; // store stacks during benchmark 
+        stacks.reserve(ManyStacks); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.emplace_back(*allocator, state.range(1), TestCoroName); 
+                BasicOperations(stacks.back()); 
+            } 
+            stacks.clear(); 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.emplace_back(*allocator, state.range(1), TestCoroName); 
+                BasicOperations(stacks.back()); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_PoolAllocatorManyStacksReleasedAndRealloc) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 8192}) 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 8192}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 8192}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 8192}); 
+ 
+    static void BM_DefaultAllocatorManyStacksReleasedAndRealloc(benchmark::State& state) { 
+        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0)); 
+        TVector<TStackHolder> stacks; // store stacks during benchmark 
+        stacks.reserve(ManyStacks); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName)); 
+                BasicOperations(stacks.back()); 
+            } 
+            stacks.clear(); 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName)); 
+                BasicOperations(stacks.back()); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_DefaultAllocatorManyStacksReleasedAndRealloc) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize}); 
+ 
+    // ------------------------------------------------------------------------ 
+    static void BM_PoolAllocatorManyStacksMemoryWriteReleasedAndRealloc(benchmark::State& state) { 
+        TPoolAllocatorSettings settings; 
+        settings.StacksPerChunk = state.range(2); 
+        auto allocator = GetAllocator(settings, (EGuard)state.range(0)); 
+        TVector<TStackHolder> stacks; // store stacks during benchmark 
+        stacks.reserve(ManyStacks); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.emplace_back(*allocator, state.range(1), TestCoroName); 
+                WriteStack(stacks.back()); 
+            } 
+            stacks.clear(); 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.emplace_back(*allocator, state.range(1), TestCoroName); 
+                WriteStack(stacks.back()); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_PoolAllocatorManyStacksMemoryWriteReleasedAndRealloc) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1}) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 1024}) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize, 8192}) 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize, 8192}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize, 8192}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize, 8192}); 
+ 
+    static void BM_DefaultAllocatorManyStacksMemoryWriteReleasedAndRealloc(benchmark::State& state) { 
+        auto allocator = GetAllocator(Nothing(), (EGuard)state.range(0)); 
+        TVector<TStackHolder> stacks; // store stacks during benchmark 
+        stacks.reserve(ManyStacks); 
+        for (auto _ : state) { 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName)); 
+                WriteStack(stacks.back()); 
+            } 
+            stacks.clear(); 
+            for (uint64_t i = 0; i < ManyStacks; ++i) { 
+                stacks.push_back(TStackHolder(*allocator, state.range(1), TestCoroName)); 
+                WriteStack(stacks.back()); 
+            } 
+        } 
+    } 
+    BENCHMARK(BM_DefaultAllocatorManyStacksMemoryWriteReleasedAndRealloc) 
+        ->Args({(int64_t)EGuard::Canary, BigCoroSize}) // old version - ArgsProduct() is not supported 
+        ->Args({(int64_t)EGuard::Canary, SmallCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, BigCoroSize}) 
+        ->Args({(int64_t)EGuard::Page, SmallCoroSize}); 
+ 
+} 
+ 
+BENCHMARK_MAIN(); 
diff --git a/library/cpp/coroutine/engine/stack/benchmark/ya.make b/library/cpp/coroutine/engine/stack/benchmark/ya.make
index b2942fe8ca..d14d75b341 100644
--- a/library/cpp/coroutine/engine/stack/benchmark/ya.make
+++ b/library/cpp/coroutine/engine/stack/benchmark/ya.make
@@ -1,13 +1,13 @@
-G_BENCHMARK()
-
-OWNER(g:balancer)
-
-SRCS(
-    alloc_bm.cpp
-)
-
-PEERDIR(
-    library/cpp/coroutine/engine
-)
-
-END()
\ No newline at end of file
+G_BENCHMARK() 
+ 
+OWNER(g:balancer) 
+ 
+SRCS( 
+    alloc_bm.cpp 
+) 
+ 
+PEERDIR( 
+    library/cpp/coroutine/engine 
+) 
+ 
+END() 
\ No newline at end of file
diff --git a/library/cpp/coroutine/engine/stack/stack.cpp b/library/cpp/coroutine/engine/stack/stack.cpp
index e29450261d..658f263216 100644
--- a/library/cpp/coroutine/engine/stack/stack.cpp
+++ b/library/cpp/coroutine/engine/stack/stack.cpp
@@ -1,67 +1,67 @@
-#include "stack.h"
-
-#include "stack_allocator.h"
-#include "stack_guards.h"
-
-
-namespace NCoro::NStack {
-
-namespace NDetails {
-
-    TStack::TStack(void* rawMemory, void* alignedMemory, uint64_t alignedSize, const char* /*name*/)
-            : RawMemory_((char*)rawMemory)
-            , AlignedMemory_((char*)alignedMemory)
-            , Size_(alignedSize)
-    {
-        Y_ASSERT(AlignedMemory_ && RawMemory_ && Size_);
-        Y_ASSERT(!(Size_ & PageSizeMask));
-        Y_ASSERT(!((uint64_t)AlignedMemory_ & PageSizeMask));
-    }
-
-    TStack::TStack(TStack&& rhs) noexcept
-            : RawMemory_(rhs.RawMemory_)
-            , AlignedMemory_(rhs.AlignedMemory_)
-            , Size_(rhs.Size_)
-    {
-        rhs.Reset();
-    }
-
-    TStack& TStack::operator=(TStack&& rhs) noexcept {
-        std::swap(*this, rhs);
-        rhs.Reset();
-        return *this;
-    }
-
-    void TStack::Reset() noexcept {
-        Y_ASSERT(AlignedMemory_ && RawMemory_ && Size_);
-
-        RawMemory_ = nullptr;
-        AlignedMemory_ = nullptr;
-        Size_ = 0;
-    }
-
-} // namespace NDetails
-
-
-    TStackHolder::TStackHolder(NStack::IAllocator& allocator, uint32_t size, const char* name) noexcept
-        : Allocator_(allocator)
-        , Stack_(Allocator_.AllocStack(size, name))
-    {}
-
-    TStackHolder::~TStackHolder() {
-        Allocator_.FreeStack(Stack_);
-    }
-
-    TArrayRef<char> TStackHolder::Get() noexcept {
-        return Allocator_.GetStackWorkspace(Stack_.GetAlignedMemory(), Stack_.GetSize());
-    }
-
-    bool TStackHolder::LowerCanaryOk() const noexcept {
-        return Allocator_.CheckStackOverflow(Stack_.GetAlignedMemory());
-    }
-
-    bool TStackHolder::UpperCanaryOk() const noexcept {
-        return Allocator_.CheckStackOverride(Stack_.GetAlignedMemory(), Stack_.GetSize());
-    }
-
-}
+#include "stack.h" 
+ 
+#include "stack_allocator.h" 
+#include "stack_guards.h" 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+namespace NDetails { 
+ 
+    TStack::TStack(void* rawMemory, void* alignedMemory, uint64_t alignedSize, const char* /*name*/) 
+            : RawMemory_((char*)rawMemory) 
+            , AlignedMemory_((char*)alignedMemory) 
+            , Size_(alignedSize) 
+    { 
+        Y_ASSERT(AlignedMemory_ && RawMemory_ && Size_); 
+        Y_ASSERT(!(Size_ & PageSizeMask)); 
+        Y_ASSERT(!((uint64_t)AlignedMemory_ & PageSizeMask)); 
+    } 
+ 
+    TStack::TStack(TStack&& rhs) noexcept 
+            : RawMemory_(rhs.RawMemory_) 
+            , AlignedMemory_(rhs.AlignedMemory_) 
+            , Size_(rhs.Size_) 
+    { 
+        rhs.Reset(); 
+    } 
+ 
+    TStack& TStack::operator=(TStack&& rhs) noexcept { 
+        std::swap(*this, rhs); 
+        rhs.Reset(); 
+        return *this; 
+    } 
+ 
+    void TStack::Reset() noexcept { 
+        Y_ASSERT(AlignedMemory_ && RawMemory_ && Size_); 
+ 
+        RawMemory_ = nullptr; 
+        AlignedMemory_ = nullptr; 
+        Size_ = 0; 
+    } 
+ 
+} // namespace NDetails 
+ 
+ 
+    TStackHolder::TStackHolder(NStack::IAllocator& allocator, uint32_t size, const char* name) noexcept 
+        : Allocator_(allocator) 
+        , Stack_(Allocator_.AllocStack(size, name)) 
+    {} 
+ 
+    TStackHolder::~TStackHolder() { 
+        Allocator_.FreeStack(Stack_); 
+    } 
+ 
+    TArrayRef<char> TStackHolder::Get() noexcept { 
+        return Allocator_.GetStackWorkspace(Stack_.GetAlignedMemory(), Stack_.GetSize()); 
+    } 
+ 
+    bool TStackHolder::LowerCanaryOk() const noexcept { 
+        return Allocator_.CheckStackOverflow(Stack_.GetAlignedMemory()); 
+    } 
+ 
+    bool TStackHolder::UpperCanaryOk() const noexcept { 
+        return Allocator_.CheckStackOverride(Stack_.GetAlignedMemory(), Stack_.GetSize()); 
+    } 
+ 
+} 
diff --git a/library/cpp/coroutine/engine/stack/stack.h b/library/cpp/coroutine/engine/stack/stack.h
index 7d98ba4c68..e6b9a3a05d 100644
--- a/library/cpp/coroutine/engine/stack/stack.h
+++ b/library/cpp/coroutine/engine/stack/stack.h
@@ -1,77 +1,77 @@
-#pragma once
-
-#include <util/generic/array_ref.h>
-#include <util/generic/fwd.h>
-#include <util/generic/noncopyable.h>
-
-#include <cstdint>
-
-
-namespace NCoro::NStack {
-
-    class IAllocator;
-
-namespace NDetails {
-
-    //! Do not use directly, use TStackHolder instead
-    class TStack final : private TMoveOnly {
-    public:
-        /*! rawMemory: can be used by unaligned allocator to free stack memory after use
-         *  alignedMemory: pointer to aligned memory on which stack workspace and guard are actually placed
-         *  alignedSize: size of workspace memory + memory for guard
-         *  guard: guard to protect this stack
-         *  name: name of coroutine for which this stack is allocated
-         */
-        TStack(void* rawMemory, void* alignedMemory, uint64_t alignedSize, const char* name);
-        TStack(TStack&& rhs) noexcept;
-        TStack& operator=(TStack&& rhs) noexcept;
-
-        char* GetRawMemory() const noexcept {
-            return RawMemory_;
-        }
-
-        char* GetAlignedMemory() const noexcept {
-            return AlignedMemory_;
-        }
-
-        //! Stack size (includes memory for guard)
-        uint64_t GetSize() const noexcept {
-            return Size_;
-        }
-
-        //! Resets parameters, should be called after stack memory is freed
-        void Reset() noexcept;
-
-    private:
-        char* RawMemory_ = nullptr; // not owned
-        char* AlignedMemory_ = nullptr; // not owned
-        uint64_t Size_ = 0;
-    };
-
-} // namespace NDetails
-
-    class TStackHolder final : private TMoveOnly {
-    public:
-        explicit TStackHolder(IAllocator& allocator, uint32_t size, const char* name) noexcept;
-        TStackHolder(TStackHolder&&) = default;
-        TStackHolder& operator=(TStackHolder&&) = default;
-
-        ~TStackHolder();
-
-        char* GetAlignedMemory() const noexcept {
-            return Stack_.GetAlignedMemory();
-        }
-        uint64_t GetSize() const noexcept {
-            return Stack_.GetSize();
-        }
-
-        TArrayRef<char> Get() noexcept;
-        bool LowerCanaryOk() const noexcept;
-        bool UpperCanaryOk() const noexcept;
-
-    private:
-        IAllocator& Allocator_;
-        NDetails::TStack Stack_;
-    };
-
-}
+#pragma once 
+ 
+#include <util/generic/array_ref.h> 
+#include <util/generic/fwd.h> 
+#include <util/generic/noncopyable.h> 
+ 
+#include <cstdint> 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+    class IAllocator; 
+ 
+namespace NDetails { 
+ 
+    //! Do not use directly, use TStackHolder instead 
+    class TStack final : private TMoveOnly { 
+    public: 
+        /*! rawMemory: can be used by unaligned allocator to free stack memory after use 
+         *  alignedMemory: pointer to aligned memory on which stack workspace and guard are actually placed 
+         *  alignedSize: size of workspace memory + memory for guard 
+         *  guard: guard to protect this stack 
+         *  name: name of coroutine for which this stack is allocated 
+         */ 
+        TStack(void* rawMemory, void* alignedMemory, uint64_t alignedSize, const char* name); 
+        TStack(TStack&& rhs) noexcept; 
+        TStack& operator=(TStack&& rhs) noexcept; 
+ 
+        char* GetRawMemory() const noexcept { 
+            return RawMemory_; 
+        } 
+ 
+        char* GetAlignedMemory() const noexcept { 
+            return AlignedMemory_; 
+        } 
+ 
+        //! Stack size (includes memory for guard) 
+        uint64_t GetSize() const noexcept { 
+            return Size_; 
+        } 
+ 
+        //! Resets parameters, should be called after stack memory is freed 
+        void Reset() noexcept; 
+ 
+    private: 
+        char* RawMemory_ = nullptr; // not owned 
+        char* AlignedMemory_ = nullptr; // not owned 
+        uint64_t Size_ = 0; 
+    }; 
+ 
+} // namespace NDetails 
+ 
+    class TStackHolder final : private TMoveOnly { 
+    public: 
+        explicit TStackHolder(IAllocator& allocator, uint32_t size, const char* name) noexcept; 
+        TStackHolder(TStackHolder&&) = default; 
+        TStackHolder& operator=(TStackHolder&&) = default; 
+ 
+        ~TStackHolder(); 
+ 
+        char* GetAlignedMemory() const noexcept { 
+            return Stack_.GetAlignedMemory(); 
+        } 
+        uint64_t GetSize() const noexcept { 
+            return Stack_.GetSize(); 
+        } 
+ 
+        TArrayRef<char> Get() noexcept; 
+        bool LowerCanaryOk() const noexcept; 
+        bool UpperCanaryOk() const noexcept; 
+ 
+    private: 
+        IAllocator& Allocator_; 
+        NDetails::TStack Stack_; 
+    }; 
+ 
+} 
diff --git a/library/cpp/coroutine/engine/stack/stack_allocator.cpp b/library/cpp/coroutine/engine/stack/stack_allocator.cpp
index bf12134e6b..494f5d315a 100644
--- a/library/cpp/coroutine/engine/stack/stack_allocator.cpp
+++ b/library/cpp/coroutine/engine/stack/stack_allocator.cpp
@@ -1,26 +1,26 @@
-#include "stack_allocator.h"
-
-
-namespace NCoro::NStack {
-
-    THolder<IAllocator> GetAllocator(TMaybe<TPoolAllocatorSettings> poolSettings, EGuard guardType) {
-        THolder<IAllocator> allocator;
-        if (poolSettings) {
-            if (guardType == EGuard::Canary) {
-                allocator = MakeHolder<TPoolAllocator<TCanaryGuard>>(*poolSettings);
-            } else {
-                Y_ASSERT(guardType == EGuard::Page);
-                allocator = MakeHolder<TPoolAllocator<TPageGuard>>(*poolSettings);
-            }
-        } else {
-            if (guardType == EGuard::Canary) {
-                allocator = MakeHolder<TSimpleAllocator<TCanaryGuard>>();
-            } else {
-                Y_ASSERT(guardType == EGuard::Page);
-                allocator = MakeHolder<TSimpleAllocator<TPageGuard>>();
-            }
-        }
-        return allocator;
-    }
-
-}
\ No newline at end of file
+#include "stack_allocator.h" 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+    THolder<IAllocator> GetAllocator(TMaybe<TPoolAllocatorSettings> poolSettings, EGuard guardType) { 
+        THolder<IAllocator> allocator; 
+        if (poolSettings) { 
+            if (guardType == EGuard::Canary) { 
+                allocator = MakeHolder<TPoolAllocator<TCanaryGuard>>(*poolSettings); 
+            } else { 
+                Y_ASSERT(guardType == EGuard::Page); 
+                allocator = MakeHolder<TPoolAllocator<TPageGuard>>(*poolSettings); 
+            } 
+        } else { 
+            if (guardType == EGuard::Canary) { 
+                allocator = MakeHolder<TSimpleAllocator<TCanaryGuard>>(); 
+            } else { 
+                Y_ASSERT(guardType == EGuard::Page); 
+                allocator = MakeHolder<TSimpleAllocator<TPageGuard>>(); 
+            } 
+        } 
+        return allocator; 
+    } 
+ 
+} 
\ No newline at end of file
diff --git a/library/cpp/coroutine/engine/stack/stack_allocator.h b/library/cpp/coroutine/engine/stack/stack_allocator.h
index da3c3a93a1..543c715634 100644
--- a/library/cpp/coroutine/engine/stack/stack_allocator.h
+++ b/library/cpp/coroutine/engine/stack/stack_allocator.h
@@ -1,52 +1,52 @@
-#pragma once
-
-#include "stack.h"
-#include "stack_common.h"
-
-#include <util/generic/maybe.h>
-#include <util/generic/noncopyable.h>
-#include <util/generic/ptr.h>
-
-#include <cstdint>
-
-
-namespace NCoro::NStack {
-
-    class IAllocator : private TNonCopyable {
-    public:
-        virtual ~IAllocator() = default;
-
-        //! Size should be page-aligned. Stack would be protected by guard, thus, actual
-        //! workspace for stack = size - size of guard.
-        NDetails::TStack AllocStack(uint64_t size, const char* name) {
-            uint64_t alignedSize = (size + PageSize - 1) & ~PageSizeMask;
-            Y_ASSERT(alignedSize < 10 * 1024 * PageSize); // more than 10K pages for stack - do you really need it?
-#if defined(_san_enabled_) || !defined(NDEBUG)
-            alignedSize *= DebugOrSanStackMultiplier;
-#endif
-            return DoAllocStack(alignedSize, name);
-        }
-
-        void FreeStack(NDetails::TStack& stack) noexcept {
-            if (stack.GetAlignedMemory()) {
-                DoFreeStack(stack);
-            }
-        };
-
-        virtual TAllocatorStats GetStackStats() const noexcept = 0;
-
-        // Stack helpers
-        virtual TArrayRef<char> GetStackWorkspace(void* stack, uint64_t size) noexcept = 0;
-        virtual bool CheckStackOverflow(void* stack) const noexcept = 0;
-        virtual bool CheckStackOverride(void* stack, uint64_t size) const noexcept = 0;
-
-    private:
-        virtual NDetails::TStack DoAllocStack(uint64_t size, const char* name) = 0;
-        virtual void DoFreeStack(NDetails::TStack& stack) noexcept = 0;
-    };
-
-    THolder<IAllocator> GetAllocator(TMaybe<TPoolAllocatorSettings> poolSettings, EGuard guardType);
-
-}
-
-#include "stack_allocator.inl"
+#pragma once 
+ 
+#include "stack.h" 
+#include "stack_common.h" 
+ 
+#include <util/generic/maybe.h> 
+#include <util/generic/noncopyable.h> 
+#include <util/generic/ptr.h> 
+ 
+#include <cstdint> 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+    class IAllocator : private TNonCopyable { 
+    public: 
+        virtual ~IAllocator() = default; 
+ 
+        //! Size should be page-aligned. Stack would be protected by guard, thus, actual 
+        //! workspace for stack = size - size of guard. 
+        NDetails::TStack AllocStack(uint64_t size, const char* name) { 
+            uint64_t alignedSize = (size + PageSize - 1) & ~PageSizeMask; 
+            Y_ASSERT(alignedSize < 10 * 1024 * PageSize); // more than 10K pages for stack - do you really need it? 
+#if defined(_san_enabled_) || !defined(NDEBUG) 
+            alignedSize *= DebugOrSanStackMultiplier; 
+#endif 
+            return DoAllocStack(alignedSize, name); 
+        } 
+ 
+        void FreeStack(NDetails::TStack& stack) noexcept { 
+            if (stack.GetAlignedMemory()) { 
+                DoFreeStack(stack); 
+            } 
+        }; 
+ 
+        virtual TAllocatorStats GetStackStats() const noexcept = 0; 
+ 
+        // Stack helpers 
+        virtual TArrayRef<char> GetStackWorkspace(void* stack, uint64_t size) noexcept = 0; 
+        virtual bool CheckStackOverflow(void* stack) const noexcept = 0; 
+        virtual bool CheckStackOverride(void* stack, uint64_t size) const noexcept = 0; 
+ 
+    private: 
+        virtual NDetails::TStack DoAllocStack(uint64_t size, const char* name) = 0; 
+        virtual void DoFreeStack(NDetails::TStack& stack) noexcept = 0; 
+    }; 
+ 
+    THolder<IAllocator> GetAllocator(TMaybe<TPoolAllocatorSettings> poolSettings, EGuard guardType); 
+ 
+} 
+ 
+#include "stack_allocator.inl" 
diff --git a/library/cpp/coroutine/engine/stack/stack_allocator.inl b/library/cpp/coroutine/engine/stack/stack_allocator.inl
index 0f25a4167b..b8bf83840f 100644
--- a/library/cpp/coroutine/engine/stack/stack_allocator.inl
+++ b/library/cpp/coroutine/engine/stack/stack_allocator.inl
@@ -1,138 +1,138 @@
-#include "stack_guards.h"
-#include "stack_pool.h"
-#include "stack_utils.h"
-
-#include <util/generic/hash.h>
-
-#ifdef _linux_
-#include <unistd.h>
-#endif
-
-
-namespace NCoro::NStack {
-
-    template<typename TGuard>
-    class TPoolAllocator final : public IAllocator {
-    public:
-        explicit TPoolAllocator(const TPoolAllocatorSettings& settings);
-
-        TArrayRef<char> GetStackWorkspace(void* stack, uint64_t size) noexcept override {
-            return Guard_.GetWorkspace(stack, size);
-        }
-        bool CheckStackOverflow(void* stack) const noexcept override {
-            return Guard_.CheckOverflow(stack);
-        }
-        bool CheckStackOverride(void* stack, uint64_t size) const noexcept override {
-            return Guard_.CheckOverride(stack, size);
-        }
-
-        TAllocatorStats GetStackStats() const noexcept override {
-            TAllocatorStats stats;
-            for (const auto& i : Pools_) {
-                stats.ReleasedSize += i.second.GetReleasedSize();
-                stats.NotReleasedSize += i.second.GetFullSize();
-                stats.NumOfAllocated += i.second.GetNumOfAllocated();
-            }
-            return stats;
-        }
-
-    private: // methods
-        NDetails::TStack DoAllocStack(uint64_t size, const char* name) override;
-        void DoFreeStack(NDetails::TStack& stack) noexcept override;
-
-    private: // data
-        const TPoolAllocatorSettings PoolSettings_;
-        const TGuard& Guard_;
-        THashMap<uint64_t, TPool<TGuard>> Pools_; // key - stack size
-    };
-
-    template<typename TGuard>
-    TPoolAllocator<TGuard>::TPoolAllocator(const TPoolAllocatorSettings& settings)
-        : PoolSettings_(settings)
-        , Guard_(GetGuard<TGuard>())
-    {
-#ifdef _linux_
-        Y_VERIFY(sysconf(_SC_PAGESIZE) == PageSize);
-#endif
-    }
-
-    template<typename TGuard>
-    NDetails::TStack TPoolAllocator<TGuard>::DoAllocStack(uint64_t alignedSize, const char* name) {
-        Y_ASSERT(alignedSize > Guard_.GetSize());
-
-        auto pool = Pools_.find(alignedSize);
-        if (pool == Pools_.end()) {
-            Y_ASSERT(Pools_.size() < 1000); // too many different sizes for coroutine stacks
-            auto [newPool, success] = Pools_.emplace(alignedSize, TPool<TGuard>{alignedSize, PoolSettings_, Guard_});
-            Y_VERIFY(success, "Failed to add new coroutine pool");
-            pool = newPool;
-        }
-        return pool->second.AllocStack(name);
-    }
-
-    template<typename TGuard>
-    void TPoolAllocator<TGuard>::DoFreeStack(NDetails::TStack& stack) noexcept {
-        auto pool = Pools_.find(stack.GetSize());
-        Y_VERIFY(pool != Pools_.end(), "Attempt to free stack from another allocator");
-        pool->second.FreeStack(stack);
-    }
-
-    // ------------------------------------------------------------------------
-    //
-    template<typename TGuard>
-    class TSimpleAllocator : public IAllocator {
-    public:
-        explicit TSimpleAllocator();
-
-        TArrayRef<char> GetStackWorkspace(void* stack, uint64_t size) noexcept override {
-            return Guard_.GetWorkspace(stack, size);
-        }
-        bool CheckStackOverflow(void* stack) const noexcept override {
-            return Guard_.CheckOverflow(stack);
-        }
-        bool CheckStackOverride(void* stack, uint64_t size) const noexcept override {
-            return Guard_.CheckOverride(stack, size);
-        }
-
-        TAllocatorStats GetStackStats() const noexcept override { return {}; } // not used for simple allocator
-
-    private: // methods
-        NDetails::TStack DoAllocStack(uint64_t size, const char* name) override;
-        void DoFreeStack(NDetails::TStack& stack) noexcept override;
-
-    private: // data
-        const TGuard& Guard_;
-    };
-
-
-    template<typename TGuard>
-    TSimpleAllocator<TGuard>::TSimpleAllocator()
-        : Guard_(GetGuard<TGuard>())
-    {}
-
-    template<typename TGuard>
-    NDetails::TStack TSimpleAllocator<TGuard>::DoAllocStack(uint64_t alignedSize, const char* name) {
-        Y_ASSERT(alignedSize > Guard_.GetSize());
-
-        char* rawPtr = nullptr;
-        char* alignedPtr = nullptr; // with extra space for previous guard in this type of allocator
-
-        Y_VERIFY(GetAlignedMemory((alignedSize + Guard_.GetPageAlignedSize()) / PageSize, rawPtr, alignedPtr)); // + memory for previous guard
-        char* alignedStackMemory = alignedPtr + Guard_.GetPageAlignedSize(); // after previous guard
-
-        // Default allocator sets both guards, because it doesn't have memory chunk with previous stack and guard on it
-        Guard_.Protect((void*)alignedPtr, Guard_.GetPageAlignedSize(), false); // first guard should be before stack memory
-        Guard_.Protect(alignedStackMemory, alignedSize, true); // second guard is placed on stack memory
-
-        return NDetails::TStack{rawPtr, alignedStackMemory, alignedSize, name};
-    }
-
-    template<typename TGuard>
-    void TSimpleAllocator<TGuard>::DoFreeStack(NDetails::TStack& stack) noexcept {
-        Guard_.RemoveProtection(stack.GetAlignedMemory() - Guard_.GetPageAlignedSize(), Guard_.GetPageAlignedSize());
-        Guard_.RemoveProtection(stack.GetAlignedMemory(), stack.GetSize());
-
-        free(stack.GetRawMemory());
-        stack.Reset();
-    }
-}
+#include "stack_guards.h" 
+#include "stack_pool.h" 
+#include "stack_utils.h" 
+ 
+#include <util/generic/hash.h> 
+ 
+#ifdef _linux_ 
+#include <unistd.h> 
+#endif 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+    template<typename TGuard> 
+    class TPoolAllocator final : public IAllocator { 
+    public: 
+        explicit TPoolAllocator(const TPoolAllocatorSettings& settings); 
+ 
+        TArrayRef<char> GetStackWorkspace(void* stack, uint64_t size) noexcept override { 
+            return Guard_.GetWorkspace(stack, size); 
+        } 
+        bool CheckStackOverflow(void* stack) const noexcept override { 
+            return Guard_.CheckOverflow(stack); 
+        } 
+        bool CheckStackOverride(void* stack, uint64_t size) const noexcept override { 
+            return Guard_.CheckOverride(stack, size); 
+        } 
+ 
+        TAllocatorStats GetStackStats() const noexcept override { 
+            TAllocatorStats stats; 
+            for (const auto& i : Pools_) { 
+                stats.ReleasedSize += i.second.GetReleasedSize(); 
+                stats.NotReleasedSize += i.second.GetFullSize(); 
+                stats.NumOfAllocated += i.second.GetNumOfAllocated(); 
+            } 
+            return stats; 
+        } 
+ 
+    private: // methods 
+        NDetails::TStack DoAllocStack(uint64_t size, const char* name) override; 
+        void DoFreeStack(NDetails::TStack& stack) noexcept override; 
+ 
+    private: // data 
+        const TPoolAllocatorSettings PoolSettings_; 
+        const TGuard& Guard_; 
+        THashMap<uint64_t, TPool<TGuard>> Pools_; // key - stack size 
+    }; 
+ 
+    template<typename TGuard> 
+    TPoolAllocator<TGuard>::TPoolAllocator(const TPoolAllocatorSettings& settings) 
+        : PoolSettings_(settings) 
+        , Guard_(GetGuard<TGuard>()) 
+    { 
+#ifdef _linux_ 
+        Y_VERIFY(sysconf(_SC_PAGESIZE) == PageSize); 
+#endif 
+    } 
+ 
+    template<typename TGuard> 
+    NDetails::TStack TPoolAllocator<TGuard>::DoAllocStack(uint64_t alignedSize, const char* name) { 
+        Y_ASSERT(alignedSize > Guard_.GetSize()); 
+ 
+        auto pool = Pools_.find(alignedSize); 
+        if (pool == Pools_.end()) { 
+            Y_ASSERT(Pools_.size() < 1000); // too many different sizes for coroutine stacks 
+            auto [newPool, success] = Pools_.emplace(alignedSize, TPool<TGuard>{alignedSize, PoolSettings_, Guard_}); 
+            Y_VERIFY(success, "Failed to add new coroutine pool"); 
+            pool = newPool; 
+        } 
+        return pool->second.AllocStack(name); 
+    } 
+ 
+    template<typename TGuard> 
+    void TPoolAllocator<TGuard>::DoFreeStack(NDetails::TStack& stack) noexcept { 
+        auto pool = Pools_.find(stack.GetSize()); 
+        Y_VERIFY(pool != Pools_.end(), "Attempt to free stack from another allocator"); 
+        pool->second.FreeStack(stack); 
+    } 
+ 
+    // ------------------------------------------------------------------------ 
+    // 
+    template<typename TGuard> 
+    class TSimpleAllocator : public IAllocator { 
+    public: 
+        explicit TSimpleAllocator(); 
+ 
+        TArrayRef<char> GetStackWorkspace(void* stack, uint64_t size) noexcept override { 
+            return Guard_.GetWorkspace(stack, size); 
+        } 
+        bool CheckStackOverflow(void* stack) const noexcept override { 
+            return Guard_.CheckOverflow(stack); 
+        } 
+        bool CheckStackOverride(void* stack, uint64_t size) const noexcept override { 
+            return Guard_.CheckOverride(stack, size); 
+        } 
+ 
+        TAllocatorStats GetStackStats() const noexcept override { return {}; } // not used for simple allocator 
+ 
+    private: // methods 
+        NDetails::TStack DoAllocStack(uint64_t size, const char* name) override; 
+        void DoFreeStack(NDetails::TStack& stack) noexcept override; 
+ 
+    private: // data 
+        const TGuard& Guard_; 
+    }; 
+ 
+ 
+    template<typename TGuard> 
+    TSimpleAllocator<TGuard>::TSimpleAllocator() 
+        : Guard_(GetGuard<TGuard>()) 
+    {} 
+ 
+    template<typename TGuard> 
+    NDetails::TStack TSimpleAllocator<TGuard>::DoAllocStack(uint64_t alignedSize, const char* name) { 
+        Y_ASSERT(alignedSize > Guard_.GetSize()); 
+ 
+        char* rawPtr = nullptr; 
+        char* alignedPtr = nullptr; // with extra space for previous guard in this type of allocator 
+ 
+        Y_VERIFY(GetAlignedMemory((alignedSize + Guard_.GetPageAlignedSize()) / PageSize, rawPtr, alignedPtr)); // + memory for previous guard 
+        char* alignedStackMemory = alignedPtr + Guard_.GetPageAlignedSize(); // after previous guard 
+ 
+        // Default allocator sets both guards, because it doesn't have memory chunk with previous stack and guard on it 
+        Guard_.Protect((void*)alignedPtr, Guard_.GetPageAlignedSize(), false); // first guard should be before stack memory 
+        Guard_.Protect(alignedStackMemory, alignedSize, true); // second guard is placed on stack memory 
+ 
+        return NDetails::TStack{rawPtr, alignedStackMemory, alignedSize, name}; 
+    } 
+ 
+    template<typename TGuard> 
+    void TSimpleAllocator<TGuard>::DoFreeStack(NDetails::TStack& stack) noexcept { 
+        Guard_.RemoveProtection(stack.GetAlignedMemory() - Guard_.GetPageAlignedSize(), Guard_.GetPageAlignedSize()); 
+        Guard_.RemoveProtection(stack.GetAlignedMemory(), stack.GetSize()); 
+ 
+        free(stack.GetRawMemory()); 
+        stack.Reset(); 
+    } 
+} 
diff --git a/library/cpp/coroutine/engine/stack/stack_common.h b/library/cpp/coroutine/engine/stack/stack_common.h
index ed2d74d296..49e3466956 100644
--- a/library/cpp/coroutine/engine/stack/stack_common.h
+++ b/library/cpp/coroutine/engine/stack/stack_common.h
@@ -1,35 +1,35 @@
-#pragma once
-
-#include <cstdint>
-
-class TContExecutor;
-
-namespace NCoro::NStack {
-
-    static constexpr uint64_t PageSize = 4096;
-    static constexpr uint64_t PageSizeMask = PageSize - 1; // for checks
-    static constexpr uint64_t DebugOrSanStackMultiplier = 4; // for debug or sanitizer builds
-    static constexpr uint64_t SmallStackMaxSizeInPages = 6;
-
-    enum class EGuard {
-        Canary, //!< writes some data to check it for corruption
-        Page,   //!< prohibits access to page memory
-    };
-
-    struct TPoolAllocatorSettings {
-        uint64_t RssPagesToKeep = 1;
-        uint64_t SmallStackRssPagesToKeep = 1; // for stack less than SmallStackMaxSizeInPages
-        uint64_t ReleaseRate = 2;
-#if !defined(_san_enabled_) && defined(NDEBUG)
-        uint64_t StacksPerChunk = 256;
-#else
-        uint64_t StacksPerChunk = 2;
-#endif
-    };
-
-    struct TAllocatorStats {
-        uint64_t ReleasedSize = 0;
-        uint64_t NotReleasedSize = 0;
-        uint64_t NumOfAllocated = 0;
-    };
-}
+#pragma once 
+ 
+#include <cstdint> 
+ 
+class TContExecutor; 
+ 
+namespace NCoro::NStack { 
+ 
+    static constexpr uint64_t PageSize = 4096; 
+    static constexpr uint64_t PageSizeMask = PageSize - 1; // for checks 
+    static constexpr uint64_t DebugOrSanStackMultiplier = 4; // for debug or sanitizer builds 
+    static constexpr uint64_t SmallStackMaxSizeInPages = 6; 
+ 
+    enum class EGuard { 
+        Canary, //!< writes some data to check it for corruption 
+        Page,   //!< prohibits access to page memory 
+    }; 
+ 
+    struct TPoolAllocatorSettings { 
+        uint64_t RssPagesToKeep = 1; 
+        uint64_t SmallStackRssPagesToKeep = 1; // for stack less than SmallStackMaxSizeInPages 
+        uint64_t ReleaseRate = 2; 
+#if !defined(_san_enabled_) && defined(NDEBUG) 
+        uint64_t StacksPerChunk = 256; 
+#else 
+        uint64_t StacksPerChunk = 2; 
+#endif 
+    }; 
+ 
+    struct TAllocatorStats { 
+        uint64_t ReleasedSize = 0; 
+        uint64_t NotReleasedSize = 0; 
+        uint64_t NumOfAllocated = 0; 
+    }; 
+} 
diff --git a/library/cpp/coroutine/engine/stack/stack_guards.cpp b/library/cpp/coroutine/engine/stack/stack_guards.cpp
index b8bcff039e..07d10ee300 100644
--- a/library/cpp/coroutine/engine/stack/stack_guards.cpp
+++ b/library/cpp/coroutine/engine/stack/stack_guards.cpp
@@ -1,17 +1,17 @@
-#include "stack_guards.h"
-
-
-namespace NCoro::NStack {
-
-    template<>
-    const TCanaryGuard& GetGuard<TCanaryGuard>() noexcept {
-        static const TCanaryGuard guard;
-        return guard;
-    }
-
-    template<>
-    const TPageGuard& GetGuard<TPageGuard>() noexcept {
-        static const TPageGuard guard;
-        return guard;
-    }
-}
\ No newline at end of file
+#include "stack_guards.h" 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+    template<> 
+    const TCanaryGuard& GetGuard<TCanaryGuard>() noexcept { 
+        static const TCanaryGuard guard; 
+        return guard; 
+    } 
+ 
+    template<> 
+    const TPageGuard& GetGuard<TPageGuard>() noexcept { 
+        static const TPageGuard guard; 
+        return guard; 
+    } 
+} 
\ No newline at end of file
diff --git a/library/cpp/coroutine/engine/stack/stack_guards.h b/library/cpp/coroutine/engine/stack/stack_guards.h
index 3a7ef26481..c354339ed2 100644
--- a/library/cpp/coroutine/engine/stack/stack_guards.h
+++ b/library/cpp/coroutine/engine/stack/stack_guards.h
@@ -1,123 +1,123 @@
-#pragma once
-
-#include "stack_common.h"
-
-#include <util/generic/array_ref.h>
-#include <util/generic/strbuf.h>
-#include <util/system/protect.h>
-
-
-namespace NCoro::NStack {
-
-    /*! Guard detect stack overflow/override, by setting memory before and after stack with predefined values/properties.
-     * Actually, it sets memory only after the end of stack workspace memory - previous guard section should be set
-     * already (for previous stack in case of pool allocator) and can be checked on demand.
-     * Stack pointer should be page-aligned.
-     */
-
-
-    //! Checks integrity by writing a predefined sequence and comparing it with original
-    class TCanaryGuard final {
-    public:
-        //! Size of guard section in bytes
-        static constexpr uint64_t GetSize() { return Canary.size(); }
-        //! Size of page-aligned guard section in bytes
-        static constexpr uint64_t GetPageAlignedSize() { return AlignedSize_; }
-
-        //! Get stack memory between guard sections
-        static TArrayRef<char> GetWorkspace(void* stack, uint64_t size) noexcept {
-            Y_ASSERT( !((uint64_t)stack & PageSizeMask) );
-            Y_ASSERT( !(size & PageSizeMask) );
-            Y_ASSERT(size > Canary.size());
-
-            return {(char*) stack, size - Canary.size()};
-        }
-
-        /*! Set guard section before the end of stack memory (at stack + size - guard size position)
-         *  checkPrevious: check guard before stack memory for integrity
-         */
-        static void Protect(void* stack, uint64_t size, bool checkPrevious) noexcept {
-            Y_ASSERT( !((uint64_t)stack & PageSizeMask) ); // stack pointer should be page aligned
-            Y_ASSERT( !(size & PageSizeMask) ); // stack size should be page aligned
-            Y_ASSERT(size >= Canary.size()); // stack should have enough space to place guard
-
-            if (checkPrevious) {
-                Y_VERIFY(CheckOverflow(stack), "Previous stack was corrupted");
-            }
-            auto guardPos = (char*) stack + size - Canary.size();
-            memcpy(guardPos, Canary.data(), Canary.size());
-        }
-
-        //! This guard doesn't change memory flags
-        static constexpr void RemoveProtection(void*, uint64_t) {}
-        //! Should remove protection before returning memory to system
-        static constexpr bool ShouldRemoveProtectionBeforeFree() { return false; }
-
-        static bool CheckOverflow(void* stack) noexcept {
-            Y_ASSERT(stack);
-
-            char* guardPos = (char*) ((uint64_t)stack - Canary.size());
-            return TStringBuf(guardPos, Canary.size()) == Canary;
-        }
-
-        static bool CheckOverride(void* stack, uint64_t size) noexcept {
-            Y_ASSERT(stack);
-            Y_ASSERT(size > Canary.size());
-
-            char* guardPos = (char*) ((uint64_t)stack + size - Canary.size());
-            return TStringBuf(guardPos, Canary.size()) == Canary;
-        }
-
-    private:
+#pragma once 
+ 
+#include "stack_common.h" 
+ 
+#include <util/generic/array_ref.h> 
+#include <util/generic/strbuf.h> 
+#include <util/system/protect.h> 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+    /*! Guard detect stack overflow/override, by setting memory before and after stack with predefined values/properties. 
+     * Actually, it sets memory only after the end of stack workspace memory - previous guard section should be set 
+     * already (for previous stack in case of pool allocator) and can be checked on demand. 
+     * Stack pointer should be page-aligned. 
+     */ 
+ 
+ 
+    //! Checks integrity by writing a predefined sequence and comparing it with original 
+    class TCanaryGuard final { 
+    public: 
+        //! Size of guard section in bytes 
+        static constexpr uint64_t GetSize() { return Canary.size(); } 
+        //! Size of page-aligned guard section in bytes 
+        static constexpr uint64_t GetPageAlignedSize() { return AlignedSize_; } 
+ 
+        //! Get stack memory between guard sections 
+        static TArrayRef<char> GetWorkspace(void* stack, uint64_t size) noexcept { 
+            Y_ASSERT( !((uint64_t)stack & PageSizeMask) ); 
+            Y_ASSERT( !(size & PageSizeMask) ); 
+            Y_ASSERT(size > Canary.size()); 
+ 
+            return {(char*) stack, size - Canary.size()}; 
+        } 
+ 
+        /*! Set guard section before the end of stack memory (at stack + size - guard size position) 
+         *  checkPrevious: check guard before stack memory for integrity 
+         */ 
+        static void Protect(void* stack, uint64_t size, bool checkPrevious) noexcept { 
+            Y_ASSERT( !((uint64_t)stack & PageSizeMask) ); // stack pointer should be page aligned 
+            Y_ASSERT( !(size & PageSizeMask) ); // stack size should be page aligned 
+            Y_ASSERT(size >= Canary.size()); // stack should have enough space to place guard 
+ 
+            if (checkPrevious) { 
+                Y_VERIFY(CheckOverflow(stack), "Previous stack was corrupted"); 
+            } 
+            auto guardPos = (char*) stack + size - Canary.size(); 
+            memcpy(guardPos, Canary.data(), Canary.size()); 
+        } 
+ 
+        //! This guard doesn't change memory flags 
+        static constexpr void RemoveProtection(void*, uint64_t) {} 
+        //! Should remove protection before returning memory to system 
+        static constexpr bool ShouldRemoveProtectionBeforeFree() { return false; } 
+ 
+        static bool CheckOverflow(void* stack) noexcept { 
+            Y_ASSERT(stack); 
+ 
+            char* guardPos = (char*) ((uint64_t)stack - Canary.size()); 
+            return TStringBuf(guardPos, Canary.size()) == Canary; 
+        } 
+ 
+        static bool CheckOverride(void* stack, uint64_t size) noexcept { 
+            Y_ASSERT(stack); 
+            Y_ASSERT(size > Canary.size()); 
+ 
+            char* guardPos = (char*) ((uint64_t)stack + size - Canary.size()); 
+            return TStringBuf(guardPos, Canary.size()) == Canary; 
+        } 
+ 
+    private: 
         static constexpr TStringBuf Canary = "[ThisIsACanaryCoroutineStackGuardIfYouReadThisTheStackIsStillOK]";
-        static_assert(Canary.size() == 64);
-        static constexpr uint64_t AlignedSize_ = (Canary.size() + PageSize - 1) & ~PageSizeMask;
-    };
-
-
-    // ------------------------------------------------------------------------
-    //
-    //! Ensures integrity by removing access rights for border pages
-    class TPageGuard final {
-    public:
-        //! Size of guard section in bytes
-        static constexpr uint64_t GetSize() { return PageSize; }
-        //! Size of page-aligned guard section in bytes
-        static constexpr uint64_t GetPageAlignedSize() { return PageSize; }
-
-        static TArrayRef<char> GetWorkspace(void* stack, uint64_t size) noexcept {
-            Y_ASSERT( !((uint64_t)stack & PageSizeMask) );
-            Y_ASSERT( !(size & PageSizeMask) );
-            Y_ASSERT(size > PageSize);
-
-            return {(char*)stack, size - PageSize};
-        }
-
-        static void Protect(void* stack, uint64_t size, bool /*checkPrevious*/) noexcept {
-            Y_ASSERT( !((uint64_t)stack & PageSizeMask) ); // stack pointer should be page aligned
-            Y_ASSERT( !(size & PageSizeMask) ); // stack size should be page aligned
-            Y_ASSERT(size >= PageSize); // stack should have enough space to place guard
-
-            ProtectMemory((char*)stack + size - PageSize, PageSize, PM_NONE);
-        }
-
-        //! Remove protection, to allow stack memory be freed
-        static void RemoveProtection(void* stack, uint64_t size) noexcept {
-            Y_ASSERT( !((uint64_t)stack & PageSizeMask) );
-            Y_ASSERT( !(size & PageSizeMask) );
-            Y_ASSERT(size >= PageSize);
-
-            ProtectMemory((char*)stack + size - PageSize, PageSize, PM_WRITE | PM_READ);
-        }
-        //! Should remove protection before returning memory to system
-        static constexpr bool ShouldRemoveProtectionBeforeFree() { return true; }
-
-        //! For page guard is not used - it crashes process at once in this case.
-        static constexpr bool CheckOverflow(void*) { return true; }
-        static constexpr bool CheckOverride(void*, uint64_t) { return true; }
-    };
-
-
-    template<typename TGuard>
-    const TGuard& GetGuard() noexcept;
-}
+        static_assert(Canary.size() == 64); 
+        static constexpr uint64_t AlignedSize_ = (Canary.size() + PageSize - 1) & ~PageSizeMask; 
+    }; 
+ 
+ 
+    // ------------------------------------------------------------------------ 
+    // 
+    //! Ensures integrity by removing access rights for border pages 
+    class TPageGuard final { 
+    public: 
+        //! Size of guard section in bytes 
+        static constexpr uint64_t GetSize() { return PageSize; } 
+        //! Size of page-aligned guard section in bytes 
+        static constexpr uint64_t GetPageAlignedSize() { return PageSize; } 
+ 
+        static TArrayRef<char> GetWorkspace(void* stack, uint64_t size) noexcept { 
+            Y_ASSERT( !((uint64_t)stack & PageSizeMask) ); 
+            Y_ASSERT( !(size & PageSizeMask) ); 
+            Y_ASSERT(size > PageSize); 
+ 
+            return {(char*)stack, size - PageSize}; 
+        } 
+ 
+        static void Protect(void* stack, uint64_t size, bool /*checkPrevious*/) noexcept { 
+            Y_ASSERT( !((uint64_t)stack & PageSizeMask) ); // stack pointer should be page aligned 
+            Y_ASSERT( !(size & PageSizeMask) ); // stack size should be page aligned 
+            Y_ASSERT(size >= PageSize); // stack should have enough space to place guard 
+ 
+            ProtectMemory((char*)stack + size - PageSize, PageSize, PM_NONE); 
+        } 
+ 
+        //! Remove protection, to allow stack memory be freed 
+        static void RemoveProtection(void* stack, uint64_t size) noexcept { 
+            Y_ASSERT( !((uint64_t)stack & PageSizeMask) ); 
+            Y_ASSERT( !(size & PageSizeMask) ); 
+            Y_ASSERT(size >= PageSize); 
+ 
+            ProtectMemory((char*)stack + size - PageSize, PageSize, PM_WRITE | PM_READ); 
+        } 
+        //! Should remove protection before returning memory to system 
+        static constexpr bool ShouldRemoveProtectionBeforeFree() { return true; } 
+ 
+        //! For page guard is not used - it crashes process at once in this case. 
+        static constexpr bool CheckOverflow(void*) { return true; } 
+        static constexpr bool CheckOverride(void*, uint64_t) { return true; } 
+    }; 
+ 
+ 
+    template<typename TGuard> 
+    const TGuard& GetGuard() noexcept; 
+} 
diff --git a/library/cpp/coroutine/engine/stack/stack_pool.h b/library/cpp/coroutine/engine/stack/stack_pool.h
index 27a8e9394b..0625362d4d 100644
--- a/library/cpp/coroutine/engine/stack/stack_pool.h
+++ b/library/cpp/coroutine/engine/stack/stack_pool.h
@@ -1,54 +1,54 @@
-#pragma once
-
-#include "stack.h"
-#include "stack_common.h"
-
-#include <util/generic/noncopyable.h>
-#include <util/generic/ptr.h>
-#include <util/generic/vector.h>
-
-
-namespace NCoro::NStack {
-
-    class IGuard;
-    class TStorage;
-    struct TPoolAllocatorSettings;
-
-    template<typename TGuard>
-    class TPool final : private TMoveOnly {
-        struct TMemory {
-            char* Raw = nullptr;
-            char* Aligned = nullptr; // points to aligned memory, which includes space for first page guard
-        };
-    public:
-        TPool(uint64_t stackSize, const TPoolAllocatorSettings& settings, const TGuard& guard);
-        TPool(TPool&& other) noexcept;
-        ~TPool();
-
-        NDetails::TStack AllocStack(const char* name);
-        void FreeStack(NDetails::TStack& stack);
-
-        uint64_t GetReleasedSize() const noexcept;
-        uint64_t GetFullSize() const noexcept;
-        uint64_t GetNumOfAllocated() const noexcept { return NumOfAllocated_; }
-
-    private:
-        void AllocNewMemoryChunk();
-        bool IsSmallStack() const noexcept;
-        bool IsStackFromThisPool(const NDetails::TStack& stack) const noexcept;
-        NDetails::TStack AllocNewStack(const char* name);
-
-    private:
-        const uint64_t StackSize_ = 0;
-        uint64_t RssPagesToKeep_ = 0;
-        const TGuard& Guard_;
-        TVector<TMemory> Memory_; // memory chunks
-        THolder<TStorage> Storage_;
-        char* NextToAlloc_ = nullptr; // points to next available stack in the last memory chunk
-        const uint64_t ChunkSize_ = 0;
-        uint64_t NumOfAllocated_ = 0;
-    };
-
-}
-
-#include "stack_pool.inl"
+#pragma once 
+ 
+#include "stack.h" 
+#include "stack_common.h" 
+ 
+#include <util/generic/noncopyable.h> 
+#include <util/generic/ptr.h> 
+#include <util/generic/vector.h> 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+    class IGuard; 
+    class TStorage; 
+    struct TPoolAllocatorSettings; 
+ 
+    template<typename TGuard> 
+    class TPool final : private TMoveOnly { 
+        struct TMemory { 
+            char* Raw = nullptr; 
+            char* Aligned = nullptr; // points to aligned memory, which includes space for first page guard 
+        }; 
+    public: 
+        TPool(uint64_t stackSize, const TPoolAllocatorSettings& settings, const TGuard& guard); 
+        TPool(TPool&& other) noexcept; 
+        ~TPool(); 
+ 
+        NDetails::TStack AllocStack(const char* name); 
+        void FreeStack(NDetails::TStack& stack); 
+ 
+        uint64_t GetReleasedSize() const noexcept; 
+        uint64_t GetFullSize() const noexcept; 
+        uint64_t GetNumOfAllocated() const noexcept { return NumOfAllocated_; } 
+ 
+    private: 
+        void AllocNewMemoryChunk(); 
+        bool IsSmallStack() const noexcept; 
+        bool IsStackFromThisPool(const NDetails::TStack& stack) const noexcept; 
+        NDetails::TStack AllocNewStack(const char* name); 
+ 
+    private: 
+        const uint64_t StackSize_ = 0; 
+        uint64_t RssPagesToKeep_ = 0; 
+        const TGuard& Guard_; 
+        TVector<TMemory> Memory_; // memory chunks 
+        THolder<TStorage> Storage_; 
+        char* NextToAlloc_ = nullptr; // points to next available stack in the last memory chunk 
+        const uint64_t ChunkSize_ = 0; 
+        uint64_t NumOfAllocated_ = 0; 
+    }; 
+ 
+} 
+ 
+#include "stack_pool.inl" 
diff --git a/library/cpp/coroutine/engine/stack/stack_pool.inl b/library/cpp/coroutine/engine/stack/stack_pool.inl
index 6e08e05a48..8a81514158 100644
--- a/library/cpp/coroutine/engine/stack/stack_pool.inl
+++ b/library/cpp/coroutine/engine/stack/stack_pool.inl
@@ -1,132 +1,132 @@
-#include "stack_storage.h"
-#include "stack_utils.h"
-
-
-namespace NCoro::NStack {
-
-    template<typename TGuard>
-    TPool<TGuard>::TPool(uint64_t stackSize, const TPoolAllocatorSettings& settings, const TGuard& guard)
-        : StackSize_(stackSize)
-        , RssPagesToKeep_(IsSmallStack() ? settings.SmallStackRssPagesToKeep : settings.RssPagesToKeep)
-        , Guard_(guard)
-        , ChunkSize_(Guard_.GetPageAlignedSize() + StackSize_ * settings.StacksPerChunk)
-    {
-        Y_ASSERT(RssPagesToKeep_);
-        if (!RssPagesToKeep_) {
-            RssPagesToKeep_ = 1; // at least guard should be kept
-        }
-
-        const uint64_t stackSizeInPages = stackSize / PageSize;
-        Y_ASSERT(stackSizeInPages >= RssPagesToKeep_);
-        if (stackSizeInPages < RssPagesToKeep_) {
-            RssPagesToKeep_ = stackSizeInPages; // keep all stack pages
-        }
-
-        Y_ASSERT(StackSize_ && !(StackSize_ & PageSizeMask)); // stack size is not zero and page aligned
-        Y_ASSERT(Guard_.GetSize() < StackSize_); // stack has enough space to place guard
-        Y_ASSERT(stackSizeInPages >= RssPagesToKeep_);
-
-        Storage_ = MakeHolder<TStorage>(StackSize_, RssPagesToKeep_, settings.ReleaseRate);
-
-        AllocNewMemoryChunk();
-    }
-
-    template<typename TGuard>
-    TPool<TGuard>::TPool(TPool&& other) noexcept = default;
-
-    template<typename TGuard>
-    TPool<TGuard>::~TPool() {
-        if (!Memory_.empty()) {
-            Y_ASSERT(NextToAlloc_ && StackSize_);
-
-            for (const auto& chunk : Memory_) {
-                Y_ASSERT(chunk.Raw && chunk.Aligned);
-
-                if (Guard_.ShouldRemoveProtectionBeforeFree()) {
-                    Guard_.RemoveProtection(chunk.Aligned, Guard_.GetPageAlignedSize()); // first page in chunk
-
-                    const char* endOfStacksMemory = chunk.Aligned + ChunkSize_;
-                    for (char* i = chunk.Aligned + Guard_.GetPageAlignedSize(); i < endOfStacksMemory; i += StackSize_) {
-                        Guard_.RemoveProtection(i, StackSize_);
-                    }
-                }
-
-                free(chunk.Raw);
-            }
-        }
-    }
-
-    template<typename TGuard>
-    NDetails::TStack TPool<TGuard>::AllocStack(const char* name) {
-        Y_ASSERT(!Memory_.empty());
-
-        if (!Storage_->IsEmpty()) {
-            return Storage_->GetStack(Guard_, name);
-        } else {
-            ++NumOfAllocated_;
-            return AllocNewStack(name);
-        }
-    }
-
-    template<typename TGuard>
-    void TPool<TGuard>::FreeStack(NDetails::TStack& stack) {
-        Y_ASSERT(Storage_->Size() < ((ChunkSize_ - Guard_.GetPageAlignedSize()) / StackSize_) * Memory_.size());
-        Y_ASSERT(IsStackFromThisPool(stack));
-
-        Storage_->ReturnStack(stack);
-    }
-
-    template<typename TGuard>
-    uint64_t TPool<TGuard>::GetReleasedSize() const noexcept {
-        return Storage_->GetReleasedSize();
-    }
-    template<typename TGuard>
-    uint64_t TPool<TGuard>::GetFullSize() const noexcept {
-        return Storage_->GetFullSize();
-    }
-
-    template<typename TGuard>
-    void TPool<TGuard>::AllocNewMemoryChunk() {
-        const uint64_t totalSizeInPages = ChunkSize_ / PageSize;
-
-        TMemory memory;
-        const auto res = GetAlignedMemory(totalSizeInPages, memory.Raw, memory.Aligned);
-        Y_VERIFY(res, "Failed to allocate memory for coro stack pool");
-
-        NextToAlloc_ = memory.Aligned + Guard_.GetPageAlignedSize(); // skip first guard page
-        Guard_.Protect(memory.Aligned, Guard_.GetPageAlignedSize(), false); // protect first guard page
-
-        Memory_.push_back(std::move(memory));
-    }
-
-    template<typename TGuard>
-    bool TPool<TGuard>::IsSmallStack() const noexcept {
-        return StackSize_ / PageSize <= SmallStackMaxSizeInPages;
-    }
-
-    template<typename TGuard>
-    bool TPool<TGuard>::IsStackFromThisPool(const NDetails::TStack& stack) const noexcept {
-        for (const auto& chunk : Memory_) {
-            const char* endOfStacksMemory = chunk.Aligned + ChunkSize_;
-            if (chunk.Raw <= stack.GetRawMemory() && stack.GetRawMemory() < endOfStacksMemory) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    template<typename TGuard>
-    NDetails::TStack TPool<TGuard>::AllocNewStack(const char* name) {
-        if (NextToAlloc_ + StackSize_ > Memory_.rbegin()->Aligned + ChunkSize_) {
-            AllocNewMemoryChunk(); // also sets NextToAlloc_ to first stack position in new allocated chunk of memory
-        }
-        Y_ASSERT(NextToAlloc_ + StackSize_ <= Memory_.rbegin()->Aligned + ChunkSize_);
-
-        char* newStack = NextToAlloc_;
-        NextToAlloc_ += StackSize_;
-
-        Guard_.Protect(newStack, StackSize_, true);
-        return NDetails::TStack{newStack, newStack, StackSize_, name};
-    }
-
-}
+#include "stack_storage.h" 
+#include "stack_utils.h" 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+    template<typename TGuard> 
+    TPool<TGuard>::TPool(uint64_t stackSize, const TPoolAllocatorSettings& settings, const TGuard& guard) 
+        : StackSize_(stackSize) 
+        , RssPagesToKeep_(IsSmallStack() ? settings.SmallStackRssPagesToKeep : settings.RssPagesToKeep) 
+        , Guard_(guard) 
+        , ChunkSize_(Guard_.GetPageAlignedSize() + StackSize_ * settings.StacksPerChunk) 
+    { 
+        Y_ASSERT(RssPagesToKeep_); 
+        if (!RssPagesToKeep_) { 
+            RssPagesToKeep_ = 1; // at least guard should be kept 
+        } 
+ 
+        const uint64_t stackSizeInPages = stackSize / PageSize; 
+        Y_ASSERT(stackSizeInPages >= RssPagesToKeep_); 
+        if (stackSizeInPages < RssPagesToKeep_) { 
+            RssPagesToKeep_ = stackSizeInPages; // keep all stack pages 
+        } 
+ 
+        Y_ASSERT(StackSize_ && !(StackSize_ & PageSizeMask)); // stack size is not zero and page aligned 
+        Y_ASSERT(Guard_.GetSize() < StackSize_); // stack has enough space to place guard 
+        Y_ASSERT(stackSizeInPages >= RssPagesToKeep_); 
+ 
+        Storage_ = MakeHolder<TStorage>(StackSize_, RssPagesToKeep_, settings.ReleaseRate); 
+ 
+        AllocNewMemoryChunk(); 
+    } 
+ 
+    template<typename TGuard> 
+    TPool<TGuard>::TPool(TPool&& other) noexcept = default; 
+ 
+    template<typename TGuard> 
+    TPool<TGuard>::~TPool() { 
+        if (!Memory_.empty()) { 
+            Y_ASSERT(NextToAlloc_ && StackSize_); 
+ 
+            for (const auto& chunk : Memory_) { 
+                Y_ASSERT(chunk.Raw && chunk.Aligned); 
+ 
+                if (Guard_.ShouldRemoveProtectionBeforeFree()) { 
+                    Guard_.RemoveProtection(chunk.Aligned, Guard_.GetPageAlignedSize()); // first page in chunk 
+ 
+                    const char* endOfStacksMemory = chunk.Aligned + ChunkSize_; 
+                    for (char* i = chunk.Aligned + Guard_.GetPageAlignedSize(); i < endOfStacksMemory; i += StackSize_) { 
+                        Guard_.RemoveProtection(i, StackSize_); 
+                    } 
+                } 
+ 
+                free(chunk.Raw); 
+            } 
+        } 
+    } 
+ 
+    template<typename TGuard> 
+    NDetails::TStack TPool<TGuard>::AllocStack(const char* name) { 
+        Y_ASSERT(!Memory_.empty()); 
+ 
+        if (!Storage_->IsEmpty()) { 
+            return Storage_->GetStack(Guard_, name); 
+        } else { 
+            ++NumOfAllocated_; 
+            return AllocNewStack(name); 
+        } 
+    } 
+ 
+    template<typename TGuard> 
+    void TPool<TGuard>::FreeStack(NDetails::TStack& stack) { 
+        Y_ASSERT(Storage_->Size() < ((ChunkSize_ - Guard_.GetPageAlignedSize()) / StackSize_) * Memory_.size()); 
+        Y_ASSERT(IsStackFromThisPool(stack)); 
+ 
+        Storage_->ReturnStack(stack); 
+    } 
+ 
+    template<typename TGuard> 
+    uint64_t TPool<TGuard>::GetReleasedSize() const noexcept { 
+        return Storage_->GetReleasedSize(); 
+    } 
+    template<typename TGuard> 
+    uint64_t TPool<TGuard>::GetFullSize() const noexcept { 
+        return Storage_->GetFullSize(); 
+    } 
+ 
+    template<typename TGuard> 
+    void TPool<TGuard>::AllocNewMemoryChunk() { 
+        const uint64_t totalSizeInPages = ChunkSize_ / PageSize; 
+ 
+        TMemory memory; 
+        const auto res = GetAlignedMemory(totalSizeInPages, memory.Raw, memory.Aligned); 
+        Y_VERIFY(res, "Failed to allocate memory for coro stack pool"); 
+ 
+        NextToAlloc_ = memory.Aligned + Guard_.GetPageAlignedSize(); // skip first guard page 
+        Guard_.Protect(memory.Aligned, Guard_.GetPageAlignedSize(), false); // protect first guard page 
+ 
+        Memory_.push_back(std::move(memory)); 
+    } 
+ 
+    template<typename TGuard> 
+    bool TPool<TGuard>::IsSmallStack() const noexcept { 
+        return StackSize_ / PageSize <= SmallStackMaxSizeInPages; 
+    } 
+ 
+    template<typename TGuard> 
+    bool TPool<TGuard>::IsStackFromThisPool(const NDetails::TStack& stack) const noexcept { 
+        for (const auto& chunk : Memory_) { 
+            const char* endOfStacksMemory = chunk.Aligned + ChunkSize_; 
+            if (chunk.Raw <= stack.GetRawMemory() && stack.GetRawMemory() < endOfStacksMemory) { 
+                return true; 
+            } 
+        } 
+        return false; 
+    } 
+ 
+    template<typename TGuard> 
+    NDetails::TStack TPool<TGuard>::AllocNewStack(const char* name) { 
+        if (NextToAlloc_ + StackSize_ > Memory_.rbegin()->Aligned + ChunkSize_) { 
+            AllocNewMemoryChunk(); // also sets NextToAlloc_ to first stack position in new allocated chunk of memory 
+        } 
+        Y_ASSERT(NextToAlloc_ + StackSize_ <= Memory_.rbegin()->Aligned + ChunkSize_); 
+ 
+        char* newStack = NextToAlloc_; 
+        NextToAlloc_ += StackSize_; 
+ 
+        Guard_.Protect(newStack, StackSize_, true); 
+        return NDetails::TStack{newStack, newStack, StackSize_, name}; 
+    } 
+ 
+} 
diff --git a/library/cpp/coroutine/engine/stack/stack_storage.cpp b/library/cpp/coroutine/engine/stack/stack_storage.cpp
index 6dc2b2d44b..c86fb62329 100644
--- a/library/cpp/coroutine/engine/stack/stack_storage.cpp
+++ b/library/cpp/coroutine/engine/stack/stack_storage.cpp
@@ -1,46 +1,46 @@
-#include "stack_storage.h"
-
-#include "stack.h"
-#include "stack_utils.h"
-
-#include <library/cpp/coroutine/engine/impl.h>
-
-
-namespace NCoro::NStack {
-
-    TStorage::TStorage(uint64_t stackSize, uint64_t rssPagesToKeep, uint64_t releaseRate)
-        : StackSize_(stackSize)
-        , RssPagesToKeep_(rssPagesToKeep)
-        , ReleaseRate_(releaseRate ? releaseRate : 1)
-    {
-        Y_ASSERT(StackSize_ && RssPagesToKeep_);
-    }
-
-    bool TStorage::IsEmpty() const noexcept {
-        return Released_.empty() && Full_.empty();
-    }
-
-    uint64_t TStorage::Size() const noexcept {
-        return Released_.size() + Full_.size();
-    }
-
-    void TStorage::ReturnStack(NDetails::TStack& stack) {
-        thread_local uint64_t i = 0;
-        if (++i % ReleaseRate_ != 0) {
-            Full_.push_back(stack.GetAlignedMemory());
-        } else {
-            ReleaseMemory(stack.GetAlignedMemory(), RssPagesToKeep_);
-            Released_.push_back(stack.GetAlignedMemory());
-        }
-        stack.Reset();
-    }
-
-    void TStorage::ReleaseMemory([[maybe_unused]] char* alignedStackMemory, [[maybe_unused]] uint64_t pagesToKeep) noexcept {
-#if !defined(_san_enabled_) && defined(NDEBUG)
-        uint64_t numOfPagesToFree = StackSize_ / PageSize;
-        numOfPagesToFree -= pagesToKeep;
-        ReleaseRss(alignedStackMemory, numOfPagesToFree);
-#endif
-    }
-
-}
+#include "stack_storage.h" 
+ 
+#include "stack.h" 
+#include "stack_utils.h" 
+ 
+#include <library/cpp/coroutine/engine/impl.h> 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+    TStorage::TStorage(uint64_t stackSize, uint64_t rssPagesToKeep, uint64_t releaseRate) 
+        : StackSize_(stackSize) 
+        , RssPagesToKeep_(rssPagesToKeep) 
+        , ReleaseRate_(releaseRate ? releaseRate : 1) 
+    { 
+        Y_ASSERT(StackSize_ && RssPagesToKeep_); 
+    } 
+ 
+    bool TStorage::IsEmpty() const noexcept { 
+        return Released_.empty() && Full_.empty(); 
+    } 
+ 
+    uint64_t TStorage::Size() const noexcept { 
+        return Released_.size() + Full_.size(); 
+    } 
+ 
+    void TStorage::ReturnStack(NDetails::TStack& stack) { 
+        thread_local uint64_t i = 0; 
+        if (++i % ReleaseRate_ != 0) { 
+            Full_.push_back(stack.GetAlignedMemory()); 
+        } else { 
+            ReleaseMemory(stack.GetAlignedMemory(), RssPagesToKeep_); 
+            Released_.push_back(stack.GetAlignedMemory()); 
+        } 
+        stack.Reset(); 
+    } 
+ 
+    void TStorage::ReleaseMemory([[maybe_unused]] char* alignedStackMemory, [[maybe_unused]] uint64_t pagesToKeep) noexcept { 
+#if !defined(_san_enabled_) && defined(NDEBUG) 
+        uint64_t numOfPagesToFree = StackSize_ / PageSize; 
+        numOfPagesToFree -= pagesToKeep; 
+        ReleaseRss(alignedStackMemory, numOfPagesToFree); 
+#endif 
+    } 
+ 
+} 
diff --git a/library/cpp/coroutine/engine/stack/stack_storage.h b/library/cpp/coroutine/engine/stack/stack_storage.h
index 25fe2cfb17..f9c348547c 100644
--- a/library/cpp/coroutine/engine/stack/stack_storage.h
+++ b/library/cpp/coroutine/engine/stack/stack_storage.h
@@ -1,60 +1,60 @@
-#pragma once
-
-#include "stack.h"
-
-#include <util/datetime/base.h>
-#include <util/generic/deque.h>
-
-
-class TCont;
-
-namespace NCoro::NStack {
-
-    class IGuard;
-
-    class TStorage final : private TMoveOnly {
-    public:
-        TStorage(uint64_t stackSize, uint64_t rssPagesToKeep, uint64_t releaseRate);
-
-        bool IsEmpty() const noexcept;
-        uint64_t Size() const noexcept;
-
-        uint64_t GetReleasedSize() const noexcept { return Released_.size(); }
-        uint64_t GetFullSize() const noexcept { return Full_.size(); }
-
-        template<typename TGuard>
-        NDetails::TStack GetStack(const TGuard& guard, const char* name);
-        void ReturnStack(NDetails::TStack& stack);
-
-    private:
-        void ReleaseMemory(char* alignedStackMemory, uint64_t pagesToKeep) noexcept;
-
-    private:
-        TDeque<void*> Released_; //!< stacks memory with released RSS memory
-        TDeque<void*> Full_;     //!< stacks memory with RSS memory
-        uint64_t StackSize_ = 0;
-        uint64_t RssPagesToKeep_ = 0;
-        const uint64_t ReleaseRate_ = 1;
-    };
-
-
-    template<typename TGuard>
-    NDetails::TStack TStorage::GetStack(const TGuard& guard, const char* name) {
-        Y_VERIFY(!IsEmpty()); // check before call
-
-        void* newStack = nullptr;
-        if (!Full_.empty()) {
-            newStack = Full_.back();
-            Full_.pop_back();
-        } else {
-            Y_ASSERT(!Released_.empty());
-            newStack = Released_.back();
-            Released_.pop_back();
-        }
-
-        Y_VERIFY(guard.CheckOverflow(newStack), "corrupted stack in pool");
-        Y_VERIFY(guard.CheckOverride(newStack, StackSize_), "corrupted stack in pool");
-
-        return NDetails::TStack{newStack, newStack, StackSize_, name};
-    }
-}
+#pragma once 
+ 
+#include "stack.h" 
+ 
+#include <util/datetime/base.h> 
+#include <util/generic/deque.h> 
+ 
+ 
+class TCont; 
+ 
+namespace NCoro::NStack { 
+ 
+    class IGuard; 
+ 
+    class TStorage final : private TMoveOnly { 
+    public: 
+        TStorage(uint64_t stackSize, uint64_t rssPagesToKeep, uint64_t releaseRate); 
+ 
+        bool IsEmpty() const noexcept; 
+        uint64_t Size() const noexcept; 
+ 
+        uint64_t GetReleasedSize() const noexcept { return Released_.size(); } 
+        uint64_t GetFullSize() const noexcept { return Full_.size(); } 
+ 
+        template<typename TGuard> 
+        NDetails::TStack GetStack(const TGuard& guard, const char* name); 
+        void ReturnStack(NDetails::TStack& stack); 
+ 
+    private: 
+        void ReleaseMemory(char* alignedStackMemory, uint64_t pagesToKeep) noexcept; 
+ 
+    private: 
+        TDeque<void*> Released_; //!< stacks memory with released RSS memory 
+        TDeque<void*> Full_;     //!< stacks memory with RSS memory 
+        uint64_t StackSize_ = 0; 
+        uint64_t RssPagesToKeep_ = 0; 
+        const uint64_t ReleaseRate_ = 1; 
+    }; 
+ 
+ 
+    template<typename TGuard> 
+    NDetails::TStack TStorage::GetStack(const TGuard& guard, const char* name) { 
+        Y_VERIFY(!IsEmpty()); // check before call 
+ 
+        void* newStack = nullptr; 
+        if (!Full_.empty()) { 
+            newStack = Full_.back(); 
+            Full_.pop_back(); 
+        } else { 
+            Y_ASSERT(!Released_.empty()); 
+            newStack = Released_.back(); 
+            Released_.pop_back(); 
+        } 
+ 
+        Y_VERIFY(guard.CheckOverflow(newStack), "corrupted stack in pool"); 
+        Y_VERIFY(guard.CheckOverride(newStack, StackSize_), "corrupted stack in pool"); 
+ 
+        return NDetails::TStack{newStack, newStack, StackSize_, name}; 
+    } 
+} 
diff --git a/library/cpp/coroutine/engine/stack/stack_utils.cpp b/library/cpp/coroutine/engine/stack/stack_utils.cpp
index 1548529b66..ceeb3b50ec 100644
--- a/library/cpp/coroutine/engine/stack/stack_utils.cpp
+++ b/library/cpp/coroutine/engine/stack/stack_utils.cpp
@@ -1,84 +1,84 @@
-#include "stack_utils.h"
-
-#include <contrib/libs/linux-headers/asm-generic/errno-base.h>
-#include <util/generic/scope.h>
-#include <util/system/yassert.h>
-
-#ifdef _linux_
-#include <sys/mman.h>
-#endif
-
-#include <cerrno>
-#include <cstdlib>
-#include <cstring>
-
-
-namespace NCoro::NStack {
-
-#ifdef _linux_
-    bool GetAlignedMemory(uint64_t sizeInPages, char*& rawPtr, char*& alignedPtr) noexcept {
-        Y_ASSERT(sizeInPages);
-
-        void* ptr = nullptr;
-        int error = posix_memalign(&ptr, PageSize, sizeInPages * PageSize);
-        alignedPtr = rawPtr = (char*)ptr;
-        return rawPtr && alignedPtr && !error;
-    }
-#else
-    bool GetAlignedMemory(uint64_t sizeInPages, char*& rawPtr, char*& alignedPtr) noexcept {
-        Y_ASSERT(sizeInPages);
-
-        rawPtr = (char*) malloc((sizeInPages + 1) * PageSize); // +1 in case result would be unaligned
-        alignedPtr = (char*)( ((uint64_t)rawPtr + PageSize - 1) & ~PageSizeMask);
-        return rawPtr && alignedPtr;
-    }
-#endif
-
-#ifdef _linux_
-    void ReleaseRss(char* alignedPtr, uint64_t numOfPages) noexcept {
-        Y_VERIFY( !((uint64_t)alignedPtr & PageSizeMask), "Not aligned pointer to release RSS memory");
-        if (!numOfPages) {
-            return;
-        }
-        if (auto res = madvise((void*) alignedPtr, numOfPages * PageSize, MADV_DONTNEED); res) {
-            Y_VERIFY(errno == EAGAIN || errno == ENOMEM, "Failed to release memory");
-        }
-    }
-#else
-    void ReleaseRss(char*, uint64_t) noexcept {
-    }
-#endif
-
-#ifdef _linux_
-    uint64_t CountMapped(char* alignedPtr, uint64_t numOfPages) noexcept {
-        Y_VERIFY( !((uint64_t)alignedPtr & PageSizeMask) );
-        Y_ASSERT(numOfPages);
-
-        uint64_t result = 0;
-        unsigned char* mappedPages = (unsigned char*) calloc(numOfPages, numOfPages);
-        Y_VERIFY(mappedPages);
-        Y_DEFER {
-            free(mappedPages);
-        };
-
-        if (!mincore((void*)alignedPtr, numOfPages * PageSize, mappedPages)) {
-            for (uint64_t i = 0; i < numOfPages; ++i) {
-                if (mappedPages[i] & 1) {
-                    ++result;
-                }
-            }
-        } else {
-            Y_ASSERT(false);
-            return 0;
-        }
-
-        return result;
-    }
-
-#else
-    uint64_t CountMapped(char*, uint64_t) noexcept {
-        return 0; // stub for Windows tests
-    }
-#endif
-
-}
+#include "stack_utils.h" 
+ 
+#include <contrib/libs/linux-headers/asm-generic/errno-base.h> 
+#include <util/generic/scope.h> 
+#include <util/system/yassert.h> 
+ 
+#ifdef _linux_ 
+#include <sys/mman.h> 
+#endif 
+ 
+#include <cerrno> 
+#include <cstdlib> 
+#include <cstring> 
+ 
+ 
+namespace NCoro::NStack { 
+ 
+#ifdef _linux_ 
+    bool GetAlignedMemory(uint64_t sizeInPages, char*& rawPtr, char*& alignedPtr) noexcept { 
+        Y_ASSERT(sizeInPages); 
+ 
+        void* ptr = nullptr; 
+        int error = posix_memalign(&ptr, PageSize, sizeInPages * PageSize); 
+        alignedPtr = rawPtr = (char*)ptr; 
+        return rawPtr && alignedPtr && !error; 
+    } 
+#else 
+    bool GetAlignedMemory(uint64_t sizeInPages, char*& rawPtr, char*& alignedPtr) noexcept { 
+        Y_ASSERT(sizeInPages); 
+ 
+        rawPtr = (char*) malloc((sizeInPages + 1) * PageSize); // +1 in case result would be unaligned 
+        alignedPtr = (char*)( ((uint64_t)rawPtr + PageSize - 1) & ~PageSizeMask); 
+        return rawPtr && alignedPtr; 
+    } 
+#endif 
+ 
+#ifdef _linux_ 
+    void ReleaseRss(char* alignedPtr, uint64_t numOfPages) noexcept { 
+        Y_VERIFY( !((uint64_t)alignedPtr & PageSizeMask), "Not aligned pointer to release RSS memory"); 
+        if (!numOfPages) { 
+            return; 
+        } 
+        if (auto res = madvise((void*) alignedPtr, numOfPages * PageSize, MADV_DONTNEED); res) { 
+            Y_VERIFY(errno == EAGAIN || errno == ENOMEM, "Failed to release memory"); 
+        } 
+    } 
+#else 
+    void ReleaseRss(char*, uint64_t) noexcept { 
+    } 
+#endif 
+ 
+#ifdef _linux_ 
+    uint64_t CountMapped(char* alignedPtr, uint64_t numOfPages) noexcept { 
+        Y_VERIFY( !((uint64_t)alignedPtr & PageSizeMask) ); 
+        Y_ASSERT(numOfPages); 
+ 
+        uint64_t result = 0; 
+        unsigned char* mappedPages = (unsigned char*) calloc(numOfPages, numOfPages); 
+        Y_VERIFY(mappedPages); 
+        Y_DEFER { 
+            free(mappedPages); 
+        }; 
+ 
+        if (!mincore((void*)alignedPtr, numOfPages * PageSize, mappedPages)) { 
+            for (uint64_t i = 0; i < numOfPages; ++i) { 
+                if (mappedPages[i] & 1) { 
+                    ++result; 
+                } 
+            } 
+        } else { 
+            Y_ASSERT(false); 
+            return 0; 
+        } 
+ 
+        return result; 
+    } 
+ 
+#else 
+    uint64_t CountMapped(char*, uint64_t) noexcept { 
+        return 0; // stub for Windows tests 
+    } 
+#endif 
+ 
+} 
diff --git a/library/cpp/coroutine/engine/stack/stack_utils.h b/library/cpp/coroutine/engine/stack/stack_utils.h
index 46c65240b5..ba25cc38dc 100644
--- a/library/cpp/coroutine/engine/stack/stack_utils.h
+++ b/library/cpp/coroutine/engine/stack/stack_utils.h
@@ -1,27 +1,27 @@
-#pragma once
-
-#include "stack_common.h"
-
-
-namespace NCoro::NStack {
-    /*! Actual size of allocated memory can exceed size in pages, due to unaligned allocation.
-     * @param sizeInPages : number of pages to allocate
-     * @param rawPtr : pointer to unaligned memory. Should be passed to free() when is not used any more.
-     * @param alignedPtr : pointer to beginning of first fully allocated page
-     * @return : true on success
-     */
-    bool GetAlignedMemory(uint64_t sizeInPages, char*& rawPtr, char*& alignedPtr) noexcept;
-
-    /*! Release mapped RSS memory.
-     *  @param alignedPt : page-size aligned memory on which RSS memory should be freed
-     *  @param numOfPages : number of pages to free from RSS memory
-     */
-    void ReleaseRss(char* alignedPtr, uint64_t numOfPages) noexcept;
-
-    /*! Count pages with RSS memory
-     * @param alignedPtr : pointer to page-aligned memory for which calculations would be done
-     * @param numOfPages : number of pages to check
-     * @return : number of pages with RSS memory
-     */
-    uint64_t CountMapped(char* alignedPtr, uint64_t numOfPages) noexcept;
-}
+#pragma once 
+ 
+#include "stack_common.h" 
+ 
+ 
+namespace NCoro::NStack { 
+    /*! Actual size of allocated memory can exceed size in pages, due to unaligned allocation. 
+     * @param sizeInPages : number of pages to allocate 
+     * @param rawPtr : pointer to unaligned memory. Should be passed to free() when is not used any more. 
+     * @param alignedPtr : pointer to beginning of first fully allocated page 
+     * @return : true on success 
+     */ 
+    bool GetAlignedMemory(uint64_t sizeInPages, char*& rawPtr, char*& alignedPtr) noexcept; 
+ 
+    /*! Release mapped RSS memory. 
+     *  @param alignedPt : page-size aligned memory on which RSS memory should be freed 
+     *  @param numOfPages : number of pages to free from RSS memory 
+     */ 
+    void ReleaseRss(char* alignedPtr, uint64_t numOfPages) noexcept; 
+ 
+    /*! Count pages with RSS memory 
+     * @param alignedPtr : pointer to page-aligned memory for which calculations would be done 
+     * @param numOfPages : number of pages to check 
+     * @return : number of pages with RSS memory 
+     */ 
+    uint64_t CountMapped(char* alignedPtr, uint64_t numOfPages) noexcept; 
+} 
diff --git a/library/cpp/coroutine/engine/stack/ut/stack_allocator_ut.cpp b/library/cpp/coroutine/engine/stack/ut/stack_allocator_ut.cpp
index a7283d44a3..718dd2352e 100644
--- a/library/cpp/coroutine/engine/stack/ut/stack_allocator_ut.cpp
+++ b/library/cpp/coroutine/engine/stack/ut/stack_allocator_ut.cpp
@@ -1,115 +1,115 @@
-#include <library/cpp/coroutine/engine/stack/stack_allocator.h>
-#include <library/cpp/coroutine/engine/stack/stack_common.h>
-#include <library/cpp/testing/gtest/gtest.h>
-
-
-using namespace testing;
-
-namespace NCoro::NStack::Tests {
-
-    enum class EAllocator {
-        Pool,    // allocates page-size aligned stacks from pools
-        Simple  // uses malloc/free for each stack
-    };
-
-    class TAllocatorParamFixture : public TestWithParam< std::tuple<EGuard, EAllocator> > {
-    protected: // methods
-    void SetUp() override {
-        EGuard guardType;
-        EAllocator allocType;
-        std::tie(guardType, allocType) = GetParam();
-
-        TMaybe<TPoolAllocatorSettings> poolSettings;
-        if (allocType == EAllocator::Pool) {
-            poolSettings = TPoolAllocatorSettings{};
-        }
-
-        Allocator_ = GetAllocator(poolSettings, guardType);
-    }
-
-    protected: // data
-        THolder<IAllocator> Allocator_;
-    };
-
-
-    TEST_P(TAllocatorParamFixture, StackAllocationAndRelease) {
-        uint64_t stackSize = PageSize * 12;
-        auto stack = Allocator_->AllocStack(stackSize, "test_stack");
-#if defined(_san_enabled_) || !defined(NDEBUG)
-        stackSize *= DebugOrSanStackMultiplier;
-#endif
-
-        // Correct stack should have
-        EXPECT_EQ(stack.GetSize(), stackSize); // predefined size
-        EXPECT_FALSE((uint64_t)stack.GetAlignedMemory() & PageSizeMask); // aligned pointer
-        // Writable workspace
-        auto workspace = Allocator_->GetStackWorkspace(stack.GetAlignedMemory(), stack.GetSize());
-        for (uint64_t i = 0; i < workspace.size(); i += 512) {
-            workspace[i] = 42;
-        }
-        EXPECT_TRUE(Allocator_->CheckStackOverflow(stack.GetAlignedMemory()));
-        EXPECT_TRUE(Allocator_->CheckStackOverride(stack.GetAlignedMemory(), stack.GetSize()));
-
-        Allocator_->FreeStack(stack);
-        EXPECT_FALSE(stack.GetRawMemory());
-    }
-
-    INSTANTIATE_TEST_SUITE_P(AllocatorTestParams, TAllocatorParamFixture,
-            Combine(Values(EGuard::Canary, EGuard::Page), Values(EAllocator::Pool, EAllocator::Simple)));
-
-
-    // ------------------------------------------------------------------------
-    // Test that allocated stack has guards
-    //
-    template<class AllocatorType>
-    THolder<IAllocator> GetAllocator(EGuard guardType);
-
-    struct TPoolTag {};
-    struct TSimpleTag {};
-
-    template<>
-    THolder<IAllocator> GetAllocator<TPoolTag>(EGuard guardType) {
-        TMaybe<TPoolAllocatorSettings> poolSettings = TPoolAllocatorSettings{};
-        return GetAllocator(poolSettings, guardType);
-    }
-
-    template<>
-    THolder<IAllocator> GetAllocator<TSimpleTag>(EGuard guardType) {
-        TMaybe<TPoolAllocatorSettings> poolSettings;
-        return GetAllocator(poolSettings, guardType);
-    }
-
-
-    template <class AllocatorType>
-    class TAllocatorFixture : public Test {
-    protected:
-        TAllocatorFixture()
-            : Allocator_(GetAllocator<AllocatorType>(EGuard::Page))
-        {}
-
-        const uint64_t StackSize_ = PageSize * 2;
-        THolder<IAllocator> Allocator_;
-    };
-
-    typedef Types<TPoolTag, TSimpleTag> Implementations;
-    TYPED_TEST_SUITE(TAllocatorFixture, Implementations);
-
-    TYPED_TEST(TAllocatorFixture, StackOverflow) {
-        ASSERT_DEATH({
-            auto stack = this->Allocator_->AllocStack(this->StackSize_, "test_stack");
-
-            // Overwrite previous guard, crash is here
-            *(stack.GetAlignedMemory() - 1) = 42;
-        }, "");
-    }
-
-    TYPED_TEST(TAllocatorFixture, StackOverride) {
-        ASSERT_DEATH({
-            auto stack = this->Allocator_->AllocStack(this->StackSize_, "test_stack");
-
-            // Overwrite guard, crash is here
-            *(stack.GetAlignedMemory() + stack.GetSize() - 1) = 42;
-        }, "");
-    }
-
-}
+#include <library/cpp/coroutine/engine/stack/stack_allocator.h> 
+#include <library/cpp/coroutine/engine/stack/stack_common.h> 
+#include <library/cpp/testing/gtest/gtest.h> 
+ 
+ 
+using namespace testing; 
+ 
+namespace NCoro::NStack::Tests { 
+ 
+    enum class EAllocator { 
+        Pool,    // allocates page-size aligned stacks from pools 
+        Simple  // uses malloc/free for each stack 
+    }; 
+ 
+    class TAllocatorParamFixture : public TestWithParam< std::tuple<EGuard, EAllocator> > { 
+    protected: // methods 
+    void SetUp() override { 
+        EGuard guardType; 
+        EAllocator allocType; 
+        std::tie(guardType, allocType) = GetParam(); 
+ 
+        TMaybe<TPoolAllocatorSettings> poolSettings; 
+        if (allocType == EAllocator::Pool) { 
+            poolSettings = TPoolAllocatorSettings{}; 
+        } 
+ 
+        Allocator_ = GetAllocator(poolSettings, guardType); 
+    } 
+ 
+    protected: // data 
+        THolder<IAllocator> Allocator_; 
+    }; 
+ 
+ 
+    TEST_P(TAllocatorParamFixture, StackAllocationAndRelease) { 
+        uint64_t stackSize = PageSize * 12; 
+        auto stack = Allocator_->AllocStack(stackSize, "test_stack"); 
+#if defined(_san_enabled_) || !defined(NDEBUG) 
+        stackSize *= DebugOrSanStackMultiplier; 
+#endif 
+ 
+        // Correct stack should have 
+        EXPECT_EQ(stack.GetSize(), stackSize); // predefined size 
+        EXPECT_FALSE((uint64_t)stack.GetAlignedMemory() & PageSizeMask); // aligned pointer 
+        // Writable workspace 
+        auto workspace = Allocator_->GetStackWorkspace(stack.GetAlignedMemory(), stack.GetSize()); 
+        for (uint64_t i = 0; i < workspace.size(); i += 512) { 
+            workspace[i] = 42; 
+        } 
+        EXPECT_TRUE(Allocator_->CheckStackOverflow(stack.GetAlignedMemory())); 
+        EXPECT_TRUE(Allocator_->CheckStackOverride(stack.GetAlignedMemory(), stack.GetSize())); 
+ 
+        Allocator_->FreeStack(stack); 
+        EXPECT_FALSE(stack.GetRawMemory()); 
+    } 
+ 
+    INSTANTIATE_TEST_SUITE_P(AllocatorTestParams, TAllocatorParamFixture, 
+            Combine(Values(EGuard::Canary, EGuard::Page), Values(EAllocator::Pool, EAllocator::Simple))); 
+ 
+ 
+    // ------------------------------------------------------------------------ 
+    // Test that allocated stack has guards 
+    // 
+    template<class AllocatorType> 
+    THolder<IAllocator> GetAllocator(EGuard guardType); 
+ 
+    struct TPoolTag {}; 
+    struct TSimpleTag {}; 
+ 
+    template<> 
+    THolder<IAllocator> GetAllocator<TPoolTag>(EGuard guardType) { 
+        TMaybe<TPoolAllocatorSettings> poolSettings = TPoolAllocatorSettings{}; 
+        return GetAllocator(poolSettings, guardType); 
+    } 
+ 
+    template<> 
+    THolder<IAllocator> GetAllocator<TSimpleTag>(EGuard guardType) { 
+        TMaybe<TPoolAllocatorSettings> poolSettings; 
+        return GetAllocator(poolSettings, guardType); 
+    } 
+ 
+ 
+    template <class AllocatorType> 
+    class TAllocatorFixture : public Test { 
+    protected: 
+        TAllocatorFixture() 
+            : Allocator_(GetAllocator<AllocatorType>(EGuard::Page)) 
+        {} 
+ 
+        const uint64_t StackSize_ = PageSize * 2; 
+        THolder<IAllocator> Allocator_; 
+    }; 
+ 
+    typedef Types<TPoolTag, TSimpleTag> Implementations; 
+    TYPED_TEST_SUITE(TAllocatorFixture, Implementations); 
+ 
+    TYPED_TEST(TAllocatorFixture, StackOverflow) { 
+        ASSERT_DEATH({ 
+            auto stack = this->Allocator_->AllocStack(this->StackSize_, "test_stack"); 
+ 
+            // Overwrite previous guard, crash is here 
+            *(stack.GetAlignedMemory() - 1) = 42; 
+        }, ""); 
+    } 
+ 
+    TYPED_TEST(TAllocatorFixture, StackOverride) { 
+        ASSERT_DEATH({ 
+            auto stack = this->Allocator_->AllocStack(this->StackSize_, "test_stack"); 
+ 
+            // Overwrite guard, crash is here 
+            *(stack.GetAlignedMemory() + stack.GetSize() - 1) = 42; 
+        }, ""); 
+    } 
+ 
+} 
diff --git a/library/cpp/coroutine/engine/stack/ut/stack_guards_ut.cpp b/library/cpp/coroutine/engine/stack/ut/stack_guards_ut.cpp
index 9da9a9b3d5..6b1a18d9ad 100644
--- a/library/cpp/coroutine/engine/stack/ut/stack_guards_ut.cpp
+++ b/library/cpp/coroutine/engine/stack/ut/stack_guards_ut.cpp
@@ -1,158 +1,158 @@
-#include <library/cpp/coroutine/engine/stack/stack_common.h>
-#include <library/cpp/coroutine/engine/stack/stack_guards.h>
-#include <library/cpp/coroutine/engine/stack/stack_utils.h>
-#include <library/cpp/testing/gtest/gtest.h>
-
-
-using namespace testing;
-
-namespace NCoro::NStack::Tests {
-
-    template <class TGuard>
-    class TGuardFixture : public Test {
-    protected:
-        TGuardFixture() : Guard_(GetGuard<TGuard>()) {}
-
-        const TGuard& Guard_;
-    };
-
-    typedef Types<TCanaryGuard, TPageGuard> Implementations;
-    TYPED_TEST_SUITE(TGuardFixture, Implementations);
-
-    TYPED_TEST(TGuardFixture, GuardSize) {
-        const auto size = this->Guard_.GetSize();
-        EXPECT_GE(size, 64ul);
-        EXPECT_FALSE(size & 63ul); // check 64-byte alignment
-    }
-
-    TYPED_TEST(TGuardFixture, GuardAlignedSize) {
-        const auto size = this->Guard_.GetPageAlignedSize();
-        EXPECT_GE(size, PageSize);
-        EXPECT_FALSE(size & PageSizeMask); // check page-alignment
-    }
-
-    TYPED_TEST(TGuardFixture, StackWorkspace) {
-        for (uint64_t sizeInPages : {2, 5, 12}) {
-            char *rawPtr, *alignedPtr = nullptr;
-            ASSERT_TRUE(GetAlignedMemory(sizeInPages, rawPtr, alignedPtr));
-            auto workspace = this->Guard_.GetWorkspace(alignedPtr, sizeInPages * PageSize);
-            EXPECT_EQ(workspace.size(), sizeInPages * PageSize - this->Guard_.GetSize()) << " size in pages " << sizeInPages;
-
-            this->Guard_.Protect(alignedPtr, sizeInPages * PageSize, false);
-            workspace = this->Guard_.GetWorkspace(alignedPtr, sizeInPages * PageSize);
-            EXPECT_EQ(workspace.size(), sizeInPages * PageSize - this->Guard_.GetSize()) << " size in pages " << sizeInPages;
-
-            this->Guard_.RemoveProtection(alignedPtr, sizeInPages * PageSize);
-            workspace = this->Guard_.GetWorkspace(alignedPtr, sizeInPages * PageSize);
-            EXPECT_EQ(workspace.size(), sizeInPages * PageSize - this->Guard_.GetSize()) << " size in pages " << sizeInPages;
-
-            free(rawPtr);
-        }
-    }
-
-    TYPED_TEST(TGuardFixture, SetRemoveProtectionWorks) {
-        char *rawPtr, *alignedPtr = nullptr;
-        constexpr uint64_t sizeInPages = 4;
-        ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr));
-
-        this->Guard_.Protect(alignedPtr, PageSize, false); // set previous guard
-        alignedPtr += PageSize; // leave first page for previous guard
-        this->Guard_.Protect(alignedPtr, sizeInPages * PageSize, true);
-
-        EXPECT_TRUE(this->Guard_.CheckOverflow(alignedPtr));
-        EXPECT_TRUE(this->Guard_.CheckOverride(alignedPtr, sizeInPages * PageSize));
-
-        this->Guard_.RemoveProtection(alignedPtr, sizeInPages * PageSize);
-        this->Guard_.RemoveProtection(alignedPtr - PageSize, PageSize); // remove previous guard
-
-        free(rawPtr);
-    }
-
-    TEST(StackGuardTest, CanaryGuardTestOverflow) {
-        const auto& guard = GetGuard<TCanaryGuard>();
-
-        char *rawPtr, *alignedPtr = nullptr;
-        constexpr uint64_t sizeInPages = 4;
-        ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr));
-        guard.Protect(alignedPtr, PageSize, false); // set previous guard
-        alignedPtr += PageSize; // leave first page for previous guard
-        guard.Protect(alignedPtr, sizeInPages * PageSize, true);
-
-        EXPECT_TRUE(guard.CheckOverflow(alignedPtr));
-        EXPECT_TRUE(guard.CheckOverride(alignedPtr, sizeInPages * PageSize));
-
-        // Overwrite previous guard
-        *(alignedPtr - 1) = 42;
-
-        EXPECT_FALSE(guard.CheckOverflow(alignedPtr));
-
-        free(rawPtr);
-    }
-
-    TEST(StackGuardTest, CanaryGuardTestOverride) {
-        const auto& guard = GetGuard<TCanaryGuard>();
-
-        char *rawPtr, *alignedPtr = nullptr;
-        constexpr uint64_t sizeInPages = 4;
-        ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr));
-        guard.Protect(alignedPtr, PageSize, false); // set previous guard
-        alignedPtr += PageSize; // leave first page for previous guard
-        guard.Protect(alignedPtr, sizeInPages * PageSize, true);
-
-        EXPECT_TRUE(guard.CheckOverflow(alignedPtr));
-        EXPECT_TRUE(guard.CheckOverride(alignedPtr, sizeInPages * PageSize));
-
-        // Overwrite guard
-        *(alignedPtr + sizeInPages * PageSize - 1) = 42;
-
-        EXPECT_FALSE(guard.CheckOverride(alignedPtr, sizeInPages * PageSize));
-
-        free(rawPtr);
-    }
-
-    TEST(StackGuardDeathTest, PageGuardTestOverflow) {
-        ASSERT_DEATH({
-            const auto &guard = GetGuard<TPageGuard>();
-
-            char* rawPtr = nullptr;
-            char* alignedPtr = nullptr;
-            constexpr uint64_t sizeInPages = 4;
-            ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr));
-
-            guard.Protect(alignedPtr, PageSize, false); // set previous guard
-            alignedPtr += PageSize; // leave first page for previous guard
-            guard.Protect(alignedPtr, sizeInPages * PageSize, true);
-
-            // Overwrite previous guard, crash is here
-            *(alignedPtr - 1) = 42;
-
-            guard.RemoveProtection(alignedPtr, sizeInPages * PageSize);
-            guard.RemoveProtection(alignedPtr - PageSize, PageSize); // remove previous guard
-
-            free(rawPtr);
-        }, "");
-    }
-
-    TEST(StackGuardDeathTest, PageGuardTestOverride) {
-        ASSERT_DEATH({
-            const auto &guard = GetGuard<TPageGuard>();
-
-            char* rawPtr = nullptr;
-            char* alignedPtr = nullptr;
-            constexpr uint64_t sizeInPages = 4;
-            ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr));
-            guard.Protect(alignedPtr, PageSize, false); // set previous guard
-            alignedPtr += PageSize; // leave first page for previous guard
-            guard.Protect(alignedPtr, sizeInPages * PageSize, true);
-
-            // Overwrite guard, crash is here
-            *(alignedPtr + sizeInPages * PageSize - 1) = 42;
-
-            guard.RemoveProtection(alignedPtr, sizeInPages * PageSize);
-            guard.RemoveProtection(alignedPtr - PageSize, PageSize); // remove previous guard
-
-            free(rawPtr);
-        }, "");
-    }
-
-}
+#include <library/cpp/coroutine/engine/stack/stack_common.h> 
+#include <library/cpp/coroutine/engine/stack/stack_guards.h> 
+#include <library/cpp/coroutine/engine/stack/stack_utils.h> 
+#include <library/cpp/testing/gtest/gtest.h> 
+ 
+ 
+using namespace testing; 
+ 
+namespace NCoro::NStack::Tests { 
+ 
+    template <class TGuard> 
+    class TGuardFixture : public Test { 
+    protected: 
+        TGuardFixture() : Guard_(GetGuard<TGuard>()) {} 
+ 
+        const TGuard& Guard_; 
+    }; 
+ 
+    typedef Types<TCanaryGuard, TPageGuard> Implementations; 
+    TYPED_TEST_SUITE(TGuardFixture, Implementations); 
+ 
+    TYPED_TEST(TGuardFixture, GuardSize) { 
+        const auto size = this->Guard_.GetSize(); 
+        EXPECT_GE(size, 64ul); 
+        EXPECT_FALSE(size & 63ul); // check 64-byte alignment 
+    } 
+ 
+    TYPED_TEST(TGuardFixture, GuardAlignedSize) { 
+        const auto size = this->Guard_.GetPageAlignedSize(); 
+        EXPECT_GE(size, PageSize); 
+        EXPECT_FALSE(size & PageSizeMask); // check page-alignment 
+    } 
+ 
+    TYPED_TEST(TGuardFixture, StackWorkspace) { 
+        for (uint64_t sizeInPages : {2, 5, 12}) { 
+            char *rawPtr, *alignedPtr = nullptr; 
+            ASSERT_TRUE(GetAlignedMemory(sizeInPages, rawPtr, alignedPtr)); 
+            auto workspace = this->Guard_.GetWorkspace(alignedPtr, sizeInPages * PageSize); 
+            EXPECT_EQ(workspace.size(), sizeInPages * PageSize - this->Guard_.GetSize()) << " size in pages " << sizeInPages; 
+ 
+            this->Guard_.Protect(alignedPtr, sizeInPages * PageSize, false); 
+            workspace = this->Guard_.GetWorkspace(alignedPtr, sizeInPages * PageSize); 
+            EXPECT_EQ(workspace.size(), sizeInPages * PageSize - this->Guard_.GetSize()) << " size in pages " << sizeInPages; 
+ 
+            this->Guard_.RemoveProtection(alignedPtr, sizeInPages * PageSize); 
+            workspace = this->Guard_.GetWorkspace(alignedPtr, sizeInPages * PageSize); 
+            EXPECT_EQ(workspace.size(), sizeInPages * PageSize - this->Guard_.GetSize()) << " size in pages " << sizeInPages; 
+ 
+            free(rawPtr); 
+        } 
+    } 
+ 
+    TYPED_TEST(TGuardFixture, SetRemoveProtectionWorks) { 
+        char *rawPtr, *alignedPtr = nullptr; 
+        constexpr uint64_t sizeInPages = 4; 
+        ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr)); 
+ 
+        this->Guard_.Protect(alignedPtr, PageSize, false); // set previous guard 
+        alignedPtr += PageSize; // leave first page for previous guard 
+        this->Guard_.Protect(alignedPtr, sizeInPages * PageSize, true); 
+ 
+        EXPECT_TRUE(this->Guard_.CheckOverflow(alignedPtr)); 
+        EXPECT_TRUE(this->Guard_.CheckOverride(alignedPtr, sizeInPages * PageSize)); 
+ 
+        this->Guard_.RemoveProtection(alignedPtr, sizeInPages * PageSize); 
+        this->Guard_.RemoveProtection(alignedPtr - PageSize, PageSize); // remove previous guard 
+ 
+        free(rawPtr); 
+    } 
+ 
+    TEST(StackGuardTest, CanaryGuardTestOverflow) { 
+        const auto& guard = GetGuard<TCanaryGuard>(); 
+ 
+        char *rawPtr, *alignedPtr = nullptr; 
+        constexpr uint64_t sizeInPages = 4; 
+        ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr)); 
+        guard.Protect(alignedPtr, PageSize, false); // set previous guard 
+        alignedPtr += PageSize; // leave first page for previous guard 
+        guard.Protect(alignedPtr, sizeInPages * PageSize, true); 
+ 
+        EXPECT_TRUE(guard.CheckOverflow(alignedPtr)); 
+        EXPECT_TRUE(guard.CheckOverride(alignedPtr, sizeInPages * PageSize)); 
+ 
+        // Overwrite previous guard 
+        *(alignedPtr - 1) = 42; 
+ 
+        EXPECT_FALSE(guard.CheckOverflow(alignedPtr)); 
+ 
+        free(rawPtr); 
+    } 
+ 
+    TEST(StackGuardTest, CanaryGuardTestOverride) { 
+        const auto& guard = GetGuard<TCanaryGuard>(); 
+ 
+        char *rawPtr, *alignedPtr = nullptr; 
+        constexpr uint64_t sizeInPages = 4; 
+        ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr)); 
+        guard.Protect(alignedPtr, PageSize, false); // set previous guard 
+        alignedPtr += PageSize; // leave first page for previous guard 
+        guard.Protect(alignedPtr, sizeInPages * PageSize, true); 
+ 
+        EXPECT_TRUE(guard.CheckOverflow(alignedPtr)); 
+        EXPECT_TRUE(guard.CheckOverride(alignedPtr, sizeInPages * PageSize)); 
+ 
+        // Overwrite guard 
+        *(alignedPtr + sizeInPages * PageSize - 1) = 42; 
+ 
+        EXPECT_FALSE(guard.CheckOverride(alignedPtr, sizeInPages * PageSize)); 
+ 
+        free(rawPtr); 
+    } 
+ 
+    TEST(StackGuardDeathTest, PageGuardTestOverflow) { 
+        ASSERT_DEATH({ 
+            const auto &guard = GetGuard<TPageGuard>(); 
+ 
+            char* rawPtr = nullptr; 
+            char* alignedPtr = nullptr; 
+            constexpr uint64_t sizeInPages = 4; 
+            ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr)); 
+ 
+            guard.Protect(alignedPtr, PageSize, false); // set previous guard 
+            alignedPtr += PageSize; // leave first page for previous guard 
+            guard.Protect(alignedPtr, sizeInPages * PageSize, true); 
+ 
+            // Overwrite previous guard, crash is here 
+            *(alignedPtr - 1) = 42; 
+ 
+            guard.RemoveProtection(alignedPtr, sizeInPages * PageSize); 
+            guard.RemoveProtection(alignedPtr - PageSize, PageSize); // remove previous guard 
+ 
+            free(rawPtr); 
+        }, ""); 
+    } 
+ 
+    TEST(StackGuardDeathTest, PageGuardTestOverride) { 
+        ASSERT_DEATH({ 
+            const auto &guard = GetGuard<TPageGuard>(); 
+ 
+            char* rawPtr = nullptr; 
+            char* alignedPtr = nullptr; 
+            constexpr uint64_t sizeInPages = 4; 
+            ASSERT_TRUE(GetAlignedMemory(sizeInPages + 1, rawPtr, alignedPtr)); 
+            guard.Protect(alignedPtr, PageSize, false); // set previous guard 
+            alignedPtr += PageSize; // leave first page for previous guard 
+            guard.Protect(alignedPtr, sizeInPages * PageSize, true); 
+ 
+            // Overwrite guard, crash is here 
+            *(alignedPtr + sizeInPages * PageSize - 1) = 42; 
+ 
+            guard.RemoveProtection(alignedPtr, sizeInPages * PageSize); 
+            guard.RemoveProtection(alignedPtr - PageSize, PageSize); // remove previous guard 
+ 
+            free(rawPtr); 
+        }, ""); 
+    } 
+ 
+} 
diff --git a/library/cpp/coroutine/engine/stack/ut/stack_pool_ut.cpp b/library/cpp/coroutine/engine/stack/ut/stack_pool_ut.cpp
index 9e3e5e7117..6a2f730c03 100644
--- a/library/cpp/coroutine/engine/stack/ut/stack_pool_ut.cpp
+++ b/library/cpp/coroutine/engine/stack/ut/stack_pool_ut.cpp
@@ -1,70 +1,70 @@
-#include <library/cpp/coroutine/engine/stack/stack_common.h>
-#include <library/cpp/coroutine/engine/stack/stack_guards.h>
-#include <library/cpp/coroutine/engine/stack/stack_pool.h>
-#include <library/cpp/testing/gtest/gtest.h>
-
-
-using namespace testing;
-
-namespace NCoro::NStack::Tests {
-
-    template <class TGuard>
-    class TPoolFixture : public Test {
-    protected:
-        TPoolFixture() : Guard_(GetGuard<TGuard>()), Pool_(StackSize_, TPoolAllocatorSettings{1, 1, 8, 32}, Guard_) {}
-
-        const uint64_t StackSize_ = PageSize * 4;
-        const TGuard& Guard_;
-        TPool<TGuard> Pool_;
-    };
-
-    typedef Types<TCanaryGuard, TPageGuard> Implementations;
-    TYPED_TEST_SUITE(TPoolFixture, Implementations);
-
-    TYPED_TEST(TPoolFixture, AllocAndFreeStack) {
-        auto stack = this->Pool_.AllocStack("test_stack");
-        this->Pool_.FreeStack(stack);
-        EXPECT_FALSE(stack.GetRawMemory());
-    }
-
-    TYPED_TEST(TPoolFixture, FreedStackReused) {
-        auto stack = this->Pool_.AllocStack("test_stack");
-        auto rawPtr = stack.GetRawMemory();
-        auto alignedPtr = stack.GetAlignedMemory();
-
-        this->Pool_.FreeStack(stack);
-        EXPECT_FALSE(stack.GetRawMemory());
-
-        auto stack2 = this->Pool_.AllocStack("test_stack");
-        EXPECT_EQ(rawPtr, stack2.GetRawMemory());
-        EXPECT_EQ(alignedPtr, stack2.GetAlignedMemory());
-
-        this->Pool_.FreeStack(stack2);
-        EXPECT_FALSE(stack2.GetRawMemory());
-    }
-
-    TYPED_TEST(TPoolFixture, MruFreedStackReused) {
-        auto stack = this->Pool_.AllocStack("test_stack");
-        auto rawPtr = stack.GetRawMemory();
-        auto alignedPtr = stack.GetAlignedMemory();
-        auto stack2 = this->Pool_.AllocStack("test_stack");
-        auto stack3 = this->Pool_.AllocStack("test_stack");
-
-        this->Pool_.FreeStack(stack2);
-        EXPECT_FALSE(stack2.GetRawMemory());
-
-        this->Pool_.FreeStack(stack);
-        EXPECT_FALSE(stack.GetRawMemory());
-
-        auto stack4 = this->Pool_.AllocStack("test_stack");
-        EXPECT_EQ(rawPtr, stack4.GetRawMemory());
-        EXPECT_EQ(alignedPtr, stack4.GetAlignedMemory());
-
-        this->Pool_.FreeStack(stack3);
-        EXPECT_FALSE(stack.GetRawMemory());
-
-        this->Pool_.FreeStack(stack4);
-        EXPECT_FALSE(stack4.GetRawMemory());
-    }
-
-}
+#include <library/cpp/coroutine/engine/stack/stack_common.h> 
+#include <library/cpp/coroutine/engine/stack/stack_guards.h> 
+#include <library/cpp/coroutine/engine/stack/stack_pool.h> 
+#include <library/cpp/testing/gtest/gtest.h> 
+ 
+ 
+using namespace testing; 
+ 
+namespace NCoro::NStack::Tests { 
+ 
+    template <class TGuard> 
+    class TPoolFixture : public Test { 
+    protected: 
+        TPoolFixture() : Guard_(GetGuard<TGuard>()), Pool_(StackSize_, TPoolAllocatorSettings{1, 1, 8, 32}, Guard_) {} 
+ 
+        const uint64_t StackSize_ = PageSize * 4; 
+        const TGuard& Guard_; 
+        TPool<TGuard> Pool_; 
+    }; 
+ 
+    typedef Types<TCanaryGuard, TPageGuard> Implementations; 
+    TYPED_TEST_SUITE(TPoolFixture, Implementations); 
+ 
+    TYPED_TEST(TPoolFixture, AllocAndFreeStack) { 
+        auto stack = this->Pool_.AllocStack("test_stack"); 
+        this->Pool_.FreeStack(stack); 
+        EXPECT_FALSE(stack.GetRawMemory()); 
+    } 
+ 
+    TYPED_TEST(TPoolFixture, FreedStackReused) { 
+        auto stack = this->Pool_.AllocStack("test_stack"); 
+        auto rawPtr = stack.GetRawMemory(); 
+        auto alignedPtr = stack.GetAlignedMemory(); 
+ 
+        this->Pool_.FreeStack(stack); 
+        EXPECT_FALSE(stack.GetRawMemory()); 
+ 
+        auto stack2 = this->Pool_.AllocStack("test_stack"); 
+        EXPECT_EQ(rawPtr, stack2.GetRawMemory()); 
+        EXPECT_EQ(alignedPtr, stack2.GetAlignedMemory()); 
+ 
+        this->Pool_.FreeStack(stack2); 
+        EXPECT_FALSE(stack2.GetRawMemory()); 
+    } 
+ 
+    TYPED_TEST(TPoolFixture, MruFreedStackReused) { 
+        auto stack = this->Pool_.AllocStack("test_stack"); 
+        auto rawPtr = stack.GetRawMemory(); 
+        auto alignedPtr = stack.GetAlignedMemory(); 
+        auto stack2 = this->Pool_.AllocStack("test_stack"); 
+        auto stack3 = this->Pool_.AllocStack("test_stack"); 
+ 
+        this->Pool_.FreeStack(stack2); 
+        EXPECT_FALSE(stack2.GetRawMemory()); 
+ 
+        this->Pool_.FreeStack(stack); 
+        EXPECT_FALSE(stack.GetRawMemory()); 
+ 
+        auto stack4 = this->Pool_.AllocStack("test_stack"); 
+        EXPECT_EQ(rawPtr, stack4.GetRawMemory()); 
+        EXPECT_EQ(alignedPtr, stack4.GetAlignedMemory()); 
+ 
+        this->Pool_.FreeStack(stack3); 
+        EXPECT_FALSE(stack.GetRawMemory()); 
+ 
+        this->Pool_.FreeStack(stack4); 
+        EXPECT_FALSE(stack4.GetRawMemory()); 
+    } 
+ 
+} 
diff --git a/library/cpp/coroutine/engine/stack/ut/stack_ut.cpp b/library/cpp/coroutine/engine/stack/ut/stack_ut.cpp
index 31f8ad6b61..a41fc6c940 100644
--- a/library/cpp/coroutine/engine/stack/ut/stack_ut.cpp
+++ b/library/cpp/coroutine/engine/stack/ut/stack_ut.cpp
@@ -1,60 +1,60 @@
-#include <library/cpp/coroutine/engine/stack/stack.h>
-#include <library/cpp/coroutine/engine/stack/stack_common.h>
-#include <library/cpp/coroutine/engine/stack/stack_guards.h>
-#include <library/cpp/coroutine/engine/stack/stack_utils.h>
-#include <library/cpp/testing/gtest/gtest.h>
-
-
-using namespace testing;
-
-namespace NCoro::NStack::Tests {
-
-    constexpr uint64_t StackSizeInPages = 4;
-
-    template <class TGuard>
-    class TStackFixture : public Test {
-    protected: // methods
-        TStackFixture()
-            : Guard_(GetGuard<TGuard>())
-            , StackSize_(StackSizeInPages * PageSize)
-        {}
-
-        void SetUp() override {
-            ASSERT_TRUE(GetAlignedMemory(StackSizeInPages, RawMemory_, AlignedMemory_));
-            Stack_ = MakeHolder<NDetails::TStack>(RawMemory_, AlignedMemory_, StackSize_, "test_stack");
-            Guard_.Protect(AlignedMemory_, StackSize_, false);
-        }
-
-        void TearDown() override {
-            Guard_.RemoveProtection(AlignedMemory_, StackSize_);
-            free(Stack_->GetRawMemory());
-            Stack_->Reset();
-            EXPECT_EQ(Stack_->GetRawMemory(), nullptr);
-        }
-
-    protected: // data
-        const TGuard& Guard_;
-        const uint64_t StackSize_ = 0;
-        char* RawMemory_ = nullptr;
-        char* AlignedMemory_ = nullptr;
-        THolder<NDetails::TStack> Stack_;
-    };
-
-    typedef Types<TCanaryGuard, TPageGuard> Implementations;
-    TYPED_TEST_SUITE(TStackFixture, Implementations);
-
-    TYPED_TEST(TStackFixture, PointersAndSize) {
-        EXPECT_EQ(this->Stack_->GetRawMemory(), this->RawMemory_);
-        EXPECT_EQ(this->Stack_->GetAlignedMemory(), this->AlignedMemory_);
-        EXPECT_EQ(this->Stack_->GetSize(), this->StackSize_);
-    }
-
-    TYPED_TEST(TStackFixture, WriteStack) {
-        auto workspace = this->Guard_.GetWorkspace(this->Stack_->GetAlignedMemory(), this->Stack_->GetSize());
-        for (uint64_t i = 0; i < workspace.size(); i += 512) {
-            workspace[i] = 42;
-        }
-        EXPECT_TRUE(this->Guard_.CheckOverride(this->Stack_->GetAlignedMemory(), this->Stack_->GetSize()));
-    }
-
-}
+#include <library/cpp/coroutine/engine/stack/stack.h> 
+#include <library/cpp/coroutine/engine/stack/stack_common.h> 
+#include <library/cpp/coroutine/engine/stack/stack_guards.h> 
+#include <library/cpp/coroutine/engine/stack/stack_utils.h> 
+#include <library/cpp/testing/gtest/gtest.h> 
+ 
+ 
+using namespace testing; 
+ 
+namespace NCoro::NStack::Tests { 
+ 
+    constexpr uint64_t StackSizeInPages = 4; 
+ 
+    template <class TGuard> 
+    class TStackFixture : public Test { 
+    protected: // methods 
+        TStackFixture() 
+            : Guard_(GetGuard<TGuard>()) 
+            , StackSize_(StackSizeInPages * PageSize) 
+        {} 
+ 
+        void SetUp() override { 
+            ASSERT_TRUE(GetAlignedMemory(StackSizeInPages, RawMemory_, AlignedMemory_)); 
+            Stack_ = MakeHolder<NDetails::TStack>(RawMemory_, AlignedMemory_, StackSize_, "test_stack"); 
+            Guard_.Protect(AlignedMemory_, StackSize_, false); 
+        } 
+ 
+        void TearDown() override { 
+            Guard_.RemoveProtection(AlignedMemory_, StackSize_); 
+            free(Stack_->GetRawMemory()); 
+            Stack_->Reset(); 
+            EXPECT_EQ(Stack_->GetRawMemory(), nullptr); 
+        } 
+ 
+    protected: // data 
+        const TGuard& Guard_; 
+        const uint64_t StackSize_ = 0; 
+        char* RawMemory_ = nullptr; 
+        char* AlignedMemory_ = nullptr; 
+        THolder<NDetails::TStack> Stack_; 
+    }; 
+ 
+    typedef Types<TCanaryGuard, TPageGuard> Implementations; 
+    TYPED_TEST_SUITE(TStackFixture, Implementations); 
+ 
+    TYPED_TEST(TStackFixture, PointersAndSize) { 
+        EXPECT_EQ(this->Stack_->GetRawMemory(), this->RawMemory_); 
+        EXPECT_EQ(this->Stack_->GetAlignedMemory(), this->AlignedMemory_); 
+        EXPECT_EQ(this->Stack_->GetSize(), this->StackSize_); 
+    } 
+ 
+    TYPED_TEST(TStackFixture, WriteStack) { 
+        auto workspace = this->Guard_.GetWorkspace(this->Stack_->GetAlignedMemory(), this->Stack_->GetSize()); 
+        for (uint64_t i = 0; i < workspace.size(); i += 512) { 
+            workspace[i] = 42; 
+        } 
+        EXPECT_TRUE(this->Guard_.CheckOverride(this->Stack_->GetAlignedMemory(), this->Stack_->GetSize())); 
+    } 
+ 
+} 
diff --git a/library/cpp/coroutine/engine/stack/ut/stack_utils_ut.cpp b/library/cpp/coroutine/engine/stack/ut/stack_utils_ut.cpp
index dc0593dcf2..90e5d94b68 100644
--- a/library/cpp/coroutine/engine/stack/ut/stack_utils_ut.cpp
+++ b/library/cpp/coroutine/engine/stack/ut/stack_utils_ut.cpp
@@ -1,73 +1,73 @@
-#include <library/cpp/coroutine/engine/stack/stack_common.h>
-#include <library/cpp/coroutine/engine/stack/stack_utils.h>
-#include <library/cpp/testing/gtest/gtest.h>
-
-
-using namespace testing;
-
-namespace NCoro::NStack::Tests {
-
-    TEST(StackUtilsTest, Allocation) {
-        char *rawPtr, *alignedPtr = nullptr;
-        for (uint64_t i : {1, 2, 3, 4, 11}) {
-            EXPECT_TRUE(GetAlignedMemory(i, rawPtr, alignedPtr));
-            EXPECT_TRUE(rawPtr);
-            EXPECT_TRUE(alignedPtr);
-            EXPECT_FALSE((uint64_t)alignedPtr & PageSizeMask);
-            free(rawPtr);
-        }
-    }
-
-#if !defined(_san_enabled_) && defined(_linux_)
-
-    TEST(StackUtilsTest, RssReleaseOnePage) {
-        char *rawPtr, *alignedPtr = nullptr;
-        for (uint64_t i : {1, 2, 8}) {
-            EXPECT_TRUE(GetAlignedMemory(i, rawPtr, alignedPtr));
-            EXPECT_TRUE(rawPtr);
-            EXPECT_TRUE(alignedPtr);
-            EXPECT_FALSE((uint64_t)alignedPtr & PageSizeMask);
-
-            ReleaseRss(alignedPtr, i); // allocator can provide reused memory with RSS memory on it
-            EXPECT_EQ(CountMapped(alignedPtr, i), 0ul); // no RSS memory allocated
-
-            *(alignedPtr + (i - 1) * PageSize) = 42; // map RSS memory
-            EXPECT_EQ(CountMapped(alignedPtr, i), 1ul);
-
-            ReleaseRss(alignedPtr, i);
-            EXPECT_EQ(CountMapped(alignedPtr, i), 0ul) << "number of pages " << i; // no RSS memory allocated
-
-            free(rawPtr);
-        }
-    }
-
-    TEST(StackUtilsTest, RssReleaseSeveralPages) {
-        char *rawPtr, *alignedPtr = nullptr;
-
-        for (uint64_t i : {1, 2, 5, 8}) {
-            EXPECT_TRUE(GetAlignedMemory(i, rawPtr, alignedPtr));
-            EXPECT_TRUE(rawPtr);
-            EXPECT_TRUE(alignedPtr);
-            EXPECT_FALSE((uint64_t)alignedPtr & PageSizeMask);
-
-            ReleaseRss(alignedPtr, i); // allocator can provide reused memory with RSS memory on it
-            EXPECT_EQ(CountMapped(alignedPtr, i), 0ul); // no RSS memory allocated
-
-            for (uint64_t page = 0; page < i; ++page) {
-                *(alignedPtr + page * PageSize) = 42; // map RSS memory
-                EXPECT_EQ(CountMapped(alignedPtr, page + 1), page + 1);
-            }
-
-            const uint64_t pagesToKeep = (i > 2) ? 2 : i;
-
-            ReleaseRss(alignedPtr, i - pagesToKeep);
-            EXPECT_EQ(CountMapped(alignedPtr, i), pagesToKeep) << "number of pages " << i; // no RSS memory allocated
-
-            free(rawPtr);
-        }
-    }
-
-#endif
-
-}
-
+#include <library/cpp/coroutine/engine/stack/stack_common.h> 
+#include <library/cpp/coroutine/engine/stack/stack_utils.h> 
+#include <library/cpp/testing/gtest/gtest.h> 
+ 
+ 
+using namespace testing; 
+ 
+namespace NCoro::NStack::Tests { 
+ 
+    TEST(StackUtilsTest, Allocation) { 
+        char *rawPtr, *alignedPtr = nullptr; 
+        for (uint64_t i : {1, 2, 3, 4, 11}) { 
+            EXPECT_TRUE(GetAlignedMemory(i, rawPtr, alignedPtr)); 
+            EXPECT_TRUE(rawPtr); 
+            EXPECT_TRUE(alignedPtr); 
+            EXPECT_FALSE((uint64_t)alignedPtr & PageSizeMask); 
+            free(rawPtr); 
+        } 
+    } 
+ 
+#if !defined(_san_enabled_) && defined(_linux_) 
+ 
+    TEST(StackUtilsTest, RssReleaseOnePage) { 
+        char *rawPtr, *alignedPtr = nullptr; 
+        for (uint64_t i : {1, 2, 8}) { 
+            EXPECT_TRUE(GetAlignedMemory(i, rawPtr, alignedPtr)); 
+            EXPECT_TRUE(rawPtr); 
+            EXPECT_TRUE(alignedPtr); 
+            EXPECT_FALSE((uint64_t)alignedPtr & PageSizeMask); 
+ 
+            ReleaseRss(alignedPtr, i); // allocator can provide reused memory with RSS memory on it 
+            EXPECT_EQ(CountMapped(alignedPtr, i), 0ul); // no RSS memory allocated 
+ 
+            *(alignedPtr + (i - 1) * PageSize) = 42; // map RSS memory 
+            EXPECT_EQ(CountMapped(alignedPtr, i), 1ul); 
+ 
+            ReleaseRss(alignedPtr, i); 
+            EXPECT_EQ(CountMapped(alignedPtr, i), 0ul) << "number of pages " << i; // no RSS memory allocated 
+ 
+            free(rawPtr); 
+        } 
+    } 
+ 
+    TEST(StackUtilsTest, RssReleaseSeveralPages) { 
+        char *rawPtr, *alignedPtr = nullptr; 
+ 
+        for (uint64_t i : {1, 2, 5, 8}) { 
+            EXPECT_TRUE(GetAlignedMemory(i, rawPtr, alignedPtr)); 
+            EXPECT_TRUE(rawPtr); 
+            EXPECT_TRUE(alignedPtr); 
+            EXPECT_FALSE((uint64_t)alignedPtr & PageSizeMask); 
+ 
+            ReleaseRss(alignedPtr, i); // allocator can provide reused memory with RSS memory on it 
+            EXPECT_EQ(CountMapped(alignedPtr, i), 0ul); // no RSS memory allocated 
+ 
+            for (uint64_t page = 0; page < i; ++page) { 
+                *(alignedPtr + page * PageSize) = 42; // map RSS memory 
+                EXPECT_EQ(CountMapped(alignedPtr, page + 1), page + 1); 
+            } 
+ 
+            const uint64_t pagesToKeep = (i > 2) ? 2 : i; 
+ 
+            ReleaseRss(alignedPtr, i - pagesToKeep); 
+            EXPECT_EQ(CountMapped(alignedPtr, i), pagesToKeep) << "number of pages " << i; // no RSS memory allocated 
+ 
+            free(rawPtr); 
+        } 
+    } 
+ 
+#endif 
+ 
+} 
+ 
diff --git a/library/cpp/coroutine/engine/stack/ut/ya.make b/library/cpp/coroutine/engine/stack/ut/ya.make
index 65c5af9b7f..f2986487fd 100644
--- a/library/cpp/coroutine/engine/stack/ut/ya.make
+++ b/library/cpp/coroutine/engine/stack/ut/ya.make
@@ -1,17 +1,17 @@
-GTEST()
-
-OWNER(g:balancer)
-
-SRCS(
-    stack_allocator_ut.cpp
-    stack_guards_ut.cpp
-    stack_pool_ut.cpp
-    stack_ut.cpp
-    stack_utils_ut.cpp
-)
-
-PEERDIR(
-    library/cpp/coroutine/engine
-)
-
-END()
\ No newline at end of file
+GTEST() 
+ 
+OWNER(g:balancer) 
+ 
+SRCS( 
+    stack_allocator_ut.cpp 
+    stack_guards_ut.cpp 
+    stack_pool_ut.cpp 
+    stack_ut.cpp 
+    stack_utils_ut.cpp 
+) 
+ 
+PEERDIR( 
+    library/cpp/coroutine/engine 
+) 
+ 
+END() 
\ No newline at end of file
diff --git a/library/cpp/coroutine/engine/trampoline.cpp b/library/cpp/coroutine/engine/trampoline.cpp
index 10ea69ddc3..2898ba562a 100644
--- a/library/cpp/coroutine/engine/trampoline.cpp
+++ b/library/cpp/coroutine/engine/trampoline.cpp
@@ -1,8 +1,8 @@
 #include "impl.h"
 #include "trampoline.h"
 
-#include "stack/stack_allocator.h"
-
+#include "stack/stack_allocator.h" 
+ 
 #include <util/system/info.h>
 #include <util/system/protect.h>
 #include <util/system/valgrind.h>
@@ -11,11 +11,11 @@
 #include <cstdlib>
 #include <util/stream/format.h>
 
-
+ 
 namespace NCoro {
 
 TTrampoline::TTrampoline(NStack::IAllocator& allocator, ui32 stackSize, TFunc f, TCont* cont) noexcept
-        : Stack_(allocator, stackSize, cont->Name())
+        : Stack_(allocator, stackSize, cont->Name()) 
         , Clo_{this, Stack_.Get(), cont->Name()}
         , Ctx_(Clo_)
         , Func_(std::move(f))
diff --git a/library/cpp/coroutine/engine/trampoline.h b/library/cpp/coroutine/engine/trampoline.h
index 37b61cf015..af45d14c87 100644
--- a/library/cpp/coroutine/engine/trampoline.h
+++ b/library/cpp/coroutine/engine/trampoline.h
@@ -1,8 +1,8 @@
 #pragma once
 
-#include "stack/stack_common.h"
-#include "stack/stack.h"
-
+#include "stack/stack_common.h" 
+#include "stack/stack.h" 
+ 
 #include <util/generic/noncopyable.h>
 #include <util/generic/ptr.h>
 #include <util/system/context.h>
@@ -17,8 +17,8 @@ typedef void (*TContFunc)(TCont*, void*);
 
 namespace NCoro {
 
-    namespace NStack {
-        class IAllocator;
+    namespace NStack { 
+        class IAllocator; 
     }
 
     class TTrampoline : public ITrampoLine, TNonCopyable {
@@ -26,8 +26,8 @@ namespace NCoro {
         typedef std::function<void (TCont*)> TFunc;
 
         TTrampoline(
-            NCoro::NStack::IAllocator& allocator,
-            uint32_t stackSize,
+            NCoro::NStack::IAllocator& allocator, 
+            uint32_t stackSize, 
             TFunc f,
             TCont* cont
         ) noexcept;
@@ -51,7 +51,7 @@ namespace NCoro {
     private:
         const char* ContName() const noexcept;
     private:
-        NStack::TStackHolder Stack_;
+        NStack::TStackHolder Stack_; 
         const TContClosure Clo_;
         TExceptionSafeContext Ctx_;
         TFunc Func_;
diff --git a/library/cpp/coroutine/engine/ya.make b/library/cpp/coroutine/engine/ya.make
index 8c20b9afc3..fc31f25a8e 100644
--- a/library/cpp/coroutine/engine/ya.make
+++ b/library/cpp/coroutine/engine/ya.make
@@ -6,7 +6,7 @@ OWNER(
 )
 
 GENERATE_ENUM_SERIALIZATION(poller.h)
-GENERATE_ENUM_SERIALIZATION(stack/stack_common.h)
+GENERATE_ENUM_SERIALIZATION(stack/stack_common.h) 
 
 PEERDIR(
     contrib/libs/libc_compat
@@ -21,11 +21,11 @@ SRCS(
     network.cpp
     poller.cpp
     sockpool.cpp
-    stack/stack.cpp
-    stack/stack_allocator.cpp
-    stack/stack_guards.cpp
-    stack/stack_storage.cpp
-    stack/stack_utils.cpp
+    stack/stack.cpp 
+    stack/stack_allocator.cpp 
+    stack/stack_guards.cpp 
+    stack/stack_storage.cpp 
+    stack/stack_utils.cpp 
     trampoline.cpp
 )
 
diff --git a/library/cpp/coroutine/ya.make b/library/cpp/coroutine/ya.make
index 34e30f2b25..6a6889fc2d 100644
--- a/library/cpp/coroutine/ya.make
+++ b/library/cpp/coroutine/ya.make
@@ -3,7 +3,7 @@ RECURSE(
     dns
     dns/example
     engine
-    engine/stack/ut
+    engine/stack/ut 
     listener
     test
     ut