src/trace_processor/tables/macros_internal.h - third_party/perfetto - Git at Google

 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef SRC_TRACE_PROCESSOR_TABLES_MACROS_INTERNAL_H_
 #define SRC_TRACE_PROCESSOR_TABLES_MACROS_INTERNAL_H_

 #include <cstddef>
 #include <cstdint>
 #include <initializer_list>
 #include <type_traits>
 #include <utility>
 #include <vector>

 #include "perfetto/base/compiler.h"
 #include "perfetto/base/logging.h"
 #include "perfetto/trace_processor/ref_counted.h"
 #include "src/trace_processor/containers/bit_vector.h"
 #include "src/trace_processor/containers/row_map.h"
 #include "src/trace_processor/containers/string_pool.h"
 #include "src/trace_processor/db/column.h"
 #include "src/trace_processor/db/column/data_layer.h"
 #include "src/trace_processor/db/column/selector_overlay.h"
 #include "src/trace_processor/db/column_storage.h"
 #include "src/trace_processor/db/column_storage_overlay.h"
 #include "src/trace_processor/db/table.h"

 namespace perfetto::trace_processor::macros_internal {

 // We define this class to allow the table macro below to compile without
 // needing templates; in reality none of the methods will be called because the
 // pointer to this class will always be null.
 class RootParentTable : public Table {
  public:
   struct Row {
    public:
     explicit Row(std::nullptr_t = nullptr) {}

     const char* type() const { return type_; }

    protected:
     const char* type_ = nullptr;
   };
   // This class only exists to allow typechecking to work correctly in Insert
   // below. If we had C++17 and if constexpr, we could statically verify that
   // this was never created but for now, we still need to define it to satisfy
   // the typechecker.
   struct IdAndRow {
     uint32_t id;
   };
   struct RowNumber {
     static uint32_t row_number() { PERFETTO_FATAL("Should not be called"); }
   };
   static IdAndRow Insert(const Row&) { PERFETTO_FATAL("Should not be called"); }

  private:
   explicit RootParentTable(std::nullptr_t);
 };

 // The parent class for all macro generated tables.
 // This class is used to extract common code from the macro tables to reduce
 // code size.
 class MacroTable : public Table {
  public:
   // We don't want a move or copy constructor because we store pointers to
   // fields of macro tables which will be invalidated if we move/copy them.
   MacroTable(const MacroTable&) = delete;
   MacroTable& operator=(const MacroTable&) = delete;

   MacroTable(MacroTable&&) = delete;
   MacroTable& operator=(MacroTable&&) noexcept = delete;

  protected:
   // Constructors for tables created by the regular constructor.
   PERFETTO_NO_INLINE explicit MacroTable(StringPool* pool,
                                          std::vector<ColumnLegacy> columns,
                                          const MacroTable* parent)
       : Table(pool, 0u, std::move(columns), EmptyOverlaysFromParent(parent)),
         allow_inserts_(true),
         parent_(parent) {}

   // Constructor for tables created by SelectAndExtendParent.
   MacroTable(StringPool* pool,
              std::vector<ColumnLegacy> columns,
              const MacroTable& parent,
              const RowMap& parent_overlay)
       : Table(pool,
               parent_overlay.size(),
               std::move(columns),
               SelectedOverlaysFromParent(parent, parent_overlay)),
         allow_inserts_(false),
         parent_(&parent) {}

   ~MacroTable() override;

   PERFETTO_NO_INLINE void UpdateOverlaysAfterParentInsert() {
     CopyLastInsertFrom(parent_->overlays());
   }

   PERFETTO_NO_INLINE void UpdateSelfOverlayAfterInsert() {
     IncrementRowCountAndAddToLastOverlay();
   }

   PERFETTO_NO_INLINE static std::vector<ColumnLegacy>
   CopyColumnsFromParentOrAddRootColumns(MacroTable* self,
                                         const MacroTable* parent) {
     std::vector<ColumnLegacy> columns;
     if (parent) {
       for (const ColumnLegacy& col : parent->columns()) {
         columns.emplace_back(col, col.index_in_table(), col.overlay_index());
       }
     } else {
       columns.emplace_back(ColumnLegacy::IdColumn(0, 0));
       columns.emplace_back("type", &self->type_, ColumnLegacy::kNonNull, 1, 0);
     }
     return columns;
   }

   PERFETTO_NO_INLINE void OnConstructionCompletedRegularConstructor(
       std::initializer_list<RefPtr<column::DataLayer>> storage_layers,
       std::initializer_list<RefPtr<column::DataLayer>> null_layers) {
     std::vector<RefPtr<column::DataLayer>> overlay_layers(
         OverlayCount(parent_) + 1);
     for (uint32_t i = 0; i < overlay_layers.size() - 1; ++i) {
       PERFETTO_CHECK(overlays()[i].row_map().IsBitVector());
       overlay_layers[i].reset(new column::SelectorOverlay(
           overlays()[i].row_map().GetIfBitVector()));
     }
     Table::OnConstructionCompleted(storage_layers, null_layers,
                                    std::move(overlay_layers));
   }

   template <typename T>
   PERFETTO_NO_INLINE static void AddColumnToVector(
       std::vector<ColumnLegacy>& columns,
       const char* name,
       ColumnStorage<T>* storage,
       uint32_t flags,
       uint32_t column_index,
       uint32_t overlay_index) {
     columns.emplace_back(name, storage, flags, column_index, overlay_index);
   }

   static uint32_t OverlayCount(const MacroTable* parent) {
     return parent ? static_cast<uint32_t>(parent->overlays().size()) : 0;
   }

   // Stores whether inserts are allowed into this macro table; by default
   // inserts are allowed but they are disallowed when a parent table is extended
   // with |ExtendParent|; the rationale for this is that extensions usually
   // happen in dynamic tables and they should not be allowed to insert rows into
   // the real (static) tables.
   bool allow_inserts_ = true;

   // Stores the most specific "derived" type of this row in the table.
   //
   // For example, suppose a row is inserted into the gpu_slice table. This will
   // also cause a row to be inserted into the slice table. For users querying
   // the slice table, they will want to know the "real" type of this slice (i.e.
   // they will want to see that the type is gpu_slice). This sparse vector
   // stores precisely the real type.
   //
   // Only relevant for parentless tables. Will be empty and unreferenced by
   // tables with parents.
   ColumnStorage<StringPool::Id> type_;

  private:
   PERFETTO_NO_INLINE static std::vector<ColumnStorageOverlay>
   EmptyOverlaysFromParent(const MacroTable* parent) {
     std::vector<ColumnStorageOverlay> overlays(
         parent ? parent->overlays().size() : 0);
     for (auto& overlay : overlays) {
       overlay = ColumnStorageOverlay(BitVector());
     }
     overlays.emplace_back();
     return overlays;
   }
   PERFETTO_NO_INLINE static std::vector<ColumnStorageOverlay>
   SelectedOverlaysFromParent(const macros_internal::MacroTable& parent,
                              const RowMap& rm) {
     std::vector<ColumnStorageOverlay> overlays;
     for (const auto& overlay : parent.overlays()) {
       overlays.emplace_back(overlay.SelectRows(rm));
       PERFETTO_DCHECK(overlays.back().size() == rm.size());
     }
     overlays.emplace_back(rm.size());
     return overlays;
   }

   const MacroTable* parent_ = nullptr;
 };

 // Abstract iterator class for macro tables.
 // Extracted to allow sharing with view code.
 template <typename Iterator,
           typename MacroTable,
           typename RowNumber,
           typename ConstRowReference>
 class AbstractConstIterator {
  public:
   explicit operator bool() const { return bool(iterator_); }

   Iterator& operator++() {
     ++iterator_;
     return *this_it();
   }

   // Returns a RowNumber for the current row.
   RowNumber row_number() const {
     return RowNumber(this_it()->CurrentRowNumber());
   }

   // Returns a ConstRowReference to the current row.
   ConstRowReference row_reference() const {
     return ConstRowReference(table_, this_it()->CurrentRowNumber());
   }

  protected:
   explicit AbstractConstIterator(const MacroTable* table,
                                  Table::Iterator iterator)
       : iterator_(std::move(iterator)), table_(table) {
     static_assert(std::is_base_of<Table, MacroTable>::value,
                   "Template param should be a subclass of Table.");
   }

   Table::Iterator iterator_;
   const MacroTable* table_;

  private:
   Iterator* this_it() { return static_cast<Iterator*>(this); }
   const Iterator* this_it() const { return static_cast<const Iterator*>(this); }
 };

 // Abstract RowNumber class for macro tables.
 // Extracted to allow sharing with view code.
 template <typename MacroTable,
           typename ConstRowReference,
           typename RowReference = void>
 class AbstractRowNumber {
  public:
   // Converts this RowNumber to a RowReference for the given |table|.
   template <
       typename RR = RowReference,
       typename = typename std::enable_if<!std::is_same<RR, void>::value>::type>
   RR ToRowReference(MacroTable* table) const {
     return RR(table, row_number_);
   }

   // Converts this RowNumber to a ConstRowReference for the given |table|.
   ConstRowReference ToRowReference(const MacroTable& table) const {
     return ConstRowReference(&table, row_number_);
   }

   // Converts this object to the underlying int value.
   uint32_t row_number() const { return row_number_; }

   // Allows sorting + storage in a map/set.
   bool operator<(const AbstractRowNumber& other) const {
     return row_number_ < other.row_number_;
   }

  protected:
   explicit AbstractRowNumber(uint32_t row_number) : row_number_(row_number) {}

  private:
   uint32_t row_number_ = 0;
 };

 // Abstract ConstRowReference class for macro tables.
 // Extracted to allow sharing with view code.
 template <typename MacroTable, typename RowNumber>
 class AbstractConstRowReference {
  public:
   // Converts this RowReference to a RowNumber object which is more memory
   // efficient to store.
   RowNumber ToRowNumber() { return RowNumber(row_number_); }

  protected:
   AbstractConstRowReference(const MacroTable* table, uint32_t row_number)
       : table_(table), row_number_(row_number) {}

   const MacroTable* table_ = nullptr;
   uint32_t row_number_ = 0;
 };

 }  // namespace perfetto::trace_processor::macros_internal

 #endif  // SRC_TRACE_PROCESSOR_TABLES_MACROS_INTERNAL_H_
	/*
	* Copyright (C) 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef SRC_TRACE_PROCESSOR_TABLES_MACROS_INTERNAL_H_
	#define SRC_TRACE_PROCESSOR_TABLES_MACROS_INTERNAL_H_

	#include <cstddef>
	#include <cstdint>
	#include <initializer_list>
	#include <type_traits>
	#include <utility>
	#include <vector>

	#include "perfetto/base/compiler.h"
	#include "perfetto/base/logging.h"
	#include "perfetto/trace_processor/ref_counted.h"
	#include "src/trace_processor/containers/bit_vector.h"
	#include "src/trace_processor/containers/row_map.h"
	#include "src/trace_processor/containers/string_pool.h"
	#include "src/trace_processor/db/column.h"
	#include "src/trace_processor/db/column/data_layer.h"
	#include "src/trace_processor/db/column/selector_overlay.h"
	#include "src/trace_processor/db/column_storage.h"
	#include "src/trace_processor/db/column_storage_overlay.h"
	#include "src/trace_processor/db/table.h"

	namespace perfetto::trace_processor::macros_internal {

	// We define this class to allow the table macro below to compile without
	// needing templates; in reality none of the methods will be called because the
	// pointer to this class will always be null.
	class RootParentTable : public Table {
	public:
	struct Row {
	public:
	explicit Row(std::nullptr_t = nullptr) {}

	const char* type() const { return type_; }

	protected:
	const char* type_ = nullptr;
	};
	// This class only exists to allow typechecking to work correctly in Insert
	// below. If we had C++17 and if constexpr, we could statically verify that
	// this was never created but for now, we still need to define it to satisfy
	// the typechecker.
	struct IdAndRow {
	uint32_t id;
	};
	struct RowNumber {
	static uint32_t row_number() { PERFETTO_FATAL("Should not be called"); }
	};
	static IdAndRow Insert(const Row&) { PERFETTO_FATAL("Should not be called"); }

	private:
	explicit RootParentTable(std::nullptr_t);
	};

	// The parent class for all macro generated tables.
	// This class is used to extract common code from the macro tables to reduce
	// code size.
	class MacroTable : public Table {
	public:
	// We don't want a move or copy constructor because we store pointers to
	// fields of macro tables which will be invalidated if we move/copy them.
	MacroTable(const MacroTable&) = delete;
	MacroTable& operator=(const MacroTable&) = delete;

	MacroTable(MacroTable&&) = delete;
	MacroTable& operator=(MacroTable&&) noexcept = delete;

	protected:
	// Constructors for tables created by the regular constructor.
	PERFETTO_NO_INLINE explicit MacroTable(StringPool* pool,
	std::vector<ColumnLegacy> columns,
	const MacroTable* parent)
	: Table(pool, 0u, std::move(columns), EmptyOverlaysFromParent(parent)),
	allow_inserts_(true),
	parent_(parent) {}

	// Constructor for tables created by SelectAndExtendParent.
	MacroTable(StringPool* pool,
	std::vector<ColumnLegacy> columns,
	const MacroTable& parent,
	const RowMap& parent_overlay)
	: Table(pool,
	parent_overlay.size(),
	std::move(columns),
	SelectedOverlaysFromParent(parent, parent_overlay)),
	allow_inserts_(false),
	parent_(&parent) {}

	~MacroTable() override;

	PERFETTO_NO_INLINE void UpdateOverlaysAfterParentInsert() {
	CopyLastInsertFrom(parent_->overlays());
	}

	PERFETTO_NO_INLINE void UpdateSelfOverlayAfterInsert() {
	IncrementRowCountAndAddToLastOverlay();
	}

	PERFETTO_NO_INLINE static std::vector<ColumnLegacy>
	CopyColumnsFromParentOrAddRootColumns(MacroTable* self,
	const MacroTable* parent) {
	std::vector<ColumnLegacy> columns;
	if (parent) {
	for (const ColumnLegacy& col : parent->columns()) {
	columns.emplace_back(col, col.index_in_table(), col.overlay_index());
	}
	} else {
	columns.emplace_back(ColumnLegacy::IdColumn(0, 0));
	columns.emplace_back("type", &self->type_, ColumnLegacy::kNonNull, 1, 0);
	}
	return columns;
	}

	PERFETTO_NO_INLINE void OnConstructionCompletedRegularConstructor(
	std::initializer_list<RefPtr<column::DataLayer>> storage_layers,
	std::initializer_list<RefPtr<column::DataLayer>> null_layers) {
	std::vector<RefPtr<column::DataLayer>> overlay_layers(
	OverlayCount(parent_) + 1);
	for (uint32_t i = 0; i < overlay_layers.size() - 1; ++i) {
	PERFETTO_CHECK(overlays()[i].row_map().IsBitVector());
	overlay_layers[i].reset(new column::SelectorOverlay(
	overlays()[i].row_map().GetIfBitVector()));
	}
	Table::OnConstructionCompleted(storage_layers, null_layers,
	std::move(overlay_layers));
	}

	template <typename T>
	PERFETTO_NO_INLINE static void AddColumnToVector(
	std::vector<ColumnLegacy>& columns,
	const char* name,
	ColumnStorage<T>* storage,
	uint32_t flags,
	uint32_t column_index,
	uint32_t overlay_index) {
	columns.emplace_back(name, storage, flags, column_index, overlay_index);
	}

	static uint32_t OverlayCount(const MacroTable* parent) {
	return parent ? static_cast<uint32_t>(parent->overlays().size()) : 0;
	}

	// Stores whether inserts are allowed into this macro table; by default
	// inserts are allowed but they are disallowed when a parent table is extended
	// with \|ExtendParent\|; the rationale for this is that extensions usually
	// happen in dynamic tables and they should not be allowed to insert rows into
	// the real (static) tables.
	bool allow_inserts_ = true;

	// Stores the most specific "derived" type of this row in the table.
	//
	// For example, suppose a row is inserted into the gpu_slice table. This will
	// also cause a row to be inserted into the slice table. For users querying
	// the slice table, they will want to know the "real" type of this slice (i.e.
	// they will want to see that the type is gpu_slice). This sparse vector
	// stores precisely the real type.
	//
	// Only relevant for parentless tables. Will be empty and unreferenced by
	// tables with parents.
	ColumnStorage<StringPool::Id> type_;

	private:
	PERFETTO_NO_INLINE static std::vector<ColumnStorageOverlay>
	EmptyOverlaysFromParent(const MacroTable* parent) {
	std::vector<ColumnStorageOverlay> overlays(
	parent ? parent->overlays().size() : 0);
	for (auto& overlay : overlays) {
	overlay = ColumnStorageOverlay(BitVector());
	}
	overlays.emplace_back();
	return overlays;
	}
	PERFETTO_NO_INLINE static std::vector<ColumnStorageOverlay>
	SelectedOverlaysFromParent(const macros_internal::MacroTable& parent,
	const RowMap& rm) {
	std::vector<ColumnStorageOverlay> overlays;
	for (const auto& overlay : parent.overlays()) {
	overlays.emplace_back(overlay.SelectRows(rm));
	PERFETTO_DCHECK(overlays.back().size() == rm.size());
	}
	overlays.emplace_back(rm.size());
	return overlays;
	}

	const MacroTable* parent_ = nullptr;
	};

	// Abstract iterator class for macro tables.
	// Extracted to allow sharing with view code.
	template <typename Iterator,
	typename MacroTable,
	typename RowNumber,
	typename ConstRowReference>
	class AbstractConstIterator {
	public:
	explicit operator bool() const { return bool(iterator_); }

	Iterator& operator++() {
	++iterator_;
	return *this_it();
	}

	// Returns a RowNumber for the current row.
	RowNumber row_number() const {
	return RowNumber(this_it()->CurrentRowNumber());
	}

	// Returns a ConstRowReference to the current row.
	ConstRowReference row_reference() const {
	return ConstRowReference(table_, this_it()->CurrentRowNumber());
	}

	protected:
	explicit AbstractConstIterator(const MacroTable* table,
	Table::Iterator iterator)
	: iterator_(std::move(iterator)), table_(table) {
	static_assert(std::is_base_of<Table, MacroTable>::value,
	"Template param should be a subclass of Table.");
	}

	Table::Iterator iterator_;
	const MacroTable* table_;

	private:
	Iterator* this_it() { return static_cast<Iterator*>(this); }
	const Iterator* this_it() const { return static_cast<const Iterator*>(this); }
	};

	// Abstract RowNumber class for macro tables.
	// Extracted to allow sharing with view code.
	template <typename MacroTable,
	typename ConstRowReference,
	typename RowReference = void>
	class AbstractRowNumber {
	public:
	// Converts this RowNumber to a RowReference for the given \|table\|.
	template <
	typename RR = RowReference,
	typename = typename std::enable_if<!std::is_same<RR, void>::value>::type>
	RR ToRowReference(MacroTable* table) const {
	return RR(table, row_number_);
	}

	// Converts this RowNumber to a ConstRowReference for the given \|table\|.
	ConstRowReference ToRowReference(const MacroTable& table) const {
	return ConstRowReference(&table, row_number_);
	}

	// Converts this object to the underlying int value.
	uint32_t row_number() const { return row_number_; }

	// Allows sorting + storage in a map/set.
	bool operator<(const AbstractRowNumber& other) const {
	return row_number_ < other.row_number_;
	}

	protected:
	explicit AbstractRowNumber(uint32_t row_number) : row_number_(row_number) {}

	private:
	uint32_t row_number_ = 0;
	};

	// Abstract ConstRowReference class for macro tables.
	// Extracted to allow sharing with view code.
	template <typename MacroTable, typename RowNumber>
	class AbstractConstRowReference {
	public:
	// Converts this RowReference to a RowNumber object which is more memory
	// efficient to store.
	RowNumber ToRowNumber() { return RowNumber(row_number_); }

	protected:
	AbstractConstRowReference(const MacroTable* table, uint32_t row_number)
	: table_(table), row_number_(row_number) {}

	const MacroTable* table_ = nullptr;
	uint32_t row_number_ = 0;
	};

	} // namespace perfetto::trace_processor::macros_internal

	#endif // SRC_TRACE_PROCESSOR_TABLES_MACROS_INTERNAL_H_