3RNN/Lib/site-packages/tensorflow/include/tsl/protobuf/test_log.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tsl/protobuf/test_log.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_tsl_2fprotobuf_2ftest_5flog_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_tsl_2fprotobuf_2ftest_5flog_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/any.pb.h>
#include <google/protobuf/wrappers.pb.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_tsl_2fprotobuf_2ftest_5flog_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tsl_2fprotobuf_2ftest_5flog_2eproto;
namespace tensorflow {
class AvailableDeviceInfo;
struct AvailableDeviceInfoDefaultTypeInternal;
extern AvailableDeviceInfoDefaultTypeInternal _AvailableDeviceInfo_default_instance_;
class BenchmarkEntries;
struct BenchmarkEntriesDefaultTypeInternal;
extern BenchmarkEntriesDefaultTypeInternal _BenchmarkEntries_default_instance_;
class BenchmarkEntry;
struct BenchmarkEntryDefaultTypeInternal;
extern BenchmarkEntryDefaultTypeInternal _BenchmarkEntry_default_instance_;
class BenchmarkEntry_ExtrasEntry_DoNotUse;
struct BenchmarkEntry_ExtrasEntry_DoNotUseDefaultTypeInternal;
extern BenchmarkEntry_ExtrasEntry_DoNotUseDefaultTypeInternal _BenchmarkEntry_ExtrasEntry_DoNotUse_default_instance_;
class BuildConfiguration;
struct BuildConfigurationDefaultTypeInternal;
extern BuildConfigurationDefaultTypeInternal _BuildConfiguration_default_instance_;
class CPUInfo;
struct CPUInfoDefaultTypeInternal;
extern CPUInfoDefaultTypeInternal _CPUInfo_default_instance_;
class CPUInfo_CacheSizeEntry_DoNotUse;
struct CPUInfo_CacheSizeEntry_DoNotUseDefaultTypeInternal;
extern CPUInfo_CacheSizeEntry_DoNotUseDefaultTypeInternal _CPUInfo_CacheSizeEntry_DoNotUse_default_instance_;
class CommitId;
struct CommitIdDefaultTypeInternal;
extern CommitIdDefaultTypeInternal _CommitId_default_instance_;
class EntryValue;
struct EntryValueDefaultTypeInternal;
extern EntryValueDefaultTypeInternal _EntryValue_default_instance_;
class GPUInfo;
struct GPUInfoDefaultTypeInternal;
extern GPUInfoDefaultTypeInternal _GPUInfo_default_instance_;
class MachineConfiguration;
struct MachineConfigurationDefaultTypeInternal;
extern MachineConfigurationDefaultTypeInternal _MachineConfiguration_default_instance_;
class MemoryInfo;
struct MemoryInfoDefaultTypeInternal;
extern MemoryInfoDefaultTypeInternal _MemoryInfo_default_instance_;
class MetricEntry;
struct MetricEntryDefaultTypeInternal;
extern MetricEntryDefaultTypeInternal _MetricEntry_default_instance_;
class PlatformInfo;
struct PlatformInfoDefaultTypeInternal;
extern PlatformInfoDefaultTypeInternal _PlatformInfo_default_instance_;
class RunConfiguration;
struct RunConfigurationDefaultTypeInternal;
extern RunConfigurationDefaultTypeInternal _RunConfiguration_default_instance_;
class RunConfiguration_EnvVarsEntry_DoNotUse;
struct RunConfiguration_EnvVarsEntry_DoNotUseDefaultTypeInternal;
extern RunConfiguration_EnvVarsEntry_DoNotUseDefaultTypeInternal _RunConfiguration_EnvVarsEntry_DoNotUse_default_instance_;
class TestResults;
struct TestResultsDefaultTypeInternal;
extern TestResultsDefaultTypeInternal _TestResults_default_instance_;
}  // namespace tensorflow
PROTOBUF_NAMESPACE_OPEN
template<> ::tensorflow::AvailableDeviceInfo* Arena::CreateMaybeMessage<::tensorflow::AvailableDeviceInfo>(Arena*);
template<> ::tensorflow::BenchmarkEntries* Arena::CreateMaybeMessage<::tensorflow::BenchmarkEntries>(Arena*);
template<> ::tensorflow::BenchmarkEntry* Arena::CreateMaybeMessage<::tensorflow::BenchmarkEntry>(Arena*);
template<> ::tensorflow::BenchmarkEntry_ExtrasEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::BenchmarkEntry_ExtrasEntry_DoNotUse>(Arena*);
template<> ::tensorflow::BuildConfiguration* Arena::CreateMaybeMessage<::tensorflow::BuildConfiguration>(Arena*);
template<> ::tensorflow::CPUInfo* Arena::CreateMaybeMessage<::tensorflow::CPUInfo>(Arena*);
template<> ::tensorflow::CPUInfo_CacheSizeEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::CPUInfo_CacheSizeEntry_DoNotUse>(Arena*);
template<> ::tensorflow::CommitId* Arena::CreateMaybeMessage<::tensorflow::CommitId>(Arena*);
template<> ::tensorflow::EntryValue* Arena::CreateMaybeMessage<::tensorflow::EntryValue>(Arena*);
template<> ::tensorflow::GPUInfo* Arena::CreateMaybeMessage<::tensorflow::GPUInfo>(Arena*);
template<> ::tensorflow::MachineConfiguration* Arena::CreateMaybeMessage<::tensorflow::MachineConfiguration>(Arena*);
template<> ::tensorflow::MemoryInfo* Arena::CreateMaybeMessage<::tensorflow::MemoryInfo>(Arena*);
template<> ::tensorflow::MetricEntry* Arena::CreateMaybeMessage<::tensorflow::MetricEntry>(Arena*);
template<> ::tensorflow::PlatformInfo* Arena::CreateMaybeMessage<::tensorflow::PlatformInfo>(Arena*);
template<> ::tensorflow::RunConfiguration* Arena::CreateMaybeMessage<::tensorflow::RunConfiguration>(Arena*);
template<> ::tensorflow::RunConfiguration_EnvVarsEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::RunConfiguration_EnvVarsEntry_DoNotUse>(Arena*);
template<> ::tensorflow::TestResults* Arena::CreateMaybeMessage<::tensorflow::TestResults>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace tensorflow {

enum TestResults_BenchmarkType : int {
  TestResults_BenchmarkType_UNKNOWN = 0,
  TestResults_BenchmarkType_CPP_MICROBENCHMARK = 1,
  TestResults_BenchmarkType_PYTHON_BENCHMARK = 2,
  TestResults_BenchmarkType_ANDROID_BENCHMARK = 3,
  TestResults_BenchmarkType_EDGE_BENCHMARK = 4,
  TestResults_BenchmarkType_IOS_BENCHMARK = 5,
  TestResults_BenchmarkType_TestResults_BenchmarkType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  TestResults_BenchmarkType_TestResults_BenchmarkType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool TestResults_BenchmarkType_IsValid(int value);
constexpr TestResults_BenchmarkType TestResults_BenchmarkType_BenchmarkType_MIN = TestResults_BenchmarkType_UNKNOWN;
constexpr TestResults_BenchmarkType TestResults_BenchmarkType_BenchmarkType_MAX = TestResults_BenchmarkType_IOS_BENCHMARK;
constexpr int TestResults_BenchmarkType_BenchmarkType_ARRAYSIZE = TestResults_BenchmarkType_BenchmarkType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TestResults_BenchmarkType_descriptor();
template<typename T>
inline const std::string& TestResults_BenchmarkType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TestResults_BenchmarkType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TestResults_BenchmarkType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TestResults_BenchmarkType_descriptor(), enum_t_value);
}
inline bool TestResults_BenchmarkType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TestResults_BenchmarkType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TestResults_BenchmarkType>(
    TestResults_BenchmarkType_descriptor(), name, value);
}
// ===================================================================

class EntryValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.EntryValue) */ {
 public:
  inline EntryValue() : EntryValue(nullptr) {}
  ~EntryValue() override;
  explicit PROTOBUF_CONSTEXPR EntryValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  EntryValue(const EntryValue& from);
  EntryValue(EntryValue&& from) noexcept
    : EntryValue() {
    *this = ::std::move(from);
  }

