#![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)]
#[derive(PartialEq,Clone,Default)]
pub struct AllocationRecord {
pub alloc_micros: i64,
pub alloc_bytes: i64,
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()
}
pub fn get_alloc_micros(&self) -> i64 {
self.alloc_micros
}
pub fn clear_alloc_micros(&mut self) {
self.alloc_micros = 0;
}
pub fn set_alloc_micros(&mut self, v: i64) {
self.alloc_micros = v;
}
pub fn get_alloc_bytes(&self) -> i64 {
self.alloc_bytes
}
pub fn clear_alloc_bytes(&mut self) {
self.alloc_bytes = 0;
}
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(())
}
#[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 {
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,
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()
}
pub fn get_allocator_name(&self) -> &str {
&self.allocator_name
}
pub fn clear_allocator_name(&mut self) {
self.allocator_name.clear();
}
pub fn set_allocator_name(&mut self, v: ::std::string::String) {
self.allocator_name = v;
}
pub fn mut_allocator_name(&mut self) -> &mut ::std::string::String {
&mut self.allocator_name
}
pub fn take_allocator_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.allocator_name, ::std::string::String::new())
}
pub fn get_total_bytes(&self) -> i64 {
self.total_bytes
}
pub fn clear_total_bytes(&mut self) {
self.total_bytes = 0;
}
pub fn set_total_bytes(&mut self, v: i64) {
self.total_bytes = v;
}
pub fn get_peak_bytes(&self) -> i64 {
self.peak_bytes
}
pub fn clear_peak_bytes(&mut self) {
self.peak_bytes = 0;
}
pub fn set_peak_bytes(&mut self, v: i64) {
self.peak_bytes = v;
}
pub fn get_live_bytes(&self) -> i64 {
self.live_bytes
}
pub fn clear_live_bytes(&mut self) {
self.live_bytes = 0;
}
pub fn set_live_bytes(&mut self, v: i64) {
self.live_bytes = v;
}
pub fn get_allocation_records(&self) -> &[AllocationRecord] {
&self.allocation_records
}
pub fn clear_allocation_records(&mut self) {
self.allocation_records.clear();
}
pub fn set_allocation_records(&mut self, v: ::protobuf::RepeatedField<AllocationRecord>) {
self.allocation_records = v;
}
pub fn mut_allocation_records(&mut self) -> &mut ::protobuf::RepeatedField<AllocationRecord> {
&mut self.allocation_records
}
pub fn take_allocation_records(&mut self) -> ::protobuf::RepeatedField<AllocationRecord> {
::std::mem::replace(&mut self.allocation_records, ::protobuf::RepeatedField::new())
}
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;
}
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(())
}
#[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 {
pub slot: i32,
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()
}
pub fn get_slot(&self) -> i32 {
self.slot
}
pub fn clear_slot(&mut self) {
self.slot = 0;
}
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(())
}
#[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 {
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>,
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()
}
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;
}
pub fn set_temp_memory_size(&mut self, v: i64) {
self.temp_memory_size = v;
}
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;
}
pub fn set_persistent_memory_size(&mut self, v: i64) {
self.persistent_memory_size = v;
}
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();
}
pub fn set_persistent_tensor_alloc_ids(&mut self, v: ::std::vec::Vec<i64>) {
self.persistent_tensor_alloc_ids = v;
}
pub fn mut_persistent_tensor_alloc_ids(&mut self) -> &mut ::std::vec::Vec<i64> {
&mut self.persistent_tensor_alloc_ids
}
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())
}
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;
}
pub fn set_device_temp_memory_size(&mut self, v: i64) {
self.device_temp_memory_size = v;
}
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;
}
pub fn set_device_persistent_memory_size(&mut self, v: i64) {
self.device_persistent_memory_size = v;
}
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();
}
pub fn set_device_persistent_tensor_alloc_ids(&mut self, v: ::std::vec::Vec<i64>) {
self.device_persistent_tensor_alloc_ids = v;
}
pub fn mut_device_persistent_tensor_alloc_ids(&mut self) -> &mut ::std::vec::Vec<i64> {
&mut self.device_persistent_tensor_alloc_ids
}
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(())
}
#[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 {
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>,
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()
}
pub fn get_node_name(&self) -> &str {
&self.node_name
}
pub fn clear_node_name(&mut self) {
self.node_name.clear();
}
pub fn set_node_name(&mut self, v: ::std::string::String) {
self.node_name = v;
}
pub fn mut_node_name(&mut self) -> &mut ::std::string::String {
&mut self.node_name
}
pub fn take_node_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.node_name, ::std::string::String::new())
}
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;
}
pub fn set_all_start_micros(&mut self, v: i64) {
self.all_start_micros = v;
}
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;
}
pub fn set_op_start_rel_micros(&mut self, v: i64) {
self.op_start_rel_micros = v;
}
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;
}
pub fn set_op_end_rel_micros(&mut self, v: i64) {
self.op_end_rel_micros = v;
}
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;
}
pub fn set_all_end_rel_micros(&mut self, v: i64) {
self.all_end_rel_micros = v;
}
pub fn get_memory(&self) -> &[AllocatorMemoryUsed] {
&self.memory
}
pub fn clear_memory(&mut self) {
self.memory.clear();
}
pub fn set_memory(&mut self, v: ::protobuf::RepeatedField<AllocatorMemoryUsed>) {
self.memory = v;
}
pub fn mut_memory(&mut self) -> &mut ::protobuf::RepeatedField<AllocatorMemoryUsed> {
&mut self.memory
}
pub fn take_memory(&mut self) -> ::protobuf::RepeatedField<AllocatorMemoryUsed> {
::std::mem::replace(&mut self.memory, ::protobuf::RepeatedField::new())
}
pub fn get_output(&self) -> &[NodeOutput] {
&self.output
}
pub fn clear_output(&mut self) {
self.output.clear();
}
pub fn set_output(&mut self, v: ::protobuf::RepeatedField<NodeOutput>) {
self.output = v;
}
pub fn mut_output(&mut self) -> &mut ::protobuf::RepeatedField<NodeOutput> {
&mut self.output
}
pub fn take_output(&mut self) -> ::protobuf::RepeatedField<NodeOutput> {
::std::mem::replace(&mut self.output, ::protobuf::RepeatedField::new())
}
pub fn get_timeline_label(&self) -> &str {
&self.timeline_label
}
pub fn clear_timeline_label(&mut self) {
self.timeline_label.clear();
}
pub fn set_timeline_label(&mut self, v: ::std::string::String) {
self.timeline_label = v;
}
pub fn mut_timeline_label(&mut self) -> &mut ::std::string::String {
&mut self.timeline_label
}
pub fn take_timeline_label(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.timeline_label, ::std::string::String::new())
}
pub fn get_scheduled_micros(&self) -> i64 {
self.scheduled_micros
}
pub fn clear_scheduled_micros(&mut self) {
self.scheduled_micros = 0;
}
pub fn set_scheduled_micros(&mut self, v: i64) {
self.scheduled_micros = v;
}
pub fn get_thread_id(&self) -> u32 {
self.thread_id
}
pub fn clear_thread_id(&mut self) {
self.thread_id = 0;
}
pub fn set_thread_id(&mut self, v: u32) {
self.thread_id = v;
}
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()
}
pub fn set_memory_stats(&mut self, v: MemoryStats) {
self.memory_stats = ::protobuf::SingularPtrField::some(v);
}
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()
}
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(())
}
#[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 {
pub device: ::std::string::String,
pub node_stats: ::protobuf::RepeatedField<NodeExecStats>,
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()
}
pub fn get_device(&self) -> &str {
&self.device
}
pub fn clear_device(&mut self) {
self.device.clear();
}
pub fn set_device(&mut self, v: ::std::string::String) {
self.device = v;
}
pub fn mut_device(&mut self) -> &mut ::std::string::String {
&mut self.device
}
pub fn take_device(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.device, ::std::string::String::new())
}
pub fn get_node_stats(&self) -> &[NodeExecStats] {
&self.node_stats
}
pub fn clear_node_stats(&mut self) {
self.node_stats.clear();
}
pub fn set_node_stats(&mut self, v: ::protobuf::RepeatedField<NodeExecStats>) {
self.node_stats = v;
}
pub fn mut_node_stats(&mut self) -> &mut ::protobuf::RepeatedField<NodeExecStats> {
&mut self.node_stats
}
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(())
}
#[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 {
pub dev_stats: ::protobuf::RepeatedField<DeviceStepStats>,
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()
}
pub fn get_dev_stats(&self) -> &[DeviceStepStats] {
&self.dev_stats
}
pub fn clear_dev_stats(&mut self) {
self.dev_stats.clear();
}
pub fn set_dev_stats(&mut self, v: ::protobuf::RepeatedField<DeviceStepStats>) {
self.dev_stats = v;
}
pub fn mut_dev_stats(&mut self) -> &mut ::protobuf::RepeatedField<DeviceStepStats> {
&mut self.dev_stats
}
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(())
}
#[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 {
pub step_stats: ::protobuf::SingularPtrField<StepStats>,
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()
}
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()
}
pub fn set_step_stats(&mut self, v: StepStats) {
self.step_stats = ::protobuf::SingularPtrField::some(v);
}
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()
}
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(())
}
#[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()
})
}