1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
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
16 #include "trace_data_cache_writer.h"
17 #include <array>
18 #include <deque>
19 #include <limits>
20 #include <map>
21 #include <optional>
22 #include <stdexcept>
23 #include <string>
24 #include <unordered_map>
25 #include <vector>
26 #include "log.h"
27 namespace SysTuning {
28 namespace TraceStreamer {
29 using namespace TraceStdtype;
~TraceDataCacheWriter()30 TraceDataCacheWriter::~TraceDataCacheWriter() {}
GetProcessInternalPid(uint32_t pid)31 InternalPid TraceDataCacheWriter::GetProcessInternalPid(uint32_t pid)
32 {
33 internalProcessesData_.emplace_back(pid);
34 return static_cast<InternalPid>(internalProcessesData_.size() - 1);
35 }
GetProcessData(InternalPid internalPid)36 Process* TraceDataCacheWriter::GetProcessData(InternalPid internalPid)
37 {
38 TS_ASSERT(internalPid < internalProcessesData_.size());
39 return &internalProcessesData_[internalPid];
40 }
41
NewInternalThread(uint32_t tid)42 InternalTid TraceDataCacheWriter::NewInternalThread(uint32_t tid)
43 {
44 internalThreadsData_.emplace_back(tid);
45 return static_cast<InternalTid>(internalThreadsData_.size() - 1);
46 }
GetThreadData(InternalTid internalTid)47 Thread* TraceDataCacheWriter::GetThreadData(InternalTid internalTid)
48 {
49 if (internalTid >= internalThreadsData_.size()) {
50 return nullptr;
51 }
52 return &internalThreadsData_[internalTid];
53 }
54
UpdateTraceTime(uint64_t timestamp)55 void TraceDataCacheWriter::UpdateTraceTime(uint64_t timestamp)
56 {
57 traceStartTime_ = std::min(traceStartTime_, timestamp);
58 traceEndTime_ = std::max(traceEndTime_, timestamp);
59 }
60
MixTraceTime(uint64_t timestampMin,uint64_t timestampMax)61 void TraceDataCacheWriter::MixTraceTime(uint64_t timestampMin, uint64_t timestampMax)
62 {
63 if (timestampMin == std::numeric_limits<uint64_t>::max() || timestampMax == 0) {
64 return;
65 }
66 if (traceStartTime_ != std::numeric_limits<uint64_t>::max()) {
67 traceStartTime_ = std::max(traceStartTime_, timestampMin);
68 } else {
69 traceStartTime_ = timestampMin;
70 }
71 if (traceEndTime_) {
72 traceEndTime_ = std::min(traceEndTime_, timestampMax);
73 } else {
74 traceEndTime_ = timestampMax;
75 }
76 }
GetInternalSlicesData()77 CallStack* TraceDataCacheWriter::GetInternalSlicesData()
78 {
79 return &internalSlicesData_;
80 }
81
GetFilterData()82 Filter* TraceDataCacheWriter::GetFilterData()
83 {
84 return &filterData_;
85 }
86
GetRawData()87 Raw* TraceDataCacheWriter::GetRawData()
88 {
89 return &rawData_;
90 }
91
GetMeasureData()92 Measure* TraceDataCacheWriter::GetMeasureData()
93 {
94 return &measureData_;
95 }
96
GetThreadStateData()97 ThreadState* TraceDataCacheWriter::GetThreadStateData()
98 {
99 return &threadStateData_;
100 }
101
GetSchedSliceData()102 SchedSlice* TraceDataCacheWriter::GetSchedSliceData()
103 {
104 return &schedSliceData_;
105 }
106
GetCpuMeasuresData()107 CpuMeasureFilter* TraceDataCacheWriter::GetCpuMeasuresData()
108 {
109 return &cpuMeasureData_;
110 }
111
GetThreadMeasureFilterData()112 ThreadMeasureFilter* TraceDataCacheWriter::GetThreadMeasureFilterData()
113 {
114 return &threadMeasureFilterData_;
115 }
116
GetThreadFilterData()117 ThreadMeasureFilter* TraceDataCacheWriter::GetThreadFilterData()
118 {
119 return &threadFilterData_;
120 }
121
GetInstantsData()122 Instants* TraceDataCacheWriter::GetInstantsData()
123 {
124 return &instantsData_;
125 }
126
GetProcessFilterData()127 ProcessMeasureFilter* TraceDataCacheWriter::GetProcessFilterData()
128 {
129 return &processFilterData_;
130 }
131
GetProcessMeasureFilterData()132 ProcessMeasureFilter* TraceDataCacheWriter::GetProcessMeasureFilterData()
133 {
134 return &processMeasureFilterData_;
135 }
136
GetClockEventFilterData()137 ClockEventData* TraceDataCacheWriter::GetClockEventFilterData()
138 {
139 return &clockEventFilterData_;
140 }
141
GetClkEventFilterData()142 ClkEventData* TraceDataCacheWriter::GetClkEventFilterData()
143 {
144 return &clkEventFilterData_;
145 }
GetStatAndInfo()146 StatAndInfo* TraceDataCacheWriter::GetStatAndInfo()
147 {
148 return &stat_;
149 }
150
GetMetaData()151 MetaData* TraceDataCacheWriter::GetMetaData()
152 {
153 return &metaData_;
154 }
155
GetSymbolsData()156 SymbolsData* TraceDataCacheWriter::GetSymbolsData()
157 {
158 return &symbolsData_;
159 }
GetSysCallData()160 SysCall* TraceDataCacheWriter::GetSysCallData()
161 {
162 return &sysCallData_;
163 }
GetHilogData()164 LogInfo* TraceDataCacheWriter::GetHilogData()
165 {
166 return &hilogData_;
167 }
GetArgSetData()168 ArgSet* TraceDataCacheWriter::GetArgSetData()
169 {
170 return &argSet_;
171 }
172
GetDataTypeData()173 DataType* TraceDataCacheWriter::GetDataTypeData()
174 {
175 return &dataType_;
176 }
177
GetSysMeasureFilterData()178 SysMeasureFilter* TraceDataCacheWriter::GetSysMeasureFilterData()
179 {
180 return &sysEvent_;
181 }
182 } // namespace TraceStreamer
183 } // namespace SysTuning
184