  inline EntryValue& operator=(const EntryValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntryValue& operator=(EntryValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const EntryValue& default_instance() {
    return *internal_default_instance();
  }
  enum KindCase {
    kDoubleValue = 1,
    kStringValue = 2,
    KIND_NOT_SET = 0,
  };

  static inline const EntryValue* internal_default_instance() {
    return reinterpret_cast<const EntryValue*>(
               &_EntryValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(EntryValue& a, EntryValue& b) {
    a.Swap(&b);
  }
  inline void Swap(EntryValue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(EntryValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  EntryValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EntryValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const EntryValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const EntryValue& from) {
    EntryValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(EntryValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.EntryValue";
  }
  protected:
  explicit EntryValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDoubleValueFieldNumber = 1,
    kStringValueFieldNumber = 2,
  };
  // double double_value = 1;
  bool has_double_value() const;
  private:
  bool _internal_has_double_value() const;
  public:
  void clear_double_value();
  double double_value() const;
  void set_double_value(double value);
  private:
  double _internal_double_value() const;
  void _internal_set_double_value(double value);
  public:

  // string string_value = 2;
  bool has_string_value() const;
  private:
  bool _internal_has_string_value() const;
  public:
  void clear_string_value();
  const std::string& string_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_string_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_string_value();
  PROTOBUF_NODISCARD std::string* release_string_value();
  void set_allocated_string_value(std::string* string_value);
  private:
  const std::string& _internal_string_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
  std::string* _internal_mutable_string_value();
  public:

  void clear_kind();
  KindCase kind_case() const;
  // @@protoc_insertion_point(class_scope:tensorflow.EntryValue)
 private:
  class _Internal;
  void set_has_double_value();
  void set_has_string_value();

  inline bool has_kind() const;
  inline void clear_has_kind();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union KindUnion {
      constexpr KindUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      double double_value_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
    } kind_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class MetricEntry final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MetricEntry) */ {
 public:
  inline MetricEntry() : MetricEntry(nullptr) {}
  ~MetricEntry() override;
  explicit PROTOBUF_CONSTEXPR MetricEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MetricEntry(const MetricEntry& from);
  MetricEntry(MetricEntry&& from) noexcept
    : MetricEntry() {
    *this = ::std::move(from);
  }

  inline MetricEntry& operator=(const MetricEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline MetricEntry& operator=(MetricEntry&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MetricEntry& default_instance() {
    return *internal_default_instance();
  }
  static inline const MetricEntry* internal_default_instance() {
    return reinterpret_cast<const MetricEntry*>(
               &_MetricEntry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(MetricEntry& a, MetricEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(MetricEntry* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MetricEntry* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MetricEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MetricEntry>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MetricEntry& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MetricEntry& from) {
    MetricEntry::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MetricEntry* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.MetricEntry";
  }
  protected:
  explicit MetricEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kMinValueFieldNumber = 3,
    kMaxValueFieldNumber = 4,
    kValueFieldNumber = 2,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .google.protobuf.DoubleValue min_value = 3;
  bool has_min_value() const;
  private:
  bool _internal_has_min_value() const;
  public:
  void clear_min_value();
  const ::PROTOBUF_NAMESPACE_ID::DoubleValue& min_value() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::DoubleValue* release_min_value();
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* mutable_min_value();
  void set_allocated_min_value(::PROTOBUF_NAMESPACE_ID::DoubleValue* min_value);
  private:
  const ::PROTOBUF_NAMESPACE_ID::DoubleValue& _internal_min_value() const;
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* _internal_mutable_min_value();
  public:
  void unsafe_arena_set_allocated_min_value(
      ::PROTOBUF_NAMESPACE_ID::DoubleValue* min_value);
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* unsafe_arena_release_min_value();

  // .google.protobuf.DoubleValue max_value = 4;
  bool has_max_value() const;
  private:
  bool _internal_has_max_value() const;
  public:
  void clear_max_value();
  const ::PROTOBUF_NAMESPACE_ID::DoubleValue& max_value() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::DoubleValue* release_max_value();
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* mutable_max_value();
  void set_allocated_max_value(::PROTOBUF_NAMESPACE_ID::DoubleValue* max_value);
  private:
  const ::PROTOBUF_NAMESPACE_ID::DoubleValue& _internal_max_value() const;
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* _internal_mutable_max_value();
  public:
  void unsafe_arena_set_allocated_max_value(
      ::PROTOBUF_NAMESPACE_ID::DoubleValue* max_value);
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* unsafe_arena_release_max_value();

  // double value = 2;
  void clear_value();
  double value() const;
  void set_value(double value);
  private:
  double _internal_value() const;
  void _internal_set_value(double value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.MetricEntry)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::DoubleValue* min_value_;
    ::PROTOBUF_NAMESPACE_ID::DoubleValue* max_value_;
    double value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class BenchmarkEntry_ExtrasEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<BenchmarkEntry_ExtrasEntry_DoNotUse, 
    std::string, ::tensorflow::EntryValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<BenchmarkEntry_ExtrasEntry_DoNotUse, 
    std::string, ::tensorflow::EntryValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  BenchmarkEntry_ExtrasEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR BenchmarkEntry_ExtrasEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit BenchmarkEntry_ExtrasEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const BenchmarkEntry_ExtrasEntry_DoNotUse& other);
  static const BenchmarkEntry_ExtrasEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const BenchmarkEntry_ExtrasEntry_DoNotUse*>(&_BenchmarkEntry_ExtrasEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.BenchmarkEntry.ExtrasEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};

// -------------------------------------------------------------------

class BenchmarkEntry final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BenchmarkEntry) */ {
 public:
  inline BenchmarkEntry() : BenchmarkEntry(nullptr) {}
  ~BenchmarkEntry() override;
  explicit PROTOBUF_CONSTEXPR BenchmarkEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BenchmarkEntry(const BenchmarkEntry& from);
  BenchmarkEntry(BenchmarkEntry&& from) noexcept
    : BenchmarkEntry() {
    *this = ::std::move(from);
  }

  inline BenchmarkEntry& operator=(const BenchmarkEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline BenchmarkEntry& operator=(BenchmarkEntry&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BenchmarkEntry& default_instance() {
    return *internal_default_instance();
  }
  static inline const BenchmarkEntry* internal_default_instance() {
    return reinterpret_cast<const BenchmarkEntry*>(
               &_BenchmarkEntry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(BenchmarkEntry& a, BenchmarkEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(BenchmarkEntry* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BenchmarkEntry* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  BenchmarkEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BenchmarkEntry>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BenchmarkEntry& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BenchmarkEntry& from) {
    BenchmarkEntry::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BenchmarkEntry* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.BenchmarkEntry";
  }
  protected:
  explicit BenchmarkEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kExtrasFieldNumber = 6,
    kMetricsFieldNumber = 7,
    kNameFieldNumber = 1,
    kItersFieldNumber = 2,
    kCpuTimeFieldNumber = 3,
    kWallTimeFieldNumber = 4,
    kThroughputFieldNumber = 5,
  };
  // map<string, .tensorflow.EntryValue> extras = 6;
  int extras_size() const;
  private:
  int _internal_extras_size() const;
  public:
  void clear_extras();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >&
      _internal_extras() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >*
      _internal_mutable_extras();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >&
      extras() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >*
      mutable_extras();

  // repeated .tensorflow.MetricEntry metrics = 7;
  int metrics_size() const;
  private:
  int _internal_metrics_size() const;
  public:
  void clear_metrics();
  ::tensorflow::MetricEntry* mutable_metrics(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry >*
      mutable_metrics();
  private:
  const ::tensorflow::MetricEntry& _internal_metrics(int index) const;
  ::tensorflow::MetricEntry* _internal_add_metrics();
  public:
  const ::tensorflow::MetricEntry& metrics(int index) const;
  ::tensorflow::MetricEntry* add_metrics();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry >&
      metrics() const;

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // int64 iters = 2;
  void clear_iters();
  int64_t iters() const;
  void set_iters(int64_t value);
  private:
  int64_t _internal_iters() const;
  void _internal_set_iters(int64_t value);
  public:

  // double cpu_time = 3;
  void clear_cpu_time();
  double cpu_time() const;
  void set_cpu_time(double value);
  private:
  double _internal_cpu_time() const;
  void _internal_set_cpu_time(double value);
  public:

  // double wall_time = 4;
  void clear_wall_time();
  double wall_time() const;
  void set_wall_time(double value);
  private:
  double _internal_wall_time() const;
  void _internal_set_wall_time(double value);
  public:

  // double throughput = 5;
  void clear_throughput();
  double throughput() const;
  void set_throughput(double value);
  private:
  double _internal_throughput() const;
  void _internal_set_throughput(double value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.BenchmarkEntry)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        BenchmarkEntry_ExtrasEntry_DoNotUse,
        std::string, ::tensorflow::EntryValue,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> extras_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry > metrics_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    int64_t iters_;
    double cpu_time_;
    double wall_time_;
    double throughput_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class BenchmarkEntries final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BenchmarkEntries) */ {
 public:
  inline BenchmarkEntries() : BenchmarkEntries(nullptr) {}
  ~BenchmarkEntries() override;
  explicit PROTOBUF_CONSTEXPR BenchmarkEntries(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BenchmarkEntries(const BenchmarkEntries& from);
  BenchmarkEntries(BenchmarkEntries&& from) noexcept
    : BenchmarkEntries() {
    *this = ::std::move(from);
  }

  inline BenchmarkEntries& operator=(const BenchmarkEntries& from) {
    CopyFrom(from);
    return *this;
  }
  inline BenchmarkEntries& operator=(BenchmarkEntries&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BenchmarkEntries& default_instance() {
    return *internal_default_instance();
  }
  static inline const BenchmarkEntries* internal_default_instance() {
    return reinterpret_cast<const BenchmarkEntries*>(
               &_BenchmarkEntries_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(BenchmarkEntries& a, BenchmarkEntries& b) {
    a.Swap(&b);
  }
  inline void Swap(BenchmarkEntries* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BenchmarkEntries* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  BenchmarkEntries* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BenchmarkEntries>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BenchmarkEntries& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BenchmarkEntries& from) {
    BenchmarkEntries::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BenchmarkEntries* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.BenchmarkEntries";
  }
  protected:
  explicit BenchmarkEntries(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEntryFieldNumber = 1,
  };
  // repeated .tensorflow.BenchmarkEntry entry = 1;
  int entry_size() const;
  private:
  int _internal_entry_size() const;
  public:
  void clear_entry();
  ::tensorflow::BenchmarkEntry* mutable_entry(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry >*
      mutable_entry();
  private:
  const ::tensorflow::BenchmarkEntry& _internal_entry(int index) const;
  ::tensorflow::BenchmarkEntry* _internal_add_entry();
  public:
  const ::tensorflow::BenchmarkEntry& entry(int index) const;
  ::tensorflow::BenchmarkEntry* add_entry();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry >&
      entry() const;

  // @@protoc_insertion_point(class_scope:tensorflow.BenchmarkEntries)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry > entry_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class BuildConfiguration final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BuildConfiguration) */ {
 public:
  inline BuildConfiguration() : BuildConfiguration(nullptr) {}
  ~BuildConfiguration() override;
  explicit PROTOBUF_CONSTEXPR BuildConfiguration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BuildConfiguration(const BuildConfiguration& from);
  BuildConfiguration(BuildConfiguration&& from) noexcept
    : BuildConfiguration() {
    *this = ::std::move(from);
  }

  inline BuildConfiguration& operator=(const BuildConfiguration& from) {
    CopyFrom(from);
    return *this;
  }
  inline BuildConfiguration& operator=(BuildConfiguration&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BuildConfiguration& default_instance() {
    return *internal_default_instance();
  }
  static inline const BuildConfiguration* internal_default_instance() {
    return reinterpret_cast<const BuildConfiguration*>(
               &_BuildConfiguration_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(BuildConfiguration& a, BuildConfiguration& b) {
    a.Swap(&b);
  }
  inline void Swap(BuildConfiguration* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BuildConfiguration* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  BuildConfiguration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BuildConfiguration>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BuildConfiguration& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BuildConfiguration& from) {
    BuildConfiguration::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BuildConfiguration* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.BuildConfiguration";
  }
  protected:
  explicit BuildConfiguration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCcFlagsFieldNumber = 2,
    kOptsFieldNumber = 3,
    kModeFieldNumber = 1,
  };
  // repeated string cc_flags = 2;
  int cc_flags_size() const;
  private:
  int _internal_cc_flags_size() const;
  public:
  void clear_cc_flags();
  const std::string& cc_flags(int index) const;
  std::string* mutable_cc_flags(int index);
  void set_cc_flags(int index, const std::string& value);
  void set_cc_flags(int index, std::string&& value);
  void set_cc_flags(int index, const char* value);
  void set_cc_flags(int index, const char* value, size_t size);
  std::string* add_cc_flags();
  void add_cc_flags(const std::string& value);
  void add_cc_flags(std::string&& value);
  void add_cc_flags(const char* value);
  void add_cc_flags(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& cc_flags() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_cc_flags();
  private:
  const std::string& _internal_cc_flags(int index) const;
  std::string* _internal_add_cc_flags();
  public:

  // repeated string opts = 3;
  int opts_size() const;
  private:
  int _internal_opts_size() const;
  public:
  void clear_opts();
  const std::string& opts(int index) const;
  std::string* mutable_opts(int index);
  void set_opts(int index, const std::string& value);
  void set_opts(int index, std::string&& value);
  void set_opts(int index, const char* value);
  void set_opts(int index, const char* value, size_t size);
  std::string* add_opts();
  void add_opts(const std::string& value);
  void add_opts(std::string&& value);
  void add_opts(const char* value);
  void add_opts(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& opts() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_opts();
  private:
  const std::string& _internal_opts(int index) const;
  std::string* _internal_add_opts();
  public:

  // string mode = 1;
  void clear_mode();
  const std::string& mode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mode();
  PROTOBUF_NODISCARD std::string* release_mode();
  void set_allocated_mode(std::string* mode);
  private:
  const std::string& _internal_mode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mode(const std::string& value);
  std::string* _internal_mutable_mode();
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.BuildConfiguration)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> cc_flags_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> opts_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mode_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class CommitId final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CommitId) */ {
 public:
  inline CommitId() : CommitId(nullptr) {}
  ~CommitId() override;
  explicit PROTOBUF_CONSTEXPR CommitId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CommitId(const CommitId& from);
  CommitId(CommitId&& from) noexcept
    : CommitId() {
    *this = ::std::move(from);
  }

  inline CommitId& operator=(const CommitId& from) {
    CopyFrom(from);
    return *this;
  }
  inline CommitId& operator=(CommitId&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CommitId& default_instance() {
    return *internal_default_instance();
  }
  enum KindCase {
    kChangelist = 1,
    kHash = 2,
    KIND_NOT_SET = 0,
  };

  static inline const CommitId* internal_default_instance() {
    return reinterpret_cast<const CommitId*>(
               &_CommitId_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(CommitId& a, CommitId& b) {
    a.Swap(&b);
  }
  inline void Swap(CommitId* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CommitId* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CommitId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CommitId>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CommitId& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CommitId& from) {
    CommitId::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CommitId* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.CommitId";
  }
  protected:
  explicit CommitId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSnapshotFieldNumber = 3,
    kPendingChangelistFieldNumber = 4,
    kChangelistFieldNumber = 1,
    kHashFieldNumber = 2,
  };
  // string snapshot = 3;
  void clear_snapshot();
  const std::string& snapshot() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_snapshot(ArgT0&& arg0, ArgT... args);
  std::string* mutable_snapshot();
  PROTOBUF_NODISCARD std::string* release_snapshot();
  void set_allocated_snapshot(std::string* snapshot);
  private:
  const std::string& _internal_snapshot() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshot(const std::string& value);
  std::string* _internal_mutable_snapshot();
  public:

  // int64 pending_changelist = 4;
  void clear_pending_changelist();
  int64_t pending_changelist() const;
  void set_pending_changelist(int64_t value);
  private:
  int64_t _internal_pending_changelist() const;
  void _internal_set_pending_changelist(int64_t value);
  public:

  // int64 changelist = 1;
  bool has_changelist() const;
  private:
  bool _internal_has_changelist() const;
  public:
  void clear_changelist();
  int64_t changelist() const;
  void set_changelist(int64_t value);
  private:
  int64_t _internal_changelist() const;
  void _internal_set_changelist(int64_t value);
  public:

  // string hash = 2;
  bool has_hash() const;
  private:
  bool _internal_has_hash() const;
  public:
  void clear_hash();
  const std::string& hash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hash();
  PROTOBUF_NODISCARD std::string* release_hash();
  void set_allocated_hash(std::string* hash);
  private:
  const std::string& _internal_hash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
  std::string* _internal_mutable_hash();
  public:

  void clear_kind();
  KindCase kind_case() const;
  // @@protoc_insertion_point(class_scope:tensorflow.CommitId)
 private:
  class _Internal;
  void set_has_changelist();
  void set_has_hash();

  inline bool has_kind() const;
  inline void clear_has_kind();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshot_;
    int64_t pending_changelist_;
    union KindUnion {
      constexpr KindUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      int64_t changelist_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
    } kind_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class CPUInfo_CacheSizeEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CPUInfo_CacheSizeEntry_DoNotUse, 
    std::string, int64_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CPUInfo_CacheSizeEntry_DoNotUse, 
    std::string, int64_t,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> SuperType;
  CPUInfo_CacheSizeEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR CPUInfo_CacheSizeEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit CPUInfo_CacheSizeEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const CPUInfo_CacheSizeEntry_DoNotUse& other);
  static const CPUInfo_CacheSizeEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const CPUInfo_CacheSizeEntry_DoNotUse*>(&_CPUInfo_CacheSizeEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.CPUInfo.CacheSizeEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};

// -------------------------------------------------------------------

class CPUInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CPUInfo) */ {
 public:
  inline CPUInfo() : CPUInfo(nullptr) {}
  ~CPUInfo() override;
  explicit PROTOBUF_CONSTEXPR CPUInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CPUInfo(const CPUInfo& from);
  CPUInfo(CPUInfo&& from) noexcept
    : CPUInfo() {
    *this = ::std::move(from);
  }

  inline CPUInfo& operator=(const CPUInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline CPUInfo& operator=(CPUInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CPUInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const CPUInfo* internal_default_instance() {
    return reinterpret_cast<const CPUInfo*>(
               &_CPUInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(CPUInfo& a, CPUInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(CPUInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CPUInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CPUInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CPUInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CPUInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CPUInfo& from) {
    CPUInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CPUInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.CPUInfo";
  }
  protected:
  explicit CPUInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kCacheSizeFieldNumber = 6,
    kCpuInfoFieldNumber = 4,
    kCpuGovernorFieldNumber = 5,
    kNumCoresFieldNumber = 1,
    kNumCoresAllowedFieldNumber = 2,
    kMhzPerCpuFieldNumber = 3,
  };
  // map<string, int64> cache_size = 6;
  int cache_size_size() const;
  private:
  int _internal_cache_size_size() const;
  public:
  void clear_cache_size();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >&
      _internal_cache_size() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >*
      _internal_mutable_cache_size();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >&
      cache_size() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >*
      mutable_cache_size();

  // string cpu_info = 4;
  void clear_cpu_info();
  const std::string& cpu_info() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cpu_info(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cpu_info();
  PROTOBUF_NODISCARD std::string* release_cpu_info();
  void set_allocated_cpu_info(std::string* cpu_info);
  private:
  const std::string& _internal_cpu_info() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cpu_info(const std::string& value);
  std::string* _internal_mutable_cpu_info();
  public:

  // string cpu_governor = 5;
  void clear_cpu_governor();
  const std::string& cpu_governor() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cpu_governor(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cpu_governor();
  PROTOBUF_NODISCARD std::string* release_cpu_governor();
  void set_allocated_cpu_governor(std::string* cpu_governor);
  private:
  const std::string& _internal_cpu_governor() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cpu_governor(const std::string& value);
  std::string* _internal_mutable_cpu_governor();
  public:

  // int64 num_cores = 1;
  void clear_num_cores();
  int64_t num_cores() const;
  void set_num_cores(int64_t value);
  private:
  int64_t _internal_num_cores() const;
  void _internal_set_num_cores(int64_t value);
  public:

  // int64 num_cores_allowed = 2;
  void clear_num_cores_allowed();
  int64_t num_cores_allowed() const;
  void set_num_cores_allowed(int64_t value);
  private:
  int64_t _internal_num_cores_allowed() const;
  void _internal_set_num_cores_allowed(int64_t value);
  public:

  // double mhz_per_cpu = 3;
  void clear_mhz_per_cpu();
  double mhz_per_cpu() const;
  void set_mhz_per_cpu(double value);
  private:
  double _internal_mhz_per_cpu() const;
  void _internal_set_mhz_per_cpu(double value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.CPUInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        CPUInfo_CacheSizeEntry_DoNotUse,
        std::string, int64_t,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> cache_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cpu_info_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cpu_governor_;
    int64_t num_cores_;
    int64_t num_cores_allowed_;
    double mhz_per_cpu_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class MemoryInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryInfo) */ {
 public:
  inline MemoryInfo() : MemoryInfo(nullptr) {}
  ~MemoryInfo() override;
  explicit PROTOBUF_CONSTEXPR MemoryInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MemoryInfo(const MemoryInfo& from);
  MemoryInfo(MemoryInfo&& from) noexcept
    : MemoryInfo() {
    *this = ::std::move(from);
  }

  inline MemoryInfo& operator=(const MemoryInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline MemoryInfo& operator=(MemoryInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MemoryInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const MemoryInfo* internal_default_instance() {
    return reinterpret_cast<const MemoryInfo*>(
               &_MemoryInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(MemoryInfo& a, MemoryInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(MemoryInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MemoryInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MemoryInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MemoryInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MemoryInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MemoryInfo& from) {
    MemoryInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MemoryInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.MemoryInfo";
  }
  protected:
  explicit MemoryInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTotalFieldNumber = 1,
    kAvailableFieldNumber = 2,
  };
  // int64 total = 1;
  void clear_total();
  int64_t total() const;
  void set_total(int64_t value);
  private:
  int64_t _internal_total() const;
  void _internal_set_total(int64_t value);
  public:

  // int64 available = 2;
  void clear_available();
  int64_t available() const;
  void set_available(int64_t value);
  private:
  int64_t _internal_available() const;
  void _internal_set_available(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.MemoryInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int64_t total_;
    int64_t available_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class GPUInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GPUInfo) */ {
 public:
  inline GPUInfo() : GPUInfo(nullptr) {}
  ~GPUInfo() override;
  explicit PROTOBUF_CONSTEXPR GPUInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GPUInfo(const GPUInfo& from);
  GPUInfo(GPUInfo&& from) noexcept
    : GPUInfo() {
    *this = ::std::move(from);
  }

  inline GPUInfo& operator=(const GPUInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline GPUInfo& operator=(GPUInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GPUInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const GPUInfo* internal_default_instance() {
    return reinterpret_cast<const GPUInfo*>(
               &_GPUInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(GPUInfo& a, GPUInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(GPUInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GPUInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GPUInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GPUInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GPUInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const GPUInfo& from) {
    GPUInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GPUInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.GPUInfo";
  }
  protected:
  explicit GPUInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kModelFieldNumber = 1,
    kUuidFieldNumber = 2,
    kBusIdFieldNumber = 3,
  };
  // string model = 1;
  void clear_model();
  const std::string& model() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model();
  PROTOBUF_NODISCARD std::string* release_model();
  void set_allocated_model(std::string* model);
  private:
  const std::string& _internal_model() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
  std::string* _internal_mutable_model();
  public:

  // string uuid = 2;
  void clear_uuid();
  const std::string& uuid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_uuid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_uuid();
  PROTOBUF_NODISCARD std::string* release_uuid();
  void set_allocated_uuid(std::string* uuid);
  private:
  const std::string& _internal_uuid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uuid(const std::string& value);
  std::string* _internal_mutable_uuid();
  public:

  // string bus_id = 3;
  void clear_bus_id();
  const std::string& bus_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bus_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bus_id();
  PROTOBUF_NODISCARD std::string* release_bus_id();
  void set_allocated_bus_id(std::string* bus_id);
  private:
  const std::string& _internal_bus_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bus_id(const std::string& value);
  std::string* _internal_mutable_bus_id();
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.GPUInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bus_id_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class PlatformInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.PlatformInfo) */ {
 public:
  inline PlatformInfo() : PlatformInfo(nullptr) {}
  ~PlatformInfo() override;
  explicit PROTOBUF_CONSTEXPR PlatformInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PlatformInfo(const PlatformInfo& from);
  PlatformInfo(PlatformInfo&& from) noexcept
    : PlatformInfo() {
    *this = ::std::move(from);
  }

  inline PlatformInfo& operator=(const PlatformInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline PlatformInfo& operator=(PlatformInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PlatformInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const PlatformInfo* internal_default_instance() {
    return reinterpret_cast<const PlatformInfo*>(
               &_PlatformInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(PlatformInfo& a, PlatformInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(PlatformInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PlatformInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PlatformInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PlatformInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PlatformInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PlatformInfo& from) {
    PlatformInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PlatformInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.PlatformInfo";
  }
  protected:
  explicit PlatformInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBitsFieldNumber = 1,
    kLinkageFieldNumber = 2,
    kMachineFieldNumber = 3,
    kReleaseFieldNumber = 4,
    kSystemFieldNumber = 5,
    kVersionFieldNumber = 6,
  };
  // string bits = 1;
  void clear_bits();
  const std::string& bits() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bits(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bits();
  PROTOBUF_NODISCARD std::string* release_bits();
  void set_allocated_bits(std::string* bits);
  private:
  const std::string& _internal_bits() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bits(const std::string& value);
  std::string* _internal_mutable_bits();
  public:

  // string linkage = 2;
  void clear_linkage();
  const std::string& linkage() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_linkage(ArgT0&& arg0, ArgT... args);
  std::string* mutable_linkage();
  PROTOBUF_NODISCARD std::string* release_linkage();
  void set_allocated_linkage(std::string* linkage);
  private:
  const std::string& _internal_linkage() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_linkage(const std::string& value);
  std::string* _internal_mutable_linkage();
  public:

  // string machine = 3;
  void clear_machine();
  const std::string& machine() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_machine(ArgT0&& arg0, ArgT... args);
  std::string* mutable_machine();
  PROTOBUF_NODISCARD std::string* release_machine();
  void set_allocated_machine(std::string* machine);
  private:
  const std::string& _internal_machine() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_machine(const std::string& value);
  std::string* _internal_mutable_machine();
  public:

  // string release = 4;
  void clear_release();
  const std::string& release() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_release(ArgT0&& arg0, ArgT... args);
  std::string* mutable_release();
  PROTOBUF_NODISCARD std::string* release_release();
  void set_allocated_release(std::string* release);
  private:
  const std::string& _internal_release() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_release(const std::string& value);
  std::string* _internal_mutable_release();
  public:

  // string system = 5;
  void clear_system();
  const std::string& system() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_system(ArgT0&& arg0, ArgT... args);
  std::string* mutable_system();
  PROTOBUF_NODISCARD std::string* release_system();
  void set_allocated_system(std::string* system);
  private:
  const std::string& _internal_system() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_system(const std::string& value);
  std::string* _internal_mutable_system();
  public:

  // string version = 6;
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.PlatformInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bits_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr linkage_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machine_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr release_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr system_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class AvailableDeviceInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AvailableDeviceInfo) */ {
 public:
  inline AvailableDeviceInfo() : AvailableDeviceInfo(nullptr) {}
  ~AvailableDeviceInfo() override;
  explicit PROTOBUF_CONSTEXPR AvailableDeviceInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AvailableDeviceInfo(const AvailableDeviceInfo& from);
  AvailableDeviceInfo(AvailableDeviceInfo&& from) noexcept
    : AvailableDeviceInfo() {
    *this = ::std::move(from);
  }

  inline AvailableDeviceInfo& operator=(const AvailableDeviceInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline AvailableDeviceInfo& operator=(AvailableDeviceInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AvailableDeviceInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const AvailableDeviceInfo* internal_default_instance() {
    return reinterpret_cast<const AvailableDeviceInfo*>(
               &_AvailableDeviceInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(AvailableDeviceInfo& a, AvailableDeviceInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(AvailableDeviceInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AvailableDeviceInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  AvailableDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AvailableDeviceInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AvailableDeviceInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AvailableDeviceInfo& from) {
    AvailableDeviceInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AvailableDeviceInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.AvailableDeviceInfo";
  }
  protected:
  explicit AvailableDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kTypeFieldNumber = 2,
    kPhysicalDescriptionFieldNumber = 4,
    kMemoryLimitFieldNumber = 3,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string type = 2;
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // string physical_description = 4;
  void clear_physical_description();
  const std::string& physical_description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_physical_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_physical_description();
  PROTOBUF_NODISCARD std::string* release_physical_description();
  void set_allocated_physical_description(std::string* physical_description);
  private:
  const std::string& _internal_physical_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_physical_description(const std::string& value);
  std::string* _internal_mutable_physical_description();
  public:

  // int64 memory_limit = 3;
  void clear_memory_limit();
  int64_t memory_limit() const;
  void set_memory_limit(int64_t value);
  private:
  int64_t _internal_memory_limit() const;
  void _internal_set_memory_limit(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.AvailableDeviceInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr physical_description_;
    int64_t memory_limit_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class MachineConfiguration final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MachineConfiguration) */ {
 public:
  inline MachineConfiguration() : MachineConfiguration(nullptr) {}
  ~MachineConfiguration() override;
  explicit PROTOBUF_CONSTEXPR MachineConfiguration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MachineConfiguration(const MachineConfiguration& from);
  MachineConfiguration(MachineConfiguration&& from) noexcept
    : MachineConfiguration() {
    *this = ::std::move(from);
  }

  inline MachineConfiguration& operator=(const MachineConfiguration& from) {
    CopyFrom(from);
    return *this;
  }
  inline MachineConfiguration& operator=(MachineConfiguration&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MachineConfiguration& default_instance() {
    return *internal_default_instance();
  }
  static inline const MachineConfiguration* internal_default_instance() {
    return reinterpret_cast<const MachineConfiguration*>(
               &_MachineConfiguration_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(MachineConfiguration& a, MachineConfiguration& b) {
    a.Swap(&b);
  }
  inline void Swap(MachineConfiguration* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MachineConfiguration* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MachineConfiguration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MachineConfiguration>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MachineConfiguration& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MachineConfiguration& from) {
    MachineConfiguration::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MachineConfiguration* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.MachineConfiguration";
  }
  protected:
  explicit MachineConfiguration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDeviceInfoFieldNumber = 4,
    kAvailableDeviceInfoFieldNumber = 5,
    kHostnameFieldNumber = 1,
    kSerialIdentifierFieldNumber = 7,
    kPlatformInfoFieldNumber = 2,
    kCpuInfoFieldNumber = 3,
    kMemoryInfoFieldNumber = 6,
  };
  // repeated .google.protobuf.Any device_info = 4;
  int device_info_size() const;
  private:
  int _internal_device_info_size() const;
  public:
  void clear_device_info();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_device_info(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >*
      mutable_device_info();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_device_info(int index) const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_add_device_info();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Any& device_info(int index) const;
  ::PROTOBUF_NAMESPACE_ID::Any* add_device_info();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >&
      device_info() const;

  // repeated .tensorflow.AvailableDeviceInfo available_device_info = 5;
  int available_device_info_size() const;
  private:
  int _internal_available_device_info_size() const;
  public:
  void clear_available_device_info();
  ::tensorflow::AvailableDeviceInfo* mutable_available_device_info(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo >*
      mutable_available_device_info();
  private:
  const ::tensorflow::AvailableDeviceInfo& _internal_available_device_info(int index) const;
  ::tensorflow::AvailableDeviceInfo* _internal_add_available_device_info();
  public:
  const ::tensorflow::AvailableDeviceInfo& available_device_info(int index) const;
  ::tensorflow::AvailableDeviceInfo* add_available_device_info();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo >&
      available_device_info() const;

  // string hostname = 1;
  void clear_hostname();
  const std::string& hostname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hostname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hostname();
  PROTOBUF_NODISCARD std::string* release_hostname();
  void set_allocated_hostname(std::string* hostname);
  private:
  const std::string& _internal_hostname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hostname(const std::string& value);
  std::string* _internal_mutable_hostname();
  public:

  // string serial_identifier = 7;
  void clear_serial_identifier();
  const std::string& serial_identifier() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_serial_identifier(ArgT0&& arg0, ArgT... args);
  std::string* mutable_serial_identifier();
  PROTOBUF_NODISCARD std::string* release_serial_identifier();
  void set_allocated_serial_identifier(std::string* serial_identifier);
  private:
  const std::string& _internal_serial_identifier() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serial_identifier(const std::string& value);
  std::string* _internal_mutable_serial_identifier();
  public:

  // .tensorflow.PlatformInfo platform_info = 2;
  bool has_platform_info() const;
  private:
  bool _internal_has_platform_info() const;
  public:
  void clear_platform_info();
  const ::tensorflow::PlatformInfo& platform_info() const;
  PROTOBUF_NODISCARD ::tensorflow::PlatformInfo* release_platform_info();
  ::tensorflow::PlatformInfo* mutable_platform_info();
  void set_allocated_platform_info(::tensorflow::PlatformInfo* platform_info);
  private:
  const ::tensorflow::PlatformInfo& _internal_platform_info() const;
  ::tensorflow::PlatformInfo* _internal_mutable_platform_info();
  public:
  void unsafe_arena_set_allocated_platform_info(
      ::tensorflow::PlatformInfo* platform_info);
  ::tensorflow::PlatformInfo* unsafe_arena_release_platform_info();

  // .tensorflow.CPUInfo cpu_info = 3;
  bool has_cpu_info() const;
  private:
  bool _internal_has_cpu_info() const;
  public:
  void clear_cpu_info();
  const ::tensorflow::CPUInfo& cpu_info() const;
  PROTOBUF_NODISCARD ::tensorflow::CPUInfo* release_cpu_info();
  ::tensorflow::CPUInfo* mutable_cpu_info();
  void set_allocated_cpu_info(::tensorflow::CPUInfo* cpu_info);
  private:
  const ::tensorflow::CPUInfo& _internal_cpu_info() const;
  ::tensorflow::CPUInfo* _internal_mutable_cpu_info();
  public:
  void unsafe_arena_set_allocated_cpu_info(
      ::tensorflow::CPUInfo* cpu_info);
  ::tensorflow::CPUInfo* unsafe_arena_release_cpu_info();

  // .tensorflow.MemoryInfo memory_info = 6;
  bool has_memory_info() const;
  private:
  bool _internal_has_memory_info() const;
  public:
  void clear_memory_info();
  const ::tensorflow::MemoryInfo& memory_info() const;
  PROTOBUF_NODISCARD ::tensorflow::MemoryInfo* release_memory_info();
  ::tensorflow::MemoryInfo* mutable_memory_info();
  void set_allocated_memory_info(::tensorflow::MemoryInfo* memory_info);
  private:
  const ::tensorflow::MemoryInfo& _internal_memory_info() const;
  ::tensorflow::MemoryInfo* _internal_mutable_memory_info();
  public:
  void unsafe_arena_set_allocated_memory_info(
      ::tensorflow::MemoryInfo* memory_info);
  ::tensorflow::MemoryInfo* unsafe_arena_release_memory_info();

  // @@protoc_insertion_point(class_scope:tensorflow.MachineConfiguration)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any > device_info_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo > available_device_info_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hostname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serial_identifier_;
    ::tensorflow::PlatformInfo* platform_info_;
    ::tensorflow::CPUInfo* cpu_info_;
    ::tensorflow::MemoryInfo* memory_info_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class RunConfiguration_EnvVarsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RunConfiguration_EnvVarsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RunConfiguration_EnvVarsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
  RunConfiguration_EnvVarsEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR RunConfiguration_EnvVarsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit RunConfiguration_EnvVarsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const RunConfiguration_EnvVarsEntry_DoNotUse& other);
  static const RunConfiguration_EnvVarsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const RunConfiguration_EnvVarsEntry_DoNotUse*>(&_RunConfiguration_EnvVarsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.RunConfiguration.EnvVarsEntry.key");
 }
  static bool ValidateValue(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.RunConfiguration.EnvVarsEntry.value");
 }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};

// -------------------------------------------------------------------

class RunConfiguration final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.RunConfiguration) */ {
 public:
  inline RunConfiguration() : RunConfiguration(nullptr) {}
  ~RunConfiguration() override;
  explicit PROTOBUF_CONSTEXPR RunConfiguration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RunConfiguration(const RunConfiguration& from);
  RunConfiguration(RunConfiguration&& from) noexcept
    : RunConfiguration() {
    *this = ::std::move(from);
  }

  inline RunConfiguration& operator=(const RunConfiguration& from) {
    CopyFrom(from);
    return *this;
  }
  inline RunConfiguration& operator=(RunConfiguration&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RunConfiguration& default_instance() {
    return *internal_default_instance();
  }
  static inline const RunConfiguration* internal_default_instance() {
    return reinterpret_cast<const RunConfiguration*>(
               &_RunConfiguration_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(RunConfiguration& a, RunConfiguration& b) {
    a.Swap(&b);
  }
  inline void Swap(RunConfiguration* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RunConfiguration* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RunConfiguration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RunConfiguration>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RunConfiguration& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RunConfiguration& from) {
    RunConfiguration::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RunConfiguration* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.RunConfiguration";
  }
  protected:
  explicit RunConfiguration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kArgumentFieldNumber = 1,
    kEnvVarsFieldNumber = 2,
  };
  // repeated string argument = 1;
  int argument_size() const;
  private:
  int _internal_argument_size() const;
  public:
  void clear_argument();
  const std::string& argument(int index) const;
  std::string* mutable_argument(int index);
  void set_argument(int index, const std::string& value);
  void set_argument(int index, std::string&& value);
  void set_argument(int index, const char* value);
  void set_argument(int index, const char* value, size_t size);
  std::string* add_argument();
  void add_argument(const std::string& value);
  void add_argument(std::string&& value);
  void add_argument(const char* value);
  void add_argument(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& argument() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_argument();
  private:
  const std::string& _internal_argument(int index) const;
  std::string* _internal_add_argument();
  public:

  // map<string, string> env_vars = 2;
  int env_vars_size() const;
  private:
  int _internal_env_vars_size() const;
  public:
  void clear_env_vars();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      _internal_env_vars() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      _internal_mutable_env_vars();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      env_vars() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      mutable_env_vars();

  // @@protoc_insertion_point(class_scope:tensorflow.RunConfiguration)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> argument_;
    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
        RunConfiguration_EnvVarsEntry_DoNotUse,
        std::string, std::string,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> env_vars_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// -------------------------------------------------------------------

class TestResults final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TestResults) */ {
 public:
  inline TestResults() : TestResults(nullptr) {}
  ~TestResults() override;
  explicit PROTOBUF_CONSTEXPR TestResults(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TestResults(const TestResults& from);
  TestResults(TestResults&& from) noexcept
    : TestResults() {
    *this = ::std::move(from);
  }

  inline TestResults& operator=(const TestResults& from) {
    CopyFrom(from);
    return *this;
  }
  inline TestResults& operator=(TestResults&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TestResults& default_instance() {
    return *internal_default_instance();
  }
  static inline const TestResults* internal_default_instance() {
    return reinterpret_cast<const TestResults*>(
               &_TestResults_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(TestResults& a, TestResults& b) {
    a.Swap(&b);
  }
  inline void Swap(TestResults* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TestResults* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TestResults* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TestResults>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TestResults& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TestResults& from) {
    TestResults::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestResults* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.TestResults";
  }
  protected:
  explicit TestResults(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestResults_BenchmarkType BenchmarkType;
  static constexpr BenchmarkType UNKNOWN =
    TestResults_BenchmarkType_UNKNOWN;
  static constexpr BenchmarkType CPP_MICROBENCHMARK =
    TestResults_BenchmarkType_CPP_MICROBENCHMARK;
  static constexpr BenchmarkType PYTHON_BENCHMARK =
    TestResults_BenchmarkType_PYTHON_BENCHMARK;
  static constexpr BenchmarkType ANDROID_BENCHMARK =
    TestResults_BenchmarkType_ANDROID_BENCHMARK;
  static constexpr BenchmarkType EDGE_BENCHMARK =
    TestResults_BenchmarkType_EDGE_BENCHMARK;
  static constexpr BenchmarkType IOS_BENCHMARK =
    TestResults_BenchmarkType_IOS_BENCHMARK;
  static inline bool BenchmarkType_IsValid(int value) {
    return TestResults_BenchmarkType_IsValid(value);
  }
  static constexpr BenchmarkType BenchmarkType_MIN =
    TestResults_BenchmarkType_BenchmarkType_MIN;
  static constexpr BenchmarkType BenchmarkType_MAX =
    TestResults_BenchmarkType_BenchmarkType_MAX;
  static constexpr int BenchmarkType_ARRAYSIZE =
    TestResults_BenchmarkType_BenchmarkType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  BenchmarkType_descriptor() {
    return TestResults_BenchmarkType_descriptor();
  }
  template<typename T>
  static inline const std::string& BenchmarkType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BenchmarkType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BenchmarkType_Name.");
    return TestResults_BenchmarkType_Name(enum_t_value);
  }
  static inline bool BenchmarkType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      BenchmarkType* value) {
    return TestResults_BenchmarkType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kTargetFieldNumber = 1,
    kNameFieldNumber = 9,
    kRunModeFieldNumber = 11,
    kTfVersionFieldNumber = 12,
    kEntriesFieldNumber = 2,
    kBuildConfigurationFieldNumber = 3,
    kCommitIdFieldNumber = 4,
    kMachineConfigurationFieldNumber = 7,
    kRunConfigurationFieldNumber = 8,
    kStartTimeFieldNumber = 5,
    kRunTimeFieldNumber = 6,
    kBenchmarkTypeFieldNumber = 10,
  };
  // string target = 1;
  void clear_target();
  const std::string& target() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_target(ArgT0&& arg0, ArgT... args);
  std::string* mutable_target();
  PROTOBUF_NODISCARD std::string* release_target();
  void set_allocated_target(std::string* target);
  private:
  const std::string& _internal_target() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_target(const std::string& value);
  std::string* _internal_mutable_target();
  public:

  // string name = 9;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string run_mode = 11;
  void clear_run_mode();
  const std::string& run_mode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_run_mode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_run_mode();
  PROTOBUF_NODISCARD std::string* release_run_mode();
  void set_allocated_run_mode(std::string* run_mode);
  private:
  const std::string& _internal_run_mode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_run_mode(const std::string& value);
  std::string* _internal_mutable_run_mode();
  public:

  // string tf_version = 12;
  void clear_tf_version();
  const std::string& tf_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tf_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tf_version();
  PROTOBUF_NODISCARD std::string* release_tf_version();
  void set_allocated_tf_version(std::string* tf_version);
  private:
  const std::string& _internal_tf_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tf_version(const std::string& value);
  std::string* _internal_mutable_tf_version();
  public:

  // .tensorflow.BenchmarkEntries entries = 2;
  bool has_entries() const;
  private:
  bool _internal_has_entries() const;
  public:
  void clear_entries();
  const ::tensorflow::BenchmarkEntries& entries() const;
  PROTOBUF_NODISCARD ::tensorflow::BenchmarkEntries* release_entries();
  ::tensorflow::BenchmarkEntries* mutable_entries();
  void set_allocated_entries(::tensorflow::BenchmarkEntries* entries);
  private:
  const ::tensorflow::BenchmarkEntries& _internal_entries() const;
  ::tensorflow::BenchmarkEntries* _internal_mutable_entries();
  public:
  void unsafe_arena_set_allocated_entries(
      ::tensorflow::BenchmarkEntries* entries);
  ::tensorflow::BenchmarkEntries* unsafe_arena_release_entries();

  // .tensorflow.BuildConfiguration build_configuration = 3;
  bool has_build_configuration() const;
  private:
  bool _internal_has_build_configuration() const;
  public:
  void clear_build_configuration();
  const ::tensorflow::BuildConfiguration& build_configuration() const;
  PROTOBUF_NODISCARD ::tensorflow::BuildConfiguration* release_build_configuration();
  ::tensorflow::BuildConfiguration* mutable_build_configuration();
  void set_allocated_build_configuration(::tensorflow::BuildConfiguration* build_configuration);
  private:
  const ::tensorflow::BuildConfiguration& _internal_build_configuration() const;
  ::tensorflow::BuildConfiguration* _internal_mutable_build_configuration();
  public:
  void unsafe_arena_set_allocated_build_configuration(
      ::tensorflow::BuildConfiguration* build_configuration);
  ::tensorflow::BuildConfiguration* unsafe_arena_release_build_configuration();

  // .tensorflow.CommitId commit_id = 4;
  bool has_commit_id() const;
  private:
  bool _internal_has_commit_id() const;
  public:
  void clear_commit_id();
  const ::tensorflow::CommitId& commit_id() const;
  PROTOBUF_NODISCARD ::tensorflow::CommitId* release_commit_id();
  ::tensorflow::CommitId* mutable_commit_id();
  void set_allocated_commit_id(::tensorflow::CommitId* commit_id);
  private:
  const ::tensorflow::CommitId& _internal_commit_id() const;
  ::tensorflow::CommitId* _internal_mutable_commit_id();
  public:
  void unsafe_arena_set_allocated_commit_id(
      ::tensorflow::CommitId* commit_id);
  ::tensorflow::CommitId* unsafe_arena_release_commit_id();

  // .tensorflow.MachineConfiguration machine_configuration = 7;
  bool has_machine_configuration() const;
  private:
  bool _internal_has_machine_configuration() const;
  public:
  void clear_machine_configuration();
  const ::tensorflow::MachineConfiguration& machine_configuration() const;
  PROTOBUF_NODISCARD ::tensorflow::MachineConfiguration* release_machine_configuration();
  ::tensorflow::MachineConfiguration* mutable_machine_configuration();
  void set_allocated_machine_configuration(::tensorflow::MachineConfiguration* machine_configuration);
  private:
  const ::tensorflow::MachineConfiguration& _internal_machine_configuration() const;
  ::tensorflow::MachineConfiguration* _internal_mutable_machine_configuration();
  public:
  void unsafe_arena_set_allocated_machine_configuration(
      ::tensorflow::MachineConfiguration* machine_configuration);
  ::tensorflow::MachineConfiguration* unsafe_arena_release_machine_configuration();

  // .tensorflow.RunConfiguration run_configuration = 8;
  bool has_run_configuration() const;
  private:
  bool _internal_has_run_configuration() const;
  public:
  void clear_run_configuration();
  const ::tensorflow::RunConfiguration& run_configuration() const;
  PROTOBUF_NODISCARD ::tensorflow::RunConfiguration* release_run_configuration();
  ::tensorflow::RunConfiguration* mutable_run_configuration();
  void set_allocated_run_configuration(::tensorflow::RunConfiguration* run_configuration);
  private:
  const ::tensorflow::RunConfiguration& _internal_run_configuration() const;
  ::tensorflow::RunConfiguration* _internal_mutable_run_configuration();
  public:
  void unsafe_arena_set_allocated_run_configuration(
      ::tensorflow::RunConfiguration* run_configuration);
  ::tensorflow::RunConfiguration* unsafe_arena_release_run_configuration();

  // int64 start_time = 5;
  void clear_start_time();
  int64_t start_time() const;
  void set_start_time(int64_t value);
  private:
  int64_t _internal_start_time() const;
  void _internal_set_start_time(int64_t value);
  public:

  // double run_time = 6;
  void clear_run_time();
  double run_time() const;
  void set_run_time(double value);
  private:
  double _internal_run_time() const;
  void _internal_set_run_time(double value);
  public:

  // .tensorflow.TestResults.BenchmarkType benchmark_type = 10;
  void clear_benchmark_type();
  ::tensorflow::TestResults_BenchmarkType benchmark_type() const;
  void set_benchmark_type(::tensorflow::TestResults_BenchmarkType value);
  private:
  ::tensorflow::TestResults_BenchmarkType _internal_benchmark_type() const;
  void _internal_set_benchmark_type(::tensorflow::TestResults_BenchmarkType value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.TestResults)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr target_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr run_mode_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tf_version_;
    ::tensorflow::BenchmarkEntries* entries_;
    ::tensorflow::BuildConfiguration* build_configuration_;
    ::tensorflow::CommitId* commit_id_;
    ::tensorflow::MachineConfiguration* machine_configuration_;
    ::tensorflow::RunConfiguration* run_configuration_;
    int64_t start_time_;
    double run_time_;
    int benchmark_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tsl_2fprotobuf_2ftest_5flog_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// EntryValue

// double double_value = 1;
inline bool EntryValue::_internal_has_double_value() const {
  return kind_case() == kDoubleValue;
}
inline bool EntryValue::has_double_value() const {
  return _internal_has_double_value();
}
inline void EntryValue::set_has_double_value() {
  _impl_._oneof_case_[0] = kDoubleValue;
}
inline void EntryValue::clear_double_value() {
  if (_internal_has_double_value()) {
    _impl_.kind_.double_value_ = 0;
    clear_has_kind();
  }
}
inline double EntryValue::_internal_double_value() const {
  if (_internal_has_double_value()) {
    return _impl_.kind_.double_value_;
  }
  return 0;
}
inline void EntryValue::_internal_set_double_value(double value) {
  if (!_internal_has_double_value()) {
    clear_kind();
    set_has_double_value();
  }
  _impl_.kind_.double_value_ = value;
}
inline double EntryValue::double_value() const {
  // @@protoc_insertion_point(field_get:tensorflow.EntryValue.double_value)
  return _internal_double_value();
}
inline void EntryValue::set_double_value(double value) {
  _internal_set_double_value(value);
  // @@protoc_insertion_point(field_set:tensorflow.EntryValue.double_value)
}

// string string_value = 2;
inline bool EntryValue::_internal_has_string_value() const {
  return kind_case() == kStringValue;
}
inline bool EntryValue::has_string_value() const {
  return _internal_has_string_value();
}
inline void EntryValue::set_has_string_value() {
  _impl_._oneof_case_[0] = kStringValue;
}
inline void EntryValue::clear_string_value() {
  if (_internal_has_string_value()) {
    _impl_.kind_.string_value_.Destroy();
    clear_has_kind();
  }
}
inline const std::string& EntryValue::string_value() const {
  // @@protoc_insertion_point(field_get:tensorflow.EntryValue.string_value)
  return _internal_string_value();
}
template <typename ArgT0, typename... ArgT>
inline void EntryValue::set_string_value(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_string_value()) {
    clear_kind();
    set_has_string_value();
    _impl_.kind_.string_value_.InitDefault();
  }
  _impl_.kind_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.EntryValue.string_value)
}
inline std::string* EntryValue::mutable_string_value() {
  std::string* _s = _internal_mutable_string_value();
  // @@protoc_insertion_point(field_mutable:tensorflow.EntryValue.string_value)
  return _s;
}
inline const std::string& EntryValue::_internal_string_value() const {
  if (_internal_has_string_value()) {
    return _impl_.kind_.string_value_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void EntryValue::_internal_set_string_value(const std::string& value) {
  if (!_internal_has_string_value()) {
    clear_kind();
    set_has_string_value();
    _impl_.kind_.string_value_.InitDefault();
  }
  _impl_.kind_.string_value_.Set(value, GetArenaForAllocation());
}
inline std::string* EntryValue::_internal_mutable_string_value() {
  if (!_internal_has_string_value()) {
    clear_kind();
    set_has_string_value();
    _impl_.kind_.string_value_.InitDefault();
  }
  return _impl_.kind_.string_value_.Mutable(      GetArenaForAllocation());
}
inline std::string* EntryValue::release_string_value() {
  // @@protoc_insertion_point(field_release:tensorflow.EntryValue.string_value)
  if (_internal_has_string_value()) {
    clear_has_kind();
    return _impl_.kind_.string_value_.Release();
  } else {
    return nullptr;
  }
}
inline void EntryValue::set_allocated_string_value(std::string* string_value) {
  if (has_kind()) {
    clear_kind();
  }
  if (string_value != nullptr) {
    set_has_string_value();
    _impl_.kind_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.EntryValue.string_value)
}

inline bool EntryValue::has_kind() const {
  return kind_case() != KIND_NOT_SET;
}
inline void EntryValue::clear_has_kind() {
  _impl_._oneof_case_[0] = KIND_NOT_SET;
}
inline EntryValue::KindCase EntryValue::kind_case() const {
  return EntryValue::KindCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// MetricEntry

// string name = 1;
inline void MetricEntry::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& MetricEntry::name() const {
  // @@protoc_insertion_point(field_get:tensorflow.MetricEntry.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MetricEntry::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.MetricEntry.name)
}
inline std::string* MetricEntry::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:tensorflow.MetricEntry.name)
  return _s;
}
inline const std::string& MetricEntry::_internal_name() const {
  return _impl_.name_.Get();
}
inline void MetricEntry::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* MetricEntry::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* MetricEntry::release_name() {
  // @@protoc_insertion_point(field_release:tensorflow.MetricEntry.name)
  return _impl_.name_.Release();
}
inline void MetricEntry::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.MetricEntry.name)
}

// double value = 2;
inline void MetricEntry::clear_value() {
  _impl_.value_ = 0;
}
inline double MetricEntry::_internal_value() const {
  return _impl_.value_;
}
inline double MetricEntry::value() const {
  // @@protoc_insertion_point(field_get:tensorflow.MetricEntry.value)
  return _internal_value();
}
inline void MetricEntry::_internal_set_value(double value) {
  
  _impl_.value_ = value;
}
inline void MetricEntry::set_value(double value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:tensorflow.MetricEntry.value)
}

// .google.protobuf.DoubleValue min_value = 3;
inline bool MetricEntry::_internal_has_min_value() const {
  return this != internal_default_instance() && _impl_.min_value_ != nullptr;
}
inline bool MetricEntry::has_min_value() const {
  return _internal_has_min_value();
}
inline const ::PROTOBUF_NAMESPACE_ID::DoubleValue& MetricEntry::_internal_min_value() const {
  const ::PROTOBUF_NAMESPACE_ID::DoubleValue* p = _impl_.min_value_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::DoubleValue&>(
      ::PROTOBUF_NAMESPACE_ID::_DoubleValue_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::DoubleValue& MetricEntry::min_value() const {
  // @@protoc_insertion_point(field_get:tensorflow.MetricEntry.min_value)
  return _internal_min_value();
}
inline void MetricEntry::unsafe_arena_set_allocated_min_value(
    ::PROTOBUF_NAMESPACE_ID::DoubleValue* min_value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.min_value_);
  }
  _impl_.min_value_ = min_value;
  if (min_value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MetricEntry.min_value)
}
inline ::PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::release_min_value() {
  
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* temp = _impl_.min_value_;
  _impl_.min_value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::unsafe_arena_release_min_value() {
  // @@protoc_insertion_point(field_release:tensorflow.MetricEntry.min_value)
  
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* temp = _impl_.min_value_;
  _impl_.min_value_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::_internal_mutable_min_value() {
  
  if (_impl_.min_value_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DoubleValue>(GetArenaForAllocation());
    _impl_.min_value_ = p;
  }
  return _impl_.min_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::mutable_min_value() {
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* _msg = _internal_mutable_min_value();
  // @@protoc_insertion_point(field_mutable:tensorflow.MetricEntry.min_value)
  return _msg;
}
inline void MetricEntry::set_allocated_min_value(::PROTOBUF_NAMESPACE_ID::DoubleValue* min_value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.min_value_);
  }
  if (min_value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_value));
    if (message_arena != submessage_arena) {
      min_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, min_value, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.min_value_ = min_value;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.MetricEntry.min_value)
}

// .google.protobuf.DoubleValue max_value = 4;
inline bool MetricEntry::_internal_has_max_value() const {
  return this != internal_default_instance() && _impl_.max_value_ != nullptr;
}
inline bool MetricEntry::has_max_value() const {
  return _internal_has_max_value();
}
inline const ::PROTOBUF_NAMESPACE_ID::DoubleValue& MetricEntry::_internal_max_value() const {
  const ::PROTOBUF_NAMESPACE_ID::DoubleValue* p = _impl_.max_value_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::DoubleValue&>(
      ::PROTOBUF_NAMESPACE_ID::_DoubleValue_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::DoubleValue& MetricEntry::max_value() const {
  // @@protoc_insertion_point(field_get:tensorflow.MetricEntry.max_value)
  return _internal_max_value();
}
inline void MetricEntry::unsafe_arena_set_allocated_max_value(
    ::PROTOBUF_NAMESPACE_ID::DoubleValue* max_value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.max_value_);
  }
  _impl_.max_value_ = max_value;
  if (max_value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MetricEntry.max_value)
}
inline ::PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::release_max_value() {
  
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* temp = _impl_.max_value_;
  _impl_.max_value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::unsafe_arena_release_max_value() {
  // @@protoc_insertion_point(field_release:tensorflow.MetricEntry.max_value)
  
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* temp = _impl_.max_value_;
  _impl_.max_value_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::_internal_mutable_max_value() {
  
  if (_impl_.max_value_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DoubleValue>(GetArenaForAllocation());
    _impl_.max_value_ = p;
  }
  return _impl_.max_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::mutable_max_value() {
  ::PROTOBUF_NAMESPACE_ID::DoubleValue* _msg = _internal_mutable_max_value();
  // @@protoc_insertion_point(field_mutable:tensorflow.MetricEntry.max_value)
  return _msg;
}
inline void MetricEntry::set_allocated_max_value(::PROTOBUF_NAMESPACE_ID::DoubleValue* max_value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.max_value_);
  }
  if (max_value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(max_value));
    if (message_arena != submessage_arena) {
      max_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, max_value, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.max_value_ = max_value;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.MetricEntry.max_value)
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// BenchmarkEntry

// string name = 1;
inline void BenchmarkEntry::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& BenchmarkEntry::name() const {
  // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BenchmarkEntry::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.name)
}
inline std::string* BenchmarkEntry::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:tensorflow.BenchmarkEntry.name)
  return _s;
}
inline const std::string& BenchmarkEntry::_internal_name() const {
  return _impl_.name_.Get();
}
inline void BenchmarkEntry::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* BenchmarkEntry::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* BenchmarkEntry::release_name() {
  // @@protoc_insertion_point(field_release:tensorflow.BenchmarkEntry.name)
  return _impl_.name_.Release();
}
inline void BenchmarkEntry::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.BenchmarkEntry.name)
}

// int64 iters = 2;
inline void BenchmarkEntry::clear_iters() {
  _impl_.iters_ = int64_t{0};
}
inline int64_t BenchmarkEntry::_internal_iters() const {
  return _impl_.iters_;
}
inline int64_t BenchmarkEntry::iters() const {
  // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.iters)
  return _internal_iters();
}
inline void BenchmarkEntry::_internal_set_iters(int64_t value) {
  
  _impl_.iters_ = value;
}
inline void BenchmarkEntry::set_iters(int64_t value) {
  _internal_set_iters(value);
  // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.iters)
}

// double cpu_time = 3;
inline void BenchmarkEntry::clear_cpu_time() {
  _impl_.cpu_time_ = 0;
}
inline double BenchmarkEntry::_internal_cpu_time() const {
  return _impl_.cpu_time_;
}
inline double BenchmarkEntry::cpu_time() const {
  // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.cpu_time)
  return _internal_cpu_time();
}
inline void BenchmarkEntry::_internal_set_cpu_time(double value) {
  
  _impl_.cpu_time_ = value;
}
inline void BenchmarkEntry::set_cpu_time(double value) {
  _internal_set_cpu_time(value);
  // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.cpu_time)
}

// double wall_time = 4;
inline void BenchmarkEntry::clear_wall_time() {
  _impl_.wall_time_ = 0;
}
inline double BenchmarkEntry::_internal_wall_time() const {
  return _impl_.wall_time_;
}
inline double BenchmarkEntry::wall_time() const {
  // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.wall_time)
  return _internal_wall_time();
}
inline void BenchmarkEntry::_internal_set_wall_time(double value) {
  
  _impl_.wall_time_ = value;
}
inline void BenchmarkEntry::set_wall_time(double value) {
  _internal_set_wall_time(value);
  // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.wall_time)
}

// double throughput = 5;
inline void BenchmarkEntry::clear_throughput() {
  _impl_.throughput_ = 0;
}
inline double BenchmarkEntry::_internal_throughput() const {
  return _impl_.throughput_;
}
inline double BenchmarkEntry::throughput() const {
  // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.throughput)
  return _internal_throughput();
}
inline void BenchmarkEntry::_internal_set_throughput(double value) {
  
  _impl_.throughput_ = value;
}
inline void BenchmarkEntry::set_throughput(double value) {
  _internal_set_throughput(value);
  // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.throughput)
}

// map<string, .tensorflow.EntryValue> extras = 6;
inline int BenchmarkEntry::_internal_extras_size() const {
  return _impl_.extras_.size();
}
inline int BenchmarkEntry::extras_size() const {
  return _internal_extras_size();
}
inline void BenchmarkEntry::clear_extras() {
  _impl_.extras_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >&
BenchmarkEntry::_internal_extras() const {
  return _impl_.extras_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >&
BenchmarkEntry::extras() const {
  // @@protoc_insertion_point(field_map:tensorflow.BenchmarkEntry.extras)
  return _internal_extras();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >*
BenchmarkEntry::_internal_mutable_extras() {
  return _impl_.extras_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >*
BenchmarkEntry::mutable_extras() {
  // @@protoc_insertion_point(field_mutable_map:tensorflow.BenchmarkEntry.extras)
  return _internal_mutable_extras();
}

// repeated .tensorflow.MetricEntry metrics = 7;
inline int BenchmarkEntry::_internal_metrics_size() const {
  return _impl_.metrics_.size();
}
inline int BenchmarkEntry::metrics_size() const {
  return _internal_metrics_size();
}
inline void BenchmarkEntry::clear_metrics() {
  _impl_.metrics_.Clear();
}
inline ::tensorflow::MetricEntry* BenchmarkEntry::mutable_metrics(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.BenchmarkEntry.metrics)
  return _impl_.metrics_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry >*
BenchmarkEntry::mutable_metrics() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.BenchmarkEntry.metrics)
  return &_impl_.metrics_;
}
inline const ::tensorflow::MetricEntry& BenchmarkEntry::_internal_metrics(int index) const {
  return _impl_.metrics_.Get(index);
}
inline const ::tensorflow::MetricEntry& BenchmarkEntry::metrics(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.metrics)
  return _internal_metrics(index);
}
inline ::tensorflow::MetricEntry* BenchmarkEntry::_internal_add_metrics() {
  return _impl_.metrics_.Add();
}
inline ::tensorflow::MetricEntry* BenchmarkEntry::add_metrics() {
  ::tensorflow::MetricEntry* _add = _internal_add_metrics();
  // @@protoc_insertion_point(field_add:tensorflow.BenchmarkEntry.metrics)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry >&
BenchmarkEntry::metrics() const {
  // @@protoc_insertion_point(field_list:tensorflow.BenchmarkEntry.metrics)
  return _impl_.metrics_;
}

// -------------------------------------------------------------------

// BenchmarkEntries

// repeated .tensorflow.BenchmarkEntry entry = 1;
inline int BenchmarkEntries::_internal_entry_size() const {
  return _impl_.entry_.size();
}
inline int BenchmarkEntries::entry_size() const {
  return _internal_entry_size();
}
inline void BenchmarkEntries::clear_entry() {
  _impl_.entry_.Clear();
}
inline ::tensorflow::BenchmarkEntry* BenchmarkEntries::mutable_entry(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.BenchmarkEntries.entry)
  return _impl_.entry_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry >*
BenchmarkEntries::mutable_entry() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.BenchmarkEntries.entry)
  return &_impl_.entry_;
}
inline const ::tensorflow::BenchmarkEntry& BenchmarkEntries::_internal_entry(int index) const {
  return _impl_.entry_.Get(index);
}
inline const ::tensorflow::BenchmarkEntry& BenchmarkEntries::entry(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntries.entry)
  return _internal_entry(index);
}
inline ::tensorflow::BenchmarkEntry* BenchmarkEntries::_internal_add_entry() {
  return _impl_.entry_.Add();
}
inline ::tensorflow::BenchmarkEntry* BenchmarkEntries::add_entry() {
  ::tensorflow::BenchmarkEntry* _add = _internal_add_entry();
  // @@protoc_insertion_point(field_add:tensorflow.BenchmarkEntries.entry)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry >&
BenchmarkEntries::entry() const {
  // @@protoc_insertion_point(field_list:tensorflow.BenchmarkEntries.entry)
  return _impl_.entry_;
}

// -------------------------------------------------------------------

// BuildConfiguration

// string mode = 1;
inline void BuildConfiguration::clear_mode() {
  _impl_.mode_.ClearToEmpty();
}
inline const std::string& BuildConfiguration::mode() const {
  // @@protoc_insertion_point(field_get:tensorflow.BuildConfiguration.mode)
  return _internal_mode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BuildConfiguration::set_mode(ArgT0&& arg0, ArgT... args) {
 
 _impl_.mode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.mode)
}
inline std::string* BuildConfiguration::mutable_mode() {
  std::string* _s = _internal_mutable_mode();
  // @@protoc_insertion_point(field_mutable:tensorflow.BuildConfiguration.mode)
  return _s;
}
inline const std::string& BuildConfiguration::_internal_mode() const {
  return _impl_.mode_.Get();
}
inline void BuildConfiguration::_internal_set_mode(const std::string& value) {
  
  _impl_.mode_.Set(value, GetArenaForAllocation());
}
inline std::string* BuildConfiguration::_internal_mutable_mode() {
  
  return _impl_.mode_.Mutable(GetArenaForAllocation());
}
inline std::string* BuildConfiguration::release_mode() {
  // @@protoc_insertion_point(field_release:tensorflow.BuildConfiguration.mode)
  return _impl_.mode_.Release();
}
inline void BuildConfiguration::set_allocated_mode(std::string* mode) {
  if (mode != nullptr) {
    
  } else {
    
  }
  _impl_.mode_.SetAllocated(mode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mode_.IsDefault()) {
    _impl_.mode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.BuildConfiguration.mode)
}

// repeated string cc_flags = 2;
inline int BuildConfiguration::_internal_cc_flags_size() const {
  return _impl_.cc_flags_.size();
}
inline int BuildConfiguration::cc_flags_size() const {
  return _internal_cc_flags_size();
}
inline void BuildConfiguration::clear_cc_flags() {
  _impl_.cc_flags_.Clear();
}
inline std::string* BuildConfiguration::add_cc_flags() {
  std::string* _s = _internal_add_cc_flags();
  // @@protoc_insertion_point(field_add_mutable:tensorflow.BuildConfiguration.cc_flags)
  return _s;
}
inline const std::string& BuildConfiguration::_internal_cc_flags(int index) const {
  return _impl_.cc_flags_.Get(index);
}
inline const std::string& BuildConfiguration::cc_flags(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.BuildConfiguration.cc_flags)
  return _internal_cc_flags(index);
}
inline std::string* BuildConfiguration::mutable_cc_flags(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.BuildConfiguration.cc_flags)
  return _impl_.cc_flags_.Mutable(index);
}
inline void BuildConfiguration::set_cc_flags(int index, const std::string& value) {
  _impl_.cc_flags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.cc_flags)
}
inline void BuildConfiguration::set_cc_flags(int index, std::string&& value) {
  _impl_.cc_flags_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.cc_flags)
}
inline void BuildConfiguration::set_cc_flags(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.cc_flags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:tensorflow.BuildConfiguration.cc_flags)
}
inline void BuildConfiguration::set_cc_flags(int index, const char* value, size_t size) {
  _impl_.cc_flags_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:tensorflow.BuildConfiguration.cc_flags)
}
inline std::string* BuildConfiguration::_internal_add_cc_flags() {
  return _impl_.cc_flags_.Add();
}
inline void BuildConfiguration::add_cc_flags(const std::string& value) {
  _impl_.cc_flags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:tensorflow.BuildConfiguration.cc_flags)
}
inline void BuildConfiguration::add_cc_flags(std::string&& value) {
  _impl_.cc_flags_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:tensorflow.BuildConfiguration.cc_flags)
}
inline void BuildConfiguration::add_cc_flags(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.cc_flags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:tensorflow.BuildConfiguration.cc_flags)
}
inline void BuildConfiguration::add_cc_flags(const char* value, size_t size) {
  _impl_.cc_flags_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:tensorflow.BuildConfiguration.cc_flags)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
BuildConfiguration::cc_flags() const {
  // @@protoc_insertion_point(field_list:tensorflow.BuildConfiguration.cc_flags)
  return _impl_.cc_flags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
BuildConfiguration::mutable_cc_flags() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.BuildConfiguration.cc_flags)
  return &_impl_.cc_flags_;
}

// repeated string opts = 3;
inline int BuildConfiguration::_internal_opts_size() const {
  return _impl_.opts_.size();
}
inline int BuildConfiguration::opts_size() const {
  return _internal_opts_size();
}
inline void BuildConfiguration::clear_opts() {
  _impl_.opts_.Clear();
}
inline std::string* BuildConfiguration::add_opts() {
  std::string* _s = _internal_add_opts();
  // @@protoc_insertion_point(field_add_mutable:tensorflow.BuildConfiguration.opts)
  return _s;
}
inline const std::string& BuildConfiguration::_internal_opts(int index) const {
  return _impl_.opts_.Get(index);
}
inline const std::string& BuildConfiguration::opts(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.BuildConfiguration.opts)
  return _internal_opts(index);
}
inline std::string* BuildConfiguration::mutable_opts(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.BuildConfiguration.opts)
  return _impl_.opts_.Mutable(index);
}
inline void BuildConfiguration::set_opts(int index, const std::string& value) {
  _impl_.opts_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.opts)
}
inline void BuildConfiguration::set_opts(int index, std::string&& value) {
  _impl_.opts_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.opts)
}
inline void BuildConfiguration::set_opts(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.opts_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:tensorflow.BuildConfiguration.opts)
}
inline void BuildConfiguration::set_opts(int index, const char* value, size_t size) {
  _impl_.opts_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:tensorflow.BuildConfiguration.opts)
}
inline std::string* BuildConfiguration::_internal_add_opts() {
  return _impl_.opts_.Add();
}
inline void BuildConfiguration::add_opts(const std::string& value) {
  _impl_.opts_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:tensorflow.BuildConfiguration.opts)
}
inline void BuildConfiguration::add_opts(std::string&& value) {
  _impl_.opts_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:tensorflow.BuildConfiguration.opts)
}
inline void BuildConfiguration::add_opts(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.opts_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:tensorflow.BuildConfiguration.opts)
}
inline void BuildConfiguration::add_opts(const char* value, size_t size) {
  _impl_.opts_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:tensorflow.BuildConfiguration.opts)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
BuildConfiguration::opts() const {
  // @@protoc_insertion_point(field_list:tensorflow.BuildConfiguration.opts)
  return _impl_.opts_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
BuildConfiguration::mutable_opts() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.BuildConfiguration.opts)
  return &_impl_.opts_;
}

// -------------------------------------------------------------------

// CommitId

// int64 changelist = 1;
inline bool CommitId::_internal_has_changelist() const {
  return kind_case() == kChangelist;
}
inline bool CommitId::has_changelist() const {
  return _internal_has_changelist();
}
inline void CommitId::set_has_changelist() {
  _impl_._oneof_case_[0] = kChangelist;
}
inline void CommitId::clear_changelist() {
  if (_internal_has_changelist()) {
    _impl_.kind_.changelist_ = int64_t{0};
    clear_has_kind();
  }
}
inline int64_t CommitId::_internal_changelist() const {
  if (_internal_has_changelist()) {
    return _impl_.kind_.changelist_;
  }
  return int64_t{0};
}
inline void CommitId::_internal_set_changelist(int64_t value) {
  if (!_internal_has_changelist()) {
    clear_kind();
    set_has_changelist();
  }
  _impl_.kind_.changelist_ = value;
}
inline int64_t CommitId::changelist() const {
  // @@protoc_insertion_point(field_get:tensorflow.CommitId.changelist)
  return _internal_changelist();
}
inline void CommitId::set_changelist(int64_t value) {
  _internal_set_changelist(value);
  // @@protoc_insertion_point(field_set:tensorflow.CommitId.changelist)
}

// string hash = 2;
inline bool CommitId::_internal_has_hash() const {
  return kind_case() == kHash;
}
inline bool CommitId::has_hash() const {
  return _internal_has_hash();
}
inline void CommitId::set_has_hash() {
  _impl_._oneof_case_[0] = kHash;
}
inline void CommitId::clear_hash() {
  if (_internal_has_hash()) {
    _impl_.kind_.hash_.Destroy();
    clear_has_kind();
  }
}
inline const std::string& CommitId::hash() const {
  // @@protoc_insertion_point(field_get:tensorflow.CommitId.hash)
  return _internal_hash();
}
template <typename ArgT0, typename... ArgT>
inline void CommitId::set_hash(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_hash()) {
    clear_kind();
    set_has_hash();
    _impl_.kind_.hash_.InitDefault();
  }
  _impl_.kind_.hash_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.CommitId.hash)
}
inline std::string* CommitId::mutable_hash() {
  std::string* _s = _internal_mutable_hash();
  // @@protoc_insertion_point(field_mutable:tensorflow.CommitId.hash)
  return _s;
}
inline const std::string& CommitId::_internal_hash() const {
  if (_internal_has_hash()) {
    return _impl_.kind_.hash_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void CommitId::_internal_set_hash(const std::string& value) {
  if (!_internal_has_hash()) {
    clear_kind();
    set_has_hash();
    _impl_.kind_.hash_.InitDefault();
  }
  _impl_.kind_.hash_.Set(value, GetArenaForAllocation());
}
inline std::string* CommitId::_internal_mutable_hash() {
  if (!_internal_has_hash()) {
    clear_kind();
    set_has_hash();
    _impl_.kind_.hash_.InitDefault();
  }
  return _impl_.kind_.hash_.Mutable(      GetArenaForAllocation());
}
inline std::string* CommitId::release_hash() {
  // @@protoc_insertion_point(field_release:tensorflow.CommitId.hash)
  if (_internal_has_hash()) {
    clear_has_kind();
    return _impl_.kind_.hash_.Release();
  } else {
    return nullptr;
  }
}
inline void CommitId::set_allocated_hash(std::string* hash) {
  if (has_kind()) {
    clear_kind();
  }
  if (hash != nullptr) {
    set_has_hash();
    _impl_.kind_.hash_.InitAllocated(hash, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.CommitId.hash)
}

// string snapshot = 3;
inline void CommitId::clear_snapshot() {
  _impl_.snapshot_.ClearToEmpty();
}
inline const std::string& CommitId::snapshot() const {
  // @@protoc_insertion_point(field_get:tensorflow.CommitId.snapshot)
  return _internal_snapshot();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CommitId::set_snapshot(ArgT0&& arg0, ArgT... args) {
 
 _impl_.snapshot_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.CommitId.snapshot)
}
inline std::string* CommitId::mutable_snapshot() {
  std::string* _s = _internal_mutable_snapshot();
  // @@protoc_insertion_point(field_mutable:tensorflow.CommitId.snapshot)
  return _s;
}
inline const std::string& CommitId::_internal_snapshot() const {
  return _impl_.snapshot_.Get();
}
inline void CommitId::_internal_set_snapshot(const std::string& value) {
  
  _impl_.snapshot_.Set(value, GetArenaForAllocation());
}
inline std::string* CommitId::_internal_mutable_snapshot() {
  
  return _impl_.snapshot_.Mutable(GetArenaForAllocation());
}
inline std::string* CommitId::release_snapshot() {
  // @@protoc_insertion_point(field_release:tensorflow.CommitId.snapshot)
  return _impl_.snapshot_.Release();
}
inline void CommitId::set_allocated_snapshot(std::string* snapshot) {
  if (snapshot != nullptr) {
    
  } else {
    
  }
  _impl_.snapshot_.SetAllocated(snapshot, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.snapshot_.IsDefault()) {
    _impl_.snapshot_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.CommitId.snapshot)
}

// int64 pending_changelist = 4;
inline void CommitId::clear_pending_changelist() {
  _impl_.pending_changelist_ = int64_t{0};
}
inline int64_t CommitId::_internal_pending_changelist() const {
  return _impl_.pending_changelist_;
}
inline int64_t CommitId::pending_changelist() const {
  // @@protoc_insertion_point(field_get:tensorflow.CommitId.pending_changelist)
  return _internal_pending_changelist();
}
inline void CommitId::_internal_set_pending_changelist(int64_t value) {
  
  _impl_.pending_changelist_ = value;
}
inline void CommitId::set_pending_changelist(int64_t value) {
  _internal_set_pending_changelist(value);
  // @@protoc_insertion_point(field_set:tensorflow.CommitId.pending_changelist)
}

inline bool CommitId::has_kind() const {
  return kind_case() != KIND_NOT_SET;
}
inline void CommitId::clear_has_kind() {
  _impl_._oneof_case_[0] = KIND_NOT_SET;
}
inline CommitId::KindCase CommitId::kind_case() const {
  return CommitId::KindCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// CPUInfo

// int64 num_cores = 1;
inline void CPUInfo::clear_num_cores() {
  _impl_.num_cores_ = int64_t{0};
}
inline int64_t CPUInfo::_internal_num_cores() const {
  return _impl_.num_cores_;
}
inline int64_t CPUInfo::num_cores() const {
  // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.num_cores)
  return _internal_num_cores();
}
inline void CPUInfo::_internal_set_num_cores(int64_t value) {
  
  _impl_.num_cores_ = value;
}
inline void CPUInfo::set_num_cores(int64_t value) {
  _internal_set_num_cores(value);
  // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.num_cores)
}

// int64 num_cores_allowed = 2;
inline void CPUInfo::clear_num_cores_allowed() {
  _impl_.num_cores_allowed_ = int64_t{0};
}
inline int64_t CPUInfo::_internal_num_cores_allowed() const {
  return _impl_.num_cores_allowed_;
}
inline int64_t CPUInfo::num_cores_allowed() const {
  // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.num_cores_allowed)
  return _internal_num_cores_allowed();
}
inline void CPUInfo::_internal_set_num_cores_allowed(int64_t value) {
  
  _impl_.num_cores_allowed_ = value;
}
inline void CPUInfo::set_num_cores_allowed(int64_t value) {
  _internal_set_num_cores_allowed(value);
  // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.num_cores_allowed)
}

// double mhz_per_cpu = 3;
inline void CPUInfo::clear_mhz_per_cpu() {
  _impl_.mhz_per_cpu_ = 0;
}
inline double CPUInfo::_internal_mhz_per_cpu() const {
  return _impl_.mhz_per_cpu_;
}
inline double CPUInfo::mhz_per_cpu() const {
  // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.mhz_per_cpu)
  return _internal_mhz_per_cpu();
}
inline void CPUInfo::_internal_set_mhz_per_cpu(double value) {
  
  _impl_.mhz_per_cpu_ = value;
}
inline void CPUInfo::set_mhz_per_cpu(double value) {
  _internal_set_mhz_per_cpu(value);
  // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.mhz_per_cpu)
}

// string cpu_info = 4;
inline void CPUInfo::clear_cpu_info() {
  _impl_.cpu_info_.ClearToEmpty();
}
inline const std::string& CPUInfo::cpu_info() const {
  // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.cpu_info)
  return _internal_cpu_info();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CPUInfo::set_cpu_info(ArgT0&& arg0, ArgT... args) {
 
 _impl_.cpu_info_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.cpu_info)
}
inline std::string* CPUInfo::mutable_cpu_info() {
  std::string* _s = _internal_mutable_cpu_info();
  // @@protoc_insertion_point(field_mutable:tensorflow.CPUInfo.cpu_info)
  return _s;
}
inline const std::string& CPUInfo::_internal_cpu_info() const {
  return _impl_.cpu_info_.Get();
}
inline void CPUInfo::_internal_set_cpu_info(const std::string& value) {
  
  _impl_.cpu_info_.Set(value, GetArenaForAllocation());
}
inline std::string* CPUInfo::_internal_mutable_cpu_info() {
  
  return _impl_.cpu_info_.Mutable(GetArenaForAllocation());
}
inline std::string* CPUInfo::release_cpu_info() {
  // @@protoc_insertion_point(field_release:tensorflow.CPUInfo.cpu_info)
  return _impl_.cpu_info_.Release();
}
inline void CPUInfo::set_allocated_cpu_info(std::string* cpu_info) {
  if (cpu_info != nullptr) {
    
  } else {
    
  }
  _impl_.cpu_info_.SetAllocated(cpu_info, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cpu_info_.IsDefault()) {
    _impl_.cpu_info_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.CPUInfo.cpu_info)
}

// string cpu_governor = 5;
inline void CPUInfo::clear_cpu_governor() {
  _impl_.cpu_governor_.ClearToEmpty();
}
inline const std::string& CPUInfo::cpu_governor() const {
  // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.cpu_governor)
  return _internal_cpu_governor();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CPUInfo::set_cpu_governor(ArgT0&& arg0, ArgT... args) {
 
 _impl_.cpu_governor_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.cpu_governor)
}
inline std::string* CPUInfo::mutable_cpu_governor() {
  std::string* _s = _internal_mutable_cpu_governor();
  // @@protoc_insertion_point(field_mutable:tensorflow.CPUInfo.cpu_governor)
  return _s;
}
inline const std::string& CPUInfo::_internal_cpu_governor() const {
  return _impl_.cpu_governor_.Get();
}
inline void CPUInfo::_internal_set_cpu_governor(const std::string& value) {
  
  _impl_.cpu_governor_.Set(value, GetArenaForAllocation());
}
inline std::string* CPUInfo::_internal_mutable_cpu_governor() {
  
  return _impl_.cpu_governor_.Mutable(GetArenaForAllocation());
}
inline std::string* CPUInfo::release_cpu_governor() {
  // @@protoc_insertion_point(field_release:tensorflow.CPUInfo.cpu_governor)
  return _impl_.cpu_governor_.Release();
}
inline void CPUInfo::set_allocated_cpu_governor(std::string* cpu_governor) {
  if (cpu_governor != nullptr) {
    
  } else {
    
  }
  _impl_.cpu_governor_.SetAllocated(cpu_governor, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cpu_governor_.IsDefault()) {
    _impl_.cpu_governor_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.CPUInfo.cpu_governor)
}

// map<string, int64> cache_size = 6;
inline int CPUInfo::_internal_cache_size_size() const {
  return _impl_.cache_size_.size();
}
inline int CPUInfo::cache_size_size() const {
  return _internal_cache_size_size();
}
inline void CPUInfo::clear_cache_size() {
  _impl_.cache_size_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >&
CPUInfo::_internal_cache_size() const {
  return _impl_.cache_size_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >&
CPUInfo::cache_size() const {
  // @@protoc_insertion_point(field_map:tensorflow.CPUInfo.cache_size)
  return _internal_cache_size();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >*
CPUInfo::_internal_mutable_cache_size() {
  return _impl_.cache_size_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >*
CPUInfo::mutable_cache_size() {
  // @@protoc_insertion_point(field_mutable_map:tensorflow.CPUInfo.cache_size)
  return _internal_mutable_cache_size();
}

// -------------------------------------------------------------------

// MemoryInfo

// int64 total = 1;
inline void MemoryInfo::clear_total() {
  _impl_.total_ = int64_t{0};
}
inline int64_t MemoryInfo::_internal_total() const {
  return _impl_.total_;
}
inline int64_t MemoryInfo::total() const {
  // @@protoc_insertion_point(field_get:tensorflow.MemoryInfo.total)
  return _internal_total();
}
inline void MemoryInfo::_internal_set_total(int64_t value) {
  
  _impl_.total_ = value;
}
inline void MemoryInfo::set_total(int64_t value) {
  _internal_set_total(value);
  // @@protoc_insertion_point(field_set:tensorflow.MemoryInfo.total)
}

// int64 available = 2;
inline void MemoryInfo::clear_available() {
  _impl_.available_ = int64_t{0};
}
inline int64_t MemoryInfo::_internal_available() const {
  return _impl_.available_;
}
inline int64_t MemoryInfo::available() const {
  // @@protoc_insertion_point(field_get:tensorflow.MemoryInfo.available)
  return _internal_available();
}
inline void MemoryInfo::_internal_set_available(int64_t value) {
  
  _impl_.available_ = value;
}
inline void MemoryInfo::set_available(int64_t value) {
  _internal_set_available(value);
  // @@protoc_insertion_point(field_set:tensorflow.MemoryInfo.available)
}

// -------------------------------------------------------------------

// GPUInfo

// string model = 1;
inline void GPUInfo::clear_model() {
  _impl_.model_.ClearToEmpty();
}
inline const std::string& GPUInfo::model() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUInfo.model)
  return _internal_model();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GPUInfo::set_model(ArgT0&& arg0, ArgT... args) {
 
 _impl_.model_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.GPUInfo.model)
}
inline std::string* GPUInfo::mutable_model() {
  std::string* _s = _internal_mutable_model();
  // @@protoc_insertion_point(field_mutable:tensorflow.GPUInfo.model)
  return _s;
}
inline const std::string& GPUInfo::_internal_model() const {
  return _impl_.model_.Get();
}
inline void GPUInfo::_internal_set_model(const std::string& value) {
  
  _impl_.model_.Set(value, GetArenaForAllocation());
}
inline std::string* GPUInfo::_internal_mutable_model() {
  
  return _impl_.model_.Mutable(GetArenaForAllocation());
}
inline std::string* GPUInfo::release_model() {
  // @@protoc_insertion_point(field_release:tensorflow.GPUInfo.model)
  return _impl_.model_.Release();
}
inline void GPUInfo::set_allocated_model(std::string* model) {
  if (model != nullptr) {
    
  } else {
    
  }
  _impl_.model_.SetAllocated(model, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_.IsDefault()) {
    _impl_.model_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUInfo.model)
}

// string uuid = 2;
inline void GPUInfo::clear_uuid() {
  _impl_.uuid_.ClearToEmpty();
}
inline const std::string& GPUInfo::uuid() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUInfo.uuid)
  return _internal_uuid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GPUInfo::set_uuid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.uuid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.GPUInfo.uuid)
}
inline std::string* GPUInfo::mutable_uuid() {
  std::string* _s = _internal_mutable_uuid();
  // @@protoc_insertion_point(field_mutable:tensorflow.GPUInfo.uuid)
  return _s;
}
inline const std::string& GPUInfo::_internal_uuid() const {
  return _impl_.uuid_.Get();
}
inline void GPUInfo::_internal_set_uuid(const std::string& value) {
  
  _impl_.uuid_.Set(value, GetArenaForAllocation());
}
inline std::string* GPUInfo::_internal_mutable_uuid() {
  
  return _impl_.uuid_.Mutable(GetArenaForAllocation());
}
inline std::string* GPUInfo::release_uuid() {
  // @@protoc_insertion_point(field_release:tensorflow.GPUInfo.uuid)
  return _impl_.uuid_.Release();
}
inline void GPUInfo::set_allocated_uuid(std::string* uuid) {
  if (uuid != nullptr) {
    
  } else {
    
  }
  _impl_.uuid_.SetAllocated(uuid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.uuid_.IsDefault()) {
    _impl_.uuid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUInfo.uuid)
}

// string bus_id = 3;
inline void GPUInfo::clear_bus_id() {
  _impl_.bus_id_.ClearToEmpty();
}
inline const std::string& GPUInfo::bus_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.GPUInfo.bus_id)
  return _internal_bus_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GPUInfo::set_bus_id(ArgT0&& arg0, ArgT... args) {
 
 _impl_.bus_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.GPUInfo.bus_id)
}
inline std::string* GPUInfo::mutable_bus_id() {
  std::string* _s = _internal_mutable_bus_id();
  // @@protoc_insertion_point(field_mutable:tensorflow.GPUInfo.bus_id)
  return _s;
}
inline const std::string& GPUInfo::_internal_bus_id() const {
  return _impl_.bus_id_.Get();
}
inline void GPUInfo::_internal_set_bus_id(const std::string& value) {
  
  _impl_.bus_id_.Set(value, GetArenaForAllocation());
}
inline std::string* GPUInfo::_internal_mutable_bus_id() {
  
  return _impl_.bus_id_.Mutable(GetArenaForAllocation());
}
inline std::string* GPUInfo::release_bus_id() {
  // @@protoc_insertion_point(field_release:tensorflow.GPUInfo.bus_id)
  return _impl_.bus_id_.Release();
}
inline void GPUInfo::set_allocated_bus_id(std::string* bus_id) {
  if (bus_id != nullptr) {
    
  } else {
    
  }
  _impl_.bus_id_.SetAllocated(bus_id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bus_id_.IsDefault()) {
    _impl_.bus_id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUInfo.bus_id)
}

// -------------------------------------------------------------------

// PlatformInfo

// string bits = 1;
inline void PlatformInfo::clear_bits() {
  _impl_.bits_.ClearToEmpty();
}
inline const std::string& PlatformInfo::bits() const {
  // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.bits)
  return _internal_bits();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PlatformInfo::set_bits(ArgT0&& arg0, ArgT... args) {
 
 _impl_.bits_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.bits)
}
inline std::string* PlatformInfo::mutable_bits() {
  std::string* _s = _internal_mutable_bits();
  // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.bits)
  return _s;
}
inline const std::string& PlatformInfo::_internal_bits() const {
  return _impl_.bits_.Get();
}
inline void PlatformInfo::_internal_set_bits(const std::string& value) {
  
  _impl_.bits_.Set(value, GetArenaForAllocation());
}
inline std::string* PlatformInfo::_internal_mutable_bits() {
  
  return _impl_.bits_.Mutable(GetArenaForAllocation());
}
inline std::string* PlatformInfo::release_bits() {
  // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.bits)
  return _impl_.bits_.Release();
}
inline void PlatformInfo::set_allocated_bits(std::string* bits) {
  if (bits != nullptr) {
    
  } else {
    
  }
  _impl_.bits_.SetAllocated(bits, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bits_.IsDefault()) {
    _impl_.bits_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.bits)
}

// string linkage = 2;
inline void PlatformInfo::clear_linkage() {
  _impl_.linkage_.ClearToEmpty();
}
inline const std::string& PlatformInfo::linkage() const {
  // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.linkage)
  return _internal_linkage();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PlatformInfo::set_linkage(ArgT0&& arg0, ArgT... args) {
 
 _impl_.linkage_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.linkage)
}
inline std::string* PlatformInfo::mutable_linkage() {
  std::string* _s = _internal_mutable_linkage();
  // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.linkage)
  return _s;
}
inline const std::string& PlatformInfo::_internal_linkage() const {
  return _impl_.linkage_.Get();
}
inline void PlatformInfo::_internal_set_linkage(const std::string& value) {
  
  _impl_.linkage_.Set(value, GetArenaForAllocation());
}
inline std::string* PlatformInfo::_internal_mutable_linkage() {
  
  return _impl_.linkage_.Mutable(GetArenaForAllocation());
}
inline std::string* PlatformInfo::release_linkage() {
  // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.linkage)
  return _impl_.linkage_.Release();
}
inline void PlatformInfo::set_allocated_linkage(std::string* linkage) {
  if (linkage != nullptr) {
    
  } else {
    
  }
  _impl_.linkage_.SetAllocated(linkage, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.linkage_.IsDefault()) {
    _impl_.linkage_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.linkage)
}

// string machine = 3;
inline void PlatformInfo::clear_machine() {
  _impl_.machine_.ClearToEmpty();
}
inline const std::string& PlatformInfo::machine() const {
  // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.machine)
  return _internal_machine();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PlatformInfo::set_machine(ArgT0&& arg0, ArgT... args) {
 
 _impl_.machine_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.machine)
}
inline std::string* PlatformInfo::mutable_machine() {
  std::string* _s = _internal_mutable_machine();
  // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.machine)
  return _s;
}
inline const std::string& PlatformInfo::_internal_machine() const {
  return _impl_.machine_.Get();
}
inline void PlatformInfo::_internal_set_machine(const std::string& value) {
  
  _impl_.machine_.Set(value, GetArenaForAllocation());
}
inline std::string* PlatformInfo::_internal_mutable_machine() {
  
  return _impl_.machine_.Mutable(GetArenaForAllocation());
}
inline std::string* PlatformInfo::release_machine() {
  // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.machine)
  return _impl_.machine_.Release();
}
inline void PlatformInfo::set_allocated_machine(std::string* machine) {
  if (machine != nullptr) {
    
  } else {
    
  }
  _impl_.machine_.SetAllocated(machine, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.machine_.IsDefault()) {
    _impl_.machine_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.machine)
}

// string release = 4;
inline void PlatformInfo::clear_release() {
  _impl_.release_.ClearToEmpty();
}
inline const std::string& PlatformInfo::release() const {
  // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.release)
  return _internal_release();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PlatformInfo::set_release(ArgT0&& arg0, ArgT... args) {
 
 _impl_.release_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.release)
}
inline std::string* PlatformInfo::mutable_release() {
  std::string* _s = _internal_mutable_release();
  // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.release)
  return _s;
}
inline const std::string& PlatformInfo::_internal_release() const {
  return _impl_.release_.Get();
}
inline void PlatformInfo::_internal_set_release(const std::string& value) {
  
  _impl_.release_.Set(value, GetArenaForAllocation());
}
inline std::string* PlatformInfo::_internal_mutable_release() {
  
  return _impl_.release_.Mutable(GetArenaForAllocation());
}
inline std::string* PlatformInfo::release_release() {
  // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.release)
  return _impl_.release_.Release();
}
inline void PlatformInfo::set_allocated_release(std::string* release) {
  if (release != nullptr) {
    
  } else {
    
  }
  _impl_.release_.SetAllocated(release, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.release_.IsDefault()) {
    _impl_.release_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.release)
}

// string system = 5;
inline void PlatformInfo::clear_system() {
  _impl_.system_.ClearToEmpty();
}
inline const std::string& PlatformInfo::system() const {
  // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.system)
  return _internal_system();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PlatformInfo::set_system(ArgT0&& arg0, ArgT... args) {
 
 _impl_.system_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.system)
}
inline std::string* PlatformInfo::mutable_system() {
  std::string* _s = _internal_mutable_system();
  // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.system)
  return _s;
}
inline const std::string& PlatformInfo::_internal_system() const {
  return _impl_.system_.Get();
}
inline void PlatformInfo::_internal_set_system(const std::string& value) {
  
  _impl_.system_.Set(value, GetArenaForAllocation());
}
inline std::string* PlatformInfo::_internal_mutable_system() {
  
  return _impl_.system_.Mutable(GetArenaForAllocation());
}
inline std::string* PlatformInfo::release_system() {
  // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.system)
  return _impl_.system_.Release();
}
inline void PlatformInfo::set_allocated_system(std::string* system) {
  if (system != nullptr) {
    
  } else {
    
  }
  _impl_.system_.SetAllocated(system, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.system_.IsDefault()) {
    _impl_.system_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.system)
}

// string version = 6;
inline void PlatformInfo::clear_version() {
  _impl_.version_.ClearToEmpty();
}
inline const std::string& PlatformInfo::version() const {
  // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.version)
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PlatformInfo::set_version(ArgT0&& arg0, ArgT... args) {
 
 _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.version)
}
inline std::string* PlatformInfo::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.version)
  return _s;
}
inline const std::string& PlatformInfo::_internal_version() const {
  return _impl_.version_.Get();
}
inline void PlatformInfo::_internal_set_version(const std::string& value) {
  
  _impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* PlatformInfo::_internal_mutable_version() {
  
  return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* PlatformInfo::release_version() {
  // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.version)
  return _impl_.version_.Release();
}
inline void PlatformInfo::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    
  } else {
    
  }
  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.version)
}

// -------------------------------------------------------------------

// AvailableDeviceInfo

// string name = 1;
inline void AvailableDeviceInfo::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& AvailableDeviceInfo::name() const {
  // @@protoc_insertion_point(field_get:tensorflow.AvailableDeviceInfo.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AvailableDeviceInfo::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.AvailableDeviceInfo.name)
}
inline std::string* AvailableDeviceInfo::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:tensorflow.AvailableDeviceInfo.name)
  return _s;
}
inline const std::string& AvailableDeviceInfo::_internal_name() const {
  return _impl_.name_.Get();
}
inline void AvailableDeviceInfo::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* AvailableDeviceInfo::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* AvailableDeviceInfo::release_name() {
  // @@protoc_insertion_point(field_release:tensorflow.AvailableDeviceInfo.name)
  return _impl_.name_.Release();
}
inline void AvailableDeviceInfo::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.AvailableDeviceInfo.name)
}

// string type = 2;
inline void AvailableDeviceInfo::clear_type() {
  _impl_.type_.ClearToEmpty();
}
inline const std::string& AvailableDeviceInfo::type() const {
  // @@protoc_insertion_point(field_get:tensorflow.AvailableDeviceInfo.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AvailableDeviceInfo::set_type(ArgT0&& arg0, ArgT... args) {
 
 _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.AvailableDeviceInfo.type)
}
inline std::string* AvailableDeviceInfo::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:tensorflow.AvailableDeviceInfo.type)
  return _s;
}
inline const std::string& AvailableDeviceInfo::_internal_type() const {
  return _impl_.type_.Get();
}
inline void AvailableDeviceInfo::_internal_set_type(const std::string& value) {
  
  _impl_.type_.Set(value, GetArenaForAllocation());
}
inline std::string* AvailableDeviceInfo::_internal_mutable_type() {
  
  return _impl_.type_.Mutable(GetArenaForAllocation());
}
inline std::string* AvailableDeviceInfo::release_type() {
  // @@protoc_insertion_point(field_release:tensorflow.AvailableDeviceInfo.type)
  return _impl_.type_.Release();
}
inline void AvailableDeviceInfo::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  _impl_.type_.SetAllocated(type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.type_.IsDefault()) {
    _impl_.type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.AvailableDeviceInfo.type)
}

// int64 memory_limit = 3;
inline void AvailableDeviceInfo::clear_memory_limit() {
  _impl_.memory_limit_ = int64_t{0};
}
inline int64_t AvailableDeviceInfo::_internal_memory_limit() const {
  return _impl_.memory_limit_;
}
inline int64_t AvailableDeviceInfo::memory_limit() const {
  // @@protoc_insertion_point(field_get:tensorflow.AvailableDeviceInfo.memory_limit)
  return _internal_memory_limit();
}
inline void AvailableDeviceInfo::_internal_set_memory_limit(int64_t value) {
  
  _impl_.memory_limit_ = value;
}
inline void AvailableDeviceInfo::set_memory_limit(int64_t value) {
  _internal_set_memory_limit(value);
  // @@protoc_insertion_point(field_set:tensorflow.AvailableDeviceInfo.memory_limit)
}

// string physical_description = 4;
inline void AvailableDeviceInfo::clear_physical_description() {
  _impl_.physical_description_.ClearToEmpty();
}
inline const std::string& AvailableDeviceInfo::physical_description() const {
  // @@protoc_insertion_point(field_get:tensorflow.AvailableDeviceInfo.physical_description)
  return _internal_physical_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AvailableDeviceInfo::set_physical_description(ArgT0&& arg0, ArgT... args) {
 
 _impl_.physical_description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.AvailableDeviceInfo.physical_description)
}
inline std::string* AvailableDeviceInfo::mutable_physical_description() {
  std::string* _s = _internal_mutable_physical_description();
  // @@protoc_insertion_point(field_mutable:tensorflow.AvailableDeviceInfo.physical_description)
  return _s;
}
inline const std::string& AvailableDeviceInfo::_internal_physical_description() const {
  return _impl_.physical_description_.Get();
}
inline void AvailableDeviceInfo::_internal_set_physical_description(const std::string& value) {
  
  _impl_.physical_description_.Set(value, GetArenaForAllocation());
}
inline std::string* AvailableDeviceInfo::_internal_mutable_physical_description() {
  
  return _impl_.physical_description_.Mutable(GetArenaForAllocation());
}
inline std::string* AvailableDeviceInfo::release_physical_description() {
  // @@protoc_insertion_point(field_release:tensorflow.AvailableDeviceInfo.physical_description)
  return _impl_.physical_description_.Release();
}
inline void AvailableDeviceInfo::set_allocated_physical_description(std::string* physical_description) {
  if (physical_description != nullptr) {
    
  } else {
    
  }
  _impl_.physical_description_.SetAllocated(physical_description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.physical_description_.IsDefault()) {
    _impl_.physical_description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.AvailableDeviceInfo.physical_description)
}

// -------------------------------------------------------------------

// MachineConfiguration

// string hostname = 1;
inline void MachineConfiguration::clear_hostname() {
  _impl_.hostname_.ClearToEmpty();
}
inline const std::string& MachineConfiguration::hostname() const {
  // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.hostname)
  return _internal_hostname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MachineConfiguration::set_hostname(ArgT0&& arg0, ArgT... args) {
 
 _impl_.hostname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.MachineConfiguration.hostname)
}
inline std::string* MachineConfiguration::mutable_hostname() {
  std::string* _s = _internal_mutable_hostname();
  // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.hostname)
  return _s;
}
inline const std::string& MachineConfiguration::_internal_hostname() const {
  return _impl_.hostname_.Get();
}
inline void MachineConfiguration::_internal_set_hostname(const std::string& value) {
  
  _impl_.hostname_.Set(value, GetArenaForAllocation());
}
inline std::string* MachineConfiguration::_internal_mutable_hostname() {
  
  return _impl_.hostname_.Mutable(GetArenaForAllocation());
}
inline std::string* MachineConfiguration::release_hostname() {
  // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.hostname)
  return _impl_.hostname_.Release();
}
inline void MachineConfiguration::set_allocated_hostname(std::string* hostname) {
  if (hostname != nullptr) {
    
  } else {
    
  }
  _impl_.hostname_.SetAllocated(hostname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hostname_.IsDefault()) {
    _impl_.hostname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.hostname)
}

// string serial_identifier = 7;
inline void MachineConfiguration::clear_serial_identifier() {
  _impl_.serial_identifier_.ClearToEmpty();
}
inline const std::string& MachineConfiguration::serial_identifier() const {
  // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.serial_identifier)
  return _internal_serial_identifier();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MachineConfiguration::set_serial_identifier(ArgT0&& arg0, ArgT... args) {
 
 _impl_.serial_identifier_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.MachineConfiguration.serial_identifier)
}
inline std::string* MachineConfiguration::mutable_serial_identifier() {
  std::string* _s = _internal_mutable_serial_identifier();
  // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.serial_identifier)
  return _s;
}
inline const std::string& MachineConfiguration::_internal_serial_identifier() const {
  return _impl_.serial_identifier_.Get();
}
inline void MachineConfiguration::_internal_set_serial_identifier(const std::string& value) {
  
  _impl_.serial_identifier_.Set(value, GetArenaForAllocation());
}
inline std::string* MachineConfiguration::_internal_mutable_serial_identifier() {
  
  return _impl_.serial_identifier_.Mutable(GetArenaForAllocation());
}
inline std::string* MachineConfiguration::release_serial_identifier() {
  // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.serial_identifier)
  return _impl_.serial_identifier_.Release();
}
inline void MachineConfiguration::set_allocated_serial_identifier(std::string* serial_identifier) {
  if (serial_identifier != nullptr) {
    
  } else {
    
  }
  _impl_.serial_identifier_.SetAllocated(serial_identifier, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.serial_identifier_.IsDefault()) {
    _impl_.serial_identifier_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.serial_identifier)
}

// .tensorflow.PlatformInfo platform_info = 2;
inline bool MachineConfiguration::_internal_has_platform_info() const {
  return this != internal_default_instance() && _impl_.platform_info_ != nullptr;
}
inline bool MachineConfiguration::has_platform_info() const {
  return _internal_has_platform_info();
}
inline void MachineConfiguration::clear_platform_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.platform_info_ != nullptr) {
    delete _impl_.platform_info_;
  }
  _impl_.platform_info_ = nullptr;
}
inline const ::tensorflow::PlatformInfo& MachineConfiguration::_internal_platform_info() const {
  const ::tensorflow::PlatformInfo* p = _impl_.platform_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::PlatformInfo&>(
      ::tensorflow::_PlatformInfo_default_instance_);
}
inline const ::tensorflow::PlatformInfo& MachineConfiguration::platform_info() const {
  // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.platform_info)
  return _internal_platform_info();
}
inline void MachineConfiguration::unsafe_arena_set_allocated_platform_info(
    ::tensorflow::PlatformInfo* platform_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.platform_info_);
  }
  _impl_.platform_info_ = platform_info;
  if (platform_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MachineConfiguration.platform_info)
}
inline ::tensorflow::PlatformInfo* MachineConfiguration::release_platform_info() {
  
  ::tensorflow::PlatformInfo* temp = _impl_.platform_info_;
  _impl_.platform_info_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::PlatformInfo* MachineConfiguration::unsafe_arena_release_platform_info() {
  // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.platform_info)
  
  ::tensorflow::PlatformInfo* temp = _impl_.platform_info_;
  _impl_.platform_info_ = nullptr;
  return temp;
}
inline ::tensorflow::PlatformInfo* MachineConfiguration::_internal_mutable_platform_info() {
  
  if (_impl_.platform_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::PlatformInfo>(GetArenaForAllocation());
    _impl_.platform_info_ = p;
  }
  return _impl_.platform_info_;
}
inline ::tensorflow::PlatformInfo* MachineConfiguration::mutable_platform_info() {
  ::tensorflow::PlatformInfo* _msg = _internal_mutable_platform_info();
  // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.platform_info)
  return _msg;
}
inline void MachineConfiguration::set_allocated_platform_info(::tensorflow::PlatformInfo* platform_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.platform_info_;
  }
  if (platform_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(platform_info);
    if (message_arena != submessage_arena) {
      platform_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, platform_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.platform_info_ = platform_info;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.platform_info)
}

// .tensorflow.CPUInfo cpu_info = 3;
inline bool MachineConfiguration::_internal_has_cpu_info() const {
  return this != internal_default_instance() && _impl_.cpu_info_ != nullptr;
}
inline bool MachineConfiguration::has_cpu_info() const {
  return _internal_has_cpu_info();
}
inline void MachineConfiguration::clear_cpu_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.cpu_info_ != nullptr) {
    delete _impl_.cpu_info_;
  }
  _impl_.cpu_info_ = nullptr;
}
inline const ::tensorflow::CPUInfo& MachineConfiguration::_internal_cpu_info() const {
  const ::tensorflow::CPUInfo* p = _impl_.cpu_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::CPUInfo&>(
      ::tensorflow::_CPUInfo_default_instance_);
}
inline const ::tensorflow::CPUInfo& MachineConfiguration::cpu_info() const {
  // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.cpu_info)
  return _internal_cpu_info();
}
inline void MachineConfiguration::unsafe_arena_set_allocated_cpu_info(
    ::tensorflow::CPUInfo* cpu_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cpu_info_);
  }
  _impl_.cpu_info_ = cpu_info;
  if (cpu_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MachineConfiguration.cpu_info)
}
inline ::tensorflow::CPUInfo* MachineConfiguration::release_cpu_info() {
  
  ::tensorflow::CPUInfo* temp = _impl_.cpu_info_;
  _impl_.cpu_info_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::CPUInfo* MachineConfiguration::unsafe_arena_release_cpu_info() {
  // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.cpu_info)
  
  ::tensorflow::CPUInfo* temp = _impl_.cpu_info_;
  _impl_.cpu_info_ = nullptr;
  return temp;
}
inline ::tensorflow::CPUInfo* MachineConfiguration::_internal_mutable_cpu_info() {
  
  if (_impl_.cpu_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::CPUInfo>(GetArenaForAllocation());
    _impl_.cpu_info_ = p;
  }
  return _impl_.cpu_info_;
}
inline ::tensorflow::CPUInfo* MachineConfiguration::mutable_cpu_info() {
  ::tensorflow::CPUInfo* _msg = _internal_mutable_cpu_info();
  // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.cpu_info)
  return _msg;
}
inline void MachineConfiguration::set_allocated_cpu_info(::tensorflow::CPUInfo* cpu_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.cpu_info_;
  }
  if (cpu_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cpu_info);
    if (message_arena != submessage_arena) {
      cpu_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cpu_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.cpu_info_ = cpu_info;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.cpu_info)
}

// repeated .google.protobuf.Any device_info = 4;
inline int MachineConfiguration::_internal_device_info_size() const {
  return _impl_.device_info_.size();
}
inline int MachineConfiguration::device_info_size() const {
  return _internal_device_info_size();
}
inline ::PROTOBUF_NAMESPACE_ID::Any* MachineConfiguration::mutable_device_info(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.device_info)
  return _impl_.device_info_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >*
MachineConfiguration::mutable_device_info() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.MachineConfiguration.device_info)
  return &_impl_.device_info_;
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& MachineConfiguration::_internal_device_info(int index) const {
  return _impl_.device_info_.Get(index);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& MachineConfiguration::device_info(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.device_info)
  return _internal_device_info(index);
}
inline ::PROTOBUF_NAMESPACE_ID::Any* MachineConfiguration::_internal_add_device_info() {
  return _impl_.device_info_.Add();
}
inline ::PROTOBUF_NAMESPACE_ID::Any* MachineConfiguration::add_device_info() {
  ::PROTOBUF_NAMESPACE_ID::Any* _add = _internal_add_device_info();
  // @@protoc_insertion_point(field_add:tensorflow.MachineConfiguration.device_info)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >&
MachineConfiguration::device_info() const {
  // @@protoc_insertion_point(field_list:tensorflow.MachineConfiguration.device_info)
  return _impl_.device_info_;
}

// repeated .tensorflow.AvailableDeviceInfo available_device_info = 5;
inline int MachineConfiguration::_internal_available_device_info_size() const {
  return _impl_.available_device_info_.size();
}
inline int MachineConfiguration::available_device_info_size() const {
  return _internal_available_device_info_size();
}
inline void MachineConfiguration::clear_available_device_info() {
  _impl_.available_device_info_.Clear();
}
inline ::tensorflow::AvailableDeviceInfo* MachineConfiguration::mutable_available_device_info(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.available_device_info)
  return _impl_.available_device_info_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo >*
MachineConfiguration::mutable_available_device_info() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.MachineConfiguration.available_device_info)
  return &_impl_.available_device_info_;
}
inline const ::tensorflow::AvailableDeviceInfo& MachineConfiguration::_internal_available_device_info(int index) const {
  return _impl_.available_device_info_.Get(index);
}
inline const ::tensorflow::AvailableDeviceInfo& MachineConfiguration::available_device_info(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.available_device_info)
  return _internal_available_device_info(index);
}
inline ::tensorflow::AvailableDeviceInfo* MachineConfiguration::_internal_add_available_device_info() {
  return _impl_.available_device_info_.Add();
}
inline ::tensorflow::AvailableDeviceInfo* MachineConfiguration::add_available_device_info() {
  ::tensorflow::AvailableDeviceInfo* _add = _internal_add_available_device_info();
  // @@protoc_insertion_point(field_add:tensorflow.MachineConfiguration.available_device_info)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo >&
MachineConfiguration::available_device_info() const {
  // @@protoc_insertion_point(field_list:tensorflow.MachineConfiguration.available_device_info)
  return _impl_.available_device_info_;
}

// .tensorflow.MemoryInfo memory_info = 6;
inline bool MachineConfiguration::_internal_has_memory_info() const {
  return this != internal_default_instance() && _impl_.memory_info_ != nullptr;
}
inline bool MachineConfiguration::has_memory_info() const {
  return _internal_has_memory_info();
}
inline void MachineConfiguration::clear_memory_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.memory_info_ != nullptr) {
    delete _impl_.memory_info_;
  }
  _impl_.memory_info_ = nullptr;
}
inline const ::tensorflow::MemoryInfo& MachineConfiguration::_internal_memory_info() const {
  const ::tensorflow::MemoryInfo* p = _impl_.memory_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::MemoryInfo&>(
      ::tensorflow::_MemoryInfo_default_instance_);
}
inline const ::tensorflow::MemoryInfo& MachineConfiguration::memory_info() const {
  // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.memory_info)
  return _internal_memory_info();
}
inline void MachineConfiguration::unsafe_arena_set_allocated_memory_info(
    ::tensorflow::MemoryInfo* memory_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.memory_info_);
  }
  _impl_.memory_info_ = memory_info;
  if (memory_info) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MachineConfiguration.memory_info)
}
inline ::tensorflow::MemoryInfo* MachineConfiguration::release_memory_info() {
  
  ::tensorflow::MemoryInfo* temp = _impl_.memory_info_;
  _impl_.memory_info_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::MemoryInfo* MachineConfiguration::unsafe_arena_release_memory_info() {
  // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.memory_info)
  
  ::tensorflow::MemoryInfo* temp = _impl_.memory_info_;
  _impl_.memory_info_ = nullptr;
  return temp;
}
inline ::tensorflow::MemoryInfo* MachineConfiguration::_internal_mutable_memory_info() {
  
  if (_impl_.memory_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::MemoryInfo>(GetArenaForAllocation());
    _impl_.memory_info_ = p;
  }
  return _impl_.memory_info_;
}
inline ::tensorflow::MemoryInfo* MachineConfiguration::mutable_memory_info() {
  ::tensorflow::MemoryInfo* _msg = _internal_mutable_memory_info();
  // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.memory_info)
  return _msg;
}
inline void MachineConfiguration::set_allocated_memory_info(::tensorflow::MemoryInfo* memory_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.memory_info_;
  }
  if (memory_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(memory_info);
    if (message_arena != submessage_arena) {
      memory_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, memory_info, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.memory_info_ = memory_info;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.memory_info)
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// RunConfiguration

// repeated string argument = 1;
inline int RunConfiguration::_internal_argument_size() const {
  return _impl_.argument_.size();
}
inline int RunConfiguration::argument_size() const {
  return _internal_argument_size();
}
inline void RunConfiguration::clear_argument() {
  _impl_.argument_.Clear();
}
inline std::string* RunConfiguration::add_argument() {
  std::string* _s = _internal_add_argument();
  // @@protoc_insertion_point(field_add_mutable:tensorflow.RunConfiguration.argument)
  return _s;
}
inline const std::string& RunConfiguration::_internal_argument(int index) const {
  return _impl_.argument_.Get(index);
}
inline const std::string& RunConfiguration::argument(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.RunConfiguration.argument)
  return _internal_argument(index);
}
inline std::string* RunConfiguration::mutable_argument(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.RunConfiguration.argument)
  return _impl_.argument_.Mutable(index);
}
inline void RunConfiguration::set_argument(int index, const std::string& value) {
  _impl_.argument_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:tensorflow.RunConfiguration.argument)
}
inline void RunConfiguration::set_argument(int index, std::string&& value) {
  _impl_.argument_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:tensorflow.RunConfiguration.argument)
}
inline void RunConfiguration::set_argument(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.argument_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:tensorflow.RunConfiguration.argument)
}
inline void RunConfiguration::set_argument(int index, const char* value, size_t size) {
  _impl_.argument_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:tensorflow.RunConfiguration.argument)
}
inline std::string* RunConfiguration::_internal_add_argument() {
  return _impl_.argument_.Add();
}
inline void RunConfiguration::add_argument(const std::string& value) {
  _impl_.argument_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:tensorflow.RunConfiguration.argument)
}
inline void RunConfiguration::add_argument(std::string&& value) {
  _impl_.argument_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:tensorflow.RunConfiguration.argument)
}
inline void RunConfiguration::add_argument(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.argument_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:tensorflow.RunConfiguration.argument)
}
inline void RunConfiguration::add_argument(const char* value, size_t size) {
  _impl_.argument_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:tensorflow.RunConfiguration.argument)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
