Restoring authorship annotation for Vladislav Kuznetsov <va.kuznecov@physics.msu.ru>. Commit 2 of 2.

10 files changed, 281 insertions, 281 deletions

diff --git a/library/cpp/actors/core/actorsystem.cpp b/library/cpp/actors/core/actorsystem.cpp
index df006ba7b8..c58698a206 100644
--- a/library/cpp/actors/core/actorsystem.cpp
+++ b/library/cpp/actors/core/actorsystem.cpp
@@ -7,7 +7,7 @@
 #include "interconnect.h"
 #include "servicemap.h"
 #include "scheduler_queue.h"
-#include "scheduler_actor.h" 
+#include "scheduler_actor.h"
 #include "log.h"
 #include "probes.h"
 #include "ask.h"
diff --git a/library/cpp/actors/core/executor_thread.cpp b/library/cpp/actors/core/executor_thread.cpp
index d4aac6e60e..446b651efd 100644
--- a/library/cpp/actors/core/executor_thread.cpp
+++ b/library/cpp/actors/core/executor_thread.cpp
@@ -20,7 +20,7 @@
 #endif
 
 #include <util/system/type_name.h>
-#include <util/system/datetime.h> 
+#include <util/system/datetime.h>
 
 LWTRACE_USING(ACTORLIB_PROVIDER)
 
diff --git a/library/cpp/actors/core/probes.h b/library/cpp/actors/core/probes.h
index 0a7804c210..4912d6dd26 100644
--- a/library/cpp/actors/core/probes.h
+++ b/library/cpp/actors/core/probes.h
@@ -71,9 +71,9 @@
     PROBE(SlowICDropConfirmed, GROUPS("ActorLibSlowIC"),                                                                              \
           TYPES(ui32, double),                                                                                                        \
           NAMES("peerId", "icDropConfirmedMs"))                                                                                       \
