text:
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tensorflow/core/framework/step_stats.proto

#ifndef PROTOBUF_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto__INCLUDED
#define PROTOBUF_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3004000
#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 3004000 < GOOGLE_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/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.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/unknown_field_set.h>
#include "tensorflow/core/framework/allocation_description.pb.h"
#include "tensorflow/core/framework/tensor_description.pb.h"
// @@protoc_insertion_point(includes)
namespace tensorflow {
class AllocationRecord;
class AllocationRecordDefaultTypeInternal;
extern AllocationRecordDefaultTypeInternal _AllocationRecord_default_instance_;
class AllocatorMemoryUsed;
class AllocatorMemoryUsedDefaultTypeInternal;
extern AllocatorMemoryUsedDefaultTypeInternal _AllocatorMemoryUsed_default_instance_;
class DeviceStepStats;
class DeviceStepStatsDefaultTypeInternal;
extern DeviceStepStatsDefaultTypeInternal _DeviceStepStats_default_instance_;
class MemoryStats;
class MemoryStatsDefaultTypeInternal;
extern MemoryStatsDefaultTypeInternal _MemoryStats_default_instance_;
class NodeExecStats;
class NodeExecStatsDefaultTypeInternal;
extern NodeExecStatsDefaultTypeInternal _NodeExecStats_default_instance_;
class NodeOutput;
class NodeOutputDefaultTypeInternal;
extern NodeOutputDefaultTypeInternal _NodeOutput_default_instance_;
class StepStats;
class StepStatsDefaultTypeInternal;
extern StepStatsDefaultTypeInternal _StepStats_default_instance_;
}  // namespace tensorflow

namespace tensorflow {

namespace protobuf_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto {
// Internal implementation detail -- do not call these.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[];
  static const ::google::protobuf::uint32 offsets[];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static void InitDefaultsImpl();
};
void AddDescriptors();
void InitDefaults();
}  // namespace protobuf_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto

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

class AllocationRecord : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.AllocationRecord) */ {
 public:
  AllocationRecord();
  virtual ~AllocationRecord();

  AllocationRecord(const AllocationRecord& from);

