1 /* 2 * Copyright (C) 2020 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 17 #ifndef SRC_TRACE_PROCESSOR_DYNAMIC_THREAD_STATE_GENERATOR_H_ 18 #define SRC_TRACE_PROCESSOR_DYNAMIC_THREAD_STATE_GENERATOR_H_ 19 20 #include "src/trace_processor/sqlite/db_sqlite_table.h" 21 22 #include "src/trace_processor/storage/trace_storage.h" 23 24 namespace perfetto { 25 namespace trace_processor { 26 27 class TraceProcessorContext; 28 29 // Dynamic table implementing the thread state table. 30 // This table is a basically the same as sched with extra information added 31 // about wakeups (obtained from sched_waking/sched_wakeup). 32 class ThreadStateGenerator : public DbSqliteTable::DynamicTableGenerator { 33 public: 34 explicit ThreadStateGenerator(TraceProcessorContext* context); 35 ~ThreadStateGenerator() override; 36 37 Table::Schema CreateSchema() override; 38 std::string TableName() override; 39 uint32_t EstimateRowCount() override; 40 util::Status ValidateConstraints(const QueryConstraints&) override; 41 std::unique_ptr<Table> ComputeTable(const std::vector<Constraint>& cs, 42 const std::vector<Order>& ob) override; 43 44 // Visible for testing. 45 std::unique_ptr<tables::ThreadStateTable> ComputeThreadStateTable( 46 int64_t trace_end_ts); 47 48 private: 49 struct ThreadSchedInfo { 50 base::Optional<int64_t> desched_ts; 51 base::Optional<StringId> desched_end_state; 52 base::Optional<uint32_t> scheduled_row; 53 base::Optional<bool> io_wait; 54 base::Optional<int64_t> runnable_ts; 55 base::Optional<StringId> blocked_function; 56 }; 57 58 void AddSchedEvent(const Table& sched, 59 uint32_t sched_idx, 60 std::unordered_map<UniqueTid, ThreadSchedInfo>& state_map, 61 int64_t trace_end_ts, 62 tables::ThreadStateTable* table); 63 64 void AddWakingEvent( 65 const Table& wakeup, 66 uint32_t wakeup_idx, 67 std::unordered_map<UniqueTid, ThreadSchedInfo>& state_map); 68 69 void AddBlockedReasonEvent( 70 const Table& blocked_reason, 71 uint32_t blocked_idx, 72 std::unordered_map<UniqueTid, ThreadSchedInfo>& state_map); 73 74 void FlushPendingEventsForThread(UniqueTid utid, 75 const ThreadSchedInfo&, 76 tables::ThreadStateTable* table, 77 base::Optional<int64_t> end_ts); 78 79 std::unique_ptr<tables::ThreadStateTable> unsorted_thread_state_table_; 80 base::Optional<Table> sorted_thread_state_table_; 81 82 const StringId running_string_id_; 83 const StringId runnable_string_id_; 84 85 TraceProcessorContext* context_ = nullptr; 86 }; 87 88 } // namespace trace_processor 89 } // namespace perfetto 90 91 #endif // SRC_TRACE_PROCESSOR_DYNAMIC_THREAD_STATE_GENERATOR_H_ 92