tensorboard_proto/

step_stats.rs

// 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 `src/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 .tensorboardrs.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,
    // 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;
    }
}

impl ::protobuf::Message for NodeOutput {
    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_int32()?;
                    self.slot = 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.slot != 0 {
            my_size += ::protobuf::rt::value_size(1, self.slot, ::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.slot != 0 {
            os.write_int32(1, self.slot)?;
        }
        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 },
            ));
            ::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.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 memory_stats: ::protobuf::SingularPtrField<MemoryStats>,
    // 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 .tensorboardrs.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 .tensorboardrs.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;
    }

    // .tensorboardrs.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())
    }
}

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.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;
                },
                12 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.memory_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;
        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);
        }
        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;
        }
        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)?;
        }
        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)?;
        }
        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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MemoryStats>>(
                "memory_stats",
                |m: &NodeExecStats| { &m.memory_stats },
                |m: &mut NodeExecStats| { &mut m.memory_stats },
            ));
            ::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.memory_stats.clear();
        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>,
    // 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 .tensorboardrs.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())
    }
}

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)?;
                },
                _ => {
                    ::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::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)?;
        };
        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 },
            ));
            ::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.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 .tensorboardrs.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)
    }
}

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

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

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

    // .tensorboardrs.StepStats step_stats = 1;


    pub fn get_step_stats(&self) -> &StepStats {
        self.step_stats.as_ref().unwrap_or_else(|| <StepStats as ::protobuf::Message>::default_instance())
    }
    pub fn clear_step_stats(&mut self) {
        self.step_stats.clear();
    }

    pub fn has_step_stats(&self) -> bool {
        self.step_stats.is_some()
    }

    // Param is passed by value, moved
    pub fn set_step_stats(&mut self, v: StepStats) {
        self.step_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_step_stats(&mut self) -> &mut StepStats {
        if self.step_stats.is_none() {
            self.step_stats.set_default();
        }
        self.step_stats.as_mut().unwrap()
    }

    // Take field
    pub fn take_step_stats(&mut self) -> StepStats {
        self.step_stats.take().unwrap_or_else(|| StepStats::new())
    }
}

