Restoring authorship annotation for Alexey Borzenkov <snaury@yandex-team.ru>. Commit 2 of 2.

contrib/libs/grpc/src/core/lib/surface/call.cc

@@ -63,8 +63,8 @@
 #include "src/core/lib/transport/status_metadata.h"
 #include "src/core/lib/transport/transport.h"
 
-#include <util/system/yassert.h> 
- 
+#include <util/system/yassert.h>
+
 /** The maximum number of concurrent batches possible.
     Based upon the maximum number of individually queueable ops in the batch
     api:
@@ -1915,7 +1915,7 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
 
   GRPC_CALL_INTERNAL_REF(call, "completion");
   if (!is_notify_tag_closure) {
-    Y_VERIFY(grpc_cq_begin_op(call->cq, notify_tag)); 
+    Y_VERIFY(grpc_cq_begin_op(call->cq, notify_tag));
   }
   bctl->set_num_steps_to_complete((has_send_ops ? 1 : 0) + num_recv_ops);
 

library/cpp/actors/core/actor.cpp

@@ -37,10 +37,10 @@ namespace NActors {
         TlsActivationContext->ExecutorThread.Schedule(deadline, ev, cookie);
     }
 
-    void TActivationContext::Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie) { 
-        TlsActivationContext->ExecutorThread.Schedule(deadline, ev, cookie); 
-    } 
- 
+    void TActivationContext::Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie) {
+        TlsActivationContext->ExecutorThread.Schedule(deadline, ev, cookie);
+    }
+
     void TActivationContext::Schedule(TDuration delta, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie) {
         TlsActivationContext->ExecutorThread.Schedule(delta, ev, cookie);
     }
@@ -87,14 +87,14 @@ namespace NActors {
         return TlsActivationContext->ExecutorThread.ActorSystem;
     }
 
-    i64 TActivationContext::GetCurrentEventTicks() { 
+    i64 TActivationContext::GetCurrentEventTicks() {
         return GetCycleCountFast() - TlsActivationContext->EventStart;
-    } 
- 
-    double TActivationContext::GetCurrentEventTicksAsSeconds() { 
-        return NHPTimer::GetSeconds(GetCurrentEventTicks()); 
-    } 
- 
+    }
+
+    double TActivationContext::GetCurrentEventTicksAsSeconds() {
+        return NHPTimer::GetSeconds(GetCurrentEventTicks());
+    }
+
     TActorId TActorContext::Register(IActor* actor, TMailboxType::EType mailboxType, ui32 poolId) const {
         return ExecutorThread.RegisterActor(actor, mailboxType, poolId, SelfID);
     }
@@ -107,10 +107,10 @@ namespace NActors {
         ExecutorThread.Schedule(deadline, new IEventHandle(SelfID, TActorId(), ev), cookie);
     }
 
-    void TActorContext::Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie) const { 
-        ExecutorThread.Schedule(deadline, new IEventHandle(SelfID, TActorId(), ev), cookie); 
-    } 
- 
+    void TActorContext::Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie) const {
+        ExecutorThread.Schedule(deadline, new IEventHandle(SelfID, TActorId(), ev), cookie);
+    }
+
     void TActorContext::Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie) const {
         ExecutorThread.Schedule(delta, new IEventHandle(SelfID, TActorId(), ev), cookie);
     }
@@ -119,10 +119,10 @@ namespace NActors {
         TlsActivationContext->ExecutorThread.Schedule(deadline, new IEventHandle(SelfActorId, TActorId(), ev), cookie);
     }
 
-    void IActor::Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie) const noexcept { 
-        TlsActivationContext->ExecutorThread.Schedule(deadline, new IEventHandle(SelfActorId, TActorId(), ev), cookie); 
-    } 
- 
+    void IActor::Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie) const noexcept {
+        TlsActivationContext->ExecutorThread.Schedule(deadline, new IEventHandle(SelfActorId, TActorId(), ev), cookie);
+    }
+
     void IActor::Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie) const noexcept {
         TlsActivationContext->ExecutorThread.Schedule(delta, new IEventHandle(SelfActorId, TActorId(), ev), cookie);
     }
@@ -131,10 +131,10 @@ namespace NActors {
         return TlsActivationContext->ExecutorThread.ActorSystem->Timestamp();
     }
 
-    TMonotonic TActivationContext::Monotonic() { 
-        return TlsActivationContext->ExecutorThread.ActorSystem->Monotonic(); 
-    } 
- 
+    TMonotonic TActivationContext::Monotonic() {
+        return TlsActivationContext->ExecutorThread.ActorSystem->Monotonic();
+    }
+
     TInstant TActorContext::Now() const {
         return ExecutorThread.ActorSystem->Timestamp();
     }

library/cpp/actors/core/actor.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "event.h"
-#include "monotonic.h" 
+#include "monotonic.h"
 #include <util/system/tls.h>
 #include <library/cpp/actors/util/local_process_key.h>
 
@@ -24,13 +24,13 @@ namespace NActors {
     public:
         TMailboxHeader& Mailbox;
         TExecutorThread& ExecutorThread;
-        const NHPTimer::STime EventStart; 
+        const NHPTimer::STime EventStart;
 
     protected:
-        explicit TActivationContext(TMailboxHeader& mailbox, TExecutorThread& executorThread, NHPTimer::STime eventStart) 
+        explicit TActivationContext(TMailboxHeader& mailbox, TExecutorThread& executorThread, NHPTimer::STime eventStart)
             : Mailbox(mailbox)
             , ExecutorThread(executorThread)
-            , EventStart(eventStart) 
+            , EventStart(eventStart)
         {
         }
 
@@ -40,22 +40,22 @@ namespace NActors {
         /**
          * Schedule one-shot event that will be send at given time point in the future.
          *
-         * @param deadline   the wallclock time point in future when event must be send 
+         * @param deadline   the wallclock time point in future when event must be send
          * @param ev         the event to send
          * @param cookie     cookie that will be piggybacked with event
          */
         static void Schedule(TInstant deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie = nullptr);
 
         /**
-         * Schedule one-shot event that will be send at given time point in the future. 
-         * 
-         * @param deadline   the monotonic time point in future when event must be send 
-         * @param ev         the event to send 
-         * @param cookie     cookie that will be piggybacked with event 
-         */ 
-        static void Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie = nullptr); 
- 
-        /** 
+         * Schedule one-shot event that will be send at given time point in the future.
+         *
+         * @param deadline   the monotonic time point in future when event must be send
+         * @param ev         the event to send
+         * @param cookie     cookie that will be piggybacked with event
+         */
+        static void Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie = nullptr);
+
+        /**
          * Schedule one-shot event that will be send after given delay.
          *
          * @param delta      the time from now to delay event sending
@@ -65,7 +65,7 @@ namespace NActors {
         static void Schedule(TDuration delta, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie = nullptr);
 
         static TInstant Now();
-        static TMonotonic Monotonic(); 
+        static TMonotonic Monotonic();
         NLog::TSettings* LoggerSettings() const;
 
         // register new actor in ActorSystem on new fresh mailbox.
@@ -83,16 +83,16 @@ namespace NActors {
 
         static TActorId InterconnectProxy(ui32 nodeid);
         static TActorSystem* ActorSystem();
- 
-        static i64 GetCurrentEventTicks(); 
-        static double GetCurrentEventTicksAsSeconds(); 
+
+        static i64 GetCurrentEventTicks();
+        static double GetCurrentEventTicksAsSeconds();
     };
 
     struct TActorContext: public TActivationContext {
         const TActorId SelfID;
 
         explicit TActorContext(TMailboxHeader& mailbox, TExecutorThread& executorThread, NHPTimer::STime eventStart, const TActorId& selfID)
-            : TActivationContext(mailbox, executorThread, eventStart) 
+            : TActivationContext(mailbox, executorThread, eventStart)
             , SelfID(selfID)
         {
         }
@@ -110,22 +110,22 @@ namespace NActors {
         /**
          * Schedule one-shot event that will be send at given time point in the future.
          *
-         * @param deadline   the wallclock time point in future when event must be send 
+         * @param deadline   the wallclock time point in future when event must be send
          * @param ev         the event to send
          * @param cookie     cookie that will be piggybacked with event
          */
         void Schedule(TInstant deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const;
 
         /**
-         * Schedule one-shot event that will be send at given time point in the future. 
-         * 
-         * @param deadline   the monotonic time point in future when event must be send 
-         * @param ev         the event to send 
-         * @param cookie     cookie that will be piggybacked with event 
-         */ 
-        void Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const; 
- 
-        /** 
+         * Schedule one-shot event that will be send at given time point in the future.
+         *
+         * @param deadline   the monotonic time point in future when event must be send
+         * @param ev         the event to send
+         * @param cookie     cookie that will be piggybacked with event
+         */
+        void Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const;
+
+        /**
          * Schedule one-shot event that will be send after given delay.
          *
          * @param delta      the time from now to delay event sending
@@ -135,7 +135,7 @@ namespace NActors {
         void Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const;
 
         TActorContext MakeFor(const TActorId& otherId) const {
-            return TActorContext(Mailbox, ExecutorThread, EventStart, otherId); 
+            return TActorContext(Mailbox, ExecutorThread, EventStart, otherId);
         }
 
         // register new actor in ActorSystem on new fresh mailbox.
@@ -179,22 +179,22 @@ namespace NActors {
         /**
          * Schedule one-shot event that will be send at given time point in the future.
          *
-         * @param deadline   the wallclock time point in future when event must be send 
+         * @param deadline   the wallclock time point in future when event must be send
          * @param ev         the event to send
          * @param cookie     cookie that will be piggybacked with event
          */
         virtual void Schedule(TInstant deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept = 0;
 
         /**
-         * Schedule one-shot event that will be send at given time point in the future. 
-         * 
-         * @param deadline   the monotonic time point in future when event must be send 
-         * @param ev         the event to send 
-         * @param cookie     cookie that will be piggybacked with event 
-         */ 
-        virtual void Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept = 0; 
- 
-        /** 
+         * Schedule one-shot event that will be send at given time point in the future.
+         *
+         * @param deadline   the monotonic time point in future when event must be send
+         * @param ev         the event to send
+         * @param cookie     cookie that will be piggybacked with event
+         */
+        virtual void Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept = 0;
+
+        /**
          * Schedule one-shot event that will be send after given delay.
          *
          * @param delta      the time from now to delay event sending
@@ -240,11 +240,11 @@ namespace NActors {
             INTERCONNECT_SESSION_KILLER = 286,
             ACTOR_SYSTEM_SCHEDULER_ACTOR = 312,
             ACTOR_FUTURE_CALLBACK = 337,
-            INTERCONNECT_MONACTOR = 362, 
+            INTERCONNECT_MONACTOR = 362,
             INTERCONNECT_LOAD_ACTOR = 376,
             INTERCONNECT_LOAD_RESPONDER = 377,
             NAMESERVICE = 450,
-            DNS_RESOLVER = 481, 
+            DNS_RESOLVER = 481,
             INTERCONNECT_PROXY_WRAPPER = 546,
         };
 
@@ -362,7 +362,7 @@ namespace NActors {
         }
 
         void Schedule(TInstant deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept final;
-        void Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept final; 
+        void Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept final;
         void Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept final;
 
         // register new actor in ActorSystem on new fresh mailbox.
@@ -456,7 +456,7 @@ namespace NActors {
 
     inline TActorContext TActivationContext::ActorContextFor(TActorId id) {
         auto& tls = *TlsActivationContext;
-        return TActorContext(tls.Mailbox, tls.ExecutorThread, tls.EventStart, id); 
+        return TActorContext(tls.Mailbox, tls.ExecutorThread, tls.EventStart, id);
     }
 
     class TDecorator : public IActor {

library/cpp/actors/core/actor_coroutine.cpp

@@ -1,9 +1,9 @@
 #include "actor_coroutine.h"
 #include "executor_thread.h"
 
-#include <util/system/sanitizers.h> 
+#include <util/system/sanitizers.h>
 #include <util/system/type_name.h>
- 
+
 namespace NActors {
     static constexpr size_t StackOverflowGap = 4096;
     static char GoodStack[StackOverflowGap];
@@ -92,8 +92,8 @@ namespace NActors {
         }
 
         // prepare actor context for in-coroutine use
-        TActivationContext *ac = TlsActivationContext; 
-        TlsActivationContext = nullptr; 
+        TActivationContext *ac = TlsActivationContext;
+        TlsActivationContext = nullptr;
         TActorContext ctx(ac->Mailbox, ac->ExecutorThread, ac->EventStart, SelfActorId);
         ActorContext = &ctx;
 

library/cpp/actors/core/actorid.h

@@ -12,13 +12,13 @@ namespace NActors {
     // next 20 bits - node id itself
 
     struct TActorId {
-        static constexpr ui32 MaxServiceIDLength = 12; 
-        static constexpr ui32 MaxPoolID = 0x000007FF; 
-        static constexpr ui32 MaxNodeId = 0x000FFFFF; 
-        static constexpr ui32 PoolIndexShift = 20; 
-        static constexpr ui32 PoolIndexMask = MaxPoolID << PoolIndexShift; 
-        static constexpr ui32 ServiceMask = 0x80000000; 
-        static constexpr ui32 NodeIdMask = MaxNodeId; 
+        static constexpr ui32 MaxServiceIDLength = 12;
+        static constexpr ui32 MaxPoolID = 0x000007FF;
+        static constexpr ui32 MaxNodeId = 0x000FFFFF;
+        static constexpr ui32 PoolIndexShift = 20;
+        static constexpr ui32 PoolIndexMask = MaxPoolID << PoolIndexShift;
+        static constexpr ui32 ServiceMask = 0x80000000;
+        static constexpr ui32 NodeIdMask = MaxNodeId;
 
     private:
         union {

library/cpp/actors/core/actorsystem.cpp

@@ -43,7 +43,7 @@ namespace NActors {
         , Scheduler(setup->Scheduler)
         , InterconnectCount((ui32)setup->Interconnect.ProxyActors.size())
         , CurrentTimestamp(0)
-        , CurrentMonotonic(0) 
+        , CurrentMonotonic(0)
         , CurrentIDCounter(RandomNumber<ui64>())
         , SystemSetup(setup.Release())
         , DefSelfID(NodeId, "actorsystem")
@@ -69,15 +69,15 @@ namespace NActors {
 #endif
 
         TActorId recipient = ev->GetRecipientRewrite();
-        const ui32 recpNodeId = recipient.NodeId(); 
+        const ui32 recpNodeId = recipient.NodeId();
 
         if (recpNodeId != NodeId && recpNodeId != 0) {
             // if recipient is not local one - rewrite with forward instruction
             Y_VERIFY_DEBUG(!ev->HasEvent() || ev->GetBase()->IsSerializable());
-            Y_VERIFY(ev->Recipient == recipient, 
-                "Event rewrite from %s to %s would be lost via interconnect", 
-                ev->Recipient.ToString().c_str(), 
-                recipient.ToString().c_str()); 
+            Y_VERIFY(ev->Recipient == recipient,
+                "Event rewrite from %s to %s would be lost via interconnect",
+                ev->Recipient.ToString().c_str(),
+                recipient.ToString().c_str());
             recipient = InterconnectProxy(recpNodeId);
             ev->Rewrite(TEvInterconnect::EvForward, recipient);
         }
@@ -119,20 +119,20 @@ namespace NActors {
     }
 
     void TActorSystem::Schedule(TInstant deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie) const {
-        Schedule(deadline - Timestamp(), ev, cookie); 
+        Schedule(deadline - Timestamp(), ev, cookie);
+    }
+
+    void TActorSystem::Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie) const {
+        const auto current = Monotonic();
+        if (deadline < current)
+            deadline = current;
+
+        TTicketLock::TGuard guard(&ScheduleLock);
+        ScheduleQueue->Writer.Push(deadline.MicroSeconds(), ev.Release(), cookie);
     }
 
-    void TActorSystem::Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie) const { 
-        const auto current = Monotonic(); 
-        if (deadline < current) 
-            deadline = current; 
- 
-        TTicketLock::TGuard guard(&ScheduleLock); 
-        ScheduleQueue->Writer.Push(deadline.MicroSeconds(), ev.Release(), cookie); 
-    } 
- 
     void TActorSystem::Schedule(TDuration delta, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie) const {
-        const auto deadline = Monotonic() + delta; 
+        const auto deadline = Monotonic() + delta;
 
         TTicketLock::TGuard guard(&ScheduleLock);
         ScheduleQueue->Writer.Push(deadline.MicroSeconds(), ev.Release(), cookie);
@@ -211,7 +211,7 @@ namespace NActors {
         TVector<NSchedulerQueue::TReader*> scheduleReaders;
         scheduleReaders.push_back(&ScheduleQueue->Reader);
         CpuManager->PrepareStart(scheduleReaders, this);
-        Scheduler->Prepare(this, &CurrentTimestamp, &CurrentMonotonic); 
+        Scheduler->Prepare(this, &CurrentTimestamp, &CurrentMonotonic);
         Scheduler->PrepareSchedules(&scheduleReaders.front(), (ui32)scheduleReaders.size());
 
         // setup interconnect proxies
@@ -242,9 +242,9 @@ namespace NActors {
         // ok, setup complete, we could destroy setup config
         SystemSetup.Destroy();
 
-        Scheduler->PrepareStart(); 
+        Scheduler->PrepareStart();
         CpuManager->Start();
-        Send(MakeSchedulerActorId(), new TEvSchedulerInitialize(scheduleReaders, &CurrentTimestamp, &CurrentMonotonic)); 
+        Send(MakeSchedulerActorId(), new TEvSchedulerInitialize(scheduleReaders, &CurrentTimestamp, &CurrentMonotonic));
         Scheduler->Start();
     }
 

library/cpp/actors/core/actorsystem.h

@@ -27,7 +27,7 @@ namespace NActors {
         char data[12];
         memcpy(data, "ICProxy@", 8);
         memcpy(data + 8, &destNodeId, sizeof(ui32));
-        return TActorId(0, TStringBuf(data, 12)); 
+        return TActorId(0, TStringBuf(data, 12));
     }
 
     inline bool IsInterconnectProxyId(const TActorId& actorId) {
@@ -69,7 +69,7 @@ namespace NActors {
         /**
          * Schedule one-shot event that will be send at given time point in the future.
          *
-         * @param deadline   the wallclock time point in future when event must be send 
+         * @param deadline   the wallclock time point in future when event must be send
          * @param ev         the event to send
          * @param cookie     cookie that will be piggybacked with event
          * @param workerId   index of thread which will perform event dispatching
@@ -77,16 +77,16 @@ namespace NActors {
         virtual void Schedule(TInstant deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie, TWorkerId workerId) = 0;
 
         /**
-         * Schedule one-shot event that will be send at given time point in the future. 
-         * 
-         * @param deadline   the monotonic time point in future when event must be send 
-         * @param ev         the event to send 
-         * @param cookie     cookie that will be piggybacked with event 
+         * Schedule one-shot event that will be send at given time point in the future.
+         *
+         * @param deadline   the monotonic time point in future when event must be send
+         * @param ev         the event to send
+         * @param cookie     cookie that will be piggybacked with event
          * @param workerId   index of thread which will perform event dispatching
-         */ 
+         */
         virtual void Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie, TWorkerId workerId) = 0;
- 
-        /** 
+
+        /**
          * Schedule one-shot event that will be send after given delay.
          *
          * @param delta      the time from now to delay event sending
@@ -136,9 +136,9 @@ namespace NActors {
         virtual ~ISchedulerThread() {
         }
 
-        virtual void Prepare(TActorSystem* actorSystem, volatile ui64* currentTimestamp, volatile ui64* currentMonotonic) = 0; 
+        virtual void Prepare(TActorSystem* actorSystem, volatile ui64* currentTimestamp, volatile ui64* currentMonotonic) = 0;
         virtual void PrepareSchedules(NSchedulerQueue::TReader** readers, ui32 scheduleReadersCount) = 0;
-        virtual void PrepareStart() { /* empty */ } 
+        virtual void PrepareStart() { /* empty */ }
         virtual void Start() = 0;
         virtual void PrepareStop() = 0;
         virtual void Stop() = 0;