  inline AllocationRecord& operator=(const AllocationRecord& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  AllocationRecord(AllocationRecord&& from) noexcept
    : AllocationRecord() {
    *this = ::std::move(from);
  }

  inline AllocationRecord& operator=(AllocationRecord&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const AllocationRecord& default_instance();

  static inline const AllocationRecord* internal_default_instance() {
    return reinterpret_cast<const AllocationRecord*>(
               &_AllocationRecord_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    0;

  void UnsafeArenaSwap(AllocationRecord* other);
  void Swap(AllocationRecord* other);
  friend void swap(AllocationRecord& a, AllocationRecord& b) {
    a.Swap(&b);
  }

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

  inline AllocationRecord* New() const PROTOBUF_FINAL { return New(NULL); }

  AllocationRecord* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const AllocationRecord& from);
  void MergeFrom(const AllocationRecord& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(AllocationRecord* other);
  protected:
  explicit AllocationRecord(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // int64 alloc_micros = 1;
  void clear_alloc_micros();
  static const int kAllocMicrosFieldNumber = 1;
  ::google::protobuf::int64 alloc_micros() const;
  void set_alloc_micros(::google::protobuf::int64 value);

  // int64 alloc_bytes = 2;
  void clear_alloc_bytes();
  static const int kAllocBytesFieldNumber = 2;
  ::google::protobuf::int64 alloc_bytes() const;
  void set_alloc_bytes(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:tensorflow.AllocationRecord)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::int64 alloc_micros_;
  ::google::protobuf::int64 alloc_bytes_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class AllocatorMemoryUsed : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.AllocatorMemoryUsed) */ {
 public:
  AllocatorMemoryUsed();
  virtual ~AllocatorMemoryUsed();

  AllocatorMemoryUsed(const AllocatorMemoryUsed& from);

  inline AllocatorMemoryUsed& operator=(const AllocatorMemoryUsed& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  AllocatorMemoryUsed(AllocatorMemoryUsed&& from) noexcept
    : AllocatorMemoryUsed() {
    *this = ::std::move(from);
  }

  inline AllocatorMemoryUsed& operator=(AllocatorMemoryUsed&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const AllocatorMemoryUsed& default_instance();

  static inline const AllocatorMemoryUsed* internal_default_instance() {
    return reinterpret_cast<const AllocatorMemoryUsed*>(
               &_AllocatorMemoryUsed_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    1;

  void UnsafeArenaSwap(AllocatorMemoryUsed* other);
  void Swap(AllocatorMemoryUsed* other);
  friend void swap(AllocatorMemoryUsed& a, AllocatorMemoryUsed& b) {
    a.Swap(&b);
  }

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

  inline AllocatorMemoryUsed* New() const PROTOBUF_FINAL { return New(NULL); }

  AllocatorMemoryUsed* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const AllocatorMemoryUsed& from);
  void MergeFrom(const AllocatorMemoryUsed& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(AllocatorMemoryUsed* other);
  protected:
  explicit AllocatorMemoryUsed(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // repeated .tensorflow.AllocationRecord allocation_records = 6;
  int allocation_records_size() const;
  void clear_allocation_records();
  static const int kAllocationRecordsFieldNumber = 6;
  const ::tensorflow::AllocationRecord& allocation_records(int index) const;
  ::tensorflow::AllocationRecord* mutable_allocation_records(int index);
  ::tensorflow::AllocationRecord* add_allocation_records();
  ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationRecord >*
      mutable_allocation_records();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationRecord >&
      allocation_records() const;

  // string allocator_name = 1;
  void clear_allocator_name();
  static const int kAllocatorNameFieldNumber = 1;
  const ::std::string& allocator_name() const;
  void set_allocator_name(const ::std::string& value);
  #if LANG_CXX11
  void set_allocator_name(::std::string&& value);
  #endif
  void set_allocator_name(const char* value);
  void set_allocator_name(const char* value, size_t size);
  ::std::string* mutable_allocator_name();
  ::std::string* release_allocator_name();
  void set_allocated_allocator_name(::std::string* allocator_name);
  ::std::string* unsafe_arena_release_allocator_name();
  void unsafe_arena_set_allocated_allocator_name(
      ::std::string* allocator_name);

  // int64 total_bytes = 2;
  void clear_total_bytes();
  static const int kTotalBytesFieldNumber = 2;
  ::google::protobuf::int64 total_bytes() const;
  void set_total_bytes(::google::protobuf::int64 value);

  // int64 peak_bytes = 3;
  void clear_peak_bytes();
  static const int kPeakBytesFieldNumber = 3;
  ::google::protobuf::int64 peak_bytes() const;
  void set_peak_bytes(::google::protobuf::int64 value);

  // int64 live_bytes = 4;
  void clear_live_bytes();
  static const int kLiveBytesFieldNumber = 4;
  ::google::protobuf::int64 live_bytes() const;
  void set_live_bytes(::google::protobuf::int64 value);

  // int64 allocator_bytes_in_use = 5;
  void clear_allocator_bytes_in_use();
  static const int kAllocatorBytesInUseFieldNumber = 5;
  ::google::protobuf::int64 allocator_bytes_in_use() const;
  void set_allocator_bytes_in_use(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:tensorflow.AllocatorMemoryUsed)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationRecord > allocation_records_;
  ::google::protobuf::internal::ArenaStringPtr allocator_name_;
  ::google::protobuf::int64 total_bytes_;
  ::google::protobuf::int64 peak_bytes_;
  ::google::protobuf::int64 live_bytes_;
  ::google::protobuf::int64 allocator_bytes_in_use_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class NodeOutput : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.NodeOutput) */ {
 public:
  NodeOutput();
  virtual ~NodeOutput();

  NodeOutput(const NodeOutput& from);

  inline NodeOutput& operator=(const NodeOutput& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NodeOutput(NodeOutput&& from) noexcept
    : NodeOutput() {
    *this = ::std::move(from);
  }

  inline NodeOutput& operator=(NodeOutput&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const NodeOutput& default_instance();

  static inline const NodeOutput* internal_default_instance() {
    return reinterpret_cast<const NodeOutput*>(
               &_NodeOutput_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    2;

  void UnsafeArenaSwap(NodeOutput* other);
  void Swap(NodeOutput* other);
  friend void swap(NodeOutput& a, NodeOutput& b) {
    a.Swap(&b);
  }

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

  inline NodeOutput* New() const PROTOBUF_FINAL { return New(NULL); }

  NodeOutput* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const NodeOutput& from);
  void MergeFrom(const NodeOutput& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(NodeOutput* other);
  protected:
  explicit NodeOutput(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // .tensorflow.TensorDescription tensor_description = 3;
  bool has_tensor_description() const;
  void clear_tensor_description();
  static const int kTensorDescriptionFieldNumber = 3;
  private:
  void _slow_mutable_tensor_description();
  void _slow_set_allocated_tensor_description(
      ::google::protobuf::Arena* message_arena, ::tensorflow::TensorDescription** tensor_description);
  ::tensorflow::TensorDescription* _slow_release_tensor_description();
  public:
  const ::tensorflow::TensorDescription& tensor_description() const;
  ::tensorflow::TensorDescription* mutable_tensor_description();
  ::tensorflow::TensorDescription* release_tensor_description();
  void set_allocated_tensor_description(::tensorflow::TensorDescription* tensor_description);
  ::tensorflow::TensorDescription* unsafe_arena_release_tensor_description();
  void unsafe_arena_set_allocated_tensor_description(
      ::tensorflow::TensorDescription* tensor_description);

  // int32 slot = 1;
  void clear_slot();
  static const int kSlotFieldNumber = 1;
  ::google::protobuf::int32 slot() const;
  void set_slot(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:tensorflow.NodeOutput)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::tensorflow::TensorDescription* tensor_description_;
  ::google::protobuf::int32 slot_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class MemoryStats : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryStats) */ {
 public:
  MemoryStats();
  virtual ~MemoryStats();

  MemoryStats(const MemoryStats& from);

  inline MemoryStats& operator=(const MemoryStats& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  MemoryStats(MemoryStats&& from) noexcept
    : MemoryStats() {
    *this = ::std::move(from);
  }

  inline MemoryStats& operator=(MemoryStats&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const MemoryStats& default_instance();

  static inline const MemoryStats* internal_default_instance() {
    return reinterpret_cast<const MemoryStats*>(
               &_MemoryStats_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    3;

  void UnsafeArenaSwap(MemoryStats* other);
  void Swap(MemoryStats* other);
  friend void swap(MemoryStats& a, MemoryStats& b) {
    a.Swap(&b);
  }

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

  inline MemoryStats* New() const PROTOBUF_FINAL { return New(NULL); }

  MemoryStats* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const MemoryStats& from);
  void MergeFrom(const MemoryStats& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(MemoryStats* other);
  protected:
  explicit MemoryStats(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // repeated int64 host_persistent_tensor_alloc_ids = 5;
  int host_persistent_tensor_alloc_ids_size() const;
  void clear_host_persistent_tensor_alloc_ids();
  static const int kHostPersistentTensorAllocIdsFieldNumber = 5;
  ::google::protobuf::int64 host_persistent_tensor_alloc_ids(int index) const;
  void set_host_persistent_tensor_alloc_ids(int index, ::google::protobuf::int64 value);
  void add_host_persistent_tensor_alloc_ids(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      host_persistent_tensor_alloc_ids() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_host_persistent_tensor_alloc_ids();

  // repeated int64 device_persistent_tensor_alloc_ids = 6;
  int device_persistent_tensor_alloc_ids_size() const;
  void clear_device_persistent_tensor_alloc_ids();
  static const int kDevicePersistentTensorAllocIdsFieldNumber = 6;
  ::google::protobuf::int64 device_persistent_tensor_alloc_ids(int index) const;
  void set_device_persistent_tensor_alloc_ids(int index, ::google::protobuf::int64 value);
  void add_device_persistent_tensor_alloc_ids(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      device_persistent_tensor_alloc_ids() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_device_persistent_tensor_alloc_ids();

  // int64 host_temp_memory_size = 1;
  void clear_host_temp_memory_size();
  static const int kHostTempMemorySizeFieldNumber = 1;
  ::google::protobuf::int64 host_temp_memory_size() const;
  void set_host_temp_memory_size(::google::protobuf::int64 value);

  // int64 device_temp_memory_size = 2;
  void clear_device_temp_memory_size();
  static const int kDeviceTempMemorySizeFieldNumber = 2;
  ::google::protobuf::int64 device_temp_memory_size() const;
  void set_device_temp_memory_size(::google::protobuf::int64 value);

  // int64 host_persistent_memory_size = 3;
  void clear_host_persistent_memory_size();
  static const int kHostPersistentMemorySizeFieldNumber = 3;
  ::google::protobuf::int64 host_persistent_memory_size() const;
  void set_host_persistent_memory_size(::google::protobuf::int64 value);

  // int64 device_persistent_memory_size = 4;
  void clear_device_persistent_memory_size();
  static const int kDevicePersistentMemorySizeFieldNumber = 4;
  ::google::protobuf::int64 device_persistent_memory_size() const;
  void set_device_persistent_memory_size(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:tensorflow.MemoryStats)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > host_persistent_tensor_alloc_ids_;
  mutable int _host_persistent_tensor_alloc_ids_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > device_persistent_tensor_alloc_ids_;
  mutable int _device_persistent_tensor_alloc_ids_cached_byte_size_;
  ::google::protobuf::int64 host_temp_memory_size_;
  ::google::protobuf::int64 device_temp_memory_size_;
  ::google::protobuf::int64 host_persistent_memory_size_;
  ::google::protobuf::int64 device_persistent_memory_size_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class NodeExecStats : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.NodeExecStats) */ {
 public:
  NodeExecStats();
  virtual ~NodeExecStats();

  NodeExecStats(const NodeExecStats& from);

  inline NodeExecStats& operator=(const NodeExecStats& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NodeExecStats(NodeExecStats&& from) noexcept
    : NodeExecStats() {
    *this = ::std::move(from);
  }

  inline NodeExecStats& operator=(NodeExecStats&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const NodeExecStats& default_instance();

  static inline const NodeExecStats* internal_default_instance() {
    return reinterpret_cast<const NodeExecStats*>(
               &_NodeExecStats_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    4;

  void UnsafeArenaSwap(NodeExecStats* other);
  void Swap(NodeExecStats* other);
  friend void swap(NodeExecStats& a, NodeExecStats& b) {
    a.Swap(&b);
  }

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

  inline NodeExecStats* New() const PROTOBUF_FINAL { return New(NULL); }

  NodeExecStats* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const NodeExecStats& from);
  void MergeFrom(const NodeExecStats& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(NodeExecStats* other);
  protected:
  explicit NodeExecStats(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // repeated .tensorflow.AllocatorMemoryUsed memory = 6;
  int memory_size() const;
  void clear_memory();
  static const int kMemoryFieldNumber = 6;
  const ::tensorflow::AllocatorMemoryUsed& memory(int index) const;
  ::tensorflow::AllocatorMemoryUsed* mutable_memory(int index);
  ::tensorflow::AllocatorMemoryUsed* add_memory();
  ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed >*
      mutable_memory();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed >&
      memory() const;

  // repeated .tensorflow.NodeOutput output = 7;
  int output_size() const;
  void clear_output();
  static const int kOutputFieldNumber = 7;
  const ::tensorflow::NodeOutput& output(int index) const;
  ::tensorflow::NodeOutput* mutable_output(int index);
  ::tensorflow::NodeOutput* add_output();
  ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeOutput >*
      mutable_output();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeOutput >&
      output() const;

  // repeated .tensorflow.AllocationDescription referenced_tensor = 11;
  int referenced_tensor_size() const;
  void clear_referenced_tensor();
  static const int kReferencedTensorFieldNumber = 11;
  const ::tensorflow::AllocationDescription& referenced_tensor(int index) const;
  ::tensorflow::AllocationDescription* mutable_referenced_tensor(int index);
  ::tensorflow::AllocationDescription* add_referenced_tensor();
  ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationDescription >*
      mutable_referenced_tensor();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationDescription >&
      referenced_tensor() const;

  // string node_name = 1;
  void clear_node_name();
  static const int kNodeNameFieldNumber = 1;
  const ::std::string& node_name() const;
  void set_node_name(const ::std::string& value);
  #if LANG_CXX11
  void set_node_name(::std::string&& value);
  #endif
  void set_node_name(const char* value);
  void set_node_name(const char* value, size_t size);
  ::std::string* mutable_node_name();
  ::std::string* release_node_name();
  void set_allocated_node_name(::std::string* node_name);
  ::std::string* unsafe_arena_release_node_name();
  void unsafe_arena_set_allocated_node_name(
      ::std::string* node_name);

  // string timeline_label = 8;
  void clear_timeline_label();
  static const int kTimelineLabelFieldNumber = 8;
  const ::std::string& timeline_label() const;
  void set_timeline_label(const ::std::string& value);
  #if LANG_CXX11
  void set_timeline_label(::std::string&& value);
  #endif
  void set_timeline_label(const char* value);
  void set_timeline_label(const char* value, size_t size);
  ::std::string* mutable_timeline_label();
  ::std::string* release_timeline_label();
  void set_allocated_timeline_label(::std::string* timeline_label);
  ::std::string* unsafe_arena_release_timeline_label();
  void unsafe_arena_set_allocated_timeline_label(
      ::std::string* timeline_label);

  // .tensorflow.MemoryStats memory_stats = 12;
  bool has_memory_stats() const;
  void clear_memory_stats();
  static const int kMemoryStatsFieldNumber = 12;
  private:
  void _slow_mutable_memory_stats();
  void _slow_set_allocated_memory_stats(
      ::google::protobuf::Arena* message_arena, ::tensorflow::MemoryStats** memory_stats);
  ::tensorflow::MemoryStats* _slow_release_memory_stats();
  public:
  const ::tensorflow::MemoryStats& memory_stats() const;
  ::tensorflow::MemoryStats* mutable_memory_stats();
  ::tensorflow::MemoryStats* release_memory_stats();
  void set_allocated_memory_stats(::tensorflow::MemoryStats* memory_stats);
  ::tensorflow::MemoryStats* unsafe_arena_release_memory_stats();
  void unsafe_arena_set_allocated_memory_stats(
      ::tensorflow::MemoryStats* memory_stats);

  // int64 all_start_micros = 2;
  void clear_all_start_micros();
  static const int kAllStartMicrosFieldNumber = 2;
  ::google::protobuf::int64 all_start_micros() const;
  void set_all_start_micros(::google::protobuf::int64 value);

  // int64 op_start_rel_micros = 3;
  void clear_op_start_rel_micros();
  static const int kOpStartRelMicrosFieldNumber = 3;
  ::google::protobuf::int64 op_start_rel_micros() const;
  void set_op_start_rel_micros(::google::protobuf::int64 value);

  // int64 op_end_rel_micros = 4;
  void clear_op_end_rel_micros();
  static const int kOpEndRelMicrosFieldNumber = 4;
  ::google::protobuf::int64 op_end_rel_micros() const;
  void set_op_end_rel_micros(::google::protobuf::int64 value);

  // int64 all_end_rel_micros = 5;
  void clear_all_end_rel_micros();
  static const int kAllEndRelMicrosFieldNumber = 5;
  ::google::protobuf::int64 all_end_rel_micros() const;
  void set_all_end_rel_micros(::google::protobuf::int64 value);

  // int64 scheduled_micros = 9;
  void clear_scheduled_micros();
  static const int kScheduledMicrosFieldNumber = 9;
  ::google::protobuf::int64 scheduled_micros() const;
  void set_scheduled_micros(::google::protobuf::int64 value);

  // uint32 thread_id = 10;
  void clear_thread_id();
  static const int kThreadIdFieldNumber = 10;
  ::google::protobuf::uint32 thread_id() const;
  void set_thread_id(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:tensorflow.NodeExecStats)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed > memory_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeOutput > output_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationDescription > referenced_tensor_;
  ::google::protobuf::internal::ArenaStringPtr node_name_;
  ::google::protobuf::internal::ArenaStringPtr timeline_label_;
  ::tensorflow::MemoryStats* memory_stats_;
  ::google::protobuf::int64 all_start_micros_;
  ::google::protobuf::int64 op_start_rel_micros_;
  ::google::protobuf::int64 op_end_rel_micros_;
  ::google::protobuf::int64 all_end_rel_micros_;
  ::google::protobuf::int64 scheduled_micros_;
  ::google::protobuf::uint32 thread_id_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class DeviceStepStats : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.DeviceStepStats) */ {
 public:
  DeviceStepStats();
  virtual ~DeviceStepStats();

  DeviceStepStats(const DeviceStepStats& from);

  inline DeviceStepStats& operator=(const DeviceStepStats& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  DeviceStepStats(DeviceStepStats&& from) noexcept
    : DeviceStepStats() {
    *this = ::std::move(from);
  }

  inline DeviceStepStats& operator=(DeviceStepStats&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const DeviceStepStats& default_instance();

  static inline const DeviceStepStats* internal_default_instance() {
    return reinterpret_cast<const DeviceStepStats*>(
               &_DeviceStepStats_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    5;

  void UnsafeArenaSwap(DeviceStepStats* other);
  void Swap(DeviceStepStats* other);
  friend void swap(DeviceStepStats& a, DeviceStepStats& b) {
    a.Swap(&b);
  }

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

  inline DeviceStepStats* New() const PROTOBUF_FINAL { return New(NULL); }

  DeviceStepStats* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const DeviceStepStats& from);
  void MergeFrom(const DeviceStepStats& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(DeviceStepStats* other);
  protected:
  explicit DeviceStepStats(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // repeated .tensorflow.NodeExecStats node_stats = 2;
  int node_stats_size() const;
  void clear_node_stats();
  static const int kNodeStatsFieldNumber = 2;
  const ::tensorflow::NodeExecStats& node_stats(int index) const;
  ::tensorflow::NodeExecStats* mutable_node_stats(int index);
  ::tensorflow::NodeExecStats* add_node_stats();
  ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeExecStats >*
      mutable_node_stats();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeExecStats >&
      node_stats() const;

  // string device = 1;
  void clear_device();
  static const int kDeviceFieldNumber = 1;
  const ::std::string& device() const;
  void set_device(const ::std::string& value);
  #if LANG_CXX11
  void set_device(::std::string&& value);
  #endif
  void set_device(const char* value);
  void set_device(const char* value, size_t size);
  ::std::string* mutable_device();
  ::std::string* release_device();
  void set_allocated_device(::std::string* device);
  ::std::string* unsafe_arena_release_device();
  void unsafe_arena_set_allocated_device(
      ::std::string* device);

  // @@protoc_insertion_point(class_scope:tensorflow.DeviceStepStats)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeExecStats > node_stats_;
  ::google::protobuf::internal::ArenaStringPtr device_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class StepStats : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:tensorflow.StepStats) */ {
 public:
  StepStats();
  virtual ~StepStats();

  StepStats(const StepStats& from);

  inline StepStats& operator=(const StepStats& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StepStats(StepStats&& from) noexcept
    : StepStats() {
    *this = ::std::move(from);
  }

  inline StepStats& operator=(StepStats&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const StepStats& default_instance();

  static inline const StepStats* internal_default_instance() {
    return reinterpret_cast<const StepStats*>(
               &_StepStats_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    6;

  void UnsafeArenaSwap(StepStats* other);
  void Swap(StepStats* other);
  friend void swap(StepStats& a, StepStats& b) {
    a.Swap(&b);
  }

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

  inline StepStats* New() const PROTOBUF_FINAL { return New(NULL); }

  StepStats* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const StepStats& from);
  void MergeFrom(const StepStats& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(StepStats* other);
  protected:
  explicit StepStats(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // repeated .tensorflow.DeviceStepStats dev_stats = 1;
  int dev_stats_size() const;
  void clear_dev_stats();
  static const int kDevStatsFieldNumber = 1;
  const ::tensorflow::DeviceStepStats& dev_stats(int index) const;
  ::tensorflow::DeviceStepStats* mutable_dev_stats(int index);
  ::tensorflow::DeviceStepStats* add_dev_stats();
  ::google::protobuf::RepeatedPtrField< ::tensorflow::DeviceStepStats >*
      mutable_dev_stats();
  const ::google::protobuf::RepeatedPtrField< ::tensorflow::DeviceStepStats >&
      dev_stats() const;

  // @@protoc_insertion_point(class_scope:tensorflow.StepStats)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::RepeatedPtrField< ::tensorflow::DeviceStepStats > dev_stats_;
  mutable int _cached_size_;
  friend struct protobuf_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto::TableStruct;
};
// ===================================================================

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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// AllocationRecord

// int64 alloc_micros = 1;
inline void AllocationRecord::clear_alloc_micros() {
  alloc_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 AllocationRecord::alloc_micros() const {
  // @@protoc_insertion_point(field_get:tensorflow.AllocationRecord.alloc_micros)
  return alloc_micros_;
}
inline void AllocationRecord::set_alloc_micros(::google::protobuf::int64 value) {

  alloc_micros_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.AllocationRecord.alloc_micros)
}

// int64 alloc_bytes = 2;
inline void AllocationRecord::clear_alloc_bytes() {
  alloc_bytes_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 AllocationRecord::alloc_bytes() const {
  // @@protoc_insertion_point(field_get:tensorflow.AllocationRecord.alloc_bytes)
  return alloc_bytes_;
}
inline void AllocationRecord::set_alloc_bytes(::google::protobuf::int64 value) {

  alloc_bytes_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.AllocationRecord.alloc_bytes)
}

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

// AllocatorMemoryUsed

// string allocator_name = 1;
inline void AllocatorMemoryUsed::clear_allocator_name() {
  allocator_name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& AllocatorMemoryUsed::allocator_name() const {
  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.allocator_name)
  return allocator_name_.Get();
}
inline void AllocatorMemoryUsed::set_allocator_name(const ::std::string& value) {

  allocator_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.allocator_name)
}
#if LANG_CXX11
inline void AllocatorMemoryUsed::set_allocator_name(::std::string&& value) {

  allocator_name_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.AllocatorMemoryUsed.allocator_name)
}
#endif
inline void AllocatorMemoryUsed::set_allocator_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);

  allocator_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.AllocatorMemoryUsed.allocator_name)
}
inline void AllocatorMemoryUsed::set_allocator_name(const char* value,
    size_t size) {

  allocator_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.AllocatorMemoryUsed.allocator_name)
}
inline ::std::string* AllocatorMemoryUsed::mutable_allocator_name() {

  // @@protoc_insertion_point(field_mutable:tensorflow.AllocatorMemoryUsed.allocator_name)
  return allocator_name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* AllocatorMemoryUsed::release_allocator_name() {
  // @@protoc_insertion_point(field_release:tensorflow.AllocatorMemoryUsed.allocator_name)

  return allocator_name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* AllocatorMemoryUsed::unsafe_arena_release_allocator_name() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AllocatorMemoryUsed.allocator_name)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);

  return allocator_name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void AllocatorMemoryUsed::set_allocated_allocator_name(::std::string* allocator_name) {
  if (allocator_name != NULL) {

  } else {

  }
  allocator_name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), allocator_name,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.AllocatorMemoryUsed.allocator_name)
}
inline void AllocatorMemoryUsed::unsafe_arena_set_allocated_allocator_name(
    ::std::string* allocator_name) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (allocator_name != NULL) {

  } else {

  }
  allocator_name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      allocator_name, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AllocatorMemoryUsed.allocator_name)
}

// int64 total_bytes = 2;
inline void AllocatorMemoryUsed::clear_total_bytes() {
  total_bytes_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 AllocatorMemoryUsed::total_bytes() const {
  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.total_bytes)
  return total_bytes_;
}
inline void AllocatorMemoryUsed::set_total_bytes(::google::protobuf::int64 value) {

  total_bytes_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.total_bytes)
}

// int64 peak_bytes = 3;
inline void AllocatorMemoryUsed::clear_peak_bytes() {
  peak_bytes_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 AllocatorMemoryUsed::peak_bytes() const {
  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.peak_bytes)
  return peak_bytes_;
}
inline void AllocatorMemoryUsed::set_peak_bytes(::google::protobuf::int64 value) {

  peak_bytes_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.peak_bytes)
}

// int64 live_bytes = 4;
inline void AllocatorMemoryUsed::clear_live_bytes() {
  live_bytes_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 AllocatorMemoryUsed::live_bytes() const {
  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.live_bytes)
  return live_bytes_;
}
inline void AllocatorMemoryUsed::set_live_bytes(::google::protobuf::int64 value) {

  live_bytes_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.live_bytes)
}

// repeated .tensorflow.AllocationRecord allocation_records = 6;
inline int AllocatorMemoryUsed::allocation_records_size() const {
  return allocation_records_.size();
}
inline void AllocatorMemoryUsed::clear_allocation_records() {
  allocation_records_.Clear();
}
inline const ::tensorflow::AllocationRecord& AllocatorMemoryUsed::allocation_records(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.allocation_records)
  return allocation_records_.Get(index);
}
inline ::tensorflow::AllocationRecord* AllocatorMemoryUsed::mutable_allocation_records(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.AllocatorMemoryUsed.allocation_records)
  return allocation_records_.Mutable(index);
}
inline ::tensorflow::AllocationRecord* AllocatorMemoryUsed::add_allocation_records() {
  // @@protoc_insertion_point(field_add:tensorflow.AllocatorMemoryUsed.allocation_records)
  return allocation_records_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationRecord >*
AllocatorMemoryUsed::mutable_allocation_records() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.AllocatorMemoryUsed.allocation_records)
  return &allocation_records_;
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationRecord >&
AllocatorMemoryUsed::allocation_records() const {
  // @@protoc_insertion_point(field_list:tensorflow.AllocatorMemoryUsed.allocation_records)
  return allocation_records_;
}

// int64 allocator_bytes_in_use = 5;
inline void AllocatorMemoryUsed::clear_allocator_bytes_in_use() {
  allocator_bytes_in_use_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 AllocatorMemoryUsed::allocator_bytes_in_use() const {
  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.allocator_bytes_in_use)
  return allocator_bytes_in_use_;
}
inline void AllocatorMemoryUsed::set_allocator_bytes_in_use(::google::protobuf::int64 value) {

  allocator_bytes_in_use_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.allocator_bytes_in_use)
}

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

// NodeOutput

// int32 slot = 1;
inline void NodeOutput::clear_slot() {
  slot_ = 0;
}
inline ::google::protobuf::int32 NodeOutput::slot() const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeOutput.slot)
  return slot_;
}
inline void NodeOutput::set_slot(::google::protobuf::int32 value) {

  slot_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.NodeOutput.slot)
}

// .tensorflow.TensorDescription tensor_description = 3;
inline bool NodeOutput::has_tensor_description() const {
  return this != internal_default_instance() && tensor_description_ != NULL;
}
inline void NodeOutput::clear_tensor_description() {
  if (GetArenaNoVirtual() == NULL && tensor_description_ != NULL) delete tensor_description_;
  tensor_description_ = NULL;
}
inline const ::tensorflow::TensorDescription& NodeOutput::tensor_description() const {
  const ::tensorflow::TensorDescription* p = tensor_description_;
  // @@protoc_insertion_point(field_get:tensorflow.NodeOutput.tensor_description)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::TensorDescription*>(
      &::tensorflow::_TensorDescription_default_instance_);
}
inline ::tensorflow::TensorDescription* NodeOutput::mutable_tensor_description() {

  if (tensor_description_ == NULL) {
    _slow_mutable_tensor_description();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.NodeOutput.tensor_description)
  return tensor_description_;
}
inline ::tensorflow::TensorDescription* NodeOutput::release_tensor_description() {
  // @@protoc_insertion_point(field_release:tensorflow.NodeOutput.tensor_description)

  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_tensor_description();
  } else {
    ::tensorflow::TensorDescription* temp = tensor_description_;
    tensor_description_ = NULL;
    return temp;
  }
}
inline  void NodeOutput::set_allocated_tensor_description(::tensorflow::TensorDescription* tensor_description) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete tensor_description_;
  }
  if (tensor_description != NULL) {
    _slow_set_allocated_tensor_description(message_arena, &tensor_description);
  }
  tensor_description_ = tensor_description;
  if (tensor_description) {

  } else {

  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeOutput.tensor_description)
}

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

// MemoryStats

// int64 host_temp_memory_size = 1;
inline void MemoryStats::clear_host_temp_memory_size() {
  host_temp_memory_size_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 MemoryStats::host_temp_memory_size() const {
  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.host_temp_memory_size)
  return host_temp_memory_size_;
}
inline void MemoryStats::set_host_temp_memory_size(::google::protobuf::int64 value) {

  host_temp_memory_size_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.host_temp_memory_size)
}

// int64 device_temp_memory_size = 2;
inline void MemoryStats::clear_device_temp_memory_size() {
  device_temp_memory_size_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 MemoryStats::device_temp_memory_size() const {
  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.device_temp_memory_size)
  return device_temp_memory_size_;
}
inline void MemoryStats::set_device_temp_memory_size(::google::protobuf::int64 value) {

  device_temp_memory_size_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.device_temp_memory_size)
}

// int64 host_persistent_memory_size = 3;
inline void MemoryStats::clear_host_persistent_memory_size() {
  host_persistent_memory_size_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 MemoryStats::host_persistent_memory_size() const {
  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.host_persistent_memory_size)
  return host_persistent_memory_size_;
}
inline void MemoryStats::set_host_persistent_memory_size(::google::protobuf::int64 value) {

  host_persistent_memory_size_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.host_persistent_memory_size)
}

// int64 device_persistent_memory_size = 4;
inline void MemoryStats::clear_device_persistent_memory_size() {
  device_persistent_memory_size_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 MemoryStats::device_persistent_memory_size() const {
  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.device_persistent_memory_size)
  return device_persistent_memory_size_;
}
inline void MemoryStats::set_device_persistent_memory_size(::google::protobuf::int64 value) {

  device_persistent_memory_size_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.device_persistent_memory_size)
}

// repeated int64 host_persistent_tensor_alloc_ids = 5;
inline int MemoryStats::host_persistent_tensor_alloc_ids_size() const {
  return host_persistent_tensor_alloc_ids_.size();
}
inline void MemoryStats::clear_host_persistent_tensor_alloc_ids() {
  host_persistent_tensor_alloc_ids_.Clear();
}
inline ::google::protobuf::int64 MemoryStats::host_persistent_tensor_alloc_ids(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.host_persistent_tensor_alloc_ids)
  return host_persistent_tensor_alloc_ids_.Get(index);
}
inline void MemoryStats::set_host_persistent_tensor_alloc_ids(int index, ::google::protobuf::int64 value) {
  host_persistent_tensor_alloc_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.host_persistent_tensor_alloc_ids)
}
inline void MemoryStats::add_host_persistent_tensor_alloc_ids(::google::protobuf::int64 value) {
  host_persistent_tensor_alloc_ids_.Add(value);
  // @@protoc_insertion_point(field_add:tensorflow.MemoryStats.host_persistent_tensor_alloc_ids)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
MemoryStats::host_persistent_tensor_alloc_ids() const {
  // @@protoc_insertion_point(field_list:tensorflow.MemoryStats.host_persistent_tensor_alloc_ids)
  return host_persistent_tensor_alloc_ids_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
MemoryStats::mutable_host_persistent_tensor_alloc_ids() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.MemoryStats.host_persistent_tensor_alloc_ids)
  return &host_persistent_tensor_alloc_ids_;
}

// repeated int64 device_persistent_tensor_alloc_ids = 6;
inline int MemoryStats::device_persistent_tensor_alloc_ids_size() const {
  return device_persistent_tensor_alloc_ids_.size();
}
inline void MemoryStats::clear_device_persistent_tensor_alloc_ids() {
  device_persistent_tensor_alloc_ids_.Clear();
}
inline ::google::protobuf::int64 MemoryStats::device_persistent_tensor_alloc_ids(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
  return device_persistent_tensor_alloc_ids_.Get(index);
}
inline void MemoryStats::set_device_persistent_tensor_alloc_ids(int index, ::google::protobuf::int64 value) {
  device_persistent_tensor_alloc_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
}
inline void MemoryStats::add_device_persistent_tensor_alloc_ids(::google::protobuf::int64 value) {
  device_persistent_tensor_alloc_ids_.Add(value);
  // @@protoc_insertion_point(field_add:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
MemoryStats::device_persistent_tensor_alloc_ids() const {
  // @@protoc_insertion_point(field_list:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
  return device_persistent_tensor_alloc_ids_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
MemoryStats::mutable_device_persistent_tensor_alloc_ids() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
  return &device_persistent_tensor_alloc_ids_;
}

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

// NodeExecStats

// string node_name = 1;
inline void NodeExecStats::clear_node_name() {
  node_name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& NodeExecStats::node_name() const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.node_name)
  return node_name_.Get();
}
inline void NodeExecStats::set_node_name(const ::std::string& value) {

  node_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.node_name)
}
#if LANG_CXX11
inline void NodeExecStats::set_node_name(::std::string&& value) {

  node_name_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.NodeExecStats.node_name)
}
#endif
inline void NodeExecStats::set_node_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);

  node_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.NodeExecStats.node_name)
}
inline void NodeExecStats::set_node_name(const char* value,
    size_t size) {

  node_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeExecStats.node_name)
}
inline ::std::string* NodeExecStats::mutable_node_name() {

  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.node_name)
  return node_name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* NodeExecStats::release_node_name() {
  // @@protoc_insertion_point(field_release:tensorflow.NodeExecStats.node_name)

  return node_name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* NodeExecStats::unsafe_arena_release_node_name() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NodeExecStats.node_name)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);