RunConfiguration::argument() const {
  // @@protoc_insertion_point(field_list:tensorflow.RunConfiguration.argument)
  return _impl_.argument_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
RunConfiguration::mutable_argument() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.RunConfiguration.argument)
  return &_impl_.argument_;
}

// map<string, string> env_vars = 2;
inline int RunConfiguration::_internal_env_vars_size() const {
  return _impl_.env_vars_.size();
}
inline int RunConfiguration::env_vars_size() const {
  return _internal_env_vars_size();
}
inline void RunConfiguration::clear_env_vars() {
  _impl_.env_vars_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
RunConfiguration::_internal_env_vars() const {
  return _impl_.env_vars_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
RunConfiguration::env_vars() const {
  // @@protoc_insertion_point(field_map:tensorflow.RunConfiguration.env_vars)
  return _internal_env_vars();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
RunConfiguration::_internal_mutable_env_vars() {
  return _impl_.env_vars_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
RunConfiguration::mutable_env_vars() {
  // @@protoc_insertion_point(field_mutable_map:tensorflow.RunConfiguration.env_vars)
  return _internal_mutable_env_vars();
}

// -------------------------------------------------------------------

// TestResults

// string target = 1;
inline void TestResults::clear_target() {
  _impl_.target_.ClearToEmpty();
}
inline const std::string& TestResults::target() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.target)
  return _internal_target();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TestResults::set_target(ArgT0&& arg0, ArgT... args) {
 
 _impl_.target_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.TestResults.target)
}
inline std::string* TestResults::mutable_target() {
  std::string* _s = _internal_mutable_target();
  // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.target)
  return _s;
}
inline const std::string& TestResults::_internal_target() const {
  return _impl_.target_.Get();
}
inline void TestResults::_internal_set_target(const std::string& value) {
  
  _impl_.target_.Set(value, GetArenaForAllocation());
}
inline std::string* TestResults::_internal_mutable_target() {
  
  return _impl_.target_.Mutable(GetArenaForAllocation());
}
inline std::string* TestResults::release_target() {
  // @@protoc_insertion_point(field_release:tensorflow.TestResults.target)
  return _impl_.target_.Release();
}
inline void TestResults::set_allocated_target(std::string* target) {
  if (target != nullptr) {
    
  } else {
    
  }
  _impl_.target_.SetAllocated(target, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.target_.IsDefault()) {
    _impl_.target_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.target)
}

// .tensorflow.BenchmarkEntries entries = 2;
inline bool TestResults::_internal_has_entries() const {
  return this != internal_default_instance() && _impl_.entries_ != nullptr;
}
inline bool TestResults::has_entries() const {
  return _internal_has_entries();
}
inline void TestResults::clear_entries() {
  if (GetArenaForAllocation() == nullptr && _impl_.entries_ != nullptr) {
    delete _impl_.entries_;
  }
  _impl_.entries_ = nullptr;
}
inline const ::tensorflow::BenchmarkEntries& TestResults::_internal_entries() const {
  const ::tensorflow::BenchmarkEntries* p = _impl_.entries_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::BenchmarkEntries&>(
      ::tensorflow::_BenchmarkEntries_default_instance_);
}
inline const ::tensorflow::BenchmarkEntries& TestResults::entries() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.entries)
  return _internal_entries();
}
inline void TestResults::unsafe_arena_set_allocated_entries(
    ::tensorflow::BenchmarkEntries* entries) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entries_);
  }
  _impl_.entries_ = entries;
  if (entries) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TestResults.entries)
}
inline ::tensorflow::BenchmarkEntries* TestResults::release_entries() {
  
  ::tensorflow::BenchmarkEntries* temp = _impl_.entries_;
  _impl_.entries_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::BenchmarkEntries* TestResults::unsafe_arena_release_entries() {
  // @@protoc_insertion_point(field_release:tensorflow.TestResults.entries)
  
  ::tensorflow::BenchmarkEntries* temp = _impl_.entries_;
  _impl_.entries_ = nullptr;
  return temp;
}
inline ::tensorflow::BenchmarkEntries* TestResults::_internal_mutable_entries() {
  
  if (_impl_.entries_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::BenchmarkEntries>(GetArenaForAllocation());
    _impl_.entries_ = p;
  }
  return _impl_.entries_;
}
inline ::tensorflow::BenchmarkEntries* TestResults::mutable_entries() {
  ::tensorflow::BenchmarkEntries* _msg = _internal_mutable_entries();
  // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.entries)
  return _msg;
}
inline void TestResults::set_allocated_entries(::tensorflow::BenchmarkEntries* entries) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.entries_;
  }
  if (entries) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(entries);
    if (message_arena != submessage_arena) {
      entries = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entries, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.entries_ = entries;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.entries)
}

