1 #ifndef SRC_TRACE_PROCESSOR_TABLES_PERF_TABLES_PY_H_ 2 #define SRC_TRACE_PROCESSOR_TABLES_PERF_TABLES_PY_H_ 3 4 #include <array> 5 #include <cstddef> 6 #include <cstdint> 7 #include <memory> 8 #include <optional> 9 #include <type_traits> 10 #include <utility> 11 #include <vector> 12 13 #include "perfetto/base/logging.h" 14 #include "perfetto/trace_processor/basic_types.h" 15 #include "perfetto/trace_processor/ref_counted.h" 16 #include "src/trace_processor/containers/bit_vector.h" 17 #include "src/trace_processor/containers/row_map.h" 18 #include "src/trace_processor/containers/string_pool.h" 19 #include "src/trace_processor/db/column/arrangement_overlay.h" 20 #include "src/trace_processor/db/column/data_layer.h" 21 #include "src/trace_processor/db/column/dense_null_overlay.h" 22 #include "src/trace_processor/db/column/numeric_storage.h" 23 #include "src/trace_processor/db/column/id_storage.h" 24 #include "src/trace_processor/db/column/null_overlay.h" 25 #include "src/trace_processor/db/column/range_overlay.h" 26 #include "src/trace_processor/db/column/selector_overlay.h" 27 #include "src/trace_processor/db/column/set_id_storage.h" 28 #include "src/trace_processor/db/column/string_storage.h" 29 #include "src/trace_processor/db/column/types.h" 30 #include "src/trace_processor/db/column_storage.h" 31 #include "src/trace_processor/db/column.h" 32 #include "src/trace_processor/db/table.h" 33 #include "src/trace_processor/db/typed_column.h" 34 #include "src/trace_processor/db/typed_column_internal.h" 35 #include "src/trace_processor/tables/macros_internal.h" 36 37 #include "src/trace_processor/tables/metadata_tables_py.h" 38 #include "src/trace_processor/tables/profiler_tables_py.h" 39 40 namespace perfetto::trace_processor::tables { 41 42 class SpeRecordTable : public macros_internal::MacroTable { 43 public: 44 static constexpr uint32_t kColumnCount = 14; 45 46 struct Id : public BaseId { 47 Id() = default; IdId48 explicit constexpr Id(uint32_t v) : BaseId(v) {} 49 }; 50 static_assert(std::is_trivially_destructible_v<Id>, 51 "Inheritance used without trivial destruction"); 52 53 struct ColumnIndex { 54 static constexpr uint32_t id = 0; 55 static constexpr uint32_t type = 1; 56 static constexpr uint32_t ts = 2; 57 static constexpr uint32_t utid = 3; 58 static constexpr uint32_t exception_level = 4; 59 static constexpr uint32_t instruction_frame_id = 5; 60 static constexpr uint32_t operation = 6; 61 static constexpr uint32_t data_virtual_address = 7; 62 static constexpr uint32_t data_physical_address = 8; 63 static constexpr uint32_t total_latency = 9; 64 static constexpr uint32_t issue_latency = 10; 65 static constexpr uint32_t translation_latency = 11; 66 static constexpr uint32_t events_bitmask = 12; 67 static constexpr uint32_t data_source = 13; 68 }; 69 struct ColumnType { 70 using id = IdColumn<SpeRecordTable::Id>; 71 using type = TypedColumn<StringPool::Id>; 72 using ts = TypedColumn<int64_t>; 73 using utid = TypedColumn<std::optional<uint32_t>>; 74 using exception_level = TypedColumn<StringPool::Id>; 75 using instruction_frame_id = TypedColumn<std::optional<StackProfileFrameTable::Id>>; 76 using operation = TypedColumn<StringPool::Id>; 77 using data_virtual_address = TypedColumn<int64_t>; 78 using data_physical_address = TypedColumn<int64_t>; 79 using total_latency = TypedColumn<uint32_t>; 80 using issue_latency = TypedColumn<uint32_t>; 81 using translation_latency = TypedColumn<uint32_t>; 82 using events_bitmask = TypedColumn<int64_t>; 83 using data_source = TypedColumn<StringPool::Id>; 84 }; 85 struct Row : public macros_internal::RootParentTable::Row { 86 Row(int64_t in_ts = {}, 87 std::optional<uint32_t> in_utid = {}, 88 StringPool::Id in_exception_level = {}, 89 std::optional<StackProfileFrameTable::Id> in_instruction_frame_id = {}, 90 StringPool::Id in_operation = {}, 91 int64_t in_data_virtual_address = {}, 92 int64_t in_data_physical_address = {}, 93 uint32_t in_total_latency = {}, 94 uint32_t in_issue_latency = {}, 95 uint32_t in_translation_latency = {}, 96 int64_t in_events_bitmask = {}, 97 StringPool::Id in_data_source = {}, 98 std::nullptr_t = nullptr) RowRow99 : macros_internal::RootParentTable::Row(), 100 ts(in_ts), 101 utid(in_utid), 102 exception_level(in_exception_level), 103 instruction_frame_id(in_instruction_frame_id), 104 operation(in_operation), 105 data_virtual_address(in_data_virtual_address), 106 data_physical_address(in_data_physical_address), 107 total_latency(in_total_latency), 108 issue_latency(in_issue_latency), 109 translation_latency(in_translation_latency), 110 events_bitmask(in_events_bitmask), 111 data_source(in_data_source) { 112 type_ = "__intrinsic_spe_record"; 113 } 114 int64_t ts; 115 std::optional<uint32_t> utid; 116 StringPool::Id exception_level; 117 std::optional<StackProfileFrameTable::Id> instruction_frame_id; 118 StringPool::Id operation; 119 int64_t data_virtual_address; 120 int64_t data_physical_address; 121 uint32_t total_latency; 122 uint32_t issue_latency; 123 uint32_t translation_latency; 124 int64_t events_bitmask; 125 StringPool::Id data_source; 126 127 bool operator==(const SpeRecordTable::Row& other) const { 128 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 129 ColumnType::utid::Equals(utid, other.utid) && 130 ColumnType::exception_level::Equals(exception_level, other.exception_level) && 131 ColumnType::instruction_frame_id::Equals(instruction_frame_id, other.instruction_frame_id) && 132 ColumnType::operation::Equals(operation, other.operation) && 133 ColumnType::data_virtual_address::Equals(data_virtual_address, other.data_virtual_address) && 134 ColumnType::data_physical_address::Equals(data_physical_address, other.data_physical_address) && 135 ColumnType::total_latency::Equals(total_latency, other.total_latency) && 136 ColumnType::issue_latency::Equals(issue_latency, other.issue_latency) && 137 ColumnType::translation_latency::Equals(translation_latency, other.translation_latency) && 138 ColumnType::events_bitmask::Equals(events_bitmask, other.events_bitmask) && 139 ColumnType::data_source::Equals(data_source, other.data_source); 140 } 141 }; 142 struct ColumnFlag { 143 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 144 static constexpr uint32_t utid = ColumnType::utid::default_flags(); 145 static constexpr uint32_t exception_level = ColumnType::exception_level::default_flags(); 146 static constexpr uint32_t instruction_frame_id = ColumnType::instruction_frame_id::default_flags(); 147 static constexpr uint32_t operation = ColumnType::operation::default_flags(); 148 static constexpr uint32_t data_virtual_address = ColumnType::data_virtual_address::default_flags(); 149 static constexpr uint32_t data_physical_address = ColumnType::data_physical_address::default_flags(); 150 static constexpr uint32_t total_latency = ColumnType::total_latency::default_flags(); 151 static constexpr uint32_t issue_latency = ColumnType::issue_latency::default_flags(); 152 static constexpr uint32_t translation_latency = ColumnType::translation_latency::default_flags(); 153 static constexpr uint32_t events_bitmask = ColumnType::events_bitmask::default_flags(); 154 static constexpr uint32_t data_source = ColumnType::data_source::default_flags(); 155 }; 156 157 class RowNumber; 158 class ConstRowReference; 159 class RowReference; 160 161 class RowNumber : public macros_internal::AbstractRowNumber< 162 SpeRecordTable, ConstRowReference, RowReference> { 163 public: RowNumber(uint32_t row_number)164 explicit RowNumber(uint32_t row_number) 165 : AbstractRowNumber(row_number) {} 166 }; 167 static_assert(std::is_trivially_destructible_v<RowNumber>, 168 "Inheritance used without trivial destruction"); 169 170 class ConstRowReference : public macros_internal::AbstractConstRowReference< 171 SpeRecordTable, RowNumber> { 172 public: ConstRowReference(const SpeRecordTable * table,uint32_t row_number)173 ConstRowReference(const SpeRecordTable* table, uint32_t row_number) 174 : AbstractConstRowReference(table, row_number) {} 175 id()176 ColumnType::id::type id() const { 177 return table()->id()[row_number_]; 178 } type()179 ColumnType::type::type type() const { 180 return table()->type()[row_number_]; 181 } ts()182 ColumnType::ts::type ts() const { 183 return table()->ts()[row_number_]; 184 } utid()185 ColumnType::utid::type utid() const { 186 return table()->utid()[row_number_]; 187 } exception_level()188 ColumnType::exception_level::type exception_level() const { 189 return table()->exception_level()[row_number_]; 190 } instruction_frame_id()191 ColumnType::instruction_frame_id::type instruction_frame_id() const { 192 return table()->instruction_frame_id()[row_number_]; 193 } operation()194 ColumnType::operation::type operation() const { 195 return table()->operation()[row_number_]; 196 } data_virtual_address()197 ColumnType::data_virtual_address::type data_virtual_address() const { 198 return table()->data_virtual_address()[row_number_]; 199 } data_physical_address()200 ColumnType::data_physical_address::type data_physical_address() const { 201 return table()->data_physical_address()[row_number_]; 202 } total_latency()203 ColumnType::total_latency::type total_latency() const { 204 return table()->total_latency()[row_number_]; 205 } issue_latency()206 ColumnType::issue_latency::type issue_latency() const { 207 return table()->issue_latency()[row_number_]; 208 } translation_latency()209 ColumnType::translation_latency::type translation_latency() const { 210 return table()->translation_latency()[row_number_]; 211 } events_bitmask()212 ColumnType::events_bitmask::type events_bitmask() const { 213 return table()->events_bitmask()[row_number_]; 214 } data_source()215 ColumnType::data_source::type data_source() const { 216 return table()->data_source()[row_number_]; 217 } 218 }; 219 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 220 "Inheritance used without trivial destruction"); 221 class RowReference : public ConstRowReference { 222 public: RowReference(const SpeRecordTable * table,uint32_t row_number)223 RowReference(const SpeRecordTable* table, uint32_t row_number) 224 : ConstRowReference(table, row_number) {} 225 set_ts(ColumnType::ts::non_optional_type v)226 void set_ts( 227 ColumnType::ts::non_optional_type v) { 228 return mutable_table()->mutable_ts()->Set(row_number_, v); 229 } set_utid(ColumnType::utid::non_optional_type v)230 void set_utid( 231 ColumnType::utid::non_optional_type v) { 232 return mutable_table()->mutable_utid()->Set(row_number_, v); 233 } set_exception_level(ColumnType::exception_level::non_optional_type v)234 void set_exception_level( 235 ColumnType::exception_level::non_optional_type v) { 236 return mutable_table()->mutable_exception_level()->Set(row_number_, v); 237 } set_instruction_frame_id(ColumnType::instruction_frame_id::non_optional_type v)238 void set_instruction_frame_id( 239 ColumnType::instruction_frame_id::non_optional_type v) { 240 return mutable_table()->mutable_instruction_frame_id()->Set(row_number_, v); 241 } set_operation(ColumnType::operation::non_optional_type v)242 void set_operation( 243 ColumnType::operation::non_optional_type v) { 244 return mutable_table()->mutable_operation()->Set(row_number_, v); 245 } set_data_virtual_address(ColumnType::data_virtual_address::non_optional_type v)246 void set_data_virtual_address( 247 ColumnType::data_virtual_address::non_optional_type v) { 248 return mutable_table()->mutable_data_virtual_address()->Set(row_number_, v); 249 } set_data_physical_address(ColumnType::data_physical_address::non_optional_type v)250 void set_data_physical_address( 251 ColumnType::data_physical_address::non_optional_type v) { 252 return mutable_table()->mutable_data_physical_address()->Set(row_number_, v); 253 } set_total_latency(ColumnType::total_latency::non_optional_type v)254 void set_total_latency( 255 ColumnType::total_latency::non_optional_type v) { 256 return mutable_table()->mutable_total_latency()->Set(row_number_, v); 257 } set_issue_latency(ColumnType::issue_latency::non_optional_type v)258 void set_issue_latency( 259 ColumnType::issue_latency::non_optional_type v) { 260 return mutable_table()->mutable_issue_latency()->Set(row_number_, v); 261 } set_translation_latency(ColumnType::translation_latency::non_optional_type v)262 void set_translation_latency( 263 ColumnType::translation_latency::non_optional_type v) { 264 return mutable_table()->mutable_translation_latency()->Set(row_number_, v); 265 } set_events_bitmask(ColumnType::events_bitmask::non_optional_type v)266 void set_events_bitmask( 267 ColumnType::events_bitmask::non_optional_type v) { 268 return mutable_table()->mutable_events_bitmask()->Set(row_number_, v); 269 } set_data_source(ColumnType::data_source::non_optional_type v)270 void set_data_source( 271 ColumnType::data_source::non_optional_type v) { 272 return mutable_table()->mutable_data_source()->Set(row_number_, v); 273 } 274 275 private: mutable_table()276 SpeRecordTable* mutable_table() const { 277 return const_cast<SpeRecordTable*>(table()); 278 } 279 }; 280 static_assert(std::is_trivially_destructible_v<RowReference>, 281 "Inheritance used without trivial destruction"); 282 283 class ConstIterator; 284 class ConstIterator : public macros_internal::AbstractConstIterator< 285 ConstIterator, SpeRecordTable, RowNumber, ConstRowReference> { 286 public: id()287 ColumnType::id::type id() const { 288 const auto& col = table()->id(); 289 return col.GetAtIdx( 290 iterator_.StorageIndexForColumn(col.index_in_table())); 291 } type()292 ColumnType::type::type type() const { 293 const auto& col = table()->type(); 294 return col.GetAtIdx( 295 iterator_.StorageIndexForColumn(col.index_in_table())); 296 } ts()297 ColumnType::ts::type ts() const { 298 const auto& col = table()->ts(); 299 return col.GetAtIdx( 300 iterator_.StorageIndexForColumn(col.index_in_table())); 301 } utid()302 ColumnType::utid::type utid() const { 303 const auto& col = table()->utid(); 304 return col.GetAtIdx( 305 iterator_.StorageIndexForColumn(col.index_in_table())); 306 } exception_level()307 ColumnType::exception_level::type exception_level() const { 308 const auto& col = table()->exception_level(); 309 return col.GetAtIdx( 310 iterator_.StorageIndexForColumn(col.index_in_table())); 311 } instruction_frame_id()312 ColumnType::instruction_frame_id::type instruction_frame_id() const { 313 const auto& col = table()->instruction_frame_id(); 314 return col.GetAtIdx( 315 iterator_.StorageIndexForColumn(col.index_in_table())); 316 } operation()317 ColumnType::operation::type operation() const { 318 const auto& col = table()->operation(); 319 return col.GetAtIdx( 320 iterator_.StorageIndexForColumn(col.index_in_table())); 321 } data_virtual_address()322 ColumnType::data_virtual_address::type data_virtual_address() const { 323 const auto& col = table()->data_virtual_address(); 324 return col.GetAtIdx( 325 iterator_.StorageIndexForColumn(col.index_in_table())); 326 } data_physical_address()327 ColumnType::data_physical_address::type data_physical_address() const { 328 const auto& col = table()->data_physical_address(); 329 return col.GetAtIdx( 330 iterator_.StorageIndexForColumn(col.index_in_table())); 331 } total_latency()332 ColumnType::total_latency::type total_latency() const { 333 const auto& col = table()->total_latency(); 334 return col.GetAtIdx( 335 iterator_.StorageIndexForColumn(col.index_in_table())); 336 } issue_latency()337 ColumnType::issue_latency::type issue_latency() const { 338 const auto& col = table()->issue_latency(); 339 return col.GetAtIdx( 340 iterator_.StorageIndexForColumn(col.index_in_table())); 341 } translation_latency()342 ColumnType::translation_latency::type translation_latency() const { 343 const auto& col = table()->translation_latency(); 344 return col.GetAtIdx( 345 iterator_.StorageIndexForColumn(col.index_in_table())); 346 } events_bitmask()347 ColumnType::events_bitmask::type events_bitmask() const { 348 const auto& col = table()->events_bitmask(); 349 return col.GetAtIdx( 350 iterator_.StorageIndexForColumn(col.index_in_table())); 351 } data_source()352 ColumnType::data_source::type data_source() const { 353 const auto& col = table()->data_source(); 354 return col.GetAtIdx( 355 iterator_.StorageIndexForColumn(col.index_in_table())); 356 } 357 358 protected: ConstIterator(const SpeRecordTable * table,Table::Iterator iterator)359 explicit ConstIterator(const SpeRecordTable* table, 360 Table::Iterator iterator) 361 : AbstractConstIterator(table, std::move(iterator)) {} 362 CurrentRowNumber()363 uint32_t CurrentRowNumber() const { 364 return iterator_.StorageIndexForLastOverlay(); 365 } 366 367 private: 368 friend class SpeRecordTable; 369 friend class macros_internal::AbstractConstIterator< 370 ConstIterator, SpeRecordTable, RowNumber, ConstRowReference>; 371 }; 372 class Iterator : public ConstIterator { 373 public: row_reference()374 RowReference row_reference() const { 375 return {const_cast<SpeRecordTable*>(table()), CurrentRowNumber()}; 376 } 377 378 private: 379 friend class SpeRecordTable; 380 Iterator(SpeRecordTable * table,Table::Iterator iterator)381 explicit Iterator(SpeRecordTable* table, Table::Iterator iterator) 382 : ConstIterator(table, std::move(iterator)) {} 383 }; 384 385 struct IdAndRow { 386 Id id; 387 uint32_t row; 388 RowReference row_reference; 389 RowNumber row_number; 390 }; 391 GetColumns(SpeRecordTable * self,const macros_internal::MacroTable * parent)392 static std::vector<ColumnLegacy> GetColumns( 393 SpeRecordTable* self, 394 const macros_internal::MacroTable* parent) { 395 std::vector<ColumnLegacy> columns = 396 CopyColumnsFromParentOrAddRootColumns(self, parent); 397 uint32_t olay_idx = OverlayCount(parent); 398 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 399 static_cast<uint32_t>(columns.size()), olay_idx); 400 AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 401 static_cast<uint32_t>(columns.size()), olay_idx); 402 AddColumnToVector(columns, "exception_level", &self->exception_level_, ColumnFlag::exception_level, 403 static_cast<uint32_t>(columns.size()), olay_idx); 404 AddColumnToVector(columns, "instruction_frame_id", &self->instruction_frame_id_, ColumnFlag::instruction_frame_id, 405 static_cast<uint32_t>(columns.size()), olay_idx); 406 AddColumnToVector(columns, "operation", &self->operation_, ColumnFlag::operation, 407 static_cast<uint32_t>(columns.size()), olay_idx); 408 AddColumnToVector(columns, "data_virtual_address", &self->data_virtual_address_, ColumnFlag::data_virtual_address, 409 static_cast<uint32_t>(columns.size()), olay_idx); 410 AddColumnToVector(columns, "data_physical_address", &self->data_physical_address_, ColumnFlag::data_physical_address, 411 static_cast<uint32_t>(columns.size()), olay_idx); 412 AddColumnToVector(columns, "total_latency", &self->total_latency_, ColumnFlag::total_latency, 413 static_cast<uint32_t>(columns.size()), olay_idx); 414 AddColumnToVector(columns, "issue_latency", &self->issue_latency_, ColumnFlag::issue_latency, 415 static_cast<uint32_t>(columns.size()), olay_idx); 416 AddColumnToVector(columns, "translation_latency", &self->translation_latency_, ColumnFlag::translation_latency, 417 static_cast<uint32_t>(columns.size()), olay_idx); 418 AddColumnToVector(columns, "events_bitmask", &self->events_bitmask_, ColumnFlag::events_bitmask, 419 static_cast<uint32_t>(columns.size()), olay_idx); 420 AddColumnToVector(columns, "data_source", &self->data_source_, ColumnFlag::data_source, 421 static_cast<uint32_t>(columns.size()), olay_idx); 422 return columns; 423 } 424 SpeRecordTable(StringPool * pool)425 PERFETTO_NO_INLINE explicit SpeRecordTable(StringPool* pool) 426 : macros_internal::MacroTable( 427 pool, 428 GetColumns(this, nullptr), 429 nullptr), 430 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 431 utid_(ColumnStorage<ColumnType::utid::stored_type>::Create<false>()), 432 exception_level_(ColumnStorage<ColumnType::exception_level::stored_type>::Create<false>()), 433 instruction_frame_id_(ColumnStorage<ColumnType::instruction_frame_id::stored_type>::Create<false>()), 434 operation_(ColumnStorage<ColumnType::operation::stored_type>::Create<false>()), 435 data_virtual_address_(ColumnStorage<ColumnType::data_virtual_address::stored_type>::Create<false>()), 436 data_physical_address_(ColumnStorage<ColumnType::data_physical_address::stored_type>::Create<false>()), 437 total_latency_(ColumnStorage<ColumnType::total_latency::stored_type>::Create<false>()), 438 issue_latency_(ColumnStorage<ColumnType::issue_latency::stored_type>::Create<false>()), 439 translation_latency_(ColumnStorage<ColumnType::translation_latency::stored_type>::Create<false>()), 440 events_bitmask_(ColumnStorage<ColumnType::events_bitmask::stored_type>::Create<false>()), 441 data_source_(ColumnStorage<ColumnType::data_source::stored_type>::Create<false>()) 442 , 443 id_storage_layer_(new column::IdStorage()), 444 type_storage_layer_( 445 new column::StringStorage(string_pool(), &type_.vector())), 446 ts_storage_layer_( 447 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 448 &ts_.vector(), 449 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 450 true)), 451 utid_storage_layer_( 452 new column::NumericStorage<ColumnType::utid::non_optional_stored_type>( 453 &utid_.non_null_vector(), 454 ColumnTypeHelper<ColumnType::utid::stored_type>::ToColumnType(), 455 false)), 456 exception_level_storage_layer_( 457 new column::StringStorage(string_pool(), &exception_level_.vector())), 458 instruction_frame_id_storage_layer_( 459 new column::NumericStorage<ColumnType::instruction_frame_id::non_optional_stored_type>( 460 &instruction_frame_id_.non_null_vector(), 461 ColumnTypeHelper<ColumnType::instruction_frame_id::stored_type>::ToColumnType(), 462 false)), 463 operation_storage_layer_( 464 new column::StringStorage(string_pool(), &operation_.vector())), 465 data_virtual_address_storage_layer_( 466 new column::NumericStorage<ColumnType::data_virtual_address::non_optional_stored_type>( 467 &data_virtual_address_.vector(), 468 ColumnTypeHelper<ColumnType::data_virtual_address::stored_type>::ToColumnType(), 469 false)), 470 data_physical_address_storage_layer_( 471 new column::NumericStorage<ColumnType::data_physical_address::non_optional_stored_type>( 472 &data_physical_address_.vector(), 473 ColumnTypeHelper<ColumnType::data_physical_address::stored_type>::ToColumnType(), 474 false)), 475 total_latency_storage_layer_( 476 new column::NumericStorage<ColumnType::total_latency::non_optional_stored_type>( 477 &total_latency_.vector(), 478 ColumnTypeHelper<ColumnType::total_latency::stored_type>::ToColumnType(), 479 false)), 480 issue_latency_storage_layer_( 481 new column::NumericStorage<ColumnType::issue_latency::non_optional_stored_type>( 482 &issue_latency_.vector(), 483 ColumnTypeHelper<ColumnType::issue_latency::stored_type>::ToColumnType(), 484 false)), 485 translation_latency_storage_layer_( 486 new column::NumericStorage<ColumnType::translation_latency::non_optional_stored_type>( 487 &translation_latency_.vector(), 488 ColumnTypeHelper<ColumnType::translation_latency::stored_type>::ToColumnType(), 489 false)), 490 events_bitmask_storage_layer_( 491 new column::NumericStorage<ColumnType::events_bitmask::non_optional_stored_type>( 492 &events_bitmask_.vector(), 493 ColumnTypeHelper<ColumnType::events_bitmask::stored_type>::ToColumnType(), 494 false)), 495 data_source_storage_layer_( 496 new column::StringStorage(string_pool(), &data_source_.vector())) 497 , 498 utid_null_layer_(new column::NullOverlay(utid_.bv())), 499 instruction_frame_id_null_layer_(new column::NullOverlay(instruction_frame_id_.bv())) { 500 static_assert( 501 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 502 ColumnFlag::ts), 503 "Column type and flag combination is not valid"); 504 static_assert( 505 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::utid::stored_type>( 506 ColumnFlag::utid), 507 "Column type and flag combination is not valid"); 508 static_assert( 509 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::exception_level::stored_type>( 510 ColumnFlag::exception_level), 511 "Column type and flag combination is not valid"); 512 static_assert( 513 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::instruction_frame_id::stored_type>( 514 ColumnFlag::instruction_frame_id), 515 "Column type and flag combination is not valid"); 516 static_assert( 517 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::operation::stored_type>( 518 ColumnFlag::operation), 519 "Column type and flag combination is not valid"); 520 static_assert( 521 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::data_virtual_address::stored_type>( 522 ColumnFlag::data_virtual_address), 523 "Column type and flag combination is not valid"); 524 static_assert( 525 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::data_physical_address::stored_type>( 526 ColumnFlag::data_physical_address), 527 "Column type and flag combination is not valid"); 528 static_assert( 529 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::total_latency::stored_type>( 530 ColumnFlag::total_latency), 531 "Column type and flag combination is not valid"); 532 static_assert( 533 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::issue_latency::stored_type>( 534 ColumnFlag::issue_latency), 535 "Column type and flag combination is not valid"); 536 static_assert( 537 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::translation_latency::stored_type>( 538 ColumnFlag::translation_latency), 539 "Column type and flag combination is not valid"); 540 static_assert( 541 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::events_bitmask::stored_type>( 542 ColumnFlag::events_bitmask), 543 "Column type and flag combination is not valid"); 544 static_assert( 545 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::data_source::stored_type>( 546 ColumnFlag::data_source), 547 "Column type and flag combination is not valid"); 548 OnConstructionCompletedRegularConstructor( 549 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,utid_storage_layer_,exception_level_storage_layer_,instruction_frame_id_storage_layer_,operation_storage_layer_,data_virtual_address_storage_layer_,data_physical_address_storage_layer_,total_latency_storage_layer_,issue_latency_storage_layer_,translation_latency_storage_layer_,events_bitmask_storage_layer_,data_source_storage_layer_}, 550 {{},{},{},utid_null_layer_,{},instruction_frame_id_null_layer_,{},{},{},{},{},{},{},{}}); 551 } 552 ~SpeRecordTable() override; 553 Name()554 static const char* Name() { return "__intrinsic_spe_record"; } 555 ComputeStaticSchema()556 static Table::Schema ComputeStaticSchema() { 557 Table::Schema schema; 558 schema.columns.emplace_back(Table::Schema::Column{ 559 "id", SqlValue::Type::kLong, true, true, false, false}); 560 schema.columns.emplace_back(Table::Schema::Column{ 561 "type", SqlValue::Type::kString, false, false, false, false}); 562 schema.columns.emplace_back(Table::Schema::Column{ 563 "ts", ColumnType::ts::SqlValueType(), false, 564 true, 565 false, 566 false}); 567 schema.columns.emplace_back(Table::Schema::Column{ 568 "utid", ColumnType::utid::SqlValueType(), false, 569 false, 570 false, 571 false}); 572 schema.columns.emplace_back(Table::Schema::Column{ 573 "exception_level", ColumnType::exception_level::SqlValueType(), false, 574 false, 575 false, 576 false}); 577 schema.columns.emplace_back(Table::Schema::Column{ 578 "instruction_frame_id", ColumnType::instruction_frame_id::SqlValueType(), false, 579 false, 580 false, 581 false}); 582 schema.columns.emplace_back(Table::Schema::Column{ 583 "operation", ColumnType::operation::SqlValueType(), false, 584 false, 585 false, 586 false}); 587 schema.columns.emplace_back(Table::Schema::Column{ 588 "data_virtual_address", ColumnType::data_virtual_address::SqlValueType(), false, 589 false, 590 false, 591 false}); 592 schema.columns.emplace_back(Table::Schema::Column{ 593 "data_physical_address", ColumnType::data_physical_address::SqlValueType(), false, 594 false, 595 false, 596 false}); 597 schema.columns.emplace_back(Table::Schema::Column{ 598 "total_latency", ColumnType::total_latency::SqlValueType(), false, 599 false, 600 false, 601 false}); 602 schema.columns.emplace_back(Table::Schema::Column{ 603 "issue_latency", ColumnType::issue_latency::SqlValueType(), false, 604 false, 605 false, 606 false}); 607 schema.columns.emplace_back(Table::Schema::Column{ 608 "translation_latency", ColumnType::translation_latency::SqlValueType(), false, 609 false, 610 false, 611 false}); 612 schema.columns.emplace_back(Table::Schema::Column{ 613 "events_bitmask", ColumnType::events_bitmask::SqlValueType(), false, 614 false, 615 false, 616 false}); 617 schema.columns.emplace_back(Table::Schema::Column{ 618 "data_source", ColumnType::data_source::SqlValueType(), false, 619 false, 620 false, 621 false}); 622 return schema; 623 } 624 IterateRows()625 ConstIterator IterateRows() const { 626 return ConstIterator(this, Table::IterateRows()); 627 } 628 IterateRows()629 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 630 FilterToIterator(const Query & q)631 ConstIterator FilterToIterator(const Query& q) const { 632 return ConstIterator(this, QueryToIterator(q)); 633 } 634 FilterToIterator(const Query & q)635 Iterator FilterToIterator(const Query& q) { 636 return Iterator(this, QueryToIterator(q)); 637 } 638 ShrinkToFit()639 void ShrinkToFit() { 640 type_.ShrinkToFit(); 641 ts_.ShrinkToFit(); 642 utid_.ShrinkToFit(); 643 exception_level_.ShrinkToFit(); 644 instruction_frame_id_.ShrinkToFit(); 645 operation_.ShrinkToFit(); 646 data_virtual_address_.ShrinkToFit(); 647 data_physical_address_.ShrinkToFit(); 648 total_latency_.ShrinkToFit(); 649 issue_latency_.ShrinkToFit(); 650 translation_latency_.ShrinkToFit(); 651 events_bitmask_.ShrinkToFit(); 652 data_source_.ShrinkToFit(); 653 } 654 655 ConstRowReference operator[](uint32_t r) const { 656 return ConstRowReference(this, r); 657 } 658 RowReference operator[](uint32_t r) { return RowReference(this, r); } 659 ConstRowReference operator[](RowNumber r) const { 660 return ConstRowReference(this, r.row_number()); 661 } 662 RowReference operator[](RowNumber r) { 663 return RowReference(this, r.row_number()); 664 } 665 FindById(Id find_id)666 std::optional<ConstRowReference> FindById(Id find_id) const { 667 std::optional<uint32_t> row = id().IndexOf(find_id); 668 return row ? std::make_optional(ConstRowReference(this, *row)) 669 : std::nullopt; 670 } 671 FindById(Id find_id)672 std::optional<RowReference> FindById(Id find_id) { 673 std::optional<uint32_t> row = id().IndexOf(find_id); 674 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 675 } 676 Insert(const Row & row)677 IdAndRow Insert(const Row& row) { 678 uint32_t row_number = row_count(); 679 Id id = Id{row_number}; 680 type_.Append(string_pool()->InternString(row.type())); 681 mutable_ts()->Append(row.ts); 682 mutable_utid()->Append(row.utid); 683 mutable_exception_level()->Append(row.exception_level); 684 mutable_instruction_frame_id()->Append(row.instruction_frame_id); 685 mutable_operation()->Append(row.operation); 686 mutable_data_virtual_address()->Append(row.data_virtual_address); 687 mutable_data_physical_address()->Append(row.data_physical_address); 688 mutable_total_latency()->Append(row.total_latency); 689 mutable_issue_latency()->Append(row.issue_latency); 690 mutable_translation_latency()->Append(row.translation_latency); 691 mutable_events_bitmask()->Append(row.events_bitmask); 692 mutable_data_source()->Append(row.data_source); 693 UpdateSelfOverlayAfterInsert(); 694 return IdAndRow{id, row_number, RowReference(this, row_number), 695 RowNumber(row_number)}; 696 } 697 698 699 id()700 const IdColumn<SpeRecordTable::Id>& id() const { 701 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 702 } type()703 const TypedColumn<StringPool::Id>& type() const { 704 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 705 } ts()706 const TypedColumn<int64_t>& ts() const { 707 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 708 } utid()709 const TypedColumn<std::optional<uint32_t>>& utid() const { 710 return static_cast<const ColumnType::utid&>(columns()[ColumnIndex::utid]); 711 } exception_level()712 const TypedColumn<StringPool::Id>& exception_level() const { 713 return static_cast<const ColumnType::exception_level&>(columns()[ColumnIndex::exception_level]); 714 } instruction_frame_id()715 const TypedColumn<std::optional<StackProfileFrameTable::Id>>& instruction_frame_id() const { 716 return static_cast<const ColumnType::instruction_frame_id&>(columns()[ColumnIndex::instruction_frame_id]); 717 } operation()718 const TypedColumn<StringPool::Id>& operation() const { 719 return static_cast<const ColumnType::operation&>(columns()[ColumnIndex::operation]); 720 } data_virtual_address()721 const TypedColumn<int64_t>& data_virtual_address() const { 722 return static_cast<const ColumnType::data_virtual_address&>(columns()[ColumnIndex::data_virtual_address]); 723 } data_physical_address()724 const TypedColumn<int64_t>& data_physical_address() const { 725 return static_cast<const ColumnType::data_physical_address&>(columns()[ColumnIndex::data_physical_address]); 726 } total_latency()727 const TypedColumn<uint32_t>& total_latency() const { 728 return static_cast<const ColumnType::total_latency&>(columns()[ColumnIndex::total_latency]); 729 } issue_latency()730 const TypedColumn<uint32_t>& issue_latency() const { 731 return static_cast<const ColumnType::issue_latency&>(columns()[ColumnIndex::issue_latency]); 732 } translation_latency()733 const TypedColumn<uint32_t>& translation_latency() const { 734 return static_cast<const ColumnType::translation_latency&>(columns()[ColumnIndex::translation_latency]); 735 } events_bitmask()736 const TypedColumn<int64_t>& events_bitmask() const { 737 return static_cast<const ColumnType::events_bitmask&>(columns()[ColumnIndex::events_bitmask]); 738 } data_source()739 const TypedColumn<StringPool::Id>& data_source() const { 740 return static_cast<const ColumnType::data_source&>(columns()[ColumnIndex::data_source]); 741 } 742 mutable_ts()743 TypedColumn<int64_t>* mutable_ts() { 744 return static_cast<ColumnType::ts*>( 745 GetColumn(ColumnIndex::ts)); 746 } mutable_utid()747 TypedColumn<std::optional<uint32_t>>* mutable_utid() { 748 return static_cast<ColumnType::utid*>( 749 GetColumn(ColumnIndex::utid)); 750 } mutable_exception_level()751 TypedColumn<StringPool::Id>* mutable_exception_level() { 752 return static_cast<ColumnType::exception_level*>( 753 GetColumn(ColumnIndex::exception_level)); 754 } mutable_instruction_frame_id()755 TypedColumn<std::optional<StackProfileFrameTable::Id>>* mutable_instruction_frame_id() { 756 return static_cast<ColumnType::instruction_frame_id*>( 757 GetColumn(ColumnIndex::instruction_frame_id)); 758 } mutable_operation()759 TypedColumn<StringPool::Id>* mutable_operation() { 760 return static_cast<ColumnType::operation*>( 761 GetColumn(ColumnIndex::operation)); 762 } mutable_data_virtual_address()763 TypedColumn<int64_t>* mutable_data_virtual_address() { 764 return static_cast<ColumnType::data_virtual_address*>( 765 GetColumn(ColumnIndex::data_virtual_address)); 766 } mutable_data_physical_address()767 TypedColumn<int64_t>* mutable_data_physical_address() { 768 return static_cast<ColumnType::data_physical_address*>( 769 GetColumn(ColumnIndex::data_physical_address)); 770 } mutable_total_latency()771 TypedColumn<uint32_t>* mutable_total_latency() { 772 return static_cast<ColumnType::total_latency*>( 773 GetColumn(ColumnIndex::total_latency)); 774 } mutable_issue_latency()775 TypedColumn<uint32_t>* mutable_issue_latency() { 776 return static_cast<ColumnType::issue_latency*>( 777 GetColumn(ColumnIndex::issue_latency)); 778 } mutable_translation_latency()779 TypedColumn<uint32_t>* mutable_translation_latency() { 780 return static_cast<ColumnType::translation_latency*>( 781 GetColumn(ColumnIndex::translation_latency)); 782 } mutable_events_bitmask()783 TypedColumn<int64_t>* mutable_events_bitmask() { 784 return static_cast<ColumnType::events_bitmask*>( 785 GetColumn(ColumnIndex::events_bitmask)); 786 } mutable_data_source()787 TypedColumn<StringPool::Id>* mutable_data_source() { 788 return static_cast<ColumnType::data_source*>( 789 GetColumn(ColumnIndex::data_source)); 790 } 791 792 private: 793 794 795 ColumnStorage<ColumnType::ts::stored_type> ts_; 796 ColumnStorage<ColumnType::utid::stored_type> utid_; 797 ColumnStorage<ColumnType::exception_level::stored_type> exception_level_; 798 ColumnStorage<ColumnType::instruction_frame_id::stored_type> instruction_frame_id_; 799 ColumnStorage<ColumnType::operation::stored_type> operation_; 800 ColumnStorage<ColumnType::data_virtual_address::stored_type> data_virtual_address_; 801 ColumnStorage<ColumnType::data_physical_address::stored_type> data_physical_address_; 802 ColumnStorage<ColumnType::total_latency::stored_type> total_latency_; 803 ColumnStorage<ColumnType::issue_latency::stored_type> issue_latency_; 804 ColumnStorage<ColumnType::translation_latency::stored_type> translation_latency_; 805 ColumnStorage<ColumnType::events_bitmask::stored_type> events_bitmask_; 806 ColumnStorage<ColumnType::data_source::stored_type> data_source_; 807 808 RefPtr<column::StorageLayer> id_storage_layer_; 809 RefPtr<column::StorageLayer> type_storage_layer_; 810 RefPtr<column::StorageLayer> ts_storage_layer_; 811 RefPtr<column::StorageLayer> utid_storage_layer_; 812 RefPtr<column::StorageLayer> exception_level_storage_layer_; 813 RefPtr<column::StorageLayer> instruction_frame_id_storage_layer_; 814 RefPtr<column::StorageLayer> operation_storage_layer_; 815 RefPtr<column::StorageLayer> data_virtual_address_storage_layer_; 816 RefPtr<column::StorageLayer> data_physical_address_storage_layer_; 817 RefPtr<column::StorageLayer> total_latency_storage_layer_; 818 RefPtr<column::StorageLayer> issue_latency_storage_layer_; 819 RefPtr<column::StorageLayer> translation_latency_storage_layer_; 820 RefPtr<column::StorageLayer> events_bitmask_storage_layer_; 821 RefPtr<column::StorageLayer> data_source_storage_layer_; 822 823 RefPtr<column::OverlayLayer> utid_null_layer_; 824 RefPtr<column::OverlayLayer> instruction_frame_id_null_layer_; 825 }; 826 827 828 class MmapRecordTable : public macros_internal::MacroTable { 829 public: 830 static constexpr uint32_t kColumnCount = 5; 831 832 struct Id : public BaseId { 833 Id() = default; IdId834 explicit constexpr Id(uint32_t v) : BaseId(v) {} 835 }; 836 static_assert(std::is_trivially_destructible_v<Id>, 837 "Inheritance used without trivial destruction"); 838 839 struct ColumnIndex { 840 static constexpr uint32_t id = 0; 841 static constexpr uint32_t type = 1; 842 static constexpr uint32_t ts = 2; 843 static constexpr uint32_t upid = 3; 844 static constexpr uint32_t mapping_id = 4; 845 }; 846 struct ColumnType { 847 using id = IdColumn<MmapRecordTable::Id>; 848 using type = TypedColumn<StringPool::Id>; 849 using ts = TypedColumn<int64_t>; 850 using upid = TypedColumn<std::optional<uint32_t>>; 851 using mapping_id = TypedColumn<StackProfileMappingTable::Id>; 852 }; 853 struct Row : public macros_internal::RootParentTable::Row { 854 Row(int64_t in_ts = {}, 855 std::optional<uint32_t> in_upid = {}, 856 StackProfileMappingTable::Id in_mapping_id = {}, 857 std::nullptr_t = nullptr) RowRow858 : macros_internal::RootParentTable::Row(), 859 ts(in_ts), 860 upid(in_upid), 861 mapping_id(in_mapping_id) { 862 type_ = "__intrinsic_mmap_record"; 863 } 864 int64_t ts; 865 std::optional<uint32_t> upid; 866 StackProfileMappingTable::Id mapping_id; 867 868 bool operator==(const MmapRecordTable::Row& other) const { 869 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 870 ColumnType::upid::Equals(upid, other.upid) && 871 ColumnType::mapping_id::Equals(mapping_id, other.mapping_id); 872 } 873 }; 874 struct ColumnFlag { 875 static constexpr uint32_t ts = ColumnType::ts::default_flags(); 876 static constexpr uint32_t upid = ColumnType::upid::default_flags(); 877 static constexpr uint32_t mapping_id = ColumnType::mapping_id::default_flags(); 878 }; 879 880 class RowNumber; 881 class ConstRowReference; 882 class RowReference; 883 884 class RowNumber : public macros_internal::AbstractRowNumber< 885 MmapRecordTable, ConstRowReference, RowReference> { 886 public: RowNumber(uint32_t row_number)887 explicit RowNumber(uint32_t row_number) 888 : AbstractRowNumber(row_number) {} 889 }; 890 static_assert(std::is_trivially_destructible_v<RowNumber>, 891 "Inheritance used without trivial destruction"); 892 893 class ConstRowReference : public macros_internal::AbstractConstRowReference< 894 MmapRecordTable, RowNumber> { 895 public: ConstRowReference(const MmapRecordTable * table,uint32_t row_number)896 ConstRowReference(const MmapRecordTable* table, uint32_t row_number) 897 : AbstractConstRowReference(table, row_number) {} 898 id()899 ColumnType::id::type id() const { 900 return table()->id()[row_number_]; 901 } type()902 ColumnType::type::type type() const { 903 return table()->type()[row_number_]; 904 } ts()905 ColumnType::ts::type ts() const { 906 return table()->ts()[row_number_]; 907 } upid()908 ColumnType::upid::type upid() const { 909 return table()->upid()[row_number_]; 910 } mapping_id()911 ColumnType::mapping_id::type mapping_id() const { 912 return table()->mapping_id()[row_number_]; 913 } 914 }; 915 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 916 "Inheritance used without trivial destruction"); 917 class RowReference : public ConstRowReference { 918 public: RowReference(const MmapRecordTable * table,uint32_t row_number)919 RowReference(const MmapRecordTable* table, uint32_t row_number) 920 : ConstRowReference(table, row_number) {} 921 set_ts(ColumnType::ts::non_optional_type v)922 void set_ts( 923 ColumnType::ts::non_optional_type v) { 924 return mutable_table()->mutable_ts()->Set(row_number_, v); 925 } set_upid(ColumnType::upid::non_optional_type v)926 void set_upid( 927 ColumnType::upid::non_optional_type v) { 928 return mutable_table()->mutable_upid()->Set(row_number_, v); 929 } set_mapping_id(ColumnType::mapping_id::non_optional_type v)930 void set_mapping_id( 931 ColumnType::mapping_id::non_optional_type v) { 932 return mutable_table()->mutable_mapping_id()->Set(row_number_, v); 933 } 934 935 private: mutable_table()936 MmapRecordTable* mutable_table() const { 937 return const_cast<MmapRecordTable*>(table()); 938 } 939 }; 940 static_assert(std::is_trivially_destructible_v<RowReference>, 941 "Inheritance used without trivial destruction"); 942 943 class ConstIterator; 944 class ConstIterator : public macros_internal::AbstractConstIterator< 945 ConstIterator, MmapRecordTable, RowNumber, ConstRowReference> { 946 public: id()947 ColumnType::id::type id() const { 948 const auto& col = table()->id(); 949 return col.GetAtIdx( 950 iterator_.StorageIndexForColumn(col.index_in_table())); 951 } type()952 ColumnType::type::type type() const { 953 const auto& col = table()->type(); 954 return col.GetAtIdx( 955 iterator_.StorageIndexForColumn(col.index_in_table())); 956 } ts()957 ColumnType::ts::type ts() const { 958 const auto& col = table()->ts(); 959 return col.GetAtIdx( 960 iterator_.StorageIndexForColumn(col.index_in_table())); 961 } upid()962 ColumnType::upid::type upid() const { 963 const auto& col = table()->upid(); 964 return col.GetAtIdx( 965 iterator_.StorageIndexForColumn(col.index_in_table())); 966 } mapping_id()967 ColumnType::mapping_id::type mapping_id() const { 968 const auto& col = table()->mapping_id(); 969 return col.GetAtIdx( 970 iterator_.StorageIndexForColumn(col.index_in_table())); 971 } 972 973 protected: ConstIterator(const MmapRecordTable * table,Table::Iterator iterator)974 explicit ConstIterator(const MmapRecordTable* table, 975 Table::Iterator iterator) 976 : AbstractConstIterator(table, std::move(iterator)) {} 977 CurrentRowNumber()978 uint32_t CurrentRowNumber() const { 979 return iterator_.StorageIndexForLastOverlay(); 980 } 981 982 private: 983 friend class MmapRecordTable; 984 friend class macros_internal::AbstractConstIterator< 985 ConstIterator, MmapRecordTable, RowNumber, ConstRowReference>; 986 }; 987 class Iterator : public ConstIterator { 988 public: row_reference()989 RowReference row_reference() const { 990 return {const_cast<MmapRecordTable*>(table()), CurrentRowNumber()}; 991 } 992 993 private: 994 friend class MmapRecordTable; 995 Iterator(MmapRecordTable * table,Table::Iterator iterator)996 explicit Iterator(MmapRecordTable* table, Table::Iterator iterator) 997 : ConstIterator(table, std::move(iterator)) {} 998 }; 999 1000 struct IdAndRow { 1001 Id id; 1002 uint32_t row; 1003 RowReference row_reference; 1004 RowNumber row_number; 1005 }; 1006 GetColumns(MmapRecordTable * self,const macros_internal::MacroTable * parent)1007 static std::vector<ColumnLegacy> GetColumns( 1008 MmapRecordTable* self, 1009 const macros_internal::MacroTable* parent) { 1010 std::vector<ColumnLegacy> columns = 1011 CopyColumnsFromParentOrAddRootColumns(self, parent); 1012 uint32_t olay_idx = OverlayCount(parent); 1013 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1014 static_cast<uint32_t>(columns.size()), olay_idx); 1015 AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 1016 static_cast<uint32_t>(columns.size()), olay_idx); 1017 AddColumnToVector(columns, "mapping_id", &self->mapping_id_, ColumnFlag::mapping_id, 1018 static_cast<uint32_t>(columns.size()), olay_idx); 1019 return columns; 1020 } 1021 MmapRecordTable(StringPool * pool)1022 PERFETTO_NO_INLINE explicit MmapRecordTable(StringPool* pool) 1023 : macros_internal::MacroTable( 1024 pool, 1025 GetColumns(this, nullptr), 1026 nullptr), 1027 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 1028 upid_(ColumnStorage<ColumnType::upid::stored_type>::Create<false>()), 1029 mapping_id_(ColumnStorage<ColumnType::mapping_id::stored_type>::Create<false>()) 1030 , 1031 id_storage_layer_(new column::IdStorage()), 1032 type_storage_layer_( 1033 new column::StringStorage(string_pool(), &type_.vector())), 1034 ts_storage_layer_( 1035 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 1036 &ts_.vector(), 1037 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 1038 false)), 1039 upid_storage_layer_( 1040 new column::NumericStorage<ColumnType::upid::non_optional_stored_type>( 1041 &upid_.non_null_vector(), 1042 ColumnTypeHelper<ColumnType::upid::stored_type>::ToColumnType(), 1043 false)), 1044 mapping_id_storage_layer_( 1045 new column::NumericStorage<ColumnType::mapping_id::non_optional_stored_type>( 1046 &mapping_id_.vector(), 1047 ColumnTypeHelper<ColumnType::mapping_id::stored_type>::ToColumnType(), 1048 false)) 1049 , 1050 upid_null_layer_(new column::NullOverlay(upid_.bv())) { 1051 static_assert( 1052 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 1053 ColumnFlag::ts), 1054 "Column type and flag combination is not valid"); 1055 static_assert( 1056 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::upid::stored_type>( 1057 ColumnFlag::upid), 1058 "Column type and flag combination is not valid"); 1059 static_assert( 1060 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::mapping_id::stored_type>( 1061 ColumnFlag::mapping_id), 1062 "Column type and flag combination is not valid"); 1063 OnConstructionCompletedRegularConstructor( 1064 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,upid_storage_layer_,mapping_id_storage_layer_}, 1065 {{},{},{},upid_null_layer_,{}}); 1066 } 1067 ~MmapRecordTable() override; 1068 Name()1069 static const char* Name() { return "__intrinsic_mmap_record"; } 1070 ComputeStaticSchema()1071 static Table::Schema ComputeStaticSchema() { 1072 Table::Schema schema; 1073 schema.columns.emplace_back(Table::Schema::Column{ 1074 "id", SqlValue::Type::kLong, true, true, false, false}); 1075 schema.columns.emplace_back(Table::Schema::Column{ 1076 "type", SqlValue::Type::kString, false, false, false, false}); 1077 schema.columns.emplace_back(Table::Schema::Column{ 1078 "ts", ColumnType::ts::SqlValueType(), false, 1079 false, 1080 false, 1081 false}); 1082 schema.columns.emplace_back(Table::Schema::Column{ 1083 "upid", ColumnType::upid::SqlValueType(), false, 1084 false, 1085 false, 1086 false}); 1087 schema.columns.emplace_back(Table::Schema::Column{ 1088 "mapping_id", ColumnType::mapping_id::SqlValueType(), false, 1089 false, 1090 false, 1091 false}); 1092 return schema; 1093 } 1094 IterateRows()1095 ConstIterator IterateRows() const { 1096 return ConstIterator(this, Table::IterateRows()); 1097 } 1098 IterateRows()1099 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 1100 FilterToIterator(const Query & q)1101 ConstIterator FilterToIterator(const Query& q) const { 1102 return ConstIterator(this, QueryToIterator(q)); 1103 } 1104 FilterToIterator(const Query & q)1105 Iterator FilterToIterator(const Query& q) { 1106 return Iterator(this, QueryToIterator(q)); 1107 } 1108 ShrinkToFit()1109 void ShrinkToFit() { 1110 type_.ShrinkToFit(); 1111 ts_.ShrinkToFit(); 1112 upid_.ShrinkToFit(); 1113 mapping_id_.ShrinkToFit(); 1114 } 1115 1116 ConstRowReference operator[](uint32_t r) const { 1117 return ConstRowReference(this, r); 1118 } 1119 RowReference operator[](uint32_t r) { return RowReference(this, r); } 1120 ConstRowReference operator[](RowNumber r) const { 1121 return ConstRowReference(this, r.row_number()); 1122 } 1123 RowReference operator[](RowNumber r) { 1124 return RowReference(this, r.row_number()); 1125 } 1126 FindById(Id find_id)1127 std::optional<ConstRowReference> FindById(Id find_id) const { 1128 std::optional<uint32_t> row = id().IndexOf(find_id); 1129 return row ? std::make_optional(ConstRowReference(this, *row)) 1130 : std::nullopt; 1131 } 1132 FindById(Id find_id)1133 std::optional<RowReference> FindById(Id find_id) { 1134 std::optional<uint32_t> row = id().IndexOf(find_id); 1135 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 1136 } 1137 Insert(const Row & row)1138 IdAndRow Insert(const Row& row) { 1139 uint32_t row_number = row_count(); 1140 Id id = Id{row_number}; 1141 type_.Append(string_pool()->InternString(row.type())); 1142 mutable_ts()->Append(row.ts); 1143 mutable_upid()->Append(row.upid); 1144 mutable_mapping_id()->Append(row.mapping_id); 1145 UpdateSelfOverlayAfterInsert(); 1146 return IdAndRow{id, row_number, RowReference(this, row_number), 1147 RowNumber(row_number)}; 1148 } 1149 1150 1151 id()1152 const IdColumn<MmapRecordTable::Id>& id() const { 1153 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 1154 } type()1155 const TypedColumn<StringPool::Id>& type() const { 1156 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 1157 } ts()1158 const TypedColumn<int64_t>& ts() const { 1159 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 1160 } upid()1161 const TypedColumn<std::optional<uint32_t>>& upid() const { 1162 return static_cast<const ColumnType::upid&>(columns()[ColumnIndex::upid]); 1163 } mapping_id()1164 const TypedColumn<StackProfileMappingTable::Id>& mapping_id() const { 1165 return static_cast<const ColumnType::mapping_id&>(columns()[ColumnIndex::mapping_id]); 1166 } 1167 mutable_ts()1168 TypedColumn<int64_t>* mutable_ts() { 1169 return static_cast<ColumnType::ts*>( 1170 GetColumn(ColumnIndex::ts)); 1171 } mutable_upid()1172 TypedColumn<std::optional<uint32_t>>* mutable_upid() { 1173 return static_cast<ColumnType::upid*>( 1174 GetColumn(ColumnIndex::upid)); 1175 } mutable_mapping_id()1176 TypedColumn<StackProfileMappingTable::Id>* mutable_mapping_id() { 1177 return static_cast<ColumnType::mapping_id*>( 1178 GetColumn(ColumnIndex::mapping_id)); 1179 } 1180 1181 private: 1182 1183 1184 ColumnStorage<ColumnType::ts::stored_type> ts_; 1185 ColumnStorage<ColumnType::upid::stored_type> upid_; 1186 ColumnStorage<ColumnType::mapping_id::stored_type> mapping_id_; 1187 1188 RefPtr<column::StorageLayer> id_storage_layer_; 1189 RefPtr<column::StorageLayer> type_storage_layer_; 1190 RefPtr<column::StorageLayer> ts_storage_layer_; 1191 RefPtr<column::StorageLayer> upid_storage_layer_; 1192 RefPtr<column::StorageLayer> mapping_id_storage_layer_; 1193 1194 RefPtr<column::OverlayLayer> upid_null_layer_; 1195 }; 1196 1197 } // namespace perfetto 1198 1199 #endif // SRC_TRACE_PROCESSOR_TABLES_PERF_TABLES_PY_H_ 1200