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 16 #ifndef MEASURE_STDTYPE_H 17 #define MEASURE_STDTYPE_H 18 #include "base_stdtype.h" 19 20 namespace SysTuning { 21 namespace TraceStdtype { 22 class Filter : public CacheBase, public BatchCacheBase { 23 public: 24 size_t AppendNewFilterData(std::string type, std::string name, uint64_t sourceArgSetId); NameData()25 const std::deque<std::string> &NameData() const 26 { 27 return nameDeque_; 28 } TypeData()29 const std::deque<std::string> &TypeData() const 30 { 31 return typeDeque_; 32 } SourceArgSetIdData()33 const std::deque<uint64_t> &SourceArgSetIdData() const 34 { 35 return sourceArgSetId_; 36 } Clear()37 void Clear() override 38 { 39 CacheBase::Clear(); 40 nameDeque_.clear(); 41 typeDeque_.clear(); 42 sourceArgSetId_.clear(); 43 } ClearExportedData()44 void ClearExportedData() override 45 { 46 EraseElements(ids_, nameDeque_, typeDeque_, sourceArgSetId_); 47 } 48 49 private: 50 std::deque<std::string> nameDeque_ = {}; 51 std::deque<std::string> typeDeque_ = {}; 52 std::deque<uint64_t> sourceArgSetId_ = {}; 53 }; 54 55 class Measure : public CacheBase, public BatchCacheBase { 56 public: 57 size_t AppendMeasureData(uint32_t type, uint64_t timeStamp, int64_t value, uint32_t filterId); TypeData()58 const std::deque<uint32_t> &TypeData() const 59 { 60 return typeDeque_; 61 } ValuesData()62 const std::deque<int64_t> &ValuesData() const 63 { 64 return valuesDeque_; 65 } DursData()66 const std::deque<uint64_t> &DursData() const 67 { 68 return durDeque_; 69 } 70 void SetDur(uint32_t row, uint64_t timeStamp); FilterIdData()71 const std::deque<uint32_t> &FilterIdData() const 72 { 73 return filterIdDeque_; 74 } Clear()75 void Clear() override 76 { 77 CacheBase::Clear(); 78 typeDeque_.clear(); 79 durDeque_.clear(); 80 valuesDeque_.clear(); 81 filterIdDeque_.clear(); 82 } UpdateReadySize(size_t size)83 void UpdateReadySize(size_t size) override 84 { 85 UpdatePrevSizeAndAdapterRows(size); 86 } ClearExportedData()87 void ClearExportedData() override 88 { 89 EraseElements(timeStamps_, typeDeque_, durDeque_, valuesDeque_, filterIdDeque_); 90 } GetFilterIdToRow()91 std::map<uint32_t, uint32_t> *GetFilterIdToRow() 92 { 93 return &filterIdToRow_; 94 } ClearRowMap()95 void ClearRowMap() 96 { 97 filterIdToRow_.clear(); 98 } 99 100 private: 101 void UpdatePrevSizeAndAdapterRows(size_t size); 102 std::deque<uint32_t> typeDeque_ = {}; 103 std::deque<uint64_t> durDeque_ = {}; 104 std::deque<int64_t> valuesDeque_ = {}; 105 std::deque<uint32_t> filterIdDeque_ = {}; 106 std::map<uint32_t, uint32_t> filterIdToRow_ = {}; 107 }; 108 109 class SysMeasureFilter : public CacheBase { 110 public: 111 size_t AppendNewFilter(uint64_t filterId, DataIndex type, DataIndex nameId); 112 const std::deque<DataIndex> &NamesData() const; 113 const std::deque<DataIndex> &TypesData() const; Clear()114 void Clear() override 115 { 116 CacheBase::Clear(); 117 types_.clear(); 118 names_.clear(); 119 } 120 121 private: 122 std::deque<DataIndex> types_ = {}; 123 std::deque<DataIndex> names_ = {}; 124 }; 125 126 class CpuMeasureFilter : public CacheBase, public BatchCacheBase { 127 public: AppendNewFilter(uint64_t filterId,DataIndex name,uint32_t cpu)128 inline size_t AppendNewFilter(uint64_t filterId, DataIndex name, uint32_t cpu) 129 { 130 ids_.emplace_back(filterId); 131 cpu_.emplace_back(cpu); 132 name_.emplace_back(name); 133 return Size() - 1; 134 } 135 CpuData()136 const std::deque<uint32_t> &CpuData() const 137 { 138 return cpu_; 139 } 140 NameData()141 const std::deque<DataIndex> &NameData() const 142 { 143 return name_; 144 } Clear()145 void Clear() override 146 { 147 CacheBase::Clear(); 148 cpu_.clear(); 149 name_.clear(); 150 } ClearExportedData()151 void ClearExportedData() override 152 { 153 EraseElements(ids_, cpu_, name_); 154 } 155 156 private: 157 std::deque<uint32_t> cpu_ = {}; 158 std::deque<DataIndex> name_ = {}; 159 }; 160 161 class ProcessMeasureFilter : public CacheBase, public BatchCacheBase { 162 public: 163 size_t AppendNewFilter(uint64_t id, DataIndex name, uint32_t internalPid); 164 UpidsData()165 const std::deque<uint32_t> &UpidsData() const 166 { 167 return internalPids_; 168 } 169 NamesData()170 const std::deque<DataIndex> &NamesData() const 171 { 172 return names_; 173 } Clear()174 void Clear() override 175 { 176 CacheBase::Clear(); 177 internalPids_.clear(); 178 names_.clear(); 179 } ClearExportedData()180 void ClearExportedData() override 181 { 182 EraseElements(ids_, internalPids_, names_); 183 } 184 185 private: 186 std::deque<uint32_t> internalPids_ = {}; 187 std::deque<DataIndex> names_ = {}; 188 }; 189 190 class ClockEventData : public CacheBase, public BatchCacheBase { 191 public: 192 size_t AppendNewFilter(uint64_t id, DataIndex type, DataIndex name, uint64_t cpu); 193 CpusData()194 const std::deque<uint64_t> &CpusData() const 195 { 196 return cpus_; 197 } 198 NamesData()199 const std::deque<DataIndex> &NamesData() const 200 { 201 return names_; 202 } TypesData()203 const std::deque<DataIndex> &TypesData() const 204 { 205 return types_; 206 } Clear()207 void Clear() override 208 { 209 CacheBase::Clear(); 210 cpus_.clear(); 211 names_.clear(); 212 types_.clear(); 213 } ClearExportedData()214 void ClearExportedData() override 215 { 216 EraseElements(ids_, cpus_, names_, types_); 217 } 218 219 private: 220 std::deque<uint64_t> cpus_ = {}; // in clock_set_rate event, it save cpu 221 std::deque<DataIndex> names_ = {}; 222 std::deque<DataIndex> types_ = {}; 223 }; 224 225 class ClkEventData : public CacheBase, public BatchCacheBase { 226 public: 227 size_t AppendNewFilter(uint64_t id, uint64_t rate, DataIndex name, uint64_t cpu); 228 NamesData()229 const std::deque<DataIndex> &NamesData() const 230 { 231 return names_; 232 } RatesData()233 const std::deque<uint64_t> &RatesData() const 234 { 235 return rates_; 236 } CpusData()237 const std::deque<uint64_t> &CpusData() const 238 { 239 return cpus_; 240 } Clear()241 void Clear() override 242 { 243 CacheBase::Clear(); 244 names_.clear(); 245 rates_.clear(); 246 cpus_.clear(); 247 } ClearExportedData()248 void ClearExportedData() override 249 { 250 EraseElements(ids_, cpus_, names_, rates_); 251 } 252 253 private: 254 std::deque<DataIndex> names_; 255 std::deque<uint64_t> rates_; 256 std::deque<uint64_t> cpus_; 257 }; 258 } // namespace TraceStdtype 259 } // namespace SysTuning 260 #endif // MEASURE_STDTYPE_H 261