// .tensorflow.BuildConfiguration build_configuration = 3;
inline bool TestResults::_internal_has_build_configuration() const {
  return this != internal_default_instance() && _impl_.build_configuration_ != nullptr;
}
inline bool TestResults::has_build_configuration() const {
  return _internal_has_build_configuration();
}
inline void TestResults::clear_build_configuration() {
  if (GetArenaForAllocation() == nullptr && _impl_.build_configuration_ != nullptr) {
    delete _impl_.build_configuration_;
  }
  _impl_.build_configuration_ = nullptr;
}
inline const ::tensorflow::BuildConfiguration& TestResults::_internal_build_configuration() const {
  const ::tensorflow::BuildConfiguration* p = _impl_.build_configuration_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::BuildConfiguration&>(
      ::tensorflow::_BuildConfiguration_default_instance_);
}
inline const ::tensorflow::BuildConfiguration& TestResults::build_configuration() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.build_configuration)
  return _internal_build_configuration();
}
inline void TestResults::unsafe_arena_set_allocated_build_configuration(
    ::tensorflow::BuildConfiguration* build_configuration) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.build_configuration_);
  }
  _impl_.build_configuration_ = build_configuration;
  if (build_configuration) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TestResults.build_configuration)
}
inline ::tensorflow::BuildConfiguration* TestResults::release_build_configuration() {
  
  ::tensorflow::BuildConfiguration* temp = _impl_.build_configuration_;
  _impl_.build_configuration_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::BuildConfiguration* TestResults::unsafe_arena_release_build_configuration() {
  // @@protoc_insertion_point(field_release:tensorflow.TestResults.build_configuration)
  
  ::tensorflow::BuildConfiguration* temp = _impl_.build_configuration_;
  _impl_.build_configuration_ = nullptr;
  return temp;
}
inline ::tensorflow::BuildConfiguration* TestResults::_internal_mutable_build_configuration() {
  
  if (_impl_.build_configuration_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::BuildConfiguration>(GetArenaForAllocation());
    _impl_.build_configuration_ = p;
  }
  return _impl_.build_configuration_;
}
inline ::tensorflow::BuildConfiguration* TestResults::mutable_build_configuration() {
  ::tensorflow::BuildConfiguration* _msg = _internal_mutable_build_configuration();
  // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.build_configuration)
  return _msg;
}
inline void TestResults::set_allocated_build_configuration(::tensorflow::BuildConfiguration* build_configuration) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.build_configuration_;
  }
  if (build_configuration) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(build_configuration);
    if (message_arena != submessage_arena) {
      build_configuration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, build_configuration, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.build_configuration_ = build_configuration;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.build_configuration)
}

