1 #ifndef SRC_TRACE_PROCESSOR_TABLES_SCHED_TABLES_PY_H_ 2 #define SRC_TRACE_PROCESSOR_TABLES_SCHED_TABLES_PY_H_ 3 4 #include <array> 5 #include <cstddef> 6 #include <cstdint> 7 #include <memory> 8 #include <optional> 9 #include <type_traits> 10 #include <utility> 11 #include <vector> 12 13 #include "perfetto/base/logging.h" 14 #include "perfetto/trace_processor/basic_types.h" 15 #include "perfetto/trace_processor/ref_counted.h" 16 #include "src/trace_processor/containers/bit_vector.h" 17 #include "src/trace_processor/containers/row_map.h" 18 #include "src/trace_processor/containers/string_pool.h" 19 #include "src/trace_processor/db/column/arrangement_overlay.h" 20 #include "src/trace_processor/db/column/data_layer.h" 21 #include "src/trace_processor/db/column/dense_null_overlay.h" 22 #include "src/trace_processor/db/column/numeric_storage.h" 23 #include "src/trace_processor/db/column/id_storage.h" 24 #include "src/trace_processor/db/column/null_overlay.h" 25 #include "src/trace_processor/db/column/range_overlay.h" 26 #include "src/trace_processor/db/column/selector_overlay.h" 27 #include "src/trace_processor/db/column/set_id_storage.h" 28 #include "src/trace_processor/db/column/string_storage.h" 29 #include "src/trace_processor/db/column/types.h" 30 #include "src/trace_processor/db/column_storage.h" 31 #include "src/trace_processor/db/column.h" 32 #include "src/trace_processor/db/table.h" 33 #include "src/trace_processor/db/typed_column.h" 34 #include "src/trace_processor/db/typed_column_internal.h" 35 #include "src/trace_processor/tables/macros_internal.h" 36 37 #include "src/trace_processor/tables/metadata_tables_py.h" 38 39 namespace perfetto::trace_processor::tables { 40 41 class SchedSliceTable : public macros_internal::MacroTable { 42 public: 43 static constexpr uint32_t kColumnCount = 8; 44 45 struct Id : public BaseId { 46 Id() = default; IdId47 explicit constexpr Id(uint32_t v) : BaseId(v) {} 48 }; 49 static_assert(std::is_trivially_destructible_v<Id>, 50 "Inheritance used without trivial destruction"); 51 52 struct ColumnIndex { 53 static constexpr uint32_t id = 0; 54 static constexpr uint32_t type = 1; 55 static constexpr uint32_t ts = 2; 56 static constexpr uint32_t dur = 3; 57 static constexpr uint32_t utid = 4; 58 static constexpr uint32_t end_state = 5; 59 static constexpr uint32_t priority = 6; 60 static constexpr uint32_t ucpu = 7; 61 }; 62 struct ColumnType { 63 using id = IdColumn<SchedSliceTable::Id>; 64 using type = TypedColumn<StringPool::Id>; 65 using ts = TypedColumn<int64_t>; 66 using dur = TypedColumn<int64_t>; 67 using utid = TypedColumn<uint32_t>; 68 using end_state = TypedColumn<StringPool::Id>; 69 using priority = TypedColumn<int32_t>; 70 using ucpu = TypedColumn<CpuTable::Id>; 71 }; 72 struct Row : public macros_internal::RootParentTable::Row { 73 Row(int64_t in_ts = {}, 74 int64_t in_dur = {}, 75 uint32_t in_utid = {}, 76 StringPool::Id in_end_state = {}, 77 int32_t in_priority = {}, 78 CpuTable::Id in_ucpu = {}, 79 std::nullptr_t = nullptr) RowRow80 : macros_internal::RootParentTable::Row(), 81 ts(in_ts), 82 dur(in_dur), 83 utid(in_utid), 84 end_state(in_end_state), 85 priority(in_priority), 86 ucpu(in_ucpu) { 87 type_ = "__intrinsic_sched_slice"; 88 } 89 int64_t ts; 90 int64_t dur; 91 uint32_t utid; 92 StringPool::Id end_state; 93 int32_t priority; 94 CpuTable::Id ucpu; 95 96 bool operator==(const SchedSliceTable::Row& other) const { 97 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 98 ColumnType::dur::Equals(dur, other.dur) && 99 ColumnType::utid::Equals(utid, other.utid) && 100 ColumnType::end_state::Equals(end_state, other.end_state) && 101 ColumnType::priority::Equals(priority, other.priority) && 102 ColumnType::ucpu::Equals(ucpu, other.ucpu); 103 } 104 }; 105 struct ColumnFlag { 106 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 107 static constexpr uint32_t dur = ColumnType::dur::default_flags(); 108 static constexpr uint32_t utid = ColumnType::utid::default_flags(); 109 static constexpr uint32_t end_state = ColumnType::end_state::default_flags(); 110 static constexpr uint32_t priority = ColumnType::priority::default_flags(); 111 static constexpr uint32_t ucpu = ColumnType::ucpu::default_flags(); 112 }; 113 114 class RowNumber; 115 class ConstRowReference; 116 class RowReference; 117 118 class RowNumber : public macros_internal::AbstractRowNumber< 119 SchedSliceTable, ConstRowReference, RowReference> { 120 public: RowNumber(uint32_t row_number)121 explicit RowNumber(uint32_t row_number) 122 : AbstractRowNumber(row_number) {} 123 }; 124 static_assert(std::is_trivially_destructible_v<RowNumber>, 125 "Inheritance used without trivial destruction"); 126 127 class ConstRowReference : public macros_internal::AbstractConstRowReference< 128 SchedSliceTable, RowNumber> { 129 public: ConstRowReference(const SchedSliceTable * table,uint32_t row_number)130 ConstRowReference(const SchedSliceTable* table, uint32_t row_number) 131 : AbstractConstRowReference(table, row_number) {} 132 id()133 ColumnType::id::type id() const { 134 return table()->id()[row_number_]; 135 } type()136 ColumnType::type::type type() const { 137 return table()->type()[row_number_]; 138 } ts()139 ColumnType::ts::type ts() const { 140 return table()->ts()[row_number_]; 141 } dur()142 ColumnType::dur::type dur() const { 143 return table()->dur()[row_number_]; 144 } utid()145 ColumnType::utid::type utid() const { 146 return table()->utid()[row_number_]; 147 } end_state()148 ColumnType::end_state::type end_state() const { 149 return table()->end_state()[row_number_]; 150 } priority()151 ColumnType::priority::type priority() const { 152 return table()->priority()[row_number_]; 153 } ucpu()154 ColumnType::ucpu::type ucpu() const { 155 return table()->ucpu()[row_number_]; 156 } 157 }; 158 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 159 "Inheritance used without trivial destruction"); 160 class RowReference : public ConstRowReference { 161 public: RowReference(const SchedSliceTable * table,uint32_t row_number)162 RowReference(const SchedSliceTable* table, uint32_t row_number) 163 : ConstRowReference(table, row_number) {} 164 set_ts(ColumnType::ts::non_optional_type v)165 void set_ts( 166 ColumnType::ts::non_optional_type v) { 167 return mutable_table()->mutable_ts()->Set(row_number_, v); 168 } set_dur(ColumnType::dur::non_optional_type v)169 void set_dur( 170 ColumnType::dur::non_optional_type v) { 171 return mutable_table()->mutable_dur()->Set(row_number_, v); 172 } set_utid(ColumnType::utid::non_optional_type v)173 void set_utid( 174 ColumnType::utid::non_optional_type v) { 175 return mutable_table()->mutable_utid()->Set(row_number_, v); 176 } set_end_state(ColumnType::end_state::non_optional_type v)177 void set_end_state( 178 ColumnType::end_state::non_optional_type v) { 179 return mutable_table()->mutable_end_state()->Set(row_number_, v); 180 } set_priority(ColumnType::priority::non_optional_type v)181 void set_priority( 182 ColumnType::priority::non_optional_type v) { 183 return mutable_table()->mutable_priority()->Set(row_number_, v); 184 } set_ucpu(ColumnType::ucpu::non_optional_type v)185 void set_ucpu( 186 ColumnType::ucpu::non_optional_type v) { 187 return mutable_table()->mutable_ucpu()->Set(row_number_, v); 188 } 189 190 private: mutable_table()191 SchedSliceTable* mutable_table() const { 192 return const_cast<SchedSliceTable*>(table()); 193 } 194 }; 195 static_assert(std::is_trivially_destructible_v<RowReference>, 196 "Inheritance used without trivial destruction"); 197 198 class ConstIterator; 199 class ConstIterator : public macros_internal::AbstractConstIterator< 200 ConstIterator, SchedSliceTable, RowNumber, ConstRowReference> { 201 public: id()202 ColumnType::id::type id() const { 203 const auto& col = table()->id(); 204 return col.GetAtIdx( 205 iterator_.StorageIndexForColumn(col.index_in_table())); 206 } type()207 ColumnType::type::type type() const { 208 const auto& col = table()->type(); 209 return col.GetAtIdx( 210 iterator_.StorageIndexForColumn(col.index_in_table())); 211 } ts()212 ColumnType::ts::type ts() const { 213 const auto& col = table()->ts(); 214 return col.GetAtIdx( 215 iterator_.StorageIndexForColumn(col.index_in_table())); 216 } dur()217 ColumnType::dur::type dur() const { 218 const auto& col = table()->dur(); 219 return col.GetAtIdx( 220 iterator_.StorageIndexForColumn(col.index_in_table())); 221 } utid()222 ColumnType::utid::type utid() const { 223 const auto& col = table()->utid(); 224 return col.GetAtIdx( 225 iterator_.StorageIndexForColumn(col.index_in_table())); 226 } end_state()227 ColumnType::end_state::type end_state() const { 228 const auto& col = table()->end_state(); 229 return col.GetAtIdx( 230 iterator_.StorageIndexForColumn(col.index_in_table())); 231 } priority()232 ColumnType::priority::type priority() const { 233 const auto& col = table()->priority(); 234 return col.GetAtIdx( 235 iterator_.StorageIndexForColumn(col.index_in_table())); 236 } ucpu()237 ColumnType::ucpu::type ucpu() const { 238 const auto& col = table()->ucpu(); 239 return col.GetAtIdx( 240 iterator_.StorageIndexForColumn(col.index_in_table())); 241 } 242 243 protected: ConstIterator(const SchedSliceTable * table,Table::Iterator iterator)244 explicit ConstIterator(const SchedSliceTable* table, 245 Table::Iterator iterator) 246 : AbstractConstIterator(table, std::move(iterator)) {} 247 CurrentRowNumber()248 uint32_t CurrentRowNumber() const { 249 return iterator_.StorageIndexForLastOverlay(); 250 } 251 252 private: 253 friend class SchedSliceTable; 254 friend class macros_internal::AbstractConstIterator< 255 ConstIterator, SchedSliceTable, RowNumber, ConstRowReference>; 256 }; 257 class Iterator : public ConstIterator { 258 public: row_reference()259 RowReference row_reference() const { 260 return {const_cast<SchedSliceTable*>(table()), CurrentRowNumber()}; 261 } 262 263 private: 264 friend class SchedSliceTable; 265 Iterator(SchedSliceTable * table,Table::Iterator iterator)266 explicit Iterator(SchedSliceTable* table, Table::Iterator iterator) 267 : ConstIterator(table, std::move(iterator)) {} 268 }; 269 270 struct IdAndRow { 271 Id id; 272 uint32_t row; 273 RowReference row_reference; 274 RowNumber row_number; 275 }; 276 GetColumns(SchedSliceTable * self,const macros_internal::MacroTable * parent)277 static std::vector<ColumnLegacy> GetColumns( 278 SchedSliceTable* self, 279 const macros_internal::MacroTable* parent) { 280 std::vector<ColumnLegacy> columns = 281 CopyColumnsFromParentOrAddRootColumns(self, parent); 282 uint32_t olay_idx = OverlayCount(parent); 283 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 284 static_cast<uint32_t>(columns.size()), olay_idx); 285 AddColumnToVector(columns, "dur", &self->dur_, ColumnFlag::dur, 286 static_cast<uint32_t>(columns.size()), olay_idx); 287 AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 288 static_cast<uint32_t>(columns.size()), olay_idx); 289 AddColumnToVector(columns, "end_state", &self->end_state_, ColumnFlag::end_state, 290 static_cast<uint32_t>(columns.size()), olay_idx); 291 AddColumnToVector(columns, "priority", &self->priority_, ColumnFlag::priority, 292 static_cast<uint32_t>(columns.size()), olay_idx); 293 AddColumnToVector(columns, "ucpu", &self->ucpu_, ColumnFlag::ucpu, 294 static_cast<uint32_t>(columns.size()), olay_idx); 295 return columns; 296 } 297 SchedSliceTable(StringPool * pool)298 PERFETTO_NO_INLINE explicit SchedSliceTable(StringPool* pool) 299 : macros_internal::MacroTable( 300 pool, 301 GetColumns(this, nullptr), 302 nullptr), 303 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 304 dur_(ColumnStorage<ColumnType::dur::stored_type>::Create<false>()), 305 utid_(ColumnStorage<ColumnType::utid::stored_type>::Create<false>()), 306 end_state_(ColumnStorage<ColumnType::end_state::stored_type>::Create<false>()), 307 priority_(ColumnStorage<ColumnType::priority::stored_type>::Create<false>()), 308 ucpu_(ColumnStorage<ColumnType::ucpu::stored_type>::Create<false>()) 309 , 310 id_storage_layer_(new column::IdStorage()), 311 type_storage_layer_( 312 new column::StringStorage(string_pool(), &type_.vector())), 313 ts_storage_layer_( 314 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 315 &ts_.vector(), 316 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 317 true)), 318 dur_storage_layer_( 319 new column::NumericStorage<ColumnType::dur::non_optional_stored_type>( 320 &dur_.vector(), 321 ColumnTypeHelper<ColumnType::dur::stored_type>::ToColumnType(), 322 false)), 323 utid_storage_layer_( 324 new column::NumericStorage<ColumnType::utid::non_optional_stored_type>( 325 &utid_.vector(), 326 ColumnTypeHelper<ColumnType::utid::stored_type>::ToColumnType(), 327 false)), 328 end_state_storage_layer_( 329 new column::StringStorage(string_pool(), &end_state_.vector())), 330 priority_storage_layer_( 331 new column::NumericStorage<ColumnType::priority::non_optional_stored_type>( 332 &priority_.vector(), 333 ColumnTypeHelper<ColumnType::priority::stored_type>::ToColumnType(), 334 false)), 335 ucpu_storage_layer_( 336 new column::NumericStorage<ColumnType::ucpu::non_optional_stored_type>( 337 &ucpu_.vector(), 338 ColumnTypeHelper<ColumnType::ucpu::stored_type>::ToColumnType(), 339 false)) 340 { 341 static_assert( 342 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 343 ColumnFlag::ts), 344 "Column type and flag combination is not valid"); 345 static_assert( 346 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::dur::stored_type>( 347 ColumnFlag::dur), 348 "Column type and flag combination is not valid"); 349 static_assert( 350 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::utid::stored_type>( 351 ColumnFlag::utid), 352 "Column type and flag combination is not valid"); 353 static_assert( 354 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::end_state::stored_type>( 355 ColumnFlag::end_state), 356 "Column type and flag combination is not valid"); 357 static_assert( 358 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::priority::stored_type>( 359 ColumnFlag::priority), 360 "Column type and flag combination is not valid"); 361 static_assert( 362 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ucpu::stored_type>( 363 ColumnFlag::ucpu), 364 "Column type and flag combination is not valid"); 365 OnConstructionCompletedRegularConstructor( 366 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,dur_storage_layer_,utid_storage_layer_,end_state_storage_layer_,priority_storage_layer_,ucpu_storage_layer_}, 367 {{},{},{},{},{},{},{},{}}); 368 } 369 ~SchedSliceTable() override; 370 Name()371 static const char* Name() { return "__intrinsic_sched_slice"; } 372 ComputeStaticSchema()373 static Table::Schema ComputeStaticSchema() { 374 Table::Schema schema; 375 schema.columns.emplace_back(Table::Schema::Column{ 376 "id", SqlValue::Type::kLong, true, true, false, false}); 377 schema.columns.emplace_back(Table::Schema::Column{ 378 "type", SqlValue::Type::kString, false, false, false, false}); 379 schema.columns.emplace_back(Table::Schema::Column{ 380 "ts", ColumnType::ts::SqlValueType(), false, 381 true, 382 false, 383 false}); 384 schema.columns.emplace_back(Table::Schema::Column{ 385 "dur", ColumnType::dur::SqlValueType(), false, 386 false, 387 false, 388 false}); 389 schema.columns.emplace_back(Table::Schema::Column{ 390 "utid", ColumnType::utid::SqlValueType(), false, 391 false, 392 false, 393 false}); 394 schema.columns.emplace_back(Table::Schema::Column{ 395 "end_state", ColumnType::end_state::SqlValueType(), false, 396 false, 397 false, 398 false}); 399 schema.columns.emplace_back(Table::Schema::Column{ 400 "priority", ColumnType::priority::SqlValueType(), false, 401 false, 402 false, 403 false}); 404 schema.columns.emplace_back(Table::Schema::Column{ 405 "ucpu", ColumnType::ucpu::SqlValueType(), false, 406 false, 407 false, 408 false}); 409 return schema; 410 } 411 IterateRows()412 ConstIterator IterateRows() const { 413 return ConstIterator(this, Table::IterateRows()); 414 } 415 IterateRows()416 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 417 FilterToIterator(const Query & q)418 ConstIterator FilterToIterator(const Query& q) const { 419 return ConstIterator(this, QueryToIterator(q)); 420 } 421 FilterToIterator(const Query & q)422 Iterator FilterToIterator(const Query& q) { 423 return Iterator(this, QueryToIterator(q)); 424 } 425 ShrinkToFit()426 void ShrinkToFit() { 427 type_.ShrinkToFit(); 428 ts_.ShrinkToFit(); 429 dur_.ShrinkToFit(); 430 utid_.ShrinkToFit(); 431 end_state_.ShrinkToFit(); 432 priority_.ShrinkToFit(); 433 ucpu_.ShrinkToFit(); 434 } 435 436 ConstRowReference operator[](uint32_t r) const { 437 return ConstRowReference(this, r); 438 } 439 RowReference operator[](uint32_t r) { return RowReference(this, r); } 440 ConstRowReference operator[](RowNumber r) const { 441 return ConstRowReference(this, r.row_number()); 442 } 443 RowReference operator[](RowNumber r) { 444 return RowReference(this, r.row_number()); 445 } 446 FindById(Id find_id)447 std::optional<ConstRowReference> FindById(Id find_id) const { 448 std::optional<uint32_t> row = id().IndexOf(find_id); 449 return row ? std::make_optional(ConstRowReference(this, *row)) 450 : std::nullopt; 451 } 452 FindById(Id find_id)453 std::optional<RowReference> FindById(Id find_id) { 454 std::optional<uint32_t> row = id().IndexOf(find_id); 455 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 456 } 457 Insert(const Row & row)458 IdAndRow Insert(const Row& row) { 459 uint32_t row_number = row_count(); 460 Id id = Id{row_number}; 461 type_.Append(string_pool()->InternString(row.type())); 462 mutable_ts()->Append(row.ts); 463 mutable_dur()->Append(row.dur); 464 mutable_utid()->Append(row.utid); 465 mutable_end_state()->Append(row.end_state); 466 mutable_priority()->Append(row.priority); 467 mutable_ucpu()->Append(row.ucpu); 468 UpdateSelfOverlayAfterInsert(); 469 return IdAndRow{id, row_number, RowReference(this, row_number), 470 RowNumber(row_number)}; 471 } 472 473 474 id()475 const IdColumn<SchedSliceTable::Id>& id() const { 476 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 477 } type()478 const TypedColumn<StringPool::Id>& type() const { 479 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 480 } ts()481 const TypedColumn<int64_t>& ts() const { 482 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 483 } dur()484 const TypedColumn<int64_t>& dur() const { 485 return static_cast<const ColumnType::dur&>(columns()[ColumnIndex::dur]); 486 } utid()487 const TypedColumn<uint32_t>& utid() const { 488 return static_cast<const ColumnType::utid&>(columns()[ColumnIndex::utid]); 489 } end_state()490 const TypedColumn<StringPool::Id>& end_state() const { 491 return static_cast<const ColumnType::end_state&>(columns()[ColumnIndex::end_state]); 492 } priority()493 const TypedColumn<int32_t>& priority() const { 494 return static_cast<const ColumnType::priority&>(columns()[ColumnIndex::priority]); 495 } ucpu()496 const TypedColumn<CpuTable::Id>& ucpu() const { 497 return static_cast<const ColumnType::ucpu&>(columns()[ColumnIndex::ucpu]); 498 } 499 mutable_ts()500 TypedColumn<int64_t>* mutable_ts() { 501 return static_cast<ColumnType::ts*>( 502 GetColumn(ColumnIndex::ts)); 503 } mutable_dur()504 TypedColumn<int64_t>* mutable_dur() { 505 return static_cast<ColumnType::dur*>( 506 GetColumn(ColumnIndex::dur)); 507 } mutable_utid()508 TypedColumn<uint32_t>* mutable_utid() { 509 return static_cast<ColumnType::utid*>( 510 GetColumn(ColumnIndex::utid)); 511 } mutable_end_state()512 TypedColumn<StringPool::Id>* mutable_end_state() { 513 return static_cast<ColumnType::end_state*>( 514 GetColumn(ColumnIndex::end_state)); 515 } mutable_priority()516 TypedColumn<int32_t>* mutable_priority() { 517 return static_cast<ColumnType::priority*>( 518 GetColumn(ColumnIndex::priority)); 519 } mutable_ucpu()520 TypedColumn<CpuTable::Id>* mutable_ucpu() { 521 return static_cast<ColumnType::ucpu*>( 522 GetColumn(ColumnIndex::ucpu)); 523 } 524 525 private: 526 527 528 ColumnStorage<ColumnType::ts::stored_type> ts_; 529 ColumnStorage<ColumnType::dur::stored_type> dur_; 530 ColumnStorage<ColumnType::utid::stored_type> utid_; 531 ColumnStorage<ColumnType::end_state::stored_type> end_state_; 532 ColumnStorage<ColumnType::priority::stored_type> priority_; 533 ColumnStorage<ColumnType::ucpu::stored_type> ucpu_; 534 535 RefPtr<column::StorageLayer> id_storage_layer_; 536 RefPtr<column::StorageLayer> type_storage_layer_; 537 RefPtr<column::StorageLayer> ts_storage_layer_; 538 RefPtr<column::StorageLayer> dur_storage_layer_; 539 RefPtr<column::StorageLayer> utid_storage_layer_; 540 RefPtr<column::StorageLayer> end_state_storage_layer_; 541 RefPtr<column::StorageLayer> priority_storage_layer_; 542 RefPtr<column::StorageLayer> ucpu_storage_layer_; 543 544 545 }; 546 547 548 class SpuriousSchedWakeupTable : public macros_internal::MacroTable { 549 public: 550 static constexpr uint32_t kColumnCount = 7; 551 552 struct Id : public BaseId { 553 Id() = default; IdId554 explicit constexpr Id(uint32_t v) : BaseId(v) {} 555 }; 556 static_assert(std::is_trivially_destructible_v<Id>, 557 "Inheritance used without trivial destruction"); 558 559 struct ColumnIndex { 560 static constexpr uint32_t id = 0; 561 static constexpr uint32_t type = 1; 562 static constexpr uint32_t ts = 2; 563 static constexpr uint32_t thread_state_id = 3; 564 static constexpr uint32_t irq_context = 4; 565 static constexpr uint32_t utid = 5; 566 static constexpr uint32_t waker_utid = 6; 567 }; 568 struct ColumnType { 569 using id = IdColumn<SpuriousSchedWakeupTable::Id>; 570 using type = TypedColumn<StringPool::Id>; 571 using ts = TypedColumn<int64_t>; 572 using thread_state_id = TypedColumn<int64_t>; 573 using irq_context = TypedColumn<std::optional<uint32_t>>; 574 using utid = TypedColumn<uint32_t>; 575 using waker_utid = TypedColumn<uint32_t>; 576 }; 577 struct Row : public macros_internal::RootParentTable::Row { 578 Row(int64_t in_ts = {}, 579 int64_t in_thread_state_id = {}, 580 std::optional<uint32_t> in_irq_context = {}, 581 uint32_t in_utid = {}, 582 uint32_t in_waker_utid = {}, 583 std::nullptr_t = nullptr) RowRow584 : macros_internal::RootParentTable::Row(), 585 ts(in_ts), 586 thread_state_id(in_thread_state_id), 587 irq_context(in_irq_context), 588 utid(in_utid), 589 waker_utid(in_waker_utid) { 590 type_ = "spurious_sched_wakeup"; 591 } 592 int64_t ts; 593 int64_t thread_state_id; 594 std::optional<uint32_t> irq_context; 595 uint32_t utid; 596 uint32_t waker_utid; 597 598 bool operator==(const SpuriousSchedWakeupTable::Row& other) const { 599 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 600 ColumnType::thread_state_id::Equals(thread_state_id, other.thread_state_id) && 601 ColumnType::irq_context::Equals(irq_context, other.irq_context) && 602 ColumnType::utid::Equals(utid, other.utid) && 603 ColumnType::waker_utid::Equals(waker_utid, other.waker_utid); 604 } 605 }; 606 struct ColumnFlag { 607 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 608 static constexpr uint32_t thread_state_id = ColumnType::thread_state_id::default_flags(); 609 static constexpr uint32_t irq_context = ColumnType::irq_context::default_flags(); 610 static constexpr uint32_t utid = ColumnType::utid::default_flags(); 611 static constexpr uint32_t waker_utid = ColumnType::waker_utid::default_flags(); 612 }; 613 614 class RowNumber; 615 class ConstRowReference; 616 class RowReference; 617 618 class RowNumber : public macros_internal::AbstractRowNumber< 619 SpuriousSchedWakeupTable, ConstRowReference, RowReference> { 620 public: RowNumber(uint32_t row_number)621 explicit RowNumber(uint32_t row_number) 622 : AbstractRowNumber(row_number) {} 623 }; 624 static_assert(std::is_trivially_destructible_v<RowNumber>, 625 "Inheritance used without trivial destruction"); 626 627 class ConstRowReference : public macros_internal::AbstractConstRowReference< 628 SpuriousSchedWakeupTable, RowNumber> { 629 public: ConstRowReference(const SpuriousSchedWakeupTable * table,uint32_t row_number)630 ConstRowReference(const SpuriousSchedWakeupTable* table, uint32_t row_number) 631 : AbstractConstRowReference(table, row_number) {} 632 id()633 ColumnType::id::type id() const { 634 return table()->id()[row_number_]; 635 } type()636 ColumnType::type::type type() const { 637 return table()->type()[row_number_]; 638 } ts()639 ColumnType::ts::type ts() const { 640 return table()->ts()[row_number_]; 641 } thread_state_id()642 ColumnType::thread_state_id::type thread_state_id() const { 643 return table()->thread_state_id()[row_number_]; 644 } irq_context()645 ColumnType::irq_context::type irq_context() const { 646 return table()->irq_context()[row_number_]; 647 } utid()648 ColumnType::utid::type utid() const { 649 return table()->utid()[row_number_]; 650 } waker_utid()651 ColumnType::waker_utid::type waker_utid() const { 652 return table()->waker_utid()[row_number_]; 653 } 654 }; 655 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 656 "Inheritance used without trivial destruction"); 657 class RowReference : public ConstRowReference { 658 public: RowReference(const SpuriousSchedWakeupTable * table,uint32_t row_number)659 RowReference(const SpuriousSchedWakeupTable* table, uint32_t row_number) 660 : ConstRowReference(table, row_number) {} 661 set_ts(ColumnType::ts::non_optional_type v)662 void set_ts( 663 ColumnType::ts::non_optional_type v) { 664 return mutable_table()->mutable_ts()->Set(row_number_, v); 665 } set_thread_state_id(ColumnType::thread_state_id::non_optional_type v)666 void set_thread_state_id( 667 ColumnType::thread_state_id::non_optional_type v) { 668 return mutable_table()->mutable_thread_state_id()->Set(row_number_, v); 669 } set_irq_context(ColumnType::irq_context::non_optional_type v)670 void set_irq_context( 671 ColumnType::irq_context::non_optional_type v) { 672 return mutable_table()->mutable_irq_context()->Set(row_number_, v); 673 } set_utid(ColumnType::utid::non_optional_type v)674 void set_utid( 675 ColumnType::utid::non_optional_type v) { 676 return mutable_table()->mutable_utid()->Set(row_number_, v); 677 } set_waker_utid(ColumnType::waker_utid::non_optional_type v)678 void set_waker_utid( 679 ColumnType::waker_utid::non_optional_type v) { 680 return mutable_table()->mutable_waker_utid()->Set(row_number_, v); 681 } 682 683 private: mutable_table()684 SpuriousSchedWakeupTable* mutable_table() const { 685 return const_cast<SpuriousSchedWakeupTable*>(table()); 686 } 687 }; 688 static_assert(std::is_trivially_destructible_v<RowReference>, 689 "Inheritance used without trivial destruction"); 690 691 class ConstIterator; 692 class ConstIterator : public macros_internal::AbstractConstIterator< 693 ConstIterator, SpuriousSchedWakeupTable, RowNumber, ConstRowReference> { 694 public: id()695 ColumnType::id::type id() const { 696 const auto& col = table()->id(); 697 return col.GetAtIdx( 698 iterator_.StorageIndexForColumn(col.index_in_table())); 699 } type()700 ColumnType::type::type type() const { 701 const auto& col = table()->type(); 702 return col.GetAtIdx( 703 iterator_.StorageIndexForColumn(col.index_in_table())); 704 } ts()705 ColumnType::ts::type ts() const { 706 const auto& col = table()->ts(); 707 return col.GetAtIdx( 708 iterator_.StorageIndexForColumn(col.index_in_table())); 709 } thread_state_id()710 ColumnType::thread_state_id::type thread_state_id() const { 711 const auto& col = table()->thread_state_id(); 712 return col.GetAtIdx( 713 iterator_.StorageIndexForColumn(col.index_in_table())); 714 } irq_context()715 ColumnType::irq_context::type irq_context() const { 716 const auto& col = table()->irq_context(); 717 return col.GetAtIdx( 718 iterator_.StorageIndexForColumn(col.index_in_table())); 719 } utid()720 ColumnType::utid::type utid() const { 721 const auto& col = table()->utid(); 722 return col.GetAtIdx( 723 iterator_.StorageIndexForColumn(col.index_in_table())); 724 } waker_utid()725 ColumnType::waker_utid::type waker_utid() const { 726 const auto& col = table()->waker_utid(); 727 return col.GetAtIdx( 728 iterator_.StorageIndexForColumn(col.index_in_table())); 729 } 730 731 protected: ConstIterator(const SpuriousSchedWakeupTable * table,Table::Iterator iterator)732 explicit ConstIterator(const SpuriousSchedWakeupTable* table, 733 Table::Iterator iterator) 734 : AbstractConstIterator(table, std::move(iterator)) {} 735 CurrentRowNumber()736 uint32_t CurrentRowNumber() const { 737 return iterator_.StorageIndexForLastOverlay(); 738 } 739 740 private: 741 friend class SpuriousSchedWakeupTable; 742 friend class macros_internal::AbstractConstIterator< 743 ConstIterator, SpuriousSchedWakeupTable, RowNumber, ConstRowReference>; 744 }; 745 class Iterator : public ConstIterator { 746 public: row_reference()747 RowReference row_reference() const { 748 return {const_cast<SpuriousSchedWakeupTable*>(table()), CurrentRowNumber()}; 749 } 750 751 private: 752 friend class SpuriousSchedWakeupTable; 753 Iterator(SpuriousSchedWakeupTable * table,Table::Iterator iterator)754 explicit Iterator(SpuriousSchedWakeupTable* table, Table::Iterator iterator) 755 : ConstIterator(table, std::move(iterator)) {} 756 }; 757 758 struct IdAndRow { 759 Id id; 760 uint32_t row; 761 RowReference row_reference; 762 RowNumber row_number; 763 }; 764 GetColumns(SpuriousSchedWakeupTable * self,const macros_internal::MacroTable * parent)765 static std::vector<ColumnLegacy> GetColumns( 766 SpuriousSchedWakeupTable* self, 767 const macros_internal::MacroTable* parent) { 768 std::vector<ColumnLegacy> columns = 769 CopyColumnsFromParentOrAddRootColumns(self, parent); 770 uint32_t olay_idx = OverlayCount(parent); 771 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 772 static_cast<uint32_t>(columns.size()), olay_idx); 773 AddColumnToVector(columns, "thread_state_id", &self->thread_state_id_, ColumnFlag::thread_state_id, 774 static_cast<uint32_t>(columns.size()), olay_idx); 775 AddColumnToVector(columns, "irq_context", &self->irq_context_, ColumnFlag::irq_context, 776 static_cast<uint32_t>(columns.size()), olay_idx); 777 AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 778 static_cast<uint32_t>(columns.size()), olay_idx); 779 AddColumnToVector(columns, "waker_utid", &self->waker_utid_, ColumnFlag::waker_utid, 780 static_cast<uint32_t>(columns.size()), olay_idx); 781 return columns; 782 } 783 SpuriousSchedWakeupTable(StringPool * pool)784 PERFETTO_NO_INLINE explicit SpuriousSchedWakeupTable(StringPool* pool) 785 : macros_internal::MacroTable( 786 pool, 787 GetColumns(this, nullptr), 788 nullptr), 789 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 790 thread_state_id_(ColumnStorage<ColumnType::thread_state_id::stored_type>::Create<false>()), 791 irq_context_(ColumnStorage<ColumnType::irq_context::stored_type>::Create<false>()), 792 utid_(ColumnStorage<ColumnType::utid::stored_type>::Create<false>()), 793 waker_utid_(ColumnStorage<ColumnType::waker_utid::stored_type>::Create<false>()) 794 , 795 id_storage_layer_(new column::IdStorage()), 796 type_storage_layer_( 797 new column::StringStorage(string_pool(), &type_.vector())), 798 ts_storage_layer_( 799 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 800 &ts_.vector(), 801 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 802 true)), 803 thread_state_id_storage_layer_( 804 new column::NumericStorage<ColumnType::thread_state_id::non_optional_stored_type>( 805 &thread_state_id_.vector(), 806 ColumnTypeHelper<ColumnType::thread_state_id::stored_type>::ToColumnType(), 807 false)), 808 irq_context_storage_layer_( 809 new column::NumericStorage<ColumnType::irq_context::non_optional_stored_type>( 810 &irq_context_.non_null_vector(), 811 ColumnTypeHelper<ColumnType::irq_context::stored_type>::ToColumnType(), 812 false)), 813 utid_storage_layer_( 814 new column::NumericStorage<ColumnType::utid::non_optional_stored_type>( 815 &utid_.vector(), 816 ColumnTypeHelper<ColumnType::utid::stored_type>::ToColumnType(), 817 false)), 818 waker_utid_storage_layer_( 819 new column::NumericStorage<ColumnType::waker_utid::non_optional_stored_type>( 820 &waker_utid_.vector(), 821 ColumnTypeHelper<ColumnType::waker_utid::stored_type>::ToColumnType(), 822 false)) 823 , 824 irq_context_null_layer_(new column::NullOverlay(irq_context_.bv())) { 825 static_assert( 826 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 827 ColumnFlag::ts), 828 "Column type and flag combination is not valid"); 829 static_assert( 830 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::thread_state_id::stored_type>( 831 ColumnFlag::thread_state_id), 832 "Column type and flag combination is not valid"); 833 static_assert( 834 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::irq_context::stored_type>( 835 ColumnFlag::irq_context), 836 "Column type and flag combination is not valid"); 837 static_assert( 838 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::utid::stored_type>( 839 ColumnFlag::utid), 840 "Column type and flag combination is not valid"); 841 static_assert( 842 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::waker_utid::stored_type>( 843 ColumnFlag::waker_utid), 844 "Column type and flag combination is not valid"); 845 OnConstructionCompletedRegularConstructor( 846 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,thread_state_id_storage_layer_,irq_context_storage_layer_,utid_storage_layer_,waker_utid_storage_layer_}, 847 {{},{},{},{},irq_context_null_layer_,{},{}}); 848 } 849 ~SpuriousSchedWakeupTable() override; 850 Name()851 static const char* Name() { return "spurious_sched_wakeup"; } 852 ComputeStaticSchema()853 static Table::Schema ComputeStaticSchema() { 854 Table::Schema schema; 855 schema.columns.emplace_back(Table::Schema::Column{ 856 "id", SqlValue::Type::kLong, true, true, false, false}); 857 schema.columns.emplace_back(Table::Schema::Column{ 858 "type", SqlValue::Type::kString, false, false, false, false}); 859 schema.columns.emplace_back(Table::Schema::Column{ 860 "ts", ColumnType::ts::SqlValueType(), false, 861 true, 862 false, 863 false}); 864 schema.columns.emplace_back(Table::Schema::Column{ 865 "thread_state_id", ColumnType::thread_state_id::SqlValueType(), false, 866 false, 867 false, 868 false}); 869 schema.columns.emplace_back(Table::Schema::Column{ 870 "irq_context", ColumnType::irq_context::SqlValueType(), false, 871 false, 872 false, 873 false}); 874 schema.columns.emplace_back(Table::Schema::Column{ 875 "utid", ColumnType::utid::SqlValueType(), false, 876 false, 877 false, 878 false}); 879 schema.columns.emplace_back(Table::Schema::Column{ 880 "waker_utid", ColumnType::waker_utid::SqlValueType(), false, 881 false, 882 false, 883 false}); 884 return schema; 885 } 886 IterateRows()887 ConstIterator IterateRows() const { 888 return ConstIterator(this, Table::IterateRows()); 889 } 890 IterateRows()891 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 892 FilterToIterator(const Query & q)893 ConstIterator FilterToIterator(const Query& q) const { 894 return ConstIterator(this, QueryToIterator(q)); 895 } 896 FilterToIterator(const Query & q)897 Iterator FilterToIterator(const Query& q) { 898 return Iterator(this, QueryToIterator(q)); 899 } 900 ShrinkToFit()901 void ShrinkToFit() { 902 type_.ShrinkToFit(); 903 ts_.ShrinkToFit(); 904 thread_state_id_.ShrinkToFit(); 905 irq_context_.ShrinkToFit(); 906 utid_.ShrinkToFit(); 907 waker_utid_.ShrinkToFit(); 908 } 909 910 ConstRowReference operator[](uint32_t r) const { 911 return ConstRowReference(this, r); 912 } 913 RowReference operator[](uint32_t r) { return RowReference(this, r); } 914 ConstRowReference operator[](RowNumber r) const { 915 return ConstRowReference(this, r.row_number()); 916 } 917 RowReference operator[](RowNumber r) { 918 return RowReference(this, r.row_number()); 919 } 920 FindById(Id find_id)921 std::optional<ConstRowReference> FindById(Id find_id) const { 922 std::optional<uint32_t> row = id().IndexOf(find_id); 923 return row ? std::make_optional(ConstRowReference(this, *row)) 924 : std::nullopt; 925 } 926 FindById(Id find_id)927 std::optional<RowReference> FindById(Id find_id) { 928 std::optional<uint32_t> row = id().IndexOf(find_id); 929 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 930 } 931 Insert(const Row & row)932 IdAndRow Insert(const Row& row) { 933 uint32_t row_number = row_count(); 934 Id id = Id{row_number}; 935 type_.Append(string_pool()->InternString(row.type())); 936 mutable_ts()->Append(row.ts); 937 mutable_thread_state_id()->Append(row.thread_state_id); 938 mutable_irq_context()->Append(row.irq_context); 939 mutable_utid()->Append(row.utid); 940 mutable_waker_utid()->Append(row.waker_utid); 941 UpdateSelfOverlayAfterInsert(); 942 return IdAndRow{id, row_number, RowReference(this, row_number), 943 RowNumber(row_number)}; 944 } 945 946 947 id()948 const IdColumn<SpuriousSchedWakeupTable::Id>& id() const { 949 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 950 } type()951 const TypedColumn<StringPool::Id>& type() const { 952 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 953 } ts()954 const TypedColumn<int64_t>& ts() const { 955 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 956 } thread_state_id()957 const TypedColumn<int64_t>& thread_state_id() const { 958 return static_cast<const ColumnType::thread_state_id&>(columns()[ColumnIndex::thread_state_id]); 959 } irq_context()960 const TypedColumn<std::optional<uint32_t>>& irq_context() const { 961 return static_cast<const ColumnType::irq_context&>(columns()[ColumnIndex::irq_context]); 962 } utid()963 const TypedColumn<uint32_t>& utid() const { 964 return static_cast<const ColumnType::utid&>(columns()[ColumnIndex::utid]); 965 } waker_utid()966 const TypedColumn<uint32_t>& waker_utid() const { 967 return static_cast<const ColumnType::waker_utid&>(columns()[ColumnIndex::waker_utid]); 968 } 969 mutable_ts()970 TypedColumn<int64_t>* mutable_ts() { 971 return static_cast<ColumnType::ts*>( 972 GetColumn(ColumnIndex::ts)); 973 } mutable_thread_state_id()974 TypedColumn<int64_t>* mutable_thread_state_id() { 975 return static_cast<ColumnType::thread_state_id*>( 976 GetColumn(ColumnIndex::thread_state_id)); 977 } mutable_irq_context()978 TypedColumn<std::optional<uint32_t>>* mutable_irq_context() { 979 return static_cast<ColumnType::irq_context*>( 980 GetColumn(ColumnIndex::irq_context)); 981 } mutable_utid()982 TypedColumn<uint32_t>* mutable_utid() { 983 return static_cast<ColumnType::utid*>( 984 GetColumn(ColumnIndex::utid)); 985 } mutable_waker_utid()986 TypedColumn<uint32_t>* mutable_waker_utid() { 987 return static_cast<ColumnType::waker_utid*>( 988 GetColumn(ColumnIndex::waker_utid)); 989 } 990 991 private: 992 993 994 ColumnStorage<ColumnType::ts::stored_type> ts_; 995 ColumnStorage<ColumnType::thread_state_id::stored_type> thread_state_id_; 996 ColumnStorage<ColumnType::irq_context::stored_type> irq_context_; 997 ColumnStorage<ColumnType::utid::stored_type> utid_; 998 ColumnStorage<ColumnType::waker_utid::stored_type> waker_utid_; 999 1000 RefPtr<column::StorageLayer> id_storage_layer_; 1001 RefPtr<column::StorageLayer> type_storage_layer_; 1002 RefPtr<column::StorageLayer> ts_storage_layer_; 1003 RefPtr<column::StorageLayer> thread_state_id_storage_layer_; 1004 RefPtr<column::StorageLayer> irq_context_storage_layer_; 1005 RefPtr<column::StorageLayer> utid_storage_layer_; 1006 RefPtr<column::StorageLayer> waker_utid_storage_layer_; 1007 1008 RefPtr<column::OverlayLayer> irq_context_null_layer_; 1009 }; 1010 1011 1012 class ThreadStateTable : public macros_internal::MacroTable { 1013 public: 1014 static constexpr uint32_t kColumnCount = 12; 1015 1016 struct Id : public BaseId { 1017 Id() = default; IdId1018 explicit constexpr Id(uint32_t v) : BaseId(v) {} 1019 }; 1020 static_assert(std::is_trivially_destructible_v<Id>, 1021 "Inheritance used without trivial destruction"); 1022 1023 struct ColumnIndex { 1024 static constexpr uint32_t id = 0; 1025 static constexpr uint32_t type = 1; 1026 static constexpr uint32_t ts = 2; 1027 static constexpr uint32_t dur = 3; 1028 static constexpr uint32_t utid = 4; 1029 static constexpr uint32_t state = 5; 1030 static constexpr uint32_t io_wait = 6; 1031 static constexpr uint32_t blocked_function = 7; 1032 static constexpr uint32_t waker_utid = 8; 1033 static constexpr uint32_t waker_id = 9; 1034 static constexpr uint32_t irq_context = 10; 1035 static constexpr uint32_t ucpu = 11; 1036 }; 1037 struct ColumnType { 1038 using id = IdColumn<ThreadStateTable::Id>; 1039 using type = TypedColumn<StringPool::Id>; 1040 using ts = TypedColumn<int64_t>; 1041 using dur = TypedColumn<int64_t>; 1042 using utid = TypedColumn<uint32_t>; 1043 using state = TypedColumn<StringPool::Id>; 1044 using io_wait = TypedColumn<std::optional<uint32_t>>; 1045 using blocked_function = TypedColumn<std::optional<StringPool::Id>>; 1046 using waker_utid = TypedColumn<std::optional<uint32_t>>; 1047 using waker_id = TypedColumn<std::optional<ThreadStateTable::Id>>; 1048 using irq_context = TypedColumn<std::optional<uint32_t>>; 1049 using ucpu = TypedColumn<std::optional<CpuTable::Id>>; 1050 }; 1051 struct Row : public macros_internal::RootParentTable::Row { 1052 Row(int64_t in_ts = {}, 1053 int64_t in_dur = {}, 1054 uint32_t in_utid = {}, 1055 StringPool::Id in_state = {}, 1056 std::optional<uint32_t> in_io_wait = {}, 1057 std::optional<StringPool::Id> in_blocked_function = {}, 1058 std::optional<uint32_t> in_waker_utid = {}, 1059 std::optional<ThreadStateTable::Id> in_waker_id = {}, 1060 std::optional<uint32_t> in_irq_context = {}, 1061 std::optional<CpuTable::Id> in_ucpu = {}, 1062 std::nullptr_t = nullptr) RowRow1063 : macros_internal::RootParentTable::Row(), 1064 ts(in_ts), 1065 dur(in_dur), 1066 utid(in_utid), 1067 state(in_state), 1068 io_wait(in_io_wait), 1069 blocked_function(in_blocked_function), 1070 waker_utid(in_waker_utid), 1071 waker_id(in_waker_id), 1072 irq_context(in_irq_context), 1073 ucpu(in_ucpu) { 1074 type_ = "__intrinsic_thread_state"; 1075 } 1076 int64_t ts; 1077 int64_t dur; 1078 uint32_t utid; 1079 StringPool::Id state; 1080 std::optional<uint32_t> io_wait; 1081 std::optional<StringPool::Id> blocked_function; 1082 std::optional<uint32_t> waker_utid; 1083 std::optional<ThreadStateTable::Id> waker_id; 1084 std::optional<uint32_t> irq_context; 1085 std::optional<CpuTable::Id> ucpu; 1086 1087 bool operator==(const ThreadStateTable::Row& other) const { 1088 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 1089 ColumnType::dur::Equals(dur, other.dur) && 1090 ColumnType::utid::Equals(utid, other.utid) && 1091 ColumnType::state::Equals(state, other.state) && 1092 ColumnType::io_wait::Equals(io_wait, other.io_wait) && 1093 ColumnType::blocked_function::Equals(blocked_function, other.blocked_function) && 1094 ColumnType::waker_utid::Equals(waker_utid, other.waker_utid) && 1095 ColumnType::waker_id::Equals(waker_id, other.waker_id) && 1096 ColumnType::irq_context::Equals(irq_context, other.irq_context) && 1097 ColumnType::ucpu::Equals(ucpu, other.ucpu); 1098 } 1099 }; 1100 struct ColumnFlag { 1101 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 1102 static constexpr uint32_t dur = ColumnType::dur::default_flags(); 1103 static constexpr uint32_t utid = ColumnType::utid::default_flags(); 1104 static constexpr uint32_t state = ColumnType::state::default_flags(); 1105 static constexpr uint32_t io_wait = ColumnType::io_wait::default_flags(); 1106 static constexpr uint32_t blocked_function = ColumnType::blocked_function::default_flags(); 1107 static constexpr uint32_t waker_utid = ColumnType::waker_utid::default_flags(); 1108 static constexpr uint32_t waker_id = ColumnType::waker_id::default_flags(); 1109 static constexpr uint32_t irq_context = ColumnType::irq_context::default_flags(); 1110 static constexpr uint32_t ucpu = ColumnType::ucpu::default_flags(); 1111 }; 1112 1113 class RowNumber; 1114 class ConstRowReference; 1115 class RowReference; 1116 1117 class RowNumber : public macros_internal::AbstractRowNumber< 1118 ThreadStateTable, ConstRowReference, RowReference> { 1119 public: RowNumber(uint32_t row_number)1120 explicit RowNumber(uint32_t row_number) 1121 : AbstractRowNumber(row_number) {} 1122 }; 1123 static_assert(std::is_trivially_destructible_v<RowNumber>, 1124 "Inheritance used without trivial destruction"); 1125 1126 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1127 ThreadStateTable, RowNumber> { 1128 public: ConstRowReference(const ThreadStateTable * table,uint32_t row_number)1129 ConstRowReference(const ThreadStateTable* table, uint32_t row_number) 1130 : AbstractConstRowReference(table, row_number) {} 1131 id()1132 ColumnType::id::type id() const { 1133 return table()->id()[row_number_]; 1134 } type()1135 ColumnType::type::type type() const { 1136 return table()->type()[row_number_]; 1137 } ts()1138 ColumnType::ts::type ts() const { 1139 return table()->ts()[row_number_]; 1140 } dur()1141 ColumnType::dur::type dur() const { 1142 return table()->dur()[row_number_]; 1143 } utid()1144 ColumnType::utid::type utid() const { 1145 return table()->utid()[row_number_]; 1146 } state()1147 ColumnType::state::type state() const { 1148 return table()->state()[row_number_]; 1149 } io_wait()1150 ColumnType::io_wait::type io_wait() const { 1151 return table()->io_wait()[row_number_]; 1152 } blocked_function()1153 ColumnType::blocked_function::type blocked_function() const { 1154 return table()->blocked_function()[row_number_]; 1155 } waker_utid()1156 ColumnType::waker_utid::type waker_utid() const { 1157 return table()->waker_utid()[row_number_]; 1158 } waker_id()1159 ColumnType::waker_id::type waker_id() const { 1160 return table()->waker_id()[row_number_]; 1161 } irq_context()1162 ColumnType::irq_context::type irq_context() const { 1163 return table()->irq_context()[row_number_]; 1164 } ucpu()1165 ColumnType::ucpu::type ucpu() const { 1166 return table()->ucpu()[row_number_]; 1167 } 1168 }; 1169 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1170 "Inheritance used without trivial destruction"); 1171 class RowReference : public ConstRowReference { 1172 public: RowReference(const ThreadStateTable * table,uint32_t row_number)1173 RowReference(const ThreadStateTable* table, uint32_t row_number) 1174 : ConstRowReference(table, row_number) {} 1175 set_ts(ColumnType::ts::non_optional_type v)1176 void set_ts( 1177 ColumnType::ts::non_optional_type v) { 1178 return mutable_table()->mutable_ts()->Set(row_number_, v); 1179 } set_dur(ColumnType::dur::non_optional_type v)1180 void set_dur( 1181 ColumnType::dur::non_optional_type v) { 1182 return mutable_table()->mutable_dur()->Set(row_number_, v); 1183 } set_utid(ColumnType::utid::non_optional_type v)1184 void set_utid( 1185 ColumnType::utid::non_optional_type v) { 1186 return mutable_table()->mutable_utid()->Set(row_number_, v); 1187 } set_state(ColumnType::state::non_optional_type v)1188 void set_state( 1189 ColumnType::state::non_optional_type v) { 1190 return mutable_table()->mutable_state()->Set(row_number_, v); 1191 } set_io_wait(ColumnType::io_wait::non_optional_type v)1192 void set_io_wait( 1193 ColumnType::io_wait::non_optional_type v) { 1194 return mutable_table()->mutable_io_wait()->Set(row_number_, v); 1195 } set_blocked_function(ColumnType::blocked_function::non_optional_type v)1196 void set_blocked_function( 1197 ColumnType::blocked_function::non_optional_type v) { 1198 return mutable_table()->mutable_blocked_function()->Set(row_number_, v); 1199 } set_waker_utid(ColumnType::waker_utid::non_optional_type v)1200 void set_waker_utid( 1201 ColumnType::waker_utid::non_optional_type v) { 1202 return mutable_table()->mutable_waker_utid()->Set(row_number_, v); 1203 } set_waker_id(ColumnType::waker_id::non_optional_type v)1204 void set_waker_id( 1205 ColumnType::waker_id::non_optional_type v) { 1206 return mutable_table()->mutable_waker_id()->Set(row_number_, v); 1207 } set_irq_context(ColumnType::irq_context::non_optional_type v)1208 void set_irq_context( 1209 ColumnType::irq_context::non_optional_type v) { 1210 return mutable_table()->mutable_irq_context()->Set(row_number_, v); 1211 } set_ucpu(ColumnType::ucpu::non_optional_type v)1212 void set_ucpu( 1213 ColumnType::ucpu::non_optional_type v) { 1214 return mutable_table()->mutable_ucpu()->Set(row_number_, v); 1215 } 1216 1217 private: mutable_table()1218 ThreadStateTable* mutable_table() const { 1219 return const_cast<ThreadStateTable*>(table()); 1220 } 1221 }; 1222 static_assert(std::is_trivially_destructible_v<RowReference>, 1223 "Inheritance used without trivial destruction"); 1224 1225 class ConstIterator; 1226 class ConstIterator : public macros_internal::AbstractConstIterator< 1227 ConstIterator, ThreadStateTable, RowNumber, ConstRowReference> { 1228 public: id()1229 ColumnType::id::type id() const { 1230 const auto& col = table()->id(); 1231 return col.GetAtIdx( 1232 iterator_.StorageIndexForColumn(col.index_in_table())); 1233 } type()1234 ColumnType::type::type type() const { 1235 const auto& col = table()->type(); 1236 return col.GetAtIdx( 1237 iterator_.StorageIndexForColumn(col.index_in_table())); 1238 } ts()1239 ColumnType::ts::type ts() const { 1240 const auto& col = table()->ts(); 1241 return col.GetAtIdx( 1242 iterator_.StorageIndexForColumn(col.index_in_table())); 1243 } dur()1244 ColumnType::dur::type dur() const { 1245 const auto& col = table()->dur(); 1246 return col.GetAtIdx( 1247 iterator_.StorageIndexForColumn(col.index_in_table())); 1248 } utid()1249 ColumnType::utid::type utid() const { 1250 const auto& col = table()->utid(); 1251 return col.GetAtIdx( 1252 iterator_.StorageIndexForColumn(col.index_in_table())); 1253 } state()1254 ColumnType::state::type state() const { 1255 const auto& col = table()->state(); 1256 return col.GetAtIdx( 1257 iterator_.StorageIndexForColumn(col.index_in_table())); 1258 } io_wait()1259 ColumnType::io_wait::type io_wait() const { 1260 const auto& col = table()->io_wait(); 1261 return col.GetAtIdx( 1262 iterator_.StorageIndexForColumn(col.index_in_table())); 1263 } blocked_function()1264 ColumnType::blocked_function::type blocked_function() const { 1265 const auto& col = table()->blocked_function(); 1266 return col.GetAtIdx( 1267 iterator_.StorageIndexForColumn(col.index_in_table())); 1268 } waker_utid()1269 ColumnType::waker_utid::type waker_utid() const { 1270 const auto& col = table()->waker_utid(); 1271 return col.GetAtIdx( 1272 iterator_.StorageIndexForColumn(col.index_in_table())); 1273 } waker_id()1274 ColumnType::waker_id::type waker_id() const { 1275 const auto& col = table()->waker_id(); 1276 return col.GetAtIdx( 1277 iterator_.StorageIndexForColumn(col.index_in_table())); 1278 } irq_context()1279 ColumnType::irq_context::type irq_context() const { 1280 const auto& col = table()->irq_context(); 1281 return col.GetAtIdx( 1282 iterator_.StorageIndexForColumn(col.index_in_table())); 1283 } ucpu()1284 ColumnType::ucpu::type ucpu() const { 1285 const auto& col = table()->ucpu(); 1286 return col.GetAtIdx( 1287 iterator_.StorageIndexForColumn(col.index_in_table())); 1288 } 1289 1290 protected: ConstIterator(const ThreadStateTable * table,Table::Iterator iterator)1291 explicit ConstIterator(const ThreadStateTable* table, 1292 Table::Iterator iterator) 1293 : AbstractConstIterator(table, std::move(iterator)) {} 1294 CurrentRowNumber()1295 uint32_t CurrentRowNumber() const { 1296 return iterator_.StorageIndexForLastOverlay(); 1297 } 1298 1299 private: 1300 friend class ThreadStateTable; 1301 friend class macros_internal::AbstractConstIterator< 1302 ConstIterator, ThreadStateTable, RowNumber, ConstRowReference>; 1303 }; 1304 class Iterator : public ConstIterator { 1305 public: row_reference()1306 RowReference row_reference() const { 1307 return {const_cast<ThreadStateTable*>(table()), CurrentRowNumber()}; 1308 } 1309 1310 private: 1311 friend class ThreadStateTable; 1312 Iterator(ThreadStateTable * table,Table::Iterator iterator)1313 explicit Iterator(ThreadStateTable* table, Table::Iterator iterator) 1314 : ConstIterator(table, std::move(iterator)) {} 1315 }; 1316 1317 struct IdAndRow { 1318 Id id; 1319 uint32_t row; 1320 RowReference row_reference; 1321 RowNumber row_number; 1322 }; 1323 GetColumns(ThreadStateTable * self,const macros_internal::MacroTable * parent)1324 static std::vector<ColumnLegacy> GetColumns( 1325 ThreadStateTable* self, 1326 const macros_internal::MacroTable* parent) { 1327 std::vector<ColumnLegacy> columns = 1328 CopyColumnsFromParentOrAddRootColumns(self, parent); 1329 uint32_t olay_idx = OverlayCount(parent); 1330 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1331 static_cast<uint32_t>(columns.size()), olay_idx); 1332 AddColumnToVector(columns, "dur", &self->dur_, ColumnFlag::dur, 1333 static_cast<uint32_t>(columns.size()), olay_idx); 1334 AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 1335 static_cast<uint32_t>(columns.size()), olay_idx); 1336 AddColumnToVector(columns, "state", &self->state_, ColumnFlag::state, 1337 static_cast<uint32_t>(columns.size()), olay_idx); 1338 AddColumnToVector(columns, "io_wait", &self->io_wait_, ColumnFlag::io_wait, 1339 static_cast<uint32_t>(columns.size()), olay_idx); 1340 AddColumnToVector(columns, "blocked_function", &self->blocked_function_, ColumnFlag::blocked_function, 1341 static_cast<uint32_t>(columns.size()), olay_idx); 1342 AddColumnToVector(columns, "waker_utid", &self->waker_utid_, ColumnFlag::waker_utid, 1343 static_cast<uint32_t>(columns.size()), olay_idx); 1344 AddColumnToVector(columns, "waker_id", &self->waker_id_, ColumnFlag::waker_id, 1345 static_cast<uint32_t>(columns.size()), olay_idx); 1346 AddColumnToVector(columns, "irq_context", &self->irq_context_, ColumnFlag::irq_context, 1347 static_cast<uint32_t>(columns.size()), olay_idx); 1348 AddColumnToVector(columns, "ucpu", &self->ucpu_, ColumnFlag::ucpu, 1349 static_cast<uint32_t>(columns.size()), olay_idx); 1350 return columns; 1351 } 1352 ThreadStateTable(StringPool * pool)1353 PERFETTO_NO_INLINE explicit ThreadStateTable(StringPool* pool) 1354 : macros_internal::MacroTable( 1355 pool, 1356 GetColumns(this, nullptr), 1357 nullptr), 1358 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 1359 dur_(ColumnStorage<ColumnType::dur::stored_type>::Create<false>()), 1360 utid_(ColumnStorage<ColumnType::utid::stored_type>::Create<false>()), 1361 state_(ColumnStorage<ColumnType::state::stored_type>::Create<false>()), 1362 io_wait_(ColumnStorage<ColumnType::io_wait::stored_type>::Create<false>()), 1363 blocked_function_(ColumnStorage<ColumnType::blocked_function::stored_type>::Create<false>()), 1364 waker_utid_(ColumnStorage<ColumnType::waker_utid::stored_type>::Create<false>()), 1365 waker_id_(ColumnStorage<ColumnType::waker_id::stored_type>::Create<false>()), 1366 irq_context_(ColumnStorage<ColumnType::irq_context::stored_type>::Create<false>()), 1367 ucpu_(ColumnStorage<ColumnType::ucpu::stored_type>::Create<false>()) 1368 , 1369 id_storage_layer_(new column::IdStorage()), 1370 type_storage_layer_( 1371 new column::StringStorage(string_pool(), &type_.vector())), 1372 ts_storage_layer_( 1373 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 1374 &ts_.vector(), 1375 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 1376 true)), 1377 dur_storage_layer_( 1378 new column::NumericStorage<ColumnType::dur::non_optional_stored_type>( 1379 &dur_.vector(), 1380 ColumnTypeHelper<ColumnType::dur::stored_type>::ToColumnType(), 1381 false)), 1382 utid_storage_layer_( 1383 new column::NumericStorage<ColumnType::utid::non_optional_stored_type>( 1384 &utid_.vector(), 1385 ColumnTypeHelper<ColumnType::utid::stored_type>::ToColumnType(), 1386 false)), 1387 state_storage_layer_( 1388 new column::StringStorage(string_pool(), &state_.vector())), 1389 io_wait_storage_layer_( 1390 new column::NumericStorage<ColumnType::io_wait::non_optional_stored_type>( 1391 &io_wait_.non_null_vector(), 1392 ColumnTypeHelper<ColumnType::io_wait::stored_type>::ToColumnType(), 1393 false)), 1394 blocked_function_storage_layer_( 1395 new column::StringStorage(string_pool(), &blocked_function_.vector())), 1396 waker_utid_storage_layer_( 1397 new column::NumericStorage<ColumnType::waker_utid::non_optional_stored_type>( 1398 &waker_utid_.non_null_vector(), 1399 ColumnTypeHelper<ColumnType::waker_utid::stored_type>::ToColumnType(), 1400 false)), 1401 waker_id_storage_layer_( 1402 new column::NumericStorage<ColumnType::waker_id::non_optional_stored_type>( 1403 &waker_id_.non_null_vector(), 1404 ColumnTypeHelper<ColumnType::waker_id::stored_type>::ToColumnType(), 1405 false)), 1406 irq_context_storage_layer_( 1407 new column::NumericStorage<ColumnType::irq_context::non_optional_stored_type>( 1408 &irq_context_.non_null_vector(), 1409 ColumnTypeHelper<ColumnType::irq_context::stored_type>::ToColumnType(), 1410 false)), 1411 ucpu_storage_layer_( 1412 new column::NumericStorage<ColumnType::ucpu::non_optional_stored_type>( 1413 &ucpu_.non_null_vector(), 1414 ColumnTypeHelper<ColumnType::ucpu::stored_type>::ToColumnType(), 1415 false)) 1416 , 1417 io_wait_null_layer_(new column::NullOverlay(io_wait_.bv())), 1418 waker_utid_null_layer_(new column::NullOverlay(waker_utid_.bv())), 1419 waker_id_null_layer_(new column::NullOverlay(waker_id_.bv())), 1420 irq_context_null_layer_(new column::NullOverlay(irq_context_.bv())), 1421 ucpu_null_layer_(new column::NullOverlay(ucpu_.bv())) { 1422 static_assert( 1423 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 1424 ColumnFlag::ts), 1425 "Column type and flag combination is not valid"); 1426 static_assert( 1427 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::dur::stored_type>( 1428 ColumnFlag::dur), 1429 "Column type and flag combination is not valid"); 1430 static_assert( 1431 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::utid::stored_type>( 1432 ColumnFlag::utid), 1433 "Column type and flag combination is not valid"); 1434 static_assert( 1435 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::state::stored_type>( 1436 ColumnFlag::state), 1437 "Column type and flag combination is not valid"); 1438 static_assert( 1439 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::io_wait::stored_type>( 1440 ColumnFlag::io_wait), 1441 "Column type and flag combination is not valid"); 1442 static_assert( 1443 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::blocked_function::stored_type>( 1444 ColumnFlag::blocked_function), 1445 "Column type and flag combination is not valid"); 1446 static_assert( 1447 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::waker_utid::stored_type>( 1448 ColumnFlag::waker_utid), 1449 "Column type and flag combination is not valid"); 1450 static_assert( 1451 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::waker_id::stored_type>( 1452 ColumnFlag::waker_id), 1453 "Column type and flag combination is not valid"); 1454 static_assert( 1455 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::irq_context::stored_type>( 1456 ColumnFlag::irq_context), 1457 "Column type and flag combination is not valid"); 1458 static_assert( 1459 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ucpu::stored_type>( 1460 ColumnFlag::ucpu), 1461 "Column type and flag combination is not valid"); 1462 OnConstructionCompletedRegularConstructor( 1463 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,dur_storage_layer_,utid_storage_layer_,state_storage_layer_,io_wait_storage_layer_,blocked_function_storage_layer_,waker_utid_storage_layer_,waker_id_storage_layer_,irq_context_storage_layer_,ucpu_storage_layer_}, 1464 {{},{},{},{},{},{},io_wait_null_layer_,{},waker_utid_null_layer_,waker_id_null_layer_,irq_context_null_layer_,ucpu_null_layer_}); 1465 } 1466 ~ThreadStateTable() override; 1467 Name()1468 static const char* Name() { return "__intrinsic_thread_state"; } 1469 ComputeStaticSchema()1470 static Table::Schema ComputeStaticSchema() { 1471 Table::Schema schema; 1472 schema.columns.emplace_back(Table::Schema::Column{ 1473 "id", SqlValue::Type::kLong, true, true, false, false}); 1474 schema.columns.emplace_back(Table::Schema::Column{ 1475 "type", SqlValue::Type::kString, false, false, false, false}); 1476 schema.columns.emplace_back(Table::Schema::Column{ 1477 "ts", ColumnType::ts::SqlValueType(), false, 1478 true, 1479 false, 1480 false}); 1481 schema.columns.emplace_back(Table::Schema::Column{ 1482 "dur", ColumnType::dur::SqlValueType(), false, 1483 false, 1484 false, 1485 false}); 1486 schema.columns.emplace_back(Table::Schema::Column{ 1487 "utid", ColumnType::utid::SqlValueType(), false, 1488 false, 1489 false, 1490 false}); 1491 schema.columns.emplace_back(Table::Schema::Column{ 1492 "state", ColumnType::state::SqlValueType(), false, 1493 false, 1494 false, 1495 false}); 1496 schema.columns.emplace_back(Table::Schema::Column{ 1497 "io_wait", ColumnType::io_wait::SqlValueType(), false, 1498 false, 1499 false, 1500 false}); 1501 schema.columns.emplace_back(Table::Schema::Column{ 1502 "blocked_function", ColumnType::blocked_function::SqlValueType(), false, 1503 false, 1504 false, 1505 false}); 1506 schema.columns.emplace_back(Table::Schema::Column{ 1507 "waker_utid", ColumnType::waker_utid::SqlValueType(), false, 1508 false, 1509 false, 1510 false}); 1511 schema.columns.emplace_back(Table::Schema::Column{ 1512 "waker_id", ColumnType::waker_id::SqlValueType(), false, 1513 false, 1514 false, 1515 false}); 1516 schema.columns.emplace_back(Table::Schema::Column{ 1517 "irq_context", ColumnType::irq_context::SqlValueType(), false, 1518 false, 1519 false, 1520 false}); 1521 schema.columns.emplace_back(Table::Schema::Column{ 1522 "ucpu", ColumnType::ucpu::SqlValueType(), false, 1523 false, 1524 false, 1525 false}); 1526 return schema; 1527 } 1528 IterateRows()1529 ConstIterator IterateRows() const { 1530 return ConstIterator(this, Table::IterateRows()); 1531 } 1532 IterateRows()1533 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 1534 FilterToIterator(const Query & q)1535 ConstIterator FilterToIterator(const Query& q) const { 1536 return ConstIterator(this, QueryToIterator(q)); 1537 } 1538 FilterToIterator(const Query & q)1539 Iterator FilterToIterator(const Query& q) { 1540 return Iterator(this, QueryToIterator(q)); 1541 } 1542 ShrinkToFit()1543 void ShrinkToFit() { 1544 type_.ShrinkToFit(); 1545 ts_.ShrinkToFit(); 1546 dur_.ShrinkToFit(); 1547 utid_.ShrinkToFit(); 1548 state_.ShrinkToFit(); 1549 io_wait_.ShrinkToFit(); 1550 blocked_function_.ShrinkToFit(); 1551 waker_utid_.ShrinkToFit(); 1552 waker_id_.ShrinkToFit(); 1553 irq_context_.ShrinkToFit(); 1554 ucpu_.ShrinkToFit(); 1555 } 1556 1557 ConstRowReference operator[](uint32_t r) const { 1558 return ConstRowReference(this, r); 1559 } 1560 RowReference operator[](uint32_t r) { return RowReference(this, r); } 1561 ConstRowReference operator[](RowNumber r) const { 1562 return ConstRowReference(this, r.row_number()); 1563 } 1564 RowReference operator[](RowNumber r) { 1565 return RowReference(this, r.row_number()); 1566 } 1567 FindById(Id find_id)1568 std::optional<ConstRowReference> FindById(Id find_id) const { 1569 std::optional<uint32_t> row = id().IndexOf(find_id); 1570 return row ? std::make_optional(ConstRowReference(this, *row)) 1571 : std::nullopt; 1572 } 1573 FindById(Id find_id)1574 std::optional<RowReference> FindById(Id find_id) { 1575 std::optional<uint32_t> row = id().IndexOf(find_id); 1576 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 1577 } 1578 Insert(const Row & row)1579 IdAndRow Insert(const Row& row) { 1580 uint32_t row_number = row_count(); 1581 Id id = Id{row_number}; 1582 type_.Append(string_pool()->InternString(row.type())); 1583 mutable_ts()->Append(row.ts); 1584 mutable_dur()->Append(row.dur); 1585 mutable_utid()->Append(row.utid); 1586 mutable_state()->Append(row.state); 1587 mutable_io_wait()->Append(row.io_wait); 1588 mutable_blocked_function()->Append(row.blocked_function); 1589 mutable_waker_utid()->Append(row.waker_utid); 1590 mutable_waker_id()->Append(row.waker_id); 1591 mutable_irq_context()->Append(row.irq_context); 1592 mutable_ucpu()->Append(row.ucpu); 1593 UpdateSelfOverlayAfterInsert(); 1594 return IdAndRow{id, row_number, RowReference(this, row_number), 1595 RowNumber(row_number)}; 1596 } 1597 1598 1599 id()1600 const IdColumn<ThreadStateTable::Id>& id() const { 1601 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 1602 } type()1603 const TypedColumn<StringPool::Id>& type() const { 1604 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 1605 } ts()1606 const TypedColumn<int64_t>& ts() const { 1607 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 1608 } dur()1609 const TypedColumn<int64_t>& dur() const { 1610 return static_cast<const ColumnType::dur&>(columns()[ColumnIndex::dur]); 1611 } utid()1612 const TypedColumn<uint32_t>& utid() const { 1613 return static_cast<const ColumnType::utid&>(columns()[ColumnIndex::utid]); 1614 } state()1615 const TypedColumn<StringPool::Id>& state() const { 1616 return static_cast<const ColumnType::state&>(columns()[ColumnIndex::state]); 1617 } io_wait()1618 const TypedColumn<std::optional<uint32_t>>& io_wait() const { 1619 return static_cast<const ColumnType::io_wait&>(columns()[ColumnIndex::io_wait]); 1620 } blocked_function()1621 const TypedColumn<std::optional<StringPool::Id>>& blocked_function() const { 1622 return static_cast<const ColumnType::blocked_function&>(columns()[ColumnIndex::blocked_function]); 1623 } waker_utid()1624 const TypedColumn<std::optional<uint32_t>>& waker_utid() const { 1625 return static_cast<const ColumnType::waker_utid&>(columns()[ColumnIndex::waker_utid]); 1626 } waker_id()1627 const TypedColumn<std::optional<ThreadStateTable::Id>>& waker_id() const { 1628 return static_cast<const ColumnType::waker_id&>(columns()[ColumnIndex::waker_id]); 1629 } irq_context()1630 const TypedColumn<std::optional<uint32_t>>& irq_context() const { 1631 return static_cast<const ColumnType::irq_context&>(columns()[ColumnIndex::irq_context]); 1632 } ucpu()1633 const TypedColumn<std::optional<CpuTable::Id>>& ucpu() const { 1634 return static_cast<const ColumnType::ucpu&>(columns()[ColumnIndex::ucpu]); 1635 } 1636 mutable_ts()1637 TypedColumn<int64_t>* mutable_ts() { 1638 return static_cast<ColumnType::ts*>( 1639 GetColumn(ColumnIndex::ts)); 1640 } mutable_dur()1641 TypedColumn<int64_t>* mutable_dur() { 1642 return static_cast<ColumnType::dur*>( 1643 GetColumn(ColumnIndex::dur)); 1644 } mutable_utid()1645 TypedColumn<uint32_t>* mutable_utid() { 1646 return static_cast<ColumnType::utid*>( 1647 GetColumn(ColumnIndex::utid)); 1648 } mutable_state()1649 TypedColumn<StringPool::Id>* mutable_state() { 1650 return static_cast<ColumnType::state*>( 1651 GetColumn(ColumnIndex::state)); 1652 } mutable_io_wait()1653 TypedColumn<std::optional<uint32_t>>* mutable_io_wait() { 1654 return static_cast<ColumnType::io_wait*>( 1655 GetColumn(ColumnIndex::io_wait)); 1656 } mutable_blocked_function()1657 TypedColumn<std::optional<StringPool::Id>>* mutable_blocked_function() { 1658 return static_cast<ColumnType::blocked_function*>( 1659 GetColumn(ColumnIndex::blocked_function)); 1660 } mutable_waker_utid()1661 TypedColumn<std::optional<uint32_t>>* mutable_waker_utid() { 1662 return static_cast<ColumnType::waker_utid*>( 1663 GetColumn(ColumnIndex::waker_utid)); 1664 } mutable_waker_id()1665 TypedColumn<std::optional<ThreadStateTable::Id>>* mutable_waker_id() { 1666 return static_cast<ColumnType::waker_id*>( 1667 GetColumn(ColumnIndex::waker_id)); 1668 } mutable_irq_context()1669 TypedColumn<std::optional<uint32_t>>* mutable_irq_context() { 1670 return static_cast<ColumnType::irq_context*>( 1671 GetColumn(ColumnIndex::irq_context)); 1672 } mutable_ucpu()1673 TypedColumn<std::optional<CpuTable::Id>>* mutable_ucpu() { 1674 return static_cast<ColumnType::ucpu*>( 1675 GetColumn(ColumnIndex::ucpu)); 1676 } 1677 1678 private: 1679 1680 1681 ColumnStorage<ColumnType::ts::stored_type> ts_; 1682 ColumnStorage<ColumnType::dur::stored_type> dur_; 1683 ColumnStorage<ColumnType::utid::stored_type> utid_; 1684 ColumnStorage<ColumnType::state::stored_type> state_; 1685 ColumnStorage<ColumnType::io_wait::stored_type> io_wait_; 1686 ColumnStorage<ColumnType::blocked_function::stored_type> blocked_function_; 1687 ColumnStorage<ColumnType::waker_utid::stored_type> waker_utid_; 1688 ColumnStorage<ColumnType::waker_id::stored_type> waker_id_; 1689 ColumnStorage<ColumnType::irq_context::stored_type> irq_context_; 1690 ColumnStorage<ColumnType::ucpu::stored_type> ucpu_; 1691 1692 RefPtr<column::StorageLayer> id_storage_layer_; 1693 RefPtr<column::StorageLayer> type_storage_layer_; 1694 RefPtr<column::StorageLayer> ts_storage_layer_; 1695 RefPtr<column::StorageLayer> dur_storage_layer_; 1696 RefPtr<column::StorageLayer> utid_storage_layer_; 1697 RefPtr<column::StorageLayer> state_storage_layer_; 1698 RefPtr<column::StorageLayer> io_wait_storage_layer_; 1699 RefPtr<column::StorageLayer> blocked_function_storage_layer_; 1700 RefPtr<column::StorageLayer> waker_utid_storage_layer_; 1701 RefPtr<column::StorageLayer> waker_id_storage_layer_; 1702 RefPtr<column::StorageLayer> irq_context_storage_layer_; 1703 RefPtr<column::StorageLayer> ucpu_storage_layer_; 1704 1705 RefPtr<column::OverlayLayer> io_wait_null_layer_; 1706 RefPtr<column::OverlayLayer> waker_utid_null_layer_; 1707 RefPtr<column::OverlayLayer> waker_id_null_layer_; 1708 RefPtr<column::OverlayLayer> irq_context_null_layer_; 1709 RefPtr<column::OverlayLayer> ucpu_null_layer_; 1710 }; 1711 1712 } // namespace perfetto 1713 1714 #endif // SRC_TRACE_PROCESSOR_TABLES_SCHED_TABLES_PY_H_ 1715