1 #ifndef SRC_TRACE_PROCESSOR_TABLES_ETM_TABLES_PY_H_
2 #define SRC_TRACE_PROCESSOR_TABLES_ETM_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 EtmV4ConfigurationTable : public macros_internal::MacroTable {
42  public:
43   static constexpr uint32_t kColumnCount = 11;
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 set_id = 2;
56     static constexpr uint32_t cpu = 3;
57     static constexpr uint32_t cs_trace_id = 4;
58     static constexpr uint32_t core_profile = 5;
59     static constexpr uint32_t arch_version = 6;
60     static constexpr uint32_t major_version = 7;
61     static constexpr uint32_t minor_version = 8;
62     static constexpr uint32_t max_speculation_depth = 9;
63     static constexpr uint32_t bool_flags = 10;
64   };
65   struct ColumnType {
66     using id = IdColumn<EtmV4ConfigurationTable::Id>;
67     using type = TypedColumn<StringPool::Id>;
68     using set_id = TypedColumn<uint32_t>;
69     using cpu = TypedColumn<uint32_t>;
70     using cs_trace_id = TypedColumn<uint32_t>;
71     using core_profile = TypedColumn<StringPool::Id>;
72     using arch_version = TypedColumn<StringPool::Id>;
73     using major_version = TypedColumn<uint32_t>;
74     using minor_version = TypedColumn<uint32_t>;
75     using max_speculation_depth = TypedColumn<uint32_t>;
76     using bool_flags = TypedColumn<int64_t>;
77   };
78   struct Row : public macros_internal::RootParentTable::Row {
79     Row(uint32_t in_set_id = {},
80         uint32_t in_cpu = {},
81         uint32_t in_cs_trace_id = {},
82         StringPool::Id in_core_profile = {},
83         StringPool::Id in_arch_version = {},
84         uint32_t in_major_version = {},
85         uint32_t in_minor_version = {},
86         uint32_t in_max_speculation_depth = {},
87         int64_t in_bool_flags = {},
88         std::nullptr_t = nullptr)
RowRow89         : macros_internal::RootParentTable::Row(),
90           set_id(in_set_id),
91           cpu(in_cpu),
92           cs_trace_id(in_cs_trace_id),
93           core_profile(in_core_profile),
94           arch_version(in_arch_version),
95           major_version(in_major_version),
96           minor_version(in_minor_version),
97           max_speculation_depth(in_max_speculation_depth),
98           bool_flags(in_bool_flags) {
99       type_ = "__intrinsic_etm_v4_configuration";
100     }
101     uint32_t set_id;
102     uint32_t cpu;
103     uint32_t cs_trace_id;
104     StringPool::Id core_profile;
105     StringPool::Id arch_version;
106     uint32_t major_version;
107     uint32_t minor_version;
108     uint32_t max_speculation_depth;
109     int64_t bool_flags;
110 
111     bool operator==(const EtmV4ConfigurationTable::Row& other) const {
112       return type() == other.type() && ColumnType::set_id::Equals(set_id, other.set_id) &&
113        ColumnType::cpu::Equals(cpu, other.cpu) &&
114        ColumnType::cs_trace_id::Equals(cs_trace_id, other.cs_trace_id) &&
115        ColumnType::core_profile::Equals(core_profile, other.core_profile) &&
116        ColumnType::arch_version::Equals(arch_version, other.arch_version) &&
117        ColumnType::major_version::Equals(major_version, other.major_version) &&
118        ColumnType::minor_version::Equals(minor_version, other.minor_version) &&
119        ColumnType::max_speculation_depth::Equals(max_speculation_depth, other.max_speculation_depth) &&
120        ColumnType::bool_flags::Equals(bool_flags, other.bool_flags);
121     }
122   };
123   struct ColumnFlag {
124     static constexpr uint32_t set_id = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted | ColumnLegacy::Flag::kSetId) | ColumnType::set_id::default_flags();
125     static constexpr uint32_t cpu = ColumnType::cpu::default_flags();
126     static constexpr uint32_t cs_trace_id = ColumnType::cs_trace_id::default_flags();
127     static constexpr uint32_t core_profile = ColumnType::core_profile::default_flags();
128     static constexpr uint32_t arch_version = ColumnType::arch_version::default_flags();
129     static constexpr uint32_t major_version = ColumnType::major_version::default_flags();
130     static constexpr uint32_t minor_version = ColumnType::minor_version::default_flags();
131     static constexpr uint32_t max_speculation_depth = ColumnType::max_speculation_depth::default_flags();
132     static constexpr uint32_t bool_flags = ColumnType::bool_flags::default_flags();
133   };
134 
135   class RowNumber;
136   class ConstRowReference;
137   class RowReference;
138 
139   class RowNumber : public macros_internal::AbstractRowNumber<
140       EtmV4ConfigurationTable, ConstRowReference, RowReference> {
141    public:
RowNumber(uint32_t row_number)142     explicit RowNumber(uint32_t row_number)
143         : AbstractRowNumber(row_number) {}
144   };
145   static_assert(std::is_trivially_destructible_v<RowNumber>,
146                 "Inheritance used without trivial destruction");
147 
148   class ConstRowReference : public macros_internal::AbstractConstRowReference<
149     EtmV4ConfigurationTable, RowNumber> {
150    public:
ConstRowReference(const EtmV4ConfigurationTable * table,uint32_t row_number)151     ConstRowReference(const EtmV4ConfigurationTable* table, uint32_t row_number)
152         : AbstractConstRowReference(table, row_number) {}
153 
id()154     ColumnType::id::type id() const {
155       return table()->id()[row_number_];
156     }
type()157     ColumnType::type::type type() const {
158       return table()->type()[row_number_];
159     }
set_id()160     ColumnType::set_id::type set_id() const {
161       return table()->set_id()[row_number_];
162     }
cpu()163     ColumnType::cpu::type cpu() const {
164       return table()->cpu()[row_number_];
165     }
cs_trace_id()166     ColumnType::cs_trace_id::type cs_trace_id() const {
167       return table()->cs_trace_id()[row_number_];
168     }
core_profile()169     ColumnType::core_profile::type core_profile() const {
170       return table()->core_profile()[row_number_];
171     }
arch_version()172     ColumnType::arch_version::type arch_version() const {
173       return table()->arch_version()[row_number_];
174     }
major_version()175     ColumnType::major_version::type major_version() const {
176       return table()->major_version()[row_number_];
177     }
minor_version()178     ColumnType::minor_version::type minor_version() const {
179       return table()->minor_version()[row_number_];
180     }
max_speculation_depth()181     ColumnType::max_speculation_depth::type max_speculation_depth() const {
182       return table()->max_speculation_depth()[row_number_];
183     }
bool_flags()184     ColumnType::bool_flags::type bool_flags() const {
185       return table()->bool_flags()[row_number_];
186     }
187   };
188   static_assert(std::is_trivially_destructible_v<ConstRowReference>,
189                 "Inheritance used without trivial destruction");
190   class RowReference : public ConstRowReference {
191    public:
RowReference(const EtmV4ConfigurationTable * table,uint32_t row_number)192     RowReference(const EtmV4ConfigurationTable* table, uint32_t row_number)
193         : ConstRowReference(table, row_number) {}
194 
set_set_id(ColumnType::set_id::non_optional_type v)195     void set_set_id(
196         ColumnType::set_id::non_optional_type v) {
197       return mutable_table()->mutable_set_id()->Set(row_number_, v);
198     }
set_cpu(ColumnType::cpu::non_optional_type v)199     void set_cpu(
200         ColumnType::cpu::non_optional_type v) {
201       return mutable_table()->mutable_cpu()->Set(row_number_, v);
202     }
set_cs_trace_id(ColumnType::cs_trace_id::non_optional_type v)203     void set_cs_trace_id(
204         ColumnType::cs_trace_id::non_optional_type v) {
205       return mutable_table()->mutable_cs_trace_id()->Set(row_number_, v);
206     }
set_core_profile(ColumnType::core_profile::non_optional_type v)207     void set_core_profile(
208         ColumnType::core_profile::non_optional_type v) {
209       return mutable_table()->mutable_core_profile()->Set(row_number_, v);
210     }
set_arch_version(ColumnType::arch_version::non_optional_type v)211     void set_arch_version(
212         ColumnType::arch_version::non_optional_type v) {
213       return mutable_table()->mutable_arch_version()->Set(row_number_, v);
214     }
set_major_version(ColumnType::major_version::non_optional_type v)215     void set_major_version(
216         ColumnType::major_version::non_optional_type v) {
217       return mutable_table()->mutable_major_version()->Set(row_number_, v);
218     }
set_minor_version(ColumnType::minor_version::non_optional_type v)219     void set_minor_version(
220         ColumnType::minor_version::non_optional_type v) {
221       return mutable_table()->mutable_minor_version()->Set(row_number_, v);
222     }
set_max_speculation_depth(ColumnType::max_speculation_depth::non_optional_type v)223     void set_max_speculation_depth(
224         ColumnType::max_speculation_depth::non_optional_type v) {
225       return mutable_table()->mutable_max_speculation_depth()->Set(row_number_, v);
226     }
set_bool_flags(ColumnType::bool_flags::non_optional_type v)227     void set_bool_flags(
228         ColumnType::bool_flags::non_optional_type v) {
229       return mutable_table()->mutable_bool_flags()->Set(row_number_, v);
230     }
231 
232    private:
mutable_table()233     EtmV4ConfigurationTable* mutable_table() const {
234       return const_cast<EtmV4ConfigurationTable*>(table());
235     }
236   };
237   static_assert(std::is_trivially_destructible_v<RowReference>,
238                 "Inheritance used without trivial destruction");
239 
240   class ConstIterator;
241   class ConstIterator : public macros_internal::AbstractConstIterator<
242     ConstIterator, EtmV4ConfigurationTable, RowNumber, ConstRowReference> {
243    public:
id()244     ColumnType::id::type id() const {
245       const auto& col = table()->id();
246       return col.GetAtIdx(
247         iterator_.StorageIndexForColumn(col.index_in_table()));
248     }
type()249     ColumnType::type::type type() const {
250       const auto& col = table()->type();
251       return col.GetAtIdx(
252         iterator_.StorageIndexForColumn(col.index_in_table()));
253     }
set_id()254     ColumnType::set_id::type set_id() const {
255       const auto& col = table()->set_id();
256       return col.GetAtIdx(
257         iterator_.StorageIndexForColumn(col.index_in_table()));
258     }
cpu()259     ColumnType::cpu::type cpu() const {
260       const auto& col = table()->cpu();
261       return col.GetAtIdx(
262         iterator_.StorageIndexForColumn(col.index_in_table()));
263     }
cs_trace_id()264     ColumnType::cs_trace_id::type cs_trace_id() const {
265       const auto& col = table()->cs_trace_id();
266       return col.GetAtIdx(
267         iterator_.StorageIndexForColumn(col.index_in_table()));
268     }
core_profile()269     ColumnType::core_profile::type core_profile() const {
270       const auto& col = table()->core_profile();
271       return col.GetAtIdx(
272         iterator_.StorageIndexForColumn(col.index_in_table()));
273     }
arch_version()274     ColumnType::arch_version::type arch_version() const {
275       const auto& col = table()->arch_version();
276       return col.GetAtIdx(
277         iterator_.StorageIndexForColumn(col.index_in_table()));
278     }
major_version()279     ColumnType::major_version::type major_version() const {
280       const auto& col = table()->major_version();
281       return col.GetAtIdx(
282         iterator_.StorageIndexForColumn(col.index_in_table()));
283     }
minor_version()284     ColumnType::minor_version::type minor_version() const {
285       const auto& col = table()->minor_version();
286       return col.GetAtIdx(
287         iterator_.StorageIndexForColumn(col.index_in_table()));
288     }
max_speculation_depth()289     ColumnType::max_speculation_depth::type max_speculation_depth() const {
290       const auto& col = table()->max_speculation_depth();
291       return col.GetAtIdx(
292         iterator_.StorageIndexForColumn(col.index_in_table()));
293     }
bool_flags()294     ColumnType::bool_flags::type bool_flags() const {
295       const auto& col = table()->bool_flags();
296       return col.GetAtIdx(
297         iterator_.StorageIndexForColumn(col.index_in_table()));
298     }
299 
300    protected:
ConstIterator(const EtmV4ConfigurationTable * table,Table::Iterator iterator)301     explicit ConstIterator(const EtmV4ConfigurationTable* table,
302                            Table::Iterator iterator)
303         : AbstractConstIterator(table, std::move(iterator)) {}
304 
CurrentRowNumber()305     uint32_t CurrentRowNumber() const {
306       return iterator_.StorageIndexForLastOverlay();
307     }
308 
309    private:
310     friend class EtmV4ConfigurationTable;
311     friend class macros_internal::AbstractConstIterator<
312       ConstIterator, EtmV4ConfigurationTable, RowNumber, ConstRowReference>;
313   };
314   class Iterator : public ConstIterator {
315     public:
row_reference()316      RowReference row_reference() const {
317        return {const_cast<EtmV4ConfigurationTable*>(table()), CurrentRowNumber()};
318      }
319 
320     private:
321      friend class EtmV4ConfigurationTable;
322 
Iterator(EtmV4ConfigurationTable * table,Table::Iterator iterator)323      explicit Iterator(EtmV4ConfigurationTable* table, Table::Iterator iterator)
324         : ConstIterator(table, std::move(iterator)) {}
325   };
326 
327   struct IdAndRow {
328     Id id;
329     uint32_t row;
330     RowReference row_reference;
331     RowNumber row_number;
332   };
333 
GetColumns(EtmV4ConfigurationTable * self,const macros_internal::MacroTable * parent)334   static std::vector<ColumnLegacy> GetColumns(
335       EtmV4ConfigurationTable* self,
336       const macros_internal::MacroTable* parent) {
337     std::vector<ColumnLegacy> columns =
338         CopyColumnsFromParentOrAddRootColumns(self, parent);
339     uint32_t olay_idx = OverlayCount(parent);
340     AddColumnToVector(columns, "set_id", &self->set_id_, ColumnFlag::set_id,
341                       static_cast<uint32_t>(columns.size()), olay_idx);
342     AddColumnToVector(columns, "cpu", &self->cpu_, ColumnFlag::cpu,
343                       static_cast<uint32_t>(columns.size()), olay_idx);
344     AddColumnToVector(columns, "cs_trace_id", &self->cs_trace_id_, ColumnFlag::cs_trace_id,
345                       static_cast<uint32_t>(columns.size()), olay_idx);
346     AddColumnToVector(columns, "core_profile", &self->core_profile_, ColumnFlag::core_profile,
347                       static_cast<uint32_t>(columns.size()), olay_idx);
348     AddColumnToVector(columns, "arch_version", &self->arch_version_, ColumnFlag::arch_version,
349                       static_cast<uint32_t>(columns.size()), olay_idx);
350     AddColumnToVector(columns, "major_version", &self->major_version_, ColumnFlag::major_version,
351                       static_cast<uint32_t>(columns.size()), olay_idx);
352     AddColumnToVector(columns, "minor_version", &self->minor_version_, ColumnFlag::minor_version,
353                       static_cast<uint32_t>(columns.size()), olay_idx);
354     AddColumnToVector(columns, "max_speculation_depth", &self->max_speculation_depth_, ColumnFlag::max_speculation_depth,
355                       static_cast<uint32_t>(columns.size()), olay_idx);
356     AddColumnToVector(columns, "bool_flags", &self->bool_flags_, ColumnFlag::bool_flags,
357                       static_cast<uint32_t>(columns.size()), olay_idx);
358     return columns;
359   }
360 
EtmV4ConfigurationTable(StringPool * pool)361   PERFETTO_NO_INLINE explicit EtmV4ConfigurationTable(StringPool* pool)
362       : macros_internal::MacroTable(
363           pool,
364           GetColumns(this, nullptr),
365           nullptr),
366         set_id_(ColumnStorage<ColumnType::set_id::stored_type>::Create<false>()),
367         cpu_(ColumnStorage<ColumnType::cpu::stored_type>::Create<false>()),
368         cs_trace_id_(ColumnStorage<ColumnType::cs_trace_id::stored_type>::Create<false>()),
369         core_profile_(ColumnStorage<ColumnType::core_profile::stored_type>::Create<false>()),
370         arch_version_(ColumnStorage<ColumnType::arch_version::stored_type>::Create<false>()),
371         major_version_(ColumnStorage<ColumnType::major_version::stored_type>::Create<false>()),
372         minor_version_(ColumnStorage<ColumnType::minor_version::stored_type>::Create<false>()),
373         max_speculation_depth_(ColumnStorage<ColumnType::max_speculation_depth::stored_type>::Create<false>()),
374         bool_flags_(ColumnStorage<ColumnType::bool_flags::stored_type>::Create<false>())
375 ,
376         id_storage_layer_(new column::IdStorage()),
377         type_storage_layer_(
378           new column::StringStorage(string_pool(), &type_.vector())),
379         set_id_storage_layer_(
380           new column::SetIdStorage(&set_id_.vector())),
381         cpu_storage_layer_(
382         new column::NumericStorage<ColumnType::cpu::non_optional_stored_type>(
383           &cpu_.vector(),
384           ColumnTypeHelper<ColumnType::cpu::stored_type>::ToColumnType(),
385           false)),
386         cs_trace_id_storage_layer_(
387         new column::NumericStorage<ColumnType::cs_trace_id::non_optional_stored_type>(
388           &cs_trace_id_.vector(),
389           ColumnTypeHelper<ColumnType::cs_trace_id::stored_type>::ToColumnType(),
390           false)),
391         core_profile_storage_layer_(
392           new column::StringStorage(string_pool(), &core_profile_.vector())),
393         arch_version_storage_layer_(
394           new column::StringStorage(string_pool(), &arch_version_.vector())),
395         major_version_storage_layer_(
396         new column::NumericStorage<ColumnType::major_version::non_optional_stored_type>(
397           &major_version_.vector(),
398           ColumnTypeHelper<ColumnType::major_version::stored_type>::ToColumnType(),
399           false)),
400         minor_version_storage_layer_(
401         new column::NumericStorage<ColumnType::minor_version::non_optional_stored_type>(
402           &minor_version_.vector(),
403           ColumnTypeHelper<ColumnType::minor_version::stored_type>::ToColumnType(),
404           false)),
405         max_speculation_depth_storage_layer_(
406         new column::NumericStorage<ColumnType::max_speculation_depth::non_optional_stored_type>(
407           &max_speculation_depth_.vector(),
408           ColumnTypeHelper<ColumnType::max_speculation_depth::stored_type>::ToColumnType(),
409           false)),
410         bool_flags_storage_layer_(
411         new column::NumericStorage<ColumnType::bool_flags::non_optional_stored_type>(
412           &bool_flags_.vector(),
413           ColumnTypeHelper<ColumnType::bool_flags::stored_type>::ToColumnType(),
414           false))
415          {
416     static_assert(
417         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::set_id::stored_type>(
418           ColumnFlag::set_id),
419         "Column type and flag combination is not valid");
420       static_assert(
421         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::cpu::stored_type>(
422           ColumnFlag::cpu),
423         "Column type and flag combination is not valid");
424       static_assert(
425         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::cs_trace_id::stored_type>(
426           ColumnFlag::cs_trace_id),
427         "Column type and flag combination is not valid");
428       static_assert(
429         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::core_profile::stored_type>(
430           ColumnFlag::core_profile),
431         "Column type and flag combination is not valid");
432       static_assert(
433         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arch_version::stored_type>(
434           ColumnFlag::arch_version),
435         "Column type and flag combination is not valid");
436       static_assert(
437         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::major_version::stored_type>(
438           ColumnFlag::major_version),
439         "Column type and flag combination is not valid");
440       static_assert(
441         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::minor_version::stored_type>(
442           ColumnFlag::minor_version),
443         "Column type and flag combination is not valid");
444       static_assert(
445         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::max_speculation_depth::stored_type>(
446           ColumnFlag::max_speculation_depth),
447         "Column type and flag combination is not valid");
448       static_assert(
449         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::bool_flags::stored_type>(
450           ColumnFlag::bool_flags),
451         "Column type and flag combination is not valid");
452     OnConstructionCompletedRegularConstructor(
453       {id_storage_layer_,type_storage_layer_,set_id_storage_layer_,cpu_storage_layer_,cs_trace_id_storage_layer_,core_profile_storage_layer_,arch_version_storage_layer_,major_version_storage_layer_,minor_version_storage_layer_,max_speculation_depth_storage_layer_,bool_flags_storage_layer_},
454       {{},{},{},{},{},{},{},{},{},{},{}});
455   }
456   ~EtmV4ConfigurationTable() override;
457 
Name()458   static const char* Name() { return "__intrinsic_etm_v4_configuration"; }
459 
ComputeStaticSchema()460   static Table::Schema ComputeStaticSchema() {
461     Table::Schema schema;
462     schema.columns.emplace_back(Table::Schema::Column{
463         "id", SqlValue::Type::kLong, true, true, false, false});
464     schema.columns.emplace_back(Table::Schema::Column{
465         "type", SqlValue::Type::kString, false, false, false, false});
466     schema.columns.emplace_back(Table::Schema::Column{
467         "set_id", ColumnType::set_id::SqlValueType(), false,
468         true,
469         false,
470         true});
471     schema.columns.emplace_back(Table::Schema::Column{
472         "cpu", ColumnType::cpu::SqlValueType(), false,
473         false,
474         false,
475         false});
476     schema.columns.emplace_back(Table::Schema::Column{
477         "cs_trace_id", ColumnType::cs_trace_id::SqlValueType(), false,
478         false,
479         false,
480         false});
481     schema.columns.emplace_back(Table::Schema::Column{
482         "core_profile", ColumnType::core_profile::SqlValueType(), false,
483         false,
484         false,
485         false});
486     schema.columns.emplace_back(Table::Schema::Column{
487         "arch_version", ColumnType::arch_version::SqlValueType(), false,
488         false,
489         false,
490         false});
491     schema.columns.emplace_back(Table::Schema::Column{
492         "major_version", ColumnType::major_version::SqlValueType(), false,
493         false,
494         false,
495         false});
496     schema.columns.emplace_back(Table::Schema::Column{
497         "minor_version", ColumnType::minor_version::SqlValueType(), false,
498         false,
499         false,
500         false});
501     schema.columns.emplace_back(Table::Schema::Column{
502         "max_speculation_depth", ColumnType::max_speculation_depth::SqlValueType(), false,
503         false,
504         false,
505         false});
506     schema.columns.emplace_back(Table::Schema::Column{
507         "bool_flags", ColumnType::bool_flags::SqlValueType(), false,
508         false,
509         false,
510         false});
511     return schema;
512   }
513 
IterateRows()514   ConstIterator IterateRows() const {
515     return ConstIterator(this, Table::IterateRows());
516   }
517 
IterateRows()518   Iterator IterateRows() { return Iterator(this, Table::IterateRows()); }
519 
FilterToIterator(const Query & q)520   ConstIterator FilterToIterator(const Query& q) const {
521     return ConstIterator(this, QueryToIterator(q));
522   }
523 
FilterToIterator(const Query & q)524   Iterator FilterToIterator(const Query& q) {
525     return Iterator(this, QueryToIterator(q));
526   }
527 
ShrinkToFit()528   void ShrinkToFit() {
529     type_.ShrinkToFit();
530     set_id_.ShrinkToFit();
531     cpu_.ShrinkToFit();
532     cs_trace_id_.ShrinkToFit();
533     core_profile_.ShrinkToFit();
534     arch_version_.ShrinkToFit();
535     major_version_.ShrinkToFit();
536     minor_version_.ShrinkToFit();
537     max_speculation_depth_.ShrinkToFit();
538     bool_flags_.ShrinkToFit();
539   }
540 
541   ConstRowReference operator[](uint32_t r) const {
542     return ConstRowReference(this, r);
543   }
544   RowReference operator[](uint32_t r) { return RowReference(this, r); }
545   ConstRowReference operator[](RowNumber r) const {
546     return ConstRowReference(this, r.row_number());
547   }
548   RowReference operator[](RowNumber r) {
549     return RowReference(this, r.row_number());
550   }
551 
FindById(Id find_id)552   std::optional<ConstRowReference> FindById(Id find_id) const {
553     std::optional<uint32_t> row = id().IndexOf(find_id);
554     return row ? std::make_optional(ConstRowReference(this, *row))
555                : std::nullopt;
556   }
557 
FindById(Id find_id)558   std::optional<RowReference> FindById(Id find_id) {
559     std::optional<uint32_t> row = id().IndexOf(find_id);
560     return row ? std::make_optional(RowReference(this, *row)) : std::nullopt;
561   }
562 
Insert(const Row & row)563   IdAndRow Insert(const Row& row) {
564     uint32_t row_number = row_count();
565     Id id = Id{row_number};
566     type_.Append(string_pool()->InternString(row.type()));
567     mutable_set_id()->Append(row.set_id);
568     mutable_cpu()->Append(row.cpu);
569     mutable_cs_trace_id()->Append(row.cs_trace_id);
570     mutable_core_profile()->Append(row.core_profile);
571     mutable_arch_version()->Append(row.arch_version);
572     mutable_major_version()->Append(row.major_version);
573     mutable_minor_version()->Append(row.minor_version);
574     mutable_max_speculation_depth()->Append(row.max_speculation_depth);
575     mutable_bool_flags()->Append(row.bool_flags);
576     UpdateSelfOverlayAfterInsert();
577     return IdAndRow{id, row_number, RowReference(this, row_number),
578                      RowNumber(row_number)};
579   }
580 
581 
582 
id()583   const IdColumn<EtmV4ConfigurationTable::Id>& id() const {
584     return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]);
585   }
type()586   const TypedColumn<StringPool::Id>& type() const {
587     return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]);
588   }
set_id()589   const TypedColumn<uint32_t>& set_id() const {
590     return static_cast<const ColumnType::set_id&>(columns()[ColumnIndex::set_id]);
591   }
cpu()592   const TypedColumn<uint32_t>& cpu() const {
593     return static_cast<const ColumnType::cpu&>(columns()[ColumnIndex::cpu]);
594   }
cs_trace_id()595   const TypedColumn<uint32_t>& cs_trace_id() const {
596     return static_cast<const ColumnType::cs_trace_id&>(columns()[ColumnIndex::cs_trace_id]);
597   }
core_profile()598   const TypedColumn<StringPool::Id>& core_profile() const {
599     return static_cast<const ColumnType::core_profile&>(columns()[ColumnIndex::core_profile]);
600   }
arch_version()601   const TypedColumn<StringPool::Id>& arch_version() const {
602     return static_cast<const ColumnType::arch_version&>(columns()[ColumnIndex::arch_version]);
603   }
major_version()604   const TypedColumn<uint32_t>& major_version() const {
605     return static_cast<const ColumnType::major_version&>(columns()[ColumnIndex::major_version]);
606   }
minor_version()607   const TypedColumn<uint32_t>& minor_version() const {
608     return static_cast<const ColumnType::minor_version&>(columns()[ColumnIndex::minor_version]);
609   }
max_speculation_depth()610   const TypedColumn<uint32_t>& max_speculation_depth() const {
611     return static_cast<const ColumnType::max_speculation_depth&>(columns()[ColumnIndex::max_speculation_depth]);
612   }
bool_flags()613   const TypedColumn<int64_t>& bool_flags() const {
614     return static_cast<const ColumnType::bool_flags&>(columns()[ColumnIndex::bool_flags]);
615   }
616 
mutable_set_id()617   TypedColumn<uint32_t>* mutable_set_id() {
618     return static_cast<ColumnType::set_id*>(
619         GetColumn(ColumnIndex::set_id));
620   }
mutable_cpu()621   TypedColumn<uint32_t>* mutable_cpu() {
622     return static_cast<ColumnType::cpu*>(
623         GetColumn(ColumnIndex::cpu));
624   }
mutable_cs_trace_id()625   TypedColumn<uint32_t>* mutable_cs_trace_id() {
626     return static_cast<ColumnType::cs_trace_id*>(
627         GetColumn(ColumnIndex::cs_trace_id));
628   }
mutable_core_profile()629   TypedColumn<StringPool::Id>* mutable_core_profile() {
630     return static_cast<ColumnType::core_profile*>(
631         GetColumn(ColumnIndex::core_profile));
632   }
mutable_arch_version()633   TypedColumn<StringPool::Id>* mutable_arch_version() {
634     return static_cast<ColumnType::arch_version*>(
635         GetColumn(ColumnIndex::arch_version));
636   }
mutable_major_version()637   TypedColumn<uint32_t>* mutable_major_version() {
638     return static_cast<ColumnType::major_version*>(
639         GetColumn(ColumnIndex::major_version));
640   }
mutable_minor_version()641   TypedColumn<uint32_t>* mutable_minor_version() {
642     return static_cast<ColumnType::minor_version*>(
643         GetColumn(ColumnIndex::minor_version));
644   }
mutable_max_speculation_depth()645   TypedColumn<uint32_t>* mutable_max_speculation_depth() {
646     return static_cast<ColumnType::max_speculation_depth*>(
647         GetColumn(ColumnIndex::max_speculation_depth));
648   }
mutable_bool_flags()649   TypedColumn<int64_t>* mutable_bool_flags() {
650     return static_cast<ColumnType::bool_flags*>(
651         GetColumn(ColumnIndex::bool_flags));
652   }
653 
654  private:
655 
656 
657   ColumnStorage<ColumnType::set_id::stored_type> set_id_;
658   ColumnStorage<ColumnType::cpu::stored_type> cpu_;
659   ColumnStorage<ColumnType::cs_trace_id::stored_type> cs_trace_id_;
660   ColumnStorage<ColumnType::core_profile::stored_type> core_profile_;
661   ColumnStorage<ColumnType::arch_version::stored_type> arch_version_;
662   ColumnStorage<ColumnType::major_version::stored_type> major_version_;
663   ColumnStorage<ColumnType::minor_version::stored_type> minor_version_;
664   ColumnStorage<ColumnType::max_speculation_depth::stored_type> max_speculation_depth_;
665   ColumnStorage<ColumnType::bool_flags::stored_type> bool_flags_;
666 
667   RefPtr<column::StorageLayer> id_storage_layer_;
668   RefPtr<column::StorageLayer> type_storage_layer_;
669   RefPtr<column::StorageLayer> set_id_storage_layer_;
670   RefPtr<column::StorageLayer> cpu_storage_layer_;
671   RefPtr<column::StorageLayer> cs_trace_id_storage_layer_;
672   RefPtr<column::StorageLayer> core_profile_storage_layer_;
673   RefPtr<column::StorageLayer> arch_version_storage_layer_;
674   RefPtr<column::StorageLayer> major_version_storage_layer_;
675   RefPtr<column::StorageLayer> minor_version_storage_layer_;
676   RefPtr<column::StorageLayer> max_speculation_depth_storage_layer_;
677   RefPtr<column::StorageLayer> bool_flags_storage_layer_;
678 
679 
680 };
681 
682 
683 class EtmV4SessionTable : public macros_internal::MacroTable {
684  public:
685   static constexpr uint32_t kColumnCount = 4;
686 
687   struct Id : public BaseId {
688     Id() = default;
IdId689     explicit constexpr Id(uint32_t v) : BaseId(v) {}
690   };
691   static_assert(std::is_trivially_destructible_v<Id>,
692                 "Inheritance used without trivial destruction");
693 
694   struct ColumnIndex {
695     static constexpr uint32_t id = 0;
696     static constexpr uint32_t type = 1;
697     static constexpr uint32_t configuration_id = 2;
698     static constexpr uint32_t start_ts = 3;
699   };
700   struct ColumnType {
701     using id = IdColumn<EtmV4SessionTable::Id>;
702     using type = TypedColumn<StringPool::Id>;
703     using configuration_id = TypedColumn<EtmV4ConfigurationTable::Id>;
704     using start_ts = TypedColumn<std::optional<int64_t>>;
705   };
706   struct Row : public macros_internal::RootParentTable::Row {
707     Row(EtmV4ConfigurationTable::Id in_configuration_id = {},
708         std::optional<int64_t> in_start_ts = {},
709         std::nullptr_t = nullptr)
RowRow710         : macros_internal::RootParentTable::Row(),
711           configuration_id(in_configuration_id),
712           start_ts(in_start_ts) {
713       type_ = "__intrinsic_etm_v4_session";
714     }
715     EtmV4ConfigurationTable::Id configuration_id;
716     std::optional<int64_t> start_ts;
717 
718     bool operator==(const EtmV4SessionTable::Row& other) const {
719       return type() == other.type() && ColumnType::configuration_id::Equals(configuration_id, other.configuration_id) &&
720        ColumnType::start_ts::Equals(start_ts, other.start_ts);
721     }
722   };
723   struct ColumnFlag {
724     static constexpr uint32_t configuration_id = ColumnType::configuration_id::default_flags();
725     static constexpr uint32_t start_ts = ColumnType::start_ts::default_flags();
726   };
727 
728   class RowNumber;
729   class ConstRowReference;
730   class RowReference;
731 
732   class RowNumber : public macros_internal::AbstractRowNumber<
733       EtmV4SessionTable, ConstRowReference, RowReference> {
734    public:
RowNumber(uint32_t row_number)735     explicit RowNumber(uint32_t row_number)
736         : AbstractRowNumber(row_number) {}
737   };
738   static_assert(std::is_trivially_destructible_v<RowNumber>,
739                 "Inheritance used without trivial destruction");
740 
741   class ConstRowReference : public macros_internal::AbstractConstRowReference<
742     EtmV4SessionTable, RowNumber> {
743    public:
ConstRowReference(const EtmV4SessionTable * table,uint32_t row_number)744     ConstRowReference(const EtmV4SessionTable* table, uint32_t row_number)
745         : AbstractConstRowReference(table, row_number) {}
746 
id()747     ColumnType::id::type id() const {
748       return table()->id()[row_number_];
749     }
type()750     ColumnType::type::type type() const {
751       return table()->type()[row_number_];
752     }
configuration_id()753     ColumnType::configuration_id::type configuration_id() const {
754       return table()->configuration_id()[row_number_];
755     }
start_ts()756     ColumnType::start_ts::type start_ts() const {
757       return table()->start_ts()[row_number_];
758     }
759   };
760   static_assert(std::is_trivially_destructible_v<ConstRowReference>,
761                 "Inheritance used without trivial destruction");
762   class RowReference : public ConstRowReference {
763    public:
RowReference(const EtmV4SessionTable * table,uint32_t row_number)764     RowReference(const EtmV4SessionTable* table, uint32_t row_number)
765         : ConstRowReference(table, row_number) {}
766 
set_configuration_id(ColumnType::configuration_id::non_optional_type v)767     void set_configuration_id(
768         ColumnType::configuration_id::non_optional_type v) {
769       return mutable_table()->mutable_configuration_id()->Set(row_number_, v);
770     }
set_start_ts(ColumnType::start_ts::non_optional_type v)771     void set_start_ts(
772         ColumnType::start_ts::non_optional_type v) {
773       return mutable_table()->mutable_start_ts()->Set(row_number_, v);
774     }
775 
776    private:
mutable_table()777     EtmV4SessionTable* mutable_table() const {
778       return const_cast<EtmV4SessionTable*>(table());
779     }
780   };
781   static_assert(std::is_trivially_destructible_v<RowReference>,
782                 "Inheritance used without trivial destruction");
783 
784   class ConstIterator;
785   class ConstIterator : public macros_internal::AbstractConstIterator<
786     ConstIterator, EtmV4SessionTable, RowNumber, ConstRowReference> {
787    public:
id()788     ColumnType::id::type id() const {
789       const auto& col = table()->id();
790       return col.GetAtIdx(
791         iterator_.StorageIndexForColumn(col.index_in_table()));
792     }
type()793     ColumnType::type::type type() const {
794       const auto& col = table()->type();
795       return col.GetAtIdx(
796         iterator_.StorageIndexForColumn(col.index_in_table()));
797     }
configuration_id()798     ColumnType::configuration_id::type configuration_id() const {
799       const auto& col = table()->configuration_id();
800       return col.GetAtIdx(
801         iterator_.StorageIndexForColumn(col.index_in_table()));
802     }
start_ts()803     ColumnType::start_ts::type start_ts() const {
804       const auto& col = table()->start_ts();
805       return col.GetAtIdx(
806         iterator_.StorageIndexForColumn(col.index_in_table()));
807     }
808 
809    protected:
ConstIterator(const EtmV4SessionTable * table,Table::Iterator iterator)810     explicit ConstIterator(const EtmV4SessionTable* table,
811                            Table::Iterator iterator)
812         : AbstractConstIterator(table, std::move(iterator)) {}
813 
CurrentRowNumber()814     uint32_t CurrentRowNumber() const {
815       return iterator_.StorageIndexForLastOverlay();
816     }
817 
818    private:
819     friend class EtmV4SessionTable;
820     friend class macros_internal::AbstractConstIterator<
821       ConstIterator, EtmV4SessionTable, RowNumber, ConstRowReference>;
822   };
823   class Iterator : public ConstIterator {
824     public:
row_reference()825      RowReference row_reference() const {
826        return {const_cast<EtmV4SessionTable*>(table()), CurrentRowNumber()};
827      }
828 
829     private:
830      friend class EtmV4SessionTable;
831 
Iterator(EtmV4SessionTable * table,Table::Iterator iterator)832      explicit Iterator(EtmV4SessionTable* table, Table::Iterator iterator)
833         : ConstIterator(table, std::move(iterator)) {}
834   };
835 
836   struct IdAndRow {
837     Id id;
838     uint32_t row;
839     RowReference row_reference;
840     RowNumber row_number;
841   };
842 
GetColumns(EtmV4SessionTable * self,const macros_internal::MacroTable * parent)843   static std::vector<ColumnLegacy> GetColumns(
844       EtmV4SessionTable* self,
845       const macros_internal::MacroTable* parent) {
846     std::vector<ColumnLegacy> columns =
847         CopyColumnsFromParentOrAddRootColumns(self, parent);
848     uint32_t olay_idx = OverlayCount(parent);
849     AddColumnToVector(columns, "configuration_id", &self->configuration_id_, ColumnFlag::configuration_id,
850                       static_cast<uint32_t>(columns.size()), olay_idx);
851     AddColumnToVector(columns, "start_ts", &self->start_ts_, ColumnFlag::start_ts,
852                       static_cast<uint32_t>(columns.size()), olay_idx);
853     return columns;
854   }
855 
EtmV4SessionTable(StringPool * pool)856   PERFETTO_NO_INLINE explicit EtmV4SessionTable(StringPool* pool)
857       : macros_internal::MacroTable(
858           pool,
859           GetColumns(this, nullptr),
860           nullptr),
861         configuration_id_(ColumnStorage<ColumnType::configuration_id::stored_type>::Create<false>()),
862         start_ts_(ColumnStorage<ColumnType::start_ts::stored_type>::Create<false>())
863 ,
864         id_storage_layer_(new column::IdStorage()),
865         type_storage_layer_(
866           new column::StringStorage(string_pool(), &type_.vector())),
867         configuration_id_storage_layer_(
868         new column::NumericStorage<ColumnType::configuration_id::non_optional_stored_type>(
869           &configuration_id_.vector(),
870           ColumnTypeHelper<ColumnType::configuration_id::stored_type>::ToColumnType(),
871           false)),
872         start_ts_storage_layer_(
873           new column::NumericStorage<ColumnType::start_ts::non_optional_stored_type>(
874             &start_ts_.non_null_vector(),
875             ColumnTypeHelper<ColumnType::start_ts::stored_type>::ToColumnType(),
876             false))
877 ,
878         start_ts_null_layer_(new column::NullOverlay(start_ts_.bv())) {
879     static_assert(
880         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::configuration_id::stored_type>(
881           ColumnFlag::configuration_id),
882         "Column type and flag combination is not valid");
883       static_assert(
884         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::start_ts::stored_type>(
885           ColumnFlag::start_ts),
886         "Column type and flag combination is not valid");
887     OnConstructionCompletedRegularConstructor(
888       {id_storage_layer_,type_storage_layer_,configuration_id_storage_layer_,start_ts_storage_layer_},
889       {{},{},{},start_ts_null_layer_});
890   }
891   ~EtmV4SessionTable() override;
892 
Name()893   static const char* Name() { return "__intrinsic_etm_v4_session"; }
894 
ComputeStaticSchema()895   static Table::Schema ComputeStaticSchema() {
896     Table::Schema schema;
897     schema.columns.emplace_back(Table::Schema::Column{
898         "id", SqlValue::Type::kLong, true, true, false, false});
899     schema.columns.emplace_back(Table::Schema::Column{
900         "type", SqlValue::Type::kString, false, false, false, false});
901     schema.columns.emplace_back(Table::Schema::Column{
902         "configuration_id", ColumnType::configuration_id::SqlValueType(), false,
903         false,
904         false,
905         false});
906     schema.columns.emplace_back(Table::Schema::Column{
907         "start_ts", ColumnType::start_ts::SqlValueType(), false,
908         false,
909         false,
910         false});
911     return schema;
912   }
913 
IterateRows()914   ConstIterator IterateRows() const {
915     return ConstIterator(this, Table::IterateRows());
916   }
917 
IterateRows()918   Iterator IterateRows() { return Iterator(this, Table::IterateRows()); }
919 
FilterToIterator(const Query & q)920   ConstIterator FilterToIterator(const Query& q) const {
921     return ConstIterator(this, QueryToIterator(q));
922   }
923 
FilterToIterator(const Query & q)924   Iterator FilterToIterator(const Query& q) {
925     return Iterator(this, QueryToIterator(q));
926   }
927 
ShrinkToFit()928   void ShrinkToFit() {
929     type_.ShrinkToFit();
930     configuration_id_.ShrinkToFit();
931     start_ts_.ShrinkToFit();
932   }
933 
934   ConstRowReference operator[](uint32_t r) const {
935     return ConstRowReference(this, r);
936   }
937   RowReference operator[](uint32_t r) { return RowReference(this, r); }
938   ConstRowReference operator[](RowNumber r) const {
939     return ConstRowReference(this, r.row_number());
940   }
941   RowReference operator[](RowNumber r) {
942     return RowReference(this, r.row_number());
943   }
944 
FindById(Id find_id)945   std::optional<ConstRowReference> FindById(Id find_id) const {
946     std::optional<uint32_t> row = id().IndexOf(find_id);
947     return row ? std::make_optional(ConstRowReference(this, *row))
948                : std::nullopt;
949   }
950 
FindById(Id find_id)951   std::optional<RowReference> FindById(Id find_id) {
952     std::optional<uint32_t> row = id().IndexOf(find_id);
953     return row ? std::make_optional(RowReference(this, *row)) : std::nullopt;
954   }
955 
Insert(const Row & row)956   IdAndRow Insert(const Row& row) {
957     uint32_t row_number = row_count();
958     Id id = Id{row_number};
959     type_.Append(string_pool()->InternString(row.type()));
960     mutable_configuration_id()->Append(row.configuration_id);
961     mutable_start_ts()->Append(row.start_ts);
962     UpdateSelfOverlayAfterInsert();
963     return IdAndRow{id, row_number, RowReference(this, row_number),
964                      RowNumber(row_number)};
965   }
966 
967 
968 
id()969   const IdColumn<EtmV4SessionTable::Id>& id() const {
970     return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]);
971   }
type()972   const TypedColumn<StringPool::Id>& type() const {
973     return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]);
974   }
configuration_id()975   const TypedColumn<EtmV4ConfigurationTable::Id>& configuration_id() const {
976     return static_cast<const ColumnType::configuration_id&>(columns()[ColumnIndex::configuration_id]);
977   }
start_ts()978   const TypedColumn<std::optional<int64_t>>& start_ts() const {
979     return static_cast<const ColumnType::start_ts&>(columns()[ColumnIndex::start_ts]);
980   }
981 
mutable_configuration_id()982   TypedColumn<EtmV4ConfigurationTable::Id>* mutable_configuration_id() {
983     return static_cast<ColumnType::configuration_id*>(
984         GetColumn(ColumnIndex::configuration_id));
985   }
mutable_start_ts()986   TypedColumn<std::optional<int64_t>>* mutable_start_ts() {
987     return static_cast<ColumnType::start_ts*>(
988         GetColumn(ColumnIndex::start_ts));
989   }
990 
991  private:
992 
993 
994   ColumnStorage<ColumnType::configuration_id::stored_type> configuration_id_;
995   ColumnStorage<ColumnType::start_ts::stored_type> start_ts_;
996 
997   RefPtr<column::StorageLayer> id_storage_layer_;
998   RefPtr<column::StorageLayer> type_storage_layer_;
999   RefPtr<column::StorageLayer> configuration_id_storage_layer_;
1000   RefPtr<column::StorageLayer> start_ts_storage_layer_;
1001 
1002   RefPtr<column::OverlayLayer> start_ts_null_layer_;
1003 };
1004 
1005 
1006 class EtmV4TraceTable : public macros_internal::MacroTable {
1007  public:
1008   static constexpr uint32_t kColumnCount = 5;
1009 
1010   struct Id : public BaseId {
1011     Id() = default;
IdId1012     explicit constexpr Id(uint32_t v) : BaseId(v) {}
1013   };
1014   static_assert(std::is_trivially_destructible_v<Id>,
1015                 "Inheritance used without trivial destruction");
1016 
1017   struct ColumnIndex {
1018     static constexpr uint32_t id = 0;
1019     static constexpr uint32_t type = 1;
1020     static constexpr uint32_t session_id = 2;
1021     static constexpr uint32_t trace_set_id = 3;
1022     static constexpr uint32_t size = 4;
1023   };
1024   struct ColumnType {
1025     using id = IdColumn<EtmV4TraceTable::Id>;
1026     using type = TypedColumn<StringPool::Id>;
1027     using session_id = TypedColumn<EtmV4SessionTable::Id>;
1028     using trace_set_id = TypedColumn<uint32_t>;
1029     using size = TypedColumn<int64_t>;
1030   };
1031   struct Row : public macros_internal::RootParentTable::Row {
1032     Row(EtmV4SessionTable::Id in_session_id = {},
1033         uint32_t in_trace_set_id = {},
1034         int64_t in_size = {},
1035         std::nullptr_t = nullptr)
RowRow1036         : macros_internal::RootParentTable::Row(),
1037           session_id(in_session_id),
1038           trace_set_id(in_trace_set_id),
1039           size(in_size) {
1040       type_ = "__intrinsic_etm_v4_trace";
1041     }
1042     EtmV4SessionTable::Id session_id;
1043     uint32_t trace_set_id;
1044     int64_t size;
1045 
1046     bool operator==(const EtmV4TraceTable::Row& other) const {
1047       return type() == other.type() && ColumnType::session_id::Equals(session_id, other.session_id) &&
1048        ColumnType::trace_set_id::Equals(trace_set_id, other.trace_set_id) &&
1049        ColumnType::size::Equals(size, other.size);
1050     }
1051   };
1052   struct ColumnFlag {
1053     static constexpr uint32_t session_id = ColumnType::session_id::default_flags();
1054     static constexpr uint32_t trace_set_id = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted | ColumnLegacy::Flag::kSetId) | ColumnType::trace_set_id::default_flags();
1055     static constexpr uint32_t size = ColumnType::size::default_flags();
1056   };
1057 
1058   class RowNumber;
1059   class ConstRowReference;
1060   class RowReference;
1061 
1062   class RowNumber : public macros_internal::AbstractRowNumber<
1063       EtmV4TraceTable, ConstRowReference, RowReference> {
1064    public:
RowNumber(uint32_t row_number)1065     explicit RowNumber(uint32_t row_number)
1066         : AbstractRowNumber(row_number) {}
1067   };
1068   static_assert(std::is_trivially_destructible_v<RowNumber>,
1069                 "Inheritance used without trivial destruction");
1070 
1071   class ConstRowReference : public macros_internal::AbstractConstRowReference<
1072     EtmV4TraceTable, RowNumber> {
1073    public:
ConstRowReference(const EtmV4TraceTable * table,uint32_t row_number)1074     ConstRowReference(const EtmV4TraceTable* table, uint32_t row_number)
1075         : AbstractConstRowReference(table, row_number) {}
1076 
id()1077     ColumnType::id::type id() const {
1078       return table()->id()[row_number_];
1079     }
type()1080     ColumnType::type::type type() const {
1081       return table()->type()[row_number_];
1082     }
session_id()1083     ColumnType::session_id::type session_id() const {
1084       return table()->session_id()[row_number_];
1085     }
trace_set_id()1086     ColumnType::trace_set_id::type trace_set_id() const {
1087       return table()->trace_set_id()[row_number_];
1088     }
size()1089     ColumnType::size::type size() const {
1090       return table()->size()[row_number_];
1091     }
1092   };
1093   static_assert(std::is_trivially_destructible_v<ConstRowReference>,
1094                 "Inheritance used without trivial destruction");
1095   class RowReference : public ConstRowReference {
1096    public:
RowReference(const EtmV4TraceTable * table,uint32_t row_number)1097     RowReference(const EtmV4TraceTable* table, uint32_t row_number)
1098         : ConstRowReference(table, row_number) {}
1099 
set_session_id(ColumnType::session_id::non_optional_type v)1100     void set_session_id(
1101         ColumnType::session_id::non_optional_type v) {
1102       return mutable_table()->mutable_session_id()->Set(row_number_, v);
1103     }
set_trace_set_id(ColumnType::trace_set_id::non_optional_type v)1104     void set_trace_set_id(
1105         ColumnType::trace_set_id::non_optional_type v) {
1106       return mutable_table()->mutable_trace_set_id()->Set(row_number_, v);
1107     }
set_size(ColumnType::size::non_optional_type v)1108     void set_size(
1109         ColumnType::size::non_optional_type v) {
1110       return mutable_table()->mutable_size()->Set(row_number_, v);
1111     }
1112 
1113    private:
mutable_table()1114     EtmV4TraceTable* mutable_table() const {
1115       return const_cast<EtmV4TraceTable*>(table());
1116     }
1117   };
1118   static_assert(std::is_trivially_destructible_v<RowReference>,
1119                 "Inheritance used without trivial destruction");
1120 
1121   class ConstIterator;
1122   class ConstIterator : public macros_internal::AbstractConstIterator<
1123     ConstIterator, EtmV4TraceTable, RowNumber, ConstRowReference> {
1124    public:
id()1125     ColumnType::id::type id() const {
1126       const auto& col = table()->id();
1127       return col.GetAtIdx(
1128         iterator_.StorageIndexForColumn(col.index_in_table()));
1129     }
type()1130     ColumnType::type::type type() const {
1131       const auto& col = table()->type();
1132       return col.GetAtIdx(
1133         iterator_.StorageIndexForColumn(col.index_in_table()));
1134     }
session_id()1135     ColumnType::session_id::type session_id() const {
1136       const auto& col = table()->session_id();
1137       return col.GetAtIdx(
1138         iterator_.StorageIndexForColumn(col.index_in_table()));
1139     }
trace_set_id()1140     ColumnType::trace_set_id::type trace_set_id() const {
1141       const auto& col = table()->trace_set_id();
1142       return col.GetAtIdx(
1143         iterator_.StorageIndexForColumn(col.index_in_table()));
1144     }
size()1145     ColumnType::size::type size() const {
1146       const auto& col = table()->size();
1147       return col.GetAtIdx(
1148         iterator_.StorageIndexForColumn(col.index_in_table()));
1149     }
1150 
1151    protected:
ConstIterator(const EtmV4TraceTable * table,Table::Iterator iterator)1152     explicit ConstIterator(const EtmV4TraceTable* table,
1153                            Table::Iterator iterator)
1154         : AbstractConstIterator(table, std::move(iterator)) {}
1155 
CurrentRowNumber()1156     uint32_t CurrentRowNumber() const {
1157       return iterator_.StorageIndexForLastOverlay();
1158     }
1159 
1160    private:
1161     friend class EtmV4TraceTable;
1162     friend class macros_internal::AbstractConstIterator<
1163       ConstIterator, EtmV4TraceTable, RowNumber, ConstRowReference>;
1164   };
1165   class Iterator : public ConstIterator {
1166     public:
row_reference()1167      RowReference row_reference() const {
1168        return {const_cast<EtmV4TraceTable*>(table()), CurrentRowNumber()};
1169      }
1170 
1171     private:
1172      friend class EtmV4TraceTable;
1173 
Iterator(EtmV4TraceTable * table,Table::Iterator iterator)1174      explicit Iterator(EtmV4TraceTable* table, Table::Iterator iterator)
1175         : ConstIterator(table, std::move(iterator)) {}
1176   };
1177 
1178   struct IdAndRow {
1179     Id id;
1180     uint32_t row;
1181     RowReference row_reference;
1182     RowNumber row_number;
1183   };
1184 
GetColumns(EtmV4TraceTable * self,const macros_internal::MacroTable * parent)1185   static std::vector<ColumnLegacy> GetColumns(
1186       EtmV4TraceTable* self,
1187       const macros_internal::MacroTable* parent) {
1188     std::vector<ColumnLegacy> columns =
1189         CopyColumnsFromParentOrAddRootColumns(self, parent);
1190     uint32_t olay_idx = OverlayCount(parent);
1191     AddColumnToVector(columns, "session_id", &self->session_id_, ColumnFlag::session_id,
1192                       static_cast<uint32_t>(columns.size()), olay_idx);
1193     AddColumnToVector(columns, "trace_set_id", &self->trace_set_id_, ColumnFlag::trace_set_id,
1194                       static_cast<uint32_t>(columns.size()), olay_idx);
1195     AddColumnToVector(columns, "size", &self->size_, ColumnFlag::size,
1196                       static_cast<uint32_t>(columns.size()), olay_idx);
1197     return columns;
1198   }
1199 
EtmV4TraceTable(StringPool * pool)1200   PERFETTO_NO_INLINE explicit EtmV4TraceTable(StringPool* pool)
1201       : macros_internal::MacroTable(
1202           pool,
1203           GetColumns(this, nullptr),
1204           nullptr),
1205         session_id_(ColumnStorage<ColumnType::session_id::stored_type>::Create<false>()),
1206         trace_set_id_(ColumnStorage<ColumnType::trace_set_id::stored_type>::Create<false>()),
1207         size_(ColumnStorage<ColumnType::size::stored_type>::Create<false>())
1208 ,
1209         id_storage_layer_(new column::IdStorage()),
1210         type_storage_layer_(
1211           new column::StringStorage(string_pool(), &type_.vector())),
1212         session_id_storage_layer_(
1213         new column::NumericStorage<ColumnType::session_id::non_optional_stored_type>(
1214           &session_id_.vector(),
1215           ColumnTypeHelper<ColumnType::session_id::stored_type>::ToColumnType(),
1216           false)),
1217         trace_set_id_storage_layer_(
1218           new column::SetIdStorage(&trace_set_id_.vector())),
1219         size_storage_layer_(
1220         new column::NumericStorage<ColumnType::size::non_optional_stored_type>(
1221           &size_.vector(),
1222           ColumnTypeHelper<ColumnType::size::stored_type>::ToColumnType(),
1223           false))
1224          {
1225     static_assert(
1226         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::session_id::stored_type>(
1227           ColumnFlag::session_id),
1228         "Column type and flag combination is not valid");
1229       static_assert(
1230         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::trace_set_id::stored_type>(
1231           ColumnFlag::trace_set_id),
1232         "Column type and flag combination is not valid");
1233       static_assert(
1234         ColumnLegacy::IsFlagsAndTypeValid<ColumnType::size::stored_type>(
1235           ColumnFlag::size),
1236         "Column type and flag combination is not valid");
1237     OnConstructionCompletedRegularConstructor(
1238       {id_storage_layer_,type_storage_layer_,session_id_storage_layer_,trace_set_id_storage_layer_,size_storage_layer_},
1239       {{},{},{},{},{}});
1240   }
1241   ~EtmV4TraceTable() override;
1242 
Name()1243   static const char* Name() { return "__intrinsic_etm_v4_trace"; }
1244 
ComputeStaticSchema()1245   static Table::Schema ComputeStaticSchema() {
1246     Table::Schema schema;
1247     schema.columns.emplace_back(Table::Schema::Column{
1248         "id", SqlValue::Type::kLong, true, true, false, false});
1249     schema.columns.emplace_back(Table::Schema::Column{
1250         "type", SqlValue::Type::kString, false, false, false, false});
1251     schema.columns.emplace_back(Table::Schema::Column{
1252         "session_id", ColumnType::session_id::SqlValueType(), false,
1253         false,
1254         false,
1255         false});
1256     schema.columns.emplace_back(Table::Schema::Column{
1257         "trace_set_id", ColumnType::trace_set_id::SqlValueType(), false,
1258         true,
1259         false,
1260         true});
1261     schema.columns.emplace_back(Table::Schema::Column{
1262         "size", ColumnType::size::SqlValueType(), false,
1263         false,
1264         false,
1265         false});
1266     return schema;
1267   }
1268 
IterateRows()1269   ConstIterator IterateRows() const {
1270     return ConstIterator(this, Table::IterateRows());
1271   }
1272 
IterateRows()1273   Iterator IterateRows() { return Iterator(this, Table::IterateRows()); }
1274 
FilterToIterator(const Query & q)1275   ConstIterator FilterToIterator(const Query& q) const {
1276     return ConstIterator(this, QueryToIterator(q));
1277   }
1278 
FilterToIterator(const Query & q)1279   Iterator FilterToIterator(const Query& q) {
1280     return Iterator(this, QueryToIterator(q));
1281   }
1282 
ShrinkToFit()1283   void ShrinkToFit() {
1284     type_.ShrinkToFit();
1285     session_id_.ShrinkToFit();
1286     trace_set_id_.ShrinkToFit();
1287     size_.ShrinkToFit();
1288   }
1289 
1290   ConstRowReference operator[](uint32_t r) const {
1291     return ConstRowReference(this, r);
1292   }
1293   RowReference operator[](uint32_t r) { return RowReference(this, r); }
1294   ConstRowReference operator[](RowNumber r) const {
1295     return ConstRowReference(this, r.row_number());
1296   }
1297   RowReference operator[](RowNumber r) {
1298     return RowReference(this, r.row_number());
1299   }
1300 
FindById(Id find_id)1301   std::optional<ConstRowReference> FindById(Id find_id) const {
1302     std::optional<uint32_t> row = id().IndexOf(find_id);
1303     return row ? std::make_optional(ConstRowReference(this, *row))
1304                : std::nullopt;
1305   }
1306 
FindById(Id find_id)1307   std::optional<RowReference> FindById(Id find_id) {
1308     std::optional<uint32_t> row = id().IndexOf(find_id);
1309     return row ? std::make_optional(RowReference(this, *row)) : std::nullopt;
1310   }
1311 
Insert(const Row & row)1312   IdAndRow Insert(const Row& row) {
1313     uint32_t row_number = row_count();
1314     Id id = Id{row_number};
1315     type_.Append(string_pool()->InternString(row.type()));
1316     mutable_session_id()->Append(row.session_id);
1317     mutable_trace_set_id()->Append(row.trace_set_id);
1318     mutable_size()->Append(row.size);
1319     UpdateSelfOverlayAfterInsert();
1320     return IdAndRow{id, row_number, RowReference(this, row_number),
1321                      RowNumber(row_number)};
1322   }
1323 
1324 
1325 
id()1326   const IdColumn<EtmV4TraceTable::Id>& id() const {
1327     return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]);
1328   }
type()1329   const TypedColumn<StringPool::Id>& type() const {
1330     return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]);
1331   }
session_id()1332   const TypedColumn<EtmV4SessionTable::Id>& session_id() const {
1333     return static_cast<const ColumnType::session_id&>(columns()[ColumnIndex::session_id]);
1334   }
trace_set_id()1335   const TypedColumn<uint32_t>& trace_set_id() const {
1336     return static_cast<const ColumnType::trace_set_id&>(columns()[ColumnIndex::trace_set_id]);
1337   }
size()1338   const TypedColumn<int64_t>& size() const {
1339     return static_cast<const ColumnType::size&>(columns()[ColumnIndex::size]);
1340   }
1341 
mutable_session_id()1342   TypedColumn<EtmV4SessionTable::Id>* mutable_session_id() {
1343     return static_cast<ColumnType::session_id*>(
1344         GetColumn(ColumnIndex::session_id));
1345   }
mutable_trace_set_id()1346   TypedColumn<uint32_t>* mutable_trace_set_id() {
1347     return static_cast<ColumnType::trace_set_id*>(
1348         GetColumn(ColumnIndex::trace_set_id));
1349   }
mutable_size()1350   TypedColumn<int64_t>* mutable_size() {
1351     return static_cast<ColumnType::size*>(
1352         GetColumn(ColumnIndex::size));
1353   }
1354 
1355  private:
1356 
1357 
1358   ColumnStorage<ColumnType::session_id::stored_type> session_id_;
1359   ColumnStorage<ColumnType::trace_set_id::stored_type> trace_set_id_;
1360   ColumnStorage<ColumnType::size::stored_type> size_;
1361 
1362   RefPtr<column::StorageLayer> id_storage_layer_;
1363   RefPtr<column::StorageLayer> type_storage_layer_;
1364   RefPtr<column::StorageLayer> session_id_storage_layer_;
1365   RefPtr<column::StorageLayer> trace_set_id_storage_layer_;
1366   RefPtr<column::StorageLayer> size_storage_layer_;
1367 
1368 
1369 };
1370 
1371 }  // namespace perfetto
1372 
1373 #endif  // SRC_TRACE_PROCESSOR_TABLES_ETM_TABLES_PY_H_
1374