catboost 1.25.1 → 1.26.0

package/inc/util/memory/pool.h

@@ -1,432 +0,0 @@
-#pragma once
-
-#include "alloc.h"
-
-#include <util/system/align.h>
-#include <util/system/yassert.h>
-#include <util/generic/bitops.h>
-#include <util/generic/utility.h>
-#include <util/generic/intrlist.h>
-#include <util/generic/strbuf.h>
-#include <util/generic/singleton.h>
-
-#include <new>
-#include <string>
-#include <utility>
-
-/**
- * Memory pool implements a memory allocation scheme that is very fast, but
- * limited in its usage.
- *
- * A common use case is when you want to allocate a bunch of small objects, and
- * then release them all at some point of your program. Using memory pool, you
- * can just drop them off into oblivion without calling any destructors,
- * provided that all associated memory was allocated on the pool.
- */
-class TMemoryPool {
-private:
-    using TBlock = IAllocator::TBlock;
-
-    class TChunk: public TIntrusiveListItem<TChunk> {
-    public:
-        inline TChunk(size_t len = 0) noexcept
-            : Cur_((char*)(this + 1))
-            , Left_(len)
-        {
-            Y_ASSERT((((size_t)Cur_) % PLATFORM_DATA_ALIGN) == 0);
-        }
-
-        inline void* Allocate(size_t len) noexcept {
-            if (Left_ >= len) {
-                char* ret = Cur_;
-
-                Cur_ += len;
-                Left_ -= len;
-
-                return ret;
-            }
-
-            return nullptr;
-        }
-
-        inline void* Allocate(size_t len, size_t align) noexcept {
-            size_t pad = AlignUp(Cur_, align) - Cur_;
-
-            void* ret = Allocate(pad + len);
-            if (ret) {
-                return static_cast<char*>(ret) + pad;
-            }
-
-            return nullptr;
-        }
-
-        inline size_t BlockLength() const noexcept {
-            return (Cur_ + Left_) - (char*)this;
-        }
-
-        inline size_t Used() const noexcept {
-            return Cur_ - (const char*)this;
-        }
-
-        inline size_t Left() const noexcept {
-            return Left_;
-        }
-
-        inline const char* Data() const noexcept {
-            return (const char*)(this + 1);
-        }
-
-        inline char* Data() noexcept {
-            return (char*)(this + 1);
-        }
-
-        inline size_t DataSize() const noexcept {
-            return Cur_ - Data();
-        }
-
-        inline void ResetChunk() noexcept {
-            size_t total = DataSize() + Left();
-            Cur_ = Data();
-            Left_ = total;
-        }
-
-    private:
-        char* Cur_;
-        size_t Left_;
-    };
-
-    using TChunkList = TIntrusiveList<TChunk>;
-
-public:
-    class IGrowPolicy {
-    public:
-        virtual ~IGrowPolicy() = default;
-
-        virtual size_t Next(size_t prev) const noexcept = 0;
-    };
-
-    class TLinearGrow: public IGrowPolicy {
-    public:
-        size_t Next(size_t prev) const noexcept override {
-            return prev;
-        }
-
-        static IGrowPolicy* Instance() noexcept;
-    };
-
-    class TExpGrow: public IGrowPolicy {
-    public:
-        size_t Next(size_t prev) const noexcept override {
-            return prev * 2;
-        }
-
-        static IGrowPolicy* Instance() noexcept;
-    };
-
-    struct TOptions {
-        bool RoundUpToNextPowerOfTwo;
-        TOptions()
-            : RoundUpToNextPowerOfTwo(true)
-        {
-        }
-    };
-
-    inline TMemoryPool(size_t initial, IGrowPolicy* grow = TExpGrow::Instance(), IAllocator* alloc = TDefaultAllocator::Instance(), const TOptions& options = TOptions())
-        : Current_(&Empty_)
-        , BlockSize_(initial)
-        , GrowPolicy_(grow)
-        , Alloc_(alloc)
-        , Options_(options)
-        , Origin_(initial)
-        , MemoryAllocatedBeforeCurrent_(0)
-        , MemoryWasteBeforeCurrent_(0)
-    {
-    }
-
-    inline ~TMemoryPool() {
-        Clear();
-    }
-
-    inline void* Allocate(size_t len) {
-        return RawAllocate(AlignUp<size_t>(len, PLATFORM_DATA_ALIGN));
-    }
-
-    inline void* Allocate(size_t len, size_t align) {
-        return RawAllocate(AlignUp<size_t>(len, PLATFORM_DATA_ALIGN), align);
-    }
-
-    template <typename T>
-    inline T* Allocate() {
-        return (T*)this->Allocate(sizeof(T), alignof(T));
-    }
-
-    template <typename T>
-    inline T* Allocate(size_t align) {
-        return (T*)this->Allocate(sizeof(T), Max(align, alignof(T)));
-    }
-
-    template <typename T>
-    inline T* AllocateArray(size_t count) {
-        return (T*)this->Allocate(sizeof(T) * count, alignof(T));
-    }
-
-    template <typename T>
-    inline T* AllocateArray(size_t count, size_t align) {
-        return (T*)this->Allocate(sizeof(T) * count, Max(align, alignof(T)));
-    }
-
-    template <typename T>
-    inline T* AllocateZeroArray(size_t count) {
-        T* ptr = AllocateArray<T>(count);
-        memset(ptr, 0, count * sizeof(T));
-        return ptr;
-    }
-
-    template <typename T>
-    inline T* AllocateZeroArray(size_t count, size_t align) {
-        T* ptr = AllocateArray<T>(count, align);
-        memset(ptr, 0, count * sizeof(T));
-        return ptr;
-    }
-
-    template <typename T, typename... Args>
-    inline T* New(Args&&... args) {
-        return new (Allocate<T>()) T(std::forward<Args>(args)...);
-    }
-
-    template <typename T>
-    inline T* NewArray(size_t count) {
-        T* arr = (T*)AllocateArray<T>(count);
-
-        for (T *ptr = arr, *end = arr + count; ptr != end; ++ptr) {
-            new (ptr) T;
-        }
-
-        return arr;
-    }
-
-    template <typename TChar>
-    inline TChar* Append(const TChar* str) {
-        return Append(str, std::char_traits<TChar>::length(str) + 1); // include terminating zero byte
-    }
-
-    template <typename TChar>
-    inline TChar* Append(const TChar* str, size_t len) {
-        TChar* ret = static_cast<TChar*>(Allocate(len * sizeof(TChar)));
-
-        std::char_traits<TChar>::copy(ret, str, len);
-
-        return ret;
-    }
-
-    template <typename TChar>
-    inline TBasicStringBuf<TChar> AppendString(const TBasicStringBuf<TChar>& buf) {
-        return TBasicStringBuf<TChar>(Append(buf.data(), buf.size()), buf.size());
-    }
-
-    template <typename TChar>
-    inline TBasicStringBuf<TChar> AppendCString(const TBasicStringBuf<TChar>& buf) {
-        TChar* ret = static_cast<TChar*>(Allocate((buf.size() + 1) * sizeof(TChar)));
-
-        std::char_traits<TChar>::copy(ret, buf.data(), buf.size());
-        *(ret + buf.size()) = 0;
-        return TBasicStringBuf<TChar>(ret, buf.size());
-    }
-
-    inline size_t Available() const noexcept {
-        return Current_->Left();
-    }
-
-    inline void Clear() noexcept {
-        DoClear(false);
-    }
-
-    inline void ClearKeepFirstChunk() noexcept {
-        DoClear(true);
-    }
-
-    inline size_t MemoryAllocated() const noexcept {
-        return MemoryAllocatedBeforeCurrent_ + (Current_ != &Empty_ ? Current_->Used() : 0);
-    }
-
-    inline size_t MemoryWaste() const noexcept {
-        return MemoryWasteBeforeCurrent_ + (Current_ != &Empty_ ? Current_->Left() : 0);
-    }
-
-    template <class TOp>
-    inline void Traverse(TOp& op) const noexcept {
-        for (TChunkList::TConstIterator i = Chunks_.Begin(); i != Chunks_.End(); ++i) {
-            op(i->Data(), i->DataSize());
-        }
-    }
-
-    inline IAllocator* RealAllocator() const noexcept {
-        return Alloc_;
-    }
-
-protected:
-    inline void* RawAllocate(size_t len) {
-        void* ret = Current_->Allocate(len);
-
-        if (ret) {
-            return ret;
-        }
-
-        AddChunk(len);
-
-        return Current_->Allocate(len);
-    }
-
-    inline void* RawAllocate(size_t len, size_t align) {
-        Y_ASSERT(align > 0);
-        void* ret = Current_->Allocate(len, align);
-
-        if (ret) {
-            return ret;
-        }
-
-        AddChunk(len + align - 1);
-
-        return Current_->Allocate(len, align);
-    }
-
-private:
-    void AddChunk(size_t hint);
-    void DoClear(bool keepfirst) noexcept;
-
-private:
-    TChunk Empty_;
-    TChunk* Current_;
-    size_t BlockSize_;
-    IGrowPolicy* GrowPolicy_;
-    IAllocator* Alloc_;
-    TOptions Options_;
-    TChunkList Chunks_;
-    const size_t Origin_;
-    size_t MemoryAllocatedBeforeCurrent_;
-    size_t MemoryWasteBeforeCurrent_;
-};
-
-template <typename TPool>
-struct TPoolableBase {
-    inline void* operator new(size_t bytes, TPool& pool) {
-        return pool.Allocate(bytes);
-    }
-
-    inline void* operator new(size_t bytes, std::align_val_t align, TPool& pool) {
-        return pool.Allocate(bytes, (size_t)align);
-    }
-
-    inline void operator delete(void*, size_t) noexcept {
-    }
-
-    inline void operator delete(void*, TPool&) noexcept {
-    }
-
-private:
-    inline void* operator new(size_t); // disallow default allocation
-};
-
-struct TPoolable: public TPoolableBase<TMemoryPool> {
-};
-
-class TMemoryPoolAllocator: public IAllocator {
-public:
-    inline TMemoryPoolAllocator(TMemoryPool* pool)
-        : Pool_(pool)
-    {
-    }
-
-    TBlock Allocate(size_t len) override {
-        TBlock ret = {Pool_->Allocate(len), len};
-
-        return ret;
-    }
-
-    void Release(const TBlock& block) override {
-        (void)block;
-    }
-
-private:
-    TMemoryPool* Pool_;
-};
-
-template <class T, class TPool>
-class TPoolAllocBase {
-public:
-    using pointer = T*;
-    using const_pointer = const T*;
-    using reference = T&;
-    using const_reference = const T&;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-    using value_type = T;
-
-    inline TPoolAllocBase(TPool* pool)
-        : Pool_(pool)
-    {
-    }
-
-    template <typename TOther>
-    inline TPoolAllocBase(const TPoolAllocBase<TOther, TPool>& o)
-        : Pool_(o.GetPool())
-    {
-    }
-
-    inline T* allocate(size_t n) {
-        return (T*)Pool_->Allocate(n * sizeof(T), alignof(T));
-    }
-
-    inline void deallocate(pointer /*p*/, size_t /*n*/) {
-    }
-
-    template <class T1>
-    struct rebind {
-        using other = TPoolAllocBase<T1, TPool>;
-    };
-
-    inline size_type max_size() const noexcept {
-        return size_type(-1) / sizeof(T);
-    }
-
-    template <typename... Args>
-    inline void construct(pointer p, Args&&... args) {
-        new (p) T(std::forward<Args>(args)...);
-    }
-
-    inline void destroy(pointer p) noexcept {
-        (void)p; /* Make MSVC happy. */
-        p->~T();
-    }
-
-    inline TPool* GetPool() const {
-        return Pool_;
-    }
-
-    inline friend bool operator==(const TPoolAllocBase& l, const TPoolAllocBase& r) {
-        return l.Pool_ == r.Pool_;
-    }
-
-    inline friend bool operator!=(const TPoolAllocBase& l, const TPoolAllocBase& r) {
-        return !(l == r);
-    }
-
-private:
-    TPool* Pool_;
-};
-
-template <class T>
-using TPoolAlloc = TPoolAllocBase<T, TMemoryPool>;
-
-// Any type since it is supposed to be rebound anyway.
-using TPoolAllocator = TPoolAlloc<int>;
-
-template <class T>
-inline bool operator==(const TPoolAlloc<T>&, const TPoolAlloc<T>&) noexcept {
-    return true;
-}
-
-template <class T>
-inline bool operator!=(const TPoolAlloc<T>&, const TPoolAlloc<T>&) noexcept {
-    return false;
-}