// .tensorflow.CommitId commit_id = 4;
inline bool TestResults::_internal_has_commit_id() const {
  return this != internal_default_instance() && _impl_.commit_id_ != nullptr;
}
inline bool TestResults::has_commit_id() const {
  return _internal_has_commit_id();
}
inline void TestResults::clear_commit_id() {
  if (GetArenaForAllocation() == nullptr && _impl_.commit_id_ != nullptr) {
    delete _impl_.commit_id_;
  }
  _impl_.commit_id_ = nullptr;
}
inline const ::tensorflow::CommitId& TestResults::_internal_commit_id() const {
  const ::tensorflow::CommitId* p = _impl_.commit_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::CommitId&>(
      ::tensorflow::_CommitId_default_instance_);
}
inline const ::tensorflow::CommitId& TestResults::commit_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.commit_id)
  return _internal_commit_id();
}
inline void TestResults::unsafe_arena_set_allocated_commit_id(
    ::tensorflow::CommitId* commit_id) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.commit_id_);
  }
  _impl_.commit_id_ = commit_id;
  if (commit_id) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TestResults.commit_id)
}
inline ::tensorflow::CommitId* TestResults::release_commit_id() {
  
  ::tensorflow::CommitId* temp = _impl_.commit_id_;
  _impl_.commit_id_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::CommitId* TestResults::unsafe_arena_release_commit_id() {
  // @@protoc_insertion_point(field_release:tensorflow.TestResults.commit_id)
  
  ::tensorflow::CommitId* temp = _impl_.commit_id_;
  _impl_.commit_id_ = nullptr;
  return temp;
}
inline ::tensorflow::CommitId* TestResults::_internal_mutable_commit_id() {
  
  if (_impl_.commit_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::CommitId>(GetArenaForAllocation());
    _impl_.commit_id_ = p;
  }
  return _impl_.commit_id_;
}
inline ::tensorflow::CommitId* TestResults::mutable_commit_id() {
  ::tensorflow::CommitId* _msg = _internal_mutable_commit_id();
  // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.commit_id)
  return _msg;
}
inline void TestResults::set_allocated_commit_id(::tensorflow::CommitId* commit_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.commit_id_;
  }
  if (commit_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(commit_id);
    if (message_arena != submessage_arena) {
      commit_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, commit_id, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.commit_id_ = commit_id;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.commit_id)
}

// int64 start_time = 5;
inline void TestResults::clear_start_time() {
  _impl_.start_time_ = int64_t{0};
}
inline int64_t TestResults::_internal_start_time() const {
  return _impl_.start_time_;
}
inline int64_t TestResults::start_time() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.start_time)
  return _internal_start_time();
}
inline void TestResults::_internal_set_start_time(int64_t value) {
  
  _impl_.start_time_ = value;
}
inline void TestResults::set_start_time(int64_t value) {
  _internal_set_start_time(value);
  // @@protoc_insertion_point(field_set:tensorflow.TestResults.start_time)
}

