Extract Fiber Manager

commit_hash:e6320630dc0f76cd4c8ae763a7d61de84b031cac

13 files changed, 244 insertions, 82 deletions

diff --git a/yt/yt/core/concurrency/config.cpp b/yt/yt/core/concurrency/config.cpp
index b6e3379d771..506650414b2 100644
--- a/yt/yt/core/concurrency/config.cpp
+++ b/yt/yt/core/concurrency/config.cpp
@@ -2,6 +2,8 @@
 
 namespace NYT::NConcurrency {
 
+using namespace NYTree;
+
 ////////////////////////////////////////////////////////////////////////////////
 
 TPeriodicExecutorOptions TPeriodicExecutorOptions::WithJitter(TDuration period)
@@ -117,4 +119,56 @@ void TPrefetchingThrottlerConfig::Register(TRegistrar registrar)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+namespace {
+
+void ValidateFiberStackPoolSizes(const THashMap<EExecutionStackKind, int>& poolSizes)
+{
+    for (auto [stackKind, poolSize] : poolSizes) {
+        if (poolSize < 0) {
+            THROW_ERROR_EXCEPTION("Pool size of %Qlv stack it not positive",
+                stackKind);
+        }
+    }
+}
+
+} // namespace
+
+TFiberManagerConfigPtr TFiberManagerConfig::ApplyDynamic(const TFiberManagerDynamicConfigPtr& dynamicConfig) const
+{
+    auto result = New<TFiberManagerConfig>();
+    for (auto [key, value] : dynamicConfig->FiberStackPoolSizes) {
+        result->FiberStackPoolSizes[key] = value;
+    }
+    UpdateYsonStructField(result->MaxIdleFibers, dynamicConfig->MaxIdleFibers);
+    return result;
+}
+
+void TFiberManagerConfig::Register(TRegistrar registrar)
+{
+    registrar.Parameter("fiber_stack_pool_sizes", &TThis::FiberStackPoolSizes)
+        .Default();
+    registrar.Parameter("max_idle_fibers", &TThis::MaxIdleFibers)
+        .Default(NConcurrency::DefaultMaxIdleFibers);
+
+    registrar.Postprocessor([] (TThis* config) {
+        ValidateFiberStackPoolSizes(config->FiberStackPoolSizes);
+    });
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TFiberManagerDynamicConfig::Register(TRegistrar registrar)
+{
+    registrar.Parameter("fiber_stack_pool_sizes", &TThis::FiberStackPoolSizes)
+        .Default();
+    registrar.Parameter("max_idle_fibers", &TThis::MaxIdleFibers)
+        .Default();
+
+    registrar.Postprocessor([] (TThis* config) {
+        ValidateFiberStackPoolSizes(config->FiberStackPoolSizes);
+    });
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace NYT::NConcurrency
diff --git a/yt/yt/core/concurrency/config.h b/yt/yt/core/concurrency/config.h
index 2b1034d4ce8..b1d3f04568e 100644
--- a/yt/yt/core/concurrency/config.h
+++ b/yt/yt/core/concurrency/config.h
@@ -37,10 +37,9 @@ namespace NDetail {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TPeriodicExecutorOptionsSerializer
+struct TPeriodicExecutorOptionsSerializer
     : public virtual NYTree::TExternalizedYsonStruct
 {
-public:
     REGISTER_EXTERNALIZED_YSON_STRUCT(TPeriodicExecutorOptions, TPeriodicExecutorOptionsSerializer);
 
     static void Register(TRegistrar registrar);
@@ -48,11 +47,10 @@ public:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TRetryingPeriodicExecutorOptionsSerializer
+struct TRetryingPeriodicExecutorOptionsSerializer
     : public TPeriodicExecutorOptionsSerializer
     , public ::NYT::NDetail::TExponentialBackoffOptionsSerializer
 {
-public:
     REGISTER_DERIVED_EXTERNALIZED_YSON_STRUCT(
         TRetryingPeriodicExecutorOptions,
         TRetryingPeriodicExecutorOptionsSerializer,
@@ -71,10 +69,9 @@ ASSIGN_EXTERNAL_YSON_SERIALIZER(TRetryingPeriodicExecutorOptions, NDetail::TRetr
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TThroughputThrottlerConfig
+struct TThroughputThrottlerConfig
     : public NYTree::TYsonStruct
 {
-public:
     //! Limit on average throughput (per sec). Null means unlimited.
     std::optional<double> Limit;
 
@@ -100,10 +97,9 @@ DEFINE_REFCOUNTED_TYPE(TThroughputThrottlerConfig)
 //! (e.g. in network bandwidth limit on nodes).
 //! The exact logic of limit/relative_limit clash resolution
 //! and the parameter access are external to the config itself.
-class TRelativeThroughputThrottlerConfig
+struct TRelativeThroughputThrottlerConfig
     : public TThroughputThrottlerConfig
 {
-public:
     std::optional<double> RelativeLimit;
 
     static TRelativeThroughputThrottlerConfigPtr Create(std::optional<double> limit);
@@ -117,10 +113,9 @@ DEFINE_REFCOUNTED_TYPE(TRelativeThroughputThrottlerConfig)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TPrefetchingThrottlerConfig
+struct TPrefetchingThrottlerConfig
     : public NYTree::TYsonStruct
 {
-public:
     //! RPS limit for requests to the underlying throttler.
     double TargetRps;
 
@@ -149,4 +144,36 @@ DEFINE_REFCOUNTED_TYPE(TPrefetchingThrottlerConfig)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+struct TFiberManagerConfig
+    : public NYTree::TYsonStruct
+{
+    THashMap<EExecutionStackKind, int> FiberStackPoolSizes;
+    int MaxIdleFibers;
+
+    TFiberManagerConfigPtr ApplyDynamic(const TFiberManagerDynamicConfigPtr& dynamicConfig) const;
+
+    REGISTER_YSON_STRUCT(TFiberManagerConfig);
+
+    static void Register(TRegistrar registrar);
+};
+
+DEFINE_REFCOUNTED_TYPE(TFiberManagerConfig)
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TFiberManagerDynamicConfig
+    : public NYTree::TYsonStruct
+{
+    THashMap<EExecutionStackKind, int> FiberStackPoolSizes;
+    std::optional<int> MaxIdleFibers;
+
+    REGISTER_YSON_STRUCT(TFiberManagerDynamicConfig);
+
+    static void Register(TRegistrar registrar);
+};
+
+DEFINE_REFCOUNTED_TYPE(TFiberManagerDynamicConfig)
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace NYT::NConcurrency
diff --git a/yt/yt/core/concurrency/execution_stack.cpp b/yt/yt/core/concurrency/execution_stack.cpp
index bc75a9b7dc4..7ef7e27bf4a 100644
--- a/yt/yt/core/concurrency/execution_stack.cpp
+++ b/yt/yt/core/concurrency/execution_stack.cpp
@@ -1,5 +1,7 @@
 #include "execution_stack.h"
+
 #include "private.h"
+#include "fiber_manager.h"
 
 #if defined(_unix_)
 #   include <sys/mman.h>
@@ -188,37 +190,8 @@ std::shared_ptr<TExecutionStack> CreateExecutionStack(EExecutionStackKind kind)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-static std::atomic<int> SmallFiberStackPoolSize = {1024};
-static std::atomic<int> LargeFiberStackPoolSize = {1024};
-
-int GetFiberStackPoolSize(EExecutionStackKind stackKind)
-{
-    switch (stackKind) {
-        case EExecutionStackKind::Small: return SmallFiberStackPoolSize.load(std::memory_order::relaxed);
-        case EExecutionStackKind::Large: return LargeFiberStackPoolSize.load(std::memory_order::relaxed);
-        default:                         YT_ABORT();
-    }
-}
-
-void SetFiberStackPoolSize(EExecutionStackKind stackKind, int poolSize)
-{
-    if (poolSize < 0) {
-        YT_LOG_FATAL("Invalid fiber stack pool size (Size: %v, Kind: %v)",
-            poolSize,
-            stackKind);
-    }
-    switch (stackKind) {
-        case EExecutionStackKind::Small: SmallFiberStackPoolSize = poolSize; break;
-        case EExecutionStackKind::Large: LargeFiberStackPoolSize = poolSize; break;
-        default:                         YT_ABORT();
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 } // namespace NYT::NConcurrency
 
-
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -242,7 +215,7 @@ struct TPooledObjectTraits<NConcurrency::TPooledExecutionStack<Kind, Size>, void
 
     static int GetMaxPoolSize()
     {
-        return NConcurrency::GetFiberStackPoolSize(Kind);
+        return NConcurrency::TFiberManager::GetFiberStackPoolSize(Kind);
     }
 };
 
diff --git a/yt/yt/core/concurrency/execution_stack.h b/yt/yt/core/concurrency/execution_stack.h
index d62f8cd026c..99038d3cd39 100644
--- a/yt/yt/core/concurrency/execution_stack.h
+++ b/yt/yt/core/concurrency/execution_stack.h
@@ -77,13 +77,4 @@ std::shared_ptr<TExecutionStack> CreateExecutionStack(EExecutionStackKind kind);
 
 ////////////////////////////////////////////////////////////////////////////////
 
-//! Returns the current global limit for the number of pooled fiber stacks of a given size.
-int GetFiberStackPoolSize(EExecutionStackKind stackKind);
-
-//! Sets the global limit for the number of pooled fiber stacks of a given size.
-void SetFiberStackPoolSize(EExecutionStackKind stackKind, int poolSize);
-
-////////////////////////////////////////////////////////////////////////////////
-
 } // namespace NTY::NConcurrency
-
diff --git a/yt/yt/core/concurrency/fiber_manager.cpp b/yt/yt/core/concurrency/fiber_manager.cpp
new file mode 100644
index 00000000000..c417b047559
--- /dev/null
+++ b/yt/yt/core/concurrency/fiber_manager.cpp
@@ -0,0 +1,94 @@
+#include "fiber_manager.h"
+
+#include "config.h"
+
+#include <yt/yt/core/misc/error.h>
+
+#include <library/cpp/yt/memory/leaky_singleton.h>
+
+#include <library/cpp/yt/containers/enum_indexed_array.h>
+
+namespace NYT::NConcurrency {
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TFiberManagerImpl
+{
+public:
+    static TFiberManagerImpl* Get()
+    {
+        return LeakySingleton<TFiberManagerImpl>();
+    }
+
+    int GetFiberStackPoolSize(EExecutionStackKind stackKind)
+    {
+        return FiberStackPoolSizes_[stackKind].load(std::memory_order::relaxed);
+    }
+
+    void SetFiberStackPoolSize(EExecutionStackKind stackKind, int poolSize)
+    {
+        if (poolSize < 1) {
+            THROW_ERROR_EXCEPTION("Pool size must be positive");
+        }
+        FiberStackPoolSizes_[stackKind].store(poolSize);
+    }
+
+    int GetMaxIdleFibers()
+    {
+        return MaxIdleFibers_.load(std::memory_order::relaxed);
+    }
+
+    void SetMaxIdleFibers(int maxIdleFibers)
+    {
+        MaxIdleFibers_.store(maxIdleFibers);
+    }
+
+    void Configure(const TFiberManagerConfigPtr& config)
+    {
+        for (auto [stackKind, poolSize] : config->FiberStackPoolSizes) {
+            SetFiberStackPoolSize(stackKind, poolSize);
+        }
+    }
+
+private:
+    DECLARE_LEAKY_SINGLETON_FRIEND()
+
+    TFiberManagerImpl()
+    {
+        std::ranges::fill(FiberStackPoolSizes_, DefaultFiberStackPoolSize);
+    }
+
+    TEnumIndexedArray<EExecutionStackKind, std::atomic<int>> FiberStackPoolSizes_;
+    std::atomic<int> MaxIdleFibers_ = DefaultMaxIdleFibers;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+int TFiberManager::GetFiberStackPoolSize(EExecutionStackKind stackKind)
+{
+    return TFiberManagerImpl::Get()->GetFiberStackPoolSize(stackKind);
+}
+
+void TFiberManager::SetFiberStackPoolSize(EExecutionStackKind stackKind, int poolSize)
+{
+    TFiberManagerImpl::Get()->SetFiberStackPoolSize(stackKind, poolSize);
+}
+
+int TFiberManager::GetMaxIdleFibers()
+{
+    return TFiberManagerImpl::Get()->GetMaxIdleFibers();
+}
+
+void TFiberManager::SetMaxIdleFibers(int maxIdleFibers)
+{
+    TFiberManagerImpl::Get()->SetMaxIdleFibers(maxIdleFibers);
+}
+
+void TFiberManager::Configure(const TFiberManagerConfigPtr& config)
+{
+    TFiberManagerImpl::Get()->Configure(config);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT::NConcurrency
diff --git a/yt/yt/core/concurrency/fiber_manager.h b/yt/yt/core/concurrency/fiber_manager.h
new file mode 100644
index 00000000000..ba41eeaa897
--- /dev/null
+++ b/yt/yt/core/concurrency/fiber_manager.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "public.h"
+
+namespace NYT::NConcurrency {
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TFiberManager
+{
+public:
+    //! Returns the current global limit for the number of pooled fiber stacks of a given size.
+    static int GetFiberStackPoolSize(EExecutionStackKind stackKind);
+
+    //! Sets the global limit for the number of pooled fiber stacks of a given size.
+    static void SetFiberStackPoolSize(EExecutionStackKind stackKind, int poolSize);
+
+    //! Returns the current global limit for the number of idle fibers.
+    static int GetMaxIdleFibers();
+
+    //! Sets the global limit for the number of idle fibers.
+    static void SetMaxIdleFibers(int maxIdleFibers);
+
+    //! Configures the singleton.
+    static void Configure(const TFiberManagerConfigPtr& config);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT::NConcurrency
diff --git a/yt/yt/core/concurrency/fiber_scheduler_thread.cpp b/yt/yt/core/concurrency/fiber_scheduler_thread.cpp
index f4af46f4712..510c4181886 100644
--- a/yt/yt/core/concurrency/fiber_scheduler_thread.cpp
+++ b/yt/yt/core/concurrency/fiber_scheduler_thread.cpp
@@ -1,6 +1,7 @@
 #include "fiber_scheduler_thread.h"
 
 #include "fiber.h"
+#include "fiber_manager.h"
 #include "moody_camel_concurrent_queue.h"
 #include "private.h"
 
@@ -384,14 +385,8 @@ public:
         return TFiber::CreateFiber();
     }
 
-    void UpdateMaxIdleFibers(int maxIdleFibers)
-    {
-        MaxIdleFibers_.store(maxIdleFibers, std::memory_order::relaxed);
-    }
-
 private:
     moodycamel::ConcurrentQueue<TFiber*> IdleFibers_;
-    std::atomic<int> MaxIdleFibers_ = DefaultMaxIdleFibers;
 
     // NB(arkady-e1ppa): Construct this last so that every other
     // field is initialized if this callback is ran concurrently.
@@ -453,11 +448,12 @@ private:
     {
         // NB: size_t to int conversion.
         int size = IdleFibers_.size_approx();
-        if (size <= MaxIdleFibers_.load(std::memory_order::relaxed)) {
+        int maxSize = TFiberManager::GetMaxIdleFibers();
+        if (size <= maxSize) {
             return;
         }
 
-        auto targetSize = std::max<size_t>(1, MaxIdleFibers_ / 2);
+        auto targetSize = std::max<size_t>(1, maxSize / 2);
 
         std::vector<TFiber*> fibers;
         DequeueFibersBulk(&fibers, size - targetSize);
@@ -1079,13 +1075,6 @@ void TFiberSchedulerThread::ThreadMain()
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void UpdateMaxIdleFibers(int maxIdleFibers)
-{
-    NDetail::TIdleFiberPool::Get()->UpdateMaxIdleFibers(maxIdleFibers);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 YT_DEFINE_THREAD_LOCAL(TFiberId, CurrentFiberId);
 
 TFiberId GetCurrentFiberId()
diff --git a/yt/yt/core/concurrency/fiber_scheduler_thread.h b/yt/yt/core/concurrency/fiber_scheduler_thread.h
index dd21e20432a..b368a7910c6 100644
--- a/yt/yt/core/concurrency/fiber_scheduler_thread.h
+++ b/yt/yt/core/concurrency/fiber_scheduler_thread.h
@@ -31,9 +31,4 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-constexpr int DefaultMaxIdleFibers = 5'000;
-void UpdateMaxIdleFibers(int maxIdleFibers);
-
-////////////////////////////////////////////////////////////////////////////////
-
 } //namespace NYT::NConcurrency
diff --git a/yt/yt/core/concurrency/public.h b/yt/yt/core/concurrency/public.h
index 151120cbc7f..b7634c07309 100644
--- a/yt/yt/core/concurrency/public.h
+++ b/yt/yt/core/concurrency/public.h
@@ -33,9 +33,9 @@ DECLARE_REFCOUNTED_STRUCT(TDelayedExecutorEntry)
 
 using TDelayedExecutorCookie = NDetail::TDelayedExecutorEntryPtr;
 
-DECLARE_REFCOUNTED_CLASS(TThroughputThrottlerConfig)
-DECLARE_REFCOUNTED_CLASS(TRelativeThroughputThrottlerConfig)
-DECLARE_REFCOUNTED_CLASS(TPrefetchingThrottlerConfig)
+DECLARE_REFCOUNTED_STRUCT(TThroughputThrottlerConfig)
+DECLARE_REFCOUNTED_STRUCT(TRelativeThroughputThrottlerConfig)
+DECLARE_REFCOUNTED_STRUCT(TPrefetchingThrottlerConfig)
 DECLARE_REFCOUNTED_STRUCT(IThroughputThrottler)
 DECLARE_REFCOUNTED_STRUCT(IReconfigurableThroughputThrottler)
 DECLARE_REFCOUNTED_STRUCT(ITestableReconfigurableThroughputThrottler)
@@ -88,6 +88,9 @@ DECLARE_REFCOUNTED_STRUCT(IThreadPoolPoller)
 
 DECLARE_REFCOUNTED_CLASS(TThread)
 
+constexpr int DefaultMaxIdleFibers = 5'000;
+constexpr int DefaultFiberStackPoolSize = 1'000;
+
 using TFiberId = size_t;
 constexpr size_t InvalidFiberId = 0;
 
@@ -108,6 +111,9 @@ DECLARE_REFCOUNTED_STRUCT(ITwoLevelFairShareThreadPool)
 
 class TFiber;
 
+DECLARE_REFCOUNTED_STRUCT(TFiberManagerConfig)
+DECLARE_REFCOUNTED_STRUCT(TFiberManagerDynamicConfig)
+
 DECLARE_REFCOUNTED_STRUCT(TFairThrottlerConfig)
 DECLARE_REFCOUNTED_STRUCT(TFairThrottlerBucketConfig)
 
diff --git a/yt/yt/core/ya.make b/yt/yt/core/ya.make
index 56334cc6c09..c9e5d8c74c7 100644
--- a/yt/yt/core/ya.make
+++ b/yt/yt/core/ya.make
@@ -64,6 +64,7 @@ SRCS(
     concurrency/fair_throttler.cpp
     concurrency/fiber_scheduler_thread.cpp
     concurrency/fiber.cpp
+    concurrency/fiber_manager.cpp
     concurrency/fls.cpp
     concurrency/invoker_alarm.cpp
     concurrency/invoker_queue.cpp
diff --git a/yt/yt/library/program/config.cpp b/yt/yt/library/program/config.cpp
index 00868ed8c35..960463a9787 100644
--- a/yt/yt/library/program/config.cpp
+++ b/yt/yt/library/program/config.cpp
@@ -22,8 +22,8 @@ void TSingletonsConfig::Register(TRegistrar registrar)
 {
     registrar.Parameter("spin_wait_slow_path_logging_threshold", &TThis::SpinWaitSlowPathLoggingThreshold)
         .Default(TDuration::MicroSeconds(100));
-    registrar.Parameter("fiber_stack_pool_sizes", &TThis::FiberStackPoolSizes)
-        .Default({});
+    registrar.Parameter("fiber_manager", &TThis::FiberManager)
+        .DefaultNew();
     registrar.Parameter("address_resolver", &TThis::AddressResolver)
         .DefaultNew();
     registrar.Parameter("tcp_dispatcher", &TThis::TcpDispatcher)
@@ -63,8 +63,8 @@ void TSingletonsDynamicConfig::Register(TRegistrar registrar)
 {
     registrar.Parameter("spin_lock_slow_path_logging_threshold", &TThis::SpinWaitSlowPathLoggingThreshold)
         .Optional();
-    registrar.Parameter("max_idle_fibers", &TThis::MaxIdleFibers)
-        .Default(NConcurrency::DefaultMaxIdleFibers);
+    registrar.Parameter("fiber_manager", &TThis::FiberManager)
+        .DefaultNew();
     registrar.Parameter("tcp_dispatcher", &TThis::TcpDispatcher)
         .DefaultNew();
     registrar.Parameter("io_dispatcher", &TThis::IODispatcher)
diff --git a/yt/yt/library/program/config.h b/yt/yt/library/program/config.h
index cedb0ff3dd9..ae69194b9fa 100644
--- a/yt/yt/library/program/config.h
+++ b/yt/yt/library/program/config.h
@@ -2,6 +2,8 @@
 
 #include "public.h"
 
+#include <yt/yt/core/concurrency/config.h>
+
 #include <yt/yt/core/tracing/config.h>
 
 #include <yt/yt/core/ytree/yson_struct.h>
@@ -60,7 +62,7 @@ class TSingletonsConfig
 {
 public:
     TDuration SpinWaitSlowPathLoggingThreshold;
-    THashMap<TString, int> FiberStackPoolSizes;
+    NConcurrency::TFiberManagerConfigPtr FiberManager;
     NNet::TAddressResolverConfigPtr AddressResolver;
     NBus::TTcpDispatcherConfigPtr TcpDispatcher;
     NPipes::TIODispatcherConfigPtr IODispatcher;
@@ -91,7 +93,7 @@ class TSingletonsDynamicConfig
 {
 public:
     std::optional<TDuration> SpinWaitSlowPathLoggingThreshold;
-    ui64 MaxIdleFibers;
+    NConcurrency::TFiberManagerDynamicConfigPtr FiberManager;
     NBus::TTcpDispatcherDynamicConfigPtr TcpDispatcher;
     NPipes::TIODispatcherConfigPtr IODispatcher;
     NRpc::TDispatcherDynamicConfigPtr RpcDispatcher;
diff --git a/yt/yt/library/program/helpers.cpp b/yt/yt/library/program/helpers.cpp
index b559fc38708..7b65c81dbff 100644
--- a/yt/yt/library/program/helpers.cpp
+++ b/yt/yt/library/program/helpers.cpp
@@ -8,6 +8,8 @@
 
 #include <yt/yt/core/bus/tcp/dispatcher.h>
 
+#include <yt/yt/core/concurrency/fiber_manager.h>
+
 #include <yt/yt/library/tracing/jaeger/tracer.h>
 
 #include <yt/yt/library/profiling/perf/counters.h>
@@ -53,9 +55,7 @@ void ConfigureSingletons(const TSingletonsConfigPtr& config)
 {
     SetSpinWaitSlowPathLoggingThreshold(config->SpinWaitSlowPathLoggingThreshold);
 
-    for (const auto& [kind, size] : config->FiberStackPoolSizes) {
-        NConcurrency::SetFiberStackPoolSize(ParseEnum<NConcurrency::EExecutionStackKind>(kind), size);
-    }
+    TFiberManager::Configure(config->FiberManager);
 
     NLogging::TLogManager::Get()->EnableReopenOnSighup();
     if (!NLogging::TLogManager::Get()->IsConfiguredFromEnv()) {
@@ -103,7 +103,7 @@ void ReconfigureSingletons(const TSingletonsConfigPtr& config, const TSingletons
 {
     SetSpinWaitSlowPathLoggingThreshold(dynamicConfig->SpinWaitSlowPathLoggingThreshold.value_or(config->SpinWaitSlowPathLoggingThreshold));
 
-    NConcurrency::UpdateMaxIdleFibers(dynamicConfig->MaxIdleFibers);
+    TFiberManager::Configure(config->FiberManager->ApplyDynamic(dynamicConfig->FiberManager));
 
     if (!NLogging::TLogManager::Get()->IsConfiguredFromEnv()) {
         NLogging::TLogManager::Get()->Configure(