1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "native_memory_stdtype.h"
16
17 namespace SysTuning {
18 namespace TraceStdtype {
AppendNativeHookSampleBase(uint32_t callChainId,uint32_t ipid,uint32_t itid,uint64_t timeStamp)19 void NativeHookSampleBase::AppendNativeHookSampleBase(uint32_t callChainId,
20 uint32_t ipid,
21 uint32_t itid,
22 uint64_t timeStamp)
23 {
24 ids_.emplace_back(id_++);
25 callChainIds_.emplace_back(callChainId);
26 ipids_.emplace_back(ipid);
27 internalTids_.emplace_back(itid);
28 timeStamps_.emplace_back(timeStamp);
29 lastCallerPathIndexs_.emplace_back(INVALID_DATAINDEX);
30 lastSymbolIndexs_.emplace_back(INVALID_DATAINDEX);
31 }
AppendNativeHookSampleBase(uint32_t callChainId,uint32_t ipid,uint64_t timeStamp)32 void NativeHookSampleBase::AppendNativeHookSampleBase(uint32_t callChainId, uint32_t ipid, uint64_t timeStamp)
33 {
34 ids_.emplace_back(id_++);
35 callChainIds_.emplace_back(callChainId);
36 ipids_.emplace_back(ipid);
37 timeStamps_.emplace_back(timeStamp);
38 lastCallerPathIndexs_.emplace_back(INVALID_DATAINDEX);
39 lastSymbolIndexs_.emplace_back(INVALID_DATAINDEX);
40 }
CallChainIds() const41 const std::deque<uint32_t> &NativeHookSampleBase::CallChainIds() const
42 {
43 return callChainIds_;
44 }
Ipids() const45 const std::deque<uint32_t> &NativeHookSampleBase::Ipids() const
46 {
47 return ipids_;
48 }
LastCallerPathIndexs() const49 const std::deque<uint64_t> &NativeHookSampleBase::LastCallerPathIndexs() const
50 {
51 return lastCallerPathIndexs_;
52 }
LastSymbolIndexs() const53 const std::deque<uint64_t> &NativeHookSampleBase::LastSymbolIndexs() const
54 {
55 return lastSymbolIndexs_;
56 }
UpdateLastCallerPathAndSymbolIndexs(std::unordered_map<uint32_t,std::tuple<DataIndex,DataIndex>> & callIdToLasLibId)57 void NativeHookSampleBase::UpdateLastCallerPathAndSymbolIndexs(
58 std::unordered_map<uint32_t, std::tuple<DataIndex, DataIndex>> &callIdToLasLibId)
59 {
60 if (callIdToLasLibId.empty()) {
61 return;
62 }
63 for (auto i = 0; i < Size(); ++i) {
64 auto symbolIt = callIdToLasLibId.find(callChainIds_[i]);
65 if (symbolIt != callIdToLasLibId.end()) {
66 std::tie(lastCallerPathIndexs_[i], lastSymbolIndexs_[i]) = symbolIt->second;
67 } else {
68 lastCallerPathIndexs_[i] = INVALID_DATAINDEX;
69 lastSymbolIndexs_[i] = INVALID_DATAINDEX;
70 }
71 }
72 }
AppendNewNativeHookData(const NativeHookRow & context)73 size_t NativeHook::AppendNewNativeHookData(const NativeHookRow &context)
74 {
75 AppendNativeHookSampleBase(context.callChainId, context.ipid, context.itid, context.timeStamp);
76 eventTypes_.emplace_back(context.eventType);
77 subTypes_.emplace_back(context.subType);
78 endTimeStamps_.emplace_back(context.endTimeStamp);
79 durations_.emplace_back(context.duration);
80 addrs_.emplace_back(context.addr);
81 memSizes_.emplace_back(context.memSize);
82 if (context.eventType == ALLOC_EVET) {
83 countHeapSizes_ += context.memSize;
84 allMemSizes_.emplace_back(countHeapSizes_);
85 } else if (context.eventType == FREE_EVENT) {
86 countHeapSizes_ -= context.memSize;
87 allMemSizes_.emplace_back(countHeapSizes_);
88 } else if (context.eventType == MMAP_EVENT) {
89 countMmapSizes_ += context.memSize;
90 allMemSizes_.emplace_back(countMmapSizes_);
91 } else if (context.eventType == MUNMAP_EVENT) {
92 countMmapSizes_ -= context.memSize;
93 allMemSizes_.emplace_back(countMmapSizes_);
94 }
95 currentSizeDurs_.emplace_back(0);
96 return Size() - 1;
97 }
UpdateCallChainId(size_t row,uint32_t callChainId)98 void NativeHook::UpdateCallChainId(size_t row, uint32_t callChainId)
99 {
100 if (row < Size()) {
101 callChainIds_[row] = callChainId;
102 } else {
103 TS_LOGE("Native hook update callChainId failed!!!");
104 }
105 }
UpdateEndTimeStampAndDuration(size_t row,uint64_t endTimeStamp)106 void NativeHook::UpdateEndTimeStampAndDuration(size_t row, uint64_t endTimeStamp)
107 {
108 endTimeStamps_[row] = endTimeStamp;
109 durations_[row] = endTimeStamp - timeStamps_[row];
110 }
UpdateCurrentSizeDur(size_t row,uint64_t timeStamp)111 void NativeHook::UpdateCurrentSizeDur(size_t row, uint64_t timeStamp)
112 {
113 currentSizeDurs_[row] = timeStamp - timeStamps_[row];
114 }
UpdateMemMapSubType(uint64_t row,uint64_t tagId)115 void NativeHook::UpdateMemMapSubType(uint64_t row, uint64_t tagId)
116 {
117 if (row < subTypes_.size()) {
118 subTypes_[row] = tagId;
119 } else {
120 TS_LOGE("subTypes_ row is invalid!");
121 }
122 }
EventTypes() const123 const std::deque<std::string> &NativeHook::EventTypes() const
124 {
125 return eventTypes_;
126 }
SubTypes() const127 const std::deque<DataIndex> &NativeHook::SubTypes() const
128 {
129 return subTypes_;
130 }
EndTimeStamps() const131 const std::deque<uint64_t> &NativeHook::EndTimeStamps() const
132 {
133 return endTimeStamps_;
134 }
Durations() const135 const std::deque<uint64_t> &NativeHook::Durations() const
136 {
137 return durations_;
138 }
Addrs() const139 const std::deque<uint64_t> &NativeHook::Addrs() const
140 {
141 return addrs_;
142 }
MemSizes() const143 const std::deque<int64_t> &NativeHook::MemSizes() const
144 {
145 return memSizes_;
146 }
AllMemSizes() const147 const std::deque<int64_t> &NativeHook::AllMemSizes() const
148 {
149 return allMemSizes_;
150 }
CurrentSizeDurs() const151 const std::deque<uint64_t> &NativeHook::CurrentSizeDurs() const
152 {
153 return currentSizeDurs_;
154 }
AppendNewNativeHookFrame(const NativeHookFrameVaddrRow & context)155 size_t NativeHookFrame::AppendNewNativeHookFrame(const NativeHookFrameVaddrRow &context)
156 {
157 callChainIds_.emplace_back(context.callChainId);
158 ips_.emplace_back(context.ip);
159 depths_.emplace_back(context.depth);
160 symbolNames_.emplace_back(context.symbolName);
161 filePaths_.emplace_back(context.filePath);
162 offsets_.emplace_back(context.offset);
163 symbolOffsets_.emplace_back(context.symbolOffset);
164 vaddrs_.emplace_back(context.vaddr);
165 return Size() - 1;
166 }
AppendNewNativeHookFrame(const NativeHookFrameRow & context)167 size_t NativeHookFrame::AppendNewNativeHookFrame(const NativeHookFrameRow &context)
168 {
169 callChainIds_.emplace_back(context.callChainId);
170 ips_.emplace_back(context.ip);
171 depths_.emplace_back(context.depth);
172 symbolNames_.emplace_back(context.symbolName);
173 filePaths_.emplace_back(context.filePath);
174 offsets_.emplace_back(context.offset);
175 symbolOffsets_.emplace_back(context.symbolOffset);
176 return Size() - 1;
177 }
UpdateSymbolIdToNameMap(uint64_t originSymbolId,uint64_t symbolId)178 void NativeHookFrame::UpdateSymbolIdToNameMap(uint64_t originSymbolId, uint64_t symbolId)
179 {
180 symbolIdToSymbolName_.insert(std::make_pair(originSymbolId, symbolId));
181 }
UpdateFrameInfo(size_t row,DataIndex symbolIndex,DataIndex filePathIndex,uint64_t offset,uint64_t symbolOffset)182 void NativeHookFrame::UpdateFrameInfo(size_t row,
183 DataIndex symbolIndex,
184 DataIndex filePathIndex,
185 uint64_t offset,
186 uint64_t symbolOffset)
187 {
188 if (row >= Size()) {
189 TS_LOGE("The updated row does not exist!");
190 return;
191 }
192 symbolNames_[row] = symbolIndex;
193 filePaths_[row] = filePathIndex;
194 offsets_[row] = offset;
195 symbolOffsets_[row] = symbolOffset;
196 }
197
UpdateSymbolId()198 void NativeHookFrame::UpdateSymbolId()
199 {
200 if (symbolIdToSymbolName_.empty()) {
201 return;
202 }
203 for (auto i = 0; i < Size(); ++i) {
204 auto symbolIt = symbolIdToSymbolName_.find(symbolNames_[i]);
205 if (symbolIt != symbolIdToSymbolName_.end()) {
206 symbolNames_[i] = symbolIt->second;
207 }
208 }
209 }
UpdateSymbolId(size_t index,DataIndex symbolId)210 void NativeHookFrame::UpdateSymbolId(size_t index, DataIndex symbolId)
211 {
212 if (index < Size()) {
213 symbolNames_[index] = symbolId;
214 }
215 }
UpdateFileId(std::map<uint32_t,uint64_t> & filePathIdToFilePathName)216 void NativeHookFrame::UpdateFileId(std::map<uint32_t, uint64_t> &filePathIdToFilePathName)
217 {
218 if (filePathIdToFilePathName.empty()) {
219 return;
220 }
221 for (auto i = 0; i < Size(); ++i) {
222 auto symbolIt = filePathIdToFilePathName.find(filePaths_[i]);
223 if (symbolIt != filePathIdToFilePathName.end()) {
224 filePaths_[i] = symbolIt->second;
225 }
226 }
227 }
UpdateVaddrs(std::deque<std::string> & vaddrs)228 void NativeHookFrame::UpdateVaddrs(std::deque<std::string> &vaddrs)
229 {
230 vaddrs_.assign(vaddrs.begin(), vaddrs.end());
231 }
CallChainIds() const232 const std::deque<uint32_t> &NativeHookFrame::CallChainIds() const
233 {
234 return callChainIds_;
235 }
Depths() const236 const std::deque<uint16_t> &NativeHookFrame::Depths() const
237 {
238 return depths_;
239 }
Ips() const240 const std::deque<uint64_t> &NativeHookFrame::Ips() const
241 {
242 return ips_;
243 }
SymbolNames() const244 const std::deque<DataIndex> &NativeHookFrame::SymbolNames() const
245 {
246 return symbolNames_;
247 }
FilePaths() const248 const std::deque<DataIndex> &NativeHookFrame::FilePaths() const
249 {
250 return filePaths_;
251 }
Offsets() const252 const std::deque<uint64_t> &NativeHookFrame::Offsets() const
253 {
254 return offsets_;
255 }
SymbolOffsets() const256 const std::deque<uint64_t> &NativeHookFrame::SymbolOffsets() const
257 {
258 return symbolOffsets_;
259 }
Vaddrs() const260 const std::deque<std::string> &NativeHookFrame::Vaddrs() const
261 {
262 return vaddrs_;
263 }
264
AppendNewNativeHookStatistic(const NativeHookStatisticRow & nativeHookStatisticRow)265 size_t NativeHookStatistic::AppendNewNativeHookStatistic(const NativeHookStatisticRow &nativeHookStatisticRow)
266 {
267 AppendNativeHookSampleBase(nativeHookStatisticRow.callChainId, nativeHookStatisticRow.ipid,
268 nativeHookStatisticRow.timeStamp);
269 memoryTypes_.emplace_back(nativeHookStatisticRow.memoryType);
270 applyCounts_.emplace_back(nativeHookStatisticRow.applyCount);
271 memSubTypes_.emplace_back(nativeHookStatisticRow.subMemType);
272 releaseCounts_.emplace_back(nativeHookStatisticRow.releaseCount);
273 applySizes_.emplace_back(nativeHookStatisticRow.applySize);
274 releaseSizes_.emplace_back(nativeHookStatisticRow.releaseSize);
275 return Size() - 1;
276 }
277
MemoryTypes() const278 const std::deque<uint32_t> &NativeHookStatistic::MemoryTypes() const
279 {
280 return memoryTypes_;
281 }
MemorySubTypes() const282 const std::deque<DataIndex> &NativeHookStatistic::MemorySubTypes() const
283 {
284 return memSubTypes_;
285 }
ApplyCounts() const286 const std::deque<uint64_t> &NativeHookStatistic::ApplyCounts() const
287 {
288 return applyCounts_;
289 }
ReleaseCounts() const290 const std::deque<uint64_t> &NativeHookStatistic::ReleaseCounts() const
291 {
292 return releaseCounts_;
293 }
ApplySizes() const294 const std::deque<uint64_t> &NativeHookStatistic::ApplySizes() const
295 {
296 return applySizes_;
297 }
ReleaseSizes() const298 const std::deque<uint64_t> &NativeHookStatistic::ReleaseSizes() const
299 {
300 return releaseSizes_;
301 }
302 } // namespace TraceStdtype
303 } // namespace SysTuning
304