// double run_time = 6;
inline void TestResults::clear_run_time() {
  _impl_.run_time_ = 0;
}
inline double TestResults::_internal_run_time() const {
  return _impl_.run_time_;
}
inline double TestResults::run_time() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.run_time)
  return _internal_run_time();
}
inline void TestResults::_internal_set_run_time(double value) {
  
  _impl_.run_time_ = value;
}
inline void TestResults::set_run_time(double value) {
  _internal_set_run_time(value);
  // @@protoc_insertion_point(field_set:tensorflow.TestResults.run_time)
}

// .tensorflow.MachineConfiguration machine_configuration = 7;
inline bool TestResults::_internal_has_machine_configuration() const {
  return this != internal_default_instance() && _impl_.machine_configuration_ != nullptr;
}
inline bool TestResults::has_machine_configuration() const {
  return _internal_has_machine_configuration();
}
inline void TestResults::clear_machine_configuration() {
  if (GetArenaForAllocation() == nullptr && _impl_.machine_configuration_ != nullptr) {
    delete _impl_.machine_configuration_;
  }
  _impl_.machine_configuration_ = nullptr;
}
inline const ::tensorflow::MachineConfiguration& TestResults::_internal_machine_configuration() const {
  const ::tensorflow::MachineConfiguration* p = _impl_.machine_configuration_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::MachineConfiguration&>(
      ::tensorflow::_MachineConfiguration_default_instance_);
}
inline const ::tensorflow::MachineConfiguration& TestResults::machine_configuration() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.machine_configuration)
  return _internal_machine_configuration();
}
inline void TestResults::unsafe_arena_set_allocated_machine_configuration(
    ::tensorflow::MachineConfiguration* machine_configuration) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.machine_configuration_);
  }
  _impl_.machine_configuration_ = machine_configuration;
  if (machine_configuration) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TestResults.machine_configuration)
}
inline ::tensorflow::MachineConfiguration* TestResults::release_machine_configuration() {
  
  ::tensorflow::MachineConfiguration* temp = _impl_.machine_configuration_;
  _impl_.machine_configuration_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::MachineConfiguration* TestResults::unsafe_arena_release_machine_configuration() {
  // @@protoc_insertion_point(field_release:tensorflow.TestResults.machine_configuration)
  
  ::tensorflow::MachineConfiguration* temp = _impl_.machine_configuration_;
  _impl_.machine_configuration_ = nullptr;
  return temp;
}
inline ::tensorflow::MachineConfiguration* TestResults::_internal_mutable_machine_configuration() {
  
  if (_impl_.machine_configuration_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::MachineConfiguration>(GetArenaForAllocation());
    _impl_.machine_configuration_ = p;
  }
  return _impl_.machine_configuration_;
}
inline ::tensorflow::MachineConfiguration* TestResults::mutable_machine_configuration() {
  ::tensorflow::MachineConfiguration* _msg = _internal_mutable_machine_configuration();
  // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.machine_configuration)
  return _msg;
}
inline void TestResults::set_allocated_machine_configuration(::tensorflow::MachineConfiguration* machine_configuration) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.machine_configuration_;
  }
  if (machine_configuration) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(machine_configuration);
    if (message_arena != submessage_arena) {
      machine_configuration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, machine_configuration, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.machine_configuration_ = machine_configuration;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.machine_configuration)
}