-    PROBE(ActorsystemScheduler, GROUPS("Durations"),                                                                                  \ 
-          TYPES(ui64, ui64, ui32, ui32, ui64, ui64),                                                                                  \ 
-          NAMES("timeUs", "timerfd_expirations", "eventsGottenFromQueues", "eventsSent",                                              \ 
+    PROBE(ActorsystemScheduler, GROUPS("Durations"),                                                                                  \
+          TYPES(ui64, ui64, ui32, ui32, ui64, ui64),                                                                                  \
+          NAMES("timeUs", "timerfd_expirations", "eventsGottenFromQueues", "eventsSent",                                              \
                 "eventsInSendQueue", "eventSchedulingErrorUs"))                                                                       \
     PROBE(ForwardEvent, GROUPS("Orbit", "InterconnectSessionTCP"),                                                                    \
           TYPES(ui32, ui32, ui32, LWTYPE_ACTORID, LWTYPE_ACTORID, ui64, ui32),                                                        \
diff --git a/library/cpp/actors/core/scheduler_actor.cpp b/library/cpp/actors/core/scheduler_actor.cpp
index cccb302c1f..febc5e40dd 100644
--- a/library/cpp/actors/core/scheduler_actor.cpp
+++ b/library/cpp/actors/core/scheduler_actor.cpp
@@ -1,135 +1,135 @@
-#include "actor_bootstrapped.h" 
-#include "hfunc.h" 
-#include "probes.h" 
-#include "scheduler_actor.h" 
-#include "scheduler_queue.h" 
- 
+#include "actor_bootstrapped.h"
+#include "hfunc.h"
+#include "probes.h"
+#include "scheduler_actor.h"
+#include "scheduler_queue.h"
+
 #include <library/cpp/actors/interconnect/poller_actor.h>
-#include <util/system/hp_timer.h> 
- 
-#ifdef __linux__ 
+#include <util/system/hp_timer.h>
+
+#ifdef __linux__
 #include <sys/timerfd.h>
 #include <errno.h>
- 
-LWTRACE_USING(ACTORLIB_PROVIDER); 
- 
-namespace NActors { 
+
+LWTRACE_USING(ACTORLIB_PROVIDER);
+
+namespace NActors {
     class TTimerDescriptor: public TSharedDescriptor {
-        const int Descriptor; 
+        const int Descriptor;
 
-    public: 
-        TTimerDescriptor() 
+    public:
+        TTimerDescriptor()
             : Descriptor(timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK))
-        { 
-            Y_VERIFY(Descriptor != -1, "timerfd_create() failed with %s", strerror(errno)); 
-        } 
- 
+        {
+            Y_VERIFY(Descriptor != -1, "timerfd_create() failed with %s", strerror(errno));
+        }
+
         ~TTimerDescriptor() override {
-            close(Descriptor); 
-        } 
- 
+            close(Descriptor);
+        }
+
         int GetDescriptor() override {
-            return Descriptor; 
-        } 
-    }; 
- 
+            return Descriptor;
+        }
+    };
+
     class TSchedulerActor: public TActor<TSchedulerActor> {
-        const TSchedulerConfig Cfg; 
-        TIntrusivePtr<TSharedDescriptor> TimerDescriptor; 
- 
-        TVector<NSchedulerQueue::TReader*> Readers; 
- 
+        const TSchedulerConfig Cfg;
+        TIntrusivePtr<TSharedDescriptor> TimerDescriptor;
+
+        TVector<NSchedulerQueue::TReader*> Readers;
+
         TActorId PollerActor;
         TPollerToken::TPtr PollerToken;
- 
-        ui64 RealTime; 
+
+        ui64 RealTime;
         ui64 MonotonicTime;
- 
-        ui64 ActiveTick; 
-        typedef TMap<ui64, TAutoPtr<NSchedulerQueue::TQueueType>> TMomentMap; // intrasecond queues 
+
+        ui64 ActiveTick;
+        typedef TMap<ui64, TAutoPtr<NSchedulerQueue::TQueueType>> TMomentMap; // intrasecond queues
         typedef THashMap<ui64, TAutoPtr<TMomentMap>> TScheduleMap;            // over-second schedule
- 
-        TScheduleMap ScheduleMap; 
- 
-        THolder<NThreading::TLegacyFuture<void, false>> MainCycle; 
- 
-        static const ui64 IntrasecondThreshold = 1048576; // ~second 
-        TAutoPtr<TMomentMap> ActiveSec; 
+
+        TScheduleMap ScheduleMap;
+
+        THolder<NThreading::TLegacyFuture<void, false>> MainCycle;
+
+        static const ui64 IntrasecondThreshold = 1048576; // ~second
+        TAutoPtr<TMomentMap> ActiveSec;
         volatile ui64* CurrentTimestamp = nullptr;
         volatile ui64* CurrentMonotonic = nullptr;
-        TDeque<TAutoPtr<IEventHandle>> EventsToBeSent; 
- 
-    public: 
+        TDeque<TAutoPtr<IEventHandle>> EventsToBeSent;
+
+    public:
         static constexpr IActor::EActivityType ActorActivityType() {
             return IActor::ACTOR_SYSTEM_SCHEDULER_ACTOR;
         }
 
         TSchedulerActor(const TSchedulerConfig& cfg)
-            : TActor(&TSchedulerActor::StateFunc) 
-            , Cfg(cfg) 
-            , TimerDescriptor(new TTimerDescriptor()) 
+            : TActor(&TSchedulerActor::StateFunc)
+            , Cfg(cfg)
+            , TimerDescriptor(new TTimerDescriptor())
             , PollerActor(MakePollerActorId())
-        { 
-            Y_ASSERT(Cfg.ResolutionMicroseconds != 0); 
-            Y_ASSERT(Cfg.ProgressThreshold != 0); 
-            Become(&TSchedulerActor::StateFunc); 
-        } 
- 
+        {
+            Y_ASSERT(Cfg.ResolutionMicroseconds != 0);
+            Y_ASSERT(Cfg.ProgressThreshold != 0);
+            Become(&TSchedulerActor::StateFunc);
+        }
+
         void Handle(TEvSchedulerInitialize::TPtr& ev, const TActorContext& ctx) {
             const TEvSchedulerInitialize& evInitialize = *ev->Get();
-            Y_ASSERT(evInitialize.ScheduleReaders.size() != 0); 
-            Readers.resize(evInitialize.ScheduleReaders.size()); 
-            Copy(evInitialize.ScheduleReaders.begin(), evInitialize.ScheduleReaders.end(), Readers.begin()); 
- 
-            Y_ASSERT(evInitialize.CurrentTimestamp != nullptr); 
-            CurrentTimestamp = evInitialize.CurrentTimestamp; 
- 
+            Y_ASSERT(evInitialize.ScheduleReaders.size() != 0);
+            Readers.resize(evInitialize.ScheduleReaders.size());
+            Copy(evInitialize.ScheduleReaders.begin(), evInitialize.ScheduleReaders.end(), Readers.begin());
+
+            Y_ASSERT(evInitialize.CurrentTimestamp != nullptr);
+            CurrentTimestamp = evInitialize.CurrentTimestamp;
+
             Y_ASSERT(evInitialize.CurrentMonotonic != nullptr);
             CurrentMonotonic = evInitialize.CurrentMonotonic;
 
-            struct itimerspec new_time; 
-            memset(&new_time, 0, sizeof(new_time)); 
-            new_time.it_value.tv_nsec = Cfg.ResolutionMicroseconds * 1000; 
-            new_time.it_interval.tv_nsec = Cfg.ResolutionMicroseconds * 1000; 
-            int ret = timerfd_settime(TimerDescriptor->GetDescriptor(), 0, &new_time, NULL); 
-            Y_VERIFY(ret != -1, "timerfd_settime() failed with %s", strerror(errno)); 
+            struct itimerspec new_time;
+            memset(&new_time, 0, sizeof(new_time));
+            new_time.it_value.tv_nsec = Cfg.ResolutionMicroseconds * 1000;
+            new_time.it_interval.tv_nsec = Cfg.ResolutionMicroseconds * 1000;
+            int ret = timerfd_settime(TimerDescriptor->GetDescriptor(), 0, &new_time, NULL);
+            Y_VERIFY(ret != -1, "timerfd_settime() failed with %s", strerror(errno));
             const bool success = ctx.Send(PollerActor, new TEvPollerRegister(TimerDescriptor, SelfId(), {}));
             Y_VERIFY(success);
- 
+
             RealTime = RelaxedLoad(CurrentTimestamp);
             MonotonicTime = RelaxedLoad(CurrentMonotonic);
- 
+
             ActiveTick = AlignUp<ui64>(MonotonicTime, IntrasecondThreshold);
-        } 
- 
+        }
+
         void Handle(TEvPollerRegisterResult::TPtr ev, const TActorContext& ctx) {
             PollerToken = ev->Get()->PollerToken;
             HandleSchedule(ctx);
         }
 
-        void UpdateTime() { 
+        void UpdateTime() {
             RealTime = TInstant::Now().MicroSeconds();
             MonotonicTime = Max(MonotonicTime, GetMonotonicMicroSeconds());
             AtomicStore(CurrentTimestamp, RealTime);
             AtomicStore(CurrentMonotonic, MonotonicTime);
-        } 
- 
+        }
+
         void TryUpdateTime(NHPTimer::STime* lastTimeUpdate) {
-            NHPTimer::STime hpnow; 
+            NHPTimer::STime hpnow;
             GetTimeFast(&hpnow);
-            const ui64 elapsedCycles = hpnow > *lastTimeUpdate ? hpnow - *lastTimeUpdate : 0; 
-            if (elapsedCycles > Cfg.ResolutionMicroseconds * (NHPTimer::GetCyclesPerSecond() / IntrasecondThreshold)) { 
-                UpdateTime(); 
+            const ui64 elapsedCycles = hpnow > *lastTimeUpdate ? hpnow - *lastTimeUpdate : 0;
+            if (elapsedCycles > Cfg.ResolutionMicroseconds * (NHPTimer::GetCyclesPerSecond() / IntrasecondThreshold)) {
+                UpdateTime();
                 GetTimeFast(lastTimeUpdate);
-            } 
-        } 
- 
-        void HandleSchedule(const TActorContext& ctx) { 
+            }
+        }
+
+        void HandleSchedule(const TActorContext& ctx) {
             for (;;) {
                 NHPTimer::STime schedulingStart;
                 GetTimeFast(&schedulingStart);
                 NHPTimer::STime lastTimeUpdate = schedulingStart;
- 
+
                 ui64 expired;
                 ssize_t bytesRead;
                 bytesRead = read(TimerDescriptor->GetDescriptor(), &expired, sizeof(expired));
@@ -143,7 +143,7 @@ namespace NActors {
                 }
                 Y_VERIFY(bytesRead == sizeof(expired), "Error while reading from timerfd, strerror# %s", strerror(errno));
                 UpdateTime();
- 
+
                 ui32 eventsGottenFromQueues = 0;
                 // collect everything from queues
                 for (ui32 i = 0; i != Readers.size(); ++i) {
@@ -151,9 +151,9 @@ namespace NActors {
                         const ui64 instant = AlignUp<ui64>(x->InstantMicroseconds, Cfg.ResolutionMicroseconds);
                         IEventHandle* const ev = x->Ev;
                         ISchedulerCookie* const cookie = x->Cookie;
- 
+
                         // check is cookie still valid? looks like it will hurt performance w/o sagnificant memory save
- 
+
                         if (instant <= ActiveTick) {
                             if (!ActiveSec)
                                 ActiveSec.Reset(new TMomentMap());
@@ -173,9 +173,9 @@ namespace NActors {
                         }
                         ++eventsGottenFromQueues;
                         TryUpdateTime(&lastTimeUpdate);
-                    } 
-                } 
- 
+                    }
+                }
+
                 ui64 eventSchedulingErrorUs = 0;
                 // send everything triggered on schedule
                 for (;;) {
@@ -197,17 +197,17 @@ namespace NActors {
                                             delete ev;
                                         }
                                     } else {
-                                        EventsToBeSent.push_back(ev); 
-                                    } 
+                                        EventsToBeSent.push_back(ev);
+                                    }
                                     TryUpdateTime(&lastTimeUpdate);
-                                } 
-                            } 
+                                }
+                            }
                             ActiveSec->erase(it);
                         } else {
                             break;
-                        } 
-                    } 
- 
+                        }
+                    }
+
                     if (ActiveTick <= MonotonicTime) {
                         Y_VERIFY_DEBUG(!ActiveSec || ActiveSec->empty());
                         ActiveSec.Destroy();
@@ -218,12 +218,12 @@ namespace NActors {
                             ScheduleMap.erase(it);
                         }
                         continue;
-                    } 
+                    }
 
                     // ok, if we are here - then nothing is ready, so send step complete
                     break;