  return node_name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void NodeExecStats::set_allocated_node_name(::std::string* node_name) {
  if (node_name != NULL) {

  } else {

  }
  node_name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), node_name,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeExecStats.node_name)
}
inline void NodeExecStats::unsafe_arena_set_allocated_node_name(
    ::std::string* node_name) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (node_name != NULL) {

  } else {

  }
  node_name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      node_name, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeExecStats.node_name)
}

// int64 all_start_micros = 2;
inline void NodeExecStats::clear_all_start_micros() {
  all_start_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 NodeExecStats::all_start_micros() const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.all_start_micros)
  return all_start_micros_;
}
inline void NodeExecStats::set_all_start_micros(::google::protobuf::int64 value) {

  all_start_micros_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.all_start_micros)
}

// int64 op_start_rel_micros = 3;
inline void NodeExecStats::clear_op_start_rel_micros() {
  op_start_rel_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 NodeExecStats::op_start_rel_micros() const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.op_start_rel_micros)
  return op_start_rel_micros_;
}
inline void NodeExecStats::set_op_start_rel_micros(::google::protobuf::int64 value) {

  op_start_rel_micros_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.op_start_rel_micros)
}

// int64 op_end_rel_micros = 4;
inline void NodeExecStats::clear_op_end_rel_micros() {
  op_end_rel_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 NodeExecStats::op_end_rel_micros() const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.op_end_rel_micros)
  return op_end_rel_micros_;
}
inline void NodeExecStats::set_op_end_rel_micros(::google::protobuf::int64 value) {

  op_end_rel_micros_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.op_end_rel_micros)
}

