catboost 1.25.1 → 1.26.0

package/inc/util/system/guard.h

@@ -1,179 +0,0 @@
-#pragma once
-
-#include <util/generic/noncopyable.h>
-
-template <class T>
-struct TCommonLockOps {
-    static inline void Acquire(T* t) noexcept {
-        t->Acquire();
-    }
-
-    static inline void Release(T* t) noexcept {
-        t->Release();
-    }
-};
-
-template <class T>
-struct TTryLockOps: public TCommonLockOps<T> {
-    static inline bool TryAcquire(T* t) noexcept {
-        return t->TryAcquire();
-    }
-};
-
-//must be used with great care
-template <class TOps>
-struct TInverseLockOps: public TOps {
-    template <class T>
-    static inline void Acquire(T* t) noexcept {
-        TOps::Release(t);
-    }
-
-    template <class T>
-    static inline void Release(T* t) noexcept {
-        TOps::Acquire(t);
-    }
-};
-
-template <class T, class TOps = TCommonLockOps<T>>
-class TGuard: public TNonCopyable {
-public:
-    inline TGuard(const T& t) noexcept {
-        Init(&t);
-    }
-
-    inline TGuard(const T* t) noexcept {
-        Init(t);
-    }
-
-    inline TGuard(TGuard&& g) noexcept
-        : T_(g.T_)
-    {
-        g.T_ = nullptr;
-    }
-
-    inline ~TGuard() {
-        Release();
-    }
-
-    inline void Release() noexcept {
-        if (WasAcquired()) {
-            TOps::Release(T_);
-            T_ = nullptr;
-        }
-    }
-
-    explicit inline operator bool() const noexcept {
-        return WasAcquired();
-    }
-
-    inline bool WasAcquired() const noexcept {
-        return T_ != nullptr;
-    }
-
-    inline T* GetMutex() const noexcept {
-        return T_;
-    }
-
-private:
-    inline void Init(const T* t) noexcept {
-        T_ = const_cast<T*>(t);
-        TOps::Acquire(T_);
-    }
-
-private:
-    T* T_;
-};
-
-/*
- * {
- *     auto guard = Guard(Lock_);
- *     some code under guard
- * }
- */
-template <class T>
-static inline TGuard<T> Guard(const T& t) {
-    return {&t};
-}
-
-/*
- * with_lock (Lock_) {
- *     some code under guard
- * }
- */
-#define with_lock(X)                                       \
-    if (auto Y_GENERATE_UNIQUE_ID(__guard) = ::Guard(X)) { \
-        goto Y_CAT(GUARD_LABEL, __LINE__);                 \
-    } else                                                 \
-        Y_CAT(GUARD_LABEL, __LINE__)                       \
-            :
-
-/*
- * auto guard = Guard(Lock_);
- * ... some code under lock
- * {
- *     auto unguard = Unguard(guard);
- *     ... some code not under lock
- * }
- * ... some code under lock
- */
-template <class T, class TOps = TCommonLockOps<T>>
-using TInverseGuard = TGuard<T, TInverseLockOps<TOps>>;
-
-template <class T, class TOps>
-static inline TInverseGuard<T, TOps> Unguard(const TGuard<T, TOps>& guard) {
-    return {guard.GetMutex()};
-}
-
-template <class T>
-static inline TInverseGuard<T> Unguard(const T& mutex) {
-    return {&mutex};
-}
-
-template <class T, class TOps = TTryLockOps<T>>
-class TTryGuard: public TNonCopyable {
-public:
-    inline TTryGuard(const T& t) noexcept {
-        Init(&t);
-    }
-
-    inline TTryGuard(const T* t) noexcept {
-        Init(t);
-    }
-
-    inline TTryGuard(TTryGuard&& g) noexcept
-        : T_(g.T_)
-    {
-        g.T_ = nullptr;
-    }
-
-    inline ~TTryGuard() {
-        Release();
-    }
-
-    inline void Release() noexcept {
-        if (WasAcquired()) {
-            TOps::Release(T_);
-            T_ = nullptr;
-        }
-    }
-
-    inline bool WasAcquired() const noexcept {
-        return T_ != nullptr;
-    }
-
-    explicit inline operator bool() const noexcept {
-        return WasAcquired();
-    }
-
-private:
-    inline void Init(const T* t) noexcept {
-        T_ = nullptr;
-        T* tMutable = const_cast<T*>(t);
-        if (TOps::TryAcquire(tMutable)) {
-            T_ = tMutable;
-        }
-    }
-
-private:
-    T* T_;
-};