impl ::protobuf::Message for RunMetadata {
    fn is_initialized(&self) -> bool {
        for v in &self.step_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_message_into(wire_type, is, &mut self.step_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;
        if let Some(ref v) = self.step_stats.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 let Some(ref v) = self.step_stats.as_ref() {
            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() -> RunMetadata {
        RunMetadata::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StepStats>>(
                "step_stats",
                |m: &RunMetadata| { &m.step_stats },
                |m: &mut RunMetadata| { &mut m.step_stats },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RunMetadata>(
                "RunMetadata",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x14src/step_stats.proto\x12\rtensorboardrs\"V\n\x10AllocationRecord\
    \x12!\n\x0calloc_micros\x18\x01\x20\x01(\x03R\x0ballocMicros\x12\x1f\n\
    \x0balloc_bytes\x18\x02\x20\x01(\x03R\nallocBytes\"\xa0\x02\n\x13Allocat\
    orMemoryUsed\x12%\n\x0eallocator_name\x18\x01\x20\x01(\tR\rallocatorName\
    \x12\x1f\n\x0btotal_bytes\x18\x02\x20\x01(\x03R\ntotalBytes\x12\x1d\n\np\
    eak_bytes\x18\x03\x20\x01(\x03R\tpeakBytes\x12\x1d\n\nlive_bytes\x18\x04\
    \x20\x01(\x03R\tliveBytes\x12N\n\x12allocation_records\x18\x06\x20\x03(\
    \x0b2\x1f.tensorboardrs.AllocationRecordR\x11allocationRecords\x123\n\
    \x16allocator_bytes_in_use\x18\x05\x20\x01(\x03R\x13allocatorBytesInUse\
    \"\x20\n\nNodeOutput\x12\x12\n\x04slot\x18\x01\x20\x01(\x05R\x04slot\"\
    \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_alloc_ids\x18\
    \x05\x20\x03(\x03R\x18persistentTensorAllocIds\x129\n\x17device_temp_mem\
    ory_size\x18\x02\x20\x01(\x03R\x14deviceTempMemorySizeB\x02\x18\x01\x12E\
    \n\x1ddevice_persistent_memory_size\x18\x04\x20\x01(\x03R\x1adevicePersi\
    stentMemorySizeB\x02\x18\x01\x12N\n\"device_persistent_tensor_alloc_ids\
    \x18\x06\x20\x03(\x03R\x1edevicePersistentTensorAllocIdsB\x02\x18\x01\"\
    \xfa\x03\n\rNodeExecStats\x12\x1b\n\tnode_name\x18\x01\x20\x01(\tR\x08no\
    deName\x12(\n\x10all_start_micros\x18\x02\x20\x01(\x03R\x0eallStartMicro\
    s\x12-\n\x13op_start_rel_micros\x18\x03\x20\x01(\x03R\x10opStartRelMicro\
    s\x12)\n\x11op_end_rel_micros\x18\x04\x20\x01(\x03R\x0eopEndRelMicros\
    \x12+\n\x12all_end_rel_micros\x18\x05\x20\x01(\x03R\x0fallEndRelMicros\
    \x12:\n\x06memory\x18\x06\x20\x03(\x0b2\".tensorboardrs.AllocatorMemoryU\
    sedR\x06memory\x121\n\x06output\x18\x07\x20\x03(\x0b2\x19.tensorboardrs.\
    NodeOutputR\x06output\x12%\n\x0etimeline_label\x18\x08\x20\x01(\tR\rtime\
    lineLabel\x12)\n\x10scheduled_micros\x18\t\x20\x01(\x03R\x0fscheduledMic\
    ros\x12\x1b\n\tthread_id\x18\n\x20\x01(\rR\x08threadId\x12=\n\x0cmemory_\
    stats\x18\x0c\x20\x01(\x0b2\x1a.tensorboardrs.MemoryStatsR\x0bmemoryStat\
    s\"f\n\x0fDeviceStepStats\x12\x16\n\x06device\x18\x01\x20\x01(\tR\x06dev\
    ice\x12;\n\nnode_stats\x18\x02\x20\x03(\x0b2\x1c.tensorboardrs.NodeExecS\
    tatsR\tnodeStats\"H\n\tStepStats\x12;\n\tdev_stats\x18\x01\x20\x03(\x0b2\
    \x1e.tensorboardrs.DeviceStepStatsR\x08devStats\"F\n\x0bRunMetadata\x127\
    \n\nstep_stats\x18\x01\x20\x01(\x0b2\x18.tensorboardrs.StepStatsR\tstepS\
    tatsBo\n\x18org.tensorflow.frameworkB\x0fStepStatsProtosP\x01Z=github.co\
    m/tensorflow/tensorflow/tensorflow/go/core/framework\xf8\x01\x01J\xf7\
    \x1a\n\x06\x12\x04\0\0^\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\
    \x02\x12\x03\x02\0\x16\n\x08\n\x01\x08\x12\x03\x03\0\x1f\n\t\n\x02\x08\
    \x1f\x12\x03\x03\0\x1f\n\x08\n\x01\x08\x12\x03\x04\00\n\t\n\x02\x08\x08\
    \x12\x03\x04\00\n\x08\n\x01\x08\x12\x03\x05\0\"\n\t\n\x02\x08\n\x12\x03\
    \x05\0\"\n\x08\n\x01\x08\x12\x03\x06\01\n\t\n\x02\x08\x01\x12\x03\x06\01\
    \n\x08\n\x01\x08\x12\x03\x07\0T\n\x89\x01\n\x02\x08\x0b\x12\x03\x07\0T\"\
    ~import\x20\"tensorflow/core/framework/allocation_description.proto\";\n\
    import\x20\"tensorflow/core/framework/tensor_description.proto\";\n\nO\n\
    \x02\x04\0\x12\x04\x0c\0\x11\x01\x1aC\x20An\x20allocation/de-allocation\
    \x20operation\x20performed\x20by\x20the\x20allocator.\n\n\n\n\x03\x04\0\
    \x01\x12\x03\x0c\x08\x18\n.\n\x04\x04\0\x02\0\x12\x03\x0e\x02\x19\x1a!\
    \x20The\x20timestamp\x20of\x20the\x20operation.\n\n\x0c\n\x05\x04\0\x02\
    \0\x05\x12\x03\x0e\x02\x07\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x0e\x08\
    \x14\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x0e\x17\x18\nF\n\x04\x04\0\x02\
    \x01\x12\x03\x10\x02\x18\x1a9\x20Number\x20of\x20bytes\x20allocated,\x20\
    or\x20de-allocated\x20if\x20negative.\n\n\x0c\n\x05\x04\0\x02\x01\x05\
    \x12\x03\x10\x02\x07\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x10\x08\x13\n\
    \x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x10\x16\x17\n\n\n\x02\x04\x01\x12\
    \x04\x13\0\x20\x01\n\n\n\x03\x04\x01\x01\x12\x03\x13\x08\x1b\n\x0b\n\x04\
    \x04\x01\x02\0\x12\x03\x14\x02\x1c\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\
    \x14\x02\x08\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x14\t\x17\n\x0c\n\x05\
    \x04\x01\x02\0\x03\x12\x03\x14\x1a\x1b\n9\n\x04\x04\x01\x02\x01\x12\x03\
    \x16\x02\x18\x1a,\x20These\x20are\x20per-node\x20allocator\x20memory\x20\
    stats.\n\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\x16\x02\x07\n\x0c\n\x05\
    \x04\x01\x02\x01\x01\x12\x03\x16\x08\x13\n\x0c\n\x05\x04\x01\x02\x01\x03\
    \x12\x03\x16\x16\x17\n\x0b\n\x04\x04\x01\x02\x02\x12\x03\x17\x02\x17\n\
    \x0c\n\x05\x04\x01\x02\x02\x05\x12\x03\x17\x02\x07\n\x0c\n\x05\x04\x01\
    \x02\x02\x01\x12\x03\x17\x08\x12\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\
    \x17\x15\x16\n2\n\x04\x04\x01\x02\x03\x12\x03\x19\x02\x17\x1a%\x20The\
    \x20bytes\x20that\x20are\x20not\x20deallocated.\n\n\x0c\n\x05\x04\x01\
    \x02\x03\x05\x12\x03\x19\x02\x07\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03\
    \x19\x08\x12\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03\x19\x15\x16\n8\n\
    \x04\x04\x01\x02\x04\x12\x03\x1b\x023\x1a+\x20The\x20allocation\x20and\
    \x20deallocation\x20timeline.\n\n\x0c\n\x05\x04\x01\x02\x04\x04\x12\x03\
    \x1b\x02\n\n\x0c\n\x05\x04\x01\x02\x04\x06\x12\x03\x1b\x0b\x1b\n\x0c\n\
    \x05\x04\x01\x02\x04\x01\x12\x03\x1b\x1c.\n\x0c\n\x05\x04\x01\x02\x04\
    \x03\x12\x03\x1b12\n\x89\x01\n\x04\x04\x01\x02\x05\x12\x03\x1f\x02#\x1a|\
    \x20These\x20are\x20snapshots\x20of\x20the\x20overall\x20allocator\x20me\
    mory\x20stats.\n\x20The\x20number\x20of\x20live\x20bytes\x20currently\
    \x20allocated\x20by\x20the\x20allocator.\n\n\x0c\n\x05\x04\x01\x02\x05\
    \x05\x12\x03\x1f\x02\x07\n\x0c\n\x05\x04\x01\x02\x05\x01\x12\x03\x1f\x08\
    \x1e\n\x0c\n\x05\x04\x01\x02\x05\x03\x12\x03\x1f!\"\nK\n\x02\x04\x02\x12\
    \x04#\0&\x01\x1a?\x20Output\x20sizes\x20recorded\x20for\x20a\x20single\
    \x20execution\x20of\x20a\x20graph\x20node.\n\n\n\n\x03\x04\x02\x01\x12\
    \x03#\x08\x12\n8\n\x04\x04\x02\x02\0\x12\x03$\x02\x11\"+\x20TensorDescri\
    ption\x20tensor_description\x20=\x203;\n\n\x0c\n\x05\x04\x02\x02\0\x05\
    \x12\x03$\x02\x07\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03$\x08\x0c\n\x0c\n\
    \x05\x04\x02\x02\0\x03\x12\x03$\x0f\x10\n\"\n\x02\x04\x03\x12\x04)\01\
    \x01\x1a\x16\x20For\x20memory\x20tracking.\n\n\n\n\x03\x04\x03\x01\x12\
    \x03)\x08\x13\n\x0b\n\x04\x04\x03\x02\0\x12\x03*\x02\x1d\n\x0c\n\x05\x04\
    \x03\x02\0\x05\x12\x03*\x02\x07\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03*\
    \x08\x18\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03*\x1b\x1c\n\x0b\n\x04\x04\
    \x03\x02\x01\x12\x03+\x02#\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03+\x02\
    \x07\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03+\x08\x1e\n\x0c\n\x05\x04\
    \x03\x02\x01\x03\x12\x03+!\"\n\x0b\n\x04\x04\x03\x02\x02\x12\x03,\x021\n\
    \x0c\n\x05\x04\x03\x02\x02\x04\x12\x03,\x02\n\n\x0c\n\x05\x04\x03\x02\
    \x02\x05\x12\x03,\x0b\x10\n\x0c\n\x05\x04\x03\x02\x02\x01\x12\x03,\x11,\
    \n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03,/0\n\x0b\n\x04\x04\x03\x02\x03\
    \x12\x03.\x028\n\x0c\n\x05\x04\x03\x02\x03\x05\x12\x03.\x02\x07\n\x0c\n\
    \x05\x04\x03\x02\x03\x01\x12\x03.\x08\x1f\n\x0c\n\x05\x04\x03\x02\x03\
    \x03\x12\x03.\"#\n\x0c\n\x05\x04\x03\x02\x03\x08\x12\x03.$7\n\r\n\x06\
    \x04\x03\x02\x03\x08\x03\x12\x03.%6\n\x0b\n\x04\x04\x03\x02\x04\x12\x03/\
    \x02>\n\x0c\n\x05\x04\x03\x02\x04\x05\x12\x03/\x02\x07\n\x0c\n\x05\x04\
    \x03\x02\x04\x01\x12\x03/\x08%\n\x0c\n\x05\x04\x03\x02\x04\x03\x12\x03/(\
    )\n\x0c\n\x05\x04\x03\x02\x04\x08\x12\x03/*=\n\r\n\x06\x04\x03\x02\x04\
    \x08\x03\x12\x03/+<\n\x0b\n\x04\x04\x03\x02\x05\x12\x030\x02L\n\x0c\n\
    \x05\x04\x03\x02\x05\x04\x12\x030\x02\n\n\x0c\n\x05\x04\x03\x02\x05\x05\
    \x12\x030\x0b\x10\n\x0c\n\x05\x04\x03\x02\x05\x01\x12\x030\x113\n\x0c\n\
    \x05\x04\x03\x02\x05\x03\x12\x03067\n\x0c\n\x05\x04\x03\x02\x05\x08\x12\
    \x0308K\n\r\n\x06\x04\x03\x02\x05\x08\x03\x12\x0309J\nN\n\x02\x04\x04\
    \x12\x044\0E\x01\x1aB\x20Time/size\x20stats\x20recorded\x20for\x20a\x20s\
    ingle\x20execution\x20of\x20a\x20graph\x20node.\n\n\n\n\x03\x04\x04\x01\
    \x12\x034\x08\x15\n\xd8\x01\n\x04\x04\x04\x02\0\x12\x039\x02\x17\x1a\xca\
    \x01\x20TODO(tucker):\x20Use\x20some\x20more\x20compact\x20form\x20of\
    \x20node\x20identity\x20than\n\x20the\x20full\x20string\x20name.\x20\x20\
    Either\x20all\x20processes\x20should\x20agree\x20on\x20a\n\x20global\x20\
    id\x20(cost_id?)\x20for\x20each\x20node,\x20or\x20we\x20should\x20use\
    \x20a\x20hash\x20of\n\x20the\x20name.\n\n\x0c\n\x05\x04\x04\x02\0\x05\
    \x12\x039\x02\x08\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x039\t\x12\n\x0c\n\
    \x05\x04\x04\x02\0\x03\x12\x039\x15\x16\n\x0b\n\x04\x04\x04\x02\x01\x12\
    \x03:\x02\x1d\n\x0c\n\x05\x04\x04\x02\x01\x05\x12\x03:\x02\x07\n\x0c\n\
    \x05\x04\x04\x02\x01\x01\x12\x03:\x08\x18\n\x0c\n\x05\x04\x04\x02\x01\
    \x03\x12\x03:\x1b\x1c\n\x0b\n\x04\x04\x04\x02\x02\x12\x03;\x02\x20\n\x0c\
    \n\x05\x04\x04\x02\x02\x05\x12\x03;\x02\x07\n\x0c\n\x05\x04\x04\x02\x02\
    \x01\x12\x03;\x08\x1b\n\x0c\n\x05\x04\x04\x02\x02\x03\x12\x03;\x1e\x1f\n\
    \x0b\n\x04\x04\x04\x02\x03\x12\x03<\x02\x1e\n\x0c\n\x05\x04\x04\x02\x03\
    \x05\x12\x03<\x02\x07\n\x0c\n\x05\x04\x04\x02\x03\x01\x12\x03<\x08\x19\n\
    \x0c\n\x05\x04\x04\x02\x03\x03\x12\x03<\x1c\x1d\n\x0b\n\x04\x04\x04\x02\
    \x04\x12\x03=\x02\x1f\n\x0c\n\x05\x04\x04\x02\x04\x05\x12\x03=\x02\x07\n\
    \x0c\n\x05\x04\x04\x02\x04\x01\x12\x03=\x08\x1a\n\x0c\n\x05\x04\x04\x02\
    \x04\x03\x12\x03=\x1d\x1e\n\x0b\n\x04\x04\x04\x02\x05\x12\x03>\x02*\n\
    \x0c\n\x05\x04\x04\x02\x05\x04\x12\x03>\x02\n\n\x0c\n\x05\x04\x04\x02\
    \x05\x06\x12\x03>\x0b\x1e\n\x0c\n\x05\x04\x04\x02\x05\x01\x12\x03>\x1f%\
    \n\x0c\n\x05\x04\x04\x02\x05\x03\x12\x03>()\n\x0b\n\x04\x04\x04\x02\x06\
    \x12\x03?\x02!\n\x0c\n\x05\x04\x04\x02\x06\x04\x12\x03?\x02\n\n\x0c\n\
    \x05\x04\x04\x02\x06\x06\x12\x03?\x0b\x15\n\x0c\n\x05\x04\x04\x02\x06\
    \x01\x12\x03?\x16\x1c\n\x0c\n\x05\x04\x04\x02\x06\x03\x12\x03?\x1f\x20\n\
    \x0b\n\x04\x04\x04\x02\x07\x12\x03@\x02\x1c\n\x0c\n\x05\x04\x04\x02\x07\
    \x05\x12\x03@\x02\x08\n\x0c\n\x05\x04\x04\x02\x07\x01\x12\x03@\t\x17\n\
    \x0c\n\x05\x04\x04\x02\x07\x03\x12\x03@\x1a\x1b\n\x0b\n\x04\x04\x04\x02\
    \x08\x12\x03A\x02\x1d\n\x0c\n\x05\x04\x04\x02\x08\x05\x12\x03A\x02\x07\n\
    \x0c\n\x05\x04\x04\x02\x08\x01\x12\x03A\x08\x18\n\x0c\n\x05\x04\x04\x02\
    \x08\x03\x12\x03A\x1b\x1c\n\x0b\n\x04\x04\x04\x02\t\x12\x03B\x02\x18\n\
    \x0c\n\x05\x04\x04\x02\t\x05\x12\x03B\x02\x08\n\x0c\n\x05\x04\x04\x02\t\
    \x01\x12\x03B\t\x12\n\x0c\n\x05\x04\x04\x02\t\x03\x12\x03B\x15\x17\nE\n\
    \x04\x04\x04\x02\n\x12\x03D\x02\x20\x1a8\x20repeated\x20AllocationDescri\
    ption\x20referenced_tensor\x20=\x2011;\n\n\x0c\n\x05\x04\x04\x02\n\x06\
    \x12\x03D\x02\r\n\x0c\n\x05\x04\x04\x02\n\x01\x12\x03D\x0e\x1a\n\x0c\n\
    \x05\x04\x04\x02\n\x03\x12\x03D\x1d\x1f\n\n\n\x02\x04\x05\x12\x04G\0J\
    \x01\n\n\n\x03\x04\x05\x01\x12\x03G\x08\x17\n\x0b\n\x04\x04\x05\x02\0\
    \x12\x03H\x02\x14\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03H\x02\x08\n\x0c\n\
    \x05\x04\x05\x02\0\x01\x12\x03H\t\x0f\n\x0c\n\x05\x04\x05\x02\0\x03\x12\
    \x03H\x12\x13\n\x0b\n\x04\x04\x05\x02\x01\x12\x03I\x02(\n\x0c\n\x05\x04\
    \x05\x02\x01\x04\x12\x03I\x02\n\n\x0c\n\x05\x04\x05\x02\x01\x06\x12\x03I\
    \x0b\x18\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03I\x19#\n\x0c\n\x05\x04\
    \x05\x02\x01\x03\x12\x03I&'\n\n\n\x02\x04\x06\x12\x04L\0N\x01\n\n\n\x03\
    \x04\x06\x01\x12\x03L\x08\x11\n\x0b\n\x04\x04\x06\x02\0\x12\x03M\x02)\n\
    \x0c\n\x05\x04\x06\x02\0\x04\x12\x03M\x02\n\n\x0c\n\x05\x04\x06\x02\0\
    \x06\x12\x03M\x0b\x1a\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03M\x1b$\n\x0c\
    \n\x05\x04\x06\x02\0\x03\x12\x03M'(\nj\n\x02\x04\x07\x12\x04S\0^\x01\x1a\
    ^\x20lanpa,\x20copied\x20from\x20config.proto\n\x20Metadata\x20output\
    \x20(i.e.,\x20non-Tensor)\x20for\x20a\x20single\x20Run()\x20call.\n\n\n\
    \n\x03\x04\x07\x01\x12\x03S\x08\x13\n\xba\x01\n\x04\x04\x07\x02\0\x12\
    \x03W\x02\x1b\x1a\xac\x01\x20Statistics\x20traced\x20for\x20this\x20step\
    .\x20Populated\x20if\x20tracing\x20is\x20turned\x20on\x20via\x20the\n\
    \x20\"RunOptions\"\x20proto.\n\x20EXPERIMENTAL:\x20The\x20format\x20and\
    \x20set\x20of\x20events\x20may\x20change\x20in\x20future\x20versions.\n\
    \n\x0c\n\x05\x04\x07\x02\0\x06\x12\x03W\x02\x0b\n\x0c\n\x05\x04\x07\x02\
    \0\x01\x12\x03W\x0c\x16\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03W\x19\x1ab\
    \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()
    })
}