// .tensorflow.RunConfiguration run_configuration = 8;
inline bool TestResults::_internal_has_run_configuration() const {
  return this != internal_default_instance() && _impl_.run_configuration_ != nullptr;
}
inline bool TestResults::has_run_configuration() const {
  return _internal_has_run_configuration();
}
inline void TestResults::clear_run_configuration() {
  if (GetArenaForAllocation() == nullptr && _impl_.run_configuration_ != nullptr) {
    delete _impl_.run_configuration_;
  }
  _impl_.run_configuration_ = nullptr;
}
inline const ::tensorflow::RunConfiguration& TestResults::_internal_run_configuration() const {
  const ::tensorflow::RunConfiguration* p = _impl_.run_configuration_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::RunConfiguration&>(
      ::tensorflow::_RunConfiguration_default_instance_);
}
inline const ::tensorflow::RunConfiguration& TestResults::run_configuration() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.run_configuration)
  return _internal_run_configuration();
}
inline void TestResults::unsafe_arena_set_allocated_run_configuration(
    ::tensorflow::RunConfiguration* run_configuration) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.run_configuration_);
  }
  _impl_.run_configuration_ = run_configuration;
  if (run_configuration) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TestResults.run_configuration)
}
inline ::tensorflow::RunConfiguration* TestResults::release_run_configuration() {
  
  ::tensorflow::RunConfiguration* temp = _impl_.run_configuration_;
  _impl_.run_configuration_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::RunConfiguration* TestResults::unsafe_arena_release_run_configuration() {
  // @@protoc_insertion_point(field_release:tensorflow.TestResults.run_configuration)
  
  ::tensorflow::RunConfiguration* temp = _impl_.run_configuration_;
  _impl_.run_configuration_ = nullptr;
  return temp;
}
inline ::tensorflow::RunConfiguration* TestResults::_internal_mutable_run_configuration() {
  
  if (_impl_.run_configuration_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::RunConfiguration>(GetArenaForAllocation());
    _impl_.run_configuration_ = p;
  }
  return _impl_.run_configuration_;
}
inline ::tensorflow::RunConfiguration* TestResults::mutable_run_configuration() {
  ::tensorflow::RunConfiguration* _msg = _internal_mutable_run_configuration();
  // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.run_configuration)
  return _msg;
}
inline void TestResults::set_allocated_run_configuration(::tensorflow::RunConfiguration* run_configuration) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.run_configuration_;
  }
  if (run_configuration) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(run_configuration);
    if (message_arena != submessage_arena) {
      run_configuration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, run_configuration, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.run_configuration_ = run_configuration;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.run_configuration)
}