package/inc/util/system/hi_lo.h

@@ -1,139 +0,0 @@
-#pragma once
-
-#include "unaligned_mem.h"
-
-#ifndef _little_endian_
-#error "Not implemented"
-#endif
-
-namespace NHiLoPrivate {
-    template <class TRepr>
-    class TConstIntRef {
-    public:
-        explicit TConstIntRef(const char* ptr)
-            : Ptr(ptr)
-        {
-        }
-
-        TRepr Get() const { return ReadUnaligned<TRepr>(Ptr); }
-        operator TRepr() const { return Get(); }
-
-        const char* GetPtr() const { return Ptr; }
-
-    protected:
-        const char* Ptr;
-    };
-
-    template <class TRepr>
-    class TIntRef : public TConstIntRef<TRepr> {
-    public:
-        explicit TIntRef(char* ptr)
-            : TConstIntRef<TRepr>(ptr)
-        {
-        }
-
-        TIntRef& operator=(TRepr value) {
-            WriteUnaligned<TRepr>(GetPtr(), value);
-            return *this;
-        }
-
-        char* GetPtr() const { return const_cast<char *>(this->Ptr); }
-    };
-
-    template <class T>
-    struct TReferenceType {
-        using TType = T;
-    };
-
-    template <class T>
-    struct TReferenceType<TConstIntRef<T>> {
-        using TType = T;
-    };
-
-    template <class T>
-    struct TReferenceType<TIntRef<T>> {
-        using TType = T;
-    };
-
-    template <class TRepr>
-    auto MakeIntRef(const char* ptr) {
-        return TConstIntRef<TRepr>(ptr);
-    }
-
-    template <class TRepr>
-    auto MakeIntRef(char* ptr) {
-        return TIntRef<TRepr>(ptr);
-    }
-
-    template <class T>
-    const char* CharPtrOf(const T& value) {
-        return reinterpret_cast<const char *>(&value);
-    }
-
-    template <class T>
-    char* CharPtrOf(T& value) {
-        return reinterpret_cast<char *>(&value);
-    }
-
-    template <class T>
-    const char* CharPtrOf(TConstIntRef<T> value) {
-        return value.GetPtr();
-    }
-
-    template <class T>
-    char* CharPtrOf(TIntRef<T> value) {
-        return value.GetPtr();
-    }
-
-    template <bool IsLow, class TRepr, class T>
-    auto MakeIntRef(T&& value) {
-        using TRef = typename TReferenceType<typename std::decay<T>::type>::TType;
-        static_assert(
-                std::is_scalar<TRef>::value,
-                "Hi* and Lo* functions can be applied only to scalar values");
-        static_assert(sizeof(TRef) >= sizeof(TRepr), "Requested bit range is not within provided value");
-        constexpr size_t offset = IsLow ? 0 : sizeof(TRef) - sizeof(TRepr);
-
-        return MakeIntRef<TRepr>(CharPtrOf(std::forward<T>(value)) + offset);
-    }
-}
-
-/**
- * Return manipulator object that allows to get and set lower or higher bits of the value.
- *
- * @param value Must be a scalar value of sufficient size or a manipulator object obtained by
- * calling any of the other Hi/Lo functions.
- *
- * @{
- */
-template <class T>
-auto Lo32(T&& value) {
-    return NHiLoPrivate::MakeIntRef<true, ui32>(std::forward<T>(value));
-}
-
-template <class T>
-auto Hi32(T&& value) {
-    return NHiLoPrivate::MakeIntRef<false, ui32>(std::forward<T>(value));
-}
-
-template <class T>
-auto Lo16(T&& value) {
-    return NHiLoPrivate::MakeIntRef<true, ui16>(std::forward<T>(value));
-}
-
-template <class T>
-auto Hi16(T&& value) {
-    return NHiLoPrivate::MakeIntRef<false, ui16>(std::forward<T>(value));
-}
-
-template <class T>
-auto Lo8(T&& value) {
-    return NHiLoPrivate::MakeIntRef<true, ui8>(std::forward<T>(value));
-}
-
-template <class T>
-auto Hi8(T&& value) {
-    return NHiLoPrivate::MakeIntRef<false, ui8>(std::forward<T>(value));
-}
-
-/** @} */

