intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

3 files changed, 216 insertions, 0 deletions

diff --git a/library/cpp/lfalloc/dbg_info/dbg_info.cpp b/library/cpp/lfalloc/dbg_info/dbg_info.cpp
new file mode 100644
index 0000000000..1fb9f7ad93
--- /dev/null
+++ b/library/cpp/lfalloc/dbg_info/dbg_info.cpp
@@ -0,0 +1,124 @@
+#include "dbg_info.h"
+
+#include <library/cpp/malloc/api/malloc.h>
+
+namespace NAllocDbg {
+    ////////////////////////////////////////////////////////////////////////////////
+
+    using TGetAllocationCounter = i64(int counter);
+
+    using TSetThreadAllocTag = int(int tag);
+    using TGetPerTagAllocInfo = void(
+        bool flushPerThreadCounters,
+        TPerTagAllocInfo* info,
+        int& maxTag,
+        int& numSizes);
+
+    using TSetProfileCurrentThread = bool(bool newVal);
+    using TSetProfileAllThreads = bool(bool newVal);
+    using TSetAllocationSamplingEnabled = bool(bool newVal);
+
+    using TSetAllocationSampleRate = size_t(size_t newVal);
+    using TSetAllocationSampleMaxSize = size_t(size_t newVal);
+
+    using TSetAllocationCallback = TAllocationCallback*(TAllocationCallback* newVal);
+    using TSetDeallocationCallback = TDeallocationCallback*(TDeallocationCallback* newVal);
+
+    struct TAllocFn {
+        TGetAllocationCounter* GetAllocationCounterFast = nullptr;
+        TGetAllocationCounter* GetAllocationCounterFull = nullptr;
+
+        TSetThreadAllocTag* SetThreadAllocTag = nullptr;
+        TGetPerTagAllocInfo* GetPerTagAllocInfo = nullptr;
+
+        TSetProfileCurrentThread* SetProfileCurrentThread = nullptr;
+        TSetProfileAllThreads* SetProfileAllThreads = nullptr;
+        TSetAllocationSamplingEnabled* SetAllocationSamplingEnabled = nullptr;
+
+        TSetAllocationSampleRate* SetAllocationSampleRate = nullptr;
+        TSetAllocationSampleMaxSize* SetAllocationSampleMaxSize = nullptr;
+
+        TSetAllocationCallback* SetAllocationCallback = nullptr;
+        TSetDeallocationCallback* SetDeallocationCallback = nullptr;
+
+        TAllocFn() {
+            auto mallocInfo = NMalloc::MallocInfo();
+
+            GetAllocationCounterFast = (TGetAllocationCounter*)mallocInfo.GetParam("GetLFAllocCounterFast");
+            GetAllocationCounterFull = (TGetAllocationCounter*)mallocInfo.GetParam("GetLFAllocCounterFull");
+
+            SetThreadAllocTag = (TSetThreadAllocTag*)mallocInfo.GetParam("SetThreadAllocTag");
+            GetPerTagAllocInfo = (TGetPerTagAllocInfo*)mallocInfo.GetParam("GetPerTagAllocInfo");
+
+            SetProfileCurrentThread = (TSetProfileCurrentThread*)mallocInfo.GetParam("SetProfileCurrentThread");
+            SetProfileAllThreads = (TSetProfileAllThreads*)mallocInfo.GetParam("SetProfileAllThreads");
+            SetAllocationSamplingEnabled = (TSetAllocationSamplingEnabled*)mallocInfo.GetParam("SetAllocationSamplingEnabled");
+
+            SetAllocationSampleRate = (TSetAllocationSampleRate*)mallocInfo.GetParam("SetAllocationSampleRate");
+            SetAllocationSampleMaxSize = (TSetAllocationSampleMaxSize*)mallocInfo.GetParam("SetAllocationSampleMaxSize");
+
+            SetAllocationCallback = (TSetAllocationCallback*)mallocInfo.GetParam("SetAllocationCallback");
+            SetDeallocationCallback = (TSetDeallocationCallback*)mallocInfo.GetParam("SetDeallocationCallback");
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////
+
+    static TAllocFn AllocFn;
+
+    i64 GetAllocationCounterFast(ELFAllocCounter counter) {
+        return AllocFn.GetAllocationCounterFast ? AllocFn.GetAllocationCounterFast(counter) : 0;
+    }
+
+    i64 GetAllocationCounterFull(ELFAllocCounter counter) {
+        return AllocFn.GetAllocationCounterFull ? AllocFn.GetAllocationCounterFull(counter) : 0;
+    }
+
+    int SetThreadAllocTag(int tag) {
+        return AllocFn.SetThreadAllocTag ? AllocFn.SetThreadAllocTag(tag) : 0;
+    }
+
+    TArrayPtr<TPerTagAllocInfo> GetPerTagAllocInfo(
+        bool flushPerThreadCounters,
+        int& maxTag,
+        int& numSizes) {
+        if (AllocFn.GetPerTagAllocInfo) {
+            AllocFn.GetPerTagAllocInfo(flushPerThreadCounters, nullptr, maxTag, numSizes);
+            TArrayPtr<TPerTagAllocInfo> info = new TPerTagAllocInfo[maxTag * numSizes];
+            AllocFn.GetPerTagAllocInfo(flushPerThreadCounters, info.Get(), maxTag, numSizes);
+            return info;
+        }
+        maxTag = 0;
+        numSizes = 0;
+        return nullptr;
+    }
+
+    bool SetProfileCurrentThread(bool newVal) {
+        return AllocFn.SetProfileCurrentThread ? AllocFn.SetProfileCurrentThread(newVal) : false;
+    }
+
+    bool SetProfileAllThreads(bool newVal) {
+        return AllocFn.SetProfileAllThreads ? AllocFn.SetProfileAllThreads(newVal) : false;
+    }
+
+    bool SetAllocationSamplingEnabled(bool newVal) {
+        return AllocFn.SetAllocationSamplingEnabled ? AllocFn.SetAllocationSamplingEnabled(newVal) : false;
+    }
+
+    size_t SetAllocationSampleRate(size_t newVal) {
+        return AllocFn.SetAllocationSampleRate ? AllocFn.SetAllocationSampleRate(newVal) : 0;
+    }
+
+    size_t SetAllocationSampleMaxSize(size_t newVal) {
+        return AllocFn.SetAllocationSampleMaxSize ? AllocFn.SetAllocationSampleMaxSize(newVal) : 0;
+    }
+
+    TAllocationCallback* SetAllocationCallback(TAllocationCallback* newVal) {
+        return AllocFn.SetAllocationCallback ? AllocFn.SetAllocationCallback(newVal) : nullptr;
+    }
+
+    TDeallocationCallback* SetDeallocationCallback(TDeallocationCallback* newVal) {
+        return AllocFn.SetDeallocationCallback ? AllocFn.SetDeallocationCallback(newVal) : nullptr;
+    }
+
+}
diff --git a/library/cpp/lfalloc/dbg_info/dbg_info.h b/library/cpp/lfalloc/dbg_info/dbg_info.h
new file mode 100644
index 0000000000..071562a81a
--- /dev/null
+++ b/library/cpp/lfalloc/dbg_info/dbg_info.h
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <util/generic/ptr.h>
+#include <util/system/types.h>
+
+namespace NAllocDbg {
+    ////////////////////////////////////////////////////////////////////////////////
+    // Allocation statistics
+
+    enum ELFAllocCounter {
+        CT_USER_ALLOC,     // accumulated size requested by user code
+        CT_MMAP,           // accumulated mmapped size
+        CT_MMAP_CNT,       // number of mmapped regions
+        CT_MUNMAP,         // accumulated unmmapped size
+        CT_MUNMAP_CNT,     // number of munmaped regions
+        CT_SYSTEM_ALLOC,   // accumulated allocated size for internal lfalloc needs
+        CT_SYSTEM_FREE,    // accumulated deallocated size for internal lfalloc needs
+        CT_SMALL_ALLOC,    // accumulated allocated size for fixed-size blocks
+        CT_SMALL_FREE,     // accumulated deallocated size for fixed-size blocks
+        CT_LARGE_ALLOC,    // accumulated allocated size for large blocks
+        CT_LARGE_FREE,     // accumulated deallocated size for large blocks
+        CT_SLOW_ALLOC_CNT, // number of slow (not LF) allocations
+        CT_DEGRAGMENT_CNT, // number of memory defragmentations
+        CT_MAX
+    };
+
+    i64 GetAllocationCounterFast(ELFAllocCounter counter);
+    i64 GetAllocationCounterFull(ELFAllocCounter counter);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Allocation statistics could be tracked on per-tag basis
+
+    int SetThreadAllocTag(int tag);
+
+    class TScopedTag {
+    private:
+        int PrevTag;
+
+    public:
+        explicit TScopedTag(int tag) {
+            PrevTag = SetThreadAllocTag(tag);
+        }
+
+        ~TScopedTag() {
+            SetThreadAllocTag(PrevTag);
+        }
+    };
+
+    struct TPerTagAllocInfo {
+        ssize_t Count;
+        ssize_t Size;
+    };
+
+    TArrayPtr<TPerTagAllocInfo> GetPerTagAllocInfo(
+        bool flushPerThreadCounters,
+        int& maxTag,
+        int& numSizes);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Allocation sampling could be used to collect detailed information
+
+    bool SetProfileCurrentThread(bool newVal);
+    bool SetProfileAllThreads(bool newVal);
+    bool SetAllocationSamplingEnabled(bool newVal);
+
+    size_t SetAllocationSampleRate(size_t newVal);
+    size_t SetAllocationSampleMaxSize(size_t newVal);
+
+#define DBG_ALLOC_INVALID_COOKIE (-1)
+
+    using TAllocationCallback = int(int tag, size_t size, int sizeIdx);
+    using TDeallocationCallback = void(int cookie, int tag, size_t size, int sizeIdx);
+
+    TAllocationCallback* SetAllocationCallback(TAllocationCallback* newVal);
+    TDeallocationCallback* SetDeallocationCallback(TDeallocationCallback* newVal);
+
+}
diff --git a/library/cpp/lfalloc/dbg_info/ya.make b/library/cpp/lfalloc/dbg_info/ya.make
new file mode 100644
index 0000000000..efecba5993
--- /dev/null
+++ b/library/cpp/lfalloc/dbg_info/ya.make
@@ -0,0 +1,15 @@
+LIBRARY()
+
+OWNER(vskipin)
+
+PEERDIR(
+    library/cpp/malloc/api
+)
+
+SRCS(
+    dbg_info.cpp
+)
+
+SET(IDE_FOLDER "util")
+
+END()