path: root/util/memory/tempbuf.cpp

#include "tempbuf.h"
#include "addstorage.h"

#include <util/system/tls.h>
#include <util/system/yassert.h>
#include <util/system/defaults.h>
#include <util/generic/intrlist.h>
#include <util/generic/singleton.h>
#include <util/generic/yexception.h>
#include <utility>
#include <util/thread/singleton.h>

#ifndef TMP_BUF_LEN
    #define TMP_BUF_LEN (64 * 1024)
#endif

class TTempBuf::TImpl: public TRefCounted<TImpl, TSimpleCounter, TImpl> {
public:
    inline TImpl(void* data, size_t size) noexcept
        : Data_(data)
        , Size_(size)
        , Offset_(0)
    {
    }

    /*
     * We do not really need 'virtual' here
     * but for compiler happiness...
     */
    virtual ~TImpl() = default;

    inline void* Data() noexcept {
        return Data_;
    }

    const void* Data() const noexcept {
        return Data_;
    }

    inline size_t Size() const noexcept {
        return Size_;
    }

    inline size_t Filled() const noexcept {
        return Offset_;
    }

    inline void Reset() noexcept {
        Offset_ = 0;
    }

    inline size_t Left() const noexcept {
        return Size() - Filled();
    }

    void SetPos(size_t off) {
        Y_ASSERT(off <= Size());
        Offset_ = off;
    }

    inline void Proceed(size_t off) {
        Y_ASSERT(off <= Left());

        Offset_ += off;
    }

    static inline void Destroy(TImpl* This) noexcept {
        This->Dispose();
    }

protected:
    virtual void Dispose() noexcept = 0;

private:
    void* Data_;
    size_t Size_;
    size_t Offset_;
};

namespace {
    class TTempBufManager;

    class TAllocedBuf: public TTempBuf::TImpl, public TAdditionalStorage<TAllocedBuf> {
    public:
        inline TAllocedBuf()
            : TImpl(AdditionalData(), AdditionalDataLength())
        {
        }

        inline ~TAllocedBuf() override = default;

    private:
        void Dispose() noexcept override {
            delete this;
        }
    };

    class TPerThreadedBuf: public TTempBuf::TImpl, public TIntrusiveSListItem<TPerThreadedBuf> {
        friend class TTempBufManager;

    public:
        inline TPerThreadedBuf(TTempBufManager* manager) noexcept
            : TImpl(Data_, sizeof(Data_))
            , Manager_(manager)
        {
        }

        inline ~TPerThreadedBuf() override = default;

    private:
        void Dispose() noexcept override;

    private:
        char Data_[TMP_BUF_LEN];
        TTempBufManager* Manager_;
    };

    class TTempBufManager {
        struct TDelete {
            inline void operator()(TPerThreadedBuf* p) noexcept {
                delete p;
            }
        };

    public:
        inline TTempBufManager() noexcept {
        }

        inline ~TTempBufManager() {
            TDelete deleter;

            Unused_.ForEach(deleter);
        }

        inline TPerThreadedBuf* Acquire() { 
            if (!Unused_.Empty()) {
                return Unused_.PopFront();
            }

            return new TPerThreadedBuf(this);
        }

        inline void Return(TPerThreadedBuf* buf) noexcept {
            buf->Reset();
            Unused_.PushFront(buf);
        }

    private:
        TIntrusiveSList<TPerThreadedBuf> Unused_;
    };
}

static inline TTempBufManager* TempBufManager() {
    return FastTlsSingletonWithPriority<TTempBufManager, 2>();
}

static inline TTempBuf::TImpl* AcquireSmallBuffer(size_t size) { 
#if defined(_asan_enabled_) 
    return new (size) TAllocedBuf(); 
#else 
    Y_UNUSED(size); 
    return TempBufManager()->Acquire(); 
#endif 
} 
 
void TPerThreadedBuf::Dispose() noexcept {
    if (Manager_ == TempBufManager()) {
        Manager_->Return(this);
    } else {
        delete this;
    }
}

TTempBuf::TTempBuf()
    : Impl_(AcquireSmallBuffer(TMP_BUF_LEN)) 
{
}

/*
 * all magick is here:
 * if len <= TMP_BUF_LEN. then we get prealloced per threaded buffer
 * else allocate one in heap
 */
static inline TTempBuf::TImpl* ConstructImpl(size_t len) {
    if (len <= TMP_BUF_LEN) {
        return AcquireSmallBuffer(len); 
    }

    return new (len) TAllocedBuf();
}

TTempBuf::TTempBuf(size_t len)
    : Impl_(ConstructImpl(len))
{
}

TTempBuf::TTempBuf(const TTempBuf&) noexcept = default;

TTempBuf::TTempBuf(TTempBuf&& b) noexcept
    : Impl_(std::move(b.Impl_))
{
}

TTempBuf::~TTempBuf() = default;

TTempBuf& TTempBuf::operator=(const TTempBuf& b) noexcept {
    if (this != &b) {
        Impl_ = b.Impl_;
    }

    return *this;
}

TTempBuf& TTempBuf::operator=(TTempBuf&& b) noexcept {
    if (this != &b) {
        Impl_ = std::move(b.Impl_);
    }

    return *this;
}

char* TTempBuf::Data() noexcept {
    return (char*)Impl_->Data();
}

const char* TTempBuf::Data() const noexcept {
    return static_cast<const char*>(Impl_->Data());
}

size_t TTempBuf::Size() const noexcept {
    return Impl_->Size();
}

char* TTempBuf::Current() noexcept {
    return Data() + Filled();
}

const char* TTempBuf::Current() const noexcept {
    return Data() + Filled();
}

size_t TTempBuf::Filled() const noexcept {
    return Impl_->Filled();
}

size_t TTempBuf::Left() const noexcept {
    return Impl_->Left();
}

void TTempBuf::Reset() noexcept {
    Impl_->Reset();
}

void TTempBuf::SetPos(size_t off) {
    Impl_->SetPos(off);
}

char* TTempBuf::Proceed(size_t off) {
    char* ptr = Current();
    Impl_->Proceed(off);
    return ptr;
}

void TTempBuf::Append(const void* data, size_t len) {
    if (len > Left()) {
        ythrow yexception() << "temp buf exhausted(" << Left() << ", " << len << ")";
    }

    memcpy(Current(), data, len);
    Proceed(len);
}

bool TTempBuf::IsNull() const noexcept {
    return !Impl_;
}

#if 0
    #include <util/datetime/cputimer.h>

    #define LEN (1024)

void* allocaFunc() {
    return alloca(LEN);
}

int main() {
    const size_t num = 10000000;
    size_t tmp = 0;

    {
        CTimer t("alloca");

        for (size_t i = 0; i < num; ++i) {
            tmp += (size_t)allocaFunc();
        }
    }

    {
        CTimer t("log buffer");

        for (size_t i = 0; i < num; ++i) {
            TTempBuf buf(LEN);

            tmp += (size_t)buf.Data();
        }
    }

    {
        CTimer t("malloc");

        for (size_t i = 0; i < num; ++i) {
            void* ptr = malloc(LEN);

            tmp += (size_t)ptr;

            free(ptr);
        }
    }

    return 0;
}
#endif