// int64 all_end_rel_micros = 5;
inline void NodeExecStats::clear_all_end_rel_micros() {
  all_end_rel_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 NodeExecStats::all_end_rel_micros() const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.all_end_rel_micros)
  return all_end_rel_micros_;
}
inline void NodeExecStats::set_all_end_rel_micros(::google::protobuf::int64 value) {

  all_end_rel_micros_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.all_end_rel_micros)
}

// repeated .tensorflow.AllocatorMemoryUsed memory = 6;
inline int NodeExecStats::memory_size() const {
  return memory_.size();
}
inline void NodeExecStats::clear_memory() {
  memory_.Clear();
}
inline const ::tensorflow::AllocatorMemoryUsed& NodeExecStats::memory(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.memory)
  return memory_.Get(index);
}
inline ::tensorflow::AllocatorMemoryUsed* NodeExecStats::mutable_memory(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.memory)
  return memory_.Mutable(index);
}
inline ::tensorflow::AllocatorMemoryUsed* NodeExecStats::add_memory() {
  // @@protoc_insertion_point(field_add:tensorflow.NodeExecStats.memory)
  return memory_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed >*
NodeExecStats::mutable_memory() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeExecStats.memory)
  return &memory_;
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed >&
NodeExecStats::memory() const {
  // @@protoc_insertion_point(field_list:tensorflow.NodeExecStats.memory)
  return memory_;
}