// string name = 9;
inline void TestResults::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& TestResults::name() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TestResults::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.TestResults.name)
}
inline std::string* TestResults::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.name)
  return _s;
}
inline const std::string& TestResults::_internal_name() const {
  return _impl_.name_.Get();
}
inline void TestResults::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* TestResults::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* TestResults::release_name() {
  // @@protoc_insertion_point(field_release:tensorflow.TestResults.name)
  return _impl_.name_.Release();
}
inline void TestResults::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.name)
}

// .tensorflow.TestResults.BenchmarkType benchmark_type = 10;
inline void TestResults::clear_benchmark_type() {
  _impl_.benchmark_type_ = 0;
}
inline ::tensorflow::TestResults_BenchmarkType TestResults::_internal_benchmark_type() const {
  return static_cast< ::tensorflow::TestResults_BenchmarkType >(_impl_.benchmark_type_);
}
inline ::tensorflow::TestResults_BenchmarkType TestResults::benchmark_type() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.benchmark_type)
  return _internal_benchmark_type();
}
inline void TestResults::_internal_set_benchmark_type(::tensorflow::TestResults_BenchmarkType value) {
  
  _impl_.benchmark_type_ = value;
}
inline void TestResults::set_benchmark_type(::tensorflow::TestResults_BenchmarkType value) {
  _internal_set_benchmark_type(value);
  // @@protoc_insertion_point(field_set:tensorflow.TestResults.benchmark_type)
}

// string run_mode = 11;
inline void TestResults::clear_run_mode() {
  _impl_.run_mode_.ClearToEmpty();
}
inline const std::string& TestResults::run_mode() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.run_mode)
  return _internal_run_mode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TestResults::set_run_mode(ArgT0&& arg0, ArgT... args) {
 
 _impl_.run_mode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.TestResults.run_mode)
}
inline std::string* TestResults::mutable_run_mode() {
  std::string* _s = _internal_mutable_run_mode();
  // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.run_mode)
  return _s;
}
inline const std::string& TestResults::_internal_run_mode() const {
  return _impl_.run_mode_.Get();
}
inline void TestResults::_internal_set_run_mode(const std::string& value) {
  
  _impl_.run_mode_.Set(value, GetArenaForAllocation());
}
inline std::string* TestResults::_internal_mutable_run_mode() {
  
  return _impl_.run_mode_.Mutable(GetArenaForAllocation());
}
inline std::string* TestResults::release_run_mode() {
  // @@protoc_insertion_point(field_release:tensorflow.TestResults.run_mode)
  return _impl_.run_mode_.Release();
}
inline void TestResults::set_allocated_run_mode(std::string* run_mode) {
  if (run_mode != nullptr) {
    
  } else {
    
  }
  _impl_.run_mode_.SetAllocated(run_mode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.run_mode_.IsDefault()) {
    _impl_.run_mode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.run_mode)
}

// string tf_version = 12;
inline void TestResults::clear_tf_version() {
  _impl_.tf_version_.ClearToEmpty();
}
inline const std::string& TestResults::tf_version() const {
  // @@protoc_insertion_point(field_get:tensorflow.TestResults.tf_version)
  return _internal_tf_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TestResults::set_tf_version(ArgT0&& arg0, ArgT... args) {
 
 _impl_.tf_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.TestResults.tf_version)
}
inline std::string* TestResults::mutable_tf_version() {
  std::string* _s = _internal_mutable_tf_version();
  // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.tf_version)
  return _s;
}
inline const std::string& TestResults::_internal_tf_version() const {
  return _impl_.tf_version_.Get();
}
inline void TestResults::_internal_set_tf_version(const std::string& value) {
  
  _impl_.tf_version_.Set(value, GetArenaForAllocation());
}
inline std::string* TestResults::_internal_mutable_tf_version() {
  
  return _impl_.tf_version_.Mutable(GetArenaForAllocation());
}
inline std::string* TestResults::release_tf_version() {
  // @@protoc_insertion_point(field_release:tensorflow.TestResults.tf_version)
  return _impl_.tf_version_.Release();
}
inline void TestResults::set_allocated_tf_version(std::string* tf_version) {
  if (tf_version != nullptr) {
    
  } else {
    
  }
  _impl_.tf_version_.SetAllocated(tf_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tf_version_.IsDefault()) {
    _impl_.tf_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.tf_version)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace tensorflow

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::tensorflow::TestResults_BenchmarkType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::TestResults_BenchmarkType>() {
  return ::tensorflow::TestResults_BenchmarkType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tsl_2fprotobuf_2ftest_5flog_2eproto