@@ -226,7 +226,7 @@ namespace NActors {
         TArrayHolder<TActorId> Interconnect;
 
         volatile ui64 CurrentTimestamp;
-        volatile ui64 CurrentMonotonic; 
+        volatile ui64 CurrentMonotonic;
         volatile ui64 CurrentIDCounter;
 
         THolder<NSchedulerQueue::TQueueType> ScheduleQueue;
@@ -264,22 +264,22 @@ namespace NActors {
         /**
          * Schedule one-shot event that will be send at given time point in the future.
          *
-         * @param deadline   the wallclock time point in future when event must be send 
+         * @param deadline   the wallclock time point in future when event must be send
          * @param ev         the event to send
          * @param cookie     cookie that will be piggybacked with event
          */
         void Schedule(TInstant deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie = nullptr) const;
 
         /**
-         * Schedule one-shot event that will be send at given time point in the future. 
-         * 
-         * @param deadline   the monotonic time point in future when event must be send 
-         * @param ev         the event to send 
-         * @param cookie     cookie that will be piggybacked with event 
-         */ 
-        void Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie = nullptr) const; 
- 
-        /** 
+         * Schedule one-shot event that will be send at given time point in the future.
+         *
+         * @param deadline   the monotonic time point in future when event must be send
+         * @param ev         the event to send
+         * @param cookie     cookie that will be piggybacked with event
+         */
+        void Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie = nullptr) const;
+
+        /**
          * Schedule one-shot event that will be send after given delay.
          *
          * @param delta      the time from now to delay event sending
@@ -340,10 +340,10 @@ namespace NActors {
             return TInstant::MicroSeconds(RelaxedLoad(&CurrentTimestamp));
         }
 
-        TMonotonic Monotonic() const { 
-            return TMonotonic::MicroSeconds(RelaxedLoad(&CurrentMonotonic)); 
-        } 
- 
+        TMonotonic Monotonic() const {
+            return TMonotonic::MicroSeconds(RelaxedLoad(&CurrentMonotonic));
+        }
+
         template <typename T>
         T* AppData() const {
             return (T*)AppData0;

library/cpp/actors/core/events.h

@@ -4,7 +4,7 @@
 #include "event_pb.h"
 
 #include <library/cpp/actors/protos/actors.pb.h>
-#include <util/system/unaligned_mem.h> 
+#include <util/system/unaligned_mem.h>
 
 namespace NActors {
     struct TEvents {
@@ -161,9 +161,9 @@ namespace NActors {
         private:
             static TString MakeData(ui32 sourceType, ui32 reason) {
                 TString s = TString::Uninitialized(sizeof(ui32) + sizeof(ui32));
-                char *p = s.Detach(); 
-                WriteUnaligned<ui32>(p + 0, sourceType); 
-                WriteUnaligned<ui32>(p + 4, reason); 
+                char *p = s.Detach();
+                WriteUnaligned<ui32>(p + 0, sourceType);
+                WriteUnaligned<ui32>(p + 4, reason);
                 return s;
             }
         };

library/cpp/actors/core/events_undelivered.cpp

@@ -32,9 +32,9 @@ namespace NActors {
     IEventBase* TEvents::TEvUndelivered::Load(TEventSerializedData* bufs) {
         TString str = bufs->GetString();
         Y_VERIFY(str.size() == (sizeof(ui32) + sizeof(ui32)));
-        const char* p = str.data(); 
-        const ui64 sourceType = ReadUnaligned<ui32>(p + 0); 
-        const ui64 reason = ReadUnaligned<ui32>(p + 4); 
+        const char* p = str.data();
+        const ui64 sourceType = ReadUnaligned<ui32>(p + 0);
+        const ui64 reason = ReadUnaligned<ui32>(p + 4);
         return new TEvUndelivered(sourceType, reason);
     }
 

library/cpp/actors/core/executor_pool_basic.cpp

@@ -87,17 +87,17 @@ namespace NActors {
         if (x < 0) {
 #if defined ACTORSLIB_COLLECT_EXEC_STATS
             if (AtomicGetAndIncrement(ThreadUtilization) == 0) {
-                // Initially counter contains -t0, the pool start timestamp 
-                // When the first thread goes to sleep we add t1, so the counter 
-                // becomes t1-t0 >= 0, or the duration of max utilization so far. 
-                // If the counter was negative and becomes positive, that means 
-                // counter just turned into a duration and we should store that 
-                // duration. Otherwise another thread raced with us and 
-                // subtracted some other timestamp t2. 
+                // Initially counter contains -t0, the pool start timestamp
+                // When the first thread goes to sleep we add t1, so the counter
+                // becomes t1-t0 >= 0, or the duration of max utilization so far.
+                // If the counter was negative and becomes positive, that means
+                // counter just turned into a duration and we should store that
+                // duration. Otherwise another thread raced with us and
+                // subtracted some other timestamp t2.
                 const i64 t = GetCycleCountFast();
-                const i64 x = AtomicGetAndAdd(MaxUtilizationCounter, t); 
-                if (x < 0 && x + t > 0) 
-                    AtomicStore(&MaxUtilizationAccumulator, x + t); 
+                const i64 x = AtomicGetAndAdd(MaxUtilizationCounter, t);
+                if (x < 0 && x + t > 0)
+                    AtomicStore(&MaxUtilizationAccumulator, x + t);
             }
 #endif
 
@@ -126,7 +126,7 @@ namespace NActors {
                     if (!doSpin) {
                         break;
                     }
-                    if (RelaxedLoad(&StopFlag)) { 
+                    if (RelaxedLoad(&StopFlag)) {
                         break;
                     }
                 }
@@ -159,20 +159,20 @@ namespace NActors {
 
 #if defined ACTORSLIB_COLLECT_EXEC_STATS
             if (AtomicDecrement(ThreadUtilization) == 0) {
-                // When we started sleeping counter contained t1-t0, or the 
-                // last duration of max utilization. Now we subtract t2 >= t1, 
-                // which turns counter negative again, and the next sleep cycle 
-                // at timestamp t3 would be adding some new duration t3-t2. 
-                // If the counter was positive and becomes negative that means 
-                // there are no current races with other threads and we should 
-                // store the last positive duration we observed. Multiple 
-                // threads may be adding and subtracting values in potentially 
-                // arbitrary order, which would cause counter to oscillate 
-                // around zero. When it crosses zero is a good indication of a 
-                // correct value. 
+                // When we started sleeping counter contained t1-t0, or the
+                // last duration of max utilization. Now we subtract t2 >= t1,
+                // which turns counter negative again, and the next sleep cycle
+                // at timestamp t3 would be adding some new duration t3-t2.
+                // If the counter was positive and becomes negative that means
+                // there are no current races with other threads and we should
+                // store the last positive duration we observed. Multiple
+                // threads may be adding and subtracting values in potentially
+                // arbitrary order, which would cause counter to oscillate
+                // around zero. When it crosses zero is a good indication of a
+                // correct value.
                 const i64 t = GetCycleCountFast();
-                const i64 x = AtomicGetAndAdd(MaxUtilizationCounter, -t); 
-                if (x > 0 && x - t < 0) 
+                const i64 x = AtomicGetAndAdd(MaxUtilizationCounter, -t);
+                if (x > 0 && x - t < 0)
                     AtomicStore(&MaxUtilizationAccumulator, x);
             }
 #endif
@@ -305,18 +305,18 @@ namespace NActors {
 
     void TBasicExecutorPool::Schedule(TMonotonic deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie, TWorkerId workerId) {
         Y_VERIFY_DEBUG(workerId < PoolThreads);
- 
-        const auto current = ActorSystem->Monotonic(); 
-        if (deadline < current) 
-            deadline = current; 
- 
+
+        const auto current = ActorSystem->Monotonic();
+        if (deadline < current)
+            deadline = current;
+
         ScheduleWriters[workerId].Push(deadline.MicroSeconds(), ev.Release(), cookie);
-    } 
- 
+    }
+
     void TBasicExecutorPool::Schedule(TDuration delta, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie, TWorkerId workerId) {
         Y_VERIFY_DEBUG(workerId < PoolThreads);
 
-        const auto deadline = ActorSystem->Monotonic() + delta; 
+        const auto deadline = ActorSystem->Monotonic() + delta;
         ScheduleWriters[workerId].Push(deadline.MicroSeconds(), ev.Release(), cookie);
     }