package/inc/util/system/hostname.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include <util/generic/fwd.h>
-
-const char* GetHostName();
-const TString& HostName();
-
-const char* GetFQDNHostName();
-const TString& FQDNHostName();
-bool IsFQDN(const TString& name);

package/inc/util/system/hp_timer.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include "defaults.h"
-
-namespace NHPTimer {
-    using STime = i64;
-    // May delay for ~50ms to compute frequency
-    double GetSeconds(const STime& a) noexcept;
-    // Returns the current time
-    void GetTime(STime* pTime) noexcept;
-    // Returns the time passed since *pTime, and writes the current time into *pTime.
-    double GetTimePassed(STime* pTime) noexcept;
-    // Get TSC frequency, may delay for ~50ms to compute frequency
-    double GetClockRate() noexcept;
-    // same as GetClockRate, but in integer
-    ui64 GetCyclesPerSecond() noexcept;
-}
-
-struct THPTimer {
-    THPTimer() noexcept {
-        Reset();
-    }
-    void Reset() noexcept {
-        NHPTimer::GetTime(&Start);
-    }
-    double Passed() const noexcept {
-        NHPTimer::STime tmp = Start;
-        return NHPTimer::GetTimePassed(&tmp);
-    }
-    double PassedReset() noexcept {
-        return NHPTimer::GetTimePassed(&Start);
-    }
-
-private:
-    NHPTimer::STime Start;
-};

package/inc/util/system/info.h

@@ -1,12 +0,0 @@
-#pragma once
-
-#include "defaults.h"
-
-namespace NSystemInfo {
-    size_t NumberOfCpus();
-    size_t CachedNumberOfCpus();
-    size_t LoadAverage(double* la, size_t len);
-    size_t GetPageSize() noexcept;
-    size_t TotalMemorySize();
-    size_t MaxOpenFiles();
-}

package/inc/util/system/interrupt_signals.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "platform.h"
-
-#include <csignal>
-
-#ifdef _win_
-    #ifndef SIGHUP
-        #define SIGHUP      1   /* Hangup (POSIX).  */
-    #endif
-#endif
-
-/**
- * Set handler for interrupt signals.
- *
- * All OSes:      SIGINT, SIGTERM (defined by C++ standard)
- * UNIX variants: Also SIGHUP
- * Windows:       CTRL_C_EVENT handled as SIGINT, CTRL_BREAK_EVENT as SIGTERM, CTRL_CLOSE_EVENT as SIGHUP
- *
- * \param handler                       Signal handler to use. Pass nullptr to clear currently set handler.
- */
-void SetInterruptSignalsHandler(void (*handler)(int signum));

