catboost 1.25.1 → 1.26.0

package/inc/util/memory/segpool_alloc.h

@@ -1,118 +0,0 @@
-#pragma once
-
-#include "segmented_string_pool.h"
-
-/**
-  This is a partially implemented allocator class that uses segmented_pool
-  as its allocatior base.
-  In fact, segpool_alloc can only allocate, it can't deallocate. Therefore,
-  it should be used with add-only containers that are just clear()'ed in the
-  end of their life cycle.
-
-  External segmented_pool object must be cleared explicitly after all
-  containers use it in their allocator are cleared.
-  Single segmented_pool object may be used for several containers.
-
-  Use segpool_alloc_vt as allocator template parameter for container.
-  Example:
-  using TSomething = THashMap<A, B, hash<A>, TEqualTo<A>, segpool_alloc_vt>;
-  ...
-  TSomething something;
-  something.GetNodeAllocator().pool = &alloc_pool;
-
-  Some containers may provide no way to access their allocator. In that case,
-  if you want to use them with segpool_alloc_vt, you should first either
-  hack them, or fix segpool_alloc so that it would create ref-counted
-  segmented_pool object on it's own
-
-  ! Only tested with THashMap
-*/
-
-template <class _Tp>
-struct segpool_alloc {
-    using pool_type = segmented_pool<char>;
-    pool_type* pool;
-    using pointer = _Tp*;
-    using const_pointer = const _Tp*;
-    using reference = _Tp&;
-    using const_reference = const _Tp&;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-    using value_type = _Tp;
-#ifndef NDEBUG
-    ui64 pool_count, malloc_count, pool_free_count, malloc_free_count;
-#endif
-    segpool_alloc()
-        : pool(nullptr)
-    {
-        Y_IF_DEBUG(pool_count = malloc_count = pool_free_count = malloc_free_count = 0);
-    }
-    segpool_alloc(pool_type* p)
-        : pool(p)
-    {
-        Y_IF_DEBUG(pool_count = malloc_count = pool_free_count = malloc_free_count = 0);
-    }
-    segpool_alloc(const segpool_alloc& a)
-        : pool(a.pool)
-    {
-        Y_IF_DEBUG(pool_count = malloc_count = pool_free_count = malloc_free_count = 0);
-    }
-    template <class _Tp1>
-    segpool_alloc(const segpool_alloc<_Tp1>& a)
-        : pool(a.pool)
-    {
-        Y_IF_DEBUG(pool_count = malloc_count = pool_free_count = malloc_free_count = 0);
-    }
-    _Tp* allocate(size_t __n) {
-        if (!pool) {
-            _Tp* data = (_Tp*)malloc(__n * sizeof(_Tp));
-            Y_IF_DEBUG(if (data) malloc_count++);
-            return data;
-        }
-        _Tp* data = (_Tp*)pool->append(nullptr, __n * sizeof(_Tp));
-        Y_IF_DEBUG(pool_count++);
-        return data;
-    }
-    void deallocate(pointer __p, size_t /*__n*/) {
-        if (!pool) {
-            Y_IF_DEBUG(malloc_free_count++);
-            free(__p);
-        } else {
-            Y_IF_DEBUG(pool_free_count++);
-            ;
-        }
-    }
-    ~segpool_alloc() {
-        //assert(pool_count == pool_free_count && malloc_count == malloc_free_count); <- uncomment when swap() problem is solved
-        //printf("in ~segpool_alloc: size = %u, pool_count = %" PRId64 ", malloc_count = %" PRId64 ", pool_free_count = %" PRId64 ", malloc_free_count = %" PRId64 "\n",
-        //        sizeof(_Tp), pool_count, malloc_count, pool_free_count, malloc_free_count);
-        //fflush(stdout);
-    }
-    template <class _Tp1>
-    struct rebind {
-        using other = segpool_alloc<_Tp1>;
-    };
-    size_type max_size() const {
-        return size_type(-1) / sizeof(_Tp);
-    }
-    void construct(pointer __p, const _Tp& __val) {
-        new (__p) _Tp(__val);
-    }
-    void destroy(pointer __p) {
-        (void)__p; /* Make MSVC happy. */
-        __p->~_Tp();
-    }
-};
-
-template <class _Tp>
-inline bool operator==(const segpool_alloc<_Tp>& a1, const segpool_alloc<_Tp>& a2) {
-    return a1.pool == a2.pool;
-}
-
-template <class _Tp>
-inline bool operator!=(const segpool_alloc<_Tp>& a1, const segpool_alloc<_Tp>& a2) {
-    return a1.pool != a2.pool;
-}
-
-// Any type since it is supposed to be rebound anyway.
-using segpool_alloc_vt = segpool_alloc<int>;

