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 #ifndef SCHED_STDTYPE_H 17 #define SCHED_STDTYPE_H 18 #include "base_stdtype.h" 19 20 namespace SysTuning { 21 namespace TraceStdtype { 22 class ThreadStateData : public BatchCacheBase { 23 public: 24 TableRowId 25 AppendThreadState(InternalTime ts, InternalTime dur, InternalCpu cpu, InternalTid itid, TableRowId idState); 26 void SetDuration(TableRowId index, InternalTime dur); 27 TableRowId UpdateDuration(TableRowId index, InternalTime ts); 28 bool End(TableRowId index, InternalTime ts); 29 void UpdateState(TableRowId index, TableRowId idState); 30 void SetArgSetId(TableRowId index, uint32_t setId); 31 void UpdateDuration(TableRowId index, InternalTime ts, TableRowId idState); 32 void UpdateTidAndPid(TableRowId index, InternalTid tid, InternalTid pid); 33 TableRowId UpdateDuration(TableRowId index, InternalTime ts, InternalCpu cpu, TableRowId idState); 34 void SortAllRowByTs(); Clear()35 void Clear() 36 { 37 timeStamps_.clear(); 38 durations_.clear(); 39 itids_.clear(); 40 tids_.clear(); 41 pids_.clear(); 42 states_.clear(); 43 cpus_.clear(); 44 } ClearExportedData()45 void ClearExportedData() override 46 { 47 EraseElements(timeStamps_, durations_, itids_, tids_, pids_, states_, cpus_); 48 } Size()49 uint32_t Size() const 50 { 51 return itids_.size(); 52 } 53 TimeStamsData()54 const std::deque<InternalTime>& TimeStamsData() const 55 { 56 return timeStamps_; 57 } DursData()58 const std::deque<InternalTime>& DursData() const 59 { 60 return durations_; 61 } ItidsData()62 const std::deque<InternalTid>& ItidsData() const 63 { 64 return itids_; 65 } TidsData()66 const std::deque<InternalTid>& TidsData() const 67 { 68 return tids_; 69 } PidsData()70 const std::deque<InternalPid>& PidsData() const 71 { 72 return pids_; 73 } StatesData()74 const std::deque<DataIndex>& StatesData() const 75 { 76 return states_; 77 } CpusData()78 const std::deque<InternalCpu>& CpusData() const 79 { 80 return cpus_; 81 } ArgSetsData()82 const std::deque<uint32_t>& ArgSetsData() const 83 { 84 return argSetIds_; 85 } 86 87 private: 88 std::deque<InternalTime> timeStamps_; 89 std::deque<InternalTime> durations_; 90 std::deque<InternalTid> itids_; 91 std::deque<InternalTid> tids_; 92 std::deque<InternalPid> pids_; 93 std::deque<DataIndex> states_; 94 std::deque<InternalCpu> cpus_; 95 std::deque<uint32_t> argSetIds_; 96 }; 97 98 class SchedSlice : public CacheBase, public CpuCacheBase, public BatchCacheBase { 99 public: 100 size_t AppendSchedSlice(uint64_t ts, 101 uint64_t dur, 102 uint64_t cpu, 103 uint32_t internalTid, 104 uint64_t endState, 105 uint64_t priority); 106 void SetDuration(size_t index, uint64_t duration); 107 void Update(uint64_t index, uint64_t ts, uint64_t state); 108 void UpdateEndState(uint64_t index, uint64_t state); 109 void UpdateArg(uint64_t index, uint32_t argsetId); 110 EndStatesData()111 const std::deque<uint64_t>& EndStatesData() const 112 { 113 return endStates_; 114 } 115 PriorityData()116 const std::deque<uint64_t>& PriorityData() const 117 { 118 return priority_; 119 } 120 ArgSetData()121 const std::deque<uint32_t>& ArgSetData() const 122 { 123 return argSets_; 124 } TsEndData()125 const std::deque<uint64_t>& TsEndData() const 126 { 127 return tsEnds_; 128 } InternalPidsData()129 const std::deque<InternalPid>& InternalPidsData() const 130 { 131 return internalPids_; 132 } ReviseInternalPid(uint32_t row,InternalPid ipid)133 void ReviseInternalPid(uint32_t row, InternalPid ipid) 134 { 135 if (row < internalPids_.size()) { 136 internalPids_[row] = ipid; 137 } 138 } Clear()139 void Clear() override 140 { 141 CacheBase::Clear(); 142 CpuCacheBase::Clear(); 143 endStates_.clear(); 144 priority_.clear(); 145 internalPids_.clear(); 146 tsEnds_.clear(); 147 } ClearExportedData()148 void ClearExportedData() override 149 { 150 EraseElements(internalTids_, timeStamps_, durs_, cpus_, endStates_, priority_, internalPids_, tsEnds_); 151 } 152 153 private: 154 std::deque<InternalPid> internalPids_ = {}; 155 std::deque<uint64_t> tsEnds_ = {}; 156 std::deque<uint64_t> endStates_ = {}; 157 std::deque<uint64_t> priority_ = {}; 158 std::deque<uint32_t> argSets_ = {}; 159 }; 160 class Raw : public CacheBase, public BatchCacheBase { 161 public: 162 size_t AppendRawData(uint64_t timeStamp, uint32_t name, uint32_t cpu, uint32_t internalTid); NameData()163 const std::deque<uint32_t>& NameData() const 164 { 165 return nameDeque_; 166 } CpuData()167 const std::deque<uint32_t>& CpuData() const 168 { 169 return cpuDeque_; 170 } Clear()171 void Clear() override 172 { 173 CacheBase::Clear(); 174 nameDeque_.clear(); 175 cpuDeque_.clear(); 176 } ClearExportedData()177 void ClearExportedData() override 178 { 179 EraseElements(internalTids_, timeStamps_, ids_, nameDeque_, cpuDeque_); 180 } 181 182 private: 183 std::deque<uint32_t> nameDeque_ = {}; 184 std::deque<uint32_t> cpuDeque_ = {}; 185 }; 186 187 class Instants : public CacheBase, public BatchCacheBase { 188 public: 189 size_t AppendInstantEventData(uint64_t timeStamp, 190 DataIndex nameIndex, 191 int64_t internalTid, 192 int64_t wakeupFromInternalPid); 193 NameIndexsData()194 const std::deque<DataIndex>& NameIndexsData() const 195 { 196 return NameIndexs_; 197 } WakeupFromPidsData()198 const std::deque<int64_t>& WakeupFromPidsData() const 199 { 200 return wakeupFromInternalPids_; 201 } Clear()202 void Clear() override 203 { 204 CacheBase::Clear(); 205 NameIndexs_.clear(); 206 wakeupFromInternalPids_.clear(); 207 } ClearExportedData()208 void ClearExportedData() override 209 { 210 EraseElements(internalTids_, timeStamps_, NameIndexs_, wakeupFromInternalPids_); 211 } 212 213 private: 214 std::deque<DataIndex> NameIndexs_; 215 std::deque<int64_t> wakeupFromInternalPids_; 216 }; 217 } // namespace TraceStdtype 218 } // namespace SysTuning 219 220 #endif // SCHED_STDTYPE_H 221