package/inc/util/system/madvise.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include "defaults.h"
-
-#include <util/generic/array_ref.h>
-
-/// see linux madvise(MADV_SEQUENTIAL)
-void MadviseSequentialAccess(const void* begin, size_t size);
-void MadviseSequentialAccess(TArrayRef<const char> data);
-void MadviseSequentialAccess(TArrayRef<const ui8> data);
-
-/// see linux madvise(MADV_RANDOM)
-void MadviseRandomAccess(const void* begin, size_t size);
-void MadviseRandomAccess(TArrayRef<const char> data);
-void MadviseRandomAccess(TArrayRef<const ui8> data);
-
-/// see linux madvise(MADV_DONTNEED)
-void MadviseEvict(const void* begin, size_t size);
-void MadviseEvict(TArrayRef<const char> data);
-void MadviseEvict(TArrayRef<const ui8> data);
-
-/// see linux madvise(MADV_DONTDUMP)
-void MadviseExcludeFromCoreDump(const void* begin, size_t size);
-void MadviseExcludeFromCoreDump(TArrayRef<const char> data);
-void MadviseExcludeFromCoreDump(TArrayRef<const ui8> data);
-
-/// see linux madvise(MADV_DODUMP)
-void MadviseIncludeIntoCoreDump(const void* begin, size_t size);
-void MadviseIncludeIntoCoreDump(TArrayRef<const char> data);
-void MadviseIncludeIntoCoreDump(TArrayRef<const ui8> data);

package/inc/util/system/maxlen.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <cstdlib>
-
-// http://support.microsoft.com/kb/208427
-#ifndef URL_MAXLEN
-#define URL_MAXLEN 2083
-#endif
-
-#define HOST_MAX 260
-#ifndef URL_MAX
-#define URL_MAX 1024
-#endif
-#define FULLURL_MAX (URL_MAX + HOST_MAX)
-
-#define LINKTEXT_MAX 1024
-
-#ifdef WIN32
-#ifndef PATH_MAX
-#define PATH_MAX _MAX_PATH
-#endif
-#else
-
-#ifndef MAX_PATH
-#define MAX_PATH PATH_MAX
-#endif
-
-#ifndef _MAX_PATH
-#define _MAX_PATH PATH_MAX
-#endif
-
-#endif

package/inc/util/system/mem_info.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "compat.h"
-
-namespace NMemInfo {
-    struct TMemInfo {
-        ui64 RSS; // current RAM size of the process
-        ui64 VMS; // current VM  size of the process
-
-        TMemInfo()
-            : RSS()
-            , VMS()
-        {
-        }
-    };
-
-    TMemInfo GetMemInfo(pid_t = 0);
-}

package/inc/util/system/mincore.h

@@ -1,38 +0,0 @@
-#pragma once
-
-#include "defaults.h"
-/**
- * Fills a vector that indicates whether pages of the calling process's virtual memory are resident in RAM. Each byte
- * in the vector contains the status of a single page. The page size can be obtained via the NSystemInfo::GetPageSize()
- * function. Use the IsPageInCore function to interpret the page status byte.
- *
- * Can be overly pessimistic:
- * - Assumes nothing is in RAM on platforms other than Linux
- * - Recent Linux kernels (4.21 and some backports) may return zeroes if the process doesn't have writing permissions
- *   for the given file. See CVE-2019-5489.
- *
- * @param[in] addr      starting address of the memory range to be examined
- * @param[in] len       length (bytes) of the memory range to be examined
- * @param[out] vec      vector of bytes to store statuses of memory pages
- * @param[in] vecLen    length (bytes) of the vec, should be large enough to hold the requested pages count
- * @throws yexception   if there was a system error or if the vecLen is too small
- *
- * @note                this is only a snapshot, results may be stale by the time they're used
- * @see                 man 2 mincore
- */
-void InCoreMemory(const void* addr, size_t len, unsigned char* vec, size_t vecLen);
-
-/**
- * Takes as an argument an element of the vector previously filled by InCoreMemory.
- *
- * @param[in]           byte corresponding to the status of a single page
- *
- * @returns             true if this page was resident in memory at the time out the InCoreMemory execution
- */
-inline bool IsPageInCore(unsigned char s) {
-    /* From mincore(2): On return, the least significant bit of each byte will be set if the corresponding page is
-     * currently resident in memory, and be clear otherwise.  (The settings of the other bits in each byte are
-     * undefined; these bits are reserved for possible later use.)
-     */
-    return s & 1;
-}

