1 #ifndef SRC_TRACE_PROCESSOR_TABLES_METADATA_TABLES_PY_H_ 2 #define SRC_TRACE_PROCESSOR_TABLES_METADATA_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 38 39 namespace perfetto::trace_processor::tables { 40 41 class MachineTable : public macros_internal::MacroTable { 42 public: 43 static constexpr uint32_t kColumnCount = 3; 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 raw_id = 2; 56 }; 57 struct ColumnType { 58 using id = IdColumn<MachineTable::Id>; 59 using type = TypedColumn<StringPool::Id>; 60 using raw_id = TypedColumn<uint32_t>; 61 }; 62 struct Row : public macros_internal::RootParentTable::Row { 63 Row(uint32_t in_raw_id = {}, 64 std::nullptr_t = nullptr) RowRow65 : macros_internal::RootParentTable::Row(), 66 raw_id(in_raw_id) { 67 type_ = "machine"; 68 } 69 uint32_t raw_id; 70 71 bool operator==(const MachineTable::Row& other) const { 72 return type() == other.type() && ColumnType::raw_id::Equals(raw_id, other.raw_id); 73 } 74 }; 75 struct ColumnFlag { 76 static constexpr uint32_t raw_id = ColumnType::raw_id::default_flags(); 77 }; 78 79 class RowNumber; 80 class ConstRowReference; 81 class RowReference; 82 83 class RowNumber : public macros_internal::AbstractRowNumber< 84 MachineTable, ConstRowReference, RowReference> { 85 public: RowNumber(uint32_t row_number)86 explicit RowNumber(uint32_t row_number) 87 : AbstractRowNumber(row_number) {} 88 }; 89 static_assert(std::is_trivially_destructible_v<RowNumber>, 90 "Inheritance used without trivial destruction"); 91 92 class ConstRowReference : public macros_internal::AbstractConstRowReference< 93 MachineTable, RowNumber> { 94 public: ConstRowReference(const MachineTable * table,uint32_t row_number)95 ConstRowReference(const MachineTable* table, uint32_t row_number) 96 : AbstractConstRowReference(table, row_number) {} 97 id()98 ColumnType::id::type id() const { 99 return table()->id()[row_number_]; 100 } type()101 ColumnType::type::type type() const { 102 return table()->type()[row_number_]; 103 } raw_id()104 ColumnType::raw_id::type raw_id() const { 105 return table()->raw_id()[row_number_]; 106 } 107 }; 108 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 109 "Inheritance used without trivial destruction"); 110 class RowReference : public ConstRowReference { 111 public: RowReference(const MachineTable * table,uint32_t row_number)112 RowReference(const MachineTable* table, uint32_t row_number) 113 : ConstRowReference(table, row_number) {} 114 set_raw_id(ColumnType::raw_id::non_optional_type v)115 void set_raw_id( 116 ColumnType::raw_id::non_optional_type v) { 117 return mutable_table()->mutable_raw_id()->Set(row_number_, v); 118 } 119 120 private: mutable_table()121 MachineTable* mutable_table() const { 122 return const_cast<MachineTable*>(table()); 123 } 124 }; 125 static_assert(std::is_trivially_destructible_v<RowReference>, 126 "Inheritance used without trivial destruction"); 127 128 class ConstIterator; 129 class ConstIterator : public macros_internal::AbstractConstIterator< 130 ConstIterator, MachineTable, RowNumber, ConstRowReference> { 131 public: id()132 ColumnType::id::type id() const { 133 const auto& col = table()->id(); 134 return col.GetAtIdx( 135 iterator_.StorageIndexForColumn(col.index_in_table())); 136 } type()137 ColumnType::type::type type() const { 138 const auto& col = table()->type(); 139 return col.GetAtIdx( 140 iterator_.StorageIndexForColumn(col.index_in_table())); 141 } raw_id()142 ColumnType::raw_id::type raw_id() const { 143 const auto& col = table()->raw_id(); 144 return col.GetAtIdx( 145 iterator_.StorageIndexForColumn(col.index_in_table())); 146 } 147 148 protected: ConstIterator(const MachineTable * table,Table::Iterator iterator)149 explicit ConstIterator(const MachineTable* table, 150 Table::Iterator iterator) 151 : AbstractConstIterator(table, std::move(iterator)) {} 152 CurrentRowNumber()153 uint32_t CurrentRowNumber() const { 154 return iterator_.StorageIndexForLastOverlay(); 155 } 156 157 private: 158 friend class MachineTable; 159 friend class macros_internal::AbstractConstIterator< 160 ConstIterator, MachineTable, RowNumber, ConstRowReference>; 161 }; 162 class Iterator : public ConstIterator { 163 public: row_reference()164 RowReference row_reference() const { 165 return {const_cast<MachineTable*>(table()), CurrentRowNumber()}; 166 } 167 168 private: 169 friend class MachineTable; 170 Iterator(MachineTable * table,Table::Iterator iterator)171 explicit Iterator(MachineTable* table, Table::Iterator iterator) 172 : ConstIterator(table, std::move(iterator)) {} 173 }; 174 175 struct IdAndRow { 176 Id id; 177 uint32_t row; 178 RowReference row_reference; 179 RowNumber row_number; 180 }; 181 GetColumns(MachineTable * self,const macros_internal::MacroTable * parent)182 static std::vector<ColumnLegacy> GetColumns( 183 MachineTable* self, 184 const macros_internal::MacroTable* parent) { 185 std::vector<ColumnLegacy> columns = 186 CopyColumnsFromParentOrAddRootColumns(self, parent); 187 uint32_t olay_idx = OverlayCount(parent); 188 AddColumnToVector(columns, "raw_id", &self->raw_id_, ColumnFlag::raw_id, 189 static_cast<uint32_t>(columns.size()), olay_idx); 190 return columns; 191 } 192 MachineTable(StringPool * pool)193 PERFETTO_NO_INLINE explicit MachineTable(StringPool* pool) 194 : macros_internal::MacroTable( 195 pool, 196 GetColumns(this, nullptr), 197 nullptr), 198 raw_id_(ColumnStorage<ColumnType::raw_id::stored_type>::Create<false>()) 199 , 200 id_storage_layer_(new column::IdStorage()), 201 type_storage_layer_( 202 new column::StringStorage(string_pool(), &type_.vector())), 203 raw_id_storage_layer_( 204 new column::NumericStorage<ColumnType::raw_id::non_optional_stored_type>( 205 &raw_id_.vector(), 206 ColumnTypeHelper<ColumnType::raw_id::stored_type>::ToColumnType(), 207 false)) 208 { 209 static_assert( 210 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::raw_id::stored_type>( 211 ColumnFlag::raw_id), 212 "Column type and flag combination is not valid"); 213 OnConstructionCompletedRegularConstructor( 214 {id_storage_layer_,type_storage_layer_,raw_id_storage_layer_}, 215 {{},{},{}}); 216 } 217 ~MachineTable() override; 218 Name()219 static const char* Name() { return "machine"; } 220 ComputeStaticSchema()221 static Table::Schema ComputeStaticSchema() { 222 Table::Schema schema; 223 schema.columns.emplace_back(Table::Schema::Column{ 224 "id", SqlValue::Type::kLong, true, true, false, false}); 225 schema.columns.emplace_back(Table::Schema::Column{ 226 "type", SqlValue::Type::kString, false, false, false, false}); 227 schema.columns.emplace_back(Table::Schema::Column{ 228 "raw_id", ColumnType::raw_id::SqlValueType(), false, 229 false, 230 false, 231 false}); 232 return schema; 233 } 234 IterateRows()235 ConstIterator IterateRows() const { 236 return ConstIterator(this, Table::IterateRows()); 237 } 238 IterateRows()239 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 240 FilterToIterator(const Query & q)241 ConstIterator FilterToIterator(const Query& q) const { 242 return ConstIterator(this, QueryToIterator(q)); 243 } 244 FilterToIterator(const Query & q)245 Iterator FilterToIterator(const Query& q) { 246 return Iterator(this, QueryToIterator(q)); 247 } 248 ShrinkToFit()249 void ShrinkToFit() { 250 type_.ShrinkToFit(); 251 raw_id_.ShrinkToFit(); 252 } 253 254 ConstRowReference operator[](uint32_t r) const { 255 return ConstRowReference(this, r); 256 } 257 RowReference operator[](uint32_t r) { return RowReference(this, r); } 258 ConstRowReference operator[](RowNumber r) const { 259 return ConstRowReference(this, r.row_number()); 260 } 261 RowReference operator[](RowNumber r) { 262 return RowReference(this, r.row_number()); 263 } 264 FindById(Id find_id)265 std::optional<ConstRowReference> FindById(Id find_id) const { 266 std::optional<uint32_t> row = id().IndexOf(find_id); 267 return row ? std::make_optional(ConstRowReference(this, *row)) 268 : std::nullopt; 269 } 270 FindById(Id find_id)271 std::optional<RowReference> FindById(Id find_id) { 272 std::optional<uint32_t> row = id().IndexOf(find_id); 273 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 274 } 275 Insert(const Row & row)276 IdAndRow Insert(const Row& row) { 277 uint32_t row_number = row_count(); 278 Id id = Id{row_number}; 279 type_.Append(string_pool()->InternString(row.type())); 280 mutable_raw_id()->Append(row.raw_id); 281 UpdateSelfOverlayAfterInsert(); 282 return IdAndRow{id, row_number, RowReference(this, row_number), 283 RowNumber(row_number)}; 284 } 285 286 287 id()288 const IdColumn<MachineTable::Id>& id() const { 289 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 290 } type()291 const TypedColumn<StringPool::Id>& type() const { 292 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 293 } raw_id()294 const TypedColumn<uint32_t>& raw_id() const { 295 return static_cast<const ColumnType::raw_id&>(columns()[ColumnIndex::raw_id]); 296 } 297 mutable_raw_id()298 TypedColumn<uint32_t>* mutable_raw_id() { 299 return static_cast<ColumnType::raw_id*>( 300 GetColumn(ColumnIndex::raw_id)); 301 } 302 303 private: 304 305 306 ColumnStorage<ColumnType::raw_id::stored_type> raw_id_; 307 308 RefPtr<column::StorageLayer> id_storage_layer_; 309 RefPtr<column::StorageLayer> type_storage_layer_; 310 RefPtr<column::StorageLayer> raw_id_storage_layer_; 311 312 313 }; 314 315 316 class ProcessTable : public macros_internal::MacroTable { 317 public: 318 static constexpr uint32_t kColumnCount = 12; 319 320 struct Id : public BaseId { 321 Id() = default; IdId322 explicit constexpr Id(uint32_t v) : BaseId(v) {} 323 }; 324 static_assert(std::is_trivially_destructible_v<Id>, 325 "Inheritance used without trivial destruction"); 326 327 struct ColumnIndex { 328 static constexpr uint32_t id = 0; 329 static constexpr uint32_t type = 1; 330 static constexpr uint32_t pid = 2; 331 static constexpr uint32_t name = 3; 332 static constexpr uint32_t start_ts = 4; 333 static constexpr uint32_t end_ts = 5; 334 static constexpr uint32_t parent_upid = 6; 335 static constexpr uint32_t uid = 7; 336 static constexpr uint32_t android_appid = 8; 337 static constexpr uint32_t cmdline = 9; 338 static constexpr uint32_t arg_set_id = 10; 339 static constexpr uint32_t machine_id = 11; 340 }; 341 struct ColumnType { 342 using id = IdColumn<ProcessTable::Id>; 343 using type = TypedColumn<StringPool::Id>; 344 using pid = TypedColumn<uint32_t>; 345 using name = TypedColumn<std::optional<StringPool::Id>>; 346 using start_ts = TypedColumn<std::optional<int64_t>>; 347 using end_ts = TypedColumn<std::optional<int64_t>>; 348 using parent_upid = TypedColumn<std::optional<uint32_t>>; 349 using uid = TypedColumn<std::optional<uint32_t>>; 350 using android_appid = TypedColumn<std::optional<uint32_t>>; 351 using cmdline = TypedColumn<std::optional<StringPool::Id>>; 352 using arg_set_id = TypedColumn<uint32_t>; 353 using machine_id = TypedColumn<std::optional<MachineTable::Id>>; 354 }; 355 struct Row : public macros_internal::RootParentTable::Row { 356 Row(uint32_t in_pid = {}, 357 std::optional<StringPool::Id> in_name = {}, 358 std::optional<int64_t> in_start_ts = {}, 359 std::optional<int64_t> in_end_ts = {}, 360 std::optional<uint32_t> in_parent_upid = {}, 361 std::optional<uint32_t> in_uid = {}, 362 std::optional<uint32_t> in_android_appid = {}, 363 std::optional<StringPool::Id> in_cmdline = {}, 364 uint32_t in_arg_set_id = {}, 365 std::optional<MachineTable::Id> in_machine_id = {}, 366 std::nullptr_t = nullptr) RowRow367 : macros_internal::RootParentTable::Row(), 368 pid(in_pid), 369 name(in_name), 370 start_ts(in_start_ts), 371 end_ts(in_end_ts), 372 parent_upid(in_parent_upid), 373 uid(in_uid), 374 android_appid(in_android_appid), 375 cmdline(in_cmdline), 376 arg_set_id(in_arg_set_id), 377 machine_id(in_machine_id) { 378 type_ = "__intrinsic_process"; 379 } 380 uint32_t pid; 381 std::optional<StringPool::Id> name; 382 std::optional<int64_t> start_ts; 383 std::optional<int64_t> end_ts; 384 std::optional<uint32_t> parent_upid; 385 std::optional<uint32_t> uid; 386 std::optional<uint32_t> android_appid; 387 std::optional<StringPool::Id> cmdline; 388 uint32_t arg_set_id; 389 std::optional<MachineTable::Id> machine_id; 390 391 bool operator==(const ProcessTable::Row& other) const { 392 return type() == other.type() && ColumnType::pid::Equals(pid, other.pid) && 393 ColumnType::name::Equals(name, other.name) && 394 ColumnType::start_ts::Equals(start_ts, other.start_ts) && 395 ColumnType::end_ts::Equals(end_ts, other.end_ts) && 396 ColumnType::parent_upid::Equals(parent_upid, other.parent_upid) && 397 ColumnType::uid::Equals(uid, other.uid) && 398 ColumnType::android_appid::Equals(android_appid, other.android_appid) && 399 ColumnType::cmdline::Equals(cmdline, other.cmdline) && 400 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 401 ColumnType::machine_id::Equals(machine_id, other.machine_id); 402 } 403 }; 404 struct ColumnFlag { 405 static constexpr uint32_t pid = ColumnType::pid::default_flags(); 406 static constexpr uint32_t name = ColumnType::name::default_flags(); 407 static constexpr uint32_t start_ts = ColumnType::start_ts::default_flags(); 408 static constexpr uint32_t end_ts = ColumnType::end_ts::default_flags(); 409 static constexpr uint32_t parent_upid = ColumnType::parent_upid::default_flags(); 410 static constexpr uint32_t uid = ColumnType::uid::default_flags(); 411 static constexpr uint32_t android_appid = ColumnType::android_appid::default_flags(); 412 static constexpr uint32_t cmdline = ColumnType::cmdline::default_flags(); 413 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 414 static constexpr uint32_t machine_id = ColumnType::machine_id::default_flags(); 415 }; 416 417 class RowNumber; 418 class ConstRowReference; 419 class RowReference; 420 421 class RowNumber : public macros_internal::AbstractRowNumber< 422 ProcessTable, ConstRowReference, RowReference> { 423 public: RowNumber(uint32_t row_number)424 explicit RowNumber(uint32_t row_number) 425 : AbstractRowNumber(row_number) {} 426 }; 427 static_assert(std::is_trivially_destructible_v<RowNumber>, 428 "Inheritance used without trivial destruction"); 429 430 class ConstRowReference : public macros_internal::AbstractConstRowReference< 431 ProcessTable, RowNumber> { 432 public: ConstRowReference(const ProcessTable * table,uint32_t row_number)433 ConstRowReference(const ProcessTable* table, uint32_t row_number) 434 : AbstractConstRowReference(table, row_number) {} 435 id()436 ColumnType::id::type id() const { 437 return table()->id()[row_number_]; 438 } type()439 ColumnType::type::type type() const { 440 return table()->type()[row_number_]; 441 } pid()442 ColumnType::pid::type pid() const { 443 return table()->pid()[row_number_]; 444 } name()445 ColumnType::name::type name() const { 446 return table()->name()[row_number_]; 447 } start_ts()448 ColumnType::start_ts::type start_ts() const { 449 return table()->start_ts()[row_number_]; 450 } end_ts()451 ColumnType::end_ts::type end_ts() const { 452 return table()->end_ts()[row_number_]; 453 } parent_upid()454 ColumnType::parent_upid::type parent_upid() const { 455 return table()->parent_upid()[row_number_]; 456 } uid()457 ColumnType::uid::type uid() const { 458 return table()->uid()[row_number_]; 459 } android_appid()460 ColumnType::android_appid::type android_appid() const { 461 return table()->android_appid()[row_number_]; 462 } cmdline()463 ColumnType::cmdline::type cmdline() const { 464 return table()->cmdline()[row_number_]; 465 } arg_set_id()466 ColumnType::arg_set_id::type arg_set_id() const { 467 return table()->arg_set_id()[row_number_]; 468 } machine_id()469 ColumnType::machine_id::type machine_id() const { 470 return table()->machine_id()[row_number_]; 471 } 472 }; 473 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 474 "Inheritance used without trivial destruction"); 475 class RowReference : public ConstRowReference { 476 public: RowReference(const ProcessTable * table,uint32_t row_number)477 RowReference(const ProcessTable* table, uint32_t row_number) 478 : ConstRowReference(table, row_number) {} 479 set_pid(ColumnType::pid::non_optional_type v)480 void set_pid( 481 ColumnType::pid::non_optional_type v) { 482 return mutable_table()->mutable_pid()->Set(row_number_, v); 483 } set_name(ColumnType::name::non_optional_type v)484 void set_name( 485 ColumnType::name::non_optional_type v) { 486 return mutable_table()->mutable_name()->Set(row_number_, v); 487 } set_start_ts(ColumnType::start_ts::non_optional_type v)488 void set_start_ts( 489 ColumnType::start_ts::non_optional_type v) { 490 return mutable_table()->mutable_start_ts()->Set(row_number_, v); 491 } set_end_ts(ColumnType::end_ts::non_optional_type v)492 void set_end_ts( 493 ColumnType::end_ts::non_optional_type v) { 494 return mutable_table()->mutable_end_ts()->Set(row_number_, v); 495 } set_parent_upid(ColumnType::parent_upid::non_optional_type v)496 void set_parent_upid( 497 ColumnType::parent_upid::non_optional_type v) { 498 return mutable_table()->mutable_parent_upid()->Set(row_number_, v); 499 } set_uid(ColumnType::uid::non_optional_type v)500 void set_uid( 501 ColumnType::uid::non_optional_type v) { 502 return mutable_table()->mutable_uid()->Set(row_number_, v); 503 } set_android_appid(ColumnType::android_appid::non_optional_type v)504 void set_android_appid( 505 ColumnType::android_appid::non_optional_type v) { 506 return mutable_table()->mutable_android_appid()->Set(row_number_, v); 507 } set_cmdline(ColumnType::cmdline::non_optional_type v)508 void set_cmdline( 509 ColumnType::cmdline::non_optional_type v) { 510 return mutable_table()->mutable_cmdline()->Set(row_number_, v); 511 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)512 void set_arg_set_id( 513 ColumnType::arg_set_id::non_optional_type v) { 514 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 515 } set_machine_id(ColumnType::machine_id::non_optional_type v)516 void set_machine_id( 517 ColumnType::machine_id::non_optional_type v) { 518 return mutable_table()->mutable_machine_id()->Set(row_number_, v); 519 } 520 521 private: mutable_table()522 ProcessTable* mutable_table() const { 523 return const_cast<ProcessTable*>(table()); 524 } 525 }; 526 static_assert(std::is_trivially_destructible_v<RowReference>, 527 "Inheritance used without trivial destruction"); 528 529 class ConstIterator; 530 class ConstIterator : public macros_internal::AbstractConstIterator< 531 ConstIterator, ProcessTable, RowNumber, ConstRowReference> { 532 public: id()533 ColumnType::id::type id() const { 534 const auto& col = table()->id(); 535 return col.GetAtIdx( 536 iterator_.StorageIndexForColumn(col.index_in_table())); 537 } type()538 ColumnType::type::type type() const { 539 const auto& col = table()->type(); 540 return col.GetAtIdx( 541 iterator_.StorageIndexForColumn(col.index_in_table())); 542 } pid()543 ColumnType::pid::type pid() const { 544 const auto& col = table()->pid(); 545 return col.GetAtIdx( 546 iterator_.StorageIndexForColumn(col.index_in_table())); 547 } name()548 ColumnType::name::type name() const { 549 const auto& col = table()->name(); 550 return col.GetAtIdx( 551 iterator_.StorageIndexForColumn(col.index_in_table())); 552 } start_ts()553 ColumnType::start_ts::type start_ts() const { 554 const auto& col = table()->start_ts(); 555 return col.GetAtIdx( 556 iterator_.StorageIndexForColumn(col.index_in_table())); 557 } end_ts()558 ColumnType::end_ts::type end_ts() const { 559 const auto& col = table()->end_ts(); 560 return col.GetAtIdx( 561 iterator_.StorageIndexForColumn(col.index_in_table())); 562 } parent_upid()563 ColumnType::parent_upid::type parent_upid() const { 564 const auto& col = table()->parent_upid(); 565 return col.GetAtIdx( 566 iterator_.StorageIndexForColumn(col.index_in_table())); 567 } uid()568 ColumnType::uid::type uid() const { 569 const auto& col = table()->uid(); 570 return col.GetAtIdx( 571 iterator_.StorageIndexForColumn(col.index_in_table())); 572 } android_appid()573 ColumnType::android_appid::type android_appid() const { 574 const auto& col = table()->android_appid(); 575 return col.GetAtIdx( 576 iterator_.StorageIndexForColumn(col.index_in_table())); 577 } cmdline()578 ColumnType::cmdline::type cmdline() const { 579 const auto& col = table()->cmdline(); 580 return col.GetAtIdx( 581 iterator_.StorageIndexForColumn(col.index_in_table())); 582 } arg_set_id()583 ColumnType::arg_set_id::type arg_set_id() const { 584 const auto& col = table()->arg_set_id(); 585 return col.GetAtIdx( 586 iterator_.StorageIndexForColumn(col.index_in_table())); 587 } machine_id()588 ColumnType::machine_id::type machine_id() const { 589 const auto& col = table()->machine_id(); 590 return col.GetAtIdx( 591 iterator_.StorageIndexForColumn(col.index_in_table())); 592 } 593 594 protected: ConstIterator(const ProcessTable * table,Table::Iterator iterator)595 explicit ConstIterator(const ProcessTable* table, 596 Table::Iterator iterator) 597 : AbstractConstIterator(table, std::move(iterator)) {} 598 CurrentRowNumber()599 uint32_t CurrentRowNumber() const { 600 return iterator_.StorageIndexForLastOverlay(); 601 } 602 603 private: 604 friend class ProcessTable; 605 friend class macros_internal::AbstractConstIterator< 606 ConstIterator, ProcessTable, RowNumber, ConstRowReference>; 607 }; 608 class Iterator : public ConstIterator { 609 public: row_reference()610 RowReference row_reference() const { 611 return {const_cast<ProcessTable*>(table()), CurrentRowNumber()}; 612 } 613 614 private: 615 friend class ProcessTable; 616 Iterator(ProcessTable * table,Table::Iterator iterator)617 explicit Iterator(ProcessTable* table, Table::Iterator iterator) 618 : ConstIterator(table, std::move(iterator)) {} 619 }; 620 621 struct IdAndRow { 622 Id id; 623 uint32_t row; 624 RowReference row_reference; 625 RowNumber row_number; 626 }; 627 GetColumns(ProcessTable * self,const macros_internal::MacroTable * parent)628 static std::vector<ColumnLegacy> GetColumns( 629 ProcessTable* self, 630 const macros_internal::MacroTable* parent) { 631 std::vector<ColumnLegacy> columns = 632 CopyColumnsFromParentOrAddRootColumns(self, parent); 633 uint32_t olay_idx = OverlayCount(parent); 634 AddColumnToVector(columns, "pid", &self->pid_, ColumnFlag::pid, 635 static_cast<uint32_t>(columns.size()), olay_idx); 636 AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 637 static_cast<uint32_t>(columns.size()), olay_idx); 638 AddColumnToVector(columns, "start_ts", &self->start_ts_, ColumnFlag::start_ts, 639 static_cast<uint32_t>(columns.size()), olay_idx); 640 AddColumnToVector(columns, "end_ts", &self->end_ts_, ColumnFlag::end_ts, 641 static_cast<uint32_t>(columns.size()), olay_idx); 642 AddColumnToVector(columns, "parent_upid", &self->parent_upid_, ColumnFlag::parent_upid, 643 static_cast<uint32_t>(columns.size()), olay_idx); 644 AddColumnToVector(columns, "uid", &self->uid_, ColumnFlag::uid, 645 static_cast<uint32_t>(columns.size()), olay_idx); 646 AddColumnToVector(columns, "android_appid", &self->android_appid_, ColumnFlag::android_appid, 647 static_cast<uint32_t>(columns.size()), olay_idx); 648 AddColumnToVector(columns, "cmdline", &self->cmdline_, ColumnFlag::cmdline, 649 static_cast<uint32_t>(columns.size()), olay_idx); 650 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 651 static_cast<uint32_t>(columns.size()), olay_idx); 652 AddColumnToVector(columns, "machine_id", &self->machine_id_, ColumnFlag::machine_id, 653 static_cast<uint32_t>(columns.size()), olay_idx); 654 return columns; 655 } 656 ProcessTable(StringPool * pool)657 PERFETTO_NO_INLINE explicit ProcessTable(StringPool* pool) 658 : macros_internal::MacroTable( 659 pool, 660 GetColumns(this, nullptr), 661 nullptr), 662 pid_(ColumnStorage<ColumnType::pid::stored_type>::Create<false>()), 663 name_(ColumnStorage<ColumnType::name::stored_type>::Create<false>()), 664 start_ts_(ColumnStorage<ColumnType::start_ts::stored_type>::Create<false>()), 665 end_ts_(ColumnStorage<ColumnType::end_ts::stored_type>::Create<false>()), 666 parent_upid_(ColumnStorage<ColumnType::parent_upid::stored_type>::Create<false>()), 667 uid_(ColumnStorage<ColumnType::uid::stored_type>::Create<false>()), 668 android_appid_(ColumnStorage<ColumnType::android_appid::stored_type>::Create<false>()), 669 cmdline_(ColumnStorage<ColumnType::cmdline::stored_type>::Create<false>()), 670 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 671 machine_id_(ColumnStorage<ColumnType::machine_id::stored_type>::Create<false>()) 672 , 673 id_storage_layer_(new column::IdStorage()), 674 type_storage_layer_( 675 new column::StringStorage(string_pool(), &type_.vector())), 676 pid_storage_layer_( 677 new column::NumericStorage<ColumnType::pid::non_optional_stored_type>( 678 &pid_.vector(), 679 ColumnTypeHelper<ColumnType::pid::stored_type>::ToColumnType(), 680 false)), 681 name_storage_layer_( 682 new column::StringStorage(string_pool(), &name_.vector())), 683 start_ts_storage_layer_( 684 new column::NumericStorage<ColumnType::start_ts::non_optional_stored_type>( 685 &start_ts_.non_null_vector(), 686 ColumnTypeHelper<ColumnType::start_ts::stored_type>::ToColumnType(), 687 false)), 688 end_ts_storage_layer_( 689 new column::NumericStorage<ColumnType::end_ts::non_optional_stored_type>( 690 &end_ts_.non_null_vector(), 691 ColumnTypeHelper<ColumnType::end_ts::stored_type>::ToColumnType(), 692 false)), 693 parent_upid_storage_layer_( 694 new column::NumericStorage<ColumnType::parent_upid::non_optional_stored_type>( 695 &parent_upid_.non_null_vector(), 696 ColumnTypeHelper<ColumnType::parent_upid::stored_type>::ToColumnType(), 697 false)), 698 uid_storage_layer_( 699 new column::NumericStorage<ColumnType::uid::non_optional_stored_type>( 700 &uid_.non_null_vector(), 701 ColumnTypeHelper<ColumnType::uid::stored_type>::ToColumnType(), 702 false)), 703 android_appid_storage_layer_( 704 new column::NumericStorage<ColumnType::android_appid::non_optional_stored_type>( 705 &android_appid_.non_null_vector(), 706 ColumnTypeHelper<ColumnType::android_appid::stored_type>::ToColumnType(), 707 false)), 708 cmdline_storage_layer_( 709 new column::StringStorage(string_pool(), &cmdline_.vector())), 710 arg_set_id_storage_layer_( 711 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 712 &arg_set_id_.vector(), 713 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 714 false)), 715 machine_id_storage_layer_( 716 new column::NumericStorage<ColumnType::machine_id::non_optional_stored_type>( 717 &machine_id_.non_null_vector(), 718 ColumnTypeHelper<ColumnType::machine_id::stored_type>::ToColumnType(), 719 false)) 720 , 721 start_ts_null_layer_(new column::NullOverlay(start_ts_.bv())), 722 end_ts_null_layer_(new column::NullOverlay(end_ts_.bv())), 723 parent_upid_null_layer_(new column::NullOverlay(parent_upid_.bv())), 724 uid_null_layer_(new column::NullOverlay(uid_.bv())), 725 android_appid_null_layer_(new column::NullOverlay(android_appid_.bv())), 726 machine_id_null_layer_(new column::NullOverlay(machine_id_.bv())) { 727 static_assert( 728 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::pid::stored_type>( 729 ColumnFlag::pid), 730 "Column type and flag combination is not valid"); 731 static_assert( 732 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::name::stored_type>( 733 ColumnFlag::name), 734 "Column type and flag combination is not valid"); 735 static_assert( 736 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::start_ts::stored_type>( 737 ColumnFlag::start_ts), 738 "Column type and flag combination is not valid"); 739 static_assert( 740 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::end_ts::stored_type>( 741 ColumnFlag::end_ts), 742 "Column type and flag combination is not valid"); 743 static_assert( 744 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::parent_upid::stored_type>( 745 ColumnFlag::parent_upid), 746 "Column type and flag combination is not valid"); 747 static_assert( 748 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::uid::stored_type>( 749 ColumnFlag::uid), 750 "Column type and flag combination is not valid"); 751 static_assert( 752 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::android_appid::stored_type>( 753 ColumnFlag::android_appid), 754 "Column type and flag combination is not valid"); 755 static_assert( 756 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::cmdline::stored_type>( 757 ColumnFlag::cmdline), 758 "Column type and flag combination is not valid"); 759 static_assert( 760 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 761 ColumnFlag::arg_set_id), 762 "Column type and flag combination is not valid"); 763 static_assert( 764 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::machine_id::stored_type>( 765 ColumnFlag::machine_id), 766 "Column type and flag combination is not valid"); 767 OnConstructionCompletedRegularConstructor( 768 {id_storage_layer_,type_storage_layer_,pid_storage_layer_,name_storage_layer_,start_ts_storage_layer_,end_ts_storage_layer_,parent_upid_storage_layer_,uid_storage_layer_,android_appid_storage_layer_,cmdline_storage_layer_,arg_set_id_storage_layer_,machine_id_storage_layer_}, 769 {{},{},{},{},start_ts_null_layer_,end_ts_null_layer_,parent_upid_null_layer_,uid_null_layer_,android_appid_null_layer_,{},{},machine_id_null_layer_}); 770 } 771 ~ProcessTable() override; 772 Name()773 static const char* Name() { return "__intrinsic_process"; } 774 ComputeStaticSchema()775 static Table::Schema ComputeStaticSchema() { 776 Table::Schema schema; 777 schema.columns.emplace_back(Table::Schema::Column{ 778 "id", SqlValue::Type::kLong, true, true, false, false}); 779 schema.columns.emplace_back(Table::Schema::Column{ 780 "type", SqlValue::Type::kString, false, false, false, false}); 781 schema.columns.emplace_back(Table::Schema::Column{ 782 "pid", ColumnType::pid::SqlValueType(), false, 783 false, 784 false, 785 false}); 786 schema.columns.emplace_back(Table::Schema::Column{ 787 "name", ColumnType::name::SqlValueType(), false, 788 false, 789 false, 790 false}); 791 schema.columns.emplace_back(Table::Schema::Column{ 792 "start_ts", ColumnType::start_ts::SqlValueType(), false, 793 false, 794 false, 795 false}); 796 schema.columns.emplace_back(Table::Schema::Column{ 797 "end_ts", ColumnType::end_ts::SqlValueType(), false, 798 false, 799 false, 800 false}); 801 schema.columns.emplace_back(Table::Schema::Column{ 802 "parent_upid", ColumnType::parent_upid::SqlValueType(), false, 803 false, 804 false, 805 false}); 806 schema.columns.emplace_back(Table::Schema::Column{ 807 "uid", ColumnType::uid::SqlValueType(), false, 808 false, 809 false, 810 false}); 811 schema.columns.emplace_back(Table::Schema::Column{ 812 "android_appid", ColumnType::android_appid::SqlValueType(), false, 813 false, 814 false, 815 false}); 816 schema.columns.emplace_back(Table::Schema::Column{ 817 "cmdline", ColumnType::cmdline::SqlValueType(), false, 818 false, 819 false, 820 false}); 821 schema.columns.emplace_back(Table::Schema::Column{ 822 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 823 false, 824 false, 825 false}); 826 schema.columns.emplace_back(Table::Schema::Column{ 827 "machine_id", ColumnType::machine_id::SqlValueType(), false, 828 false, 829 false, 830 false}); 831 return schema; 832 } 833 IterateRows()834 ConstIterator IterateRows() const { 835 return ConstIterator(this, Table::IterateRows()); 836 } 837 IterateRows()838 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 839 FilterToIterator(const Query & q)840 ConstIterator FilterToIterator(const Query& q) const { 841 return ConstIterator(this, QueryToIterator(q)); 842 } 843 FilterToIterator(const Query & q)844 Iterator FilterToIterator(const Query& q) { 845 return Iterator(this, QueryToIterator(q)); 846 } 847 ShrinkToFit()848 void ShrinkToFit() { 849 type_.ShrinkToFit(); 850 pid_.ShrinkToFit(); 851 name_.ShrinkToFit(); 852 start_ts_.ShrinkToFit(); 853 end_ts_.ShrinkToFit(); 854 parent_upid_.ShrinkToFit(); 855 uid_.ShrinkToFit(); 856 android_appid_.ShrinkToFit(); 857 cmdline_.ShrinkToFit(); 858 arg_set_id_.ShrinkToFit(); 859 machine_id_.ShrinkToFit(); 860 } 861 862 ConstRowReference operator[](uint32_t r) const { 863 return ConstRowReference(this, r); 864 } 865 RowReference operator[](uint32_t r) { return RowReference(this, r); } 866 ConstRowReference operator[](RowNumber r) const { 867 return ConstRowReference(this, r.row_number()); 868 } 869 RowReference operator[](RowNumber r) { 870 return RowReference(this, r.row_number()); 871 } 872 FindById(Id find_id)873 std::optional<ConstRowReference> FindById(Id find_id) const { 874 std::optional<uint32_t> row = id().IndexOf(find_id); 875 return row ? std::make_optional(ConstRowReference(this, *row)) 876 : std::nullopt; 877 } 878 FindById(Id find_id)879 std::optional<RowReference> FindById(Id find_id) { 880 std::optional<uint32_t> row = id().IndexOf(find_id); 881 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 882 } 883 Insert(const Row & row)884 IdAndRow Insert(const Row& row) { 885 uint32_t row_number = row_count(); 886 Id id = Id{row_number}; 887 type_.Append(string_pool()->InternString(row.type())); 888 mutable_pid()->Append(row.pid); 889 mutable_name()->Append(row.name); 890 mutable_start_ts()->Append(row.start_ts); 891 mutable_end_ts()->Append(row.end_ts); 892 mutable_parent_upid()->Append(row.parent_upid); 893 mutable_uid()->Append(row.uid); 894 mutable_android_appid()->Append(row.android_appid); 895 mutable_cmdline()->Append(row.cmdline); 896 mutable_arg_set_id()->Append(row.arg_set_id); 897 mutable_machine_id()->Append(row.machine_id); 898 UpdateSelfOverlayAfterInsert(); 899 return IdAndRow{id, row_number, RowReference(this, row_number), 900 RowNumber(row_number)}; 901 } 902 903 904 id()905 const IdColumn<ProcessTable::Id>& id() const { 906 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 907 } type()908 const TypedColumn<StringPool::Id>& type() const { 909 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 910 } pid()911 const TypedColumn<uint32_t>& pid() const { 912 return static_cast<const ColumnType::pid&>(columns()[ColumnIndex::pid]); 913 } name()914 const TypedColumn<std::optional<StringPool::Id>>& name() const { 915 return static_cast<const ColumnType::name&>(columns()[ColumnIndex::name]); 916 } start_ts()917 const TypedColumn<std::optional<int64_t>>& start_ts() const { 918 return static_cast<const ColumnType::start_ts&>(columns()[ColumnIndex::start_ts]); 919 } end_ts()920 const TypedColumn<std::optional<int64_t>>& end_ts() const { 921 return static_cast<const ColumnType::end_ts&>(columns()[ColumnIndex::end_ts]); 922 } parent_upid()923 const TypedColumn<std::optional<uint32_t>>& parent_upid() const { 924 return static_cast<const ColumnType::parent_upid&>(columns()[ColumnIndex::parent_upid]); 925 } uid()926 const TypedColumn<std::optional<uint32_t>>& uid() const { 927 return static_cast<const ColumnType::uid&>(columns()[ColumnIndex::uid]); 928 } android_appid()929 const TypedColumn<std::optional<uint32_t>>& android_appid() const { 930 return static_cast<const ColumnType::android_appid&>(columns()[ColumnIndex::android_appid]); 931 } cmdline()932 const TypedColumn<std::optional<StringPool::Id>>& cmdline() const { 933 return static_cast<const ColumnType::cmdline&>(columns()[ColumnIndex::cmdline]); 934 } arg_set_id()935 const TypedColumn<uint32_t>& arg_set_id() const { 936 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 937 } machine_id()938 const TypedColumn<std::optional<MachineTable::Id>>& machine_id() const { 939 return static_cast<const ColumnType::machine_id&>(columns()[ColumnIndex::machine_id]); 940 } 941 mutable_pid()942 TypedColumn<uint32_t>* mutable_pid() { 943 return static_cast<ColumnType::pid*>( 944 GetColumn(ColumnIndex::pid)); 945 } mutable_name()946 TypedColumn<std::optional<StringPool::Id>>* mutable_name() { 947 return static_cast<ColumnType::name*>( 948 GetColumn(ColumnIndex::name)); 949 } mutable_start_ts()950 TypedColumn<std::optional<int64_t>>* mutable_start_ts() { 951 return static_cast<ColumnType::start_ts*>( 952 GetColumn(ColumnIndex::start_ts)); 953 } mutable_end_ts()954 TypedColumn<std::optional<int64_t>>* mutable_end_ts() { 955 return static_cast<ColumnType::end_ts*>( 956 GetColumn(ColumnIndex::end_ts)); 957 } mutable_parent_upid()958 TypedColumn<std::optional<uint32_t>>* mutable_parent_upid() { 959 return static_cast<ColumnType::parent_upid*>( 960 GetColumn(ColumnIndex::parent_upid)); 961 } mutable_uid()962 TypedColumn<std::optional<uint32_t>>* mutable_uid() { 963 return static_cast<ColumnType::uid*>( 964 GetColumn(ColumnIndex::uid)); 965 } mutable_android_appid()966 TypedColumn<std::optional<uint32_t>>* mutable_android_appid() { 967 return static_cast<ColumnType::android_appid*>( 968 GetColumn(ColumnIndex::android_appid)); 969 } mutable_cmdline()970 TypedColumn<std::optional<StringPool::Id>>* mutable_cmdline() { 971 return static_cast<ColumnType::cmdline*>( 972 GetColumn(ColumnIndex::cmdline)); 973 } mutable_arg_set_id()974 TypedColumn<uint32_t>* mutable_arg_set_id() { 975 return static_cast<ColumnType::arg_set_id*>( 976 GetColumn(ColumnIndex::arg_set_id)); 977 } mutable_machine_id()978 TypedColumn<std::optional<MachineTable::Id>>* mutable_machine_id() { 979 return static_cast<ColumnType::machine_id*>( 980 GetColumn(ColumnIndex::machine_id)); 981 } 982 983 private: 984 985 986 ColumnStorage<ColumnType::pid::stored_type> pid_; 987 ColumnStorage<ColumnType::name::stored_type> name_; 988 ColumnStorage<ColumnType::start_ts::stored_type> start_ts_; 989 ColumnStorage<ColumnType::end_ts::stored_type> end_ts_; 990 ColumnStorage<ColumnType::parent_upid::stored_type> parent_upid_; 991 ColumnStorage<ColumnType::uid::stored_type> uid_; 992 ColumnStorage<ColumnType::android_appid::stored_type> android_appid_; 993 ColumnStorage<ColumnType::cmdline::stored_type> cmdline_; 994 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 995 ColumnStorage<ColumnType::machine_id::stored_type> machine_id_; 996 997 RefPtr<column::StorageLayer> id_storage_layer_; 998 RefPtr<column::StorageLayer> type_storage_layer_; 999 RefPtr<column::StorageLayer> pid_storage_layer_; 1000 RefPtr<column::StorageLayer> name_storage_layer_; 1001 RefPtr<column::StorageLayer> start_ts_storage_layer_; 1002 RefPtr<column::StorageLayer> end_ts_storage_layer_; 1003 RefPtr<column::StorageLayer> parent_upid_storage_layer_; 1004 RefPtr<column::StorageLayer> uid_storage_layer_; 1005 RefPtr<column::StorageLayer> android_appid_storage_layer_; 1006 RefPtr<column::StorageLayer> cmdline_storage_layer_; 1007 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 1008 RefPtr<column::StorageLayer> machine_id_storage_layer_; 1009 1010 RefPtr<column::OverlayLayer> start_ts_null_layer_; 1011 RefPtr<column::OverlayLayer> end_ts_null_layer_; 1012 RefPtr<column::OverlayLayer> parent_upid_null_layer_; 1013 RefPtr<column::OverlayLayer> uid_null_layer_; 1014 RefPtr<column::OverlayLayer> android_appid_null_layer_; 1015 RefPtr<column::OverlayLayer> machine_id_null_layer_; 1016 }; 1017 1018 1019 class ThreadTable : public macros_internal::MacroTable { 1020 public: 1021 static constexpr uint32_t kColumnCount = 9; 1022 1023 struct Id : public BaseId { 1024 Id() = default; IdId1025 explicit constexpr Id(uint32_t v) : BaseId(v) {} 1026 }; 1027 static_assert(std::is_trivially_destructible_v<Id>, 1028 "Inheritance used without trivial destruction"); 1029 1030 struct ColumnIndex { 1031 static constexpr uint32_t id = 0; 1032 static constexpr uint32_t type = 1; 1033 static constexpr uint32_t tid = 2; 1034 static constexpr uint32_t name = 3; 1035 static constexpr uint32_t start_ts = 4; 1036 static constexpr uint32_t end_ts = 5; 1037 static constexpr uint32_t upid = 6; 1038 static constexpr uint32_t is_main_thread = 7; 1039 static constexpr uint32_t machine_id = 8; 1040 }; 1041 struct ColumnType { 1042 using id = IdColumn<ThreadTable::Id>; 1043 using type = TypedColumn<StringPool::Id>; 1044 using tid = TypedColumn<uint32_t>; 1045 using name = TypedColumn<std::optional<StringPool::Id>>; 1046 using start_ts = TypedColumn<std::optional<int64_t>>; 1047 using end_ts = TypedColumn<std::optional<int64_t>>; 1048 using upid = TypedColumn<std::optional<uint32_t>>; 1049 using is_main_thread = TypedColumn<std::optional<uint32_t>>; 1050 using machine_id = TypedColumn<std::optional<MachineTable::Id>>; 1051 }; 1052 struct Row : public macros_internal::RootParentTable::Row { 1053 Row(uint32_t in_tid = {}, 1054 std::optional<StringPool::Id> in_name = {}, 1055 std::optional<int64_t> in_start_ts = {}, 1056 std::optional<int64_t> in_end_ts = {}, 1057 std::optional<uint32_t> in_upid = {}, 1058 std::optional<uint32_t> in_is_main_thread = {}, 1059 std::optional<MachineTable::Id> in_machine_id = {}, 1060 std::nullptr_t = nullptr) RowRow1061 : macros_internal::RootParentTable::Row(), 1062 tid(in_tid), 1063 name(in_name), 1064 start_ts(in_start_ts), 1065 end_ts(in_end_ts), 1066 upid(in_upid), 1067 is_main_thread(in_is_main_thread), 1068 machine_id(in_machine_id) { 1069 type_ = "__intrinsic_thread"; 1070 } 1071 uint32_t tid; 1072 std::optional<StringPool::Id> name; 1073 std::optional<int64_t> start_ts; 1074 std::optional<int64_t> end_ts; 1075 std::optional<uint32_t> upid; 1076 std::optional<uint32_t> is_main_thread; 1077 std::optional<MachineTable::Id> machine_id; 1078 1079 bool operator==(const ThreadTable::Row& other) const { 1080 return type() == other.type() && ColumnType::tid::Equals(tid, other.tid) && 1081 ColumnType::name::Equals(name, other.name) && 1082 ColumnType::start_ts::Equals(start_ts, other.start_ts) && 1083 ColumnType::end_ts::Equals(end_ts, other.end_ts) && 1084 ColumnType::upid::Equals(upid, other.upid) && 1085 ColumnType::is_main_thread::Equals(is_main_thread, other.is_main_thread) && 1086 ColumnType::machine_id::Equals(machine_id, other.machine_id); 1087 } 1088 }; 1089 struct ColumnFlag { 1090 static constexpr uint32_t tid = ColumnType::tid::default_flags(); 1091 static constexpr uint32_t name = ColumnType::name::default_flags(); 1092 static constexpr uint32_t start_ts = ColumnType::start_ts::default_flags(); 1093 static constexpr uint32_t end_ts = ColumnType::end_ts::default_flags(); 1094 static constexpr uint32_t upid = ColumnType::upid::default_flags(); 1095 static constexpr uint32_t is_main_thread = ColumnType::is_main_thread::default_flags(); 1096 static constexpr uint32_t machine_id = ColumnType::machine_id::default_flags(); 1097 }; 1098 1099 class RowNumber; 1100 class ConstRowReference; 1101 class RowReference; 1102 1103 class RowNumber : public macros_internal::AbstractRowNumber< 1104 ThreadTable, ConstRowReference, RowReference> { 1105 public: RowNumber(uint32_t row_number)1106 explicit RowNumber(uint32_t row_number) 1107 : AbstractRowNumber(row_number) {} 1108 }; 1109 static_assert(std::is_trivially_destructible_v<RowNumber>, 1110 "Inheritance used without trivial destruction"); 1111 1112 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1113 ThreadTable, RowNumber> { 1114 public: ConstRowReference(const ThreadTable * table,uint32_t row_number)1115 ConstRowReference(const ThreadTable* table, uint32_t row_number) 1116 : AbstractConstRowReference(table, row_number) {} 1117 id()1118 ColumnType::id::type id() const { 1119 return table()->id()[row_number_]; 1120 } type()1121 ColumnType::type::type type() const { 1122 return table()->type()[row_number_]; 1123 } tid()1124 ColumnType::tid::type tid() const { 1125 return table()->tid()[row_number_]; 1126 } name()1127 ColumnType::name::type name() const { 1128 return table()->name()[row_number_]; 1129 } start_ts()1130 ColumnType::start_ts::type start_ts() const { 1131 return table()->start_ts()[row_number_]; 1132 } end_ts()1133 ColumnType::end_ts::type end_ts() const { 1134 return table()->end_ts()[row_number_]; 1135 } upid()1136 ColumnType::upid::type upid() const { 1137 return table()->upid()[row_number_]; 1138 } is_main_thread()1139 ColumnType::is_main_thread::type is_main_thread() const { 1140 return table()->is_main_thread()[row_number_]; 1141 } machine_id()1142 ColumnType::machine_id::type machine_id() const { 1143 return table()->machine_id()[row_number_]; 1144 } 1145 }; 1146 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1147 "Inheritance used without trivial destruction"); 1148 class RowReference : public ConstRowReference { 1149 public: RowReference(const ThreadTable * table,uint32_t row_number)1150 RowReference(const ThreadTable* table, uint32_t row_number) 1151 : ConstRowReference(table, row_number) {} 1152 set_tid(ColumnType::tid::non_optional_type v)1153 void set_tid( 1154 ColumnType::tid::non_optional_type v) { 1155 return mutable_table()->mutable_tid()->Set(row_number_, v); 1156 } set_name(ColumnType::name::non_optional_type v)1157 void set_name( 1158 ColumnType::name::non_optional_type v) { 1159 return mutable_table()->mutable_name()->Set(row_number_, v); 1160 } set_start_ts(ColumnType::start_ts::non_optional_type v)1161 void set_start_ts( 1162 ColumnType::start_ts::non_optional_type v) { 1163 return mutable_table()->mutable_start_ts()->Set(row_number_, v); 1164 } set_end_ts(ColumnType::end_ts::non_optional_type v)1165 void set_end_ts( 1166 ColumnType::end_ts::non_optional_type v) { 1167 return mutable_table()->mutable_end_ts()->Set(row_number_, v); 1168 } set_upid(ColumnType::upid::non_optional_type v)1169 void set_upid( 1170 ColumnType::upid::non_optional_type v) { 1171 return mutable_table()->mutable_upid()->Set(row_number_, v); 1172 } set_is_main_thread(ColumnType::is_main_thread::non_optional_type v)1173 void set_is_main_thread( 1174 ColumnType::is_main_thread::non_optional_type v) { 1175 return mutable_table()->mutable_is_main_thread()->Set(row_number_, v); 1176 } set_machine_id(ColumnType::machine_id::non_optional_type v)1177 void set_machine_id( 1178 ColumnType::machine_id::non_optional_type v) { 1179 return mutable_table()->mutable_machine_id()->Set(row_number_, v); 1180 } 1181 1182 private: mutable_table()1183 ThreadTable* mutable_table() const { 1184 return const_cast<ThreadTable*>(table()); 1185 } 1186 }; 1187 static_assert(std::is_trivially_destructible_v<RowReference>, 1188 "Inheritance used without trivial destruction"); 1189 1190 class ConstIterator; 1191 class ConstIterator : public macros_internal::AbstractConstIterator< 1192 ConstIterator, ThreadTable, RowNumber, ConstRowReference> { 1193 public: id()1194 ColumnType::id::type id() const { 1195 const auto& col = table()->id(); 1196 return col.GetAtIdx( 1197 iterator_.StorageIndexForColumn(col.index_in_table())); 1198 } type()1199 ColumnType::type::type type() const { 1200 const auto& col = table()->type(); 1201 return col.GetAtIdx( 1202 iterator_.StorageIndexForColumn(col.index_in_table())); 1203 } tid()1204 ColumnType::tid::type tid() const { 1205 const auto& col = table()->tid(); 1206 return col.GetAtIdx( 1207 iterator_.StorageIndexForColumn(col.index_in_table())); 1208 } name()1209 ColumnType::name::type name() const { 1210 const auto& col = table()->name(); 1211 return col.GetAtIdx( 1212 iterator_.StorageIndexForColumn(col.index_in_table())); 1213 } start_ts()1214 ColumnType::start_ts::type start_ts() const { 1215 const auto& col = table()->start_ts(); 1216 return col.GetAtIdx( 1217 iterator_.StorageIndexForColumn(col.index_in_table())); 1218 } end_ts()1219 ColumnType::end_ts::type end_ts() const { 1220 const auto& col = table()->end_ts(); 1221 return col.GetAtIdx( 1222 iterator_.StorageIndexForColumn(col.index_in_table())); 1223 } upid()1224 ColumnType::upid::type upid() const { 1225 const auto& col = table()->upid(); 1226 return col.GetAtIdx( 1227 iterator_.StorageIndexForColumn(col.index_in_table())); 1228 } is_main_thread()1229 ColumnType::is_main_thread::type is_main_thread() const { 1230 const auto& col = table()->is_main_thread(); 1231 return col.GetAtIdx( 1232 iterator_.StorageIndexForColumn(col.index_in_table())); 1233 } machine_id()1234 ColumnType::machine_id::type machine_id() const { 1235 const auto& col = table()->machine_id(); 1236 return col.GetAtIdx( 1237 iterator_.StorageIndexForColumn(col.index_in_table())); 1238 } 1239 1240 protected: ConstIterator(const ThreadTable * table,Table::Iterator iterator)1241 explicit ConstIterator(const ThreadTable* table, 1242 Table::Iterator iterator) 1243 : AbstractConstIterator(table, std::move(iterator)) {} 1244 CurrentRowNumber()1245 uint32_t CurrentRowNumber() const { 1246 return iterator_.StorageIndexForLastOverlay(); 1247 } 1248 1249 private: 1250 friend class ThreadTable; 1251 friend class macros_internal::AbstractConstIterator< 1252 ConstIterator, ThreadTable, RowNumber, ConstRowReference>; 1253 }; 1254 class Iterator : public ConstIterator { 1255 public: row_reference()1256 RowReference row_reference() const { 1257 return {const_cast<ThreadTable*>(table()), CurrentRowNumber()}; 1258 } 1259 1260 private: 1261 friend class ThreadTable; 1262 Iterator(ThreadTable * table,Table::Iterator iterator)1263 explicit Iterator(ThreadTable* table, Table::Iterator iterator) 1264 : ConstIterator(table, std::move(iterator)) {} 1265 }; 1266 1267 struct IdAndRow { 1268 Id id; 1269 uint32_t row; 1270 RowReference row_reference; 1271 RowNumber row_number; 1272 }; 1273 GetColumns(ThreadTable * self,const macros_internal::MacroTable * parent)1274 static std::vector<ColumnLegacy> GetColumns( 1275 ThreadTable* self, 1276 const macros_internal::MacroTable* parent) { 1277 std::vector<ColumnLegacy> columns = 1278 CopyColumnsFromParentOrAddRootColumns(self, parent); 1279 uint32_t olay_idx = OverlayCount(parent); 1280 AddColumnToVector(columns, "tid", &self->tid_, ColumnFlag::tid, 1281 static_cast<uint32_t>(columns.size()), olay_idx); 1282 AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 1283 static_cast<uint32_t>(columns.size()), olay_idx); 1284 AddColumnToVector(columns, "start_ts", &self->start_ts_, ColumnFlag::start_ts, 1285 static_cast<uint32_t>(columns.size()), olay_idx); 1286 AddColumnToVector(columns, "end_ts", &self->end_ts_, ColumnFlag::end_ts, 1287 static_cast<uint32_t>(columns.size()), olay_idx); 1288 AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 1289 static_cast<uint32_t>(columns.size()), olay_idx); 1290 AddColumnToVector(columns, "is_main_thread", &self->is_main_thread_, ColumnFlag::is_main_thread, 1291 static_cast<uint32_t>(columns.size()), olay_idx); 1292 AddColumnToVector(columns, "machine_id", &self->machine_id_, ColumnFlag::machine_id, 1293 static_cast<uint32_t>(columns.size()), olay_idx); 1294 return columns; 1295 } 1296 ThreadTable(StringPool * pool)1297 PERFETTO_NO_INLINE explicit ThreadTable(StringPool* pool) 1298 : macros_internal::MacroTable( 1299 pool, 1300 GetColumns(this, nullptr), 1301 nullptr), 1302 tid_(ColumnStorage<ColumnType::tid::stored_type>::Create<false>()), 1303 name_(ColumnStorage<ColumnType::name::stored_type>::Create<false>()), 1304 start_ts_(ColumnStorage<ColumnType::start_ts::stored_type>::Create<false>()), 1305 end_ts_(ColumnStorage<ColumnType::end_ts::stored_type>::Create<false>()), 1306 upid_(ColumnStorage<ColumnType::upid::stored_type>::Create<false>()), 1307 is_main_thread_(ColumnStorage<ColumnType::is_main_thread::stored_type>::Create<false>()), 1308 machine_id_(ColumnStorage<ColumnType::machine_id::stored_type>::Create<false>()) 1309 , 1310 id_storage_layer_(new column::IdStorage()), 1311 type_storage_layer_( 1312 new column::StringStorage(string_pool(), &type_.vector())), 1313 tid_storage_layer_( 1314 new column::NumericStorage<ColumnType::tid::non_optional_stored_type>( 1315 &tid_.vector(), 1316 ColumnTypeHelper<ColumnType::tid::stored_type>::ToColumnType(), 1317 false)), 1318 name_storage_layer_( 1319 new column::StringStorage(string_pool(), &name_.vector())), 1320 start_ts_storage_layer_( 1321 new column::NumericStorage<ColumnType::start_ts::non_optional_stored_type>( 1322 &start_ts_.non_null_vector(), 1323 ColumnTypeHelper<ColumnType::start_ts::stored_type>::ToColumnType(), 1324 false)), 1325 end_ts_storage_layer_( 1326 new column::NumericStorage<ColumnType::end_ts::non_optional_stored_type>( 1327 &end_ts_.non_null_vector(), 1328 ColumnTypeHelper<ColumnType::end_ts::stored_type>::ToColumnType(), 1329 false)), 1330 upid_storage_layer_( 1331 new column::NumericStorage<ColumnType::upid::non_optional_stored_type>( 1332 &upid_.non_null_vector(), 1333 ColumnTypeHelper<ColumnType::upid::stored_type>::ToColumnType(), 1334 false)), 1335 is_main_thread_storage_layer_( 1336 new column::NumericStorage<ColumnType::is_main_thread::non_optional_stored_type>( 1337 &is_main_thread_.non_null_vector(), 1338 ColumnTypeHelper<ColumnType::is_main_thread::stored_type>::ToColumnType(), 1339 false)), 1340 machine_id_storage_layer_( 1341 new column::NumericStorage<ColumnType::machine_id::non_optional_stored_type>( 1342 &machine_id_.non_null_vector(), 1343 ColumnTypeHelper<ColumnType::machine_id::stored_type>::ToColumnType(), 1344 false)) 1345 , 1346 start_ts_null_layer_(new column::NullOverlay(start_ts_.bv())), 1347 end_ts_null_layer_(new column::NullOverlay(end_ts_.bv())), 1348 upid_null_layer_(new column::NullOverlay(upid_.bv())), 1349 is_main_thread_null_layer_(new column::NullOverlay(is_main_thread_.bv())), 1350 machine_id_null_layer_(new column::NullOverlay(machine_id_.bv())) { 1351 static_assert( 1352 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::tid::stored_type>( 1353 ColumnFlag::tid), 1354 "Column type and flag combination is not valid"); 1355 static_assert( 1356 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::name::stored_type>( 1357 ColumnFlag::name), 1358 "Column type and flag combination is not valid"); 1359 static_assert( 1360 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::start_ts::stored_type>( 1361 ColumnFlag::start_ts), 1362 "Column type and flag combination is not valid"); 1363 static_assert( 1364 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::end_ts::stored_type>( 1365 ColumnFlag::end_ts), 1366 "Column type and flag combination is not valid"); 1367 static_assert( 1368 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::upid::stored_type>( 1369 ColumnFlag::upid), 1370 "Column type and flag combination is not valid"); 1371 static_assert( 1372 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::is_main_thread::stored_type>( 1373 ColumnFlag::is_main_thread), 1374 "Column type and flag combination is not valid"); 1375 static_assert( 1376 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::machine_id::stored_type>( 1377 ColumnFlag::machine_id), 1378 "Column type and flag combination is not valid"); 1379 OnConstructionCompletedRegularConstructor( 1380 {id_storage_layer_,type_storage_layer_,tid_storage_layer_,name_storage_layer_,start_ts_storage_layer_,end_ts_storage_layer_,upid_storage_layer_,is_main_thread_storage_layer_,machine_id_storage_layer_}, 1381 {{},{},{},{},start_ts_null_layer_,end_ts_null_layer_,upid_null_layer_,is_main_thread_null_layer_,machine_id_null_layer_}); 1382 } 1383 ~ThreadTable() override; 1384 Name()1385 static const char* Name() { return "__intrinsic_thread"; } 1386 ComputeStaticSchema()1387 static Table::Schema ComputeStaticSchema() { 1388 Table::Schema schema; 1389 schema.columns.emplace_back(Table::Schema::Column{ 1390 "id", SqlValue::Type::kLong, true, true, false, false}); 1391 schema.columns.emplace_back(Table::Schema::Column{ 1392 "type", SqlValue::Type::kString, false, false, false, false}); 1393 schema.columns.emplace_back(Table::Schema::Column{ 1394 "tid", ColumnType::tid::SqlValueType(), false, 1395 false, 1396 false, 1397 false}); 1398 schema.columns.emplace_back(Table::Schema::Column{ 1399 "name", ColumnType::name::SqlValueType(), false, 1400 false, 1401 false, 1402 false}); 1403 schema.columns.emplace_back(Table::Schema::Column{ 1404 "start_ts", ColumnType::start_ts::SqlValueType(), false, 1405 false, 1406 false, 1407 false}); 1408 schema.columns.emplace_back(Table::Schema::Column{ 1409 "end_ts", ColumnType::end_ts::SqlValueType(), false, 1410 false, 1411 false, 1412 false}); 1413 schema.columns.emplace_back(Table::Schema::Column{ 1414 "upid", ColumnType::upid::SqlValueType(), false, 1415 false, 1416 false, 1417 false}); 1418 schema.columns.emplace_back(Table::Schema::Column{ 1419 "is_main_thread", ColumnType::is_main_thread::SqlValueType(), false, 1420 false, 1421 false, 1422 false}); 1423 schema.columns.emplace_back(Table::Schema::Column{ 1424 "machine_id", ColumnType::machine_id::SqlValueType(), false, 1425 false, 1426 false, 1427 false}); 1428 return schema; 1429 } 1430 IterateRows()1431 ConstIterator IterateRows() const { 1432 return ConstIterator(this, Table::IterateRows()); 1433 } 1434 IterateRows()1435 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 1436 FilterToIterator(const Query & q)1437 ConstIterator FilterToIterator(const Query& q) const { 1438 return ConstIterator(this, QueryToIterator(q)); 1439 } 1440 FilterToIterator(const Query & q)1441 Iterator FilterToIterator(const Query& q) { 1442 return Iterator(this, QueryToIterator(q)); 1443 } 1444 ShrinkToFit()1445 void ShrinkToFit() { 1446 type_.ShrinkToFit(); 1447 tid_.ShrinkToFit(); 1448 name_.ShrinkToFit(); 1449 start_ts_.ShrinkToFit(); 1450 end_ts_.ShrinkToFit(); 1451 upid_.ShrinkToFit(); 1452 is_main_thread_.ShrinkToFit(); 1453 machine_id_.ShrinkToFit(); 1454 } 1455 1456 ConstRowReference operator[](uint32_t r) const { 1457 return ConstRowReference(this, r); 1458 } 1459 RowReference operator[](uint32_t r) { return RowReference(this, r); } 1460 ConstRowReference operator[](RowNumber r) const { 1461 return ConstRowReference(this, r.row_number()); 1462 } 1463 RowReference operator[](RowNumber r) { 1464 return RowReference(this, r.row_number()); 1465 } 1466 FindById(Id find_id)1467 std::optional<ConstRowReference> FindById(Id find_id) const { 1468 std::optional<uint32_t> row = id().IndexOf(find_id); 1469 return row ? std::make_optional(ConstRowReference(this, *row)) 1470 : std::nullopt; 1471 } 1472 FindById(Id find_id)1473 std::optional<RowReference> FindById(Id find_id) { 1474 std::optional<uint32_t> row = id().IndexOf(find_id); 1475 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 1476 } 1477 Insert(const Row & row)1478 IdAndRow Insert(const Row& row) { 1479 uint32_t row_number = row_count(); 1480 Id id = Id{row_number}; 1481 type_.Append(string_pool()->InternString(row.type())); 1482 mutable_tid()->Append(row.tid); 1483 mutable_name()->Append(row.name); 1484 mutable_start_ts()->Append(row.start_ts); 1485 mutable_end_ts()->Append(row.end_ts); 1486 mutable_upid()->Append(row.upid); 1487 mutable_is_main_thread()->Append(row.is_main_thread); 1488 mutable_machine_id()->Append(row.machine_id); 1489 UpdateSelfOverlayAfterInsert(); 1490 return IdAndRow{id, row_number, RowReference(this, row_number), 1491 RowNumber(row_number)}; 1492 } 1493 1494 1495 id()1496 const IdColumn<ThreadTable::Id>& id() const { 1497 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 1498 } type()1499 const TypedColumn<StringPool::Id>& type() const { 1500 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 1501 } tid()1502 const TypedColumn<uint32_t>& tid() const { 1503 return static_cast<const ColumnType::tid&>(columns()[ColumnIndex::tid]); 1504 } name()1505 const TypedColumn<std::optional<StringPool::Id>>& name() const { 1506 return static_cast<const ColumnType::name&>(columns()[ColumnIndex::name]); 1507 } start_ts()1508 const TypedColumn<std::optional<int64_t>>& start_ts() const { 1509 return static_cast<const ColumnType::start_ts&>(columns()[ColumnIndex::start_ts]); 1510 } end_ts()1511 const TypedColumn<std::optional<int64_t>>& end_ts() const { 1512 return static_cast<const ColumnType::end_ts&>(columns()[ColumnIndex::end_ts]); 1513 } upid()1514 const TypedColumn<std::optional<uint32_t>>& upid() const { 1515 return static_cast<const ColumnType::upid&>(columns()[ColumnIndex::upid]); 1516 } is_main_thread()1517 const TypedColumn<std::optional<uint32_t>>& is_main_thread() const { 1518 return static_cast<const ColumnType::is_main_thread&>(columns()[ColumnIndex::is_main_thread]); 1519 } machine_id()1520 const TypedColumn<std::optional<MachineTable::Id>>& machine_id() const { 1521 return static_cast<const ColumnType::machine_id&>(columns()[ColumnIndex::machine_id]); 1522 } 1523 mutable_tid()1524 TypedColumn<uint32_t>* mutable_tid() { 1525 return static_cast<ColumnType::tid*>( 1526 GetColumn(ColumnIndex::tid)); 1527 } mutable_name()1528 TypedColumn<std::optional<StringPool::Id>>* mutable_name() { 1529 return static_cast<ColumnType::name*>( 1530 GetColumn(ColumnIndex::name)); 1531 } mutable_start_ts()1532 TypedColumn<std::optional<int64_t>>* mutable_start_ts() { 1533 return static_cast<ColumnType::start_ts*>( 1534 GetColumn(ColumnIndex::start_ts)); 1535 } mutable_end_ts()1536 TypedColumn<std::optional<int64_t>>* mutable_end_ts() { 1537 return static_cast<ColumnType::end_ts*>( 1538 GetColumn(ColumnIndex::end_ts)); 1539 } mutable_upid()1540 TypedColumn<std::optional<uint32_t>>* mutable_upid() { 1541 return static_cast<ColumnType::upid*>( 1542 GetColumn(ColumnIndex::upid)); 1543 } mutable_is_main_thread()1544 TypedColumn<std::optional<uint32_t>>* mutable_is_main_thread() { 1545 return static_cast<ColumnType::is_main_thread*>( 1546 GetColumn(ColumnIndex::is_main_thread)); 1547 } mutable_machine_id()1548 TypedColumn<std::optional<MachineTable::Id>>* mutable_machine_id() { 1549 return static_cast<ColumnType::machine_id*>( 1550 GetColumn(ColumnIndex::machine_id)); 1551 } 1552 1553 private: 1554 1555 1556 ColumnStorage<ColumnType::tid::stored_type> tid_; 1557 ColumnStorage<ColumnType::name::stored_type> name_; 1558 ColumnStorage<ColumnType::start_ts::stored_type> start_ts_; 1559 ColumnStorage<ColumnType::end_ts::stored_type> end_ts_; 1560 ColumnStorage<ColumnType::upid::stored_type> upid_; 1561 ColumnStorage<ColumnType::is_main_thread::stored_type> is_main_thread_; 1562 ColumnStorage<ColumnType::machine_id::stored_type> machine_id_; 1563 1564 RefPtr<column::StorageLayer> id_storage_layer_; 1565 RefPtr<column::StorageLayer> type_storage_layer_; 1566 RefPtr<column::StorageLayer> tid_storage_layer_; 1567 RefPtr<column::StorageLayer> name_storage_layer_; 1568 RefPtr<column::StorageLayer> start_ts_storage_layer_; 1569 RefPtr<column::StorageLayer> end_ts_storage_layer_; 1570 RefPtr<column::StorageLayer> upid_storage_layer_; 1571 RefPtr<column::StorageLayer> is_main_thread_storage_layer_; 1572 RefPtr<column::StorageLayer> machine_id_storage_layer_; 1573 1574 RefPtr<column::OverlayLayer> start_ts_null_layer_; 1575 RefPtr<column::OverlayLayer> end_ts_null_layer_; 1576 RefPtr<column::OverlayLayer> upid_null_layer_; 1577 RefPtr<column::OverlayLayer> is_main_thread_null_layer_; 1578 RefPtr<column::OverlayLayer> machine_id_null_layer_; 1579 }; 1580 1581 1582 class ArgTable : public macros_internal::MacroTable { 1583 public: 1584 static constexpr uint32_t kColumnCount = 9; 1585 1586 struct Id : public BaseId { 1587 Id() = default; IdId1588 explicit constexpr Id(uint32_t v) : BaseId(v) {} 1589 }; 1590 static_assert(std::is_trivially_destructible_v<Id>, 1591 "Inheritance used without trivial destruction"); 1592 1593 struct ColumnIndex { 1594 static constexpr uint32_t id = 0; 1595 static constexpr uint32_t type = 1; 1596 static constexpr uint32_t arg_set_id = 2; 1597 static constexpr uint32_t flat_key = 3; 1598 static constexpr uint32_t key = 4; 1599 static constexpr uint32_t int_value = 5; 1600 static constexpr uint32_t string_value = 6; 1601 static constexpr uint32_t real_value = 7; 1602 static constexpr uint32_t value_type = 8; 1603 }; 1604 struct ColumnType { 1605 using id = IdColumn<ArgTable::Id>; 1606 using type = TypedColumn<StringPool::Id>; 1607 using arg_set_id = TypedColumn<uint32_t>; 1608 using flat_key = TypedColumn<StringPool::Id>; 1609 using key = TypedColumn<StringPool::Id>; 1610 using int_value = TypedColumn<std::optional<int64_t>>; 1611 using string_value = TypedColumn<std::optional<StringPool::Id>>; 1612 using real_value = TypedColumn<std::optional<double>>; 1613 using value_type = TypedColumn<StringPool::Id>; 1614 }; 1615 struct Row : public macros_internal::RootParentTable::Row { 1616 Row(uint32_t in_arg_set_id = {}, 1617 StringPool::Id in_flat_key = {}, 1618 StringPool::Id in_key = {}, 1619 std::optional<int64_t> in_int_value = {}, 1620 std::optional<StringPool::Id> in_string_value = {}, 1621 std::optional<double> in_real_value = {}, 1622 StringPool::Id in_value_type = {}, 1623 std::nullptr_t = nullptr) RowRow1624 : macros_internal::RootParentTable::Row(), 1625 arg_set_id(in_arg_set_id), 1626 flat_key(in_flat_key), 1627 key(in_key), 1628 int_value(in_int_value), 1629 string_value(in_string_value), 1630 real_value(in_real_value), 1631 value_type(in_value_type) { 1632 type_ = "__intrinsic_args"; 1633 } 1634 uint32_t arg_set_id; 1635 StringPool::Id flat_key; 1636 StringPool::Id key; 1637 std::optional<int64_t> int_value; 1638 std::optional<StringPool::Id> string_value; 1639 std::optional<double> real_value; 1640 StringPool::Id value_type; 1641 1642 bool operator==(const ArgTable::Row& other) const { 1643 return type() == other.type() && ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 1644 ColumnType::flat_key::Equals(flat_key, other.flat_key) && 1645 ColumnType::key::Equals(key, other.key) && 1646 ColumnType::int_value::Equals(int_value, other.int_value) && 1647 ColumnType::string_value::Equals(string_value, other.string_value) && 1648 ColumnType::real_value::Equals(real_value, other.real_value) && 1649 ColumnType::value_type::Equals(value_type, other.value_type); 1650 } 1651 }; 1652 struct ColumnFlag { 1653 static constexpr uint32_t arg_set_id = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::arg_set_id::default_flags(); 1654 static constexpr uint32_t flat_key = ColumnType::flat_key::default_flags(); 1655 static constexpr uint32_t key = ColumnType::key::default_flags(); 1656 static constexpr uint32_t int_value = ColumnType::int_value::default_flags(); 1657 static constexpr uint32_t string_value = ColumnType::string_value::default_flags(); 1658 static constexpr uint32_t real_value = ColumnType::real_value::default_flags(); 1659 static constexpr uint32_t value_type = ColumnType::value_type::default_flags(); 1660 }; 1661 1662 class RowNumber; 1663 class ConstRowReference; 1664 class RowReference; 1665 1666 class RowNumber : public macros_internal::AbstractRowNumber< 1667 ArgTable, ConstRowReference, RowReference> { 1668 public: RowNumber(uint32_t row_number)1669 explicit RowNumber(uint32_t row_number) 1670 : AbstractRowNumber(row_number) {} 1671 }; 1672 static_assert(std::is_trivially_destructible_v<RowNumber>, 1673 "Inheritance used without trivial destruction"); 1674 1675 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1676 ArgTable, RowNumber> { 1677 public: ConstRowReference(const ArgTable * table,uint32_t row_number)1678 ConstRowReference(const ArgTable* table, uint32_t row_number) 1679 : AbstractConstRowReference(table, row_number) {} 1680 id()1681 ColumnType::id::type id() const { 1682 return table()->id()[row_number_]; 1683 } type()1684 ColumnType::type::type type() const { 1685 return table()->type()[row_number_]; 1686 } arg_set_id()1687 ColumnType::arg_set_id::type arg_set_id() const { 1688 return table()->arg_set_id()[row_number_]; 1689 } flat_key()1690 ColumnType::flat_key::type flat_key() const { 1691 return table()->flat_key()[row_number_]; 1692 } key()1693 ColumnType::key::type key() const { 1694 return table()->key()[row_number_]; 1695 } int_value()1696 ColumnType::int_value::type int_value() const { 1697 return table()->int_value()[row_number_]; 1698 } string_value()1699 ColumnType::string_value::type string_value() const { 1700 return table()->string_value()[row_number_]; 1701 } real_value()1702 ColumnType::real_value::type real_value() const { 1703 return table()->real_value()[row_number_]; 1704 } value_type()1705 ColumnType::value_type::type value_type() const { 1706 return table()->value_type()[row_number_]; 1707 } 1708 }; 1709 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1710 "Inheritance used without trivial destruction"); 1711 class RowReference : public ConstRowReference { 1712 public: RowReference(const ArgTable * table,uint32_t row_number)1713 RowReference(const ArgTable* table, uint32_t row_number) 1714 : ConstRowReference(table, row_number) {} 1715 set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)1716 void set_arg_set_id( 1717 ColumnType::arg_set_id::non_optional_type v) { 1718 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 1719 } set_flat_key(ColumnType::flat_key::non_optional_type v)1720 void set_flat_key( 1721 ColumnType::flat_key::non_optional_type v) { 1722 return mutable_table()->mutable_flat_key()->Set(row_number_, v); 1723 } set_key(ColumnType::key::non_optional_type v)1724 void set_key( 1725 ColumnType::key::non_optional_type v) { 1726 return mutable_table()->mutable_key()->Set(row_number_, v); 1727 } set_int_value(ColumnType::int_value::non_optional_type v)1728 void set_int_value( 1729 ColumnType::int_value::non_optional_type v) { 1730 return mutable_table()->mutable_int_value()->Set(row_number_, v); 1731 } set_string_value(ColumnType::string_value::non_optional_type v)1732 void set_string_value( 1733 ColumnType::string_value::non_optional_type v) { 1734 return mutable_table()->mutable_string_value()->Set(row_number_, v); 1735 } set_real_value(ColumnType::real_value::non_optional_type v)1736 void set_real_value( 1737 ColumnType::real_value::non_optional_type v) { 1738 return mutable_table()->mutable_real_value()->Set(row_number_, v); 1739 } set_value_type(ColumnType::value_type::non_optional_type v)1740 void set_value_type( 1741 ColumnType::value_type::non_optional_type v) { 1742 return mutable_table()->mutable_value_type()->Set(row_number_, v); 1743 } 1744 1745 private: mutable_table()1746 ArgTable* mutable_table() const { 1747 return const_cast<ArgTable*>(table()); 1748 } 1749 }; 1750 static_assert(std::is_trivially_destructible_v<RowReference>, 1751 "Inheritance used without trivial destruction"); 1752 1753 class ConstIterator; 1754 class ConstIterator : public macros_internal::AbstractConstIterator< 1755 ConstIterator, ArgTable, RowNumber, ConstRowReference> { 1756 public: id()1757 ColumnType::id::type id() const { 1758 const auto& col = table()->id(); 1759 return col.GetAtIdx( 1760 iterator_.StorageIndexForColumn(col.index_in_table())); 1761 } type()1762 ColumnType::type::type type() const { 1763 const auto& col = table()->type(); 1764 return col.GetAtIdx( 1765 iterator_.StorageIndexForColumn(col.index_in_table())); 1766 } arg_set_id()1767 ColumnType::arg_set_id::type arg_set_id() const { 1768 const auto& col = table()->arg_set_id(); 1769 return col.GetAtIdx( 1770 iterator_.StorageIndexForColumn(col.index_in_table())); 1771 } flat_key()1772 ColumnType::flat_key::type flat_key() const { 1773 const auto& col = table()->flat_key(); 1774 return col.GetAtIdx( 1775 iterator_.StorageIndexForColumn(col.index_in_table())); 1776 } key()1777 ColumnType::key::type key() const { 1778 const auto& col = table()->key(); 1779 return col.GetAtIdx( 1780 iterator_.StorageIndexForColumn(col.index_in_table())); 1781 } int_value()1782 ColumnType::int_value::type int_value() const { 1783 const auto& col = table()->int_value(); 1784 return col.GetAtIdx( 1785 iterator_.StorageIndexForColumn(col.index_in_table())); 1786 } string_value()1787 ColumnType::string_value::type string_value() const { 1788 const auto& col = table()->string_value(); 1789 return col.GetAtIdx( 1790 iterator_.StorageIndexForColumn(col.index_in_table())); 1791 } real_value()1792 ColumnType::real_value::type real_value() const { 1793 const auto& col = table()->real_value(); 1794 return col.GetAtIdx( 1795 iterator_.StorageIndexForColumn(col.index_in_table())); 1796 } value_type()1797 ColumnType::value_type::type value_type() const { 1798 const auto& col = table()->value_type(); 1799 return col.GetAtIdx( 1800 iterator_.StorageIndexForColumn(col.index_in_table())); 1801 } 1802 1803 protected: ConstIterator(const ArgTable * table,Table::Iterator iterator)1804 explicit ConstIterator(const ArgTable* table, 1805 Table::Iterator iterator) 1806 : AbstractConstIterator(table, std::move(iterator)) {} 1807 CurrentRowNumber()1808 uint32_t CurrentRowNumber() const { 1809 return iterator_.StorageIndexForLastOverlay(); 1810 } 1811 1812 private: 1813 friend class ArgTable; 1814 friend class macros_internal::AbstractConstIterator< 1815 ConstIterator, ArgTable, RowNumber, ConstRowReference>; 1816 }; 1817 class Iterator : public ConstIterator { 1818 public: row_reference()1819 RowReference row_reference() const { 1820 return {const_cast<ArgTable*>(table()), CurrentRowNumber()}; 1821 } 1822 1823 private: 1824 friend class ArgTable; 1825 Iterator(ArgTable * table,Table::Iterator iterator)1826 explicit Iterator(ArgTable* table, Table::Iterator iterator) 1827 : ConstIterator(table, std::move(iterator)) {} 1828 }; 1829 1830 struct IdAndRow { 1831 Id id; 1832 uint32_t row; 1833 RowReference row_reference; 1834 RowNumber row_number; 1835 }; 1836 GetColumns(ArgTable * self,const macros_internal::MacroTable * parent)1837 static std::vector<ColumnLegacy> GetColumns( 1838 ArgTable* self, 1839 const macros_internal::MacroTable* parent) { 1840 std::vector<ColumnLegacy> columns = 1841 CopyColumnsFromParentOrAddRootColumns(self, parent); 1842 uint32_t olay_idx = OverlayCount(parent); 1843 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 1844 static_cast<uint32_t>(columns.size()), olay_idx); 1845 AddColumnToVector(columns, "flat_key", &self->flat_key_, ColumnFlag::flat_key, 1846 static_cast<uint32_t>(columns.size()), olay_idx); 1847 AddColumnToVector(columns, "key", &self->key_, ColumnFlag::key, 1848 static_cast<uint32_t>(columns.size()), olay_idx); 1849 AddColumnToVector(columns, "int_value", &self->int_value_, ColumnFlag::int_value, 1850 static_cast<uint32_t>(columns.size()), olay_idx); 1851 AddColumnToVector(columns, "string_value", &self->string_value_, ColumnFlag::string_value, 1852 static_cast<uint32_t>(columns.size()), olay_idx); 1853 AddColumnToVector(columns, "real_value", &self->real_value_, ColumnFlag::real_value, 1854 static_cast<uint32_t>(columns.size()), olay_idx); 1855 AddColumnToVector(columns, "value_type", &self->value_type_, ColumnFlag::value_type, 1856 static_cast<uint32_t>(columns.size()), olay_idx); 1857 return columns; 1858 } 1859 ArgTable(StringPool * pool)1860 PERFETTO_NO_INLINE explicit ArgTable(StringPool* pool) 1861 : macros_internal::MacroTable( 1862 pool, 1863 GetColumns(this, nullptr), 1864 nullptr), 1865 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 1866 flat_key_(ColumnStorage<ColumnType::flat_key::stored_type>::Create<false>()), 1867 key_(ColumnStorage<ColumnType::key::stored_type>::Create<false>()), 1868 int_value_(ColumnStorage<ColumnType::int_value::stored_type>::Create<false>()), 1869 string_value_(ColumnStorage<ColumnType::string_value::stored_type>::Create<false>()), 1870 real_value_(ColumnStorage<ColumnType::real_value::stored_type>::Create<false>()), 1871 value_type_(ColumnStorage<ColumnType::value_type::stored_type>::Create<false>()) 1872 , 1873 id_storage_layer_(new column::IdStorage()), 1874 type_storage_layer_( 1875 new column::StringStorage(string_pool(), &type_.vector())), 1876 arg_set_id_storage_layer_( 1877 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 1878 &arg_set_id_.vector(), 1879 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 1880 true)), 1881 flat_key_storage_layer_( 1882 new column::StringStorage(string_pool(), &flat_key_.vector())), 1883 key_storage_layer_( 1884 new column::StringStorage(string_pool(), &key_.vector())), 1885 int_value_storage_layer_( 1886 new column::NumericStorage<ColumnType::int_value::non_optional_stored_type>( 1887 &int_value_.non_null_vector(), 1888 ColumnTypeHelper<ColumnType::int_value::stored_type>::ToColumnType(), 1889 false)), 1890 string_value_storage_layer_( 1891 new column::StringStorage(string_pool(), &string_value_.vector())), 1892 real_value_storage_layer_( 1893 new column::NumericStorage<ColumnType::real_value::non_optional_stored_type>( 1894 &real_value_.non_null_vector(), 1895 ColumnTypeHelper<ColumnType::real_value::stored_type>::ToColumnType(), 1896 false)), 1897 value_type_storage_layer_( 1898 new column::StringStorage(string_pool(), &value_type_.vector())) 1899 , 1900 int_value_null_layer_(new column::NullOverlay(int_value_.bv())), 1901 real_value_null_layer_(new column::NullOverlay(real_value_.bv())) { 1902 static_assert( 1903 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 1904 ColumnFlag::arg_set_id), 1905 "Column type and flag combination is not valid"); 1906 static_assert( 1907 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::flat_key::stored_type>( 1908 ColumnFlag::flat_key), 1909 "Column type and flag combination is not valid"); 1910 static_assert( 1911 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::key::stored_type>( 1912 ColumnFlag::key), 1913 "Column type and flag combination is not valid"); 1914 static_assert( 1915 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::int_value::stored_type>( 1916 ColumnFlag::int_value), 1917 "Column type and flag combination is not valid"); 1918 static_assert( 1919 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::string_value::stored_type>( 1920 ColumnFlag::string_value), 1921 "Column type and flag combination is not valid"); 1922 static_assert( 1923 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::real_value::stored_type>( 1924 ColumnFlag::real_value), 1925 "Column type and flag combination is not valid"); 1926 static_assert( 1927 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::value_type::stored_type>( 1928 ColumnFlag::value_type), 1929 "Column type and flag combination is not valid"); 1930 OnConstructionCompletedRegularConstructor( 1931 {id_storage_layer_,type_storage_layer_,arg_set_id_storage_layer_,flat_key_storage_layer_,key_storage_layer_,int_value_storage_layer_,string_value_storage_layer_,real_value_storage_layer_,value_type_storage_layer_}, 1932 {{},{},{},{},{},int_value_null_layer_,{},real_value_null_layer_,{}}); 1933 } 1934 ~ArgTable() override; 1935 Name()1936 static const char* Name() { return "__intrinsic_args"; } 1937 ComputeStaticSchema()1938 static Table::Schema ComputeStaticSchema() { 1939 Table::Schema schema; 1940 schema.columns.emplace_back(Table::Schema::Column{ 1941 "id", SqlValue::Type::kLong, true, true, false, false}); 1942 schema.columns.emplace_back(Table::Schema::Column{ 1943 "type", SqlValue::Type::kString, false, false, false, false}); 1944 schema.columns.emplace_back(Table::Schema::Column{ 1945 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 1946 true, 1947 false, 1948 false}); 1949 schema.columns.emplace_back(Table::Schema::Column{ 1950 "flat_key", ColumnType::flat_key::SqlValueType(), false, 1951 false, 1952 false, 1953 false}); 1954 schema.columns.emplace_back(Table::Schema::Column{ 1955 "key", ColumnType::key::SqlValueType(), false, 1956 false, 1957 false, 1958 false}); 1959 schema.columns.emplace_back(Table::Schema::Column{ 1960 "int_value", ColumnType::int_value::SqlValueType(), false, 1961 false, 1962 false, 1963 false}); 1964 schema.columns.emplace_back(Table::Schema::Column{ 1965 "string_value", ColumnType::string_value::SqlValueType(), false, 1966 false, 1967 false, 1968 false}); 1969 schema.columns.emplace_back(Table::Schema::Column{ 1970 "real_value", ColumnType::real_value::SqlValueType(), false, 1971 false, 1972 false, 1973 false}); 1974 schema.columns.emplace_back(Table::Schema::Column{ 1975 "value_type", ColumnType::value_type::SqlValueType(), false, 1976 false, 1977 false, 1978 false}); 1979 return schema; 1980 } 1981 IterateRows()1982 ConstIterator IterateRows() const { 1983 return ConstIterator(this, Table::IterateRows()); 1984 } 1985 IterateRows()1986 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 1987 FilterToIterator(const Query & q)1988 ConstIterator FilterToIterator(const Query& q) const { 1989 return ConstIterator(this, QueryToIterator(q)); 1990 } 1991 FilterToIterator(const Query & q)1992 Iterator FilterToIterator(const Query& q) { 1993 return Iterator(this, QueryToIterator(q)); 1994 } 1995 ShrinkToFit()1996 void ShrinkToFit() { 1997 type_.ShrinkToFit(); 1998 arg_set_id_.ShrinkToFit(); 1999 flat_key_.ShrinkToFit(); 2000 key_.ShrinkToFit(); 2001 int_value_.ShrinkToFit(); 2002 string_value_.ShrinkToFit(); 2003 real_value_.ShrinkToFit(); 2004 value_type_.ShrinkToFit(); 2005 } 2006 2007 ConstRowReference operator[](uint32_t r) const { 2008 return ConstRowReference(this, r); 2009 } 2010 RowReference operator[](uint32_t r) { return RowReference(this, r); } 2011 ConstRowReference operator[](RowNumber r) const { 2012 return ConstRowReference(this, r.row_number()); 2013 } 2014 RowReference operator[](RowNumber r) { 2015 return RowReference(this, r.row_number()); 2016 } 2017 FindById(Id find_id)2018 std::optional<ConstRowReference> FindById(Id find_id) const { 2019 std::optional<uint32_t> row = id().IndexOf(find_id); 2020 return row ? std::make_optional(ConstRowReference(this, *row)) 2021 : std::nullopt; 2022 } 2023 FindById(Id find_id)2024 std::optional<RowReference> FindById(Id find_id) { 2025 std::optional<uint32_t> row = id().IndexOf(find_id); 2026 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 2027 } 2028 Insert(const Row & row)2029 IdAndRow Insert(const Row& row) { 2030 uint32_t row_number = row_count(); 2031 Id id = Id{row_number}; 2032 type_.Append(string_pool()->InternString(row.type())); 2033 mutable_arg_set_id()->Append(row.arg_set_id); 2034 mutable_flat_key()->Append(row.flat_key); 2035 mutable_key()->Append(row.key); 2036 mutable_int_value()->Append(row.int_value); 2037 mutable_string_value()->Append(row.string_value); 2038 mutable_real_value()->Append(row.real_value); 2039 mutable_value_type()->Append(row.value_type); 2040 UpdateSelfOverlayAfterInsert(); 2041 return IdAndRow{id, row_number, RowReference(this, row_number), 2042 RowNumber(row_number)}; 2043 } 2044 2045 2046 id()2047 const IdColumn<ArgTable::Id>& id() const { 2048 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 2049 } type()2050 const TypedColumn<StringPool::Id>& type() const { 2051 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 2052 } arg_set_id()2053 const TypedColumn<uint32_t>& arg_set_id() const { 2054 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 2055 } flat_key()2056 const TypedColumn<StringPool::Id>& flat_key() const { 2057 return static_cast<const ColumnType::flat_key&>(columns()[ColumnIndex::flat_key]); 2058 } key()2059 const TypedColumn<StringPool::Id>& key() const { 2060 return static_cast<const ColumnType::key&>(columns()[ColumnIndex::key]); 2061 } int_value()2062 const TypedColumn<std::optional<int64_t>>& int_value() const { 2063 return static_cast<const ColumnType::int_value&>(columns()[ColumnIndex::int_value]); 2064 } string_value()2065 const TypedColumn<std::optional<StringPool::Id>>& string_value() const { 2066 return static_cast<const ColumnType::string_value&>(columns()[ColumnIndex::string_value]); 2067 } real_value()2068 const TypedColumn<std::optional<double>>& real_value() const { 2069 return static_cast<const ColumnType::real_value&>(columns()[ColumnIndex::real_value]); 2070 } value_type()2071 const TypedColumn<StringPool::Id>& value_type() const { 2072 return static_cast<const ColumnType::value_type&>(columns()[ColumnIndex::value_type]); 2073 } 2074 mutable_arg_set_id()2075 TypedColumn<uint32_t>* mutable_arg_set_id() { 2076 return static_cast<ColumnType::arg_set_id*>( 2077 GetColumn(ColumnIndex::arg_set_id)); 2078 } mutable_flat_key()2079 TypedColumn<StringPool::Id>* mutable_flat_key() { 2080 return static_cast<ColumnType::flat_key*>( 2081 GetColumn(ColumnIndex::flat_key)); 2082 } mutable_key()2083 TypedColumn<StringPool::Id>* mutable_key() { 2084 return static_cast<ColumnType::key*>( 2085 GetColumn(ColumnIndex::key)); 2086 } mutable_int_value()2087 TypedColumn<std::optional<int64_t>>* mutable_int_value() { 2088 return static_cast<ColumnType::int_value*>( 2089 GetColumn(ColumnIndex::int_value)); 2090 } mutable_string_value()2091 TypedColumn<std::optional<StringPool::Id>>* mutable_string_value() { 2092 return static_cast<ColumnType::string_value*>( 2093 GetColumn(ColumnIndex::string_value)); 2094 } mutable_real_value()2095 TypedColumn<std::optional<double>>* mutable_real_value() { 2096 return static_cast<ColumnType::real_value*>( 2097 GetColumn(ColumnIndex::real_value)); 2098 } mutable_value_type()2099 TypedColumn<StringPool::Id>* mutable_value_type() { 2100 return static_cast<ColumnType::value_type*>( 2101 GetColumn(ColumnIndex::value_type)); 2102 } 2103 2104 private: 2105 2106 2107 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 2108 ColumnStorage<ColumnType::flat_key::stored_type> flat_key_; 2109 ColumnStorage<ColumnType::key::stored_type> key_; 2110 ColumnStorage<ColumnType::int_value::stored_type> int_value_; 2111 ColumnStorage<ColumnType::string_value::stored_type> string_value_; 2112 ColumnStorage<ColumnType::real_value::stored_type> real_value_; 2113 ColumnStorage<ColumnType::value_type::stored_type> value_type_; 2114 2115 RefPtr<column::StorageLayer> id_storage_layer_; 2116 RefPtr<column::StorageLayer> type_storage_layer_; 2117 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 2118 RefPtr<column::StorageLayer> flat_key_storage_layer_; 2119 RefPtr<column::StorageLayer> key_storage_layer_; 2120 RefPtr<column::StorageLayer> int_value_storage_layer_; 2121 RefPtr<column::StorageLayer> string_value_storage_layer_; 2122 RefPtr<column::StorageLayer> real_value_storage_layer_; 2123 RefPtr<column::StorageLayer> value_type_storage_layer_; 2124 2125 RefPtr<column::OverlayLayer> int_value_null_layer_; 2126 RefPtr<column::OverlayLayer> real_value_null_layer_; 2127 }; 2128 2129 2130 class ClockSnapshotTable : public macros_internal::MacroTable { 2131 public: 2132 static constexpr uint32_t kColumnCount = 8; 2133 2134 struct Id : public BaseId { 2135 Id() = default; IdId2136 explicit constexpr Id(uint32_t v) : BaseId(v) {} 2137 }; 2138 static_assert(std::is_trivially_destructible_v<Id>, 2139 "Inheritance used without trivial destruction"); 2140 2141 struct ColumnIndex { 2142 static constexpr uint32_t id = 0; 2143 static constexpr uint32_t type = 1; 2144 static constexpr uint32_t ts = 2; 2145 static constexpr uint32_t clock_id = 3; 2146 static constexpr uint32_t clock_name = 4; 2147 static constexpr uint32_t clock_value = 5; 2148 static constexpr uint32_t snapshot_id = 6; 2149 static constexpr uint32_t machine_id = 7; 2150 }; 2151 struct ColumnType { 2152 using id = IdColumn<ClockSnapshotTable::Id>; 2153 using type = TypedColumn<StringPool::Id>; 2154 using ts = TypedColumn<int64_t>; 2155 using clock_id = TypedColumn<int64_t>; 2156 using clock_name = TypedColumn<std::optional<StringPool::Id>>; 2157 using clock_value = TypedColumn<int64_t>; 2158 using snapshot_id = TypedColumn<uint32_t>; 2159 using machine_id = TypedColumn<std::optional<MachineTable::Id>>; 2160 }; 2161 struct Row : public macros_internal::RootParentTable::Row { 2162 Row(int64_t in_ts = {}, 2163 int64_t in_clock_id = {}, 2164 std::optional<StringPool::Id> in_clock_name = {}, 2165 int64_t in_clock_value = {}, 2166 uint32_t in_snapshot_id = {}, 2167 std::optional<MachineTable::Id> in_machine_id = {}, 2168 std::nullptr_t = nullptr) RowRow2169 : macros_internal::RootParentTable::Row(), 2170 ts(in_ts), 2171 clock_id(in_clock_id), 2172 clock_name(in_clock_name), 2173 clock_value(in_clock_value), 2174 snapshot_id(in_snapshot_id), 2175 machine_id(in_machine_id) { 2176 type_ = "clock_snapshot"; 2177 } 2178 int64_t ts; 2179 int64_t clock_id; 2180 std::optional<StringPool::Id> clock_name; 2181 int64_t clock_value; 2182 uint32_t snapshot_id; 2183 std::optional<MachineTable::Id> machine_id; 2184 2185 bool operator==(const ClockSnapshotTable::Row& other) const { 2186 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 2187 ColumnType::clock_id::Equals(clock_id, other.clock_id) && 2188 ColumnType::clock_name::Equals(clock_name, other.clock_name) && 2189 ColumnType::clock_value::Equals(clock_value, other.clock_value) && 2190 ColumnType::snapshot_id::Equals(snapshot_id, other.snapshot_id) && 2191 ColumnType::machine_id::Equals(machine_id, other.machine_id); 2192 } 2193 }; 2194 struct ColumnFlag { 2195 static constexpr uint32_t ts = ColumnType::ts::default_flags(); 2196 static constexpr uint32_t clock_id = ColumnType::clock_id::default_flags(); 2197 static constexpr uint32_t clock_name = ColumnType::clock_name::default_flags(); 2198 static constexpr uint32_t clock_value = ColumnType::clock_value::default_flags(); 2199 static constexpr uint32_t snapshot_id = ColumnType::snapshot_id::default_flags(); 2200 static constexpr uint32_t machine_id = ColumnType::machine_id::default_flags(); 2201 }; 2202 2203 class RowNumber; 2204 class ConstRowReference; 2205 class RowReference; 2206 2207 class RowNumber : public macros_internal::AbstractRowNumber< 2208 ClockSnapshotTable, ConstRowReference, RowReference> { 2209 public: RowNumber(uint32_t row_number)2210 explicit RowNumber(uint32_t row_number) 2211 : AbstractRowNumber(row_number) {} 2212 }; 2213 static_assert(std::is_trivially_destructible_v<RowNumber>, 2214 "Inheritance used without trivial destruction"); 2215 2216 class ConstRowReference : public macros_internal::AbstractConstRowReference< 2217 ClockSnapshotTable, RowNumber> { 2218 public: ConstRowReference(const ClockSnapshotTable * table,uint32_t row_number)2219 ConstRowReference(const ClockSnapshotTable* table, uint32_t row_number) 2220 : AbstractConstRowReference(table, row_number) {} 2221 id()2222 ColumnType::id::type id() const { 2223 return table()->id()[row_number_]; 2224 } type()2225 ColumnType::type::type type() const { 2226 return table()->type()[row_number_]; 2227 } ts()2228 ColumnType::ts::type ts() const { 2229 return table()->ts()[row_number_]; 2230 } clock_id()2231 ColumnType::clock_id::type clock_id() const { 2232 return table()->clock_id()[row_number_]; 2233 } clock_name()2234 ColumnType::clock_name::type clock_name() const { 2235 return table()->clock_name()[row_number_]; 2236 } clock_value()2237 ColumnType::clock_value::type clock_value() const { 2238 return table()->clock_value()[row_number_]; 2239 } snapshot_id()2240 ColumnType::snapshot_id::type snapshot_id() const { 2241 return table()->snapshot_id()[row_number_]; 2242 } machine_id()2243 ColumnType::machine_id::type machine_id() const { 2244 return table()->machine_id()[row_number_]; 2245 } 2246 }; 2247 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 2248 "Inheritance used without trivial destruction"); 2249 class RowReference : public ConstRowReference { 2250 public: RowReference(const ClockSnapshotTable * table,uint32_t row_number)2251 RowReference(const ClockSnapshotTable* table, uint32_t row_number) 2252 : ConstRowReference(table, row_number) {} 2253 set_ts(ColumnType::ts::non_optional_type v)2254 void set_ts( 2255 ColumnType::ts::non_optional_type v) { 2256 return mutable_table()->mutable_ts()->Set(row_number_, v); 2257 } set_clock_id(ColumnType::clock_id::non_optional_type v)2258 void set_clock_id( 2259 ColumnType::clock_id::non_optional_type v) { 2260 return mutable_table()->mutable_clock_id()->Set(row_number_, v); 2261 } set_clock_name(ColumnType::clock_name::non_optional_type v)2262 void set_clock_name( 2263 ColumnType::clock_name::non_optional_type v) { 2264 return mutable_table()->mutable_clock_name()->Set(row_number_, v); 2265 } set_clock_value(ColumnType::clock_value::non_optional_type v)2266 void set_clock_value( 2267 ColumnType::clock_value::non_optional_type v) { 2268 return mutable_table()->mutable_clock_value()->Set(row_number_, v); 2269 } set_snapshot_id(ColumnType::snapshot_id::non_optional_type v)2270 void set_snapshot_id( 2271 ColumnType::snapshot_id::non_optional_type v) { 2272 return mutable_table()->mutable_snapshot_id()->Set(row_number_, v); 2273 } set_machine_id(ColumnType::machine_id::non_optional_type v)2274 void set_machine_id( 2275 ColumnType::machine_id::non_optional_type v) { 2276 return mutable_table()->mutable_machine_id()->Set(row_number_, v); 2277 } 2278 2279 private: mutable_table()2280 ClockSnapshotTable* mutable_table() const { 2281 return const_cast<ClockSnapshotTable*>(table()); 2282 } 2283 }; 2284 static_assert(std::is_trivially_destructible_v<RowReference>, 2285 "Inheritance used without trivial destruction"); 2286 2287 class ConstIterator; 2288 class ConstIterator : public macros_internal::AbstractConstIterator< 2289 ConstIterator, ClockSnapshotTable, RowNumber, ConstRowReference> { 2290 public: id()2291 ColumnType::id::type id() const { 2292 const auto& col = table()->id(); 2293 return col.GetAtIdx( 2294 iterator_.StorageIndexForColumn(col.index_in_table())); 2295 } type()2296 ColumnType::type::type type() const { 2297 const auto& col = table()->type(); 2298 return col.GetAtIdx( 2299 iterator_.StorageIndexForColumn(col.index_in_table())); 2300 } ts()2301 ColumnType::ts::type ts() const { 2302 const auto& col = table()->ts(); 2303 return col.GetAtIdx( 2304 iterator_.StorageIndexForColumn(col.index_in_table())); 2305 } clock_id()2306 ColumnType::clock_id::type clock_id() const { 2307 const auto& col = table()->clock_id(); 2308 return col.GetAtIdx( 2309 iterator_.StorageIndexForColumn(col.index_in_table())); 2310 } clock_name()2311 ColumnType::clock_name::type clock_name() const { 2312 const auto& col = table()->clock_name(); 2313 return col.GetAtIdx( 2314 iterator_.StorageIndexForColumn(col.index_in_table())); 2315 } clock_value()2316 ColumnType::clock_value::type clock_value() const { 2317 const auto& col = table()->clock_value(); 2318 return col.GetAtIdx( 2319 iterator_.StorageIndexForColumn(col.index_in_table())); 2320 } snapshot_id()2321 ColumnType::snapshot_id::type snapshot_id() const { 2322 const auto& col = table()->snapshot_id(); 2323 return col.GetAtIdx( 2324 iterator_.StorageIndexForColumn(col.index_in_table())); 2325 } machine_id()2326 ColumnType::machine_id::type machine_id() const { 2327 const auto& col = table()->machine_id(); 2328 return col.GetAtIdx( 2329 iterator_.StorageIndexForColumn(col.index_in_table())); 2330 } 2331 2332 protected: ConstIterator(const ClockSnapshotTable * table,Table::Iterator iterator)2333 explicit ConstIterator(const ClockSnapshotTable* table, 2334 Table::Iterator iterator) 2335 : AbstractConstIterator(table, std::move(iterator)) {} 2336 CurrentRowNumber()2337 uint32_t CurrentRowNumber() const { 2338 return iterator_.StorageIndexForLastOverlay(); 2339 } 2340 2341 private: 2342 friend class ClockSnapshotTable; 2343 friend class macros_internal::AbstractConstIterator< 2344 ConstIterator, ClockSnapshotTable, RowNumber, ConstRowReference>; 2345 }; 2346 class Iterator : public ConstIterator { 2347 public: row_reference()2348 RowReference row_reference() const { 2349 return {const_cast<ClockSnapshotTable*>(table()), CurrentRowNumber()}; 2350 } 2351 2352 private: 2353 friend class ClockSnapshotTable; 2354 Iterator(ClockSnapshotTable * table,Table::Iterator iterator)2355 explicit Iterator(ClockSnapshotTable* table, Table::Iterator iterator) 2356 : ConstIterator(table, std::move(iterator)) {} 2357 }; 2358 2359 struct IdAndRow { 2360 Id id; 2361 uint32_t row; 2362 RowReference row_reference; 2363 RowNumber row_number; 2364 }; 2365 GetColumns(ClockSnapshotTable * self,const macros_internal::MacroTable * parent)2366 static std::vector<ColumnLegacy> GetColumns( 2367 ClockSnapshotTable* self, 2368 const macros_internal::MacroTable* parent) { 2369 std::vector<ColumnLegacy> columns = 2370 CopyColumnsFromParentOrAddRootColumns(self, parent); 2371 uint32_t olay_idx = OverlayCount(parent); 2372 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 2373 static_cast<uint32_t>(columns.size()), olay_idx); 2374 AddColumnToVector(columns, "clock_id", &self->clock_id_, ColumnFlag::clock_id, 2375 static_cast<uint32_t>(columns.size()), olay_idx); 2376 AddColumnToVector(columns, "clock_name", &self->clock_name_, ColumnFlag::clock_name, 2377 static_cast<uint32_t>(columns.size()), olay_idx); 2378 AddColumnToVector(columns, "clock_value", &self->clock_value_, ColumnFlag::clock_value, 2379 static_cast<uint32_t>(columns.size()), olay_idx); 2380 AddColumnToVector(columns, "snapshot_id", &self->snapshot_id_, ColumnFlag::snapshot_id, 2381 static_cast<uint32_t>(columns.size()), olay_idx); 2382 AddColumnToVector(columns, "machine_id", &self->machine_id_, ColumnFlag::machine_id, 2383 static_cast<uint32_t>(columns.size()), olay_idx); 2384 return columns; 2385 } 2386 ClockSnapshotTable(StringPool * pool)2387 PERFETTO_NO_INLINE explicit ClockSnapshotTable(StringPool* pool) 2388 : macros_internal::MacroTable( 2389 pool, 2390 GetColumns(this, nullptr), 2391 nullptr), 2392 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 2393 clock_id_(ColumnStorage<ColumnType::clock_id::stored_type>::Create<false>()), 2394 clock_name_(ColumnStorage<ColumnType::clock_name::stored_type>::Create<false>()), 2395 clock_value_(ColumnStorage<ColumnType::clock_value::stored_type>::Create<false>()), 2396 snapshot_id_(ColumnStorage<ColumnType::snapshot_id::stored_type>::Create<false>()), 2397 machine_id_(ColumnStorage<ColumnType::machine_id::stored_type>::Create<false>()) 2398 , 2399 id_storage_layer_(new column::IdStorage()), 2400 type_storage_layer_( 2401 new column::StringStorage(string_pool(), &type_.vector())), 2402 ts_storage_layer_( 2403 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 2404 &ts_.vector(), 2405 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 2406 false)), 2407 clock_id_storage_layer_( 2408 new column::NumericStorage<ColumnType::clock_id::non_optional_stored_type>( 2409 &clock_id_.vector(), 2410 ColumnTypeHelper<ColumnType::clock_id::stored_type>::ToColumnType(), 2411 false)), 2412 clock_name_storage_layer_( 2413 new column::StringStorage(string_pool(), &clock_name_.vector())), 2414 clock_value_storage_layer_( 2415 new column::NumericStorage<ColumnType::clock_value::non_optional_stored_type>( 2416 &clock_value_.vector(), 2417 ColumnTypeHelper<ColumnType::clock_value::stored_type>::ToColumnType(), 2418 false)), 2419 snapshot_id_storage_layer_( 2420 new column::NumericStorage<ColumnType::snapshot_id::non_optional_stored_type>( 2421 &snapshot_id_.vector(), 2422 ColumnTypeHelper<ColumnType::snapshot_id::stored_type>::ToColumnType(), 2423 false)), 2424 machine_id_storage_layer_( 2425 new column::NumericStorage<ColumnType::machine_id::non_optional_stored_type>( 2426 &machine_id_.non_null_vector(), 2427 ColumnTypeHelper<ColumnType::machine_id::stored_type>::ToColumnType(), 2428 false)) 2429 , 2430 machine_id_null_layer_(new column::NullOverlay(machine_id_.bv())) { 2431 static_assert( 2432 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 2433 ColumnFlag::ts), 2434 "Column type and flag combination is not valid"); 2435 static_assert( 2436 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::clock_id::stored_type>( 2437 ColumnFlag::clock_id), 2438 "Column type and flag combination is not valid"); 2439 static_assert( 2440 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::clock_name::stored_type>( 2441 ColumnFlag::clock_name), 2442 "Column type and flag combination is not valid"); 2443 static_assert( 2444 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::clock_value::stored_type>( 2445 ColumnFlag::clock_value), 2446 "Column type and flag combination is not valid"); 2447 static_assert( 2448 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::snapshot_id::stored_type>( 2449 ColumnFlag::snapshot_id), 2450 "Column type and flag combination is not valid"); 2451 static_assert( 2452 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::machine_id::stored_type>( 2453 ColumnFlag::machine_id), 2454 "Column type and flag combination is not valid"); 2455 OnConstructionCompletedRegularConstructor( 2456 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,clock_id_storage_layer_,clock_name_storage_layer_,clock_value_storage_layer_,snapshot_id_storage_layer_,machine_id_storage_layer_}, 2457 {{},{},{},{},{},{},{},machine_id_null_layer_}); 2458 } 2459 ~ClockSnapshotTable() override; 2460 Name()2461 static const char* Name() { return "clock_snapshot"; } 2462 ComputeStaticSchema()2463 static Table::Schema ComputeStaticSchema() { 2464 Table::Schema schema; 2465 schema.columns.emplace_back(Table::Schema::Column{ 2466 "id", SqlValue::Type::kLong, true, true, false, false}); 2467 schema.columns.emplace_back(Table::Schema::Column{ 2468 "type", SqlValue::Type::kString, false, false, false, false}); 2469 schema.columns.emplace_back(Table::Schema::Column{ 2470 "ts", ColumnType::ts::SqlValueType(), false, 2471 false, 2472 false, 2473 false}); 2474 schema.columns.emplace_back(Table::Schema::Column{ 2475 "clock_id", ColumnType::clock_id::SqlValueType(), false, 2476 false, 2477 false, 2478 false}); 2479 schema.columns.emplace_back(Table::Schema::Column{ 2480 "clock_name", ColumnType::clock_name::SqlValueType(), false, 2481 false, 2482 false, 2483 false}); 2484 schema.columns.emplace_back(Table::Schema::Column{ 2485 "clock_value", ColumnType::clock_value::SqlValueType(), false, 2486 false, 2487 false, 2488 false}); 2489 schema.columns.emplace_back(Table::Schema::Column{ 2490 "snapshot_id", ColumnType::snapshot_id::SqlValueType(), false, 2491 false, 2492 false, 2493 false}); 2494 schema.columns.emplace_back(Table::Schema::Column{ 2495 "machine_id", ColumnType::machine_id::SqlValueType(), false, 2496 false, 2497 false, 2498 false}); 2499 return schema; 2500 } 2501 IterateRows()2502 ConstIterator IterateRows() const { 2503 return ConstIterator(this, Table::IterateRows()); 2504 } 2505 IterateRows()2506 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 2507 FilterToIterator(const Query & q)2508 ConstIterator FilterToIterator(const Query& q) const { 2509 return ConstIterator(this, QueryToIterator(q)); 2510 } 2511 FilterToIterator(const Query & q)2512 Iterator FilterToIterator(const Query& q) { 2513 return Iterator(this, QueryToIterator(q)); 2514 } 2515 ShrinkToFit()2516 void ShrinkToFit() { 2517 type_.ShrinkToFit(); 2518 ts_.ShrinkToFit(); 2519 clock_id_.ShrinkToFit(); 2520 clock_name_.ShrinkToFit(); 2521 clock_value_.ShrinkToFit(); 2522 snapshot_id_.ShrinkToFit(); 2523 machine_id_.ShrinkToFit(); 2524 } 2525 2526 ConstRowReference operator[](uint32_t r) const { 2527 return ConstRowReference(this, r); 2528 } 2529 RowReference operator[](uint32_t r) { return RowReference(this, r); } 2530 ConstRowReference operator[](RowNumber r) const { 2531 return ConstRowReference(this, r.row_number()); 2532 } 2533 RowReference operator[](RowNumber r) { 2534 return RowReference(this, r.row_number()); 2535 } 2536 FindById(Id find_id)2537 std::optional<ConstRowReference> FindById(Id find_id) const { 2538 std::optional<uint32_t> row = id().IndexOf(find_id); 2539 return row ? std::make_optional(ConstRowReference(this, *row)) 2540 : std::nullopt; 2541 } 2542 FindById(Id find_id)2543 std::optional<RowReference> FindById(Id find_id) { 2544 std::optional<uint32_t> row = id().IndexOf(find_id); 2545 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 2546 } 2547 Insert(const Row & row)2548 IdAndRow Insert(const Row& row) { 2549 uint32_t row_number = row_count(); 2550 Id id = Id{row_number}; 2551 type_.Append(string_pool()->InternString(row.type())); 2552 mutable_ts()->Append(row.ts); 2553 mutable_clock_id()->Append(row.clock_id); 2554 mutable_clock_name()->Append(row.clock_name); 2555 mutable_clock_value()->Append(row.clock_value); 2556 mutable_snapshot_id()->Append(row.snapshot_id); 2557 mutable_machine_id()->Append(row.machine_id); 2558 UpdateSelfOverlayAfterInsert(); 2559 return IdAndRow{id, row_number, RowReference(this, row_number), 2560 RowNumber(row_number)}; 2561 } 2562 2563 2564 id()2565 const IdColumn<ClockSnapshotTable::Id>& id() const { 2566 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 2567 } type()2568 const TypedColumn<StringPool::Id>& type() const { 2569 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 2570 } ts()2571 const TypedColumn<int64_t>& ts() const { 2572 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 2573 } clock_id()2574 const TypedColumn<int64_t>& clock_id() const { 2575 return static_cast<const ColumnType::clock_id&>(columns()[ColumnIndex::clock_id]); 2576 } clock_name()2577 const TypedColumn<std::optional<StringPool::Id>>& clock_name() const { 2578 return static_cast<const ColumnType::clock_name&>(columns()[ColumnIndex::clock_name]); 2579 } clock_value()2580 const TypedColumn<int64_t>& clock_value() const { 2581 return static_cast<const ColumnType::clock_value&>(columns()[ColumnIndex::clock_value]); 2582 } snapshot_id()2583 const TypedColumn<uint32_t>& snapshot_id() const { 2584 return static_cast<const ColumnType::snapshot_id&>(columns()[ColumnIndex::snapshot_id]); 2585 } machine_id()2586 const TypedColumn<std::optional<MachineTable::Id>>& machine_id() const { 2587 return static_cast<const ColumnType::machine_id&>(columns()[ColumnIndex::machine_id]); 2588 } 2589 mutable_ts()2590 TypedColumn<int64_t>* mutable_ts() { 2591 return static_cast<ColumnType::ts*>( 2592 GetColumn(ColumnIndex::ts)); 2593 } mutable_clock_id()2594 TypedColumn<int64_t>* mutable_clock_id() { 2595 return static_cast<ColumnType::clock_id*>( 2596 GetColumn(ColumnIndex::clock_id)); 2597 } mutable_clock_name()2598 TypedColumn<std::optional<StringPool::Id>>* mutable_clock_name() { 2599 return static_cast<ColumnType::clock_name*>( 2600 GetColumn(ColumnIndex::clock_name)); 2601 } mutable_clock_value()2602 TypedColumn<int64_t>* mutable_clock_value() { 2603 return static_cast<ColumnType::clock_value*>( 2604 GetColumn(ColumnIndex::clock_value)); 2605 } mutable_snapshot_id()2606 TypedColumn<uint32_t>* mutable_snapshot_id() { 2607 return static_cast<ColumnType::snapshot_id*>( 2608 GetColumn(ColumnIndex::snapshot_id)); 2609 } mutable_machine_id()2610 TypedColumn<std::optional<MachineTable::Id>>* mutable_machine_id() { 2611 return static_cast<ColumnType::machine_id*>( 2612 GetColumn(ColumnIndex::machine_id)); 2613 } 2614 2615 private: 2616 2617 2618 ColumnStorage<ColumnType::ts::stored_type> ts_; 2619 ColumnStorage<ColumnType::clock_id::stored_type> clock_id_; 2620 ColumnStorage<ColumnType::clock_name::stored_type> clock_name_; 2621 ColumnStorage<ColumnType::clock_value::stored_type> clock_value_; 2622 ColumnStorage<ColumnType::snapshot_id::stored_type> snapshot_id_; 2623 ColumnStorage<ColumnType::machine_id::stored_type> machine_id_; 2624 2625 RefPtr<column::StorageLayer> id_storage_layer_; 2626 RefPtr<column::StorageLayer> type_storage_layer_; 2627 RefPtr<column::StorageLayer> ts_storage_layer_; 2628 RefPtr<column::StorageLayer> clock_id_storage_layer_; 2629 RefPtr<column::StorageLayer> clock_name_storage_layer_; 2630 RefPtr<column::StorageLayer> clock_value_storage_layer_; 2631 RefPtr<column::StorageLayer> snapshot_id_storage_layer_; 2632 RefPtr<column::StorageLayer> machine_id_storage_layer_; 2633 2634 RefPtr<column::OverlayLayer> machine_id_null_layer_; 2635 }; 2636 2637 2638 class CpuTable : public macros_internal::MacroTable { 2639 public: 2640 static constexpr uint32_t kColumnCount = 8; 2641 2642 struct Id : public BaseId { 2643 Id() = default; IdId2644 explicit constexpr Id(uint32_t v) : BaseId(v) {} 2645 }; 2646 static_assert(std::is_trivially_destructible_v<Id>, 2647 "Inheritance used without trivial destruction"); 2648 2649 struct ColumnIndex { 2650 static constexpr uint32_t id = 0; 2651 static constexpr uint32_t type = 1; 2652 static constexpr uint32_t cpu = 2; 2653 static constexpr uint32_t cluster_id = 3; 2654 static constexpr uint32_t processor = 4; 2655 static constexpr uint32_t machine_id = 5; 2656 static constexpr uint32_t capacity = 6; 2657 static constexpr uint32_t arg_set_id = 7; 2658 }; 2659 struct ColumnType { 2660 using id = IdColumn<CpuTable::Id>; 2661 using type = TypedColumn<StringPool::Id>; 2662 using cpu = TypedColumn<std::optional<uint32_t>>; 2663 using cluster_id = TypedColumn<uint32_t>; 2664 using processor = TypedColumn<StringPool::Id>; 2665 using machine_id = TypedColumn<std::optional<MachineTable::Id>>; 2666 using capacity = TypedColumn<std::optional<uint32_t>>; 2667 using arg_set_id = TypedColumn<std::optional<uint32_t>>; 2668 }; 2669 struct Row : public macros_internal::RootParentTable::Row { 2670 Row(std::optional<uint32_t> in_cpu = {}, 2671 uint32_t in_cluster_id = {}, 2672 StringPool::Id in_processor = {}, 2673 std::optional<MachineTable::Id> in_machine_id = {}, 2674 std::optional<uint32_t> in_capacity = {}, 2675 std::optional<uint32_t> in_arg_set_id = {}, 2676 std::nullptr_t = nullptr) RowRow2677 : macros_internal::RootParentTable::Row(), 2678 cpu(in_cpu), 2679 cluster_id(in_cluster_id), 2680 processor(in_processor), 2681 machine_id(in_machine_id), 2682 capacity(in_capacity), 2683 arg_set_id(in_arg_set_id) { 2684 type_ = "__intrinsic_cpu"; 2685 } 2686 std::optional<uint32_t> cpu; 2687 uint32_t cluster_id; 2688 StringPool::Id processor; 2689 std::optional<MachineTable::Id> machine_id; 2690 std::optional<uint32_t> capacity; 2691 std::optional<uint32_t> arg_set_id; 2692 2693 bool operator==(const CpuTable::Row& other) const { 2694 return type() == other.type() && ColumnType::cpu::Equals(cpu, other.cpu) && 2695 ColumnType::cluster_id::Equals(cluster_id, other.cluster_id) && 2696 ColumnType::processor::Equals(processor, other.processor) && 2697 ColumnType::machine_id::Equals(machine_id, other.machine_id) && 2698 ColumnType::capacity::Equals(capacity, other.capacity) && 2699 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id); 2700 } 2701 }; 2702 struct ColumnFlag { 2703 static constexpr uint32_t cpu = ColumnType::cpu::default_flags(); 2704 static constexpr uint32_t cluster_id = ColumnType::cluster_id::default_flags(); 2705 static constexpr uint32_t processor = ColumnType::processor::default_flags(); 2706 static constexpr uint32_t machine_id = ColumnType::machine_id::default_flags(); 2707 static constexpr uint32_t capacity = ColumnType::capacity::default_flags(); 2708 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 2709 }; 2710 2711 class RowNumber; 2712 class ConstRowReference; 2713 class RowReference; 2714 2715 class RowNumber : public macros_internal::AbstractRowNumber< 2716 CpuTable, ConstRowReference, RowReference> { 2717 public: RowNumber(uint32_t row_number)2718 explicit RowNumber(uint32_t row_number) 2719 : AbstractRowNumber(row_number) {} 2720 }; 2721 static_assert(std::is_trivially_destructible_v<RowNumber>, 2722 "Inheritance used without trivial destruction"); 2723 2724 class ConstRowReference : public macros_internal::AbstractConstRowReference< 2725 CpuTable, RowNumber> { 2726 public: ConstRowReference(const CpuTable * table,uint32_t row_number)2727 ConstRowReference(const CpuTable* table, uint32_t row_number) 2728 : AbstractConstRowReference(table, row_number) {} 2729 id()2730 ColumnType::id::type id() const { 2731 return table()->id()[row_number_]; 2732 } type()2733 ColumnType::type::type type() const { 2734 return table()->type()[row_number_]; 2735 } cpu()2736 ColumnType::cpu::type cpu() const { 2737 return table()->cpu()[row_number_]; 2738 } cluster_id()2739 ColumnType::cluster_id::type cluster_id() const { 2740 return table()->cluster_id()[row_number_]; 2741 } processor()2742 ColumnType::processor::type processor() const { 2743 return table()->processor()[row_number_]; 2744 } machine_id()2745 ColumnType::machine_id::type machine_id() const { 2746 return table()->machine_id()[row_number_]; 2747 } capacity()2748 ColumnType::capacity::type capacity() const { 2749 return table()->capacity()[row_number_]; 2750 } arg_set_id()2751 ColumnType::arg_set_id::type arg_set_id() const { 2752 return table()->arg_set_id()[row_number_]; 2753 } 2754 }; 2755 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 2756 "Inheritance used without trivial destruction"); 2757 class RowReference : public ConstRowReference { 2758 public: RowReference(const CpuTable * table,uint32_t row_number)2759 RowReference(const CpuTable* table, uint32_t row_number) 2760 : ConstRowReference(table, row_number) {} 2761 set_cpu(ColumnType::cpu::non_optional_type v)2762 void set_cpu( 2763 ColumnType::cpu::non_optional_type v) { 2764 return mutable_table()->mutable_cpu()->Set(row_number_, v); 2765 } set_cluster_id(ColumnType::cluster_id::non_optional_type v)2766 void set_cluster_id( 2767 ColumnType::cluster_id::non_optional_type v) { 2768 return mutable_table()->mutable_cluster_id()->Set(row_number_, v); 2769 } set_processor(ColumnType::processor::non_optional_type v)2770 void set_processor( 2771 ColumnType::processor::non_optional_type v) { 2772 return mutable_table()->mutable_processor()->Set(row_number_, v); 2773 } set_machine_id(ColumnType::machine_id::non_optional_type v)2774 void set_machine_id( 2775 ColumnType::machine_id::non_optional_type v) { 2776 return mutable_table()->mutable_machine_id()->Set(row_number_, v); 2777 } set_capacity(ColumnType::capacity::non_optional_type v)2778 void set_capacity( 2779 ColumnType::capacity::non_optional_type v) { 2780 return mutable_table()->mutable_capacity()->Set(row_number_, v); 2781 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)2782 void set_arg_set_id( 2783 ColumnType::arg_set_id::non_optional_type v) { 2784 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 2785 } 2786 2787 private: mutable_table()2788 CpuTable* mutable_table() const { 2789 return const_cast<CpuTable*>(table()); 2790 } 2791 }; 2792 static_assert(std::is_trivially_destructible_v<RowReference>, 2793 "Inheritance used without trivial destruction"); 2794 2795 class ConstIterator; 2796 class ConstIterator : public macros_internal::AbstractConstIterator< 2797 ConstIterator, CpuTable, RowNumber, ConstRowReference> { 2798 public: id()2799 ColumnType::id::type id() const { 2800 const auto& col = table()->id(); 2801 return col.GetAtIdx( 2802 iterator_.StorageIndexForColumn(col.index_in_table())); 2803 } type()2804 ColumnType::type::type type() const { 2805 const auto& col = table()->type(); 2806 return col.GetAtIdx( 2807 iterator_.StorageIndexForColumn(col.index_in_table())); 2808 } cpu()2809 ColumnType::cpu::type cpu() const { 2810 const auto& col = table()->cpu(); 2811 return col.GetAtIdx( 2812 iterator_.StorageIndexForColumn(col.index_in_table())); 2813 } cluster_id()2814 ColumnType::cluster_id::type cluster_id() const { 2815 const auto& col = table()->cluster_id(); 2816 return col.GetAtIdx( 2817 iterator_.StorageIndexForColumn(col.index_in_table())); 2818 } processor()2819 ColumnType::processor::type processor() const { 2820 const auto& col = table()->processor(); 2821 return col.GetAtIdx( 2822 iterator_.StorageIndexForColumn(col.index_in_table())); 2823 } machine_id()2824 ColumnType::machine_id::type machine_id() const { 2825 const auto& col = table()->machine_id(); 2826 return col.GetAtIdx( 2827 iterator_.StorageIndexForColumn(col.index_in_table())); 2828 } capacity()2829 ColumnType::capacity::type capacity() const { 2830 const auto& col = table()->capacity(); 2831 return col.GetAtIdx( 2832 iterator_.StorageIndexForColumn(col.index_in_table())); 2833 } arg_set_id()2834 ColumnType::arg_set_id::type arg_set_id() const { 2835 const auto& col = table()->arg_set_id(); 2836 return col.GetAtIdx( 2837 iterator_.StorageIndexForColumn(col.index_in_table())); 2838 } 2839 2840 protected: ConstIterator(const CpuTable * table,Table::Iterator iterator)2841 explicit ConstIterator(const CpuTable* table, 2842 Table::Iterator iterator) 2843 : AbstractConstIterator(table, std::move(iterator)) {} 2844 CurrentRowNumber()2845 uint32_t CurrentRowNumber() const { 2846 return iterator_.StorageIndexForLastOverlay(); 2847 } 2848 2849 private: 2850 friend class CpuTable; 2851 friend class macros_internal::AbstractConstIterator< 2852 ConstIterator, CpuTable, RowNumber, ConstRowReference>; 2853 }; 2854 class Iterator : public ConstIterator { 2855 public: row_reference()2856 RowReference row_reference() const { 2857 return {const_cast<CpuTable*>(table()), CurrentRowNumber()}; 2858 } 2859 2860 private: 2861 friend class CpuTable; 2862 Iterator(CpuTable * table,Table::Iterator iterator)2863 explicit Iterator(CpuTable* table, Table::Iterator iterator) 2864 : ConstIterator(table, std::move(iterator)) {} 2865 }; 2866 2867 struct IdAndRow { 2868 Id id; 2869 uint32_t row; 2870 RowReference row_reference; 2871 RowNumber row_number; 2872 }; 2873 GetColumns(CpuTable * self,const macros_internal::MacroTable * parent)2874 static std::vector<ColumnLegacy> GetColumns( 2875 CpuTable* self, 2876 const macros_internal::MacroTable* parent) { 2877 std::vector<ColumnLegacy> columns = 2878 CopyColumnsFromParentOrAddRootColumns(self, parent); 2879 uint32_t olay_idx = OverlayCount(parent); 2880 AddColumnToVector(columns, "cpu", &self->cpu_, ColumnFlag::cpu, 2881 static_cast<uint32_t>(columns.size()), olay_idx); 2882 AddColumnToVector(columns, "cluster_id", &self->cluster_id_, ColumnFlag::cluster_id, 2883 static_cast<uint32_t>(columns.size()), olay_idx); 2884 AddColumnToVector(columns, "processor", &self->processor_, ColumnFlag::processor, 2885 static_cast<uint32_t>(columns.size()), olay_idx); 2886 AddColumnToVector(columns, "machine_id", &self->machine_id_, ColumnFlag::machine_id, 2887 static_cast<uint32_t>(columns.size()), olay_idx); 2888 AddColumnToVector(columns, "capacity", &self->capacity_, ColumnFlag::capacity, 2889 static_cast<uint32_t>(columns.size()), olay_idx); 2890 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2891 static_cast<uint32_t>(columns.size()), olay_idx); 2892 return columns; 2893 } 2894 CpuTable(StringPool * pool)2895 PERFETTO_NO_INLINE explicit CpuTable(StringPool* pool) 2896 : macros_internal::MacroTable( 2897 pool, 2898 GetColumns(this, nullptr), 2899 nullptr), 2900 cpu_(ColumnStorage<ColumnType::cpu::stored_type>::Create<false>()), 2901 cluster_id_(ColumnStorage<ColumnType::cluster_id::stored_type>::Create<false>()), 2902 processor_(ColumnStorage<ColumnType::processor::stored_type>::Create<false>()), 2903 machine_id_(ColumnStorage<ColumnType::machine_id::stored_type>::Create<false>()), 2904 capacity_(ColumnStorage<ColumnType::capacity::stored_type>::Create<false>()), 2905 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()) 2906 , 2907 id_storage_layer_(new column::IdStorage()), 2908 type_storage_layer_( 2909 new column::StringStorage(string_pool(), &type_.vector())), 2910 cpu_storage_layer_( 2911 new column::NumericStorage<ColumnType::cpu::non_optional_stored_type>( 2912 &cpu_.non_null_vector(), 2913 ColumnTypeHelper<ColumnType::cpu::stored_type>::ToColumnType(), 2914 false)), 2915 cluster_id_storage_layer_( 2916 new column::NumericStorage<ColumnType::cluster_id::non_optional_stored_type>( 2917 &cluster_id_.vector(), 2918 ColumnTypeHelper<ColumnType::cluster_id::stored_type>::ToColumnType(), 2919 false)), 2920 processor_storage_layer_( 2921 new column::StringStorage(string_pool(), &processor_.vector())), 2922 machine_id_storage_layer_( 2923 new column::NumericStorage<ColumnType::machine_id::non_optional_stored_type>( 2924 &machine_id_.non_null_vector(), 2925 ColumnTypeHelper<ColumnType::machine_id::stored_type>::ToColumnType(), 2926 false)), 2927 capacity_storage_layer_( 2928 new column::NumericStorage<ColumnType::capacity::non_optional_stored_type>( 2929 &capacity_.non_null_vector(), 2930 ColumnTypeHelper<ColumnType::capacity::stored_type>::ToColumnType(), 2931 false)), 2932 arg_set_id_storage_layer_( 2933 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 2934 &arg_set_id_.non_null_vector(), 2935 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 2936 false)) 2937 , 2938 cpu_null_layer_(new column::NullOverlay(cpu_.bv())), 2939 machine_id_null_layer_(new column::NullOverlay(machine_id_.bv())), 2940 capacity_null_layer_(new column::NullOverlay(capacity_.bv())), 2941 arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())) { 2942 static_assert( 2943 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::cpu::stored_type>( 2944 ColumnFlag::cpu), 2945 "Column type and flag combination is not valid"); 2946 static_assert( 2947 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::cluster_id::stored_type>( 2948 ColumnFlag::cluster_id), 2949 "Column type and flag combination is not valid"); 2950 static_assert( 2951 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::processor::stored_type>( 2952 ColumnFlag::processor), 2953 "Column type and flag combination is not valid"); 2954 static_assert( 2955 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::machine_id::stored_type>( 2956 ColumnFlag::machine_id), 2957 "Column type and flag combination is not valid"); 2958 static_assert( 2959 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::capacity::stored_type>( 2960 ColumnFlag::capacity), 2961 "Column type and flag combination is not valid"); 2962 static_assert( 2963 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 2964 ColumnFlag::arg_set_id), 2965 "Column type and flag combination is not valid"); 2966 OnConstructionCompletedRegularConstructor( 2967 {id_storage_layer_,type_storage_layer_,cpu_storage_layer_,cluster_id_storage_layer_,processor_storage_layer_,machine_id_storage_layer_,capacity_storage_layer_,arg_set_id_storage_layer_}, 2968 {{},{},cpu_null_layer_,{},{},machine_id_null_layer_,capacity_null_layer_,arg_set_id_null_layer_}); 2969 } 2970 ~CpuTable() override; 2971 Name()2972 static const char* Name() { return "__intrinsic_cpu"; } 2973 ComputeStaticSchema()2974 static Table::Schema ComputeStaticSchema() { 2975 Table::Schema schema; 2976 schema.columns.emplace_back(Table::Schema::Column{ 2977 "id", SqlValue::Type::kLong, true, true, false, false}); 2978 schema.columns.emplace_back(Table::Schema::Column{ 2979 "type", SqlValue::Type::kString, false, false, false, false}); 2980 schema.columns.emplace_back(Table::Schema::Column{ 2981 "cpu", ColumnType::cpu::SqlValueType(), false, 2982 false, 2983 false, 2984 false}); 2985 schema.columns.emplace_back(Table::Schema::Column{ 2986 "cluster_id", ColumnType::cluster_id::SqlValueType(), false, 2987 false, 2988 false, 2989 false}); 2990 schema.columns.emplace_back(Table::Schema::Column{ 2991 "processor", ColumnType::processor::SqlValueType(), false, 2992 false, 2993 false, 2994 false}); 2995 schema.columns.emplace_back(Table::Schema::Column{ 2996 "machine_id", ColumnType::machine_id::SqlValueType(), false, 2997 false, 2998 false, 2999 false}); 3000 schema.columns.emplace_back(Table::Schema::Column{ 3001 "capacity", ColumnType::capacity::SqlValueType(), false, 3002 false, 3003 false, 3004 false}); 3005 schema.columns.emplace_back(Table::Schema::Column{ 3006 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 3007 false, 3008 false, 3009 false}); 3010 return schema; 3011 } 3012 IterateRows()3013 ConstIterator IterateRows() const { 3014 return ConstIterator(this, Table::IterateRows()); 3015 } 3016 IterateRows()3017 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 3018 FilterToIterator(const Query & q)3019 ConstIterator FilterToIterator(const Query& q) const { 3020 return ConstIterator(this, QueryToIterator(q)); 3021 } 3022 FilterToIterator(const Query & q)3023 Iterator FilterToIterator(const Query& q) { 3024 return Iterator(this, QueryToIterator(q)); 3025 } 3026 ShrinkToFit()3027 void ShrinkToFit() { 3028 type_.ShrinkToFit(); 3029 cpu_.ShrinkToFit(); 3030 cluster_id_.ShrinkToFit(); 3031 processor_.ShrinkToFit(); 3032 machine_id_.ShrinkToFit(); 3033 capacity_.ShrinkToFit(); 3034 arg_set_id_.ShrinkToFit(); 3035 } 3036 3037 ConstRowReference operator[](uint32_t r) const { 3038 return ConstRowReference(this, r); 3039 } 3040 RowReference operator[](uint32_t r) { return RowReference(this, r); } 3041 ConstRowReference operator[](RowNumber r) const { 3042 return ConstRowReference(this, r.row_number()); 3043 } 3044 RowReference operator[](RowNumber r) { 3045 return RowReference(this, r.row_number()); 3046 } 3047 FindById(Id find_id)3048 std::optional<ConstRowReference> FindById(Id find_id) const { 3049 std::optional<uint32_t> row = id().IndexOf(find_id); 3050 return row ? std::make_optional(ConstRowReference(this, *row)) 3051 : std::nullopt; 3052 } 3053 FindById(Id find_id)3054 std::optional<RowReference> FindById(Id find_id) { 3055 std::optional<uint32_t> row = id().IndexOf(find_id); 3056 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 3057 } 3058 Insert(const Row & row)3059 IdAndRow Insert(const Row& row) { 3060 uint32_t row_number = row_count(); 3061 Id id = Id{row_number}; 3062 type_.Append(string_pool()->InternString(row.type())); 3063 mutable_cpu()->Append(row.cpu); 3064 mutable_cluster_id()->Append(row.cluster_id); 3065 mutable_processor()->Append(row.processor); 3066 mutable_machine_id()->Append(row.machine_id); 3067 mutable_capacity()->Append(row.capacity); 3068 mutable_arg_set_id()->Append(row.arg_set_id); 3069 UpdateSelfOverlayAfterInsert(); 3070 return IdAndRow{id, row_number, RowReference(this, row_number), 3071 RowNumber(row_number)}; 3072 } 3073 3074 3075 id()3076 const IdColumn<CpuTable::Id>& id() const { 3077 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 3078 } type()3079 const TypedColumn<StringPool::Id>& type() const { 3080 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 3081 } cpu()3082 const TypedColumn<std::optional<uint32_t>>& cpu() const { 3083 return static_cast<const ColumnType::cpu&>(columns()[ColumnIndex::cpu]); 3084 } cluster_id()3085 const TypedColumn<uint32_t>& cluster_id() const { 3086 return static_cast<const ColumnType::cluster_id&>(columns()[ColumnIndex::cluster_id]); 3087 } processor()3088 const TypedColumn<StringPool::Id>& processor() const { 3089 return static_cast<const ColumnType::processor&>(columns()[ColumnIndex::processor]); 3090 } machine_id()3091 const TypedColumn<std::optional<MachineTable::Id>>& machine_id() const { 3092 return static_cast<const ColumnType::machine_id&>(columns()[ColumnIndex::machine_id]); 3093 } capacity()3094 const TypedColumn<std::optional<uint32_t>>& capacity() const { 3095 return static_cast<const ColumnType::capacity&>(columns()[ColumnIndex::capacity]); 3096 } arg_set_id()3097 const TypedColumn<std::optional<uint32_t>>& arg_set_id() const { 3098 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 3099 } 3100 mutable_cpu()3101 TypedColumn<std::optional<uint32_t>>* mutable_cpu() { 3102 return static_cast<ColumnType::cpu*>( 3103 GetColumn(ColumnIndex::cpu)); 3104 } mutable_cluster_id()3105 TypedColumn<uint32_t>* mutable_cluster_id() { 3106 return static_cast<ColumnType::cluster_id*>( 3107 GetColumn(ColumnIndex::cluster_id)); 3108 } mutable_processor()3109 TypedColumn<StringPool::Id>* mutable_processor() { 3110 return static_cast<ColumnType::processor*>( 3111 GetColumn(ColumnIndex::processor)); 3112 } mutable_machine_id()3113 TypedColumn<std::optional<MachineTable::Id>>* mutable_machine_id() { 3114 return static_cast<ColumnType::machine_id*>( 3115 GetColumn(ColumnIndex::machine_id)); 3116 } mutable_capacity()3117 TypedColumn<std::optional<uint32_t>>* mutable_capacity() { 3118 return static_cast<ColumnType::capacity*>( 3119 GetColumn(ColumnIndex::capacity)); 3120 } mutable_arg_set_id()3121 TypedColumn<std::optional<uint32_t>>* mutable_arg_set_id() { 3122 return static_cast<ColumnType::arg_set_id*>( 3123 GetColumn(ColumnIndex::arg_set_id)); 3124 } 3125 3126 private: 3127 3128 3129 ColumnStorage<ColumnType::cpu::stored_type> cpu_; 3130 ColumnStorage<ColumnType::cluster_id::stored_type> cluster_id_; 3131 ColumnStorage<ColumnType::processor::stored_type> processor_; 3132 ColumnStorage<ColumnType::machine_id::stored_type> machine_id_; 3133 ColumnStorage<ColumnType::capacity::stored_type> capacity_; 3134 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 3135 3136 RefPtr<column::StorageLayer> id_storage_layer_; 3137 RefPtr<column::StorageLayer> type_storage_layer_; 3138 RefPtr<column::StorageLayer> cpu_storage_layer_; 3139 RefPtr<column::StorageLayer> cluster_id_storage_layer_; 3140 RefPtr<column::StorageLayer> processor_storage_layer_; 3141 RefPtr<column::StorageLayer> machine_id_storage_layer_; 3142 RefPtr<column::StorageLayer> capacity_storage_layer_; 3143 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 3144 3145 RefPtr<column::OverlayLayer> cpu_null_layer_; 3146 RefPtr<column::OverlayLayer> machine_id_null_layer_; 3147 RefPtr<column::OverlayLayer> capacity_null_layer_; 3148 RefPtr<column::OverlayLayer> arg_set_id_null_layer_; 3149 }; 3150 3151 3152 class CpuFreqTable : public macros_internal::MacroTable { 3153 public: 3154 static constexpr uint32_t kColumnCount = 4; 3155 3156 struct Id : public BaseId { 3157 Id() = default; IdId3158 explicit constexpr Id(uint32_t v) : BaseId(v) {} 3159 }; 3160 static_assert(std::is_trivially_destructible_v<Id>, 3161 "Inheritance used without trivial destruction"); 3162 3163 struct ColumnIndex { 3164 static constexpr uint32_t id = 0; 3165 static constexpr uint32_t type = 1; 3166 static constexpr uint32_t ucpu = 2; 3167 static constexpr uint32_t freq = 3; 3168 }; 3169 struct ColumnType { 3170 using id = IdColumn<CpuFreqTable::Id>; 3171 using type = TypedColumn<StringPool::Id>; 3172 using ucpu = TypedColumn<CpuTable::Id>; 3173 using freq = TypedColumn<uint32_t>; 3174 }; 3175 struct Row : public macros_internal::RootParentTable::Row { 3176 Row(CpuTable::Id in_ucpu = {}, 3177 uint32_t in_freq = {}, 3178 std::nullptr_t = nullptr) RowRow3179 : macros_internal::RootParentTable::Row(), 3180 ucpu(in_ucpu), 3181 freq(in_freq) { 3182 type_ = "__intrinsic_cpu_freq"; 3183 } 3184 CpuTable::Id ucpu; 3185 uint32_t freq; 3186 3187 bool operator==(const CpuFreqTable::Row& other) const { 3188 return type() == other.type() && ColumnType::ucpu::Equals(ucpu, other.ucpu) && 3189 ColumnType::freq::Equals(freq, other.freq); 3190 } 3191 }; 3192 struct ColumnFlag { 3193 static constexpr uint32_t ucpu = ColumnType::ucpu::default_flags(); 3194 static constexpr uint32_t freq = ColumnType::freq::default_flags(); 3195 }; 3196 3197 class RowNumber; 3198 class ConstRowReference; 3199 class RowReference; 3200 3201 class RowNumber : public macros_internal::AbstractRowNumber< 3202 CpuFreqTable, ConstRowReference, RowReference> { 3203 public: RowNumber(uint32_t row_number)3204 explicit RowNumber(uint32_t row_number) 3205 : AbstractRowNumber(row_number) {} 3206 }; 3207 static_assert(std::is_trivially_destructible_v<RowNumber>, 3208 "Inheritance used without trivial destruction"); 3209 3210 class ConstRowReference : public macros_internal::AbstractConstRowReference< 3211 CpuFreqTable, RowNumber> { 3212 public: ConstRowReference(const CpuFreqTable * table,uint32_t row_number)3213 ConstRowReference(const CpuFreqTable* table, uint32_t row_number) 3214 : AbstractConstRowReference(table, row_number) {} 3215 id()3216 ColumnType::id::type id() const { 3217 return table()->id()[row_number_]; 3218 } type()3219 ColumnType::type::type type() const { 3220 return table()->type()[row_number_]; 3221 } ucpu()3222 ColumnType::ucpu::type ucpu() const { 3223 return table()->ucpu()[row_number_]; 3224 } freq()3225 ColumnType::freq::type freq() const { 3226 return table()->freq()[row_number_]; 3227 } 3228 }; 3229 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 3230 "Inheritance used without trivial destruction"); 3231 class RowReference : public ConstRowReference { 3232 public: RowReference(const CpuFreqTable * table,uint32_t row_number)3233 RowReference(const CpuFreqTable* table, uint32_t row_number) 3234 : ConstRowReference(table, row_number) {} 3235 set_ucpu(ColumnType::ucpu::non_optional_type v)3236 void set_ucpu( 3237 ColumnType::ucpu::non_optional_type v) { 3238 return mutable_table()->mutable_ucpu()->Set(row_number_, v); 3239 } set_freq(ColumnType::freq::non_optional_type v)3240 void set_freq( 3241 ColumnType::freq::non_optional_type v) { 3242 return mutable_table()->mutable_freq()->Set(row_number_, v); 3243 } 3244 3245 private: mutable_table()3246 CpuFreqTable* mutable_table() const { 3247 return const_cast<CpuFreqTable*>(table()); 3248 } 3249 }; 3250 static_assert(std::is_trivially_destructible_v<RowReference>, 3251 "Inheritance used without trivial destruction"); 3252 3253 class ConstIterator; 3254 class ConstIterator : public macros_internal::AbstractConstIterator< 3255 ConstIterator, CpuFreqTable, RowNumber, ConstRowReference> { 3256 public: id()3257 ColumnType::id::type id() const { 3258 const auto& col = table()->id(); 3259 return col.GetAtIdx( 3260 iterator_.StorageIndexForColumn(col.index_in_table())); 3261 } type()3262 ColumnType::type::type type() const { 3263 const auto& col = table()->type(); 3264 return col.GetAtIdx( 3265 iterator_.StorageIndexForColumn(col.index_in_table())); 3266 } ucpu()3267 ColumnType::ucpu::type ucpu() const { 3268 const auto& col = table()->ucpu(); 3269 return col.GetAtIdx( 3270 iterator_.StorageIndexForColumn(col.index_in_table())); 3271 } freq()3272 ColumnType::freq::type freq() const { 3273 const auto& col = table()->freq(); 3274 return col.GetAtIdx( 3275 iterator_.StorageIndexForColumn(col.index_in_table())); 3276 } 3277 3278 protected: ConstIterator(const CpuFreqTable * table,Table::Iterator iterator)3279 explicit ConstIterator(const CpuFreqTable* table, 3280 Table::Iterator iterator) 3281 : AbstractConstIterator(table, std::move(iterator)) {} 3282 CurrentRowNumber()3283 uint32_t CurrentRowNumber() const { 3284 return iterator_.StorageIndexForLastOverlay(); 3285 } 3286 3287 private: 3288 friend class CpuFreqTable; 3289 friend class macros_internal::AbstractConstIterator< 3290 ConstIterator, CpuFreqTable, RowNumber, ConstRowReference>; 3291 }; 3292 class Iterator : public ConstIterator { 3293 public: row_reference()3294 RowReference row_reference() const { 3295 return {const_cast<CpuFreqTable*>(table()), CurrentRowNumber()}; 3296 } 3297 3298 private: 3299 friend class CpuFreqTable; 3300 Iterator(CpuFreqTable * table,Table::Iterator iterator)3301 explicit Iterator(CpuFreqTable* table, Table::Iterator iterator) 3302 : ConstIterator(table, std::move(iterator)) {} 3303 }; 3304 3305 struct IdAndRow { 3306 Id id; 3307 uint32_t row; 3308 RowReference row_reference; 3309 RowNumber row_number; 3310 }; 3311 GetColumns(CpuFreqTable * self,const macros_internal::MacroTable * parent)3312 static std::vector<ColumnLegacy> GetColumns( 3313 CpuFreqTable* self, 3314 const macros_internal::MacroTable* parent) { 3315 std::vector<ColumnLegacy> columns = 3316 CopyColumnsFromParentOrAddRootColumns(self, parent); 3317 uint32_t olay_idx = OverlayCount(parent); 3318 AddColumnToVector(columns, "ucpu", &self->ucpu_, ColumnFlag::ucpu, 3319 static_cast<uint32_t>(columns.size()), olay_idx); 3320 AddColumnToVector(columns, "freq", &self->freq_, ColumnFlag::freq, 3321 static_cast<uint32_t>(columns.size()), olay_idx); 3322 return columns; 3323 } 3324 CpuFreqTable(StringPool * pool)3325 PERFETTO_NO_INLINE explicit CpuFreqTable(StringPool* pool) 3326 : macros_internal::MacroTable( 3327 pool, 3328 GetColumns(this, nullptr), 3329 nullptr), 3330 ucpu_(ColumnStorage<ColumnType::ucpu::stored_type>::Create<false>()), 3331 freq_(ColumnStorage<ColumnType::freq::stored_type>::Create<false>()) 3332 , 3333 id_storage_layer_(new column::IdStorage()), 3334 type_storage_layer_( 3335 new column::StringStorage(string_pool(), &type_.vector())), 3336 ucpu_storage_layer_( 3337 new column::NumericStorage<ColumnType::ucpu::non_optional_stored_type>( 3338 &ucpu_.vector(), 3339 ColumnTypeHelper<ColumnType::ucpu::stored_type>::ToColumnType(), 3340 false)), 3341 freq_storage_layer_( 3342 new column::NumericStorage<ColumnType::freq::non_optional_stored_type>( 3343 &freq_.vector(), 3344 ColumnTypeHelper<ColumnType::freq::stored_type>::ToColumnType(), 3345 false)) 3346 { 3347 static_assert( 3348 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ucpu::stored_type>( 3349 ColumnFlag::ucpu), 3350 "Column type and flag combination is not valid"); 3351 static_assert( 3352 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::freq::stored_type>( 3353 ColumnFlag::freq), 3354 "Column type and flag combination is not valid"); 3355 OnConstructionCompletedRegularConstructor( 3356 {id_storage_layer_,type_storage_layer_,ucpu_storage_layer_,freq_storage_layer_}, 3357 {{},{},{},{}}); 3358 } 3359 ~CpuFreqTable() override; 3360 Name()3361 static const char* Name() { return "__intrinsic_cpu_freq"; } 3362 ComputeStaticSchema()3363 static Table::Schema ComputeStaticSchema() { 3364 Table::Schema schema; 3365 schema.columns.emplace_back(Table::Schema::Column{ 3366 "id", SqlValue::Type::kLong, true, true, false, false}); 3367 schema.columns.emplace_back(Table::Schema::Column{ 3368 "type", SqlValue::Type::kString, false, false, false, false}); 3369 schema.columns.emplace_back(Table::Schema::Column{ 3370 "ucpu", ColumnType::ucpu::SqlValueType(), false, 3371 false, 3372 false, 3373 false}); 3374 schema.columns.emplace_back(Table::Schema::Column{ 3375 "freq", ColumnType::freq::SqlValueType(), false, 3376 false, 3377 false, 3378 false}); 3379 return schema; 3380 } 3381 IterateRows()3382 ConstIterator IterateRows() const { 3383 return ConstIterator(this, Table::IterateRows()); 3384 } 3385 IterateRows()3386 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 3387 FilterToIterator(const Query & q)3388 ConstIterator FilterToIterator(const Query& q) const { 3389 return ConstIterator(this, QueryToIterator(q)); 3390 } 3391 FilterToIterator(const Query & q)3392 Iterator FilterToIterator(const Query& q) { 3393 return Iterator(this, QueryToIterator(q)); 3394 } 3395 ShrinkToFit()3396 void ShrinkToFit() { 3397 type_.ShrinkToFit(); 3398 ucpu_.ShrinkToFit(); 3399 freq_.ShrinkToFit(); 3400 } 3401 3402 ConstRowReference operator[](uint32_t r) const { 3403 return ConstRowReference(this, r); 3404 } 3405 RowReference operator[](uint32_t r) { return RowReference(this, r); } 3406 ConstRowReference operator[](RowNumber r) const { 3407 return ConstRowReference(this, r.row_number()); 3408 } 3409 RowReference operator[](RowNumber r) { 3410 return RowReference(this, r.row_number()); 3411 } 3412 FindById(Id find_id)3413 std::optional<ConstRowReference> FindById(Id find_id) const { 3414 std::optional<uint32_t> row = id().IndexOf(find_id); 3415 return row ? std::make_optional(ConstRowReference(this, *row)) 3416 : std::nullopt; 3417 } 3418 FindById(Id find_id)3419 std::optional<RowReference> FindById(Id find_id) { 3420 std::optional<uint32_t> row = id().IndexOf(find_id); 3421 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 3422 } 3423 Insert(const Row & row)3424 IdAndRow Insert(const Row& row) { 3425 uint32_t row_number = row_count(); 3426 Id id = Id{row_number}; 3427 type_.Append(string_pool()->InternString(row.type())); 3428 mutable_ucpu()->Append(row.ucpu); 3429 mutable_freq()->Append(row.freq); 3430 UpdateSelfOverlayAfterInsert(); 3431 return IdAndRow{id, row_number, RowReference(this, row_number), 3432 RowNumber(row_number)}; 3433 } 3434 3435 3436 id()3437 const IdColumn<CpuFreqTable::Id>& id() const { 3438 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 3439 } type()3440 const TypedColumn<StringPool::Id>& type() const { 3441 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 3442 } ucpu()3443 const TypedColumn<CpuTable::Id>& ucpu() const { 3444 return static_cast<const ColumnType::ucpu&>(columns()[ColumnIndex::ucpu]); 3445 } freq()3446 const TypedColumn<uint32_t>& freq() const { 3447 return static_cast<const ColumnType::freq&>(columns()[ColumnIndex::freq]); 3448 } 3449 mutable_ucpu()3450 TypedColumn<CpuTable::Id>* mutable_ucpu() { 3451 return static_cast<ColumnType::ucpu*>( 3452 GetColumn(ColumnIndex::ucpu)); 3453 } mutable_freq()3454 TypedColumn<uint32_t>* mutable_freq() { 3455 return static_cast<ColumnType::freq*>( 3456 GetColumn(ColumnIndex::freq)); 3457 } 3458 3459 private: 3460 3461 3462 ColumnStorage<ColumnType::ucpu::stored_type> ucpu_; 3463 ColumnStorage<ColumnType::freq::stored_type> freq_; 3464 3465 RefPtr<column::StorageLayer> id_storage_layer_; 3466 RefPtr<column::StorageLayer> type_storage_layer_; 3467 RefPtr<column::StorageLayer> ucpu_storage_layer_; 3468 RefPtr<column::StorageLayer> freq_storage_layer_; 3469 3470 3471 }; 3472 3473 3474 class ExpMissingChromeProcTable : public macros_internal::MacroTable { 3475 public: 3476 static constexpr uint32_t kColumnCount = 4; 3477 3478 struct Id : public BaseId { 3479 Id() = default; IdId3480 explicit constexpr Id(uint32_t v) : BaseId(v) {} 3481 }; 3482 static_assert(std::is_trivially_destructible_v<Id>, 3483 "Inheritance used without trivial destruction"); 3484 3485 struct ColumnIndex { 3486 static constexpr uint32_t id = 0; 3487 static constexpr uint32_t type = 1; 3488 static constexpr uint32_t upid = 2; 3489 static constexpr uint32_t reliable_from = 3; 3490 }; 3491 struct ColumnType { 3492 using id = IdColumn<ExpMissingChromeProcTable::Id>; 3493 using type = TypedColumn<StringPool::Id>; 3494 using upid = TypedColumn<uint32_t>; 3495 using reliable_from = TypedColumn<std::optional<int64_t>>; 3496 }; 3497 struct Row : public macros_internal::RootParentTable::Row { 3498 Row(uint32_t in_upid = {}, 3499 std::optional<int64_t> in_reliable_from = {}, 3500 std::nullptr_t = nullptr) RowRow3501 : macros_internal::RootParentTable::Row(), 3502 upid(in_upid), 3503 reliable_from(in_reliable_from) { 3504 type_ = "experimental_missing_chrome_processes"; 3505 } 3506 uint32_t upid; 3507 std::optional<int64_t> reliable_from; 3508 3509 bool operator==(const ExpMissingChromeProcTable::Row& other) const { 3510 return type() == other.type() && ColumnType::upid::Equals(upid, other.upid) && 3511 ColumnType::reliable_from::Equals(reliable_from, other.reliable_from); 3512 } 3513 }; 3514 struct ColumnFlag { 3515 static constexpr uint32_t upid = ColumnType::upid::default_flags(); 3516 static constexpr uint32_t reliable_from = ColumnType::reliable_from::default_flags(); 3517 }; 3518 3519 class RowNumber; 3520 class ConstRowReference; 3521 class RowReference; 3522 3523 class RowNumber : public macros_internal::AbstractRowNumber< 3524 ExpMissingChromeProcTable, ConstRowReference, RowReference> { 3525 public: RowNumber(uint32_t row_number)3526 explicit RowNumber(uint32_t row_number) 3527 : AbstractRowNumber(row_number) {} 3528 }; 3529 static_assert(std::is_trivially_destructible_v<RowNumber>, 3530 "Inheritance used without trivial destruction"); 3531 3532 class ConstRowReference : public macros_internal::AbstractConstRowReference< 3533 ExpMissingChromeProcTable, RowNumber> { 3534 public: ConstRowReference(const ExpMissingChromeProcTable * table,uint32_t row_number)3535 ConstRowReference(const ExpMissingChromeProcTable* table, uint32_t row_number) 3536 : AbstractConstRowReference(table, row_number) {} 3537 id()3538 ColumnType::id::type id() const { 3539 return table()->id()[row_number_]; 3540 } type()3541 ColumnType::type::type type() const { 3542 return table()->type()[row_number_]; 3543 } upid()3544 ColumnType::upid::type upid() const { 3545 return table()->upid()[row_number_]; 3546 } reliable_from()3547 ColumnType::reliable_from::type reliable_from() const { 3548 return table()->reliable_from()[row_number_]; 3549 } 3550 }; 3551 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 3552 "Inheritance used without trivial destruction"); 3553 class RowReference : public ConstRowReference { 3554 public: RowReference(const ExpMissingChromeProcTable * table,uint32_t row_number)3555 RowReference(const ExpMissingChromeProcTable* table, uint32_t row_number) 3556 : ConstRowReference(table, row_number) {} 3557 set_upid(ColumnType::upid::non_optional_type v)3558 void set_upid( 3559 ColumnType::upid::non_optional_type v) { 3560 return mutable_table()->mutable_upid()->Set(row_number_, v); 3561 } set_reliable_from(ColumnType::reliable_from::non_optional_type v)3562 void set_reliable_from( 3563 ColumnType::reliable_from::non_optional_type v) { 3564 return mutable_table()->mutable_reliable_from()->Set(row_number_, v); 3565 } 3566 3567 private: mutable_table()3568 ExpMissingChromeProcTable* mutable_table() const { 3569 return const_cast<ExpMissingChromeProcTable*>(table()); 3570 } 3571 }; 3572 static_assert(std::is_trivially_destructible_v<RowReference>, 3573 "Inheritance used without trivial destruction"); 3574 3575 class ConstIterator; 3576 class ConstIterator : public macros_internal::AbstractConstIterator< 3577 ConstIterator, ExpMissingChromeProcTable, RowNumber, ConstRowReference> { 3578 public: id()3579 ColumnType::id::type id() const { 3580 const auto& col = table()->id(); 3581 return col.GetAtIdx( 3582 iterator_.StorageIndexForColumn(col.index_in_table())); 3583 } type()3584 ColumnType::type::type type() const { 3585 const auto& col = table()->type(); 3586 return col.GetAtIdx( 3587 iterator_.StorageIndexForColumn(col.index_in_table())); 3588 } upid()3589 ColumnType::upid::type upid() const { 3590 const auto& col = table()->upid(); 3591 return col.GetAtIdx( 3592 iterator_.StorageIndexForColumn(col.index_in_table())); 3593 } reliable_from()3594 ColumnType::reliable_from::type reliable_from() const { 3595 const auto& col = table()->reliable_from(); 3596 return col.GetAtIdx( 3597 iterator_.StorageIndexForColumn(col.index_in_table())); 3598 } 3599 3600 protected: ConstIterator(const ExpMissingChromeProcTable * table,Table::Iterator iterator)3601 explicit ConstIterator(const ExpMissingChromeProcTable* table, 3602 Table::Iterator iterator) 3603 : AbstractConstIterator(table, std::move(iterator)) {} 3604 CurrentRowNumber()3605 uint32_t CurrentRowNumber() const { 3606 return iterator_.StorageIndexForLastOverlay(); 3607 } 3608 3609 private: 3610 friend class ExpMissingChromeProcTable; 3611 friend class macros_internal::AbstractConstIterator< 3612 ConstIterator, ExpMissingChromeProcTable, RowNumber, ConstRowReference>; 3613 }; 3614 class Iterator : public ConstIterator { 3615 public: row_reference()3616 RowReference row_reference() const { 3617 return {const_cast<ExpMissingChromeProcTable*>(table()), CurrentRowNumber()}; 3618 } 3619 3620 private: 3621 friend class ExpMissingChromeProcTable; 3622 Iterator(ExpMissingChromeProcTable * table,Table::Iterator iterator)3623 explicit Iterator(ExpMissingChromeProcTable* table, Table::Iterator iterator) 3624 : ConstIterator(table, std::move(iterator)) {} 3625 }; 3626 3627 struct IdAndRow { 3628 Id id; 3629 uint32_t row; 3630 RowReference row_reference; 3631 RowNumber row_number; 3632 }; 3633 GetColumns(ExpMissingChromeProcTable * self,const macros_internal::MacroTable * parent)3634 static std::vector<ColumnLegacy> GetColumns( 3635 ExpMissingChromeProcTable* self, 3636 const macros_internal::MacroTable* parent) { 3637 std::vector<ColumnLegacy> columns = 3638 CopyColumnsFromParentOrAddRootColumns(self, parent); 3639 uint32_t olay_idx = OverlayCount(parent); 3640 AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 3641 static_cast<uint32_t>(columns.size()), olay_idx); 3642 AddColumnToVector(columns, "reliable_from", &self->reliable_from_, ColumnFlag::reliable_from, 3643 static_cast<uint32_t>(columns.size()), olay_idx); 3644 return columns; 3645 } 3646 ExpMissingChromeProcTable(StringPool * pool)3647 PERFETTO_NO_INLINE explicit ExpMissingChromeProcTable(StringPool* pool) 3648 : macros_internal::MacroTable( 3649 pool, 3650 GetColumns(this, nullptr), 3651 nullptr), 3652 upid_(ColumnStorage<ColumnType::upid::stored_type>::Create<false>()), 3653 reliable_from_(ColumnStorage<ColumnType::reliable_from::stored_type>::Create<false>()) 3654 , 3655 id_storage_layer_(new column::IdStorage()), 3656 type_storage_layer_( 3657 new column::StringStorage(string_pool(), &type_.vector())), 3658 upid_storage_layer_( 3659 new column::NumericStorage<ColumnType::upid::non_optional_stored_type>( 3660 &upid_.vector(), 3661 ColumnTypeHelper<ColumnType::upid::stored_type>::ToColumnType(), 3662 false)), 3663 reliable_from_storage_layer_( 3664 new column::NumericStorage<ColumnType::reliable_from::non_optional_stored_type>( 3665 &reliable_from_.non_null_vector(), 3666 ColumnTypeHelper<ColumnType::reliable_from::stored_type>::ToColumnType(), 3667 false)) 3668 , 3669 reliable_from_null_layer_(new column::NullOverlay(reliable_from_.bv())) { 3670 static_assert( 3671 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::upid::stored_type>( 3672 ColumnFlag::upid), 3673 "Column type and flag combination is not valid"); 3674 static_assert( 3675 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::reliable_from::stored_type>( 3676 ColumnFlag::reliable_from), 3677 "Column type and flag combination is not valid"); 3678 OnConstructionCompletedRegularConstructor( 3679 {id_storage_layer_,type_storage_layer_,upid_storage_layer_,reliable_from_storage_layer_}, 3680 {{},{},{},reliable_from_null_layer_}); 3681 } 3682 ~ExpMissingChromeProcTable() override; 3683 Name()3684 static const char* Name() { return "experimental_missing_chrome_processes"; } 3685 ComputeStaticSchema()3686 static Table::Schema ComputeStaticSchema() { 3687 Table::Schema schema; 3688 schema.columns.emplace_back(Table::Schema::Column{ 3689 "id", SqlValue::Type::kLong, true, true, false, false}); 3690 schema.columns.emplace_back(Table::Schema::Column{ 3691 "type", SqlValue::Type::kString, false, false, false, false}); 3692 schema.columns.emplace_back(Table::Schema::Column{ 3693 "upid", ColumnType::upid::SqlValueType(), false, 3694 false, 3695 false, 3696 false}); 3697 schema.columns.emplace_back(Table::Schema::Column{ 3698 "reliable_from", ColumnType::reliable_from::SqlValueType(), false, 3699 false, 3700 false, 3701 false}); 3702 return schema; 3703 } 3704 IterateRows()3705 ConstIterator IterateRows() const { 3706 return ConstIterator(this, Table::IterateRows()); 3707 } 3708 IterateRows()3709 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 3710 FilterToIterator(const Query & q)3711 ConstIterator FilterToIterator(const Query& q) const { 3712 return ConstIterator(this, QueryToIterator(q)); 3713 } 3714 FilterToIterator(const Query & q)3715 Iterator FilterToIterator(const Query& q) { 3716 return Iterator(this, QueryToIterator(q)); 3717 } 3718 ShrinkToFit()3719 void ShrinkToFit() { 3720 type_.ShrinkToFit(); 3721 upid_.ShrinkToFit(); 3722 reliable_from_.ShrinkToFit(); 3723 } 3724 3725 ConstRowReference operator[](uint32_t r) const { 3726 return ConstRowReference(this, r); 3727 } 3728 RowReference operator[](uint32_t r) { return RowReference(this, r); } 3729 ConstRowReference operator[](RowNumber r) const { 3730 return ConstRowReference(this, r.row_number()); 3731 } 3732 RowReference operator[](RowNumber r) { 3733 return RowReference(this, r.row_number()); 3734 } 3735 FindById(Id find_id)3736 std::optional<ConstRowReference> FindById(Id find_id) const { 3737 std::optional<uint32_t> row = id().IndexOf(find_id); 3738 return row ? std::make_optional(ConstRowReference(this, *row)) 3739 : std::nullopt; 3740 } 3741 FindById(Id find_id)3742 std::optional<RowReference> FindById(Id find_id) { 3743 std::optional<uint32_t> row = id().IndexOf(find_id); 3744 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 3745 } 3746 Insert(const Row & row)3747 IdAndRow Insert(const Row& row) { 3748 uint32_t row_number = row_count(); 3749 Id id = Id{row_number}; 3750 type_.Append(string_pool()->InternString(row.type())); 3751 mutable_upid()->Append(row.upid); 3752 mutable_reliable_from()->Append(row.reliable_from); 3753 UpdateSelfOverlayAfterInsert(); 3754 return IdAndRow{id, row_number, RowReference(this, row_number), 3755 RowNumber(row_number)}; 3756 } 3757 3758 3759 id()3760 const IdColumn<ExpMissingChromeProcTable::Id>& id() const { 3761 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 3762 } type()3763 const TypedColumn<StringPool::Id>& type() const { 3764 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 3765 } upid()3766 const TypedColumn<uint32_t>& upid() const { 3767 return static_cast<const ColumnType::upid&>(columns()[ColumnIndex::upid]); 3768 } reliable_from()3769 const TypedColumn<std::optional<int64_t>>& reliable_from() const { 3770 return static_cast<const ColumnType::reliable_from&>(columns()[ColumnIndex::reliable_from]); 3771 } 3772 mutable_upid()3773 TypedColumn<uint32_t>* mutable_upid() { 3774 return static_cast<ColumnType::upid*>( 3775 GetColumn(ColumnIndex::upid)); 3776 } mutable_reliable_from()3777 TypedColumn<std::optional<int64_t>>* mutable_reliable_from() { 3778 return static_cast<ColumnType::reliable_from*>( 3779 GetColumn(ColumnIndex::reliable_from)); 3780 } 3781 3782 private: 3783 3784 3785 ColumnStorage<ColumnType::upid::stored_type> upid_; 3786 ColumnStorage<ColumnType::reliable_from::stored_type> reliable_from_; 3787 3788 RefPtr<column::StorageLayer> id_storage_layer_; 3789 RefPtr<column::StorageLayer> type_storage_layer_; 3790 RefPtr<column::StorageLayer> upid_storage_layer_; 3791 RefPtr<column::StorageLayer> reliable_from_storage_layer_; 3792 3793 RefPtr<column::OverlayLayer> reliable_from_null_layer_; 3794 }; 3795 3796 3797 class FiledescriptorTable : public macros_internal::MacroTable { 3798 public: 3799 static constexpr uint32_t kColumnCount = 7; 3800 3801 struct Id : public BaseId { 3802 Id() = default; IdId3803 explicit constexpr Id(uint32_t v) : BaseId(v) {} 3804 }; 3805 static_assert(std::is_trivially_destructible_v<Id>, 3806 "Inheritance used without trivial destruction"); 3807 3808 struct ColumnIndex { 3809 static constexpr uint32_t id = 0; 3810 static constexpr uint32_t type = 1; 3811 static constexpr uint32_t ufd = 2; 3812 static constexpr uint32_t fd = 3; 3813 static constexpr uint32_t ts = 4; 3814 static constexpr uint32_t upid = 5; 3815 static constexpr uint32_t path = 6; 3816 }; 3817 struct ColumnType { 3818 using id = IdColumn<FiledescriptorTable::Id>; 3819 using type = TypedColumn<StringPool::Id>; 3820 using ufd = TypedColumn<int64_t>; 3821 using fd = TypedColumn<int64_t>; 3822 using ts = TypedColumn<std::optional<int64_t>>; 3823 using upid = TypedColumn<std::optional<uint32_t>>; 3824 using path = TypedColumn<std::optional<StringPool::Id>>; 3825 }; 3826 struct Row : public macros_internal::RootParentTable::Row { 3827 Row(int64_t in_ufd = {}, 3828 int64_t in_fd = {}, 3829 std::optional<int64_t> in_ts = {}, 3830 std::optional<uint32_t> in_upid = {}, 3831 std::optional<StringPool::Id> in_path = {}, 3832 std::nullptr_t = nullptr) RowRow3833 : macros_internal::RootParentTable::Row(), 3834 ufd(in_ufd), 3835 fd(in_fd), 3836 ts(in_ts), 3837 upid(in_upid), 3838 path(in_path) { 3839 type_ = "filedescriptor"; 3840 } 3841 int64_t ufd; 3842 int64_t fd; 3843 std::optional<int64_t> ts; 3844 std::optional<uint32_t> upid; 3845 std::optional<StringPool::Id> path; 3846 3847 bool operator==(const FiledescriptorTable::Row& other) const { 3848 return type() == other.type() && ColumnType::ufd::Equals(ufd, other.ufd) && 3849 ColumnType::fd::Equals(fd, other.fd) && 3850 ColumnType::ts::Equals(ts, other.ts) && 3851 ColumnType::upid::Equals(upid, other.upid) && 3852 ColumnType::path::Equals(path, other.path); 3853 } 3854 }; 3855 struct ColumnFlag { 3856 static constexpr uint32_t ufd = ColumnType::ufd::default_flags(); 3857 static constexpr uint32_t fd = ColumnType::fd::default_flags(); 3858 static constexpr uint32_t ts = ColumnType::ts::default_flags(); 3859 static constexpr uint32_t upid = ColumnType::upid::default_flags(); 3860 static constexpr uint32_t path = ColumnType::path::default_flags(); 3861 }; 3862 3863 class RowNumber; 3864 class ConstRowReference; 3865 class RowReference; 3866 3867 class RowNumber : public macros_internal::AbstractRowNumber< 3868 FiledescriptorTable, ConstRowReference, RowReference> { 3869 public: RowNumber(uint32_t row_number)3870 explicit RowNumber(uint32_t row_number) 3871 : AbstractRowNumber(row_number) {} 3872 }; 3873 static_assert(std::is_trivially_destructible_v<RowNumber>, 3874 "Inheritance used without trivial destruction"); 3875 3876 class ConstRowReference : public macros_internal::AbstractConstRowReference< 3877 FiledescriptorTable, RowNumber> { 3878 public: ConstRowReference(const FiledescriptorTable * table,uint32_t row_number)3879 ConstRowReference(const FiledescriptorTable* table, uint32_t row_number) 3880 : AbstractConstRowReference(table, row_number) {} 3881 id()3882 ColumnType::id::type id() const { 3883 return table()->id()[row_number_]; 3884 } type()3885 ColumnType::type::type type() const { 3886 return table()->type()[row_number_]; 3887 } ufd()3888 ColumnType::ufd::type ufd() const { 3889 return table()->ufd()[row_number_]; 3890 } fd()3891 ColumnType::fd::type fd() const { 3892 return table()->fd()[row_number_]; 3893 } ts()3894 ColumnType::ts::type ts() const { 3895 return table()->ts()[row_number_]; 3896 } upid()3897 ColumnType::upid::type upid() const { 3898 return table()->upid()[row_number_]; 3899 } path()3900 ColumnType::path::type path() const { 3901 return table()->path()[row_number_]; 3902 } 3903 }; 3904 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 3905 "Inheritance used without trivial destruction"); 3906 class RowReference : public ConstRowReference { 3907 public: RowReference(const FiledescriptorTable * table,uint32_t row_number)3908 RowReference(const FiledescriptorTable* table, uint32_t row_number) 3909 : ConstRowReference(table, row_number) {} 3910 set_ufd(ColumnType::ufd::non_optional_type v)3911 void set_ufd( 3912 ColumnType::ufd::non_optional_type v) { 3913 return mutable_table()->mutable_ufd()->Set(row_number_, v); 3914 } set_fd(ColumnType::fd::non_optional_type v)3915 void set_fd( 3916 ColumnType::fd::non_optional_type v) { 3917 return mutable_table()->mutable_fd()->Set(row_number_, v); 3918 } set_ts(ColumnType::ts::non_optional_type v)3919 void set_ts( 3920 ColumnType::ts::non_optional_type v) { 3921 return mutable_table()->mutable_ts()->Set(row_number_, v); 3922 } set_upid(ColumnType::upid::non_optional_type v)3923 void set_upid( 3924 ColumnType::upid::non_optional_type v) { 3925 return mutable_table()->mutable_upid()->Set(row_number_, v); 3926 } set_path(ColumnType::path::non_optional_type v)3927 void set_path( 3928 ColumnType::path::non_optional_type v) { 3929 return mutable_table()->mutable_path()->Set(row_number_, v); 3930 } 3931 3932 private: mutable_table()3933 FiledescriptorTable* mutable_table() const { 3934 return const_cast<FiledescriptorTable*>(table()); 3935 } 3936 }; 3937 static_assert(std::is_trivially_destructible_v<RowReference>, 3938 "Inheritance used without trivial destruction"); 3939 3940 class ConstIterator; 3941 class ConstIterator : public macros_internal::AbstractConstIterator< 3942 ConstIterator, FiledescriptorTable, RowNumber, ConstRowReference> { 3943 public: id()3944 ColumnType::id::type id() const { 3945 const auto& col = table()->id(); 3946 return col.GetAtIdx( 3947 iterator_.StorageIndexForColumn(col.index_in_table())); 3948 } type()3949 ColumnType::type::type type() const { 3950 const auto& col = table()->type(); 3951 return col.GetAtIdx( 3952 iterator_.StorageIndexForColumn(col.index_in_table())); 3953 } ufd()3954 ColumnType::ufd::type ufd() const { 3955 const auto& col = table()->ufd(); 3956 return col.GetAtIdx( 3957 iterator_.StorageIndexForColumn(col.index_in_table())); 3958 } fd()3959 ColumnType::fd::type fd() const { 3960 const auto& col = table()->fd(); 3961 return col.GetAtIdx( 3962 iterator_.StorageIndexForColumn(col.index_in_table())); 3963 } ts()3964 ColumnType::ts::type ts() const { 3965 const auto& col = table()->ts(); 3966 return col.GetAtIdx( 3967 iterator_.StorageIndexForColumn(col.index_in_table())); 3968 } upid()3969 ColumnType::upid::type upid() const { 3970 const auto& col = table()->upid(); 3971 return col.GetAtIdx( 3972 iterator_.StorageIndexForColumn(col.index_in_table())); 3973 } path()3974 ColumnType::path::type path() const { 3975 const auto& col = table()->path(); 3976 return col.GetAtIdx( 3977 iterator_.StorageIndexForColumn(col.index_in_table())); 3978 } 3979 3980 protected: ConstIterator(const FiledescriptorTable * table,Table::Iterator iterator)3981 explicit ConstIterator(const FiledescriptorTable* table, 3982 Table::Iterator iterator) 3983 : AbstractConstIterator(table, std::move(iterator)) {} 3984 CurrentRowNumber()3985 uint32_t CurrentRowNumber() const { 3986 return iterator_.StorageIndexForLastOverlay(); 3987 } 3988 3989 private: 3990 friend class FiledescriptorTable; 3991 friend class macros_internal::AbstractConstIterator< 3992 ConstIterator, FiledescriptorTable, RowNumber, ConstRowReference>; 3993 }; 3994 class Iterator : public ConstIterator { 3995 public: row_reference()3996 RowReference row_reference() const { 3997 return {const_cast<FiledescriptorTable*>(table()), CurrentRowNumber()}; 3998 } 3999 4000 private: 4001 friend class FiledescriptorTable; 4002 Iterator(FiledescriptorTable * table,Table::Iterator iterator)4003 explicit Iterator(FiledescriptorTable* table, Table::Iterator iterator) 4004 : ConstIterator(table, std::move(iterator)) {} 4005 }; 4006 4007 struct IdAndRow { 4008 Id id; 4009 uint32_t row; 4010 RowReference row_reference; 4011 RowNumber row_number; 4012 }; 4013 GetColumns(FiledescriptorTable * self,const macros_internal::MacroTable * parent)4014 static std::vector<ColumnLegacy> GetColumns( 4015 FiledescriptorTable* self, 4016 const macros_internal::MacroTable* parent) { 4017 std::vector<ColumnLegacy> columns = 4018 CopyColumnsFromParentOrAddRootColumns(self, parent); 4019 uint32_t olay_idx = OverlayCount(parent); 4020 AddColumnToVector(columns, "ufd", &self->ufd_, ColumnFlag::ufd, 4021 static_cast<uint32_t>(columns.size()), olay_idx); 4022 AddColumnToVector(columns, "fd", &self->fd_, ColumnFlag::fd, 4023 static_cast<uint32_t>(columns.size()), olay_idx); 4024 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 4025 static_cast<uint32_t>(columns.size()), olay_idx); 4026 AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 4027 static_cast<uint32_t>(columns.size()), olay_idx); 4028 AddColumnToVector(columns, "path", &self->path_, ColumnFlag::path, 4029 static_cast<uint32_t>(columns.size()), olay_idx); 4030 return columns; 4031 } 4032 FiledescriptorTable(StringPool * pool)4033 PERFETTO_NO_INLINE explicit FiledescriptorTable(StringPool* pool) 4034 : macros_internal::MacroTable( 4035 pool, 4036 GetColumns(this, nullptr), 4037 nullptr), 4038 ufd_(ColumnStorage<ColumnType::ufd::stored_type>::Create<false>()), 4039 fd_(ColumnStorage<ColumnType::fd::stored_type>::Create<false>()), 4040 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 4041 upid_(ColumnStorage<ColumnType::upid::stored_type>::Create<false>()), 4042 path_(ColumnStorage<ColumnType::path::stored_type>::Create<false>()) 4043 , 4044 id_storage_layer_(new column::IdStorage()), 4045 type_storage_layer_( 4046 new column::StringStorage(string_pool(), &type_.vector())), 4047 ufd_storage_layer_( 4048 new column::NumericStorage<ColumnType::ufd::non_optional_stored_type>( 4049 &ufd_.vector(), 4050 ColumnTypeHelper<ColumnType::ufd::stored_type>::ToColumnType(), 4051 false)), 4052 fd_storage_layer_( 4053 new column::NumericStorage<ColumnType::fd::non_optional_stored_type>( 4054 &fd_.vector(), 4055 ColumnTypeHelper<ColumnType::fd::stored_type>::ToColumnType(), 4056 false)), 4057 ts_storage_layer_( 4058 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 4059 &ts_.non_null_vector(), 4060 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 4061 false)), 4062 upid_storage_layer_( 4063 new column::NumericStorage<ColumnType::upid::non_optional_stored_type>( 4064 &upid_.non_null_vector(), 4065 ColumnTypeHelper<ColumnType::upid::stored_type>::ToColumnType(), 4066 false)), 4067 path_storage_layer_( 4068 new column::StringStorage(string_pool(), &path_.vector())) 4069 , 4070 ts_null_layer_(new column::NullOverlay(ts_.bv())), 4071 upid_null_layer_(new column::NullOverlay(upid_.bv())) { 4072 static_assert( 4073 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ufd::stored_type>( 4074 ColumnFlag::ufd), 4075 "Column type and flag combination is not valid"); 4076 static_assert( 4077 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::fd::stored_type>( 4078 ColumnFlag::fd), 4079 "Column type and flag combination is not valid"); 4080 static_assert( 4081 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 4082 ColumnFlag::ts), 4083 "Column type and flag combination is not valid"); 4084 static_assert( 4085 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::upid::stored_type>( 4086 ColumnFlag::upid), 4087 "Column type and flag combination is not valid"); 4088 static_assert( 4089 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::path::stored_type>( 4090 ColumnFlag::path), 4091 "Column type and flag combination is not valid"); 4092 OnConstructionCompletedRegularConstructor( 4093 {id_storage_layer_,type_storage_layer_,ufd_storage_layer_,fd_storage_layer_,ts_storage_layer_,upid_storage_layer_,path_storage_layer_}, 4094 {{},{},{},{},ts_null_layer_,upid_null_layer_,{}}); 4095 } 4096 ~FiledescriptorTable() override; 4097 Name()4098 static const char* Name() { return "filedescriptor"; } 4099 ComputeStaticSchema()4100 static Table::Schema ComputeStaticSchema() { 4101 Table::Schema schema; 4102 schema.columns.emplace_back(Table::Schema::Column{ 4103 "id", SqlValue::Type::kLong, true, true, false, false}); 4104 schema.columns.emplace_back(Table::Schema::Column{ 4105 "type", SqlValue::Type::kString, false, false, false, false}); 4106 schema.columns.emplace_back(Table::Schema::Column{ 4107 "ufd", ColumnType::ufd::SqlValueType(), false, 4108 false, 4109 false, 4110 false}); 4111 schema.columns.emplace_back(Table::Schema::Column{ 4112 "fd", ColumnType::fd::SqlValueType(), false, 4113 false, 4114 false, 4115 false}); 4116 schema.columns.emplace_back(Table::Schema::Column{ 4117 "ts", ColumnType::ts::SqlValueType(), false, 4118 false, 4119 false, 4120 false}); 4121 schema.columns.emplace_back(Table::Schema::Column{ 4122 "upid", ColumnType::upid::SqlValueType(), false, 4123 false, 4124 false, 4125 false}); 4126 schema.columns.emplace_back(Table::Schema::Column{ 4127 "path", ColumnType::path::SqlValueType(), false, 4128 false, 4129 false, 4130 false}); 4131 return schema; 4132 } 4133 IterateRows()4134 ConstIterator IterateRows() const { 4135 return ConstIterator(this, Table::IterateRows()); 4136 } 4137 IterateRows()4138 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 4139 FilterToIterator(const Query & q)4140 ConstIterator FilterToIterator(const Query& q) const { 4141 return ConstIterator(this, QueryToIterator(q)); 4142 } 4143 FilterToIterator(const Query & q)4144 Iterator FilterToIterator(const Query& q) { 4145 return Iterator(this, QueryToIterator(q)); 4146 } 4147 ShrinkToFit()4148 void ShrinkToFit() { 4149 type_.ShrinkToFit(); 4150 ufd_.ShrinkToFit(); 4151 fd_.ShrinkToFit(); 4152 ts_.ShrinkToFit(); 4153 upid_.ShrinkToFit(); 4154 path_.ShrinkToFit(); 4155 } 4156 4157 ConstRowReference operator[](uint32_t r) const { 4158 return ConstRowReference(this, r); 4159 } 4160 RowReference operator[](uint32_t r) { return RowReference(this, r); } 4161 ConstRowReference operator[](RowNumber r) const { 4162 return ConstRowReference(this, r.row_number()); 4163 } 4164 RowReference operator[](RowNumber r) { 4165 return RowReference(this, r.row_number()); 4166 } 4167 FindById(Id find_id)4168 std::optional<ConstRowReference> FindById(Id find_id) const { 4169 std::optional<uint32_t> row = id().IndexOf(find_id); 4170 return row ? std::make_optional(ConstRowReference(this, *row)) 4171 : std::nullopt; 4172 } 4173 FindById(Id find_id)4174 std::optional<RowReference> FindById(Id find_id) { 4175 std::optional<uint32_t> row = id().IndexOf(find_id); 4176 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 4177 } 4178 Insert(const Row & row)4179 IdAndRow Insert(const Row& row) { 4180 uint32_t row_number = row_count(); 4181 Id id = Id{row_number}; 4182 type_.Append(string_pool()->InternString(row.type())); 4183 mutable_ufd()->Append(row.ufd); 4184 mutable_fd()->Append(row.fd); 4185 mutable_ts()->Append(row.ts); 4186 mutable_upid()->Append(row.upid); 4187 mutable_path()->Append(row.path); 4188 UpdateSelfOverlayAfterInsert(); 4189 return IdAndRow{id, row_number, RowReference(this, row_number), 4190 RowNumber(row_number)}; 4191 } 4192 4193 4194 id()4195 const IdColumn<FiledescriptorTable::Id>& id() const { 4196 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 4197 } type()4198 const TypedColumn<StringPool::Id>& type() const { 4199 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 4200 } ufd()4201 const TypedColumn<int64_t>& ufd() const { 4202 return static_cast<const ColumnType::ufd&>(columns()[ColumnIndex::ufd]); 4203 } fd()4204 const TypedColumn<int64_t>& fd() const { 4205 return static_cast<const ColumnType::fd&>(columns()[ColumnIndex::fd]); 4206 } ts()4207 const TypedColumn<std::optional<int64_t>>& ts() const { 4208 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 4209 } upid()4210 const TypedColumn<std::optional<uint32_t>>& upid() const { 4211 return static_cast<const ColumnType::upid&>(columns()[ColumnIndex::upid]); 4212 } path()4213 const TypedColumn<std::optional<StringPool::Id>>& path() const { 4214 return static_cast<const ColumnType::path&>(columns()[ColumnIndex::path]); 4215 } 4216 mutable_ufd()4217 TypedColumn<int64_t>* mutable_ufd() { 4218 return static_cast<ColumnType::ufd*>( 4219 GetColumn(ColumnIndex::ufd)); 4220 } mutable_fd()4221 TypedColumn<int64_t>* mutable_fd() { 4222 return static_cast<ColumnType::fd*>( 4223 GetColumn(ColumnIndex::fd)); 4224 } mutable_ts()4225 TypedColumn<std::optional<int64_t>>* mutable_ts() { 4226 return static_cast<ColumnType::ts*>( 4227 GetColumn(ColumnIndex::ts)); 4228 } mutable_upid()4229 TypedColumn<std::optional<uint32_t>>* mutable_upid() { 4230 return static_cast<ColumnType::upid*>( 4231 GetColumn(ColumnIndex::upid)); 4232 } mutable_path()4233 TypedColumn<std::optional<StringPool::Id>>* mutable_path() { 4234 return static_cast<ColumnType::path*>( 4235 GetColumn(ColumnIndex::path)); 4236 } 4237 4238 private: 4239 4240 4241 ColumnStorage<ColumnType::ufd::stored_type> ufd_; 4242 ColumnStorage<ColumnType::fd::stored_type> fd_; 4243 ColumnStorage<ColumnType::ts::stored_type> ts_; 4244 ColumnStorage<ColumnType::upid::stored_type> upid_; 4245 ColumnStorage<ColumnType::path::stored_type> path_; 4246 4247 RefPtr<column::StorageLayer> id_storage_layer_; 4248 RefPtr<column::StorageLayer> type_storage_layer_; 4249 RefPtr<column::StorageLayer> ufd_storage_layer_; 4250 RefPtr<column::StorageLayer> fd_storage_layer_; 4251 RefPtr<column::StorageLayer> ts_storage_layer_; 4252 RefPtr<column::StorageLayer> upid_storage_layer_; 4253 RefPtr<column::StorageLayer> path_storage_layer_; 4254 4255 RefPtr<column::OverlayLayer> ts_null_layer_; 4256 RefPtr<column::OverlayLayer> upid_null_layer_; 4257 }; 4258 4259 4260 class RawTable : public macros_internal::MacroTable { 4261 public: 4262 static constexpr uint32_t kColumnCount = 8; 4263 4264 struct Id : public BaseId { 4265 Id() = default; IdId4266 explicit constexpr Id(uint32_t v) : BaseId(v) {} 4267 }; 4268 static_assert(std::is_trivially_destructible_v<Id>, 4269 "Inheritance used without trivial destruction"); 4270 4271 struct ColumnIndex { 4272 static constexpr uint32_t id = 0; 4273 static constexpr uint32_t type = 1; 4274 static constexpr uint32_t ts = 2; 4275 static constexpr uint32_t name = 3; 4276 static constexpr uint32_t utid = 4; 4277 static constexpr uint32_t arg_set_id = 5; 4278 static constexpr uint32_t common_flags = 6; 4279 static constexpr uint32_t ucpu = 7; 4280 }; 4281 struct ColumnType { 4282 using id = IdColumn<RawTable::Id>; 4283 using type = TypedColumn<StringPool::Id>; 4284 using ts = TypedColumn<int64_t>; 4285 using name = TypedColumn<StringPool::Id>; 4286 using utid = TypedColumn<uint32_t>; 4287 using arg_set_id = TypedColumn<uint32_t>; 4288 using common_flags = TypedColumn<uint32_t>; 4289 using ucpu = TypedColumn<CpuTable::Id>; 4290 }; 4291 struct Row : public macros_internal::RootParentTable::Row { 4292 Row(int64_t in_ts = {}, 4293 StringPool::Id in_name = {}, 4294 uint32_t in_utid = {}, 4295 uint32_t in_arg_set_id = {}, 4296 uint32_t in_common_flags = {}, 4297 CpuTable::Id in_ucpu = {}, 4298 std::nullptr_t = nullptr) RowRow4299 : macros_internal::RootParentTable::Row(), 4300 ts(in_ts), 4301 name(in_name), 4302 utid(in_utid), 4303 arg_set_id(in_arg_set_id), 4304 common_flags(in_common_flags), 4305 ucpu(in_ucpu) { 4306 type_ = "__intrinsic_raw"; 4307 } 4308 int64_t ts; 4309 StringPool::Id name; 4310 uint32_t utid; 4311 uint32_t arg_set_id; 4312 uint32_t common_flags; 4313 CpuTable::Id ucpu; 4314 4315 bool operator==(const RawTable::Row& other) const { 4316 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 4317 ColumnType::name::Equals(name, other.name) && 4318 ColumnType::utid::Equals(utid, other.utid) && 4319 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 4320 ColumnType::common_flags::Equals(common_flags, other.common_flags) && 4321 ColumnType::ucpu::Equals(ucpu, other.ucpu); 4322 } 4323 }; 4324 struct ColumnFlag { 4325 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 4326 static constexpr uint32_t name = ColumnType::name::default_flags(); 4327 static constexpr uint32_t utid = ColumnType::utid::default_flags(); 4328 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 4329 static constexpr uint32_t common_flags = ColumnType::common_flags::default_flags(); 4330 static constexpr uint32_t ucpu = ColumnType::ucpu::default_flags(); 4331 }; 4332 4333 class RowNumber; 4334 class ConstRowReference; 4335 class RowReference; 4336 4337 class RowNumber : public macros_internal::AbstractRowNumber< 4338 RawTable, ConstRowReference, RowReference> { 4339 public: RowNumber(uint32_t row_number)4340 explicit RowNumber(uint32_t row_number) 4341 : AbstractRowNumber(row_number) {} 4342 }; 4343 static_assert(std::is_trivially_destructible_v<RowNumber>, 4344 "Inheritance used without trivial destruction"); 4345 4346 class ConstRowReference : public macros_internal::AbstractConstRowReference< 4347 RawTable, RowNumber> { 4348 public: ConstRowReference(const RawTable * table,uint32_t row_number)4349 ConstRowReference(const RawTable* table, uint32_t row_number) 4350 : AbstractConstRowReference(table, row_number) {} 4351 id()4352 ColumnType::id::type id() const { 4353 return table()->id()[row_number_]; 4354 } type()4355 ColumnType::type::type type() const { 4356 return table()->type()[row_number_]; 4357 } ts()4358 ColumnType::ts::type ts() const { 4359 return table()->ts()[row_number_]; 4360 } name()4361 ColumnType::name::type name() const { 4362 return table()->name()[row_number_]; 4363 } utid()4364 ColumnType::utid::type utid() const { 4365 return table()->utid()[row_number_]; 4366 } arg_set_id()4367 ColumnType::arg_set_id::type arg_set_id() const { 4368 return table()->arg_set_id()[row_number_]; 4369 } common_flags()4370 ColumnType::common_flags::type common_flags() const { 4371 return table()->common_flags()[row_number_]; 4372 } ucpu()4373 ColumnType::ucpu::type ucpu() const { 4374 return table()->ucpu()[row_number_]; 4375 } 4376 }; 4377 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 4378 "Inheritance used without trivial destruction"); 4379 class RowReference : public ConstRowReference { 4380 public: RowReference(const RawTable * table,uint32_t row_number)4381 RowReference(const RawTable* table, uint32_t row_number) 4382 : ConstRowReference(table, row_number) {} 4383 set_ts(ColumnType::ts::non_optional_type v)4384 void set_ts( 4385 ColumnType::ts::non_optional_type v) { 4386 return mutable_table()->mutable_ts()->Set(row_number_, v); 4387 } set_name(ColumnType::name::non_optional_type v)4388 void set_name( 4389 ColumnType::name::non_optional_type v) { 4390 return mutable_table()->mutable_name()->Set(row_number_, v); 4391 } set_utid(ColumnType::utid::non_optional_type v)4392