-                } 
- 
+                }
+
                 // Send all from buffer queue
                 const ui64 eventsToBeSentSize = EventsToBeSent.size();
                 ui32 sentCount = 0;
@@ -237,7 +237,7 @@ namespace NActors {
                     ctx.Send(EventsToBeSent.front());
                     EventsToBeSent.pop_front();
                 }
- 
+
                 NHPTimer::STime hpnow;
                 GetTimeFast(&hpnow);
                 const ui64 processingTime = hpnow > schedulingStart ? hpnow - schedulingStart : 0;
@@ -245,35 +245,35 @@ namespace NActors {
                 LWPROBE(ActorsystemScheduler, elapsedTimeMicroseconds, expired, eventsGottenFromQueues, sentCount,
                         eventsToBeSentSize, eventSchedulingErrorUs);
                 TryUpdateTime(&lastTimeUpdate);
-            } 
-        } 
- 
+            }
+        }
+
         STRICT_STFUNC(StateFunc,
             HFunc(TEvSchedulerInitialize, Handle)
             CFunc(TEvPollerReady::EventType, HandleSchedule)
             CFunc(TEvents::TSystem::PoisonPill, Die)
             HFunc(TEvPollerRegisterResult, Handle)
         )
-    }; 
- 
+    };
+
     IActor* CreateSchedulerActor(const TSchedulerConfig& cfg) {
-        if (cfg.UseSchedulerActor) { 
-            return new TSchedulerActor(cfg); 
-        } else { 
-            return nullptr; 
-        } 
-    } 
- 
+        if (cfg.UseSchedulerActor) {
+            return new TSchedulerActor(cfg);
+        } else {
+            return nullptr;
+        }
+    }
+
 }
