Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2019 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Lalit Maganti | 617deae | 2020-04-14 21:00:49 +0100 | [diff] [blame] | 17 | #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_ARGS_TRACKER_H_ |
| 18 | #define SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_ARGS_TRACKER_H_ |
Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 19 | |
Lalit Maganti | 617deae | 2020-04-14 21:00:49 +0100 | [diff] [blame] | 20 | #include "src/trace_processor/importers/common/global_args_tracker.h" |
Lalit Maganti | 7010b33 | 2020-02-07 10:51:15 +0000 | [diff] [blame] | 21 | #include "src/trace_processor/storage/trace_storage.h" |
Lalit Maganti | 0faddc4 | 2020-04-10 17:58:24 +0100 | [diff] [blame] | 22 | #include "src/trace_processor/types/trace_processor_context.h" |
Lalit Maganti | 83b53fa | 2020-01-13 12:55:36 +0000 | [diff] [blame] | 23 | #include "src/trace_processor/types/variadic.h" |
Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 24 | |
| 25 | namespace perfetto { |
| 26 | namespace trace_processor { |
| 27 | |
| 28 | // Tracks and stores args for rows until the end of the packet. This allows |
| 29 | // allows args to pushed as a group into storage. |
| 30 | class ArgsTracker { |
| 31 | public: |
Eric Seckler | c7b0c61 | 2020-02-12 18:30:35 +0000 | [diff] [blame] | 32 | using UpdatePolicy = GlobalArgsTracker::UpdatePolicy; |
| 33 | |
Lalit Maganti | 7449dc8 | 2019-12-30 15:52:35 +0000 | [diff] [blame] | 34 | // Stores the table and row at creation time which args are associated with. |
| 35 | // This allows callers to directly add args without repeating the row the |
| 36 | // args should be associated with. |
| 37 | class BoundInserter { |
| 38 | public: |
Lalit Maganti | 7449dc8 | 2019-12-30 15:52:35 +0000 | [diff] [blame] | 39 | virtual ~BoundInserter(); |
| 40 | |
Lalit Maganti | ccdcbae | 2020-04-15 14:31:40 +0100 | [diff] [blame] | 41 | BoundInserter(BoundInserter&&); |
| 42 | BoundInserter& operator=(BoundInserter&&); |
| 43 | |
| 44 | BoundInserter(const BoundInserter&) = delete; |
| 45 | BoundInserter& operator=(const BoundInserter&) = delete; |
| 46 | |
Lalit Maganti | 7449dc8 | 2019-12-30 15:52:35 +0000 | [diff] [blame] | 47 | // Adds an arg with the same key and flat_key. |
Eric Seckler | c7b0c61 | 2020-02-12 18:30:35 +0000 | [diff] [blame] | 48 | BoundInserter& AddArg( |
| 49 | StringId key, |
| 50 | Variadic v, |
| 51 | UpdatePolicy update_policy = UpdatePolicy::kAddOrUpdate) { |
| 52 | return AddArg(key, key, v, update_policy); |
Lalit Maganti | 7449dc8 | 2019-12-30 15:52:35 +0000 | [diff] [blame] | 53 | } |
| 54 | |
Eric Seckler | c7b0c61 | 2020-02-12 18:30:35 +0000 | [diff] [blame] | 55 | virtual BoundInserter& AddArg( |
| 56 | StringId flat_key, |
| 57 | StringId key, |
| 58 | Variadic v, |
| 59 | UpdatePolicy update_policy = UpdatePolicy::kAddOrUpdate) { |
| 60 | args_tracker_->AddArg(arg_set_id_column_, row_, flat_key, key, v, |
| 61 | update_policy); |
Lalit Maganti | 5228f36 | 2020-01-15 13:45:56 +0000 | [diff] [blame] | 62 | return *this; |
| 63 | } |
| 64 | |
Eric Seckler | c7b0c61 | 2020-02-12 18:30:35 +0000 | [diff] [blame] | 65 | // IncrementArrayEntryIndex() and GetNextArrayEntryIndex() provide a way to |
| 66 | // track the next array index for an array under a specific key. |
Eric Seckler | c7b0c61 | 2020-02-12 18:30:35 +0000 | [diff] [blame] | 67 | size_t GetNextArrayEntryIndex(StringId key) { |
| 68 | // Zero-initializes |key| in the map if it doesn't exist yet. |
| 69 | return args_tracker_ |
| 70 | ->array_indexes_[std::make_tuple(arg_set_id_column_, row_, key)]; |
| 71 | } |
| 72 | |
Alexander Timin | 97d8785 | 2021-05-17 18:01:33 +0000 | [diff] [blame^] | 73 | // Returns the next available array index after increment. |
| 74 | size_t IncrementArrayEntryIndex(StringId key) { |
| 75 | // Zero-initializes |key| in the map if it doesn't exist yet. |
| 76 | return ++args_tracker_->array_indexes_[std::make_tuple(arg_set_id_column_, |
| 77 | row_, key)]; |
| 78 | } |
| 79 | |
Lalit Maganti | 5228f36 | 2020-01-15 13:45:56 +0000 | [diff] [blame] | 80 | protected: |
| 81 | BoundInserter(ArgsTracker* args_tracker, |
| 82 | Column* arg_set_id_column, |
| 83 | uint32_t row); |
| 84 | |
Lalit Maganti | 7449dc8 | 2019-12-30 15:52:35 +0000 | [diff] [blame] | 85 | private: |
Lalit Maganti | 5228f36 | 2020-01-15 13:45:56 +0000 | [diff] [blame] | 86 | friend class ArgsTracker; |
| 87 | |
Lalit Maganti | 7449dc8 | 2019-12-30 15:52:35 +0000 | [diff] [blame] | 88 | ArgsTracker* args_tracker_ = nullptr; |
Lalit Maganti | 5228f36 | 2020-01-15 13:45:56 +0000 | [diff] [blame] | 89 | Column* arg_set_id_column_ = nullptr; |
Lalit Maganti | 7449dc8 | 2019-12-30 15:52:35 +0000 | [diff] [blame] | 90 | uint32_t row_ = 0; |
| 91 | }; |
| 92 | |
Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 93 | explicit ArgsTracker(TraceProcessorContext*); |
Primiano Tucci | 7e9865c | 2021-01-10 23:55:15 +0100 | [diff] [blame] | 94 | ArgsTracker(const ArgsTracker&) = default; |
Eric Seckler | 70cc442 | 2019-05-28 16:00:23 +0100 | [diff] [blame] | 95 | virtual ~ArgsTracker(); |
Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 96 | |
Lalit Maganti | 5228f36 | 2020-01-15 13:45:56 +0000 | [diff] [blame] | 97 | BoundInserter AddArgsTo(RawId id) { |
| 98 | return AddArgsTo(context_->storage->mutable_raw_table(), id); |
| 99 | } |
| 100 | |
| 101 | BoundInserter AddArgsTo(CounterId id) { |
| 102 | return AddArgsTo(context_->storage->mutable_counter_table(), id); |
| 103 | } |
| 104 | |
| 105 | BoundInserter AddArgsTo(InstantId id) { |
| 106 | return AddArgsTo(context_->storage->mutable_instant_table(), id); |
| 107 | } |
| 108 | |
| 109 | BoundInserter AddArgsTo(SliceId id) { |
| 110 | return AddArgsTo(context_->storage->mutable_slice_table(), id); |
| 111 | } |
| 112 | |
Andrii | dd07cb1 | 2020-09-10 16:09:01 +0300 | [diff] [blame] | 113 | BoundInserter AddArgsTo(tables::FlowTable::Id id) { |
| 114 | return AddArgsTo(context_->storage->mutable_flow_table(), id); |
| 115 | } |
| 116 | |
Sylwester Blaszczyk | 76aa700 | 2020-11-27 15:48:21 +0100 | [diff] [blame] | 117 | BoundInserter AddArgsTo(tables::MemorySnapshotNodeTable::Id id) { |
Tomasz Konieczny | 6e2d3dd | 2020-11-04 15:54:04 +0100 | [diff] [blame] | 118 | return AddArgsTo(context_->storage->mutable_memory_snapshot_node_table(), |
| 119 | id); |
| 120 | } |
| 121 | |
Lalit Maganti | 5228f36 | 2020-01-15 13:45:56 +0000 | [diff] [blame] | 122 | BoundInserter AddArgsTo(MetadataId id) { |
| 123 | auto* table = context_->storage->mutable_metadata_table(); |
| 124 | uint32_t row = *table->id().IndexOf(id); |
| 125 | return BoundInserter(this, table->mutable_int_value(), row); |
| 126 | } |
| 127 | |
| 128 | BoundInserter AddArgsTo(TrackId id) { |
| 129 | auto* table = context_->storage->mutable_track_table(); |
| 130 | uint32_t row = *table->id().IndexOf(id); |
| 131 | return BoundInserter(this, table->mutable_source_arg_set_id(), row); |
| 132 | } |
| 133 | |
| 134 | BoundInserter AddArgsTo(VulkanAllocId id) { |
| 135 | return AddArgsTo( |
| 136 | context_->storage->mutable_vulkan_memory_allocations_table(), id); |
| 137 | } |
Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 138 | |
Eric Seckler | fbbf022 | 2020-07-23 17:26:29 +0100 | [diff] [blame] | 139 | BoundInserter AddArgsTo(UniquePid id) { |
| 140 | return BoundInserter( |
| 141 | this, context_->storage->mutable_process_table()->mutable_arg_set_id(), |
| 142 | id); |
| 143 | } |
| 144 | |
Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 145 | // Commits the added args to storage. |
Eric Seckler | c93823e | 2019-06-03 16:49:19 +0100 | [diff] [blame] | 146 | // Virtual for testing. |
| 147 | virtual void Flush(); |
Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 148 | |
| 149 | private: |
Lalit Maganti | 5228f36 | 2020-01-15 13:45:56 +0000 | [diff] [blame] | 150 | template <typename Table> |
| 151 | BoundInserter AddArgsTo(Table* table, typename Table::Id id) { |
| 152 | uint32_t row = *table->id().IndexOf(id); |
| 153 | return BoundInserter(this, table->mutable_arg_set_id(), row); |
| 154 | } |
| 155 | |
| 156 | void AddArg(Column* arg_set_id, |
| 157 | uint32_t row, |
| 158 | StringId flat_key, |
| 159 | StringId key, |
Eric Seckler | c7b0c61 | 2020-02-12 18:30:35 +0000 | [diff] [blame] | 160 | Variadic, |
| 161 | UpdatePolicy); |
Lalit Maganti | 5228f36 | 2020-01-15 13:45:56 +0000 | [diff] [blame] | 162 | |
Lalit Maganti | 1908e26 | 2020-01-09 14:33:19 +0000 | [diff] [blame] | 163 | std::vector<GlobalArgsTracker::Arg> args_; |
Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 164 | TraceProcessorContext* const context_; |
Eric Seckler | c7b0c61 | 2020-02-12 18:30:35 +0000 | [diff] [blame] | 165 | |
| 166 | using ArrayKeyTuple = |
| 167 | std::tuple<Column* /*arg_set_id*/, uint32_t /*row*/, StringId /*key*/>; |
| 168 | std::map<ArrayKeyTuple, size_t /*next_index*/> array_indexes_; |
Lalit Maganti | 4fa7c6c | 2019-02-06 15:06:36 +0000 | [diff] [blame] | 169 | }; |
| 170 | |
| 171 | } // namespace trace_processor |
| 172 | } // namespace perfetto |
| 173 | |
Lalit Maganti | 617deae | 2020-04-14 21:00:49 +0100 | [diff] [blame] | 174 | #endif // SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_ARGS_TRACKER_H_ |