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 "render_service_stdtype.h"
16
17 namespace SysTuning {
18 namespace TraceStdtype {
AppendFrame(uint64_t ts,uint32_t ipid,uint32_t itid,uint32_t vsyncId,uint64_t callStackSliceId)19 size_t FrameSlice::AppendFrame(uint64_t ts, uint32_t ipid, uint32_t itid, uint32_t vsyncId, uint64_t callStackSliceId)
20 {
21 timeStamps_.emplace_back(ts);
22 ipids_.emplace_back(ipid);
23 internalTids_.emplace_back(itid);
24 vsyncIds_.emplace_back(vsyncId);
25 callStackIds_.emplace_back(callStackSliceId);
26 endTss_.emplace_back(INVALID_UINT64);
27 dsts_.emplace_back(INVALID_UINT64);
28 ids_.emplace_back(id_++);
29 durs_.emplace_back(INVALID_UINT64);
30 types_.emplace_back(0);
31 flags_.emplace_back(INVALID_UINT8);
32 srcs_.emplace_back("");
33 depths_.emplace_back(0);
34 frameNos_.emplace_back(0);
35 return Size() - 1;
36 }
AppendFrame(const FrameSliceRow & frameSliceRow)37 size_t FrameSlice::AppendFrame(const FrameSliceRow &frameSliceRow)
38 {
39 auto row = AppendFrame(frameSliceRow.ts, frameSliceRow.ipid, frameSliceRow.itid, frameSliceRow.vsyncId,
40 frameSliceRow.callStackSliceId);
41 SetEndTime(row, frameSliceRow.end);
42 SetType(row, frameSliceRow.type);
43 depths_.emplace_back(0);
44 frameNos_.emplace_back(0);
45 durs_[row] = frameSliceRow.end - frameSliceRow.ts;
46 return row;
47 }
48
UpdateDepth()49 void FrameSlice::UpdateDepth()
50 {
51 DoubleMap<uint32_t, uint8_t, std::shared_ptr<std::vector<uint64_t>>> ipidAndTypesToVEndTime(nullptr);
52 for (auto row = 0; row < Size(); row++) {
53 if (flags_[row] == flagValue_) {
54 continue;
55 }
56 auto endTime = timeStamps_[row] + durs_[row];
57 auto vEndTimes = ipidAndTypesToVEndTime.Find(ipids_[row], types_[row]);
58 auto depth = 0;
59 if (!vEndTimes) {
60 vEndTimes = std::make_shared<std::vector<uint64_t>>();
61 vEndTimes->push_back(endTime);
62 ipidAndTypesToVEndTime.Insert(ipids_[row], types_[row], vEndTimes);
63 depths_[row] = depth;
64 continue;
65 }
66 for (; depth < vEndTimes->size(); depth++) {
67 if (timeStamps_[row] > vEndTimes->at(depth)) {
68 depths_[row] = depth;
69 vEndTimes->at(depth) = endTime;
70 break;
71 }
72 }
73 if (depth == vEndTimes->size()) {
74 depths_[row] = depth;
75 vEndTimes->push_back(endTime);
76 }
77 }
78 }
79
SetEndTime(uint64_t row,uint64_t end)80 void FrameSlice::SetEndTime(uint64_t row, uint64_t end)
81 {
82 endTss_[row] = end;
83 }
SetType(uint64_t row,uint8_t type)84 void FrameSlice::SetType(uint64_t row, uint8_t type)
85 {
86 types_[row] = type;
87 }
SetDst(uint64_t row,uint64_t dst)88 void FrameSlice::SetDst(uint64_t row, uint64_t dst)
89 {
90 dsts_[row] = diskTableSize_ + dst;
91 }
92
SetSrcs(uint64_t row,const std::vector<uint64_t> & fromSlices)93 void FrameSlice::SetSrcs(uint64_t row, const std::vector<uint64_t> &fromSlices)
94 {
95 std::string s = "";
96 for (auto &&i : fromSlices) {
97 if (i != INVALID_UINT64) {
98 s += std::to_string(diskTableSize_ + i) + ",";
99 }
100 }
101 if (s.back() == ',') {
102 s.pop_back();
103 srcs_[row] = s;
104 }
105 }
SetFlags(uint64_t row,const uint32_t flags)106 void FrameSlice::SetFlags(uint64_t row, const uint32_t flags)
107 {
108 flags_[row] = flags;
109 }
SetVsync(uint64_t row,uint32_t vsync)110 void FrameSlice::SetVsync(uint64_t row, uint32_t vsync)
111 {
112 vsyncIds_[row] = vsync;
113 }
114
GetExpectEndByItidAndVsyncId(uint32_t mainThreadId,uint32_t vsyncId) const115 uint64_t FrameSlice::GetExpectEndByItidAndVsyncId(uint32_t mainThreadId, uint32_t vsyncId) const
116 {
117 auto row = Size();
118 while (row > 0) {
119 --row;
120 if (vsyncIds_[row] == vsyncId && internalTids_[row] == mainThreadId) {
121 return timeStamps_[row] + durs_[row];
122 }
123 }
124 return INVALID_UINT64;
125 }
Ipids() const126 const std::deque<uint32_t> FrameSlice::Ipids() const
127 {
128 return ipids_;
129 }
VsyncIds() const130 const std::deque<uint32_t> FrameSlice::VsyncIds() const
131 {
132 return vsyncIds_;
133 }
CallStackIds() const134 const std::deque<uint64_t> FrameSlice::CallStackIds() const
135 {
136 return callStackIds_;
137 }
EndTss() const138 const std::deque<uint64_t> FrameSlice::EndTss() const
139 {
140 return endTss_;
141 }
Dsts() const142 const std::deque<uint64_t> FrameSlice::Dsts() const
143 {
144 return dsts_;
145 }
Durs() const146 const std::deque<uint64_t> FrameSlice::Durs() const
147 {
148 return durs_;
149 }
Types() const150 const std::deque<uint8_t> FrameSlice::Types() const
151 {
152 return types_;
153 }
Flags() const154 const std::deque<uint8_t> FrameSlice::Flags() const
155 {
156 return flags_;
157 }
158
Depths() const159 const std::deque<uint8_t> FrameSlice::Depths() const
160 {
161 return depths_;
162 }
FrameNos() const163 const std::deque<uint32_t> FrameSlice::FrameNos() const
164 {
165 return frameNos_;
166 }
Srcs() const167 const std::deque<std::string> &FrameSlice::Srcs() const
168 {
169 return srcs_;
170 }
UpdateCallStackSliceId(uint64_t row,uint64_t callStackSliceId)171 void FrameSlice::UpdateCallStackSliceId(uint64_t row, uint64_t callStackSliceId)
172 {
173 callStackIds_[row] = callStackSliceId;
174 }
SetEndTimeAndFlag(uint64_t row,uint64_t ts,uint64_t expectEnd)175 void FrameSlice::SetEndTimeAndFlag(uint64_t row, uint64_t ts, uint64_t expectEnd)
176 {
177 durs_[row] = ts - timeStamps_[row];
178 if (flags_[row] != abnormalStartEndTimeState_) {
179 flags_[row] = expectEnd >= ts ? 0 : 1;
180 }
181 }
Erase(uint64_t row)182 void FrameSlice::Erase(uint64_t row)
183 {
184 flags_[row] = invalidRow_;
185 }
186
AppendNew(uint32_t frameRow,uint64_t dur)187 size_t GPUSlice::AppendNew(uint32_t frameRow, uint64_t dur)
188 {
189 ids_.emplace_back(id_++);
190 frameRows_.emplace_back(frameRow);
191 durs_.emplace_back(dur);
192 return Size() - 1;
193 }
FrameRows() const194 const std::deque<uint32_t> &GPUSlice::FrameRows() const
195 {
196 return frameRows_;
197 }
Durs() const198 const std::deque<uint64_t> &GPUSlice::Durs() const
199 {
200 return durs_;
201 }
AppendNew(const DmaFenceRow & dmaFenceRow)202 size_t DmaFence::AppendNew(const DmaFenceRow &dmaFenceRow)
203 {
204 timeStamps_.emplace_back(dmaFenceRow.timeStamp);
205 durs_.emplace_back(dmaFenceRow.duration);
206 cats_.emplace_back(dmaFenceRow.eventName);
207 drivers_.emplace_back(dmaFenceRow.driver);
208 timelines_.emplace_back(dmaFenceRow.timeline);
209 contexts_.emplace_back(dmaFenceRow.context);
210 seqnos_.emplace_back(dmaFenceRow.seqno);
211 return Size() - 1;
212 }
213
DursData() const214 const std::deque<uint64_t> &DmaFence::DursData() const
215 {
216 return durs_;
217 }
218
CatsData() const219 const std::deque<DataIndex> &DmaFence::CatsData() const
220 {
221 return cats_;
222 }
223
DriversData() const224 const std::deque<DataIndex> &DmaFence::DriversData() const
225 {
226 return drivers_;
227 }
228
TimelinesData() const229 const std::deque<DataIndex> &DmaFence::TimelinesData() const
230 {
231 return timelines_;
232 }
233
ContextsData() const234 const std::deque<uint32_t> &DmaFence::ContextsData() const
235 {
236 return contexts_;
237 }
238
SeqnosData() const239 const std::deque<uint32_t> &DmaFence::SeqnosData() const
240 {
241 return seqnos_;
242 }
243
AppendNew(FrameSlice * frameSlice,uint64_t src,uint64_t dst)244 size_t FrameMaps::AppendNew(FrameSlice *frameSlice, uint64_t src, uint64_t dst)
245 {
246 timeStamps_.emplace_back(0);
247 ids_.emplace_back(id_++);
248 srcs_.emplace_back(frameSlice->diskTableSize_ + src);
249 dsts_.emplace_back(frameSlice->diskTableSize_ + dst);
250 if (frameSlice->Types().at(dst) == FrameSlice::EXPECT_SLICE) {
251 uint64_t expRsStartTime = frameSlice->TimeStampData().at(dst);
252 uint64_t expUiEndTime = frameSlice->TimeStampData().at(src) + frameSlice->Durs().at(src);
253 if (std::abs(static_cast<long long>(expRsStartTime - expUiEndTime)) >= ONE_MILLION_NANOSECONDS) {
254 auto acturalRow = dst - 1;
255 frameSlice->SetFlags(acturalRow, FrameSlice::GetAbnormalStartEndTimeState());
256 }
257 }
258
259 return Size() - 1;
260 }
SrcIndexs() const261 const std::deque<uint64_t> &FrameMaps::SrcIndexs() const
262 {
263 return srcs_;
264 }
DstIndexs() const265 const std::deque<uint64_t> &FrameMaps::DstIndexs() const
266 {
267 return dsts_;
268 }
269
270 } // namespace TraceStdtype
271 } // namespace SysTuning
272