- 
-#else // linux 
- 
-namespace NActors { 
+
+#else // linux
+
+namespace NActors {
     IActor* CreateSchedulerActor(const TSchedulerConfig& cfg) {
-        Y_UNUSED(cfg); 
-        return nullptr; 
-    } 
- 
+        Y_UNUSED(cfg);
+        return nullptr;
+    }
+
 }
- 
-#endif // linux 
+
+#endif // linux
diff --git a/library/cpp/actors/core/scheduler_actor.h b/library/cpp/actors/core/scheduler_actor.h
index 5aa9f0216d..c2c561b43d 100644
--- a/library/cpp/actors/core/scheduler_actor.h
+++ b/library/cpp/actors/core/scheduler_actor.h
@@ -1,29 +1,29 @@
-#pragma once 
- 
-#include "actor.h" 
-#include "event_local.h" 
-#include "events.h" 
-#include "scheduler_basic.h" 
- 
-namespace NActors { 
-    struct TEvSchedulerInitialize : TEventLocal<TEvSchedulerInitialize, TEvents::TSystem::Bootstrap> { 
-        TVector<NSchedulerQueue::TReader*> ScheduleReaders; 
+#pragma once
+
+#include "actor.h"
+#include "event_local.h"
+#include "events.h"
+#include "scheduler_basic.h"
+
+namespace NActors {
+    struct TEvSchedulerInitialize : TEventLocal<TEvSchedulerInitialize, TEvents::TSystem::Bootstrap> {
+        TVector<NSchedulerQueue::TReader*> ScheduleReaders;
         volatile ui64* CurrentTimestamp;
         volatile ui64* CurrentMonotonic;
- 
+
         TEvSchedulerInitialize(const TVector<NSchedulerQueue::TReader*>& scheduleReaders, volatile ui64* currentTimestamp, volatile ui64* currentMonotonic)
-            : ScheduleReaders(scheduleReaders) 
-            , CurrentTimestamp(currentTimestamp) 
+            : ScheduleReaders(scheduleReaders)
+            , CurrentTimestamp(currentTimestamp)
             , CurrentMonotonic(currentMonotonic)
         {
         }
-    }; 
- 
+    };
+
     IActor* CreateSchedulerActor(const TSchedulerConfig& cfg);
- 
+
     inline TActorId MakeSchedulerActorId() {
-        char x[12] = {'s', 'c', 'h', 'e', 'd', 'u', 'l', 'e', 'r', 's', 'e', 'r'}; 
+        char x[12] = {'s', 'c', 'h', 'e', 'd', 'u', 'l', 'e', 'r', 's', 'e', 'r'};
         return TActorId(0, TStringBuf(x, 12));
-    } 
- 
+    }
+
 }
