tracing/core/trace_stats.cc

/*
 * 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