package/inc/util/memory/smallobj.h

@@ -1,141 +0,0 @@
-#pragma once
-
-#include "pool.h"
-#include "alloc.h"
-
-#include <util/generic/utility.h>
-#include <util/generic/intrlist.h>
-
-class TFixedSizeAllocator {
-    struct TAlloc: public TIntrusiveSListItem<TAlloc> {
-        inline void* ToPointer() noexcept {
-            return this;
-        }
-
-        static inline TAlloc* FromPointer(void* ptr) noexcept {
-            return (TAlloc*)ptr;
-        }
-
-        static constexpr size_t EntitySize(size_t alloc) noexcept {
-            return Max(sizeof(TAlloc), alloc);
-        }
-
-        static constexpr size_t EntityAlign(size_t align) noexcept {
-            return Max(alignof(TAlloc), align);
-        }
-
-        static inline TAlloc* Construct(void* ptr) noexcept {
-            return (TAlloc*)ptr;
-        }
-    };
-
-public:
-    using IGrowPolicy = TMemoryPool::IGrowPolicy;
-
-    TFixedSizeAllocator(size_t allocSize, IAllocator* alloc)
-        : TFixedSizeAllocator(allocSize, alignof(TAlloc), TMemoryPool::TExpGrow::Instance(), alloc)
-    {
-    }
-
-    TFixedSizeAllocator(size_t allocSize, size_t alignSize, IAllocator* alloc)
-        : TFixedSizeAllocator(allocSize, alignSize, TMemoryPool::TExpGrow::Instance(), alloc)
-    {
-    }
-
-    TFixedSizeAllocator(size_t allocSize, IGrowPolicy* grow, IAllocator* alloc)
-        : TFixedSizeAllocator(allocSize, alignof(TAlloc), grow, alloc)
-    {
-    }
-
-    TFixedSizeAllocator(size_t allocSize, size_t alignSize, IGrowPolicy* grow, IAllocator* alloc)
-        : Pool_(allocSize, grow, alloc)
-        , AlignSize_(TAlloc::EntityAlign(alignSize))
-        , AllocSize_(TAlloc::EntitySize(allocSize))
-    {
-    }
-
-    inline void* Allocate() {
-        if (Y_UNLIKELY(Free_.Empty())) {
-            return Pool_.Allocate(AllocSize_, AlignSize_);
-        }
-
-        return Free_.PopFront()->ToPointer();
-    }
-
-    inline void Release(void* ptr) noexcept {
-        Free_.PushFront(TAlloc::FromPointer(ptr));
-    }
-
-    inline size_t Size() const noexcept {
-        return AllocSize_;
-    }
-
-private:
-    TMemoryPool Pool_;
-    const size_t AlignSize_;
-    const size_t AllocSize_;
-    TIntrusiveSList<TAlloc> Free_;
-};
-
-template <class T>
-class TSmallObjAllocator {
-public:
-    using IGrowPolicy = TFixedSizeAllocator::IGrowPolicy;
-
-    inline TSmallObjAllocator(IAllocator* alloc)
-        : Alloc_(sizeof(T), alignof(T), alloc)
-    {
-    }
-
-    inline TSmallObjAllocator(IGrowPolicy* grow, IAllocator* alloc)
-        : Alloc_(sizeof(T), alignof(T), grow, alloc)
-    {
-    }
-
-    inline T* Allocate() {
-        return (T*)Alloc_.Allocate();
-    }
-
-    inline void Release(T* t) noexcept {
-        Alloc_.Release(t);
-    }
-
-private:
-    TFixedSizeAllocator Alloc_;
-};
-
-template <class T>
-class TObjectFromPool {
-public:
-    struct THeader {
-        void* Pool;
-        // Can't just use T because THeader must be standard layout type for offsetof to work.
-        alignas(T) char Obj[sizeof(T)];
-    };
-    using TPool = TSmallObjAllocator<THeader>;
-
-    inline void* operator new(size_t, TPool* pool) {
-        THeader* ret = pool->Allocate();
-        ret->Pool = pool;
-        return &ret->Obj;
-    }
-
-    inline void operator delete(void* ptr, size_t) noexcept {
-        DoDelete(ptr);
-    }
-
-    inline void operator delete(void* ptr, TPool*) noexcept {
-        /*
-         * this delete operator can be called automagically by compiler
-         */
-
-        DoDelete(ptr);
-    }
-
-private:
-    static inline void DoDelete(void* ptr) noexcept {
-        static_assert(std::is_standard_layout<THeader>::value, "offsetof is only defined for standard layout types");
-        THeader* header = (THeader*)((char*)ptr - offsetof(THeader, Obj));
-        ((TPool*)header->Pool)->Release(header);
-    }
-};

