library/cpp/lfalloc/dbg_info/dbg_info.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
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;
    }
 
}