// repeated .tensorflow.NodeOutput output = 7;
inline int NodeExecStats::output_size() const {
  return output_.size();
}
inline void NodeExecStats::clear_output() {
  output_.Clear();
}
inline const ::tensorflow::NodeOutput& NodeExecStats::output(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.output)
  return output_.Get(index);
}
inline ::tensorflow::NodeOutput* NodeExecStats::mutable_output(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.output)
  return output_.Mutable(index);
}
inline ::tensorflow::NodeOutput* NodeExecStats::add_output() {
  // @@protoc_insertion_point(field_add:tensorflow.NodeExecStats.output)
  return output_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeOutput >*
NodeExecStats::mutable_output() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeExecStats.output)
  return &output_;
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeOutput >&
NodeExecStats::output() const {
  // @@protoc_insertion_point(field_list:tensorflow.NodeExecStats.output)
  return output_;
}

// string timeline_label = 8;
inline void NodeExecStats::clear_timeline_label() {
  timeline_label_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& NodeExecStats::timeline_label() const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.timeline_label)
  return timeline_label_.Get();
}
inline void NodeExecStats::set_timeline_label(const ::std::string& value) {

  timeline_label_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.timeline_label)
}
#if LANG_CXX11
inline void NodeExecStats::set_timeline_label(::std::string&& value) {

  timeline_label_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.NodeExecStats.timeline_label)
}
#endif
inline void NodeExecStats::set_timeline_label(const char* value) {
  GOOGLE_DCHECK(value != NULL);

  timeline_label_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.NodeExecStats.timeline_label)
}
inline void NodeExecStats::set_timeline_label(const char* value,
    size_t size) {

  timeline_label_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeExecStats.timeline_label)
}
inline ::std::string* NodeExecStats::mutable_timeline_label() {

  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.timeline_label)
  return timeline_label_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* NodeExecStats::release_timeline_label() {
  // @@protoc_insertion_point(field_release:tensorflow.NodeExecStats.timeline_label)

  return timeline_label_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* NodeExecStats::unsafe_arena_release_timeline_label() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NodeExecStats.timeline_label)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);

  return timeline_label_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void NodeExecStats::set_allocated_timeline_label(::std::string* timeline_label) {
  if (timeline_label != NULL) {

  } else {

  }
  timeline_label_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), timeline_label,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeExecStats.timeline_label)
}
inline void NodeExecStats::unsafe_arena_set_allocated_timeline_label(
    ::std::string* timeline_label) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (timeline_label != NULL) {

  } else {

  }
  timeline_label_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      timeline_label, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeExecStats.timeline_label)
}

