// This file is generated by rust-protobuf 2.27.1. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `tensorflow/core/framework/step_stats.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_27_1;

#[derive(PartialEq,Clone,Default)]
pub struct AllocationRecord {
    // message fields
    pub alloc_micros: i64,
    pub alloc_bytes: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a AllocationRecord {
    fn default() -> &'a AllocationRecord {
        <AllocationRecord as ::protobuf::Message>::default_instance()
    }
}

impl AllocationRecord {
    pub fn new() -> AllocationRecord {
        ::std::default::Default::default()
    }

    // int64 alloc_micros = 1;


    pub fn get_alloc_micros(&self) -> i64 {
        self.alloc_micros
    }
    pub fn clear_alloc_micros(&mut self) {
        self.alloc_micros = 0;
    }

    // Param is passed by value, moved
    pub fn set_alloc_micros(&mut self, v: i64) {
        self.alloc_micros = v;
    }

    // int64 alloc_bytes = 2;


    pub fn get_alloc_bytes(&self) -> i64 {
        self.alloc_bytes
    }
    pub fn clear_alloc_bytes(&mut self) {
        self.alloc_bytes = 0;
    }

    // Param is passed by value, moved
    pub fn set_alloc_bytes(&mut self, v: i64) {
        self.alloc_bytes = v;
    }
}

