| /* |
| * 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. |
| */ |
| |
| #include "src/trace_processor/stack_profile_tracker.h" |
| |
| #include "src/trace_processor/trace_processor_context.h" |
| |
| #include "perfetto/base/logging.h" |
| #include "perfetto/ext/base/string_utils.h" |
| |
| namespace perfetto { |
| namespace trace_processor { |
| |
| StackProfileTracker::InternLookup::~InternLookup() = default; |
| |
| StackProfileTracker::StackProfileTracker(TraceProcessorContext* context) |
| : context_(context), empty_(kNullStringId) {} |
| |
| StackProfileTracker::~StackProfileTracker() = default; |
| |
| StringId StackProfileTracker::GetEmptyStringId() { |
| if (empty_ == kNullStringId) { |
| empty_ = context_->storage->InternString({"", 0}); |
| } |
| |
| return empty_; |
| } |
| |
| void StackProfileTracker::AddString(SourceStringId id, base::StringView str) { |
| string_map_.emplace(id, str.ToStdString()); |
| } |
| |
| base::Optional<int64_t> StackProfileTracker::AddMapping( |
| SourceMappingId id, |
| const SourceMapping& mapping, |
| const InternLookup* intern_lookup) { |
| std::string path; |
| for (SourceStringId str_id : mapping.name_ids) { |
| auto opt_str = |
| FindString(str_id, intern_lookup, InternedStringType::kMappingPath); |
| if (!opt_str) |
| break; |
| path += "/" + *opt_str; |
| } |
| |
| auto opt_build_id = FindAndInternString(mapping.build_id, intern_lookup, |
| InternedStringType::kBuildId); |
| if (!opt_build_id) { |
| context_->storage->IncrementStats(stats::stackprofile_invalid_string_id); |
| PERFETTO_DFATAL("Invalid string."); |
| return base::nullopt; |
| } |
| const StringId raw_build_id = opt_build_id.value(); |
| NullTermStringView raw_build_id_str = |
| context_->storage->GetString(raw_build_id); |
| StringId build_id = GetEmptyStringId(); |
| if (raw_build_id_str.size() > 0) { |
| std::string hex_build_id = |
| base::ToHex(raw_build_id_str.c_str(), raw_build_id_str.size()); |
| build_id = context_->storage->InternString(base::StringView(hex_build_id)); |
| } |
| |
| tables::StackProfileMappingTable::Row row{ |
| build_id, |
| static_cast<int64_t>(mapping.exact_offset), |
| static_cast<int64_t>(mapping.start_offset), |
| static_cast<int64_t>(mapping.start), |
| static_cast<int64_t>(mapping.end), |
| static_cast<int64_t>(mapping.load_bias), |
| context_->storage->InternString(base::StringView(path))}; |
| |
| tables::StackProfileMappingTable* mappings = |
| context_->storage->mutable_stack_profile_mapping_table(); |
| int64_t cur_row = -1; |
| auto it = mapping_idx_.find(row); |
| if (it != mapping_idx_.end()) { |
| cur_row = it->second; |
| } else { |
| std::vector<int64_t> db_mappings = |
| context_->storage->FindMappingRow(row.name, row.build_id); |
| for (const int64_t preexisting_mapping : db_mappings) { |
| PERFETTO_DCHECK(preexisting_mapping >= 0); |
| uint32_t preexisting_row_id = static_cast<uint32_t>(preexisting_mapping); |
| tables::StackProfileMappingTable::Row preexisting_row{ |
| mappings->build_id()[preexisting_row_id], |
| mappings->exact_offset()[preexisting_row_id], |
| mappings->start_offset()[preexisting_row_id], |
| mappings->start()[preexisting_row_id], |
| mappings->end()[preexisting_row_id], |
| mappings->load_bias()[preexisting_row_id], |
| mappings->name()[preexisting_row_id]}; |
| |
| if (row == preexisting_row) { |
| cur_row = preexisting_mapping; |
| } |
| } |
| if (cur_row == -1) { |
| MappingId mapping_id = mappings->Insert(row); |
| uint32_t mapping_row = *mappings->id().IndexOf(mapping_id); |
| context_->storage->InsertMappingRow(row.name, row.build_id, mapping_row); |
| cur_row = mapping_row; |
| } |
| mapping_idx_.emplace(row, cur_row); |
| } |
| mappings_.emplace(id, cur_row); |
| return cur_row; |
| } |
| |
| base::Optional<int64_t> StackProfileTracker::AddFrame( |
| SourceFrameId id, |
| const SourceFrame& frame, |
| const InternLookup* intern_lookup) { |
| auto opt_str_id = FindAndInternString(frame.name_id, intern_lookup, |
| InternedStringType::kFunctionName); |
| if (!opt_str_id) { |
| context_->storage->IncrementStats(stats::stackprofile_invalid_string_id); |
| PERFETTO_DFATAL("Invalid string."); |
| return base::nullopt; |
| } |
| const StringId& str_id = opt_str_id.value(); |
| |
| auto maybe_mapping = FindMapping(frame.mapping_id, intern_lookup); |
| if (!maybe_mapping) { |
| context_->storage->IncrementStats(stats::stackprofile_invalid_mapping_id); |
| PERFETTO_ELOG("Invalid mapping for frame %" PRIu64, id); |
| return base::nullopt; |
| } |
| int64_t mapping_row = *maybe_mapping; |
| |
| tables::StackProfileFrameTable::Row row{str_id, mapping_row, |
| static_cast<int64_t>(frame.rel_pc)}; |
| |
| auto* frames = context_->storage->mutable_stack_profile_frame_table(); |
| |
| int64_t cur_row = -1; |
| auto it = frame_idx_.find(row); |
| if (it != frame_idx_.end()) { |
| cur_row = it->second; |
| } else { |
| std::vector<int64_t> db_frames = context_->storage->FindFrameRow( |
| static_cast<size_t>(mapping_row), frame.rel_pc); |
| for (const int64_t preexisting_frame : db_frames) { |
| PERFETTO_DCHECK(preexisting_frame >= 0); |
| uint32_t preexisting_row_id = static_cast<uint32_t>(preexisting_frame); |
| tables::StackProfileFrameTable::Row preexisting_row{ |
| frames->name()[preexisting_row_id], |
| frames->mapping()[preexisting_row_id], |
| frames->rel_pc()[preexisting_row_id]}; |
| |
| if (row == preexisting_row) { |
| cur_row = preexisting_frame; |
| } |
| } |
| if (cur_row == -1) { |
| auto new_id = frames->Insert(row); |
| cur_row = *frames->id().IndexOf(new_id); |
| context_->storage->InsertFrameRow(static_cast<size_t>(row.mapping), |
| static_cast<uint64_t>(row.rel_pc), |
| static_cast<uint32_t>(cur_row)); |
| } |
| frame_idx_.emplace(row, cur_row); |
| } |
| frames_.emplace(id, cur_row); |
| return cur_row; |
| } |
| |
| base::Optional<int64_t> StackProfileTracker::AddCallstack( |
| SourceCallstackId id, |
| const SourceCallstack& frame_ids, |
| const InternLookup* intern_lookup) { |
| // TODO(fmayer): This should be NULL. |
| int64_t parent_id = -1; |
| for (size_t depth = 0; depth < frame_ids.size(); ++depth) { |
| std::vector<SourceFrameId> frame_subset = frame_ids; |
| frame_subset.resize(depth + 1); |
| auto self_it = callstacks_from_frames_.find(frame_subset); |
| if (self_it != callstacks_from_frames_.end()) { |
| parent_id = self_it->second; |
| continue; |
| } |
| |
| SourceFrameId frame_id = frame_ids[depth]; |
| auto maybe_frame_row = FindFrame(frame_id, intern_lookup); |
| if (!maybe_frame_row) { |
| context_->storage->IncrementStats(stats::stackprofile_invalid_frame_id); |
| PERFETTO_ELOG("Unknown frame in callstack; ignoring."); |
| return base::nullopt; |
| } |
| int64_t frame_row = *maybe_frame_row; |
| |
| tables::StackProfileCallsiteTable::Row row{static_cast<int64_t>(depth), |
| parent_id, frame_row}; |
| |
| int64_t self_id; |
| auto callsite_it = callsite_idx_.find(row); |
| if (callsite_it != callsite_idx_.end()) { |
| self_id = callsite_it->second; |
| } else { |
| auto* callsite = |
| context_->storage->mutable_stack_profile_callsite_table(); |
| auto callsite_id = callsite->Insert(row); |
| self_id = callsite_id.value; |
| callsite_idx_.emplace(row, self_id); |
| } |
| parent_id = self_id; |
| } |
| callstacks_.emplace(id, parent_id); |
| return parent_id; |
| } |
| |
| int64_t StackProfileTracker::GetDatabaseFrameIdForTesting( |
| SourceFrameId frame_id) { |
| auto it = frames_.find(frame_id); |
| if (it == frames_.end()) { |
| PERFETTO_DFATAL("Invalid frame."); |
| return -1; |
| } |
| return it->second; |
| } |
| |
| base::Optional<StringId> StackProfileTracker::FindAndInternString( |
| SourceStringId id, |
| const InternLookup* intern_lookup, |
| StackProfileTracker::InternedStringType type) { |
| if (id == 0) |
| return GetEmptyStringId(); |
| |
| auto opt_str = FindString(id, intern_lookup, type); |
| if (!opt_str) |
| return GetEmptyStringId(); |
| |
| return context_->storage->InternString(base::StringView(*opt_str)); |
| } |
| |
| base::Optional<std::string> StackProfileTracker::FindString( |
| SourceStringId id, |
| const InternLookup* intern_lookup, |
| StackProfileTracker::InternedStringType type) { |
| if (id == 0) |
| return ""; |
| |
| auto it = string_map_.find(id); |
| if (it == string_map_.end()) { |
| if (intern_lookup) { |
| auto str = intern_lookup->GetString(id, type); |
| if (!str) { |
| context_->storage->IncrementStats( |
| stats::stackprofile_invalid_string_id); |
| PERFETTO_DFATAL("Invalid string."); |
| return base::nullopt; |
| } |
| return str->ToStdString(); |
| } |
| return base::nullopt; |
| } |
| |
| return it->second; |
| } |
| |
| base::Optional<int64_t> StackProfileTracker::FindMapping( |
| SourceMappingId mapping_id, |
| const InternLookup* intern_lookup) { |
| base::Optional<int64_t> res; |
| auto it = mappings_.find(mapping_id); |
| if (it == mappings_.end()) { |
| if (intern_lookup) { |
| auto interned_mapping = intern_lookup->GetMapping(mapping_id); |
| if (interned_mapping) { |
| res = AddMapping(mapping_id, *interned_mapping, intern_lookup); |
| return res; |
| } |
| } |
| context_->storage->IncrementStats(stats::stackprofile_invalid_mapping_id); |
| PERFETTO_ELOG("Unknown mapping %" PRIu64 " : %zu", mapping_id, |
| mappings_.size()); |
| return res; |
| } |
| res = it->second; |
| return res; |
| } |
| |
| base::Optional<int64_t> StackProfileTracker::FindFrame( |
| SourceFrameId frame_id, |
| const InternLookup* intern_lookup) { |
| base::Optional<int64_t> res; |
| auto it = frames_.find(frame_id); |
| if (it == frames_.end()) { |
| if (intern_lookup) { |
| auto interned_frame = intern_lookup->GetFrame(frame_id); |
| if (interned_frame) { |
| res = AddFrame(frame_id, *interned_frame, intern_lookup); |
| return res; |
| } |
| } |
| context_->storage->IncrementStats(stats::stackprofile_invalid_frame_id); |
| PERFETTO_DFATAL("Unknown frame %" PRIu64 " : %zu", frame_id, |
| frames_.size()); |
| return res; |
| } |
| res = it->second; |
| return res; |
| } |
| |
| base::Optional<int64_t> StackProfileTracker::FindCallstack( |
| SourceCallstackId callstack_id, |
| const InternLookup* intern_lookup) { |
| base::Optional<int64_t> res; |
| auto it = callstacks_.find(callstack_id); |
| if (it == callstacks_.end()) { |
| auto interned_callstack = intern_lookup->GetCallstack(callstack_id); |
| if (interned_callstack) { |
| res = AddCallstack(callstack_id, *interned_callstack, intern_lookup); |
| return res; |
| } |
| context_->storage->IncrementStats(stats::stackprofile_invalid_callstack_id); |
| PERFETTO_DFATAL("Unknown callstack %" PRIu64 " : %zu", callstack_id, |
| callstacks_.size()); |
| return res; |
| } |
| res = it->second; |
| return res; |
| } |
| |
| void StackProfileTracker::ClearIndices() { |
| string_map_.clear(); |
| mappings_.clear(); |
| callstacks_from_frames_.clear(); |
| callstacks_.clear(); |
| frames_.clear(); |
| } |
| |
| } // namespace trace_processor |
| } // namespace perfetto |