package/inc/util/memory/tempbuf.h

@@ -1,111 +0,0 @@
-#pragma once
-
-#include <util/system/defaults.h>
-#include <util/generic/ptr.h>
-
-/*
- * This is really fast buffer for temporary data.
- * For small sizes it works almost fast as pure alloca()
- * (by using perthreaded list of free blocks),
- * for big sizes it works as fast as malloc()/operator new()/...
- */
-class TTempBuf {
-public:
-    /*
-     * we do not want many friends for this class :)
-     */
-    class TImpl;
-
-    TTempBuf();
-    TTempBuf(size_t len);
-    TTempBuf(const TTempBuf& b) noexcept;
-    TTempBuf(TTempBuf&& b) noexcept;
-    ~TTempBuf();
-
-    TTempBuf& operator=(const TTempBuf& b) noexcept;
-    TTempBuf& operator=(TTempBuf&& b) noexcept;
-
-    Y_PURE_FUNCTION
-    char* Data() noexcept;
-
-    Y_PURE_FUNCTION
-    const char* Data() const noexcept;
-
-    Y_PURE_FUNCTION
-    char* Current() noexcept;
-
-    Y_PURE_FUNCTION
-    const char* Current() const noexcept;
-
-    Y_PURE_FUNCTION
-    size_t Size() const noexcept;
-
-    Y_PURE_FUNCTION
-    size_t Filled() const noexcept;
-
-    Y_PURE_FUNCTION
-    size_t Left() const noexcept;
-
-    void Reset() noexcept;
-    void SetPos(size_t off);
-    char* Proceed(size_t off);
-    void Append(const void* data, size_t len);
-
-    Y_PURE_FUNCTION
-    bool IsNull() const noexcept;
-
-private:
-    TIntrusivePtr<TImpl> Impl_;
-};
-
-template <typename T>
-class TTempArray: private TTempBuf {
-private:
-    static T* TypedPointer(char* pointer) noexcept {
-        return reinterpret_cast<T*>(pointer);
-    }
-    static const T* TypedPointer(const char* pointer) noexcept {
-        return reinterpret_cast<const T*>(pointer);
-    }
-    static constexpr size_t RawSize(const size_t size) noexcept {
-        return size * sizeof(T);
-    }
-    static constexpr size_t TypedSize(const size_t size) noexcept {
-        return size / sizeof(T);
-    }
-
-public:
-    TTempArray() = default;
-
-    TTempArray(size_t len)
-        : TTempBuf(RawSize(len))
-    {
-    }
-
-    T* Data() noexcept {
-        return TypedPointer(TTempBuf::Data());
-    }
-
-    const T* Data() const noexcept {
-        return TypedPointer(TTempBuf::Data());
-    }
-
-    T* Current() noexcept {
-        return TypedPointer(TTempBuf::Current());
-    }
-
-    const T* Current() const noexcept {
-        return TypedPointer(TTempBuf::Current());
-    }
-
-    size_t Size() const noexcept {
-        return TypedSize(TTempBuf::Size());
-    }
-    size_t Filled() const noexcept {
-        return TypedSize(TTempBuf::Filled());
-    }
-
-    T* Proceed(size_t off) {
-        return (T*)TTempBuf::Proceed(RawSize(off));
-    }
-};

