// <auto-generated>
//     Generated by the protocol buffer compiler.  DO NOT EDIT!
//     source: tensorflow/core/framework/step_stats.proto
// </auto-generated>
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Tensorflow {

  /// <summary>Holder for reflection information generated from tensorflow/core/framework/step_stats.proto</summary>
  public static partial class StepStatsReflection {

    #region Descriptor
    /// <summary>File descriptor for tensorflow/core/framework/step_stats.proto</summary>
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static StepStatsReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "Cip0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL3N0ZXBfc3RhdHMucHJvdG8S",
            "CnRlbnNvcmZsb3caNnRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvYWxsb2Nh",
            "dGlvbl9kZXNjcmlwdGlvbi5wcm90bxoydGVuc29yZmxvdy9jb3JlL2ZyYW1l",
            "d29yay90ZW5zb3JfZGVzY3JpcHRpb24ucHJvdG8iPQoQQWxsb2NhdGlvblJl",
            "Y29yZBIUCgxhbGxvY19taWNyb3MYASABKAMSEwoLYWxsb2NfYnl0ZXMYAiAB",
            "KAMixAEKE0FsbG9jYXRvck1lbW9yeVVzZWQSFgoOYWxsb2NhdG9yX25hbWUY",
            "ASABKAkSEwoLdG90YWxfYnl0ZXMYAiABKAMSEgoKcGVha19ieXRlcxgDIAEo",
            "AxISCgpsaXZlX2J5dGVzGAQgASgDEjgKEmFsbG9jYXRpb25fcmVjb3JkcxgG",
            "IAMoCzIcLnRlbnNvcmZsb3cuQWxsb2NhdGlvblJlY29yZBIeChZhbGxvY2F0",
            "b3JfYnl0ZXNfaW5fdXNlGAUgASgDIlUKCk5vZGVPdXRwdXQSDAoEc2xvdBgB",
            "IAEoBRI5ChJ0ZW5zb3JfZGVzY3JpcHRpb24YAyABKAsyHS50ZW5zb3JmbG93",
            "LlRlbnNvckRlc2NyaXB0aW9uIuwBCgtNZW1vcnlTdGF0cxIYChB0ZW1wX21l",
            "bW9yeV9zaXplGAEgASgDEh4KFnBlcnNpc3RlbnRfbWVtb3J5X3NpemUYAyAB",
            "KAMSIwobcGVyc2lzdGVudF90ZW5zb3JfYWxsb2NfaWRzGAUgAygDEiMKF2Rl",
            "dmljZV90ZW1wX21lbW9yeV9zaXplGAIgASgDQgIYARIpCh1kZXZpY2VfcGVy",
            "c2lzdGVudF9tZW1vcnlfc2l6ZRgEIAEoA0ICGAESLgoiZGV2aWNlX3BlcnNp",
            "c3RlbnRfdGVuc29yX2FsbG9jX2lkcxgGIAMoA0ICGAEingQKDU5vZGVFeGVj",
            "U3RhdHMSEQoJbm9kZV9uYW1lGAEgASgJEhgKEGFsbF9zdGFydF9taWNyb3MY",
            "AiABKAMSGwoTb3Bfc3RhcnRfcmVsX21pY3JvcxgDIAEoAxIZChFvcF9lbmRf",
            "cmVsX21pY3JvcxgEIAEoAxIaChJhbGxfZW5kX3JlbF9taWNyb3MYBSABKAMS",
            "LwoGbWVtb3J5GAYgAygLMh8udGVuc29yZmxvdy5BbGxvY2F0b3JNZW1vcnlV",
            "c2VkEiYKBm91dHB1dBgHIAMoCzIWLnRlbnNvcmZsb3cuTm9kZU91dHB1dBIW",
            "Cg50aW1lbGluZV9sYWJlbBgIIAEoCRIYChBzY2hlZHVsZWRfbWljcm9zGAkg",
            "ASgDEhEKCXRocmVhZF9pZBgKIAEoDRI8ChFyZWZlcmVuY2VkX3RlbnNvchgL",
            "IAMoCzIhLnRlbnNvcmZsb3cuQWxsb2NhdGlvbkRlc2NyaXB0aW9uEi0KDG1l",
            "bW9yeV9zdGF0cxgMIAEoCzIXLnRlbnNvcmZsb3cuTWVtb3J5U3RhdHMSFwoP",
            "YWxsX3N0YXJ0X25hbm9zGA0gASgDEhoKEm9wX3N0YXJ0X3JlbF9uYW5vcxgO",
            "IAEoAxIYChBvcF9lbmRfcmVsX25hbm9zGA8gASgDEhkKEWFsbF9lbmRfcmVs",
            "X25hbm9zGBAgASgDEhcKD3NjaGVkdWxlZF9uYW5vcxgRIAEoAyJQCg9EZXZp",
            "Y2VTdGVwU3RhdHMSDgoGZGV2aWNlGAEgASgJEi0KCm5vZGVfc3RhdHMYAiAD",
            "KAsyGS50ZW5zb3JmbG93Lk5vZGVFeGVjU3RhdHMiOwoJU3RlcFN0YXRzEi4K",
            "CWRldl9zdGF0cxgBIAMoCzIbLnRlbnNvcmZsb3cuRGV2aWNlU3RlcFN0YXRz",
            "Qm8KGG9yZy50ZW5zb3JmbG93LmZyYW1ld29ya0IPU3RlcFN0YXRzUHJvdG9z",
            "UAFaPWdpdGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3JmbG93L3RlbnNvcmZs",
            "b3cvZ28vY29yZS9mcmFtZXdvcmv4AQFiBnByb3RvMw=="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { global::Tensorflow.AllocationDescriptionReflection.Descriptor, global::Tensorflow.TensorDescriptionReflection.Descriptor, },
          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.AllocationRecord), global::Tensorflow.AllocationRecord.Parser, new[]{ "AllocMicros", "AllocBytes" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.AllocatorMemoryUsed), global::Tensorflow.AllocatorMemoryUsed.Parser, new[]{ "AllocatorName", "TotalBytes", "PeakBytes", "LiveBytes", "AllocationRecords", "AllocatorBytesInUse" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.NodeOutput), global::Tensorflow.NodeOutput.Parser, new[]{ "Slot", "TensorDescription" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.MemoryStats), global::Tensorflow.MemoryStats.Parser, new[]{ "TempMemorySize", "PersistentMemorySize", "PersistentTensorAllocIds", "DeviceTempMemorySize", "DevicePersistentMemorySize", "DevicePersistentTensorAllocIds" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.NodeExecStats), global::Tensorflow.NodeExecStats.Parser, new[]{ "NodeName", "AllStartMicros", "OpStartRelMicros", "OpEndRelMicros", "AllEndRelMicros", "Memory", "Output", "TimelineLabel", "ScheduledMicros", "ThreadId", "ReferencedTensor", "MemoryStats", "AllStartNanos", "OpStartRelNanos", "OpEndRelNanos", "AllEndRelNanos", "ScheduledNanos" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.DeviceStepStats), global::Tensorflow.DeviceStepStats.Parser, new[]{ "Device", "NodeStats" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.StepStats), global::Tensorflow.StepStats.Parser, new[]{ "DevStats" }, null, null, null)
          }));
    }
    #endregion

  }
  #region Messages
  /// <summary>
  /// An allocation/de-allocation operation performed by the allocator.
  /// </summary>
  public sealed partial class AllocationRecord : pb::IMessage<AllocationRecord> {
    private static readonly pb::MessageParser<AllocationRecord> _parser = new pb::MessageParser<AllocationRecord>(() => new AllocationRecord());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<AllocationRecord> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.StepStatsReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AllocationRecord() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AllocationRecord(AllocationRecord other) : this() {
      allocMicros_ = other.allocMicros_;
      allocBytes_ = other.allocBytes_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AllocationRecord Clone() {
      return new AllocationRecord(this);
    }

    /// <summary>Field number for the "alloc_micros" field.</summary>
    public const int AllocMicrosFieldNumber = 1;
    private long allocMicros_;
    /// <summary>
    /// The timestamp of the operation.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long AllocMicros {
      get { return allocMicros_; }
      set {
        allocMicros_ = value;
      }
    }

    /// <summary>Field number for the "alloc_bytes" field.</summary>
    public const int AllocBytesFieldNumber = 2;
    private long allocBytes_;
    /// <summary>
    /// Number of bytes allocated, or de-allocated if negative.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long AllocBytes {
      get { return allocBytes_; }
      set {
        allocBytes_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as AllocationRecord);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(AllocationRecord other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (AllocMicros != other.AllocMicros) return false;
      if (AllocBytes != other.AllocBytes) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (AllocMicros != 0L) hash ^= AllocMicros.GetHashCode();
      if (AllocBytes != 0L) hash ^= AllocBytes.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (AllocMicros != 0L) {
        output.WriteRawTag(8);
        output.WriteInt64(AllocMicros);
      }
      if (AllocBytes != 0L) {
        output.WriteRawTag(16);
        output.WriteInt64(AllocBytes);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (AllocMicros != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(AllocMicros);
      }
      if (AllocBytes != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(AllocBytes);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(AllocationRecord other) {
      if (other == null) {
        return;
      }
      if (other.AllocMicros != 0L) {
        AllocMicros = other.AllocMicros;
      }
      if (other.AllocBytes != 0L) {
        AllocBytes = other.AllocBytes;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            AllocMicros = input.ReadInt64();
            break;
          }
          case 16: {
            AllocBytes = input.ReadInt64();
            break;
          }
        }
      }
    }

  }

  public sealed partial class AllocatorMemoryUsed : pb::IMessage<AllocatorMemoryUsed> {
    private static readonly pb::MessageParser<AllocatorMemoryUsed> _parser = new pb::MessageParser<AllocatorMemoryUsed>(() => new AllocatorMemoryUsed());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<AllocatorMemoryUsed> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.StepStatsReflection.Descriptor.MessageTypes[1]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AllocatorMemoryUsed() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AllocatorMemoryUsed(AllocatorMemoryUsed other) : this() {
      allocatorName_ = other.allocatorName_;
      totalBytes_ = other.totalBytes_;
      peakBytes_ = other.peakBytes_;
      liveBytes_ = other.liveBytes_;
      allocationRecords_ = other.allocationRecords_.Clone();
      allocatorBytesInUse_ = other.allocatorBytesInUse_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AllocatorMemoryUsed Clone() {
      return new AllocatorMemoryUsed(this);
    }

    /// <summary>Field number for the "allocator_name" field.</summary>
    public const int AllocatorNameFieldNumber = 1;
    private string allocatorName_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string AllocatorName {
      get { return allocatorName_; }
      set {
        allocatorName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "total_bytes" field.</summary>
    public const int TotalBytesFieldNumber = 2;
    private long totalBytes_;
    /// <summary>
    /// These are per-node allocator memory stats.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long TotalBytes {
      get { return totalBytes_; }
      set {
        totalBytes_ = value;
      }
    }

    /// <summary>Field number for the "peak_bytes" field.</summary>
    public const int PeakBytesFieldNumber = 3;
    private long peakBytes_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long PeakBytes {
      get { return peakBytes_; }
      set {
        peakBytes_ = value;
      }
    }

    /// <summary>Field number for the "live_bytes" field.</summary>
    public const int LiveBytesFieldNumber = 4;
    private long liveBytes_;
    /// <summary>
    /// The bytes that are not deallocated.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long LiveBytes {
      get { return liveBytes_; }
      set {
        liveBytes_ = value;
      }
    }

    /// <summary>Field number for the "allocation_records" field.</summary>
    public const int AllocationRecordsFieldNumber = 6;
    private static readonly pb::FieldCodec<global::Tensorflow.AllocationRecord> _repeated_allocationRecords_codec
        = pb::FieldCodec.ForMessage(50, global::Tensorflow.AllocationRecord.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.AllocationRecord> allocationRecords_ = new pbc::RepeatedField<global::Tensorflow.AllocationRecord>();
    /// <summary>
    /// The allocation and deallocation timeline.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.AllocationRecord> AllocationRecords {
      get { return allocationRecords_; }
    }

    /// <summary>Field number for the "allocator_bytes_in_use" field.</summary>
    public const int AllocatorBytesInUseFieldNumber = 5;
    private long allocatorBytesInUse_;
    /// <summary>
    /// These are snapshots of the overall allocator memory stats.
    /// The number of live bytes currently allocated by the allocator.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long AllocatorBytesInUse {
      get { return allocatorBytesInUse_; }
      set {
        allocatorBytesInUse_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as AllocatorMemoryUsed);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(AllocatorMemoryUsed other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (AllocatorName != other.AllocatorName) return false;
      if (TotalBytes != other.TotalBytes) return false;
      if (PeakBytes != other.PeakBytes) return false;
      if (LiveBytes != other.LiveBytes) return false;
      if(!allocationRecords_.Equals(other.allocationRecords_)) return false;
      if (AllocatorBytesInUse != other.AllocatorBytesInUse) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (AllocatorName.Length != 0) hash ^= AllocatorName.GetHashCode();
      if (TotalBytes != 0L) hash ^= TotalBytes.GetHashCode();
      if (PeakBytes != 0L) hash ^= PeakBytes.GetHashCode();
      if (LiveBytes != 0L) hash ^= LiveBytes.GetHashCode();
      hash ^= allocationRecords_.GetHashCode();
      if (AllocatorBytesInUse != 0L) hash ^= AllocatorBytesInUse.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (AllocatorName.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(AllocatorName);
      }
      if (TotalBytes != 0L) {
        output.WriteRawTag(16);
        output.WriteInt64(TotalBytes);
      }
      if (PeakBytes != 0L) {
        output.WriteRawTag(24);
        output.WriteInt64(PeakBytes);
      }
      if (LiveBytes != 0L) {
        output.WriteRawTag(32);
        output.WriteInt64(LiveBytes);
      }
      if (AllocatorBytesInUse != 0L) {
        output.WriteRawTag(40);
        output.WriteInt64(AllocatorBytesInUse);
      }
      allocationRecords_.WriteTo(output, _repeated_allocationRecords_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (AllocatorName.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(AllocatorName);
      }
      if (TotalBytes != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(TotalBytes);
      }
      if (PeakBytes != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(PeakBytes);
      }
      if (LiveBytes != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(LiveBytes);
      }
      size += allocationRecords_.CalculateSize(_repeated_allocationRecords_codec);
      if (AllocatorBytesInUse != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(AllocatorBytesInUse);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(AllocatorMemoryUsed other) {
      if (other == null) {
        return;
      }
      if (other.AllocatorName.Length != 0) {
        AllocatorName = other.AllocatorName;
      }
      if (other.TotalBytes != 0L) {
        TotalBytes = other.TotalBytes;
      }
      if (other.PeakBytes != 0L) {
        PeakBytes = other.PeakBytes;
      }
      if (other.LiveBytes != 0L) {
        LiveBytes = other.LiveBytes;
      }
      allocationRecords_.Add(other.allocationRecords_);
      if (other.AllocatorBytesInUse != 0L) {
        AllocatorBytesInUse = other.AllocatorBytesInUse;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            AllocatorName = input.ReadString();
            break;
          }
          case 16: {
            TotalBytes = input.ReadInt64();
            break;
          }
          case 24: {
            PeakBytes = input.ReadInt64();
            break;
          }
          case 32: {
            LiveBytes = input.ReadInt64();
            break;
          }
          case 40: {
            AllocatorBytesInUse = input.ReadInt64();
            break;
          }
          case 50: {
            allocationRecords_.AddEntriesFrom(input, _repeated_allocationRecords_codec);
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// Output sizes recorded for a single execution of a graph node.
  /// </summary>
  public sealed partial class NodeOutput : pb::IMessage<NodeOutput> {
    private static readonly pb::MessageParser<NodeOutput> _parser = new pb::MessageParser<NodeOutput>(() => new NodeOutput());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<NodeOutput> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.StepStatsReflection.Descriptor.MessageTypes[2]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NodeOutput() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NodeOutput(NodeOutput other) : this() {
      slot_ = other.slot_;
      tensorDescription_ = other.tensorDescription_ != null ? other.tensorDescription_.Clone() : null;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NodeOutput Clone() {
      return new NodeOutput(this);
    }

    /// <summary>Field number for the "slot" field.</summary>
    public const int SlotFieldNumber = 1;
    private int slot_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Slot {
      get { return slot_; }
      set {
        slot_ = value;
      }
    }

    /// <summary>Field number for the "tensor_description" field.</summary>
    public const int TensorDescriptionFieldNumber = 3;
    private global::Tensorflow.TensorDescription tensorDescription_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.TensorDescription TensorDescription {
      get { return tensorDescription_; }
      set {
        tensorDescription_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as NodeOutput);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(NodeOutput other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Slot != other.Slot) return false;
      if (!object.Equals(TensorDescription, other.TensorDescription)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Slot != 0) hash ^= Slot.GetHashCode();
      if (tensorDescription_ != null) hash ^= TensorDescription.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Slot != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(Slot);
      }
      if (tensorDescription_ != null) {
        output.WriteRawTag(26);
        output.WriteMessage(TensorDescription);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Slot != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Slot);
      }
      if (tensorDescription_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(TensorDescription);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(NodeOutput other) {
      if (other == null) {
        return;
      }
      if (other.Slot != 0) {
        Slot = other.Slot;
      }
      if (other.tensorDescription_ != null) {
        if (tensorDescription_ == null) {
          tensorDescription_ = new global::Tensorflow.TensorDescription();
        }
        TensorDescription.MergeFrom(other.TensorDescription);
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Slot = input.ReadInt32();
            break;
          }
          case 26: {
            if (tensorDescription_ == null) {
              tensorDescription_ = new global::Tensorflow.TensorDescription();
            }
            input.ReadMessage(tensorDescription_);
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// For memory tracking.
  /// </summary>
  public sealed partial class MemoryStats : pb::IMessage<MemoryStats> {
    private static readonly pb::MessageParser<MemoryStats> _parser = new pb::MessageParser<MemoryStats>(() => new MemoryStats());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<MemoryStats> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.StepStatsReflection.Descriptor.MessageTypes[3]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public MemoryStats() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public MemoryStats(MemoryStats other) : this() {
      tempMemorySize_ = other.tempMemorySize_;
      persistentMemorySize_ = other.persistentMemorySize_;
      persistentTensorAllocIds_ = other.persistentTensorAllocIds_.Clone();
      deviceTempMemorySize_ = other.deviceTempMemorySize_;
      devicePersistentMemorySize_ = other.devicePersistentMemorySize_;
      devicePersistentTensorAllocIds_ = other.devicePersistentTensorAllocIds_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public MemoryStats Clone() {
      return new MemoryStats(this);
    }

    /// <summary>Field number for the "temp_memory_size" field.</summary>
    public const int TempMemorySizeFieldNumber = 1;
    private long tempMemorySize_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long TempMemorySize {
      get { return tempMemorySize_; }
      set {
        tempMemorySize_ = value;
      }
    }

    /// <summary>Field number for the "persistent_memory_size" field.</summary>
    public const int PersistentMemorySizeFieldNumber = 3;
    private long persistentMemorySize_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long PersistentMemorySize {
      get { return persistentMemorySize_; }
      set {
        persistentMemorySize_ = value;
      }
    }

    /// <summary>Field number for the "persistent_tensor_alloc_ids" field.</summary>
    public const int PersistentTensorAllocIdsFieldNumber = 5;
    private static readonly pb::FieldCodec<long> _repeated_persistentTensorAllocIds_codec
        = pb::FieldCodec.ForInt64(42);
    private readonly pbc::RepeatedField<long> persistentTensorAllocIds_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> PersistentTensorAllocIds {
      get { return persistentTensorAllocIds_; }
    }

    /// <summary>Field number for the "device_temp_memory_size" field.</summary>
    public const int DeviceTempMemorySizeFieldNumber = 2;
    private long deviceTempMemorySize_;
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long DeviceTempMemorySize {
      get { return deviceTempMemorySize_; }
      set {
        deviceTempMemorySize_ = value;
      }
    }

    /// <summary>Field number for the "device_persistent_memory_size" field.</summary>
    public const int DevicePersistentMemorySizeFieldNumber = 4;
    private long devicePersistentMemorySize_;
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long DevicePersistentMemorySize {
      get { return devicePersistentMemorySize_; }
      set {
        devicePersistentMemorySize_ = value;
      }
    }

    /// <summary>Field number for the "device_persistent_tensor_alloc_ids" field.</summary>
    public const int DevicePersistentTensorAllocIdsFieldNumber = 6;
    private static readonly pb::FieldCodec<long> _repeated_devicePersistentTensorAllocIds_codec
        = pb::FieldCodec.ForInt64(50);
    private readonly pbc::RepeatedField<long> devicePersistentTensorAllocIds_ = new pbc::RepeatedField<long>();
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> DevicePersistentTensorAllocIds {
      get { return devicePersistentTensorAllocIds_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as MemoryStats);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(MemoryStats other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (TempMemorySize != other.TempMemorySize) return false;
      if (PersistentMemorySize != other.PersistentMemorySize) return false;
      if(!persistentTensorAllocIds_.Equals(other.persistentTensorAllocIds_)) return false;
      if (DeviceTempMemorySize != other.DeviceTempMemorySize) return false;
      if (DevicePersistentMemorySize != other.DevicePersistentMemorySize) return false;
      if(!devicePersistentTensorAllocIds_.Equals(other.devicePersistentTensorAllocIds_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (TempMemorySize != 0L) hash ^= TempMemorySize.GetHashCode();
      if (PersistentMemorySize != 0L) hash ^= PersistentMemorySize.GetHashCode();
      hash ^= persistentTensorAllocIds_.GetHashCode();
      if (DeviceTempMemorySize != 0L) hash ^= DeviceTempMemorySize.GetHashCode();
      if (DevicePersistentMemorySize != 0L) hash ^= DevicePersistentMemorySize.GetHashCode();
      hash ^= devicePersistentTensorAllocIds_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (TempMemorySize != 0L) {
        output.WriteRawTag(8);
        output.WriteInt64(TempMemorySize);
      }
      if (DeviceTempMemorySize != 0L) {
        output.WriteRawTag(16);
        output.WriteInt64(DeviceTempMemorySize);
      }
      if (PersistentMemorySize != 0L) {
        output.WriteRawTag(24);
        output.WriteInt64(PersistentMemorySize);
      }
      if (DevicePersistentMemorySize != 0L) {
        output.WriteRawTag(32);
        output.WriteInt64(DevicePersistentMemorySize);
      }
      persistentTensorAllocIds_.WriteTo(output, _repeated_persistentTensorAllocIds_codec);
      devicePersistentTensorAllocIds_.WriteTo(output, _repeated_devicePersistentTensorAllocIds_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (TempMemorySize != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(TempMemorySize);
      }
      if (PersistentMemorySize != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(PersistentMemorySize);
      }
      size += persistentTensorAllocIds_.CalculateSize(_repeated_persistentTensorAllocIds_codec);
      if (DeviceTempMemorySize != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(DeviceTempMemorySize);
      }
      if (DevicePersistentMemorySize != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(DevicePersistentMemorySize);
      }
      size += devicePersistentTensorAllocIds_.CalculateSize(_repeated_devicePersistentTensorAllocIds_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(MemoryStats other) {
      if (other == null) {
        return;
      }
      if (other.TempMemorySize != 0L) {
        TempMemorySize = other.TempMemorySize;
      }
      if (other.PersistentMemorySize != 0L) {
        PersistentMemorySize = other.PersistentMemorySize;
      }
      persistentTensorAllocIds_.Add(other.persistentTensorAllocIds_);
      if (other.DeviceTempMemorySize != 0L) {
        DeviceTempMemorySize = other.DeviceTempMemorySize;
      }
      if (other.DevicePersistentMemorySize != 0L) {
        DevicePersistentMemorySize = other.DevicePersistentMemorySize;
      }
      devicePersistentTensorAllocIds_.Add(other.devicePersistentTensorAllocIds_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            TempMemorySize = input.ReadInt64();
            break;
          }
          case 16: {
            DeviceTempMemorySize = input.ReadInt64();
            break;
          }
          case 24: {
            PersistentMemorySize = input.ReadInt64();
            break;
          }
          case 32: {
            DevicePersistentMemorySize = input.ReadInt64();
            break;
          }
          case 42:
          case 40: {
            persistentTensorAllocIds_.AddEntriesFrom(input, _repeated_persistentTensorAllocIds_codec);
            break;
          }
          case 50:
          case 48: {
            devicePersistentTensorAllocIds_.AddEntriesFrom(input, _repeated_devicePersistentTensorAllocIds_codec);
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// Time/size stats recorded for a single execution of a graph node.
  /// </summary>
  public sealed partial class NodeExecStats : pb::IMessage<NodeExecStats> {
    private static readonly pb::MessageParser<NodeExecStats> _parser = new pb::MessageParser<NodeExecStats>(() => new NodeExecStats());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<NodeExecStats> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.StepStatsReflection.Descriptor.MessageTypes[4]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NodeExecStats() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NodeExecStats(NodeExecStats other) : this() {
      nodeName_ = other.nodeName_;
      allStartMicros_ = other.allStartMicros_;
      opStartRelMicros_ = other.opStartRelMicros_;
      opEndRelMicros_ = other.opEndRelMicros_;
      allEndRelMicros_ = other.allEndRelMicros_;
      memory_ = other.memory_.Clone();
      output_ = other.output_.Clone();
      timelineLabel_ = other.timelineLabel_;
      scheduledMicros_ = other.scheduledMicros_;
      threadId_ = other.threadId_;
      referencedTensor_ = other.referencedTensor_.Clone();
      memoryStats_ = other.memoryStats_ != null ? other.memoryStats_.Clone() : null;
      allStartNanos_ = other.allStartNanos_;
      opStartRelNanos_ = other.opStartRelNanos_;
      opEndRelNanos_ = other.opEndRelNanos_;
      allEndRelNanos_ = other.allEndRelNanos_;
      scheduledNanos_ = other.scheduledNanos_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NodeExecStats Clone() {
      return new NodeExecStats(this);
    }

    /// <summary>Field number for the "node_name" field.</summary>
    public const int NodeNameFieldNumber = 1;
    private string nodeName_ = "";
    /// <summary>
    /// TODO(tucker): Use some more compact form of node identity than
    /// the full string name.  Either all processes should agree on a
    /// global id (cost_id?) for each node, or we should use a hash of
    /// the name.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string NodeName {
      get { return nodeName_; }
      set {
        nodeName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "all_start_micros" field.</summary>
    public const int AllStartMicrosFieldNumber = 2;
    private long allStartMicros_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long AllStartMicros {
      get { return allStartMicros_; }
      set {
        allStartMicros_ = value;
      }
    }

    /// <summary>Field number for the "op_start_rel_micros" field.</summary>
    public const int OpStartRelMicrosFieldNumber = 3;
    private long opStartRelMicros_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long OpStartRelMicros {
      get { return opStartRelMicros_; }
      set {
        opStartRelMicros_ = value;
      }
    }

    /// <summary>Field number for the "op_end_rel_micros" field.</summary>
    public const int OpEndRelMicrosFieldNumber = 4;
    private long opEndRelMicros_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long OpEndRelMicros {
      get { return opEndRelMicros_; }
      set {
        opEndRelMicros_ = value;
      }
    }

    /// <summary>Field number for the "all_end_rel_micros" field.</summary>
    public const int AllEndRelMicrosFieldNumber = 5;
    private long allEndRelMicros_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long AllEndRelMicros {
      get { return allEndRelMicros_; }
      set {
        allEndRelMicros_ = value;
      }
    }

    /// <summary>Field number for the "memory" field.</summary>
    public const int MemoryFieldNumber = 6;
    private static readonly pb::FieldCodec<global::Tensorflow.AllocatorMemoryUsed> _repeated_memory_codec
        = pb::FieldCodec.ForMessage(50, global::Tensorflow.AllocatorMemoryUsed.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.AllocatorMemoryUsed> memory_ = new pbc::RepeatedField<global::Tensorflow.AllocatorMemoryUsed>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.AllocatorMemoryUsed> Memory {
      get { return memory_; }
    }

    /// <summary>Field number for the "output" field.</summary>
    public const int OutputFieldNumber = 7;
    private static readonly pb::FieldCodec<global::Tensorflow.NodeOutput> _repeated_output_codec
        = pb::FieldCodec.ForMessage(58, global::Tensorflow.NodeOutput.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.NodeOutput> output_ = new pbc::RepeatedField<global::Tensorflow.NodeOutput>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.NodeOutput> Output {
      get { return output_; }
    }

    /// <summary>Field number for the "timeline_label" field.</summary>
    public const int TimelineLabelFieldNumber = 8;
    private string timelineLabel_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string TimelineLabel {
      get { return timelineLabel_; }
      set {
        timelineLabel_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "scheduled_micros" field.</summary>
    public const int ScheduledMicrosFieldNumber = 9;
    private long scheduledMicros_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long ScheduledMicros {
      get { return scheduledMicros_; }
      set {
        scheduledMicros_ = value;
      }
    }

    /// <summary>Field number for the "thread_id" field.</summary>
    public const int ThreadIdFieldNumber = 10;
    private uint threadId_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint ThreadId {
      get { return threadId_; }
      set {
        threadId_ = value;
      }
    }

    /// <summary>Field number for the "referenced_tensor" field.</summary>
    public const int ReferencedTensorFieldNumber = 11;
    private static readonly pb::FieldCodec<global::Tensorflow.AllocationDescription> _repeated_referencedTensor_codec
        = pb::FieldCodec.ForMessage(90, global::Tensorflow.AllocationDescription.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.AllocationDescription> referencedTensor_ = new pbc::RepeatedField<global::Tensorflow.AllocationDescription>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.AllocationDescription> ReferencedTensor {
      get { return referencedTensor_; }
    }

    /// <summary>Field number for the "memory_stats" field.</summary>
    public const int MemoryStatsFieldNumber = 12;
    private global::Tensorflow.MemoryStats memoryStats_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.MemoryStats MemoryStats {
      get { return memoryStats_; }
      set {
        memoryStats_ = value;
      }
    }

    /// <summary>Field number for the "all_start_nanos" field.</summary>
    public const int AllStartNanosFieldNumber = 13;
    private long allStartNanos_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long AllStartNanos {
      get { return allStartNanos_; }
      set {
        allStartNanos_ = value;
      }
    }

    /// <summary>Field number for the "op_start_rel_nanos" field.</summary>
    public const int OpStartRelNanosFieldNumber = 14;
    private long opStartRelNanos_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long OpStartRelNanos {
      get { return opStartRelNanos_; }
      set {
        opStartRelNanos_ = value;
      }
    }

    /// <summary>Field number for the "op_end_rel_nanos" field.</summary>
    public const int OpEndRelNanosFieldNumber = 15;
    private long opEndRelNanos_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long OpEndRelNanos {
      get { return opEndRelNanos_; }
      set {
        opEndRelNanos_ = value;
      }
    }

    /// <summary>Field number for the "all_end_rel_nanos" field.</summary>
    public const int AllEndRelNanosFieldNumber = 16;
    private long allEndRelNanos_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long AllEndRelNanos {
      get { return allEndRelNanos_; }
      set {
        allEndRelNanos_ = value;
      }
    }

    /// <summary>Field number for the "scheduled_nanos" field.</summary>
    public const int ScheduledNanosFieldNumber = 17;
    private long scheduledNanos_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long ScheduledNanos {
      get { return scheduledNanos_; }
      set {
        scheduledNanos_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as NodeExecStats);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(NodeExecStats other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (NodeName != other.NodeName) return false;
      if (AllStartMicros != other.AllStartMicros) return false;
      if (OpStartRelMicros != other.OpStartRelMicros) return false;
      if (OpEndRelMicros != other.OpEndRelMicros) return false;
      if (AllEndRelMicros != other.AllEndRelMicros) return false;
      if(!memory_.Equals(other.memory_)) return false;
      if(!output_.Equals(other.output_)) return false;
      if (TimelineLabel != other.TimelineLabel) return false;
      if (ScheduledMicros != other.ScheduledMicros) return false;
      if (ThreadId != other.ThreadId) return false;
      if(!referencedTensor_.Equals(other.referencedTensor_)) return false;
      if (!object.Equals(MemoryStats, other.MemoryStats)) return false;
      if (AllStartNanos != other.AllStartNanos) return false;
      if (OpStartRelNanos != other.OpStartRelNanos) return false;
      if (OpEndRelNanos != other.OpEndRelNanos) return false;
      if (AllEndRelNanos != other.AllEndRelNanos) return false;
      if (ScheduledNanos != other.ScheduledNanos) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (NodeName.Length != 0) hash ^= NodeName.GetHashCode();
      if (AllStartMicros != 0L) hash ^= AllStartMicros.GetHashCode();
      if (OpStartRelMicros != 0L) hash ^= OpStartRelMicros.GetHashCode();
      if (OpEndRelMicros != 0L) hash ^= OpEndRelMicros.GetHashCode();
      if (AllEndRelMicros != 0L) hash ^= AllEndRelMicros.GetHashCode();
      hash ^= memory_.GetHashCode();
      hash ^= output_.GetHashCode();
      if (TimelineLabel.Length != 0) hash ^= TimelineLabel.GetHashCode();
      if (ScheduledMicros != 0L) hash ^= ScheduledMicros.GetHashCode();
      if (ThreadId != 0) hash ^= ThreadId.GetHashCode();
      hash ^= referencedTensor_.GetHashCode();
      if (memoryStats_ != null) hash ^= MemoryStats.GetHashCode();
      if (AllStartNanos != 0L) hash ^= AllStartNanos.GetHashCode();
      if (OpStartRelNanos != 0L) hash ^= OpStartRelNanos.GetHashCode();
      if (OpEndRelNanos != 0L) hash ^= OpEndRelNanos.GetHashCode();
      if (AllEndRelNanos != 0L) hash ^= AllEndRelNanos.GetHashCode();
      if (ScheduledNanos != 0L) hash ^= ScheduledNanos.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (NodeName.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(NodeName);
      }
      if (AllStartMicros != 0L) {
        output.WriteRawTag(16);
        output.WriteInt64(AllStartMicros);
      }
      if (OpStartRelMicros != 0L) {
        output.WriteRawTag(24);
        output.WriteInt64(OpStartRelMicros);
      }
      if (OpEndRelMicros != 0L) {
        output.WriteRawTag(32);
        output.WriteInt64(OpEndRelMicros);
      }
      if (AllEndRelMicros != 0L) {
        output.WriteRawTag(40);
        output.WriteInt64(AllEndRelMicros);
      }
      memory_.WriteTo(output, _repeated_memory_codec);
      output_.WriteTo(output, _repeated_output_codec);
      if (TimelineLabel.Length != 0) {
        output.WriteRawTag(66);
        output.WriteString(TimelineLabel);
      }
      if (ScheduledMicros != 0L) {
        output.WriteRawTag(72);
        output.WriteInt64(ScheduledMicros);
      }
      if (ThreadId != 0) {
        output.WriteRawTag(80);
        output.WriteUInt32(ThreadId);
      }
      referencedTensor_.WriteTo(output, _repeated_referencedTensor_codec);
      if (memoryStats_ != null) {
        output.WriteRawTag(98);
        output.WriteMessage(MemoryStats);
      }
      if (AllStartNanos != 0L) {
        output.WriteRawTag(104);
        output.WriteInt64(AllStartNanos);
      }
      if (OpStartRelNanos != 0L) {
        output.WriteRawTag(112);
        output.WriteInt64(OpStartRelNanos);
      }
      if (OpEndRelNanos != 0L) {
        output.WriteRawTag(120);
        output.WriteInt64(OpEndRelNanos);
      }
      if (AllEndRelNanos != 0L) {
        output.WriteRawTag(128, 1);
        output.WriteInt64(AllEndRelNanos);
      }
      if (ScheduledNanos != 0L) {
        output.WriteRawTag(136, 1);
        output.WriteInt64(ScheduledNanos);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (NodeName.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(NodeName);
      }
      if (AllStartMicros != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(AllStartMicros);
      }
      if (OpStartRelMicros != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(OpStartRelMicros);
      }
      if (OpEndRelMicros != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(OpEndRelMicros);
      }
      if (AllEndRelMicros != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(AllEndRelMicros);
      }
      size += memory_.CalculateSize(_repeated_memory_codec);
      size += output_.CalculateSize(_repeated_output_codec);
      if (TimelineLabel.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(TimelineLabel);
      }
      if (ScheduledMicros != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(ScheduledMicros);
      }
      if (ThreadId != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ThreadId);
      }
      size += referencedTensor_.CalculateSize(_repeated_referencedTensor_codec);
      if (memoryStats_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(MemoryStats);
      }
      if (AllStartNanos != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(AllStartNanos);
      }
      if (OpStartRelNanos != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(OpStartRelNanos);
      }
      if (OpEndRelNanos != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(OpEndRelNanos);
      }
      if (AllEndRelNanos != 0L) {
        size += 2 + pb::CodedOutputStream.ComputeInt64Size(AllEndRelNanos);
      }
      if (ScheduledNanos != 0L) {
        size += 2 + pb::CodedOutputStream.ComputeInt64Size(ScheduledNanos);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(NodeExecStats other) {
      if (other == null) {
        return;
      }
      if (other.NodeName.Length != 0) {
        NodeName = other.NodeName;
      }
      if (other.AllStartMicros != 0L) {
        AllStartMicros = other.AllStartMicros;
      }
      if (other.OpStartRelMicros != 0L) {
        OpStartRelMicros = other.OpStartRelMicros;
      }
      if (other.OpEndRelMicros != 0L) {
        OpEndRelMicros = other.OpEndRelMicros;
      }
      if (other.AllEndRelMicros != 0L) {
        AllEndRelMicros = other.AllEndRelMicros;
      }
      memory_.Add(other.memory_);
      output_.Add(other.output_);
      if (other.TimelineLabel.Length != 0) {
        TimelineLabel = other.TimelineLabel;
      }
      if (other.ScheduledMicros != 0L) {
        ScheduledMicros = other.ScheduledMicros;
      }
      if (other.ThreadId != 0) {
        ThreadId = other.ThreadId;
      }
      referencedTensor_.Add(other.referencedTensor_);
      if (other.memoryStats_ != null) {
        if (memoryStats_ == null) {
          memoryStats_ = new global::Tensorflow.MemoryStats();
        }
        MemoryStats.MergeFrom(other.MemoryStats);
      }
      if (other.AllStartNanos != 0L) {
        AllStartNanos = other.AllStartNanos;
      }
      if (other.OpStartRelNanos != 0L) {
        OpStartRelNanos = other.OpStartRelNanos;
      }
      if (other.OpEndRelNanos != 0L) {
        OpEndRelNanos = other.OpEndRelNanos;
      }
      if (other.AllEndRelNanos != 0L) {
        AllEndRelNanos = other.AllEndRelNanos;
      }
      if (other.ScheduledNanos != 0L) {
        ScheduledNanos = other.ScheduledNanos;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            NodeName = input.ReadString();
            break;
          }
          case 16: {
            AllStartMicros = input.ReadInt64();
            break;
          }
          case 24: {
            OpStartRelMicros = input.ReadInt64();
            break;
          }
          case 32: {
            OpEndRelMicros = input.ReadInt64();
            break;
          }
          case 40: {
            AllEndRelMicros = input.ReadInt64();
            break;
          }
          case 50: {
            memory_.AddEntriesFrom(input, _repeated_memory_codec);
            break;
          }
          case 58: {
            output_.AddEntriesFrom(input, _repeated_output_codec);
            break;
          }
          case 66: {
            TimelineLabel = input.ReadString();
            break;
          }
          case 72: {
            ScheduledMicros = input.ReadInt64();
            break;
          }
          case 80: {
            ThreadId = input.ReadUInt32();
            break;
          }
          case 90: {
            referencedTensor_.AddEntriesFrom(input, _repeated_referencedTensor_codec);
            break;
          }
          case 98: {
            if (memoryStats_ == null) {
              memoryStats_ = new global::Tensorflow.MemoryStats();
            }
            input.ReadMessage(memoryStats_);
            break;
          }
          case 104: {
            AllStartNanos = input.ReadInt64();
            break;
          }
          case 112: {
            OpStartRelNanos = input.ReadInt64();
            break;
          }
          case 120: {
            OpEndRelNanos = input.ReadInt64();
            break;
          }
          case 128: {
            AllEndRelNanos = input.ReadInt64();
            break;
          }
          case 136: {
            ScheduledNanos = input.ReadInt64();
            break;
          }
        }
      }
    }

  }

  public sealed partial class DeviceStepStats : pb::IMessage<DeviceStepStats> {
    private static readonly pb::MessageParser<DeviceStepStats> _parser = new pb::MessageParser<DeviceStepStats>(() => new DeviceStepStats());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<DeviceStepStats> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.StepStatsReflection.Descriptor.MessageTypes[5]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public DeviceStepStats() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public DeviceStepStats(DeviceStepStats other) : this() {
      device_ = other.device_;
      nodeStats_ = other.nodeStats_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public DeviceStepStats Clone() {
      return new DeviceStepStats(this);
    }

    /// <summary>Field number for the "device" field.</summary>
    public const int DeviceFieldNumber = 1;
    private string device_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Device {
      get { return device_; }
      set {
        device_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "node_stats" field.</summary>
    public const int NodeStatsFieldNumber = 2;
    private static readonly pb::FieldCodec<global::Tensorflow.NodeExecStats> _repeated_nodeStats_codec
        = pb::FieldCodec.ForMessage(18, global::Tensorflow.NodeExecStats.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.NodeExecStats> nodeStats_ = new pbc::RepeatedField<global::Tensorflow.NodeExecStats>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.NodeExecStats> NodeStats {
      get { return nodeStats_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as DeviceStepStats);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(DeviceStepStats other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Device != other.Device) return false;
      if(!nodeStats_.Equals(other.nodeStats_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Device.Length != 0) hash ^= Device.GetHashCode();
      hash ^= nodeStats_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Device.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Device);
      }
      nodeStats_.WriteTo(output, _repeated_nodeStats_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Device.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Device);
      }
      size += nodeStats_.CalculateSize(_repeated_nodeStats_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(DeviceStepStats other) {
      if (other == null) {
        return;
      }
      if (other.Device.Length != 0) {
        Device = other.Device;
      }
      nodeStats_.Add(other.nodeStats_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            Device = input.ReadString();
            break;
          }
          case 18: {
            nodeStats_.AddEntriesFrom(input, _repeated_nodeStats_codec);
            break;
          }
        }
      }
    }

  }

  public sealed partial class StepStats : pb::IMessage<StepStats> {
    private static readonly pb::MessageParser<StepStats> _parser = new pb::MessageParser<StepStats>(() => new StepStats());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<StepStats> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.StepStatsReflection.Descriptor.MessageTypes[6]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public StepStats() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public StepStats(StepStats other) : this() {
      devStats_ = other.devStats_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public StepStats Clone() {
      return new StepStats(this);
    }

    /// <summary>Field number for the "dev_stats" field.</summary>
    public const int DevStatsFieldNumber = 1;
    private static readonly pb::FieldCodec<global::Tensorflow.DeviceStepStats> _repeated_devStats_codec
        = pb::FieldCodec.ForMessage(10, global::Tensorflow.DeviceStepStats.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.DeviceStepStats> devStats_ = new pbc::RepeatedField<global::Tensorflow.DeviceStepStats>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.DeviceStepStats> DevStats {
      get { return devStats_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as StepStats);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(StepStats other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!devStats_.Equals(other.devStats_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= devStats_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      devStats_.WriteTo(output, _repeated_devStats_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += devStats_.CalculateSize(_repeated_devStats_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(StepStats other) {
      if (other == null) {
        return;
      }
      devStats_.Add(other.devStats_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            devStats_.AddEntriesFrom(input, _repeated_devStats_codec);
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code
