LLVM  16.0.0git
MemProfData.inc
Go to the documentation of this file.
1 #ifndef MEMPROF_DATA_INC
2 #define MEMPROF_DATA_INC
3 /*===-- MemProfData.inc - MemProf profiling runtime structures -*- C++ -*-=== *\
4 |*
5 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
6 |* See https://llvm.org/LICENSE.txt for license information.
7 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
8 |*
9 \*===----------------------------------------------------------------------===*/
10 /*
11  * This is the main file that defines all the data structure, signature,
12  * constant literals that are shared across profiling runtime library,
13  * and host tools (reader/writer).
14  *
15  * This file has two identical copies. The primary copy lives in LLVM and
16  * the other one sits in compiler-rt/include/profile directory. To make changes
17  * in this file, first modify the primary copy and copy it over to compiler-rt.
18  * Testing of any change in this file can start only after the two copies are
19  * synced up.
20  *
21 \*===----------------------------------------------------------------------===*/
22 
23 #ifdef _MSC_VER
24 #define PACKED(...) __pragma(pack(push,1)) __VA_ARGS__ __pragma(pack(pop))
25 #else
26 #define PACKED(...) __VA_ARGS__ __attribute__((__packed__))
27 #endif
28 
29 // A 64-bit magic number to uniquely identify the raw binary memprof profile file.
30 #define MEMPROF_RAW_MAGIC_64 \
31  ((uint64_t)255 << 56 | (uint64_t)'m' << 48 | (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | \
32  (uint64_t)'o' << 24 | (uint64_t)'f' << 16 | (uint64_t)'r' << 8 | (uint64_t)129)
33 
34 // The version number of the raw binary format.
35 #define MEMPROF_RAW_VERSION 1ULL
36 
37 namespace llvm {
38 namespace memprof {
39 // A struct describing the header used for the raw binary memprof profile format.
40 PACKED(struct Header {
43  uint64_t TotalSize;
45  uint64_t MIBOffset;
46  uint64_t StackOffset;
47 });
48 
49 
50 // A struct describing the information necessary to describe a /proc/maps
51 // segment entry for a particular binary/library identified by its build id.
52 PACKED(struct SegmentEntry {
53  uint64_t Start;
54  uint64_t End;
56  // This field is unused until sanitizer procmaps support for build ids for
57  // Linux-Elf is implemented.
58  uint8_t BuildId[32] = {0};
59 
60  SegmentEntry(uint64_t S, uint64_t E, uint64_t O) :
61  Start(S), End(E), Offset(O) {}
62 
63  SegmentEntry(const SegmentEntry& S) {
64  Start = S.Start;
65  End = S.End;
66  Offset = S.Offset;
67  }
68 
69  SegmentEntry& operator=(const SegmentEntry& S) {
70  Start = S.Start;
71  End = S.End;
72  Offset = S.Offset;
73  return *this;
74  }
75 
76  bool operator==(const SegmentEntry& S) const {
77  return Start == S.Start &&
78  End == S.End &&
79  Offset == S.Offset;
80  }
81 });
82 
83 // Packed struct definition for MSVC. We can't use the PACKED macro defined in
84 // MemProfData.inc since it would mean we are embedding a directive (the
85 // #include for MIBEntryDef) into the macros which is undefined behaviour.
86 #ifdef _MSC_VER
87 __pragma(pack(push,1))
88 #endif
89 
90 // A struct representing the heap allocation characteristics of a particular
91 // runtime context. This struct is shared between the compiler-rt runtime and
92 // the raw profile reader. The indexed format uses a separate, self-describing
93 // backwards compatible format.
94 struct MemInfoBlock{
95 
96 #define MIBEntryDef(NameTag, Name, Type) Type Name;
97 #include "MIBEntryDef.inc"
98 #undef MIBEntryDef
99 
100 bool operator==(const MemInfoBlock& Other) const {
101  bool IsEqual = true;
102 #define MIBEntryDef(NameTag, Name, Type) \
103  IsEqual = (IsEqual && Name == Other.Name);
104 #include "MIBEntryDef.inc"
105 #undef MIBEntryDef
106  return IsEqual;
107 }
108 
109 MemInfoBlock() {
110 #define MIBEntryDef(NameTag, Name, Type) Name = Type();
111 #include "MIBEntryDef.inc"
112 #undef MIBEntryDef
113 }
114 
115 MemInfoBlock(uint32_t Size, uint64_t AccessCount, uint32_t AllocTs,
116  uint32_t DeallocTs, uint32_t AllocCpu, uint32_t DeallocCpu)
117  : MemInfoBlock() {
118  AllocCount = 1U;
119  TotalAccessCount = AccessCount;
120  MinAccessCount = AccessCount;
121  MaxAccessCount = AccessCount;
122  TotalSize = Size;
123  MinSize = Size;
124  MaxSize = Size;
125  AllocTimestamp = AllocTs;
126  DeallocTimestamp = DeallocTs;
127  TotalLifetime = DeallocTimestamp - AllocTimestamp;
128  MinLifetime = TotalLifetime;
129  MaxLifetime = TotalLifetime;
130  AllocCpuId = AllocCpu;
131  DeallocCpuId = DeallocCpu;
132  NumMigratedCpu = AllocCpuId != DeallocCpuId;
133 }
134 
135 void Merge(const MemInfoBlock &newMIB) {
136  AllocCount += newMIB.AllocCount;
137 
138  TotalAccessCount += newMIB.TotalAccessCount;
139  MinAccessCount = newMIB.MinAccessCount < MinAccessCount ? newMIB.MinAccessCount : MinAccessCount;
140  MaxAccessCount = newMIB.MaxAccessCount > MaxAccessCount ? newMIB.MaxAccessCount : MaxAccessCount;
141 
142  TotalSize += newMIB.TotalSize;
143  MinSize = newMIB.MinSize < MinSize ? newMIB.MinSize : MinSize;
144  MaxSize = newMIB.MaxSize > MaxSize ? newMIB.MaxSize : MaxSize;
145 
146  TotalLifetime += newMIB.TotalLifetime;
147  MinLifetime = newMIB.MinLifetime < MinLifetime ? newMIB.MinLifetime : MinLifetime;
148  MaxLifetime = newMIB.MaxLifetime > MaxLifetime ? newMIB.MaxLifetime : MaxLifetime;
149 
150  // We know newMIB was deallocated later, so just need to check if it was
151  // allocated before last one deallocated.
152  NumLifetimeOverlaps += newMIB.AllocTimestamp < DeallocTimestamp;
153  AllocTimestamp = newMIB.AllocTimestamp;
154  DeallocTimestamp = newMIB.DeallocTimestamp;
155 
156  NumSameAllocCpu += AllocCpuId == newMIB.AllocCpuId;
157  NumSameDeallocCpu += DeallocCpuId == newMIB.DeallocCpuId;
158  AllocCpuId = newMIB.AllocCpuId;
159  DeallocCpuId = newMIB.DeallocCpuId;
160 }
161 
162 #ifdef _MSC_VER
163 } __pragma(pack(pop));
164 #else
165 } __attribute__((__packed__));
166 #endif
167 
168 } // namespace memprof
169 } // namespace llvm
170 
171 #endif
llvm::Check::Size
@ Size
Definition: FileCheck.h:77
Merge
R600 Clause Merge
Definition: R600ClauseMergePass.cpp:70
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
push
static void push(SmallVectorImpl< uint64_t > &R, StringRef Str)
Definition: BitstreamRemarkSerializer.cpp:24
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:1056
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:264
llvm::AMDGPU::Hwreg::Offset
Offset
Definition: SIDefines.h:416
uint64_t
llvm::operator==
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:2010
llvm::msf::Magic
static const char Magic[]
Definition: MSFCommon.h:23
SegmentOffset
static Constant * SegmentOffset(IRBuilderBase &IRB, int Offset, unsigned AddressSpace)
Definition: X86ISelLowering.cpp:2917
uint32_t
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
MIBEntryDef.inc