package/inc/util/network/address.h

@@ -1,136 +0,0 @@
-#pragma once
-
-#include "ip.h"
-#include "socket.h"
-
-#include <util/generic/ptr.h>
-#include <util/generic/string.h>
-
-namespace NAddr {
-    class IRemoteAddr {
-    public:
-        virtual ~IRemoteAddr() = default;
-
-        virtual const sockaddr* Addr() const = 0;
-        virtual socklen_t Len() const = 0;
-    };
-
-    using IRemoteAddrPtr = THolder<IRemoteAddr>;
-    using IRemoteAddrRef = TAtomicSharedPtr<NAddr::IRemoteAddr>;
-
-    IRemoteAddrPtr GetSockAddr(SOCKET s);
-    IRemoteAddrPtr GetPeerAddr(SOCKET s);
-    void PrintHost(IOutputStream& out, const IRemoteAddr& addr);
-
-    TString PrintHost(const IRemoteAddr& addr);
-    TString PrintHostAndPort(const IRemoteAddr& addr);
-
-    bool IsLoopback(const IRemoteAddr& addr);
-    bool IsSame(const IRemoteAddr& lhs, const IRemoteAddr& rhs);
-
-    socklen_t SockAddrLength(const sockaddr* addr);
-
-    //for accept, recvfrom - see LenPtr()
-    class TOpaqueAddr: public IRemoteAddr {
-    public:
-        inline TOpaqueAddr() noexcept
-            : L_(sizeof(S_))
-        {
-            Zero(S_);
-        }
-
-        inline TOpaqueAddr(const IRemoteAddr* addr) noexcept {
-            Assign(addr->Addr(), addr->Len());
-        }
-
-        inline TOpaqueAddr(const sockaddr* addr) {
-            Assign(addr, SockAddrLength(addr));
-        }
-
-        const sockaddr* Addr() const override {
-            return MutableAddr();
-        }
-
-        socklen_t Len() const override {
-            return L_;
-        }
-
-        inline sockaddr* MutableAddr() const noexcept {
-            return (sockaddr*)&S_;
-        }
-
-        inline socklen_t* LenPtr() noexcept {
-            return &L_;
-        }
-
-    private:
-        inline void Assign(const sockaddr* addr, socklen_t len) noexcept {
-            L_ = len;
-            memcpy(MutableAddr(), addr, L_);
-        }
-
-    private:
-        sockaddr_storage S_;
-        socklen_t L_;
-    };
-
-    //for TNetworkAddress
-    class TAddrInfo: public IRemoteAddr {
-    public:
-        inline TAddrInfo(const addrinfo* ai) noexcept
-            : AI_(ai)
-        {
-        }
-
-        const sockaddr* Addr() const override {
-            return AI_->ai_addr;
-        }
-
-        socklen_t Len() const override {
-            return (socklen_t)AI_->ai_addrlen;
-        }
-
-    private:
-        const addrinfo* const AI_;
-    };
-
-    //compat, for TIpAddress
-    class TIPv4Addr: public IRemoteAddr {
-    public:
-        inline TIPv4Addr(const TIpAddress& addr) noexcept
-            : A_(addr)
-        {
-        }
-
-        const sockaddr* Addr() const override {
-            return A_;
-        }
-
-        socklen_t Len() const override {
-            return A_;
-        }
-
-    private:
-        const TIpAddress A_;
-    };
-
-    //same, for ipv6 addresses
-    class TIPv6Addr: public IRemoteAddr {
-    public:
-        inline TIPv6Addr(const sockaddr_in6& a) noexcept
-            : A_(a)
-        {
-        }
-
-        const sockaddr* Addr() const override {
-            return (sockaddr*)&A_;
-        }
-
-        socklen_t Len() const override {
-            return sizeof(A_);
-        }
-
-    private:
-        const sockaddr_in6 A_;
-    };
-}