package/inc/util/system/mktemp.h

@@ -1,11 +0,0 @@
-#pragma once
-
-#include <util/generic/fwd.h>
-
-/*
- * Create temp file name in the specified directory. If there is no file with this name, it will be created.
- * Note, that the function is not race-free, the file is guaranteed to exist at the time the function returns, but not at the time the returned name is first used.
- * If wrkDir is NULL or empty, GetSystemTempDir is used.
- * throw exception on error
- */
-TString MakeTempName(const char* wrkDir = nullptr, const char* prefix = "yandex");

package/inc/util/system/mlock.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#include "defaults.h"
-
-#include <util/generic/flags.h>
-
-//on some systems (not win, freebd, linux, but darwin (Mac OS X)
-//multiple mlock calls on the same address range
-//require the corresponding number of munlock calls to actually unlock the pages
-
-//on some systems you must have privilege and resource limit
-
-void LockMemory(const void* addr, size_t len);
-void UnlockMemory(const void* addr, size_t len);
-
-enum ELockAllMemoryFlag {
-    /** Lock all pages which are currently mapped into the address space of the process. */
-    LockCurrentMemory = 1,
-
-    /** Lock all pages which will become mapped into the address space of the process in the future. */
-    LockFutureMemory = 2,
-
-    /** Since Linux 4.4, with LockCurrentMemory or LockFutureMemory or both, lock only pages that are or once they are present in memory. */
-    LockMemoryOnFault = 4,
-};
-Y_DECLARE_FLAGS(ELockAllMemoryFlags, ELockAllMemoryFlag)
-Y_DECLARE_OPERATORS_FOR_FLAGS(ELockAllMemoryFlags)
-
-/**
- * Performs provided locking operation.
- *
- * Does nothing on windows.
- *
- * \param flags                         Locking operation to perform.
- */
-void LockAllMemory(ELockAllMemoryFlags flags);
-
-/**
- * Unlocks whatever was locked with a previous call to `LockAllMemory`.
- *
- * Does nothing on windows.
- */
-void UnlockAllMemory();

package/inc/util/system/mutex.h

@@ -1,67 +0,0 @@
-#pragma once
-
-#include "guard.h"
-#include "defaults.h"
-
-#include <util/generic/ptr.h>
-#include <util/generic/noncopyable.h>
-
-class TFakeMutex: public TNonCopyable {
-public:
-    inline void Acquire() noexcept {
-    }
-
-    inline bool TryAcquire() noexcept {
-        return true;
-    }
-
-    inline void Release() noexcept {
-    }
-
-    inline void lock() noexcept {
-        Acquire();
-    }
-
-    inline bool try_lock() noexcept {
-        return TryAcquire();
-    }
-
-    inline void unlock() noexcept {
-        Release();
-    }
-
-    ~TFakeMutex() = default;
-};
-
-class TSysMutex {
-public:
-    TSysMutex();
-    TSysMutex(TSysMutex&&);
-    ~TSysMutex();
-
-    void Acquire() noexcept;
-    bool TryAcquire() noexcept;
-    void Release() noexcept;
-
-    inline void lock() noexcept {
-        Acquire();
-    }
-
-    inline bool try_lock() noexcept {
-        return TryAcquire();
-    }
-
-    inline void unlock() noexcept {
-        Release();
-    }
-
-    //return opaque pointer to real handler
-    void* Handle() const noexcept;
-
-private:
-    class TImpl;
-    THolder<TImpl> Impl_;
-};
-
-class TMutex: public TSysMutex {
-};

package/inc/util/system/nice.h

@@ -1,3 +0,0 @@
-#pragma once
-
-bool Nice(int prioDelta);