| /* |
| * Copyright (C) 2017 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. |
| */ |
| |
| /******************************************************************************* |
| * AUTOGENERATED - DO NOT EDIT |
| ******************************************************************************* |
| * This file has been generated from the protobuf message |
| * perfetto/common/trace_stats.proto |
| * by |
| * ../../tools/proto_to_cpp/proto_to_cpp.cc. |
| * If you need to make changes here, change the .proto file and then run |
| * ./tools/gen_tracing_cpp_headers_from_protos |
| */ |
| |
| #include "perfetto/tracing/core/trace_stats.h" |
| |
| #include "perfetto/common/trace_stats.pb.h" |
| |
| namespace perfetto { |
| |
| TraceStats::TraceStats() = default; |
| TraceStats::~TraceStats() = default; |
| TraceStats::TraceStats(const TraceStats&) = default; |
| TraceStats& TraceStats::operator=(const TraceStats&) = default; |
| TraceStats::TraceStats(TraceStats&&) noexcept = default; |
| TraceStats& TraceStats::operator=(TraceStats&&) = default; |
| |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wfloat-equal" |
| bool TraceStats::operator==(const TraceStats& other) const { |
| return (buffer_stats_ == other.buffer_stats_) && |
| (producers_connected_ == other.producers_connected_) && |
| (producers_seen_ == other.producers_seen_) && |
| (data_sources_registered_ == other.data_sources_registered_) && |
| (data_sources_seen_ == other.data_sources_seen_) && |
| (tracing_sessions_ == other.tracing_sessions_) && |
| (total_buffers_ == other.total_buffers_) && |
| (chunks_discarded_ == other.chunks_discarded_) && |
| (patches_discarded_ == other.patches_discarded_); |
| } |
| #pragma GCC diagnostic pop |
| |
| void TraceStats::FromProto(const perfetto::protos::TraceStats& proto) { |
| buffer_stats_.clear(); |
| for (const auto& field : proto.buffer_stats()) { |
| buffer_stats_.emplace_back(); |
| buffer_stats_.back().FromProto(field); |
| } |
| |
| static_assert( |
| sizeof(producers_connected_) == sizeof(proto.producers_connected()), |
| "size mismatch"); |
| producers_connected_ = |
| static_cast<decltype(producers_connected_)>(proto.producers_connected()); |
| |
| static_assert(sizeof(producers_seen_) == sizeof(proto.producers_seen()), |
| "size mismatch"); |
| producers_seen_ = |
| static_cast<decltype(producers_seen_)>(proto.producers_seen()); |
| |
| static_assert(sizeof(data_sources_registered_) == |
| sizeof(proto.data_sources_registered()), |
| "size mismatch"); |
| data_sources_registered_ = static_cast<decltype(data_sources_registered_)>( |
| proto.data_sources_registered()); |
| |
| static_assert(sizeof(data_sources_seen_) == sizeof(proto.data_sources_seen()), |
| "size mismatch"); |
| data_sources_seen_ = |
| static_cast<decltype(data_sources_seen_)>(proto.data_sources_seen()); |
| |
| static_assert(sizeof(tracing_sessions_) == sizeof(proto.tracing_sessions()), |
| "size mismatch"); |
| tracing_sessions_ = |
| static_cast<decltype(tracing_sessions_)>(proto.tracing_sessions()); |
| |
| static_assert(sizeof(total_buffers_) == sizeof(proto.total_buffers()), |
| "size mismatch"); |
| total_buffers_ = static_cast<decltype(total_buffers_)>(proto.total_buffers()); |
| |
| static_assert(sizeof(chunks_discarded_) == sizeof(proto.chunks_discarded()), |
| "size mismatch"); |
| chunks_discarded_ = |
| static_cast<decltype(chunks_discarded_)>(proto.chunks_discarded()); |
| |
| static_assert(sizeof(patches_discarded_) == sizeof(proto.patches_discarded()), |
| "size mismatch"); |
| patches_discarded_ = |
| static_cast<decltype(patches_discarded_)>(proto.patches_discarded()); |
| unknown_fields_ = proto.unknown_fields(); |
| } |
| |
| void TraceStats::ToProto(perfetto::protos::TraceStats* proto) const { |
| proto->Clear(); |
| |
| for (const auto& it : buffer_stats_) { |
| auto* entry = proto->add_buffer_stats(); |
| it.ToProto(entry); |
| } |
| |
| static_assert( |
| sizeof(producers_connected_) == sizeof(proto->producers_connected()), |
| "size mismatch"); |
| proto->set_producers_connected( |
| static_cast<decltype(proto->producers_connected())>( |
| producers_connected_)); |
| |
| static_assert(sizeof(producers_seen_) == sizeof(proto->producers_seen()), |
| "size mismatch"); |
| proto->set_producers_seen( |
| static_cast<decltype(proto->producers_seen())>(producers_seen_)); |
| |
| static_assert(sizeof(data_sources_registered_) == |
| sizeof(proto->data_sources_registered()), |
| "size mismatch"); |
| proto->set_data_sources_registered( |
| static_cast<decltype(proto->data_sources_registered())>( |
| data_sources_registered_)); |
| |
| static_assert( |
| sizeof(data_sources_seen_) == sizeof(proto->data_sources_seen()), |
| "size mismatch"); |
| proto->set_data_sources_seen( |
| static_cast<decltype(proto->data_sources_seen())>(data_sources_seen_)); |
| |
| static_assert(sizeof(tracing_sessions_) == sizeof(proto->tracing_sessions()), |
| "size mismatch"); |
| proto->set_tracing_sessions( |
| static_cast<decltype(proto->tracing_sessions())>(tracing_sessions_)); |
| |
| static_assert(sizeof(total_buffers_) == sizeof(proto->total_buffers()), |
| "size mismatch"); |
| proto->set_total_buffers( |
| static_cast<decltype(proto->total_buffers())>(total_buffers_)); |
| |
| static_assert(sizeof(chunks_discarded_) == sizeof(proto->chunks_discarded()), |
| "size mismatch"); |
| proto->set_chunks_discarded( |
| static_cast<decltype(proto->chunks_discarded())>(chunks_discarded_)); |
| |
| static_assert( |
| sizeof(patches_discarded_) == sizeof(proto->patches_discarded()), |
| "size mismatch"); |
| proto->set_patches_discarded( |
| static_cast<decltype(proto->patches_discarded())>(patches_discarded_)); |
| *(proto->mutable_unknown_fields()) = unknown_fields_; |
| } |
| |
| TraceStats::BufferStats::BufferStats() = default; |
| TraceStats::BufferStats::~BufferStats() = default; |
| TraceStats::BufferStats::BufferStats(const TraceStats::BufferStats&) = default; |
| TraceStats::BufferStats& TraceStats::BufferStats::operator=( |
| const TraceStats::BufferStats&) = default; |
| TraceStats::BufferStats::BufferStats(TraceStats::BufferStats&&) noexcept = |
| default; |
| TraceStats::BufferStats& TraceStats::BufferStats::operator=( |
| TraceStats::BufferStats&&) = default; |
| |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wfloat-equal" |
| bool TraceStats::BufferStats::operator==( |
| const TraceStats::BufferStats& other) const { |
| return (buffer_size_ == other.buffer_size_) && |
| (bytes_written_ == other.bytes_written_) && |
| (bytes_overwritten_ == other.bytes_overwritten_) && |
| (bytes_read_ == other.bytes_read_) && |
| (padding_bytes_written_ == other.padding_bytes_written_) && |
| (padding_bytes_cleared_ == other.padding_bytes_cleared_) && |
| (chunks_written_ == other.chunks_written_) && |
| (chunks_rewritten_ == other.chunks_rewritten_) && |
| (chunks_overwritten_ == other.chunks_overwritten_) && |
| (chunks_discarded_ == other.chunks_discarded_) && |
| (chunks_read_ == other.chunks_read_) && |
| (chunks_committed_out_of_order_ == |
| other.chunks_committed_out_of_order_) && |
| (write_wrap_count_ == other.write_wrap_count_) && |
| (patches_succeeded_ == other.patches_succeeded_) && |
| (patches_failed_ == other.patches_failed_) && |
| (readaheads_succeeded_ == other.readaheads_succeeded_) && |
| (readaheads_failed_ == other.readaheads_failed_) && |
| (abi_violations_ == other.abi_violations_); |
| } |
| #pragma GCC diagnostic pop |
| |
| void TraceStats::BufferStats::FromProto( |
| const perfetto::protos::TraceStats_BufferStats& proto) { |
| static_assert(sizeof(buffer_size_) == sizeof(proto.buffer_size()), |
| "size mismatch"); |
| buffer_size_ = static_cast<decltype(buffer_size_)>(proto.buffer_size()); |
| |
| static_assert(sizeof(bytes_written_) == sizeof(proto.bytes_written()), |
| "size mismatch"); |
| bytes_written_ = static_cast<decltype(bytes_written_)>(proto.bytes_written()); |
| |
| static_assert(sizeof(bytes_overwritten_) == sizeof(proto.bytes_overwritten()), |
| "size mismatch"); |
| bytes_overwritten_ = |
| static_cast<decltype(bytes_overwritten_)>(proto.bytes_overwritten()); |
| |
| static_assert(sizeof(bytes_read_) == sizeof(proto.bytes_read()), |
| "size mismatch"); |
| bytes_read_ = static_cast<decltype(bytes_read_)>(proto.bytes_read()); |
| |
| static_assert( |
| sizeof(padding_bytes_written_) == sizeof(proto.padding_bytes_written()), |
| "size mismatch"); |
| padding_bytes_written_ = static_cast<decltype(padding_bytes_written_)>( |
| proto.padding_bytes_written()); |
| |
| static_assert( |
| sizeof(padding_bytes_cleared_) == sizeof(proto.padding_bytes_cleared()), |
| "size mismatch"); |
| padding_bytes_cleared_ = static_cast<decltype(padding_bytes_cleared_)>( |
| proto.padding_bytes_cleared()); |
| |
| static_assert(sizeof(chunks_written_) == sizeof(proto.chunks_written()), |
| "size mismatch"); |
| chunks_written_ = |
| static_cast<decltype(chunks_written_)>(proto.chunks_written()); |
| |
| static_assert(sizeof(chunks_rewritten_) == sizeof(proto.chunks_rewritten()), |
| "size mismatch"); |
| chunks_rewritten_ = |
| static_cast<decltype(chunks_rewritten_)>(proto.chunks_rewritten()); |
| |
| static_assert( |
| sizeof(chunks_overwritten_) == sizeof(proto.chunks_overwritten()), |
| "size mismatch"); |
| chunks_overwritten_ = |
| static_cast<decltype(chunks_overwritten_)>(proto.chunks_overwritten()); |
| |
| static_assert(sizeof(chunks_discarded_) == sizeof(proto.chunks_discarded()), |
| "size mismatch"); |
| chunks_discarded_ = |
| static_cast<decltype(chunks_discarded_)>(proto.chunks_discarded()); |
| |
| static_assert(sizeof(chunks_read_) == sizeof(proto.chunks_read()), |
| "size mismatch"); |
| chunks_read_ = static_cast<decltype(chunks_read_)>(proto.chunks_read()); |
| |
| static_assert(sizeof(chunks_committed_out_of_order_) == |
| sizeof(proto.chunks_committed_out_of_order()), |
| "size mismatch"); |
| chunks_committed_out_of_order_ = |
| static_cast<decltype(chunks_committed_out_of_order_)>( |
| proto.chunks_committed_out_of_order()); |
| |
| static_assert(sizeof(write_wrap_count_) == sizeof(proto.write_wrap_count()), |
| "size mismatch"); |
| write_wrap_count_ = |
| static_cast<decltype(write_wrap_count_)>(proto.write_wrap_count()); |
| |
| static_assert(sizeof(patches_succeeded_) == sizeof(proto.patches_succeeded()), |
| "size mismatch"); |
| patches_succeeded_ = |
| static_cast<decltype(patches_succeeded_)>(proto.patches_succeeded()); |
| |
| static_assert(sizeof(patches_failed_) == sizeof(proto.patches_failed()), |
| "size mismatch"); |
| patches_failed_ = |
| static_cast<decltype(patches_failed_)>(proto.patches_failed()); |
| |
| static_assert( |
| sizeof(readaheads_succeeded_) == sizeof(proto.readaheads_succeeded()), |
| "size mismatch"); |
| readaheads_succeeded_ = static_cast<decltype(readaheads_succeeded_)>( |
| proto.readaheads_succeeded()); |
| |
| static_assert(sizeof(readaheads_failed_) == sizeof(proto.readaheads_failed()), |
| "size mismatch"); |
| readaheads_failed_ = |
| static_cast<decltype(readaheads_failed_)>(proto.readaheads_failed()); |
| |
| static_assert(sizeof(abi_violations_) == sizeof(proto.abi_violations()), |
| "size mismatch"); |
| abi_violations_ = |
| static_cast<decltype(abi_violations_)>(proto.abi_violations()); |
| unknown_fields_ = proto.unknown_fields(); |
| } |
| |
| void TraceStats::BufferStats::ToProto( |
| perfetto::protos::TraceStats_BufferStats* proto) const { |
| proto->Clear(); |
| |
| static_assert(sizeof(buffer_size_) == sizeof(proto->buffer_size()), |
| "size mismatch"); |
| proto->set_buffer_size( |
| static_cast<decltype(proto->buffer_size())>(buffer_size_)); |
| |
| static_assert(sizeof(bytes_written_) == sizeof(proto->bytes_written()), |
| "size mismatch"); |
| proto->set_bytes_written( |
| static_cast<decltype(proto->bytes_written())>(bytes_written_)); |
| |
| static_assert( |
| sizeof(bytes_overwritten_) == sizeof(proto->bytes_overwritten()), |
| "size mismatch"); |
| proto->set_bytes_overwritten( |
| static_cast<decltype(proto->bytes_overwritten())>(bytes_overwritten_)); |
| |
| static_assert(sizeof(bytes_read_) == sizeof(proto->bytes_read()), |
| "size mismatch"); |
| proto->set_bytes_read( |
| static_cast<decltype(proto->bytes_read())>(bytes_read_)); |
| |
| static_assert( |
| sizeof(padding_bytes_written_) == sizeof(proto->padding_bytes_written()), |
| "size mismatch"); |
| proto->set_padding_bytes_written( |
| static_cast<decltype(proto->padding_bytes_written())>( |
| padding_bytes_written_)); |
| |
| static_assert( |
| sizeof(padding_bytes_cleared_) == sizeof(proto->padding_bytes_cleared()), |
| "size mismatch"); |
| proto->set_padding_bytes_cleared( |
| static_cast<decltype(proto->padding_bytes_cleared())>( |
| padding_bytes_cleared_)); |
| |
| static_assert(sizeof(chunks_written_) == sizeof(proto->chunks_written()), |
| "size mismatch"); |
| proto->set_chunks_written( |
| static_cast<decltype(proto->chunks_written())>(chunks_written_)); |
| |
| static_assert(sizeof(chunks_rewritten_) == sizeof(proto->chunks_rewritten()), |
| "size mismatch"); |
| proto->set_chunks_rewritten( |
| static_cast<decltype(proto->chunks_rewritten())>(chunks_rewritten_)); |
| |
| static_assert( |
| sizeof(chunks_overwritten_) == sizeof(proto->chunks_overwritten()), |
| "size mismatch"); |
| proto->set_chunks_overwritten( |
| static_cast<decltype(proto->chunks_overwritten())>(chunks_overwritten_)); |
| |
| static_assert(sizeof(chunks_discarded_) == sizeof(proto->chunks_discarded()), |
| "size mismatch"); |
| proto->set_chunks_discarded( |
| static_cast<decltype(proto->chunks_discarded())>(chunks_discarded_)); |
| |
| static_assert(sizeof(chunks_read_) == sizeof(proto->chunks_read()), |
| "size mismatch"); |
| proto->set_chunks_read( |
| static_cast<decltype(proto->chunks_read())>(chunks_read_)); |
| |
| static_assert(sizeof(chunks_committed_out_of_order_) == |
| sizeof(proto->chunks_committed_out_of_order()), |
| "size mismatch"); |
| proto->set_chunks_committed_out_of_order( |
| static_cast<decltype(proto->chunks_committed_out_of_order())>( |
| chunks_committed_out_of_order_)); |
| |
| static_assert(sizeof(write_wrap_count_) == sizeof(proto->write_wrap_count()), |
| "size mismatch"); |
| proto->set_write_wrap_count( |
| static_cast<decltype(proto->write_wrap_count())>(write_wrap_count_)); |
| |
| static_assert( |
| sizeof(patches_succeeded_) == sizeof(proto->patches_succeeded()), |
| "size mismatch"); |
| proto->set_patches_succeeded( |
| static_cast<decltype(proto->patches_succeeded())>(patches_succeeded_)); |
| |
| static_assert(sizeof(patches_failed_) == sizeof(proto->patches_failed()), |
| "size mismatch"); |
| proto->set_patches_failed( |
| static_cast<decltype(proto->patches_failed())>(patches_failed_)); |
| |
| static_assert( |
| sizeof(readaheads_succeeded_) == sizeof(proto->readaheads_succeeded()), |
| "size mismatch"); |
| proto->set_readaheads_succeeded( |
| static_cast<decltype(proto->readaheads_succeeded())>( |
| readaheads_succeeded_)); |
| |
| static_assert( |
| sizeof(readaheads_failed_) == sizeof(proto->readaheads_failed()), |
| "size mismatch"); |
| proto->set_readaheads_failed( |
| static_cast<decltype(proto->readaheads_failed())>(readaheads_failed_)); |
| |
| static_assert(sizeof(abi_violations_) == sizeof(proto->abi_violations()), |
| "size mismatch"); |
| proto->set_abi_violations( |
| static_cast<decltype(proto->abi_violations())>(abi_violations_)); |
| *(proto->mutable_unknown_fields()) = unknown_fields_; |
| } |
| |
| } // namespace perfetto |