package/inc/util/memory/segmented_string_pool.h

@@ -1,194 +0,0 @@
-#pragma once
-
-#include <util/system/align.h>
-#include <util/system/yassert.h>
-#include <util/system/defaults.h>
-#include <util/generic/noncopyable.h>
-#include <util/generic/vector.h>
-#include <util/generic/strbuf.h>
-
-#include <memory>
-#include <cstdio>
-#include <cstdlib>
-
-/*
- * Non-reallocated storage for the objects of POD type
- */
-template <class T, class Alloc = std::allocator<T>>
-class segmented_pool : TNonCopyable {
-protected:
-    Alloc seg_allocator;
-    struct seg_inf {
-        T* data;   // allocated chunk
-        size_t _size;   // size of allocated chunk in sizeof(T)-units
-        size_t freepos; // offset to free chunk's memory in bytes
-        seg_inf()
-            : data(nullptr)
-            , _size(0)
-            , freepos(0)
-        {
-        }
-        seg_inf(T* d, size_t sz)
-            : data(d)
-            , _size(sz)
-            , freepos(0)
-        {
-        }
-    };
-    using seg_container = TVector<seg_inf>;
-    using seg_iterator = typename seg_container::iterator;
-    using seg_const_iterator = typename seg_container::const_iterator;
-    const size_t segment_size; // default size of a memory chunk in sizeof(T)-units
-    size_t last_free;          // size of free memory in chunk in sizeof(T)-units
-    size_t last_ins_size;      // size of memory used in chunk by the last append() in bytes
-    seg_container segs;        // array of memory chunks
-    seg_iterator curseg;       // a segment for the current insertion
-    const char* Name;          // for debug memory usage
-protected:
-    void check_capacity(size_t len) {
-        if (Y_UNLIKELY(!last_free || len > last_free)) {
-            if (curseg != segs.end() && curseg->freepos > 0)
-                ++curseg;
-            last_free = (len > segment_size ? len : segment_size);
-            if (curseg == segs.end() || curseg->_size < last_free) {
-                segs.push_back(seg_inf(seg_allocator.allocate(last_free), last_free));
-                if (Y_UNLIKELY(Name))
-                    printf("Pool \"%s\" was increased by %" PRISZT " bytes to %" PRISZT " Mb.\n", Name, last_free * sizeof(T), capacity() / 0x100000);
-                curseg = segs.end() - 1;
-            }
-            Y_ASSERT(curseg->freepos == 0);
-            Y_ASSERT(curseg->_size >= last_free);
-        }
-    }
-
-public:
-    explicit segmented_pool(size_t segsz, const char* name = nullptr)
-        : segment_size(segsz)
-        , last_free(0)
-        , last_ins_size(0)
-        , Name(name)
-    {
-        curseg = segs.begin();
-    }
-    ~segmented_pool() {
-        clear();
-    }
-    /* src - array of objects, len - count of elements in array */
-    T* append(const T* src, size_t len) {
-        check_capacity(len);
-        ui8* rv = (ui8*)curseg->data + curseg->freepos;
-        last_ins_size = sizeof(T) * len;
-        if (src)
-            memcpy(rv, src, last_ins_size);
-        curseg->freepos += last_ins_size, last_free -= len;
-        return (T*)rv;
-    }
-    T* append() {
-        T* obj = get_raw();
-        new (obj) T();
-        return obj;
-    }
-    T* get_raw() { // append(0, 1)
-        check_capacity(1);
-        ui8* rv = (ui8*)curseg->data + curseg->freepos;
-        last_ins_size = sizeof(T);
-        curseg->freepos += last_ins_size, last_free -= 1;
-        return (T*)rv;
-    }
-    size_t get_segment_size() const {
-        return segment_size;
-    }
-    bool contains(const T* ptr) const {
-        for (seg_const_iterator i = segs.begin(), ie = segs.end(); i != ie; ++i)
-            if ((char*)ptr >= (char*)i->data && (char*)ptr < (char*)i->data + i->freepos)
-                return true;
-        return false;
-    }
-    size_t size() const {
-        size_t r = 0;
-        for (seg_const_iterator i = segs.begin(); i != segs.end(); ++i)
-            r += i->freepos;
-        return r;
-    }
-    size_t capacity() const {
-        return segs.size() * segment_size * sizeof(T);
-    }
-    void restart() {
-        if (curseg != segs.end())
-            ++curseg;
-        for (seg_iterator i = segs.begin(); i != curseg; ++i)
-            i->freepos = 0;
-        curseg = segs.begin();
-        last_free = 0;
-        last_ins_size = 0;
-    }
-    void clear() {
-        for (seg_iterator i = segs.begin(); i != segs.end(); ++i)
-            seg_allocator.deallocate(i->data, i->_size);
-        segs.clear();
-        curseg = segs.begin();
-        last_free = 0;
-        last_ins_size = 0;
-    }
-    void undo_last_append() {
-        Y_ASSERT(curseg != segs.end()); // do not use before append()
-        if (last_ins_size) {
-            Y_ASSERT(last_ins_size <= curseg->freepos);
-            curseg->freepos -= last_ins_size;
-            last_free += last_ins_size / sizeof(T);
-            last_ins_size = 0;
-        }
-    }
-    void alloc_first_seg() {
-        Y_ASSERT(capacity() == 0);
-        check_capacity(segment_size);
-        Y_ASSERT(capacity() == segment_size * sizeof(T));
-    }
-};
-
-class segmented_string_pool: public segmented_pool<char> {
-private:
-    using _Base = segmented_pool<char>;
-
-public:
-    segmented_string_pool()
-        : segmented_string_pool(1024 * 1024)
-    {
-    }
-
-    explicit segmented_string_pool(size_t segsz)
-        : _Base(segsz)
-    {
-    }
-    char* append(const char* src) {
-        Y_ASSERT(src);
-        return _Base::append(src, strlen(src) + 1);
-    }
-    char* append(const char* src, size_t len) {
-        char* rv = _Base::append(nullptr, len + 1);
-        if (src)
-            memcpy(rv, src, len);
-        rv[len] = 0;
-        return rv;
-    }
-    char* Append(const TStringBuf s) {
-        return append(s.data(), s.size());
-    }
-    void align_4() {
-        size_t t = (curseg->freepos + 3) & ~3;
-        last_free -= t - curseg->freepos;
-        curseg->freepos = t;
-    }
-    char* Allocate(size_t len) {
-        return append(nullptr, len);
-    }
-};
-
-template <typename T, typename C>
-inline T* pool_push(segmented_pool<C>& pool, const T* v) {
-    static_assert(sizeof(C) == 1, "only char type supported");
-    size_t len = SizeOf(v);
-    C* buf = pool.append(nullptr, AlignUp(len));
-    memcpy(buf, v, len);
-    return (T*)buf;
-}