package/inc/util/network/endpoint.h

@@ -1,61 +0,0 @@
-#pragma once
-
-#include "address.h"
-
-#include <util/str_stl.h>
-
-//some equivalent boost::asio::ip::endpoint (easy for using pair ip:port)
-class TEndpoint {
-public:
-    using TAddrRef = NAddr::IRemoteAddrRef;
-
-    TEndpoint(const TAddrRef& addr);
-    TEndpoint();
-
-    inline const TAddrRef& Addr() const noexcept {
-        return Addr_;
-    }
-    inline const sockaddr* SockAddr() const {
-        return Addr_->Addr();
-    }
-    inline socklen_t SockAddrLen() const {
-        return Addr_->Len();
-    }
-
-    inline bool IsIpV4() const {
-        return Addr_->Addr()->sa_family == AF_INET;
-    }
-    inline bool IsIpV6() const {
-        return Addr_->Addr()->sa_family == AF_INET6;
-    }
-    inline bool IsUnix() const {
-        return Addr_->Addr()->sa_family == AF_UNIX;
-    }
-
-    inline TString IpToString() const {
-        return NAddr::PrintHost(*Addr_);
-    }
-
-    void SetPort(ui16 port);
-    ui16 Port() const noexcept;
-
-    size_t Hash() const;
-
-private:
-    TAddrRef Addr_;
-};
-
-template <>
-struct THash<TEndpoint> {
-    inline size_t operator()(const TEndpoint& ep) const {
-        return ep.Hash();
-    }
-};
-
-inline bool operator==(const TEndpoint& l, const TEndpoint& r) {
-    try {
-        return NAddr::IsSame(*l.Addr(), *r.Addr()) && l.Port() == r.Port();
-    } catch (...) {
-        return false;
-    }
-}

package/inc/util/network/hostip.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include <util/system/defaults.h>
-
-namespace NResolver {
-    // resolve hostname and fills up to *slots slots in ip array;
-    // actual number of slots filled is returned in *slots;
-    int GetHostIP(const char* hostname, ui32* ip, size_t* slots);
-    int GetDnsError();
-
-    inline int GetHostIP(const char* hostname, ui32* ip) {
-        size_t slots = 1;
-
-        return GetHostIP(hostname, ip, &slots);
-    }
-}

package/inc/util/network/init.h

@@ -1,60 +0,0 @@
-#pragma once
-
-#include <util/system/error.h>
-
-#if defined(_unix_)
-#include <fcntl.h>
-#include <netdb.h>
-#include <time.h>
-#include <unistd.h>
-#include <poll.h>
-
-#include <sys/uio.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-
-using SOCKET = int;
-
-#define closesocket(s) close(s)
-#define SOCKET_ERROR -1
-#define INVALID_SOCKET -1
-#define WSAGetLastError() errno
-#elif defined(_win_)
-#include <util/system/winint.h>
-#include <io.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-using nfds_t = ULONG;
-
-#undef Yield
-
-struct sockaddr_un {
-    short sun_family;
-    char sun_path[108];
-};
-
-#define PF_LOCAL AF_UNIX
-#define NETDB_INTERNAL -1
-#define NETDB_SUCCESS 0
-
-#endif
-
-#if defined(_win_) || defined(_darwin_)
-#ifndef MSG_NOSIGNAL
-#define MSG_NOSIGNAL 0
-#endif
-#endif // _win_ or _darwin_
-
-void InitNetworkSubSystem();
-
-static struct TNetworkInitializer {
-    inline TNetworkInitializer() {
-        InitNetworkSubSystem();
-    }
-} NetworkInitializerObject;

package/inc/util/network/interface.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "address.h"
-
-#include <util/generic/vector.h>
-
-namespace NAddr {
-    struct TNetworkInterface {
-        TString Name;
-        IRemoteAddrRef Address;
-        IRemoteAddrRef Mask;
-    };
-
-    using TNetworkInterfaceList = TVector<TNetworkInterface>;
-
-    TNetworkInterfaceList GetNetworkInterfaces();
-}