// int64 scheduled_micros = 9;
inline void NodeExecStats::clear_scheduled_micros() {
  scheduled_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 NodeExecStats::scheduled_micros() const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.scheduled_micros)
  return scheduled_micros_;
}
inline void NodeExecStats::set_scheduled_micros(::google::protobuf::int64 value) {

  scheduled_micros_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.scheduled_micros)
}

// uint32 thread_id = 10;
inline void NodeExecStats::clear_thread_id() {
  thread_id_ = 0u;
}
inline ::google::protobuf::uint32 NodeExecStats::thread_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.thread_id)
  return thread_id_;
}
inline void NodeExecStats::set_thread_id(::google::protobuf::uint32 value) {

  thread_id_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.thread_id)
}

// repeated .tensorflow.AllocationDescription referenced_tensor = 11;
inline int NodeExecStats::referenced_tensor_size() const {
  return referenced_tensor_.size();
}
inline void NodeExecStats::clear_referenced_tensor() {
  referenced_tensor_.Clear();
}
inline const ::tensorflow::AllocationDescription& NodeExecStats::referenced_tensor(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.referenced_tensor)
  return referenced_tensor_.Get(index);
}
inline ::tensorflow::AllocationDescription* NodeExecStats::mutable_referenced_tensor(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.referenced_tensor)
  return referenced_tensor_.Mutable(index);
}
inline ::tensorflow::AllocationDescription* NodeExecStats::add_referenced_tensor() {
  // @@protoc_insertion_point(field_add:tensorflow.NodeExecStats.referenced_tensor)
  return referenced_tensor_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationDescription >*
NodeExecStats::mutable_referenced_tensor() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeExecStats.referenced_tensor)
  return &referenced_tensor_;
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::AllocationDescription >&
NodeExecStats::referenced_tensor() const {
  // @@protoc_insertion_point(field_list:tensorflow.NodeExecStats.referenced_tensor)
  return referenced_tensor_;
}

// .tensorflow.MemoryStats memory_stats = 12;
inline bool NodeExecStats::has_memory_stats() const {
  return this != internal_default_instance() && memory_stats_ != NULL;
}
inline void NodeExecStats::clear_memory_stats() {
  if (GetArenaNoVirtual() == NULL && memory_stats_ != NULL) delete memory_stats_;
  memory_stats_ = NULL;
}
inline const ::tensorflow::MemoryStats& NodeExecStats::memory_stats() const {
  const ::tensorflow::MemoryStats* p = memory_stats_;
  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.memory_stats)
  return p != NULL ? *p : *reinterpret_cast<const ::tensorflow::MemoryStats*>(
      &::tensorflow::_MemoryStats_default_instance_);
}
inline ::tensorflow::MemoryStats* NodeExecStats::mutable_memory_stats() {

  if (memory_stats_ == NULL) {
    _slow_mutable_memory_stats();
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.memory_stats)
  return memory_stats_;
}
inline ::tensorflow::MemoryStats* NodeExecStats::release_memory_stats() {
  // @@protoc_insertion_point(field_release:tensorflow.NodeExecStats.memory_stats)

  if (GetArenaNoVirtual() != NULL) {
    return _slow_release_memory_stats();
  } else {
    ::tensorflow::MemoryStats* temp = memory_stats_;
    memory_stats_ = NULL;
    return temp;
  }
}
inline  void NodeExecStats::set_allocated_memory_stats(::tensorflow::MemoryStats* memory_stats) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete memory_stats_;
  }
  if (memory_stats != NULL) {
    _slow_set_allocated_memory_stats(message_arena, &memory_stats);
  }
  memory_stats_ = memory_stats;
  if (memory_stats) {

  } else {

  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeExecStats.memory_stats)
}

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

// DeviceStepStats

// string device = 1;
inline void DeviceStepStats::clear_device() {
  device_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline const ::std::string& DeviceStepStats::device() const {
  // @@protoc_insertion_point(field_get:tensorflow.DeviceStepStats.device)
  return device_.Get();
}
inline void DeviceStepStats::set_device(const ::std::string& value) {

  device_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:tensorflow.DeviceStepStats.device)
}
#if LANG_CXX11
inline void DeviceStepStats::set_device(::std::string&& value) {

  device_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:tensorflow.DeviceStepStats.device)
}
#endif
inline void DeviceStepStats::set_device(const char* value) {
  GOOGLE_DCHECK(value != NULL);

  device_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:tensorflow.DeviceStepStats.device)
}
inline void DeviceStepStats::set_device(const char* value,
    size_t size) {

  device_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:tensorflow.DeviceStepStats.device)
}
inline ::std::string* DeviceStepStats::mutable_device() {

  // @@protoc_insertion_point(field_mutable:tensorflow.DeviceStepStats.device)
  return device_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* DeviceStepStats::release_device() {
  // @@protoc_insertion_point(field_release:tensorflow.DeviceStepStats.device)

  return device_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* DeviceStepStats::unsafe_arena_release_device() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DeviceStepStats.device)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);

  return device_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void DeviceStepStats::set_allocated_device(::std::string* device) {
  if (device != NULL) {

  } else {

  }
  device_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), device,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceStepStats.device)
}
inline void DeviceStepStats::unsafe_arena_set_allocated_device(
    ::std::string* device) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (device != NULL) {

  } else {

  }
  device_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      device, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DeviceStepStats.device)
}