impl ::protobuf::Message for AllocationRecord {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.alloc_micros = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.alloc_bytes = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.alloc_micros != 0 {
            my_size += ::protobuf::rt::value_size(1, self.alloc_micros, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.alloc_bytes != 0 {
            my_size += ::protobuf::rt::value_size(2, self.alloc_bytes, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.alloc_micros != 0 {
            os.write_int64(1, self.alloc_micros)?;
        }
        if self.alloc_bytes != 0 {
            os.write_int64(2, self.alloc_bytes)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> AllocationRecord {
        AllocationRecord::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "alloc_micros",
                |m: &AllocationRecord| { &m.alloc_micros },
                |m: &mut AllocationRecord| { &mut m.alloc_micros },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "alloc_bytes",
                |m: &AllocationRecord| { &m.alloc_bytes },
                |m: &mut AllocationRecord| { &mut m.alloc_bytes },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<AllocationRecord>(
                "AllocationRecord",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static AllocationRecord {
        static instance: ::protobuf::rt::LazyV2<AllocationRecord> = ::protobuf::rt::LazyV2::INIT;
        instance.get(AllocationRecord::new)
    }
}

impl ::protobuf::Clear for AllocationRecord {
    fn clear(&mut self) {
        self.alloc_micros = 0;
        self.alloc_bytes = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for AllocationRecord {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for AllocationRecord {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct AllocatorMemoryUsed {
    // message fields
    pub allocator_name: ::std::string::String,
    pub total_bytes: i64,
    pub peak_bytes: i64,
    pub live_bytes: i64,
    pub allocation_records: ::protobuf::RepeatedField<AllocationRecord>,
    pub allocator_bytes_in_use: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a AllocatorMemoryUsed {
    fn default() -> &'a AllocatorMemoryUsed {
        <AllocatorMemoryUsed as ::protobuf::Message>::default_instance()
    }
}

impl AllocatorMemoryUsed {
    pub fn new() -> AllocatorMemoryUsed {
        ::std::default::Default::default()
    }

    // string allocator_name = 1;


    pub fn get_allocator_name(&self) -> &str {
        &self.allocator_name
    }
    pub fn clear_allocator_name(&mut self) {
        self.allocator_name.clear();
    }

    // Param is passed by value, moved
    pub fn set_allocator_name(&mut self, v: ::std::string::String) {
        self.allocator_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_allocator_name(&mut self) -> &mut ::std::string::String {
        &mut self.allocator_name
    }

    // Take field
    pub fn take_allocator_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.allocator_name, ::std::string::String::new())
    }

    // int64 total_bytes = 2;


    pub fn get_total_bytes(&self) -> i64 {
        self.total_bytes
    }
    pub fn clear_total_bytes(&mut self) {
        self.total_bytes = 0;
    }

    // Param is passed by value, moved
    pub fn set_total_bytes(&mut self, v: i64) {
        self.total_bytes = v;
    }

    // int64 peak_bytes = 3;


    pub fn get_peak_bytes(&self) -> i64 {
        self.peak_bytes
    }
    pub fn clear_peak_bytes(&mut self) {
        self.peak_bytes = 0;
    }

    // Param is passed by value, moved
    pub fn set_peak_bytes(&mut self, v: i64) {
        self.peak_bytes = v;
    }

    // int64 live_bytes = 4;


    pub fn get_live_bytes(&self) -> i64 {
        self.live_bytes
    }
    pub fn clear_live_bytes(&mut self) {
        self.live_bytes = 0;
    }

    // Param is passed by value, moved
    pub fn set_live_bytes(&mut self, v: i64) {
        self.live_bytes = v;
    }

    // repeated .tensorflow.AllocationRecord allocation_records = 6;


    pub fn get_allocation_records(&self) -> &[AllocationRecord] {
        &self.allocation_records
    }
    pub fn clear_allocation_records(&mut self) {
        self.allocation_records.clear();
    }

    // Param is passed by value, moved
    pub fn set_allocation_records(&mut self, v: ::protobuf::RepeatedField<AllocationRecord>) {
        self.allocation_records = v;
    }

    // Mutable pointer to the field.
    pub fn mut_allocation_records(&mut self) -> &mut ::protobuf::RepeatedField<AllocationRecord> {
        &mut self.allocation_records
    }

    // Take field
    pub fn take_allocation_records(&mut self) -> ::protobuf::RepeatedField<AllocationRecord> {
        ::std::mem::replace(&mut self.allocation_records, ::protobuf::RepeatedField::new())
    }

    // int64 allocator_bytes_in_use = 5;


    pub fn get_allocator_bytes_in_use(&self) -> i64 {
        self.allocator_bytes_in_use
    }
    pub fn clear_allocator_bytes_in_use(&mut self) {
        self.allocator_bytes_in_use = 0;
    }

    // Param is passed by value, moved
    pub fn set_allocator_bytes_in_use(&mut self, v: i64) {
        self.allocator_bytes_in_use = v;
    }
}

impl ::protobuf::Message for AllocatorMemoryUsed {
    fn is_initialized(&self) -> bool {
        for v in &self.allocation_records {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.allocator_name)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.total_bytes = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.peak_bytes = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.live_bytes = tmp;
                },
                6 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.allocation_records)?;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.allocator_bytes_in_use = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.allocator_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.allocator_name);
        }
        if self.total_bytes != 0 {
            my_size += ::protobuf::rt::value_size(2, self.total_bytes, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.peak_bytes != 0 {
            my_size += ::protobuf::rt::value_size(3, self.peak_bytes, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.live_bytes != 0 {
            my_size += ::protobuf::rt::value_size(4, self.live_bytes, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.allocation_records {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.allocator_bytes_in_use != 0 {
            my_size += ::protobuf::rt::value_size(5, self.allocator_bytes_in_use, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.allocator_name.is_empty() {
            os.write_string(1, &self.allocator_name)?;
        }
        if self.total_bytes != 0 {
            os.write_int64(2, self.total_bytes)?;
        }
        if self.peak_bytes != 0 {
            os.write_int64(3, self.peak_bytes)?;
        }
        if self.live_bytes != 0 {
            os.write_int64(4, self.live_bytes)?;
        }
        for v in &self.allocation_records {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.allocator_bytes_in_use != 0 {
            os.write_int64(5, self.allocator_bytes_in_use)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> AllocatorMemoryUsed {
        AllocatorMemoryUsed::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "allocator_name",
                |m: &AllocatorMemoryUsed| { &m.allocator_name },
                |m: &mut AllocatorMemoryUsed| { &mut m.allocator_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "total_bytes",
                |m: &AllocatorMemoryUsed| { &m.total_bytes },
                |m: &mut AllocatorMemoryUsed| { &mut m.total_bytes },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "peak_bytes",
                |m: &AllocatorMemoryUsed| { &m.peak_bytes },
                |m: &mut AllocatorMemoryUsed| { &mut m.peak_bytes },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "live_bytes",
                |m: &AllocatorMemoryUsed| { &m.live_bytes },
                |m: &mut AllocatorMemoryUsed| { &mut m.live_bytes },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AllocationRecord>>(
                "allocation_records",
                |m: &AllocatorMemoryUsed| { &m.allocation_records },
                |m: &mut AllocatorMemoryUsed| { &mut m.allocation_records },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "allocator_bytes_in_use",
                |m: &AllocatorMemoryUsed| { &m.allocator_bytes_in_use },
                |m: &mut AllocatorMemoryUsed| { &mut m.allocator_bytes_in_use },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<AllocatorMemoryUsed>(
                "AllocatorMemoryUsed",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static AllocatorMemoryUsed {
        static instance: ::protobuf::rt::LazyV2<AllocatorMemoryUsed> = ::protobuf::rt::LazyV2::INIT;
        instance.get(AllocatorMemoryUsed::new)
    }
}

impl ::protobuf::Clear for AllocatorMemoryUsed {
    fn clear(&mut self) {
        self.allocator_name.clear();
        self.total_bytes = 0;
        self.peak_bytes = 0;
        self.live_bytes = 0;
        self.allocation_records.clear();
        self.allocator_bytes_in_use = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for AllocatorMemoryUsed {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for AllocatorMemoryUsed {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct NodeOutput {
    // message fields
    pub slot: i32,
    pub tensor_description: ::protobuf::SingularPtrField<super::tensor_description::TensorDescription>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a NodeOutput {
    fn default() -> &'a NodeOutput {
        <NodeOutput as ::protobuf::Message>::default_instance()
    }
}

impl NodeOutput {
    pub fn new() -> NodeOutput {
        ::std::default::Default::default()
    }

    // int32 slot = 1;


    pub fn get_slot(&self) -> i32 {
        self.slot
    }
    pub fn clear_slot(&mut self) {
        self.slot = 0;
    }

    // Param is passed by value, moved
    pub fn set_slot(&mut self, v: i32) {
        self.slot = v;
    }

    // .tensorflow.TensorDescription tensor_description = 3;


    pub fn get_tensor_description(&self) -> &super::tensor_description::TensorDescription {
        self.tensor_description.as_ref().unwrap_or_else(|| <super::tensor_description::TensorDescription as ::protobuf::Message>::default_instance())
    }
    pub fn clear_tensor_description(&mut self) {
        self.tensor_description.clear();
    }

    pub fn has_tensor_description(&self) -> bool {
        self.tensor_description.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tensor_description(&mut self, v: super::tensor_description::TensorDescription) {
        self.tensor_description = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tensor_description(&mut self) -> &mut super::tensor_description::TensorDescription {
        if self.tensor_description.is_none() {
            self.tensor_description.set_default();
        }
        self.tensor_description.as_mut().unwrap()
    }

    // Take field
    pub fn take_tensor_description(&mut self) -> super::tensor_description::TensorDescription {
        self.tensor_description.take().unwrap_or_else(|| super::tensor_description::TensorDescription::new())
    }
}

impl ::protobuf::Message for NodeOutput {
    fn is_initialized(&self) -> bool {
        for v in &self.tensor_description {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.slot = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.tensor_description)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.slot != 0 {
            my_size += ::protobuf::rt::value_size(1, self.slot, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.tensor_description.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.slot != 0 {
            os.write_int32(1, self.slot)?;
        }
        if let Some(ref v) = self.tensor_description.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> NodeOutput {
        NodeOutput::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "slot",
                |m: &NodeOutput| { &m.slot },
                |m: &mut NodeOutput| { &mut m.slot },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor_description::TensorDescription>>(
                "tensor_description",
                |m: &NodeOutput| { &m.tensor_description },
                |m: &mut NodeOutput| { &mut m.tensor_description },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<NodeOutput>(
                "NodeOutput",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static NodeOutput {
        static instance: ::protobuf::rt::LazyV2<NodeOutput> = ::protobuf::rt::LazyV2::INIT;
        instance.get(NodeOutput::new)
    }
}

impl ::protobuf::Clear for NodeOutput {
    fn clear(&mut self) {
        self.slot = 0;
        self.tensor_description.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for NodeOutput {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for NodeOutput {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct MemoryStats {
    // message fields
    pub temp_memory_size: i64,
    pub persistent_memory_size: i64,
    pub persistent_tensor_alloc_ids: ::std::vec::Vec<i64>,
    pub device_temp_memory_size: i64,
    pub device_persistent_memory_size: i64,
    pub device_persistent_tensor_alloc_ids: ::std::vec::Vec<i64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a MemoryStats {
    fn default() -> &'a MemoryStats {
        <MemoryStats as ::protobuf::Message>::default_instance()
    }
}

impl MemoryStats {
    pub fn new() -> MemoryStats {
        ::std::default::Default::default()
    }

    // int64 temp_memory_size = 1;


    pub fn get_temp_memory_size(&self) -> i64 {
        self.temp_memory_size
    }
    pub fn clear_temp_memory_size(&mut self) {
        self.temp_memory_size = 0;
    }

    // Param is passed by value, moved
    pub fn set_temp_memory_size(&mut self, v: i64) {
        self.temp_memory_size = v;
    }

    // int64 persistent_memory_size = 3;


    pub fn get_persistent_memory_size(&self) -> i64 {
        self.persistent_memory_size
    }
    pub fn clear_persistent_memory_size(&mut self) {
        self.persistent_memory_size = 0;
    }

    // Param is passed by value, moved
    pub fn set_persistent_memory_size(&mut self, v: i64) {
        self.persistent_memory_size = v;
    }

    // repeated int64 persistent_tensor_alloc_ids = 5;


    pub fn get_persistent_tensor_alloc_ids(&self) -> &[i64] {
        &self.persistent_tensor_alloc_ids
    }
    pub fn clear_persistent_tensor_alloc_ids(&mut self) {
        self.persistent_tensor_alloc_ids.clear();
    }

    // Param is passed by value, moved
    pub fn set_persistent_tensor_alloc_ids(&mut self, v: ::std::vec::Vec<i64>) {
        self.persistent_tensor_alloc_ids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_persistent_tensor_alloc_ids(&mut self) -> &mut ::std::vec::Vec<i64> {
        &mut self.persistent_tensor_alloc_ids
    }

    // Take field
    pub fn take_persistent_tensor_alloc_ids(&mut self) -> ::std::vec::Vec<i64> {
        ::std::mem::replace(&mut self.persistent_tensor_alloc_ids, ::std::vec::Vec::new())
    }

    // int64 device_temp_memory_size = 2;


    pub fn get_device_temp_memory_size(&self) -> i64 {
        self.device_temp_memory_size
    }
    pub fn clear_device_temp_memory_size(&mut self) {
        self.device_temp_memory_size = 0;
    }

    // Param is passed by value, moved
    pub fn set_device_temp_memory_size(&mut self, v: i64) {
        self.device_temp_memory_size = v;
    }

    // int64 device_persistent_memory_size = 4;


    pub fn get_device_persistent_memory_size(&self) -> i64 {
        self.device_persistent_memory_size
    }
    pub fn clear_device_persistent_memory_size(&mut self) {
        self.device_persistent_memory_size = 0;
    }

    // Param is passed by value, moved
    pub fn set_device_persistent_memory_size(&mut self, v: i64) {
        self.device_persistent_memory_size = v;
    }

    // repeated int64 device_persistent_tensor_alloc_ids = 6;


    pub fn get_device_persistent_tensor_alloc_ids(&self) -> &[i64] {
        &self.device_persistent_tensor_alloc_ids
    }
    pub fn clear_device_persistent_tensor_alloc_ids(&mut self) {
        self.device_persistent_tensor_alloc_ids.clear();
    }

    // Param is passed by value, moved
    pub fn set_device_persistent_tensor_alloc_ids(&mut self, v: ::std::vec::Vec<i64>) {
        self.device_persistent_tensor_alloc_ids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_device_persistent_tensor_alloc_ids(&mut self) -> &mut ::std::vec::Vec<i64> {
        &mut self.device_persistent_tensor_alloc_ids
    }

    // Take field
    pub fn take_device_persistent_tensor_alloc_ids(&mut self) -> ::std::vec::Vec<i64> {
        ::std::mem::replace(&mut self.device_persistent_tensor_alloc_ids, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for MemoryStats {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.temp_memory_size = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.persistent_memory_size = tmp;
                },
                5 => {
                    ::protobuf::rt::read_repeated_int64_into(wire_type, is, &mut self.persistent_tensor_alloc_ids)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.device_temp_memory_size = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.device_persistent_memory_size = tmp;
                },
                6 => {
                    ::protobuf::rt::read_repeated_int64_into(wire_type, is, &mut self.device_persistent_tensor_alloc_ids)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.temp_memory_size != 0 {
            my_size += ::protobuf::rt::value_size(1, self.temp_memory_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.persistent_memory_size != 0 {
            my_size += ::protobuf::rt::value_size(3, self.persistent_memory_size, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.persistent_tensor_alloc_ids {
            my_size += ::protobuf::rt::value_size(5, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if self.device_temp_memory_size != 0 {
            my_size += ::protobuf::rt::value_size(2, self.device_temp_memory_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.device_persistent_memory_size != 0 {
            my_size += ::protobuf::rt::value_size(4, self.device_persistent_memory_size, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.device_persistent_tensor_alloc_ids {
            my_size += ::protobuf::rt::value_size(6, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.temp_memory_size != 0 {
            os.write_int64(1, self.temp_memory_size)?;
        }
        if self.persistent_memory_size != 0 {
            os.write_int64(3, self.persistent_memory_size)?;
        }
        for v in &self.persistent_tensor_alloc_ids {
            os.write_int64(5, *v)?;
        };
        if self.device_temp_memory_size != 0 {
            os.write_int64(2, self.device_temp_memory_size)?;
        }
        if self.device_persistent_memory_size != 0 {
            os.write_int64(4, self.device_persistent_memory_size)?;
        }
        for v in &self.device_persistent_tensor_alloc_ids {
            os.write_int64(6, *v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> MemoryStats {
        MemoryStats::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "temp_memory_size",
                |m: &MemoryStats| { &m.temp_memory_size },
                |m: &mut MemoryStats| { &mut m.temp_memory_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "persistent_memory_size",
                |m: &MemoryStats| { &m.persistent_memory_size },
                |m: &mut MemoryStats| { &mut m.persistent_memory_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "persistent_tensor_alloc_ids",
                |m: &MemoryStats| { &m.persistent_tensor_alloc_ids },
                |m: &mut MemoryStats| { &mut m.persistent_tensor_alloc_ids },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "device_temp_memory_size",
                |m: &MemoryStats| { &m.device_temp_memory_size },
                |m: &mut MemoryStats| { &mut m.device_temp_memory_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "device_persistent_memory_size",
                |m: &MemoryStats| { &m.device_persistent_memory_size },
                |m: &mut MemoryStats| { &mut m.device_persistent_memory_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "device_persistent_tensor_alloc_ids",
                |m: &MemoryStats| { &m.device_persistent_tensor_alloc_ids },
                |m: &mut MemoryStats| { &mut m.device_persistent_tensor_alloc_ids },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MemoryStats>(
                "MemoryStats",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MemoryStats {
        static instance: ::protobuf::rt::LazyV2<MemoryStats> = ::protobuf::rt::LazyV2::INIT;
        instance.get(MemoryStats::new)
    }
}

impl ::protobuf::Clear for MemoryStats {
    fn clear(&mut self) {
        self.temp_memory_size = 0;
        self.persistent_memory_size = 0;
        self.persistent_tensor_alloc_ids.clear();
        self.device_temp_memory_size = 0;
        self.device_persistent_memory_size = 0;
        self.device_persistent_tensor_alloc_ids.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for MemoryStats {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for MemoryStats {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct NodeExecStats {
    // message fields
    pub node_name: ::std::string::String,
    pub all_start_micros: i64,
    pub op_start_rel_micros: i64,
    pub op_end_rel_micros: i64,
    pub all_end_rel_micros: i64,
    pub memory: ::protobuf::RepeatedField<AllocatorMemoryUsed>,
    pub output: ::protobuf::RepeatedField<NodeOutput>,
    pub timeline_label: ::std::string::String,
    pub scheduled_micros: i64,
    pub thread_id: u32,
    pub referenced_tensor: ::protobuf::RepeatedField<super::allocation_description::AllocationDescription>,
    pub memory_stats: ::protobuf::SingularPtrField<MemoryStats>,
    pub all_start_nanos: i64,
    pub op_start_rel_nanos: i64,
    pub op_end_rel_nanos: i64,
    pub all_end_rel_nanos: i64,
    pub scheduled_nanos: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a NodeExecStats {
    fn default() -> &'a NodeExecStats {
        <NodeExecStats as ::protobuf::Message>::default_instance()
    }
}

impl NodeExecStats {
    pub fn new() -> NodeExecStats {
        ::std::default::Default::default()
    }

    // string node_name = 1;


    pub fn get_node_name(&self) -> &str {
        &self.node_name
    }
    pub fn clear_node_name(&mut self) {
        self.node_name.clear();
    }

    // Param is passed by value, moved
    pub fn set_node_name(&mut self, v: ::std::string::String) {
        self.node_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_node_name(&mut self) -> &mut ::std::string::String {
        &mut self.node_name
    }

    // Take field
    pub fn take_node_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.node_name, ::std::string::String::new())
    }

    // int64 all_start_micros = 2;


    pub fn get_all_start_micros(&self) -> i64 {
        self.all_start_micros
    }
    pub fn clear_all_start_micros(&mut self) {
        self.all_start_micros = 0;
    }

    // Param is passed by value, moved
    pub fn set_all_start_micros(&mut self, v: i64) {
        self.all_start_micros = v;
    }

    // int64 op_start_rel_micros = 3;


    pub fn get_op_start_rel_micros(&self) -> i64 {
        self.op_start_rel_micros
    }
    pub fn clear_op_start_rel_micros(&mut self) {
        self.op_start_rel_micros = 0;
    }

    // Param is passed by value, moved
    pub fn set_op_start_rel_micros(&mut self, v: i64) {
        self.op_start_rel_micros = v;
    }

    // int64 op_end_rel_micros = 4;


    pub fn get_op_end_rel_micros(&self) -> i64 {
        self.op_end_rel_micros
    }
    pub fn clear_op_end_rel_micros(&mut self) {
        self.op_end_rel_micros = 0;
    }

    // Param is passed by value, moved
    pub fn set_op_end_rel_micros(&mut self, v: i64) {
        self.op_end_rel_micros = v;
    }

    // int64 all_end_rel_micros = 5;


    pub fn get_all_end_rel_micros(&self) -> i64 {
        self.all_end_rel_micros
    }
    pub fn clear_all_end_rel_micros(&mut self) {
        self.all_end_rel_micros = 0;
    }

    // Param is passed by value, moved
    pub fn set_all_end_rel_micros(&mut self, v: i64) {
        self.all_end_rel_micros = v;
    }

    // repeated .tensorflow.AllocatorMemoryUsed memory = 6;


    pub fn get_memory(&self) -> &[AllocatorMemoryUsed] {
        &self.memory
    }
    pub fn clear_memory(&mut self) {
        self.memory.clear();
    }

    // Param is passed by value, moved
    pub fn set_memory(&mut self, v: ::protobuf::RepeatedField<AllocatorMemoryUsed>) {
        self.memory = v;
    }

    // Mutable pointer to the field.
    pub fn mut_memory(&mut self) -> &mut ::protobuf::RepeatedField<AllocatorMemoryUsed> {
        &mut self.memory
    }

    // Take field
    pub fn take_memory(&mut self) -> ::protobuf::RepeatedField<AllocatorMemoryUsed> {
        ::std::mem::replace(&mut self.memory, ::protobuf::RepeatedField::new())
    }

    // repeated .tensorflow.NodeOutput output = 7;


    pub fn get_output(&self) -> &[NodeOutput] {
        &self.output
    }
    pub fn clear_output(&mut self) {
        self.output.clear();
    }

    // Param is passed by value, moved
    pub fn set_output(&mut self, v: ::protobuf::RepeatedField<NodeOutput>) {
        self.output = v;
    }

    // Mutable pointer to the field.
    pub fn mut_output(&mut self) -> &mut ::protobuf::RepeatedField<NodeOutput> {
        &mut self.output
    }

    // Take field
    pub fn take_output(&mut self) -> ::protobuf::RepeatedField<NodeOutput> {
        ::std::mem::replace(&mut self.output, ::protobuf::RepeatedField::new())
    }

    // string timeline_label = 8;


    pub fn get_timeline_label(&self) -> &str {
        &self.timeline_label
    }
    pub fn clear_timeline_label(&mut self) {
        self.timeline_label.clear();
    }

    // Param is passed by value, moved
    pub fn set_timeline_label(&mut self, v: ::std::string::String) {
        self.timeline_label = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_timeline_label(&mut self) -> &mut ::std::string::String {
        &mut self.timeline_label
    }

    // Take field
    pub fn take_timeline_label(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.timeline_label, ::std::string::String::new())
    }

    // int64 scheduled_micros = 9;


    pub fn get_scheduled_micros(&self) -> i64 {
        self.scheduled_micros
    }
    pub fn clear_scheduled_micros(&mut self) {
        self.scheduled_micros = 0;
    }

    // Param is passed by value, moved
    pub fn set_scheduled_micros(&mut self, v: i64) {
        self.scheduled_micros = v;
    }

    // uint32 thread_id = 10;


    pub fn get_thread_id(&self) -> u32 {
        self.thread_id
    }
    pub fn clear_thread_id(&mut self) {
        self.thread_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_thread_id(&mut self, v: u32) {
        self.thread_id = v;
    }

    // repeated .tensorflow.AllocationDescription referenced_tensor = 11;


    pub fn get_referenced_tensor(&self) -> &[super::allocation_description::AllocationDescription] {
        &self.referenced_tensor
    }
    pub fn clear_referenced_tensor(&mut self) {
        self.referenced_tensor.clear();
    }

    // Param is passed by value, moved
    pub fn set_referenced_tensor(&mut self, v: ::protobuf::RepeatedField<super::allocation_description::AllocationDescription>) {
        self.referenced_tensor = v;
    }

    // Mutable pointer to the field.
    pub fn mut_referenced_tensor(&mut self) -> &mut ::protobuf::RepeatedField<super::allocation_description::AllocationDescription> {
        &mut self.referenced_tensor
    }

    // Take field
    pub fn take_referenced_tensor(&mut self) -> ::protobuf::RepeatedField<super::allocation_description::AllocationDescription> {
        ::std::mem::replace(&mut self.referenced_tensor, ::protobuf::RepeatedField::new())
    }

    // .tensorflow.MemoryStats memory_stats = 12;


    pub fn get_memory_stats(&self) -> &MemoryStats {
        self.memory_stats.as_ref().unwrap_or_else(|| <MemoryStats as ::protobuf::Message>::default_instance())
    }
    pub fn clear_memory_stats(&mut self) {
        self.memory_stats.clear();
    }

    pub fn has_memory_stats(&self) -> bool {
        self.memory_stats.is_some()
    }

    // Param is passed by value, moved
    pub fn set_memory_stats(&mut self, v: MemoryStats) {
        self.memory_stats = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_memory_stats(&mut self) -> &mut MemoryStats {
        if self.memory_stats.is_none() {
            self.memory_stats.set_default();
        }
        self.memory_stats.as_mut().unwrap()
    }

    // Take field
    pub fn take_memory_stats(&mut self) -> MemoryStats {
        self.memory_stats.take().unwrap_or_else(|| MemoryStats::new())
    }

    // int64 all_start_nanos = 13;


    pub fn get_all_start_nanos(&self) -> i64 {
        self.all_start_nanos
    }
    pub fn clear_all_start_nanos(&mut self) {
        self.all_start_nanos = 0;
    }

    // Param is passed by value, moved
    pub fn set_all_start_nanos(&mut self, v: i64) {
        self.all_start_nanos = v;
    }

    // int64 op_start_rel_nanos = 14;


    pub fn get_op_start_rel_nanos(&self) -> i64 {
        self.op_start_rel_nanos
    }
    pub fn clear_op_start_rel_nanos(&mut self) {
        self.op_start_rel_nanos = 0;
    }

    // Param is passed by value, moved
    pub fn set_op_start_rel_nanos(&mut self, v: i64) {
        self.op_start_rel_nanos = v;
    }

    // int64 op_end_rel_nanos = 15;


    pub fn get_op_end_rel_nanos(&self) -> i64 {
        self.op_end_rel_nanos
    }
    pub fn clear_op_end_rel_nanos(&mut self) {
        self.op_end_rel_nanos = 0;
    }

    // Param is passed by value, moved
    pub fn set_op_end_rel_nanos(&mut self, v: i64) {
        self.op_end_rel_nanos = v;
    }

    // int64 all_end_rel_nanos = 16;


    pub fn get_all_end_rel_nanos(&self) -> i64 {
        self.all_end_rel_nanos
    }
    pub fn clear_all_end_rel_nanos(&mut self) {
        self.all_end_rel_nanos = 0;
    }

    // Param is passed by value, moved
    pub fn set_all_end_rel_nanos(&mut self, v: i64) {
        self.all_end_rel_nanos = v;
    }

    // int64 scheduled_nanos = 17;


    pub fn get_scheduled_nanos(&self) -> i64 {
        self.scheduled_nanos
    }
    pub fn clear_scheduled_nanos(&mut self) {
        self.scheduled_nanos = 0;
    }

    // Param is passed by value, moved
    pub fn set_scheduled_nanos(&mut self, v: i64) {
        self.scheduled_nanos = v;
    }
}

impl ::protobuf::Message for NodeExecStats {
    fn is_initialized(&self) -> bool {
        for v in &self.memory {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.output {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.referenced_tensor {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.memory_stats {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.node_name)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.all_start_micros = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.op_start_rel_micros = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.op_end_rel_micros = tmp;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.all_end_rel_micros = tmp;
                },
                6 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.memory)?;
                },
                7 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.output)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.timeline_label)?;
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.scheduled_micros = tmp;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.thread_id = tmp;
                },
                11 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.referenced_tensor)?;
                },
                12 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.memory_stats)?;
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.all_start_nanos = tmp;
                },
                14 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.op_start_rel_nanos = tmp;
                },
                15 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.op_end_rel_nanos = tmp;
                },
                16 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.all_end_rel_nanos = tmp;
                },
                17 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.scheduled_nanos = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.node_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.node_name);
        }
        if self.all_start_micros != 0 {
            my_size += ::protobuf::rt::value_size(2, self.all_start_micros, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.op_start_rel_micros != 0 {
            my_size += ::protobuf::rt::value_size(3, self.op_start_rel_micros, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.op_end_rel_micros != 0 {
            my_size += ::protobuf::rt::value_size(4, self.op_end_rel_micros, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.all_end_rel_micros != 0 {
            my_size += ::protobuf::rt::value_size(5, self.all_end_rel_micros, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.memory {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.output {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if !self.timeline_label.is_empty() {
            my_size += ::protobuf::rt::string_size(8, &self.timeline_label);
        }
        if self.scheduled_micros != 0 {
            my_size += ::protobuf::rt::value_size(9, self.scheduled_micros, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.thread_id != 0 {
            my_size += ::protobuf::rt::value_size(10, self.thread_id, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.referenced_tensor {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.memory_stats.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.all_start_nanos != 0 {
            my_size += ::protobuf::rt::value_size(13, self.all_start_nanos, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.op_start_rel_nanos != 0 {
            my_size += ::protobuf::rt::value_size(14, self.op_start_rel_nanos, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.op_end_rel_nanos != 0 {
            my_size += ::protobuf::rt::value_size(15, self.op_end_rel_nanos, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.all_end_rel_nanos != 0 {
            my_size += ::protobuf::rt::value_size(16, self.all_end_rel_nanos, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.scheduled_nanos != 0 {
            my_size += ::protobuf::rt::value_size(17, self.scheduled_nanos, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.node_name.is_empty() {
            os.write_string(1, &self.node_name)?;
        }
        if self.all_start_micros != 0 {
            os.write_int64(2, self.all_start_micros)?;
        }
        if self.op_start_rel_micros != 0 {
            os.write_int64(3, self.op_start_rel_micros)?;
        }
        if self.op_end_rel_micros != 0 {
            os.write_int64(4, self.op_end_rel_micros)?;
        }
        if self.all_end_rel_micros != 0 {
            os.write_int64(5, self.all_end_rel_micros)?;
        }
        for v in &self.memory {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.output {
            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if !self.timeline_label.is_empty() {
            os.write_string(8, &self.timeline_label)?;
        }
        if self.scheduled_micros != 0 {
            os.write_int64(9, self.scheduled_micros)?;
        }
        if self.thread_id != 0 {
            os.write_uint32(10, self.thread_id)?;
        }
        for v in &self.referenced_tensor {
            os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(ref v) = self.memory_stats.as_ref() {
            os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.all_start_nanos != 0 {
            os.write_int64(13, self.all_start_nanos)?;
        }
        if self.op_start_rel_nanos != 0 {
            os.write_int64(14, self.op_start_rel_nanos)?;
        }
        if self.op_end_rel_nanos != 0 {
            os.write_int64(15, self.op_end_rel_nanos)?;
        }
        if self.all_end_rel_nanos != 0 {
            os.write_int64(16, self.all_end_rel_nanos)?;
        }
        if self.scheduled_nanos != 0 {
            os.write_int64(17, self.scheduled_nanos)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> NodeExecStats {
        NodeExecStats::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "node_name",
                |m: &NodeExecStats| { &m.node_name },
                |m: &mut NodeExecStats| { &mut m.node_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "all_start_micros",
                |m: &NodeExecStats| { &m.all_start_micros },
                |m: &mut NodeExecStats| { &mut m.all_start_micros },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "op_start_rel_micros",
                |m: &NodeExecStats| { &m.op_start_rel_micros },
                |m: &mut NodeExecStats| { &mut m.op_start_rel_micros },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "op_end_rel_micros",
                |m: &NodeExecStats| { &m.op_end_rel_micros },
                |m: &mut NodeExecStats| { &mut m.op_end_rel_micros },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "all_end_rel_micros",
                |m: &NodeExecStats| { &m.all_end_rel_micros },
                |m: &mut NodeExecStats| { &mut m.all_end_rel_micros },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AllocatorMemoryUsed>>(
                "memory",
                |m: &NodeExecStats| { &m.memory },
                |m: &mut NodeExecStats| { &mut m.memory },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NodeOutput>>(
                "output",
                |m: &NodeExecStats| { &m.output },
                |m: &mut NodeExecStats| { &mut m.output },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "timeline_label",
                |m: &NodeExecStats| { &m.timeline_label },
                |m: &mut NodeExecStats| { &mut m.timeline_label },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "scheduled_micros",
                |m: &NodeExecStats| { &m.scheduled_micros },
                |m: &mut NodeExecStats| { &mut m.scheduled_micros },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "thread_id",
                |m: &NodeExecStats| { &m.thread_id },
                |m: &mut NodeExecStats| { &mut m.thread_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::allocation_description::AllocationDescription>>(
                "referenced_tensor",
                |m: &NodeExecStats| { &m.referenced_tensor },
                |m: &mut NodeExecStats| { &mut m.referenced_tensor },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MemoryStats>>(
                "memory_stats",
                |m: &NodeExecStats| { &m.memory_stats },
                |m: &mut NodeExecStats| { &mut m.memory_stats },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "all_start_nanos",
                |m: &NodeExecStats| { &m.all_start_nanos },
                |m: &mut NodeExecStats| { &mut m.all_start_nanos },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "op_start_rel_nanos",
                |m: &NodeExecStats| { &m.op_start_rel_nanos },
                |m: &mut NodeExecStats| { &mut m.op_start_rel_nanos },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "op_end_rel_nanos",
                |m: &NodeExecStats| { &m.op_end_rel_nanos },
                |m: &mut NodeExecStats| { &mut m.op_end_rel_nanos },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "all_end_rel_nanos",
                |m: &NodeExecStats| { &m.all_end_rel_nanos },
                |m: &mut NodeExecStats| { &mut m.all_end_rel_nanos },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "scheduled_nanos",
                |m: &NodeExecStats| { &m.scheduled_nanos },
                |m: &mut NodeExecStats| { &mut m.scheduled_nanos },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<NodeExecStats>(
                "NodeExecStats",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static NodeExecStats {
        static instance: ::protobuf::rt::LazyV2<NodeExecStats> = ::protobuf::rt::LazyV2::INIT;
        instance.get(NodeExecStats::new)
    }
}

impl ::protobuf::Clear for NodeExecStats {
    fn clear(&mut self) {
        self.node_name.clear();
        self.all_start_micros = 0;
        self.op_start_rel_micros = 0;
        self.op_end_rel_micros = 0;
        self.all_end_rel_micros = 0;
        self.memory.clear();
        self.output.clear();
        self.timeline_label.clear();
        self.scheduled_micros = 0;
        self.thread_id = 0;
        self.referenced_tensor.clear();
        self.memory_stats.clear();
        self.all_start_nanos = 0;
        self.op_start_rel_nanos = 0;
        self.op_end_rel_nanos = 0;
        self.all_end_rel_nanos = 0;
        self.scheduled_nanos = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for NodeExecStats {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for NodeExecStats {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DeviceStepStats {
    // message fields
    pub device: ::std::string::String,
    pub node_stats: ::protobuf::RepeatedField<NodeExecStats>,
    pub thread_names: ::std::collections::HashMap<u32, ::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a DeviceStepStats {
    fn default() -> &'a DeviceStepStats {
        <DeviceStepStats as ::protobuf::Message>::default_instance()
    }
}

impl DeviceStepStats {
    pub fn new() -> DeviceStepStats {
        ::std::default::Default::default()
    }

    // string device = 1;


    pub fn get_device(&self) -> &str {
        &self.device
    }
    pub fn clear_device(&mut self) {
        self.device.clear();
    }

    // Param is passed by value, moved
    pub fn set_device(&mut self, v: ::std::string::String) {
        self.device = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_device(&mut self) -> &mut ::std::string::String {
        &mut self.device
    }

    // Take field
    pub fn take_device(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.device, ::std::string::String::new())
    }

    // repeated .tensorflow.NodeExecStats node_stats = 2;


    pub fn get_node_stats(&self) -> &[NodeExecStats] {
        &self.node_stats
    }
    pub fn clear_node_stats(&mut self) {
        self.node_stats.clear();
    }

    // Param is passed by value, moved
    pub fn set_node_stats(&mut self, v: ::protobuf::RepeatedField<NodeExecStats>) {
        self.node_stats = v;
    }

    // Mutable pointer to the field.
    pub fn mut_node_stats(&mut self) -> &mut ::protobuf::RepeatedField<NodeExecStats> {
        &mut self.node_stats
    }

    // Take field
    pub fn take_node_stats(&mut self) -> ::protobuf::RepeatedField<NodeExecStats> {
        ::std::mem::replace(&mut self.node_stats, ::protobuf::RepeatedField::new())
    }

    // repeated .tensorflow.DeviceStepStats.ThreadNamesEntry thread_names = 3;


    pub fn get_thread_names(&self) -> &::std::collections::HashMap<u32, ::std::string::String> {
        &self.thread_names
    }
    pub fn clear_thread_names(&mut self) {
        self.thread_names.clear();
    }

    // Param is passed by value, moved
    pub fn set_thread_names(&mut self, v: ::std::collections::HashMap<u32, ::std::string::String>) {
        self.thread_names = v;
    }

    // Mutable pointer to the field.
    pub fn mut_thread_names(&mut self) -> &mut ::std::collections::HashMap<u32, ::std::string::String> {
        &mut self.thread_names
    }

    // Take field
    pub fn take_thread_names(&mut self) -> ::std::collections::HashMap<u32, ::std::string::String> {
        ::std::mem::replace(&mut self.thread_names, ::std::collections::HashMap::new())
    }
}

impl ::protobuf::Message for DeviceStepStats {
    fn is_initialized(&self) -> bool {
        for v in &self.node_stats {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.device)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.node_stats)?;
                },
                3 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeUint32, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.thread_names)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.device.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.device);
        }
        for value in &self.node_stats {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeUint32, ::protobuf::types::ProtobufTypeString>(3, &self.thread_names);
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.device.is_empty() {
            os.write_string(1, &self.device)?;
        }
        for v in &self.node_stats {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeUint32, ::protobuf::types::ProtobufTypeString>(3, &self.thread_names, os)?;
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> DeviceStepStats {
        DeviceStepStats::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "device",
                |m: &DeviceStepStats| { &m.device },
                |m: &mut DeviceStepStats| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NodeExecStats>>(
                "node_stats",
                |m: &DeviceStepStats| { &m.node_stats },
                |m: &mut DeviceStepStats| { &mut m.node_stats },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeUint32, ::protobuf::types::ProtobufTypeString>(
                "thread_names",
                |m: &DeviceStepStats| { &m.thread_names },
                |m: &mut DeviceStepStats| { &mut m.thread_names },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeviceStepStats>(
                "DeviceStepStats",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static DeviceStepStats {
        static instance: ::protobuf::rt::LazyV2<DeviceStepStats> = ::protobuf::rt::LazyV2::INIT;
        instance.get(DeviceStepStats::new)
    }
}

impl ::protobuf::Clear for DeviceStepStats {
    fn clear(&mut self) {
        self.device.clear();
        self.node_stats.clear();
        self.thread_names.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for DeviceStepStats {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for DeviceStepStats {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct StepStats {
    // message fields
    pub dev_stats: ::protobuf::RepeatedField<DeviceStepStats>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a StepStats {
    fn default() -> &'a StepStats {
        <StepStats as ::protobuf::Message>::default_instance()
    }
}

impl StepStats {
    pub fn new() -> StepStats {
        ::std::default::Default::default()
    }

    // repeated .tensorflow.DeviceStepStats dev_stats = 1;


    pub fn get_dev_stats(&self) -> &[DeviceStepStats] {
        &self.dev_stats
    }
    pub fn clear_dev_stats(&mut self) {
        self.dev_stats.clear();
    }

    // Param is passed by value, moved
    pub fn set_dev_stats(&mut self, v: ::protobuf::RepeatedField<DeviceStepStats>) {
        self.dev_stats = v;
    }

    // Mutable pointer to the field.
    pub fn mut_dev_stats(&mut self) -> &mut ::protobuf::RepeatedField<DeviceStepStats> {
        &mut self.dev_stats
    }

    // Take field
    pub fn take_dev_stats(&mut self) -> ::protobuf::RepeatedField<DeviceStepStats> {
        ::std::mem::replace(&mut self.dev_stats, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for StepStats {
    fn is_initialized(&self) -> bool {
        for v in &self.dev_stats {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.dev_stats)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.dev_stats {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.dev_stats {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> StepStats {
        StepStats::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DeviceStepStats>>(
                "dev_stats",
                |m: &StepStats| { &m.dev_stats },
                |m: &mut StepStats| { &mut m.dev_stats },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<StepStats>(
                "StepStats",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static StepStats {
        static instance: ::protobuf::rt::LazyV2<StepStats> = ::protobuf::rt::LazyV2::INIT;
        instance.get(StepStats::new)
    }
}

impl ::protobuf::Clear for StepStats {
    fn clear(&mut self) {
        self.dev_stats.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for StepStats {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for StepStats {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n*tensorflow/core/framework/step_stats.proto\x12\ntensorflow\x1a6tensor\
    flow/core/framework/allocation_description.proto\x1a2tensorflow/core/fra\
    mework/tensor_description.proto\"V\n\x10AllocationRecord\x12!\n\x0calloc\
    _micros\x18\x01\x20\x01(\x03R\x0ballocMicros\x12\x1f\n\x0balloc_bytes\
    \x18\x02\x20\x01(\x03R\nallocBytes\"\x9d\x02\n\x13AllocatorMemoryUsed\
    \x12%\n\x0eallocator_name\x18\x01\x20\x01(\tR\rallocatorName\x12\x1f\n\
    \x0btotal_bytes\x18\x02\x20\x01(\x03R\ntotalBytes\x12\x1d\n\npeak_bytes\
    \x18\x03\x20\x01(\x03R\tpeakBytes\x12\x1d\n\nlive_bytes\x18\x04\x20\x01(\
    \x03R\tliveBytes\x12K\n\x12allocation_records\x18\x06\x20\x03(\x0b2\x1c.\
    tensorflow.AllocationRecordR\x11allocationRecords\x123\n\x16allocator_by\
    tes_in_use\x18\x05\x20\x01(\x03R\x13allocatorBytesInUse\"n\n\nNodeOutput\
    \x12\x12\n\x04slot\x18\x01\x20\x01(\x05R\x04slot\x12L\n\x12tensor_descri\
    ption\x18\x03\x20\x01(\x0b2\x1d.tensorflow.TensorDescriptionR\x11tensorD\
    escription\"\xfe\x02\n\x0bMemoryStats\x12(\n\x10temp_memory_size\x18\x01\
    \x20\x01(\x03R\x0etempMemorySize\x124\n\x16persistent_memory_size\x18\
    \x03\x20\x01(\x03R\x14persistentMemorySize\x12=\n\x1bpersistent_tensor_a\
    lloc_ids\x18\x05\x20\x03(\x03R\x18persistentTensorAllocIds\x129\n\x17dev\
    ice_temp_memory_size\x18\x02\x20\x01(\x03R\x14deviceTempMemorySizeB\x02\
    \x18\x01\x12E\n\x1ddevice_persistent_memory_size\x18\x04\x20\x01(\x03R\
    \x1adevicePersistentMemorySizeB\x02\x18\x01\x12N\n\"device_persistent_te\
    nsor_alloc_ids\x18\x06\x20\x03(\x03R\x1edevicePersistentTensorAllocIdsB\
    \x02\x18\x01\"\x93\x06\n\rNodeExecStats\x12\x1b\n\tnode_name\x18\x01\x20\
    \x01(\tR\x08nodeName\x12(\n\x10all_start_micros\x18\x02\x20\x01(\x03R\
    \x0eallStartMicros\x12-\n\x13op_start_rel_micros\x18\x03\x20\x01(\x03R\
    \x10opStartRelMicros\x12)\n\x11op_end_rel_micros\x18\x04\x20\x01(\x03R\
    \x0eopEndRelMicros\x12+\n\x12all_end_rel_micros\x18\x05\x20\x01(\x03R\
    \x0fallEndRelMicros\x127\n\x06memory\x18\x06\x20\x03(\x0b2\x1f.tensorflo\
    w.AllocatorMemoryUsedR\x06memory\x12.\n\x06output\x18\x07\x20\x03(\x0b2\
    \x16.tensorflow.NodeOutputR\x06output\x12%\n\x0etimeline_label\x18\x08\
    \x20\x01(\tR\rtimelineLabel\x12)\n\x10scheduled_micros\x18\t\x20\x01(\
    \x03R\x0fscheduledMicros\x12\x1b\n\tthread_id\x18\n\x20\x01(\rR\x08threa\
    dId\x12N\n\x11referenced_tensor\x18\x0b\x20\x03(\x0b2!.tensorflow.Alloca\
    tionDescriptionR\x10referencedTensor\x12:\n\x0cmemory_stats\x18\x0c\x20\
    \x01(\x0b2\x17.tensorflow.MemoryStatsR\x0bmemoryStats\x12&\n\x0fall_star\
    t_nanos\x18\r\x20\x01(\x03R\rallStartNanos\x12+\n\x12op_start_rel_nanos\
    \x18\x0e\x20\x01(\x03R\x0fopStartRelNanos\x12'\n\x10op_end_rel_nanos\x18\
    \x0f\x20\x01(\x03R\ropEndRelNanos\x12)\n\x11all_end_rel_nanos\x18\x10\
    \x20\x01(\x03R\x0eallEndRelNanos\x12'\n\x0fscheduled_nanos\x18\x11\x20\
    \x01(\x03R\x0escheduledNanos\"\xf4\x01\n\x0fDeviceStepStats\x12\x16\n\
    \x06device\x18\x01\x20\x01(\tR\x06device\x128\n\nnode_stats\x18\x02\x20\
    \x03(\x0b2\x19.tensorflow.NodeExecStatsR\tnodeStats\x12O\n\x0cthread_nam\
    es\x18\x03\x20\x03(\x0b2,.tensorflow.DeviceStepStats.ThreadNamesEntryR\
    \x0bthreadNames\x1a>\n\x10ThreadNamesEntry\x12\x10\n\x03key\x18\x01\x20\
    \x01(\rR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\
    \x01\"E\n\tStepStats\x128\n\tdev_stats\x18\x01\x20\x03(\x0b2\x1b.tensorf\
    low.DeviceStepStatsR\x08devStatsB\x83\x01\n\x18org.tensorflow.frameworkB\
    \x0fStepStatsProtosP\x01ZQgithub.com/tensorflow/tensorflow/tensorflow/go\
    /core/framework/step_stats_go_proto\xf8\x01\x01b\x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}