diff --git a/library/cpp/actors/core/scheduler_actor_ut.cpp b/library/cpp/actors/core/scheduler_actor_ut.cpp
index 8f5cf6b23f..09b7369d36 100644
--- a/library/cpp/actors/core/scheduler_actor_ut.cpp
+++ b/library/cpp/actors/core/scheduler_actor_ut.cpp
@@ -1,100 +1,100 @@
-#include "actor_coroutine.h" 
-#include "actorsystem.h" 
-#include "executor_pool_basic.h" 
-#include "scheduler_actor.h" 
-#include "scheduler_basic.h" 
-#include "events.h" 
-#include "event_local.h" 
-#include "hfunc.h" 
+#include "actor_coroutine.h"
+#include "actorsystem.h"
+#include "executor_pool_basic.h"
+#include "scheduler_actor.h"
+#include "scheduler_basic.h"
+#include "events.h"
+#include "event_local.h"
+#include "hfunc.h"
 #include <library/cpp/actors/interconnect/poller_actor.h>
 #include <library/cpp/testing/unittest/registar.h>
- 
-#include <util/system/sanitizers.h> 
- 
-using namespace NActors; 
- 
+
+#include <util/system/sanitizers.h>
+
+using namespace NActors;
+
 Y_UNIT_TEST_SUITE(SchedulerActor) {
-    class TTestActor: public TActorBootstrapped<TTestActor> { 
-        TManualEvent& DoneEvent; 
-        TAtomic& EventsProcessed; 
-        TInstant LastWakeup; 
-        const TAtomicBase EventsTotalCount; 
-        const TDuration ScheduleDelta; 
- 
-    public: 
-        TTestActor(TManualEvent& doneEvent, TAtomic& eventsProcessed, TAtomicBase eventsTotalCount, ui32 scheduleDeltaMs) 
-            : DoneEvent(doneEvent) 
-            , EventsProcessed(eventsProcessed) 
-            , EventsTotalCount(eventsTotalCount) 
-            , ScheduleDelta(TDuration::MilliSeconds(scheduleDeltaMs)) 
-        { 
-        } 
- 
+    class TTestActor: public TActorBootstrapped<TTestActor> {
+        TManualEvent& DoneEvent;
+        TAtomic& EventsProcessed;
+        TInstant LastWakeup;
+        const TAtomicBase EventsTotalCount;
+        const TDuration ScheduleDelta;
+
+    public:
+        TTestActor(TManualEvent& doneEvent, TAtomic& eventsProcessed, TAtomicBase eventsTotalCount, ui32 scheduleDeltaMs)
+            : DoneEvent(doneEvent)
+            , EventsProcessed(eventsProcessed)
+            , EventsTotalCount(eventsTotalCount)
+            , ScheduleDelta(TDuration::MilliSeconds(scheduleDeltaMs))
+        {
+        }
+
         void Bootstrap(const TActorContext& ctx) {
-            LastWakeup = ctx.Now(); 
-            Become(&TThis::StateFunc); 
-            ctx.Schedule(ScheduleDelta, new TEvents::TEvWakeup()); 
-        } 
- 
+            LastWakeup = ctx.Now();
+            Become(&TThis::StateFunc);
+            ctx.Schedule(ScheduleDelta, new TEvents::TEvWakeup());
+        }
+
         void Handle(TEvents::TEvWakeup::TPtr& /*ev*/, const TActorContext& ctx) {
-            const TInstant now = ctx.Now(); 
-            UNIT_ASSERT(now - LastWakeup >= ScheduleDelta); 
-            LastWakeup = now; 
- 
-            if (AtomicIncrement(EventsProcessed) == EventsTotalCount) { 
-                DoneEvent.Signal(); 
-            } else { 
-                ctx.Schedule(ScheduleDelta, new TEvents::TEvWakeup()); 
-            } 
-        } 
- 
+            const TInstant now = ctx.Now();
+            UNIT_ASSERT(now - LastWakeup >= ScheduleDelta);
+            LastWakeup = now;
+
+            if (AtomicIncrement(EventsProcessed) == EventsTotalCount) {
+                DoneEvent.Signal();
+            } else {
+                ctx.Schedule(ScheduleDelta, new TEvents::TEvWakeup());
+            }
+        }
+
         STRICT_STFUNC(StateFunc, {HFunc(TEvents::TEvWakeup, Handle)})
-    }; 
- 
-    void Test(TAtomicBase eventsTotalCount, ui32 scheduleDeltaMs) { 
+    };
+
+    void Test(TAtomicBase eventsTotalCount, ui32 scheduleDeltaMs) {
         THolder<TActorSystemSetup> setup = MakeHolder<TActorSystemSetup>();
-        setup->NodeId = 0; 
-        setup->ExecutorsCount = 1; 
+        setup->NodeId = 0;
+        setup->ExecutorsCount = 1;
         setup->Executors.Reset(new TAutoPtr<IExecutorPool>[setup->ExecutorsCount]);
-        for (ui32 i = 0; i < setup->ExecutorsCount; ++i) { 
-            setup->Executors[i] = new TBasicExecutorPool(i, 5, 10, "basic"); 
-        } 
-        // create poller actor (whether platform supports it) 
+        for (ui32 i = 0; i < setup->ExecutorsCount; ++i) {
+            setup->Executors[i] = new TBasicExecutorPool(i, 5, 10, "basic");
+        }
+        // create poller actor (whether platform supports it)
         TActorId pollerActorId;
         if (IActor* poller = CreatePollerActor()) {
             pollerActorId = MakePollerActorId();
-            setup->LocalServices.emplace_back(pollerActorId, TActorSetupCmd(poller, TMailboxType::ReadAsFilled, 0)); 
-        } 
+            setup->LocalServices.emplace_back(pollerActorId, TActorSetupCmd(poller, TMailboxType::ReadAsFilled, 0));
+        }
         TActorId schedulerActorId;
         if (IActor* schedulerActor = CreateSchedulerActor(TSchedulerConfig())) {
             schedulerActorId = MakeSchedulerActorId();
-            setup->LocalServices.emplace_back(schedulerActorId, TActorSetupCmd(schedulerActor, TMailboxType::ReadAsFilled, 0)); 
-        } 
-        setup->Scheduler = CreateSchedulerThread(TSchedulerConfig()); 
- 
-        TActorSystem actorSystem(setup); 
- 
-        actorSystem.Start(); 
- 
-        TManualEvent doneEvent; 
-        TAtomic eventsProcessed = 0; 
-        actorSystem.Register(new TTestActor(doneEvent, eventsProcessed, eventsTotalCount, scheduleDeltaMs)); 
-        doneEvent.WaitI(); 
- 
-        UNIT_ASSERT(AtomicGet(eventsProcessed) == eventsTotalCount); 
- 
-        actorSystem.Stop(); 
-    } 
- 
+            setup->LocalServices.emplace_back(schedulerActorId, TActorSetupCmd(schedulerActor, TMailboxType::ReadAsFilled, 0));
+        }
+        setup->Scheduler = CreateSchedulerThread(TSchedulerConfig());
+
+        TActorSystem actorSystem(setup);
+
+        actorSystem.Start();
+
+        TManualEvent doneEvent;
+        TAtomic eventsProcessed = 0;
+        actorSystem.Register(new TTestActor(doneEvent, eventsProcessed, eventsTotalCount, scheduleDeltaMs));
+        doneEvent.WaitI();
+
+        UNIT_ASSERT(AtomicGet(eventsProcessed) == eventsTotalCount);
+
+        actorSystem.Stop();
+    }
+
     Y_UNIT_TEST(LongEvents) {
-        Test(10, 500); 
-    } 
- 
+        Test(10, 500);
+    }
+
     Y_UNIT_TEST(MediumEvents) {
-        Test(100, 50); 
-    } 
- 
+        Test(100, 50);
+    }
+
     Y_UNIT_TEST(QuickEvents) {
-        Test(1000, 5); 
-    } 
-} 
+        Test(1000, 5);
+    }
+}
diff --git a/library/cpp/actors/core/scheduler_basic.cpp b/library/cpp/actors/core/scheduler_basic.cpp
index ab5919c15f..fba200e16b 100644
--- a/library/cpp/actors/core/scheduler_basic.cpp
+++ b/library/cpp/actors/core/scheduler_basic.cpp
@@ -42,7 +42,7 @@ namespace NActors {
         , StopFlag(false)
         , ScheduleMap(3600)
     {
-        Y_VERIFY(!Config.UseSchedulerActor, "Cannot create scheduler thread because Config.UseSchedulerActor# true"); 
+        Y_VERIFY(!Config.UseSchedulerActor, "Cannot create scheduler thread because Config.UseSchedulerActor# true");
     }
 
     TBasicSchedulerThread::~TBasicSchedulerThread() {
@@ -247,28 +247,28 @@ namespace NActors {
         MainCycle->Get();
         MainCycle.Destroy();
     }
- 
+
 }
- 
-#ifdef __linux__ 
- 
-namespace NActors { 
-    ISchedulerThread* CreateSchedulerThread(const TSchedulerConfig& config) { 
-        if (config.UseSchedulerActor) { 
-            return new TMockSchedulerThread(); 
-        } else { 
-            return new TBasicSchedulerThread(config); 
-        } 
-    } 
- 
+
+#ifdef __linux__
+
+namespace NActors {
+    ISchedulerThread* CreateSchedulerThread(const TSchedulerConfig& config) {
+        if (config.UseSchedulerActor) {
+            return new TMockSchedulerThread();
+        } else {
+            return new TBasicSchedulerThread(config);
+        }
+    }
+
 }
- 
-#else //  __linux__ 
- 
-namespace NActors { 
+
+#else //  __linux__
+
+namespace NActors {
     ISchedulerThread* CreateSchedulerThread(const TSchedulerConfig& config) {
-        return new TBasicSchedulerThread(config); 
-    } 
+        return new TBasicSchedulerThread(config);
+    }
 }
- 
-#endif // __linux__ 
+
+#endif // __linux__
diff --git a/library/cpp/actors/core/scheduler_basic.h b/library/cpp/actors/core/scheduler_basic.h
index 043cc5257d..2ccde39235 100644
--- a/library/cpp/actors/core/scheduler_basic.h
+++ b/library/cpp/actors/core/scheduler_basic.h
@@ -49,33 +49,33 @@ namespace NActors {
         void PrepareStop() override;
         void Stop() override;
     };
- 
+
     class TMockSchedulerThread: public ISchedulerThread {
-    public: 
-        virtual ~TMockSchedulerThread() override { 
-        } 
- 
+    public:
+        virtual ~TMockSchedulerThread() override {
+        }
+
         void Prepare(TActorSystem* actorSystem, volatile ui64* currentTimestamp, volatile ui64* currentMonotonic) override {
-            Y_UNUSED(actorSystem); 
+            Y_UNUSED(actorSystem);
             *currentTimestamp = TInstant::Now().MicroSeconds();
             *currentMonotonic = GetMonotonicMicroSeconds();
-        } 
- 
+        }
+
         void PrepareSchedules(NSchedulerQueue::TReader** readers, ui32 scheduleReadersCount) override {
-            Y_UNUSED(readers); 
-            Y_UNUSED(scheduleReadersCount); 
-        } 
- 
-        void Start() override { 
-        } 
- 
-        void PrepareStop() override { 
-        } 
- 
-        void Stop() override { 
-        } 
-    }; 
- 
+            Y_UNUSED(readers);
+            Y_UNUSED(scheduleReadersCount);
+        }
+
+        void Start() override {
+        }
+
+        void PrepareStop() override {
+        }
+
+        void Stop() override {
+        }
+    };
+
     ISchedulerThread* CreateSchedulerThread(const TSchedulerConfig& cfg);
- 
+
 }
diff --git a/library/cpp/actors/core/ut/ya.make b/library/cpp/actors/core/ut/ya.make
index 50d885b1b3..3ee28d5850 100644
--- a/library/cpp/actors/core/ut/ya.make
+++ b/library/cpp/actors/core/ut/ya.make
@@ -23,11 +23,11 @@ ELSE()
 ENDIF()
 
 
-PEERDIR( 
+PEERDIR(
     library/cpp/actors/interconnect
     library/cpp/actors/testlib
-) 
- 
+)
+
 SRCS(
     actor_coroutine_ut.cpp
     actor_ut.cpp
diff --git a/library/cpp/actors/core/ya.make b/library/cpp/actors/core/ya.make
index a583363523..880a9d00db 100644
--- a/library/cpp/actors/core/ya.make
+++ b/library/cpp/actors/core/ya.make
@@ -89,8 +89,8 @@ SRCS(
     probes.h
     process_stats.cpp
     process_stats.h
-    scheduler_actor.cpp 
-    scheduler_actor.h 
+    scheduler_actor.cpp
+    scheduler_actor.h
     scheduler_basic.cpp
     scheduler_basic.h
     scheduler_cookie.cpp