// repeated .tensorflow.NodeExecStats node_stats = 2;
inline int DeviceStepStats::node_stats_size() const {
  return node_stats_.size();
}
inline void DeviceStepStats::clear_node_stats() {
  node_stats_.Clear();
}
inline const ::tensorflow::NodeExecStats& DeviceStepStats::node_stats(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.DeviceStepStats.node_stats)
  return node_stats_.Get(index);
}
inline ::tensorflow::NodeExecStats* DeviceStepStats::mutable_node_stats(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.DeviceStepStats.node_stats)
  return node_stats_.Mutable(index);
}
inline ::tensorflow::NodeExecStats* DeviceStepStats::add_node_stats() {
  // @@protoc_insertion_point(field_add:tensorflow.DeviceStepStats.node_stats)
  return node_stats_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeExecStats >*
DeviceStepStats::mutable_node_stats() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.DeviceStepStats.node_stats)
  return &node_stats_;
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::NodeExecStats >&
DeviceStepStats::node_stats() const {
  // @@protoc_insertion_point(field_list:tensorflow.DeviceStepStats.node_stats)
  return node_stats_;
}

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

// StepStats

// repeated .tensorflow.DeviceStepStats dev_stats = 1;
inline int StepStats::dev_stats_size() const {
  return dev_stats_.size();
}
inline void StepStats::clear_dev_stats() {
  dev_stats_.Clear();
}
inline const ::tensorflow::DeviceStepStats& StepStats::dev_stats(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.StepStats.dev_stats)
  return dev_stats_.Get(index);
}
inline ::tensorflow::DeviceStepStats* StepStats::mutable_dev_stats(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.StepStats.dev_stats)
  return dev_stats_.Mutable(index);
}
inline ::tensorflow::DeviceStepStats* StepStats::add_dev_stats() {
  // @@protoc_insertion_point(field_add:tensorflow.StepStats.dev_stats)
  return dev_stats_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::tensorflow::DeviceStepStats >*
StepStats::mutable_dev_stats() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.StepStats.dev_stats)
  return &dev_stats_;
}
inline const ::google::protobuf::RepeatedPtrField< ::tensorflow::DeviceStepStats >&
StepStats::dev_stats() const {
  // @@protoc_insertion_point(field_list:tensorflow.StepStats.dev_stats)
  return dev_stats_;
}

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

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

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

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

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

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

// @@protoc_insertion_point(namespace_scope)

}  // namespace tensorflow

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto__INCLUDED

redpajama_set_name: RedPajamaGithub


text:
Science›
Hurricane Florence could be the most powerful storm to ever make landfall north of Florida
Jeremy BerkeSep 11, 2018, 23:39 IST
Hurricane Florence over the Atlantic.
Hurricane Florence could be the most powerful storm to make landfall in North Carolina if predictions hold - no Category 4 hurricane has ever made landfall in the state.
Florence may even be the strongest hurricane ever to hit the US north of Florida.
The storm is being fed by warmer-than-average waters.
Hurricane Florence may be the strongest storm ever to make landfall north of Florida if predictions hold.
The Category 4 storm is located 905 miles east of Cape Fear, North Carolina and has maximum wind speeds of 130 mph, according to the National Hurricane Center.
Only four Category 4 hurricanes have ever made landfall north of Florida since records were kept, according to The Weather Channel. All of those, however, made landfall south of where Florence is predicted to hit, and Florence's wind speeds are predicted to be higher than those four storms.
Hurricane Hugo, the strongest hurricane ever to impact North Carolina, actually made landfall just north of Charleston, South Carolina in 1989 with 130 mph winds. If Hurricane Florence's predicted track holds, it will be the first Category 4 storm to make landfall directly on the North Carolina coast.
Read More: Here's what Category 1, 2, 3, 4, and 5 labels for hurricanes really mean
The storm will also have stronger winds than Hugo did if Florence strengthens as predicted. The NHC warned on Tuesday that the storm may strengthen to Category 5, with wind speeds in excess of 157 mph, as it moves over a band of warmer water off of North Carolina's coast.
Warmer ocean water makes hurricanes more intense because the storms are fed by evaporating water. With warmer ocean water, there's more energy available to power the hurricane, according to Nature.
On Wednesday and Thursday, Florence is predicted to move across a band of water that's around 84 degrees Fahrenheit, which is 3 or 4 degrees higher than average for this time of year. Hurricanes typically need a minimum sea surface temperature of 79 degrees, according to The Weather Channel.
The warming ocean temperatures are linked to climate change caused by heat-trapping greenhouse gases in the atmosphere.
Hurricane Florence is predicted to be the size of the entire state of North Carolina when it makes landfall late Thursday night or early Friday morning.
Read More: Here's a map of all the areas that could get hit
The storm's 175-mile wide "cone of probability" suggests the storm will likely hit North Carolina's coast near Cape Fear, but storms fall outside the cone one-third of the time, according to The Weather Channel.
Category 4 hurricanes are unusual this far north. Hurricanes need warm water to thrive - and the sea surface temperature of ocean water cools as you get further away from the tropics.
The hurricane could inundate low-lying islands off the coast of North Carolina, like the Outer Banks and other barrier islands, according to the NHC. Heavy rain may extend as far inland as Charlotte, North Carolina's largest city, though the severity will depend on the storm's track, according to The Charlotte Observer.
As of Tuesday morning, close to 1.5 million people were under evacuation orders in South Carolina, North Carolina, and Virginia.
Read more of Business Insider's hurricane coverage:
Hurricane Florence is barreling toward the Carolinas, with about 1.5 million people ordered to evacuate - here are the areas that could get hit
Hurricane Florence is forecast to be as big as the whole state of North Carolina when it hits the US
The 13 most important things you should do to prepare for a hurricane
'Spaghetti models' show potential paths for storms like Hurricane Florence - here's what they mean
We've reached the peak of Atlantic hurricane season - and three hurricanes are churning at once
Astronauts in space just photographed 3 threatening hurricanes lurking in the Atlantic Ocean
NOW WATCH: Most hurricanes that hit the US come from the same exact spot in the world
Next StoryWe've reached the peak of Atlantic hurricane season - and three hurricanes are churning at once
TBSE Class 12th (Science) board exam results declared; check scores on tripuraresults.nic.in
17 science 'facts' you might have learned in school that aren't true
Health and science startups could be uniquely positioned to dupe investors and the public, experts say

redpajama_set_name: RedPajamaCommonCrawl


text:
Home FOOD & DRINK Star Milwaukee Chef Sanford D'Amato pens memoir "Good Stock", comes to Madison to cook
Star Milwaukee Chef Sanford D'Amato pens memoir "Good Stock", comes to Madison to cook
by André Darlington
Agate Midway
Good Stock: Life on a Low Simmer
Wisconsin chef Sanford D'Amato's book, Good Stock: Life on a Low Simmer will be released next month, and the chef is currently on a tour through Madison and Milwaukee. He recently finished a five-night stint at his former restaurant, Sanford, in Milwaukee, and he comes to Madison with a dinner at L'Etoile on Oct. 30 and another at Heritage Tavern on Nov. 3. Copies of the book will be available at these events.
D'Amato sold Sanford to his chef de cuisine, Justin Aprahamian, in late 2012, ending a decades-long run at the nationally renowned restaurant that he opened with his wife, Angie, in 1989.
D'Amato's personal story cleaves close to the rise of the modern American food revolution of the last third of the 20th century, and his delectable memoir is loaded with incredible anecdotes: He enrolled at the very first class at the Culinary Institute of America at Hyde Park when it opened in 1972, and was present for the opening party; he worked in some of New York's top French kitchens back when no American chefs ever had; he was a James Beard Award nominee the first year the accolade was given (and was in subsequent years, until he won); he rode in the Wienermobile with Julia Child, took her to the now-defunct Gobbler revolving supper club in Johnson Creek, and cooked for her 80th birthday party.
But D'Amato also relates more mundane personal moments in Good Stock with great skill and feeling. There's the classic Americana story of his first cigarette at a Big Boy, the magical tale of his uncle roasting hazelnuts in sand bags.
D'Amato grew up above his family's grocery, and he returned to live in the building when he transformed the space into Sanford. The homecoming gives a charming circularity to his tales, which are always humorous, poignant and unpretentious.
The book is a must-read for anyone interested in a first-person snapshot of American culinary history -- in how a Midwestern boy can go from eating TV dinners to being one of the most well regarded chefs of a generation.
The thoughtfulness, curiosity and attention to detail necessary for such a journey are aptly reflected in this lovable memoir, which will certainly be one of the year's best. The book makes clear that D'Amato has always been hungry for the unexplored, working toward his signature "Modern Ethnic" cuisine that he honed at Sanford.
In addition to the stories, each chapter is dotted with tempting, well-written recipes that are related to significant points in D'Amato's life. Unlike so many chef cookbooks, D'Amato is able to make these recipes meaningful to the reader. The result is a warm, compelling memoir that will bubble over into home kitchens everywhere.
Longtime Sanford fans will recognize some of these recipes and rejoice at trying them themselves. New fans, finding their way to D'Amato's food through his memoir for the first time, may find them quickly becoming part of their family's food repertoire.


