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;
    }

}