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

7 files changed, 332 insertions, 332 deletions

diff --git a/library/cpp/actors/util/affinity.cpp b/library/cpp/actors/util/affinity.cpp
index cc1b6e70ec..69f9048ec1 100644
--- a/library/cpp/actors/util/affinity.cpp
+++ b/library/cpp/actors/util/affinity.cpp
@@ -16,17 +16,17 @@ public:
 #endif
     }
 
-    explicit TImpl(const ui8* cpus, ui32 size) {
+    explicit TImpl(const ui8* cpus, ui32 size) { 
 #ifdef _linux_
         CPU_ZERO(&Mask);
-        for (ui32 i = 0; i != size; ++i) {
-            if (cpus[i]) {
-                CPU_SET(i, &Mask);
-            }
-        }
+        for (ui32 i = 0; i != size; ++i) { 
+            if (cpus[i]) { 
+                CPU_SET(i, &Mask); 
+            } 
+        } 
 #else
-        Y_UNUSED(cpus);
-        Y_UNUSED(size);
+        Y_UNUSED(cpus); 
+        Y_UNUSED(size); 
 #endif
     }
 
@@ -36,18 +36,18 @@ public:
         Y_VERIFY_DEBUG(ar == 0);
 #endif
     }
-
-    operator TCpuMask() const {
-        TCpuMask result;
-#ifdef _linux_
-        for (ui32 i = 0; i != CPU_SETSIZE; ++i) {
-            result.Cpus.emplace_back(CPU_ISSET(i, &Mask));
-        }
-        result.RemoveTrailingZeros();
-#endif
-        return result;
-    }
-
+ 
+    operator TCpuMask() const { 
+        TCpuMask result; 
+#ifdef _linux_ 
+        for (ui32 i = 0; i != CPU_SETSIZE; ++i) { 
+            result.Cpus.emplace_back(CPU_ISSET(i, &Mask)); 
+        } 
+        result.RemoveTrailingZeros(); 
+#endif 
+        return result; 
+    } 
+ 
 };
 
 TAffinity::TAffinity() {
@@ -57,37 +57,37 @@ TAffinity::~TAffinity() {
 }
 
 TAffinity::TAffinity(const ui8* x, ui32 sz) {
-    if (x && sz) {
-        Impl.Reset(new TImpl(x, sz));
-    }
-}
-
-TAffinity::TAffinity(const TCpuMask& mask) {
-    if (!mask.IsEmpty()) {
-        static_assert(sizeof(ui8) == sizeof(mask.Cpus[0]));
-        const ui8* x = reinterpret_cast<const ui8*>(&mask.Cpus[0]);
-        const ui32 sz = mask.Size();
+    if (x && sz) { 
         Impl.Reset(new TImpl(x, sz));
-    }
+    } 
 }
 
+TAffinity::TAffinity(const TCpuMask& mask) { 
+    if (!mask.IsEmpty()) { 
+        static_assert(sizeof(ui8) == sizeof(mask.Cpus[0])); 
+        const ui8* x = reinterpret_cast<const ui8*>(&mask.Cpus[0]); 
+        const ui32 sz = mask.Size(); 
+        Impl.Reset(new TImpl(x, sz)); 
+    } 
+} 
+ 
 void TAffinity::Current() {
     Impl.Reset(new TImpl());
 }
 
 void TAffinity::Set() const {
-    if (!!Impl) {
+    if (!!Impl) { 
         Impl->Set();
-    }
+    } 
 }
 
 bool TAffinity::Empty() const {
-    return !Impl;
-}
-
-TAffinity::operator TCpuMask() const {
-    if (!!Impl) {
-        return *Impl;
-    }
-    return TCpuMask();
+    return !Impl; 
 }
+ 
+TAffinity::operator TCpuMask() const { 
+    if (!!Impl) { 
+        return *Impl; 
+    } 
+    return TCpuMask(); 
+} 
diff --git a/library/cpp/actors/util/affinity.h b/library/cpp/actors/util/affinity.h
index ae106ed180..c807d03b76 100644
--- a/library/cpp/actors/util/affinity.h
+++ b/library/cpp/actors/util/affinity.h
@@ -1,27 +1,27 @@
 #pragma once
 
 #include "defs.h"
-#include "cpumask.h"
+#include "cpumask.h" 
 
-// Platform-specific class to set or get thread affinity
+// Platform-specific class to set or get thread affinity 
 class TAffinity: public TThrRefBase, TNonCopyable {
     class TImpl;
     THolder<TImpl> Impl;
 
 public:
     TAffinity();
-    TAffinity(const ui8* cpus, ui32 size);
-    explicit TAffinity(const TCpuMask& mask);
+    TAffinity(const ui8* cpus, ui32 size); 
+    explicit TAffinity(const TCpuMask& mask); 
     ~TAffinity();
 
     void Current();
     void Set() const;
     bool Empty() const;
-
-    operator TCpuMask() const;
+ 
+    operator TCpuMask() const; 
 };
 
-// Scoped affinity setter
+// Scoped affinity setter 
 class TAffinityGuard : TNonCopyable {
     bool Stacked;
     TAffinity OldAffinity;
diff --git a/library/cpp/actors/util/cpumask.h b/library/cpp/actors/util/cpumask.h
index 29741aa1d6..1f72ae3895 100644
--- a/library/cpp/actors/util/cpumask.h
+++ b/library/cpp/actors/util/cpumask.h
@@ -1,133 +1,133 @@
-#pragma once
-
-#include "defs.h"
-
-#include <library/cpp/containers/stack_vector/stack_vec.h>
-
-#include <util/string/split.h>
-#include <util/generic/yexception.h>
-
-using TCpuId = ui32;
-
-// Simple data structure to operate with set of cpus
-struct TCpuMask {
-    TStackVec<bool, 1024> Cpus;
-
-    // Creates empty mask
-    TCpuMask() {}
-
-    // Creates mask with single cpu set
-    explicit TCpuMask(TCpuId cpuId) {
-        Set(cpuId);
-    }
-
-    // Initialize mask from raw boolean array
-    template <class T>
-    TCpuMask(const T* cpus, TCpuId size) {
-        Cpus.reserve(size);
-        for (TCpuId i = 0; i != size; ++i) {
-            Cpus.emplace_back(bool(cpus[i]));
-        }
-    }
-
-    // Parse a numerical list of processors. The numbers are separated by commas and may include ranges. For example: 0,5,7,9-11
-    explicit TCpuMask(const TString& cpuList) {
-        try {
-            for (TStringBuf s : StringSplitter(cpuList).Split(',')) {
-                TCpuId l, r;
-                if (s.find('-') != TString::npos) {
-                    StringSplitter(s).Split('-').CollectInto(&l, &r);
-                } else {
-                    l = r = FromString<TCpuId>(s);
-                }
-                if (r >= Cpus.size()) {
-                    Cpus.resize(r + 1, false);
-                }
-                for (TCpuId cpu = l; cpu <= r; cpu++) {
-                    Cpus[cpu] = true;
-                }
-            }
-        } catch (...) {
-            ythrow TWithBackTrace<yexception>() << "Exception occured while parsing cpu list '" << cpuList << "': " << CurrentExceptionMessage();
-        }
-    }
-
-    // Returns size of underlying vector
-    TCpuId Size() const {
-        return Cpus.size();
-    }
-
-    // Returns number of set bits in mask
-    TCpuId CpuCount() const {
-        TCpuId result = 0;
-        for (bool value : Cpus) {
-            result += value;
-        }
-        return result;
-    }
-
-    bool IsEmpty() const {
-        for (bool value : Cpus) {
-            if (value) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    bool IsSet(TCpuId cpu) const {
-        return cpu < Cpus.size() && Cpus[cpu];
-    }
-
-    void Set(TCpuId cpu) {
-        if (cpu >= Cpus.size()) {
-            Cpus.resize(cpu + 1, false);
-        }
-        Cpus[cpu] = true;
-    }
-
-    void Reset(TCpuId cpu) {
-        if (cpu < Cpus.size()) {
-            Cpus[cpu] = false;
-        }
-    }
-
-    void RemoveTrailingZeros() {
-        while (!Cpus.empty() && !Cpus.back()) {
-            Cpus.pop_back();
-        }
-    }
-
-    explicit operator bool() const {
-        return !IsEmpty();
-    }
-
-    TCpuMask operator &(const TCpuMask& rhs) const {
-        TCpuMask result;
-        TCpuId size = Max(Size(), rhs.Size());
-        result.Cpus.reserve(size);
-        for (TCpuId cpu = 0; cpu < size; cpu++) {
-            result.Cpus.emplace_back(IsSet(cpu) && rhs.IsSet(cpu));
-        }
-        return result;
-    }
-
-    TCpuMask operator |(const TCpuMask& rhs) const {
-        TCpuMask result;
-        TCpuId size = Max(Size(), rhs.Size());
-        result.Cpus.reserve(size);
-        for (TCpuId cpu = 0; cpu < size; cpu++) {
-            result.Cpus.emplace_back(IsSet(cpu) || rhs.IsSet(cpu));
-        }
-        return result;
-    }
-
-    TCpuMask operator -(const TCpuMask& rhs) const {
-        TCpuMask result;
-        result.Cpus.reserve(Size());
-        for (TCpuId cpu = 0; cpu < Size(); cpu++) {
-            result.Cpus.emplace_back(IsSet(cpu) && !rhs.IsSet(cpu));
-        }
-        return result;
-    }
-};
+#pragma once 
+ 
+#include "defs.h" 
+ 
+#include <library/cpp/containers/stack_vector/stack_vec.h> 
+ 
+#include <util/string/split.h> 
+#include <util/generic/yexception.h> 
+ 
+using TCpuId = ui32; 
+ 
+// Simple data structure to operate with set of cpus 
+struct TCpuMask { 
+    TStackVec<bool, 1024> Cpus; 
+ 
+    // Creates empty mask 
+    TCpuMask() {} 
+ 
+    // Creates mask with single cpu set 
+    explicit TCpuMask(TCpuId cpuId) { 
+        Set(cpuId); 
+    } 
+ 
+    // Initialize mask from raw boolean array 
+    template <class T> 
+    TCpuMask(const T* cpus, TCpuId size) { 
+        Cpus.reserve(size); 
+        for (TCpuId i = 0; i != size; ++i) { 
+            Cpus.emplace_back(bool(cpus[i])); 
+        } 
+    } 
+ 
+    // Parse a numerical list of processors. The numbers are separated by commas and may include ranges. For example: 0,5,7,9-11 
+    explicit TCpuMask(const TString& cpuList) { 
+        try { 
+            for (TStringBuf s : StringSplitter(cpuList).Split(',')) { 
+                TCpuId l, r; 
+                if (s.find('-') != TString::npos) { 
+                    StringSplitter(s).Split('-').CollectInto(&l, &r); 
+                } else { 
+                    l = r = FromString<TCpuId>(s); 
+                } 
+                if (r >= Cpus.size()) { 
+                    Cpus.resize(r + 1, false); 
+                } 
+                for (TCpuId cpu = l; cpu <= r; cpu++) { 
+                    Cpus[cpu] = true; 
+                } 
+            } 
+        } catch (...) { 
+            ythrow TWithBackTrace<yexception>() << "Exception occured while parsing cpu list '" << cpuList << "': " << CurrentExceptionMessage(); 
+        } 
+    } 
+ 
+    // Returns size of underlying vector 
+    TCpuId Size() const { 
+        return Cpus.size(); 
+    } 
+ 
+    // Returns number of set bits in mask 
+    TCpuId CpuCount() const { 
+        TCpuId result = 0; 
+        for (bool value : Cpus) { 
+            result += value; 
+        } 
+        return result; 
+    } 
+ 
+    bool IsEmpty() const { 
+        for (bool value : Cpus) { 
+            if (value) { 
+                return false; 
+            } 
+        } 
+        return true; 
+    } 
+ 
+    bool IsSet(TCpuId cpu) const { 
+        return cpu < Cpus.size() && Cpus[cpu]; 
+    } 
+ 
+    void Set(TCpuId cpu) { 
+        if (cpu >= Cpus.size()) { 
+            Cpus.resize(cpu + 1, false); 
+        } 
+        Cpus[cpu] = true; 
+    } 
+ 
+    void Reset(TCpuId cpu) { 
+        if (cpu < Cpus.size()) { 
+            Cpus[cpu] = false; 
+        } 
+    } 
+ 
+    void RemoveTrailingZeros() { 
+        while (!Cpus.empty() && !Cpus.back()) { 
+            Cpus.pop_back(); 
+        } 
+    } 
+ 
+    explicit operator bool() const { 
+        return !IsEmpty(); 
+    } 
+ 
+    TCpuMask operator &(const TCpuMask& rhs) const { 
+        TCpuMask result; 
+        TCpuId size = Max(Size(), rhs.Size()); 
+        result.Cpus.reserve(size); 
+        for (TCpuId cpu = 0; cpu < size; cpu++) { 
+            result.Cpus.emplace_back(IsSet(cpu) && rhs.IsSet(cpu)); 
+        } 
+        return result; 
+    } 
+ 
+    TCpuMask operator |(const TCpuMask& rhs) const { 
+        TCpuMask result; 
+        TCpuId size = Max(Size(), rhs.Size()); 
+        result.Cpus.reserve(size); 
+        for (TCpuId cpu = 0; cpu < size; cpu++) { 
+            result.Cpus.emplace_back(IsSet(cpu) || rhs.IsSet(cpu)); 
+        } 
+        return result; 
+    } 
+ 
+    TCpuMask operator -(const TCpuMask& rhs) const { 
+        TCpuMask result; 
+        result.Cpus.reserve(Size()); 
+        for (TCpuId cpu = 0; cpu < Size(); cpu++) { 
+            result.Cpus.emplace_back(IsSet(cpu) && !rhs.IsSet(cpu)); 
+        } 
+        return result; 
+    } 
+}; 
diff --git a/library/cpp/actors/util/datetime.h b/library/cpp/actors/util/datetime.h
index cbec5965d6..4bdf57bbde 100644
--- a/library/cpp/actors/util/datetime.h
+++ b/library/cpp/actors/util/datetime.h
@@ -1,82 +1,82 @@
-#pragma once
-
-#include <util/system/defaults.h>
-#include <util/system/hp_timer.h>
-#include <util/system/platform.h>
-
-#if defined(_win_)
-#include <intrin.h>
-#pragma intrinsic(__rdtsc)
-#endif // _win_
-
-#if defined(_darwin_) && !defined(_x86_)
-#include <mach/mach_time.h>
-#endif
-
-// GetCycleCount() from util/system/datetime.h uses rdtscp, which is more accurate than rdtsc,
-// but rdtscp disables processor's out-of-order execution, so it can be slow
-Y_FORCE_INLINE ui64 GetCycleCountFast() {
-#if defined(_MSC_VER)
-    // Generates the rdtsc instruction, which returns the processor time stamp.
-    // The processor time stamp records the number of clock cycles since the last reset.
-    return __rdtsc();
-#elif defined(__clang__) && !defined(_arm64_)
-    return __builtin_readcyclecounter();
-#elif defined(_x86_64_)
-    unsigned hi, lo;
-    __asm__ __volatile__("rdtsc"
-                         : "=a"(lo), "=d"(hi));
-    return ((unsigned long long)lo) | (((unsigned long long)hi) << 32);
-#elif defined(_i386_)
-    ui64 x;
-    __asm__ volatile("rdtsc\n\t"
-                     : "=A"(x));
-    return x;
-#elif defined(_darwin_)
-    return mach_absolute_time();
-#elif defined(_arm32_)
-    return MicroSeconds();
-#elif defined(_arm64_)
-    ui64 x;
-
-    __asm__ __volatile__("isb; mrs %0, cntvct_el0"
-                         : "=r"(x));
-
-    return x;
-#else
-#error "unsupported arch"
-#endif
-}
-
-// NHPTimer::GetTime fast analog
-Y_FORCE_INLINE void GetTimeFast(NHPTimer::STime* pTime) noexcept {
-    *pTime = GetCycleCountFast();
-}
-
-namespace NActors {
-    inline double Ts2Ns(ui64 ts) {
-        return NHPTimer::GetSeconds(ts) * 1e9;
-    }
-
-    inline double Ts2Us(ui64 ts) {
-        return NHPTimer::GetSeconds(ts) * 1e6;
-    }
-
-    inline double Ts2Ms(ui64 ts) {
-        return NHPTimer::GetSeconds(ts) * 1e3;
-    }
-
-    inline ui64 Us2Ts(double us) {
-        return ui64(NHPTimer::GetClockRate() * us / 1e6);
-    }
-
-    struct TTimeTracker {
-        ui64 Ts;
-        TTimeTracker(): Ts(GetCycleCountFast()) {}
-        ui64 Elapsed() {
-            ui64 ts = GetCycleCountFast();
-            std::swap(Ts, ts);
-            return Ts - ts;
-        }
-    };
-}
+#pragma once 
+ 
+#include <util/system/defaults.h> 
+#include <util/system/hp_timer.h> 
+#include <util/system/platform.h> 
+ 
+#if defined(_win_) 
+#include <intrin.h> 
+#pragma intrinsic(__rdtsc) 
+#endif // _win_ 
+ 
+#if defined(_darwin_) && !defined(_x86_) 
+#include <mach/mach_time.h> 
+#endif 
+ 
+// GetCycleCount() from util/system/datetime.h uses rdtscp, which is more accurate than rdtsc, 
+// but rdtscp disables processor's out-of-order execution, so it can be slow 
+Y_FORCE_INLINE ui64 GetCycleCountFast() { 
+#if defined(_MSC_VER) 
+    // Generates the rdtsc instruction, which returns the processor time stamp. 
+    // The processor time stamp records the number of clock cycles since the last reset. 
+    return __rdtsc(); 
+#elif defined(__clang__) && !defined(_arm64_) 
+    return __builtin_readcyclecounter(); 
+#elif defined(_x86_64_) 
+    unsigned hi, lo; 
+    __asm__ __volatile__("rdtsc" 
+                         : "=a"(lo), "=d"(hi)); 
+    return ((unsigned long long)lo) | (((unsigned long long)hi) << 32); 
+#elif defined(_i386_) 
+    ui64 x; 
+    __asm__ volatile("rdtsc\n\t" 
+                     : "=A"(x)); 
+    return x; 
+#elif defined(_darwin_) 
+    return mach_absolute_time(); 
+#elif defined(_arm32_) 
+    return MicroSeconds(); 
+#elif defined(_arm64_) 
+    ui64 x; 
+ 
+    __asm__ __volatile__("isb; mrs %0, cntvct_el0" 
+                         : "=r"(x)); 
+ 
+    return x; 
+#else 
+#error "unsupported arch" 
+#endif 
+} 
+ 
+// NHPTimer::GetTime fast analog 
+Y_FORCE_INLINE void GetTimeFast(NHPTimer::STime* pTime) noexcept { 
+    *pTime = GetCycleCountFast(); 
+} 
+ 
+namespace NActors { 
+    inline double Ts2Ns(ui64 ts) { 
+        return NHPTimer::GetSeconds(ts) * 1e9; 
+    } 
+ 
+    inline double Ts2Us(ui64 ts) { 
+        return NHPTimer::GetSeconds(ts) * 1e6; 
+    } 
+ 
+    inline double Ts2Ms(ui64 ts) { 
+        return NHPTimer::GetSeconds(ts) * 1e3; 
+    } 
+ 
+    inline ui64 Us2Ts(double us) { 
+        return ui64(NHPTimer::GetClockRate() * us / 1e6); 
+    } 
+ 
+    struct TTimeTracker { 
+        ui64 Ts; 
+        TTimeTracker(): Ts(GetCycleCountFast()) {} 
+        ui64 Elapsed() { 
+            ui64 ts = GetCycleCountFast(); 
+            std::swap(Ts, ts); 
+            return Ts - ts; 
+        } 
+    }; 
+} 
diff --git a/library/cpp/actors/util/thread.h b/library/cpp/actors/util/thread.h
index d742c8c585..4cab922647 100644
--- a/library/cpp/actors/util/thread.h
+++ b/library/cpp/actors/util/thread.h
@@ -5,7 +5,7 @@
 #include <util/system/execpath.h>
 #include <util/system/thread.h>
 #include <util/system/thread.h>
-#include <time.h>
+#include <time.h> 
 
 inline void SetCurrentThreadName(const TString& name,
                                  const ui32 maxCharsFromProcessName = 8) {
diff --git a/library/cpp/actors/util/timerfd.h b/library/cpp/actors/util/timerfd.h
index 3189e2a672..a9b35ff9e7 100644
--- a/library/cpp/actors/util/timerfd.h
+++ b/library/cpp/actors/util/timerfd.h
@@ -1,65 +1,65 @@
-#pragma once
-
-#include "datetime.h"
-
-#include <util/generic/noncopyable.h>
-
-#ifdef _linux_
-
-#include <util/system/yassert.h>
-#include <errno.h>
-#include <sys/timerfd.h>
-
-struct TTimerFd: public TNonCopyable {
-    int Fd;
-
-    TTimerFd() {
-        Fd = timerfd_create(CLOCK_MONOTONIC, 0);
-        Y_VERIFY(Fd != -1, "timerfd_create(CLOCK_MONOTONIC, 0) -> -1; errno:%d: %s", int(errno), strerror(errno));
-    }
-
-    ~TTimerFd() {
-        close(Fd);
-    }
-
-    void Set(ui64 ts) {
-        ui64 now = GetCycleCountFast();
-        Arm(now >= ts? 1: NHPTimer::GetSeconds(ts - now) * 1e9);
-    }
-
-    void Reset() {
-        Arm(0); // disarm timer
-    }
-
-    void Wait() {
-        ui64 expirations;
-        ssize_t s = read(Fd, &expirations, sizeof(ui64));
-        Y_UNUSED(s); // Y_VERIFY(s == sizeof(ui64));
-    }
-
-    void Wake() {
-        Arm(1);
-    }
-private:
-    void Arm(ui64 ns) {
-        struct itimerspec spec;
-        spec.it_value.tv_sec = ns / 1'000'000'000;
-        spec.it_value.tv_nsec = ns % 1'000'000'000;
-        spec.it_interval.tv_sec = 0;
-        spec.it_interval.tv_nsec = 0;
-        int ret = timerfd_settime(Fd, 0, &spec, nullptr);
-        Y_VERIFY(ret != -1, "timerfd_settime(%d, 0, %" PRIu64 "ns, 0) -> %d; errno:%d: %s", Fd, ns, ret, int(errno), strerror(errno));
-    }
-};
-
-#else
-
-struct TTimerFd: public TNonCopyable {
-    int Fd = 0;
-    void Set(ui64) {}
-    void Reset() {}
-    void Wait() {}
-    void Wake() {}
-};
-
-#endif
+#pragma once 
+ 
+#include "datetime.h" 
+ 
+#include <util/generic/noncopyable.h> 
+ 
+#ifdef _linux_ 
+ 
+#include <util/system/yassert.h> 
+#include <errno.h> 
+#include <sys/timerfd.h> 
+ 
+struct TTimerFd: public TNonCopyable { 
+    int Fd; 
+ 
+    TTimerFd() { 
+        Fd = timerfd_create(CLOCK_MONOTONIC, 0); 
+        Y_VERIFY(Fd != -1, "timerfd_create(CLOCK_MONOTONIC, 0) -> -1; errno:%d: %s", int(errno), strerror(errno)); 
+    } 
+ 
+    ~TTimerFd() { 
+        close(Fd); 
+    } 
+ 
+    void Set(ui64 ts) { 
+        ui64 now = GetCycleCountFast(); 
+        Arm(now >= ts? 1: NHPTimer::GetSeconds(ts - now) * 1e9); 
+    } 
+ 
+    void Reset() { 
+        Arm(0); // disarm timer 
+    } 
+ 
+    void Wait() { 
+        ui64 expirations; 
+        ssize_t s = read(Fd, &expirations, sizeof(ui64)); 
+        Y_UNUSED(s); // Y_VERIFY(s == sizeof(ui64)); 
+    } 
+ 
+    void Wake() { 
+        Arm(1); 
+    } 
+private: 
+    void Arm(ui64 ns) { 
+        struct itimerspec spec; 
+        spec.it_value.tv_sec = ns / 1'000'000'000; 
+        spec.it_value.tv_nsec = ns % 1'000'000'000; 
+        spec.it_interval.tv_sec = 0; 
+        spec.it_interval.tv_nsec = 0; 
+        int ret = timerfd_settime(Fd, 0, &spec, nullptr); 
+        Y_VERIFY(ret != -1, "timerfd_settime(%d, 0, %" PRIu64 "ns, 0) -> %d; errno:%d: %s", Fd, ns, ret, int(errno), strerror(errno)); 
+    } 
+}; 
+ 
+#else 
+ 
+struct TTimerFd: public TNonCopyable { 
+    int Fd = 0; 
+    void Set(ui64) {} 
+    void Reset() {} 
+    void Wait() {} 
+    void Wake() {} 
+}; 
+ 
+#endif 
diff --git a/library/cpp/actors/util/ya.make b/library/cpp/actors/util/ya.make
index 37488c3962..a8bfd05d5a 100644
--- a/library/cpp/actors/util/ya.make
+++ b/library/cpp/actors/util/ya.make
@@ -8,8 +8,8 @@ OWNER(
 SRCS(
     affinity.cpp
     affinity.h
-    cpumask.h
-    datetime.h
+    cpumask.h 
+    datetime.h 
     defs.h
     funnel_queue.h
     futex.h
@@ -26,7 +26,7 @@ SRCS(
     threadparkpad.cpp
     threadparkpad.h
     ticket_lock.h
-    timerfd.h
+    timerfd.h 
     unordered_cache.h
 )