text:
Australia's first Passivhaus apartment block a 'sign of what's possible'
News | Patrick Hunn
The Fern by Steele Associates.
Image: courtesy Steele Associates
The architect and builder behind Australia's first apartment building to meet the exacting Passivhaus building principles hopes the development will "show what's possible" in the design and construction of sustainable apartments.
Oliver Steele, of Steele Associates, said the recently completed apartment block The Fern in Sydney's Redfern was a demonstration of sustainable design beyond passive solar principles.
<!— /5912001/AAU_AU_MR_side_300x250 —>

The Passivhaus building model was initially developed by German physicist Wolfgang Feist in the 1980s. While the system has been used in Australia, it has not yet been used in the design and construction of a multi-residential building.
The 11 apartments in the building have been almost entirely sealed, with air drawn into the units through a Heat Recovery Ventilation system that filters dust, pollution and allergens. Insulation comes not only from triple-glazed doors and windows, but also structural thermal breaks that prevent heat transfer. For instance, a balcony on a conventional apartment is typically an extension of the concrete floor slab that acts as a kind of heat fin, drawing or dispersing heat from the apartment interior. At The Fern, the balcony plates are insulated from the floor slab by a barrier of rigid foam, and affixed to the structure by stainless steel dowels.
Steele said that he was drawn to the Passivhaus methodology when more typical passive solar design principles proved too rigid to apply effectively in an urban setting.
"I was trained in passive solar design, and that's what I've practised until now," he said. "But I've always found that it has its limitations, especially when the site doesn't allow you to have north-facing glazing. Passive solar design relies on getting winter sun in to heat the house, and excluding summer sun – which is great if you've got a greenfield site and you can orient everything correctly. But in city infill sites you often don't have that luxury.
<!— /5912001/AAU_AU_MR2_side_300x250 —>

"In this particular case the northern facade is a firewall because it's a boundary, so we couldn't have northern light coming in and we have a conventionally unfavourable east-west orientation. Passivhaus has the tools to overcome that, with its Heat Recovery Ventilation and super-insulation and airtightness. It can work with the passive solar principals [as well], but it doesn't require passive solar gains to be functional."
Steele also pointed out that the sustainability benefits are measurable under more conventional appraisal systems, with the building achieving between a 9.3- and a 10-star NatHERS energy rating.
<!— /5912001/AAU_AU_MR3_side_300x25 —>

"The proof really is in the pudding. The apartments are very quiet and comfortable, and the east-west alignment isn't proving to be such a problem as it might be without the Passivhaus principles."
The Passivhaus principals are unusually complete and exacting in their specifications, which can be looked at as one explanation for the slow uptake of the principles in Australia.
"I'm sometimes frustrated by people calling something a 'sustainable house' or a 'green project' because they put some solar panels or a water tank on it – and then you look at the huge areas of single glazing. And [the designers] will say it's going to have a lot of natural light, which is true, but it's also going to have a heck of a lot of heat loss in winter. Passivhaus is a very thorough, rigorous building methodology that gives you a certainty of outcome."
"It was designed by a physicist, not an architect, so it is intended to have replicable outcomes in terms of quality."
Steele conceded that the precise and demanding construction requirements of the Passivhaus principles, particularly those regarding airtightness, can seem onerous.
"It's a big challenge, especially for builders who are used to doing things differently."
Steele pointed to a 2016 study by the CSIRO into the airtightness of newly built homes in Australia which found that homes in Sydney were more than forty times less airtight than a home built to Passivhaus specifications. Achieving that, Steele said, "is a lot of work."
Another barrier to uptake is Australia's relatively low energy costs by international standards. Overseas, the higher construction cost can usually be rationalized by the long-term savings made in ventilating, heating and cooling the interior.
"When you look at it in terms of payback period, going Passive is not necessarily going to give you a great return. It's really got to be about a qualitative, rather than quantitative outcome."
Steele said he hoped that The Fern would be an example of what is possible using the methodology.
"Hopefully this project will help [people see] that, even if not fully Passivhaus-certified, these principles are worth taking seriously."
Tension as controversial Hobart hotel proposal recommended for approval
A proposed hotel in a public reserve in Hobart has been recommended for approval, but opponents of the project are gearing up for a fight.
Humanitarian architect wins global women in architecture award
Pakistan's first female architect, who's had a decades-long career in humanitarian architecture, has been honoured in the 2020 W Awards.
'Sculptural family of towers' proposed for suburban Brisbane
A proposed multi-use complex in Lutwyche by Conrad Gargett will create a fluid and transparent public dialogue with its surroundings.
Design challenge for the future of senior living
The University of Queensland is seeking participants for a design challenge to imagine Australia's aged care system in 2050.
News Gray Puksand designs high school with 'neighbourhood' feel for Shepparton


The England U19s are gearing up for a challenging set of fixtures in May – a series of matches that will pit them against Scotland, Belgium and Georgia in the hope that they can top the group and qualify or the U19 European Championship Finals this summer.
Arguably their toughest opponent will be the home side, Belgium. In order to best prepare, England and coach Noel Blake will be playing Turkey on 21 March at the home of AFC Telford. It will be the last chance for Blake to assess his charges and pick a squad that can challenge for honours.
In the last squad before the Elite Qualifiers kick off, England U19s will welcome in a few new faces – primarily from the northwest. The joke used to be Noel Blake picked only players from Liverpool – that has certainly changed!
Everton will be well represented with four players (Tyias Browning, John Stones, Matthew Pennington, John Lundstram), one former loanee (Eric Dier), and one former striker (Anton Forrester), while Manchester United midfielder Nick Powell drops down to compete at U19 level.
Elsehwere, Josh Murphy retains his spot, while twin Jacob is on standby. Premier League experience is provided by the inimitable James Ward-Prowse, who should be a guaranteed starter along with Dan Potts. Starlet Chuba Akpom will be looking to add to his impressive tally of goals this term, while Dominic Samuel and Max Clayton provide some welcome Football League experience.
I hope we pick some deep lying midfielders with actual technical ability as well as good passing/positioning/awareness instead of the usual english way of favouring athleticism and physical attributes. its no use having good forward players if we cant get the ball into their feet.


text:
Warcisław (ur. ok. 1120, zm. 1164) – książę Obodrzytów, syn Niklota.

Po śmierci ojca w 1160 roku objął wraz z bratem Przybysławem panowanie w części dawnego księstwa obodrzyckiego z ośrodkiem w Werle, jako lennik Henryka Lwa. W 1163 roku Henryk najechał ziemie obodrzyckie pod pretekstem uprzedzenia rzekomych przygotowań wojennych i obległ Warcisława w grodzie Werle. Pozbawiony wsparcia książę poddał się i został uwięziony w Brunszwiku.

W roku 1164 Henryk Lew zawiązał koalicję z margrabią brandenburskim Albrechtem Niedźwiedziem i królem duńskim Waldemarem, rozpoczynając wielką kampanię wojenną przeciwko Przybysławowi. Rozkazał wówczas przewieźć więzionego Warcisława do Malechowa, gdzie został powieszony.

Przypisy

Książęta obodrzyccy
Zmarli w 1164
Urodzeni w XII wieku

redpajama_set_name: RedPajamaWikipedia


A group of cartoon characters from various different franchises decide that today's their day to head out and golf. However, little do they know that a Shadow King and his two servants are preparing to take over the world, and will they be able to stop it before it is too late.
Browse cast and crew roles for Cartoon Golfing below, with the most popular fan casting suggestion shown. Click to see all suggestions and vote for your favorite!