1#![allow(unknown_lints)]
6#![allow(clippy::all)]
7
8#![cfg_attr(rustfmt, rustfmt_skip)]
9
10#![allow(box_pointers)]
11#![allow(dead_code)]
12#![allow(missing_docs)]
13#![allow(non_camel_case_types)]
14#![allow(non_snake_case)]
15#![allow(non_upper_case_globals)]
16#![allow(trivial_casts)]
17#![allow(unsafe_code)]
18#![allow(unused_imports)]
19#![allow(unused_results)]
20use protobuf::Message as Message_imported_for_functions;
23use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
24
25#[derive(PartialEq,Clone,Default)]
30pub struct AutoParallelOptions {
31 pub enable: bool,
33 pub num_replicas: i32,
34 pub unknown_fields: ::protobuf::UnknownFields,
36 pub cached_size: ::protobuf::CachedSize,
37}
38
39impl<'a> ::std::default::Default for &'a AutoParallelOptions {
40 fn default() -> &'a AutoParallelOptions {
41 <AutoParallelOptions as ::protobuf::Message>::default_instance()
42 }
43}
44
45impl AutoParallelOptions {
46 pub fn new() -> AutoParallelOptions {
47 ::std::default::Default::default()
48 }
49
50 pub fn get_enable(&self) -> bool {
54 self.enable
55 }
56 pub fn clear_enable(&mut self) {
57 self.enable = false;
58 }
59
60 pub fn set_enable(&mut self, v: bool) {
62 self.enable = v;
63 }
64
65 pub fn get_num_replicas(&self) -> i32 {
69 self.num_replicas
70 }
71 pub fn clear_num_replicas(&mut self) {
72 self.num_replicas = 0;
73 }
74
75 pub fn set_num_replicas(&mut self, v: i32) {
77 self.num_replicas = v;
78 }
79}
80
81impl ::protobuf::Message for AutoParallelOptions {
82 fn is_initialized(&self) -> bool {
83 true
84 }
85
86 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
87 while !is.eof()? {
88 let (field_number, wire_type) = is.read_tag_unpack()?;
89 match field_number {
90 1 => {
91 if wire_type != ::protobuf::wire_format::WireTypeVarint {
92 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
93 }
94 let tmp = is.read_bool()?;
95 self.enable = tmp;
96 },
97 2 => {
98 if wire_type != ::protobuf::wire_format::WireTypeVarint {
99 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
100 }
101 let tmp = is.read_int32()?;
102 self.num_replicas = tmp;
103 },
104 _ => {
105 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
106 },
107 };
108 }
109 ::std::result::Result::Ok(())
110 }
111
112 #[allow(unused_variables)]
114 fn compute_size(&self) -> u32 {
115 let mut my_size = 0;
116 if self.enable != false {
117 my_size += 2;
118 }
119 if self.num_replicas != 0 {
120 my_size += ::protobuf::rt::value_size(2, self.num_replicas, ::protobuf::wire_format::WireTypeVarint);
121 }
122 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
123 self.cached_size.set(my_size);
124 my_size
125 }
126
127 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
128 if self.enable != false {
129 os.write_bool(1, self.enable)?;
130 }
131 if self.num_replicas != 0 {
132 os.write_int32(2, self.num_replicas)?;
133 }
134 os.write_unknown_fields(self.get_unknown_fields())?;
135 ::std::result::Result::Ok(())
136 }
137
138 fn get_cached_size(&self) -> u32 {
139 self.cached_size.get()
140 }
141
142 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
143 &self.unknown_fields
144 }
145
146 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
147 &mut self.unknown_fields
148 }
149
150 fn as_any(&self) -> &dyn (::std::any::Any) {
151 self as &dyn (::std::any::Any)
152 }
153 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
154 self as &mut dyn (::std::any::Any)
155 }
156 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
157 self
158 }
159
160 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
161 Self::descriptor_static()
162 }
163
164 fn new() -> AutoParallelOptions {
165 AutoParallelOptions::new()
166 }
167
168 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
169 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
170 unsafe {
171 descriptor.get(|| {
172 let mut fields = ::std::vec::Vec::new();
173 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
174 "enable",
175 |m: &AutoParallelOptions| { &m.enable },
176 |m: &mut AutoParallelOptions| { &mut m.enable },
177 ));
178 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
179 "num_replicas",
180 |m: &AutoParallelOptions| { &m.num_replicas },
181 |m: &mut AutoParallelOptions| { &mut m.num_replicas },
182 ));
183 ::protobuf::reflect::MessageDescriptor::new_pb_name::<AutoParallelOptions>(
184 "AutoParallelOptions",
185 fields,
186 file_descriptor_proto()
187 )
188 })
189 }
190 }
191
192 fn default_instance() -> &'static AutoParallelOptions {
193 static mut instance: ::protobuf::lazy::Lazy<AutoParallelOptions> = ::protobuf::lazy::Lazy::INIT;
194 unsafe {
195 instance.get(AutoParallelOptions::new)
196 }
197 }
198}
199
200impl ::protobuf::Clear for AutoParallelOptions {
201 fn clear(&mut self) {
202 self.enable = false;
203 self.num_replicas = 0;
204 self.unknown_fields.clear();
205 }
206}
207
208impl ::std::fmt::Debug for AutoParallelOptions {
209 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
210 ::protobuf::text_format::fmt(self, f)
211 }
212}
213
214impl ::protobuf::reflect::ProtobufValue for AutoParallelOptions {
215 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
216 ::protobuf::reflect::ReflectValueRef::Message(self)
217 }
218}
219
220#[derive(PartialEq,Clone,Default)]
221pub struct ScopedAllocatorOptions {
222 pub enable_op: ::protobuf::RepeatedField<::std::string::String>,
224 pub unknown_fields: ::protobuf::UnknownFields,
226 pub cached_size: ::protobuf::CachedSize,
227}
228
229impl<'a> ::std::default::Default for &'a ScopedAllocatorOptions {
230 fn default() -> &'a ScopedAllocatorOptions {
231 <ScopedAllocatorOptions as ::protobuf::Message>::default_instance()
232 }
233}
234
235impl ScopedAllocatorOptions {
236 pub fn new() -> ScopedAllocatorOptions {
237 ::std::default::Default::default()
238 }
239
240 pub fn get_enable_op(&self) -> &[::std::string::String] {
244 &self.enable_op
245 }
246 pub fn clear_enable_op(&mut self) {
247 self.enable_op.clear();
248 }
249
250 pub fn set_enable_op(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
252 self.enable_op = v;
253 }
254
255 pub fn mut_enable_op(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
257 &mut self.enable_op
258 }
259
260 pub fn take_enable_op(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
262 ::std::mem::replace(&mut self.enable_op, ::protobuf::RepeatedField::new())
263 }
264}
265
266impl ::protobuf::Message for ScopedAllocatorOptions {
267 fn is_initialized(&self) -> bool {
268 true
269 }
270
271 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
272 while !is.eof()? {
273 let (field_number, wire_type) = is.read_tag_unpack()?;
274 match field_number {
275 1 => {
276 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.enable_op)?;
277 },
278 _ => {
279 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
280 },
281 };
282 }
283 ::std::result::Result::Ok(())
284 }
285
286 #[allow(unused_variables)]
288 fn compute_size(&self) -> u32 {
289 let mut my_size = 0;
290 for value in &self.enable_op {
291 my_size += ::protobuf::rt::string_size(1, &value);
292 };
293 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
294 self.cached_size.set(my_size);
295 my_size
296 }
297
298 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
299 for v in &self.enable_op {
300 os.write_string(1, &v)?;
301 };
302 os.write_unknown_fields(self.get_unknown_fields())?;
303 ::std::result::Result::Ok(())
304 }
305
306 fn get_cached_size(&self) -> u32 {
307 self.cached_size.get()
308 }
309
310 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
311 &self.unknown_fields
312 }
313
314 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
315 &mut self.unknown_fields
316 }
317
318 fn as_any(&self) -> &dyn (::std::any::Any) {
319 self as &dyn (::std::any::Any)
320 }
321 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
322 self as &mut dyn (::std::any::Any)
323 }
324 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
325 self
326 }
327
328 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
329 Self::descriptor_static()
330 }
331
332 fn new() -> ScopedAllocatorOptions {
333 ScopedAllocatorOptions::new()
334 }
335
336 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
337 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
338 unsafe {
339 descriptor.get(|| {
340 let mut fields = ::std::vec::Vec::new();
341 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
342 "enable_op",
343 |m: &ScopedAllocatorOptions| { &m.enable_op },
344 |m: &mut ScopedAllocatorOptions| { &mut m.enable_op },
345 ));
346 ::protobuf::reflect::MessageDescriptor::new_pb_name::<ScopedAllocatorOptions>(
347 "ScopedAllocatorOptions",
348 fields,
349 file_descriptor_proto()
350 )
351 })
352 }
353 }
354
355 fn default_instance() -> &'static ScopedAllocatorOptions {
356 static mut instance: ::protobuf::lazy::Lazy<ScopedAllocatorOptions> = ::protobuf::lazy::Lazy::INIT;
357 unsafe {
358 instance.get(ScopedAllocatorOptions::new)
359 }
360 }
361}
362
363impl ::protobuf::Clear for ScopedAllocatorOptions {
364 fn clear(&mut self) {
365 self.enable_op.clear();
366 self.unknown_fields.clear();
367 }
368}
369
370impl ::std::fmt::Debug for ScopedAllocatorOptions {
371 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
372 ::protobuf::text_format::fmt(self, f)
373 }
374}
375
376impl ::protobuf::reflect::ProtobufValue for ScopedAllocatorOptions {
377 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
378 ::protobuf::reflect::ReflectValueRef::Message(self)
379 }
380}
381
382#[derive(PartialEq,Clone,Default)]
383pub struct RewriterConfig {
384 pub layout_optimizer: RewriterConfig_Toggle,
386 pub constant_folding: RewriterConfig_Toggle,
387 pub shape_optimization: RewriterConfig_Toggle,
388 pub remapping: RewriterConfig_Toggle,
389 pub common_subgraph_elimination: RewriterConfig_Toggle,
390 pub arithmetic_optimization: RewriterConfig_Toggle,
391 pub dependency_optimization: RewriterConfig_Toggle,
392 pub loop_optimization: RewriterConfig_Toggle,
393 pub function_optimization: RewriterConfig_Toggle,
394 pub debug_stripper: RewriterConfig_Toggle,
395 pub disable_model_pruning: bool,
396 pub scoped_allocator_optimization: RewriterConfig_Toggle,
397 pub pin_to_host_optimization: RewriterConfig_Toggle,
398 pub implementation_selector: RewriterConfig_Toggle,
399 pub auto_mixed_precision: RewriterConfig_Toggle,
400 pub auto_mixed_precision_mkl: RewriterConfig_Toggle,
401 pub disable_meta_optimizer: bool,
402 pub meta_optimizer_iterations: RewriterConfig_NumIterationsType,
403 pub min_graph_nodes: i32,
404 pub memory_optimization: RewriterConfig_MemOptType,
405 pub memory_optimizer_target_node_name_scope: ::std::string::String,
406 pub meta_optimizer_timeout_ms: i64,
407 pub auto_parallel: ::protobuf::SingularPtrField<AutoParallelOptions>,
408 pub fail_on_optimizer_errors: bool,
409 pub scoped_allocator_opts: ::protobuf::SingularPtrField<ScopedAllocatorOptions>,
410 pub optimizers: ::protobuf::RepeatedField<::std::string::String>,
411 pub custom_optimizers: ::protobuf::RepeatedField<RewriterConfig_CustomGraphOptimizer>,
412 pub inter_optimizer_verifier_config: ::protobuf::SingularPtrField<super::verifier_config::VerifierConfig>,
413 pub post_optimization_verifier_config: ::protobuf::SingularPtrField<super::verifier_config::VerifierConfig>,
414 pub unknown_fields: ::protobuf::UnknownFields,
416 pub cached_size: ::protobuf::CachedSize,
417}
418
419impl<'a> ::std::default::Default for &'a RewriterConfig {
420 fn default() -> &'a RewriterConfig {
421 <RewriterConfig as ::protobuf::Message>::default_instance()
422 }
423}
424
425impl RewriterConfig {
426 pub fn new() -> RewriterConfig {
427 ::std::default::Default::default()
428 }
429
430 pub fn get_layout_optimizer(&self) -> RewriterConfig_Toggle {
434 self.layout_optimizer
435 }
436 pub fn clear_layout_optimizer(&mut self) {
437 self.layout_optimizer = RewriterConfig_Toggle::DEFAULT;
438 }
439
440 pub fn set_layout_optimizer(&mut self, v: RewriterConfig_Toggle) {
442 self.layout_optimizer = v;
443 }
444
445 pub fn get_constant_folding(&self) -> RewriterConfig_Toggle {
449 self.constant_folding
450 }
451 pub fn clear_constant_folding(&mut self) {
452 self.constant_folding = RewriterConfig_Toggle::DEFAULT;
453 }
454
455 pub fn set_constant_folding(&mut self, v: RewriterConfig_Toggle) {
457 self.constant_folding = v;
458 }
459
460 pub fn get_shape_optimization(&self) -> RewriterConfig_Toggle {
464 self.shape_optimization
465 }
466 pub fn clear_shape_optimization(&mut self) {
467 self.shape_optimization = RewriterConfig_Toggle::DEFAULT;
468 }
469
470 pub fn set_shape_optimization(&mut self, v: RewriterConfig_Toggle) {
472 self.shape_optimization = v;
473 }
474
475 pub fn get_remapping(&self) -> RewriterConfig_Toggle {
479 self.remapping
480 }
481 pub fn clear_remapping(&mut self) {
482 self.remapping = RewriterConfig_Toggle::DEFAULT;
483 }
484
485 pub fn set_remapping(&mut self, v: RewriterConfig_Toggle) {
487 self.remapping = v;
488 }
489
490 pub fn get_common_subgraph_elimination(&self) -> RewriterConfig_Toggle {
494 self.common_subgraph_elimination
495 }
496 pub fn clear_common_subgraph_elimination(&mut self) {
497 self.common_subgraph_elimination = RewriterConfig_Toggle::DEFAULT;
498 }
499
500 pub fn set_common_subgraph_elimination(&mut self, v: RewriterConfig_Toggle) {
502 self.common_subgraph_elimination = v;
503 }
504
505 pub fn get_arithmetic_optimization(&self) -> RewriterConfig_Toggle {
509 self.arithmetic_optimization
510 }
511 pub fn clear_arithmetic_optimization(&mut self) {
512 self.arithmetic_optimization = RewriterConfig_Toggle::DEFAULT;
513 }
514
515 pub fn set_arithmetic_optimization(&mut self, v: RewriterConfig_Toggle) {
517 self.arithmetic_optimization = v;
518 }
519
520 pub fn get_dependency_optimization(&self) -> RewriterConfig_Toggle {
524 self.dependency_optimization
525 }
526 pub fn clear_dependency_optimization(&mut self) {
527 self.dependency_optimization = RewriterConfig_Toggle::DEFAULT;
528 }
529
530 pub fn set_dependency_optimization(&mut self, v: RewriterConfig_Toggle) {
532 self.dependency_optimization = v;
533 }
534
535 pub fn get_loop_optimization(&self) -> RewriterConfig_Toggle {
539 self.loop_optimization
540 }
541 pub fn clear_loop_optimization(&mut self) {
542 self.loop_optimization = RewriterConfig_Toggle::DEFAULT;
543 }
544
545 pub fn set_loop_optimization(&mut self, v: RewriterConfig_Toggle) {
547 self.loop_optimization = v;
548 }
549
550 pub fn get_function_optimization(&self) -> RewriterConfig_Toggle {
554 self.function_optimization
555 }
556 pub fn clear_function_optimization(&mut self) {
557 self.function_optimization = RewriterConfig_Toggle::DEFAULT;
558 }
559
560 pub fn set_function_optimization(&mut self, v: RewriterConfig_Toggle) {
562 self.function_optimization = v;
563 }
564
565 pub fn get_debug_stripper(&self) -> RewriterConfig_Toggle {
569 self.debug_stripper
570 }
571 pub fn clear_debug_stripper(&mut self) {
572 self.debug_stripper = RewriterConfig_Toggle::DEFAULT;
573 }
574
575 pub fn set_debug_stripper(&mut self, v: RewriterConfig_Toggle) {
577 self.debug_stripper = v;
578 }
579
580 pub fn get_disable_model_pruning(&self) -> bool {
584 self.disable_model_pruning
585 }
586 pub fn clear_disable_model_pruning(&mut self) {
587 self.disable_model_pruning = false;
588 }
589
590 pub fn set_disable_model_pruning(&mut self, v: bool) {
592 self.disable_model_pruning = v;
593 }
594
595 pub fn get_scoped_allocator_optimization(&self) -> RewriterConfig_Toggle {
599 self.scoped_allocator_optimization
600 }
601 pub fn clear_scoped_allocator_optimization(&mut self) {
602 self.scoped_allocator_optimization = RewriterConfig_Toggle::DEFAULT;
603 }
604
605 pub fn set_scoped_allocator_optimization(&mut self, v: RewriterConfig_Toggle) {
607 self.scoped_allocator_optimization = v;
608 }
609
610 pub fn get_pin_to_host_optimization(&self) -> RewriterConfig_Toggle {
614 self.pin_to_host_optimization
615 }
616 pub fn clear_pin_to_host_optimization(&mut self) {
617 self.pin_to_host_optimization = RewriterConfig_Toggle::DEFAULT;
618 }
619
620 pub fn set_pin_to_host_optimization(&mut self, v: RewriterConfig_Toggle) {
622 self.pin_to_host_optimization = v;
623 }
624
625 pub fn get_implementation_selector(&self) -> RewriterConfig_Toggle {
629 self.implementation_selector
630 }
631 pub fn clear_implementation_selector(&mut self) {
632 self.implementation_selector = RewriterConfig_Toggle::DEFAULT;
633 }
634
635 pub fn set_implementation_selector(&mut self, v: RewriterConfig_Toggle) {
637 self.implementation_selector = v;
638 }
639
640 pub fn get_auto_mixed_precision(&self) -> RewriterConfig_Toggle {
644 self.auto_mixed_precision
645 }
646 pub fn clear_auto_mixed_precision(&mut self) {
647 self.auto_mixed_precision = RewriterConfig_Toggle::DEFAULT;
648 }
649
650 pub fn set_auto_mixed_precision(&mut self, v: RewriterConfig_Toggle) {
652 self.auto_mixed_precision = v;
653 }
654
655 pub fn get_auto_mixed_precision_mkl(&self) -> RewriterConfig_Toggle {
659 self.auto_mixed_precision_mkl
660 }
661 pub fn clear_auto_mixed_precision_mkl(&mut self) {
662 self.auto_mixed_precision_mkl = RewriterConfig_Toggle::DEFAULT;
663 }
664
665 pub fn set_auto_mixed_precision_mkl(&mut self, v: RewriterConfig_Toggle) {
667 self.auto_mixed_precision_mkl = v;
668 }
669
670 pub fn get_disable_meta_optimizer(&self) -> bool {
674 self.disable_meta_optimizer
675 }
676 pub fn clear_disable_meta_optimizer(&mut self) {
677 self.disable_meta_optimizer = false;
678 }
679
680 pub fn set_disable_meta_optimizer(&mut self, v: bool) {
682 self.disable_meta_optimizer = v;
683 }
684
685 pub fn get_meta_optimizer_iterations(&self) -> RewriterConfig_NumIterationsType {
689 self.meta_optimizer_iterations
690 }
691 pub fn clear_meta_optimizer_iterations(&mut self) {
692 self.meta_optimizer_iterations = RewriterConfig_NumIterationsType::DEFAULT_NUM_ITERS;
693 }
694
695 pub fn set_meta_optimizer_iterations(&mut self, v: RewriterConfig_NumIterationsType) {
697 self.meta_optimizer_iterations = v;
698 }
699
700 pub fn get_min_graph_nodes(&self) -> i32 {
704 self.min_graph_nodes
705 }
706 pub fn clear_min_graph_nodes(&mut self) {
707 self.min_graph_nodes = 0;
708 }
709
710 pub fn set_min_graph_nodes(&mut self, v: i32) {
712 self.min_graph_nodes = v;
713 }
714
715 pub fn get_memory_optimization(&self) -> RewriterConfig_MemOptType {
719 self.memory_optimization
720 }
721 pub fn clear_memory_optimization(&mut self) {
722 self.memory_optimization = RewriterConfig_MemOptType::DEFAULT_MEM_OPT;
723 }
724
725 pub fn set_memory_optimization(&mut self, v: RewriterConfig_MemOptType) {
727 self.memory_optimization = v;
728 }
729
730 pub fn get_memory_optimizer_target_node_name_scope(&self) -> &str {
734 &self.memory_optimizer_target_node_name_scope
735 }
736 pub fn clear_memory_optimizer_target_node_name_scope(&mut self) {
737 self.memory_optimizer_target_node_name_scope.clear();
738 }
739
740 pub fn set_memory_optimizer_target_node_name_scope(&mut self, v: ::std::string::String) {
742 self.memory_optimizer_target_node_name_scope = v;
743 }
744
745 pub fn mut_memory_optimizer_target_node_name_scope(&mut self) -> &mut ::std::string::String {
748 &mut self.memory_optimizer_target_node_name_scope
749 }
750
751 pub fn take_memory_optimizer_target_node_name_scope(&mut self) -> ::std::string::String {
753 ::std::mem::replace(&mut self.memory_optimizer_target_node_name_scope, ::std::string::String::new())
754 }
755
756 pub fn get_meta_optimizer_timeout_ms(&self) -> i64 {
760 self.meta_optimizer_timeout_ms
761 }
762 pub fn clear_meta_optimizer_timeout_ms(&mut self) {
763 self.meta_optimizer_timeout_ms = 0;
764 }
765
766 pub fn set_meta_optimizer_timeout_ms(&mut self, v: i64) {
768 self.meta_optimizer_timeout_ms = v;
769 }
770
771 pub fn get_auto_parallel(&self) -> &AutoParallelOptions {
775 self.auto_parallel.as_ref().unwrap_or_else(|| AutoParallelOptions::default_instance())
776 }
777 pub fn clear_auto_parallel(&mut self) {
778 self.auto_parallel.clear();
779 }
780
781 pub fn has_auto_parallel(&self) -> bool {
782 self.auto_parallel.is_some()
783 }
784
785 pub fn set_auto_parallel(&mut self, v: AutoParallelOptions) {
787 self.auto_parallel = ::protobuf::SingularPtrField::some(v);
788 }
789
790 pub fn mut_auto_parallel(&mut self) -> &mut AutoParallelOptions {
793 if self.auto_parallel.is_none() {
794 self.auto_parallel.set_default();
795 }
796 self.auto_parallel.as_mut().unwrap()
797 }
798
799 pub fn take_auto_parallel(&mut self) -> AutoParallelOptions {
801 self.auto_parallel.take().unwrap_or_else(|| AutoParallelOptions::new())
802 }
803
804 pub fn get_fail_on_optimizer_errors(&self) -> bool {
808 self.fail_on_optimizer_errors
809 }
810 pub fn clear_fail_on_optimizer_errors(&mut self) {
811 self.fail_on_optimizer_errors = false;
812 }
813
814 pub fn set_fail_on_optimizer_errors(&mut self, v: bool) {
816 self.fail_on_optimizer_errors = v;
817 }
818
819 pub fn get_scoped_allocator_opts(&self) -> &ScopedAllocatorOptions {
823 self.scoped_allocator_opts.as_ref().unwrap_or_else(|| ScopedAllocatorOptions::default_instance())
824 }
825 pub fn clear_scoped_allocator_opts(&mut self) {
826 self.scoped_allocator_opts.clear();
827 }
828
829 pub fn has_scoped_allocator_opts(&self) -> bool {
830 self.scoped_allocator_opts.is_some()
831 }
832
833 pub fn set_scoped_allocator_opts(&mut self, v: ScopedAllocatorOptions) {
835 self.scoped_allocator_opts = ::protobuf::SingularPtrField::some(v);
836 }
837
838 pub fn mut_scoped_allocator_opts(&mut self) -> &mut ScopedAllocatorOptions {
841 if self.scoped_allocator_opts.is_none() {
842 self.scoped_allocator_opts.set_default();
843 }
844 self.scoped_allocator_opts.as_mut().unwrap()
845 }
846
847 pub fn take_scoped_allocator_opts(&mut self) -> ScopedAllocatorOptions {
849 self.scoped_allocator_opts.take().unwrap_or_else(|| ScopedAllocatorOptions::new())
850 }
851
852 pub fn get_optimizers(&self) -> &[::std::string::String] {
856 &self.optimizers
857 }
858 pub fn clear_optimizers(&mut self) {
859 self.optimizers.clear();
860 }
861
862 pub fn set_optimizers(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
864 self.optimizers = v;
865 }
866
867 pub fn mut_optimizers(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
869 &mut self.optimizers
870 }
871
872 pub fn take_optimizers(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
874 ::std::mem::replace(&mut self.optimizers, ::protobuf::RepeatedField::new())
875 }
876
877 pub fn get_custom_optimizers(&self) -> &[RewriterConfig_CustomGraphOptimizer] {
881 &self.custom_optimizers
882 }
883 pub fn clear_custom_optimizers(&mut self) {
884 self.custom_optimizers.clear();
885 }
886
887 pub fn set_custom_optimizers(&mut self, v: ::protobuf::RepeatedField<RewriterConfig_CustomGraphOptimizer>) {
889 self.custom_optimizers = v;
890 }
891
892 pub fn mut_custom_optimizers(&mut self) -> &mut ::protobuf::RepeatedField<RewriterConfig_CustomGraphOptimizer> {
894 &mut self.custom_optimizers
895 }
896
897 pub fn take_custom_optimizers(&mut self) -> ::protobuf::RepeatedField<RewriterConfig_CustomGraphOptimizer> {
899 ::std::mem::replace(&mut self.custom_optimizers, ::protobuf::RepeatedField::new())
900 }
901
902 pub fn get_inter_optimizer_verifier_config(&self) -> &super::verifier_config::VerifierConfig {
906 self.inter_optimizer_verifier_config.as_ref().unwrap_or_else(|| super::verifier_config::VerifierConfig::default_instance())
907 }
908 pub fn clear_inter_optimizer_verifier_config(&mut self) {
909 self.inter_optimizer_verifier_config.clear();
910 }
911
912 pub fn has_inter_optimizer_verifier_config(&self) -> bool {
913 self.inter_optimizer_verifier_config.is_some()
914 }
915
916 pub fn set_inter_optimizer_verifier_config(&mut self, v: super::verifier_config::VerifierConfig) {
918 self.inter_optimizer_verifier_config = ::protobuf::SingularPtrField::some(v);
919 }
920
921 pub fn mut_inter_optimizer_verifier_config(&mut self) -> &mut super::verifier_config::VerifierConfig {
924 if self.inter_optimizer_verifier_config.is_none() {
925 self.inter_optimizer_verifier_config.set_default();
926 }
927 self.inter_optimizer_verifier_config.as_mut().unwrap()
928 }
929
930 pub fn take_inter_optimizer_verifier_config(&mut self) -> super::verifier_config::VerifierConfig {
932 self.inter_optimizer_verifier_config.take().unwrap_or_else(|| super::verifier_config::VerifierConfig::new())
933 }
934
935 pub fn get_post_optimization_verifier_config(&self) -> &super::verifier_config::VerifierConfig {
939 self.post_optimization_verifier_config.as_ref().unwrap_or_else(|| super::verifier_config::VerifierConfig::default_instance())
940 }
941 pub fn clear_post_optimization_verifier_config(&mut self) {
942 self.post_optimization_verifier_config.clear();
943 }
944
945 pub fn has_post_optimization_verifier_config(&self) -> bool {
946 self.post_optimization_verifier_config.is_some()
947 }
948
949 pub fn set_post_optimization_verifier_config(&mut self, v: super::verifier_config::VerifierConfig) {
951 self.post_optimization_verifier_config = ::protobuf::SingularPtrField::some(v);
952 }
953
954 pub fn mut_post_optimization_verifier_config(&mut self) -> &mut super::verifier_config::VerifierConfig {
957 if self.post_optimization_verifier_config.is_none() {
958 self.post_optimization_verifier_config.set_default();
959 }
960 self.post_optimization_verifier_config.as_mut().unwrap()
961 }
962
963 pub fn take_post_optimization_verifier_config(&mut self) -> super::verifier_config::VerifierConfig {
965 self.post_optimization_verifier_config.take().unwrap_or_else(|| super::verifier_config::VerifierConfig::new())
966 }
967}
968
969impl ::protobuf::Message for RewriterConfig {
970 fn is_initialized(&self) -> bool {
971 for v in &self.auto_parallel {
972 if !v.is_initialized() {
973 return false;
974 }
975 };
976 for v in &self.scoped_allocator_opts {
977 if !v.is_initialized() {
978 return false;
979 }
980 };
981 for v in &self.custom_optimizers {
982 if !v.is_initialized() {
983 return false;
984 }
985 };
986 for v in &self.inter_optimizer_verifier_config {
987 if !v.is_initialized() {
988 return false;
989 }
990 };
991 for v in &self.post_optimization_verifier_config {
992 if !v.is_initialized() {
993 return false;
994 }
995 };
996 true
997 }
998
999 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1000 while !is.eof()? {
1001 let (field_number, wire_type) = is.read_tag_unpack()?;
1002 match field_number {
1003 1 => {
1004 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.layout_optimizer, 1, &mut self.unknown_fields)?
1005 },
1006 3 => {
1007 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.constant_folding, 3, &mut self.unknown_fields)?
1008 },
1009 13 => {
1010 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.shape_optimization, 13, &mut self.unknown_fields)?
1011 },
1012 14 => {
1013 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.remapping, 14, &mut self.unknown_fields)?
1014 },
1015 24 => {
1016 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.common_subgraph_elimination, 24, &mut self.unknown_fields)?
1017 },
1018 7 => {
1019 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.arithmetic_optimization, 7, &mut self.unknown_fields)?
1020 },
1021 8 => {
1022 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.dependency_optimization, 8, &mut self.unknown_fields)?
1023 },
1024 9 => {
1025 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.loop_optimization, 9, &mut self.unknown_fields)?
1026 },
1027 10 => {
1028 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.function_optimization, 10, &mut self.unknown_fields)?
1029 },
1030 11 => {
1031 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.debug_stripper, 11, &mut self.unknown_fields)?
1032 },
1033 2 => {
1034 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1035 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1036 }
1037 let tmp = is.read_bool()?;
1038 self.disable_model_pruning = tmp;
1039 },
1040 15 => {
1041 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.scoped_allocator_optimization, 15, &mut self.unknown_fields)?
1042 },
1043 18 => {
1044 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.pin_to_host_optimization, 18, &mut self.unknown_fields)?
1045 },
1046 22 => {
1047 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.implementation_selector, 22, &mut self.unknown_fields)?
1048 },
1049 23 => {
1050 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.auto_mixed_precision, 23, &mut self.unknown_fields)?
1051 },
1052 25 => {
1053 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.auto_mixed_precision_mkl, 25, &mut self.unknown_fields)?
1054 },
1055 19 => {
1056 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1057 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1058 }
1059 let tmp = is.read_bool()?;
1060 self.disable_meta_optimizer = tmp;
1061 },
1062 12 => {
1063 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.meta_optimizer_iterations, 12, &mut self.unknown_fields)?
1064 },
1065 17 => {
1066 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1067 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1068 }
1069 let tmp = is.read_int32()?;
1070 self.min_graph_nodes = tmp;
1071 },
1072 4 => {
1073 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.memory_optimization, 4, &mut self.unknown_fields)?
1074 },
1075 6 => {
1076 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.memory_optimizer_target_node_name_scope)?;
1077 },
1078 20 => {
1079 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1080 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1081 }
1082 let tmp = is.read_int64()?;
1083 self.meta_optimizer_timeout_ms = tmp;
1084 },
1085 5 => {
1086 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.auto_parallel)?;
1087 },
1088 21 => {
1089 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1090 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1091 }
1092 let tmp = is.read_bool()?;
1093 self.fail_on_optimizer_errors = tmp;
1094 },
1095 16 => {
1096 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.scoped_allocator_opts)?;
1097 },
1098 100 => {
1099 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.optimizers)?;
1100 },
1101 200 => {
1102 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.custom_optimizers)?;
1103 },
1104 300 => {
1105 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.inter_optimizer_verifier_config)?;
1106 },
1107 301 => {
1108 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.post_optimization_verifier_config)?;
1109 },
1110 _ => {
1111 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1112 },
1113 };
1114 }
1115 ::std::result::Result::Ok(())
1116 }
1117
1118 #[allow(unused_variables)]
1120 fn compute_size(&self) -> u32 {
1121 let mut my_size = 0;
1122 if self.layout_optimizer != RewriterConfig_Toggle::DEFAULT {
1123 my_size += ::protobuf::rt::enum_size(1, self.layout_optimizer);
1124 }
1125 if self.constant_folding != RewriterConfig_Toggle::DEFAULT {
1126 my_size += ::protobuf::rt::enum_size(3, self.constant_folding);
1127 }
1128 if self.shape_optimization != RewriterConfig_Toggle::DEFAULT {
1129 my_size += ::protobuf::rt::enum_size(13, self.shape_optimization);
1130 }
1131 if self.remapping != RewriterConfig_Toggle::DEFAULT {
1132 my_size += ::protobuf::rt::enum_size(14, self.remapping);
1133 }
1134 if self.common_subgraph_elimination != RewriterConfig_Toggle::DEFAULT {
1135 my_size += ::protobuf::rt::enum_size(24, self.common_subgraph_elimination);
1136 }
1137 if self.arithmetic_optimization != RewriterConfig_Toggle::DEFAULT {
1138 my_size += ::protobuf::rt::enum_size(7, self.arithmetic_optimization);
1139 }
1140 if self.dependency_optimization != RewriterConfig_Toggle::DEFAULT {
1141 my_size += ::protobuf::rt::enum_size(8, self.dependency_optimization);
1142 }
1143 if self.loop_optimization != RewriterConfig_Toggle::DEFAULT {
1144 my_size += ::protobuf::rt::enum_size(9, self.loop_optimization);
1145 }
1146 if self.function_optimization != RewriterConfig_Toggle::DEFAULT {
1147 my_size += ::protobuf::rt::enum_size(10, self.function_optimization);
1148 }
1149 if self.debug_stripper != RewriterConfig_Toggle::DEFAULT {
1150 my_size += ::protobuf::rt::enum_size(11, self.debug_stripper);
1151 }
1152 if self.disable_model_pruning != false {
1153 my_size += 2;
1154 }
1155 if self.scoped_allocator_optimization != RewriterConfig_Toggle::DEFAULT {
1156 my_size += ::protobuf::rt::enum_size(15, self.scoped_allocator_optimization);
1157 }
1158 if self.pin_to_host_optimization != RewriterConfig_Toggle::DEFAULT {
1159 my_size += ::protobuf::rt::enum_size(18, self.pin_to_host_optimization);
1160 }
1161 if self.implementation_selector != RewriterConfig_Toggle::DEFAULT {
1162 my_size += ::protobuf::rt::enum_size(22, self.implementation_selector);
1163 }
1164 if self.auto_mixed_precision != RewriterConfig_Toggle::DEFAULT {
1165 my_size += ::protobuf::rt::enum_size(23, self.auto_mixed_precision);
1166 }
1167 if self.auto_mixed_precision_mkl != RewriterConfig_Toggle::DEFAULT {
1168 my_size += ::protobuf::rt::enum_size(25, self.auto_mixed_precision_mkl);
1169 }
1170 if self.disable_meta_optimizer != false {
1171 my_size += 3;
1172 }
1173 if self.meta_optimizer_iterations != RewriterConfig_NumIterationsType::DEFAULT_NUM_ITERS {
1174 my_size += ::protobuf::rt::enum_size(12, self.meta_optimizer_iterations);
1175 }
1176 if self.min_graph_nodes != 0 {
1177 my_size += ::protobuf::rt::value_size(17, self.min_graph_nodes, ::protobuf::wire_format::WireTypeVarint);
1178 }
1179 if self.memory_optimization != RewriterConfig_MemOptType::DEFAULT_MEM_OPT {
1180 my_size += ::protobuf::rt::enum_size(4, self.memory_optimization);
1181 }
1182 if !self.memory_optimizer_target_node_name_scope.is_empty() {
1183 my_size += ::protobuf::rt::string_size(6, &self.memory_optimizer_target_node_name_scope);
1184 }
1185 if self.meta_optimizer_timeout_ms != 0 {
1186 my_size += ::protobuf::rt::value_size(20, self.meta_optimizer_timeout_ms, ::protobuf::wire_format::WireTypeVarint);
1187 }
1188 if let Some(ref v) = self.auto_parallel.as_ref() {
1189 let len = v.compute_size();
1190 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1191 }
1192 if self.fail_on_optimizer_errors != false {
1193 my_size += 3;
1194 }
1195 if let Some(ref v) = self.scoped_allocator_opts.as_ref() {
1196 let len = v.compute_size();
1197 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1198 }
1199 for value in &self.optimizers {
1200 my_size += ::protobuf::rt::string_size(100, &value);
1201 };
1202 for value in &self.custom_optimizers {
1203 let len = value.compute_size();
1204 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1205 };
1206 if let Some(ref v) = self.inter_optimizer_verifier_config.as_ref() {
1207 let len = v.compute_size();
1208 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1209 }
1210 if let Some(ref v) = self.post_optimization_verifier_config.as_ref() {
1211 let len = v.compute_size();
1212 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1213 }
1214 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1215 self.cached_size.set(my_size);
1216 my_size
1217 }
1218
1219 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1220 if self.layout_optimizer != RewriterConfig_Toggle::DEFAULT {
1221 os.write_enum(1, self.layout_optimizer.value())?;
1222 }
1223 if self.constant_folding != RewriterConfig_Toggle::DEFAULT {
1224 os.write_enum(3, self.constant_folding.value())?;
1225 }
1226 if self.shape_optimization != RewriterConfig_Toggle::DEFAULT {
1227 os.write_enum(13, self.shape_optimization.value())?;
1228 }
1229 if self.remapping != RewriterConfig_Toggle::DEFAULT {
1230 os.write_enum(14, self.remapping.value())?;
1231 }
1232 if self.common_subgraph_elimination != RewriterConfig_Toggle::DEFAULT {
1233 os.write_enum(24, self.common_subgraph_elimination.value())?;
1234 }
1235 if self.arithmetic_optimization != RewriterConfig_Toggle::DEFAULT {
1236 os.write_enum(7, self.arithmetic_optimization.value())?;
1237 }
1238 if self.dependency_optimization != RewriterConfig_Toggle::DEFAULT {
1239 os.write_enum(8, self.dependency_optimization.value())?;
1240 }
1241 if self.loop_optimization != RewriterConfig_Toggle::DEFAULT {
1242 os.write_enum(9, self.loop_optimization.value())?;
1243 }
1244 if self.function_optimization != RewriterConfig_Toggle::DEFAULT {
1245 os.write_enum(10, self.function_optimization.value())?;
1246 }
1247 if self.debug_stripper != RewriterConfig_Toggle::DEFAULT {
1248 os.write_enum(11, self.debug_stripper.value())?;
1249 }
1250 if self.disable_model_pruning != false {
1251 os.write_bool(2, self.disable_model_pruning)?;
1252 }
1253 if self.scoped_allocator_optimization != RewriterConfig_Toggle::DEFAULT {
1254 os.write_enum(15, self.scoped_allocator_optimization.value())?;
1255 }
1256 if self.pin_to_host_optimization != RewriterConfig_Toggle::DEFAULT {
1257 os.write_enum(18, self.pin_to_host_optimization.value())?;
1258 }
1259 if self.implementation_selector != RewriterConfig_Toggle::DEFAULT {
1260 os.write_enum(22, self.implementation_selector.value())?;
1261 }
1262 if self.auto_mixed_precision != RewriterConfig_Toggle::DEFAULT {
1263 os.write_enum(23, self.auto_mixed_precision.value())?;
1264 }
1265 if self.auto_mixed_precision_mkl != RewriterConfig_Toggle::DEFAULT {
1266 os.write_enum(25, self.auto_mixed_precision_mkl.value())?;
1267 }
1268 if self.disable_meta_optimizer != false {
1269 os.write_bool(19, self.disable_meta_optimizer)?;
1270 }
1271 if self.meta_optimizer_iterations != RewriterConfig_NumIterationsType::DEFAULT_NUM_ITERS {
1272 os.write_enum(12, self.meta_optimizer_iterations.value())?;
1273 }
1274 if self.min_graph_nodes != 0 {
1275 os.write_int32(17, self.min_graph_nodes)?;
1276 }
1277 if self.memory_optimization != RewriterConfig_MemOptType::DEFAULT_MEM_OPT {
1278 os.write_enum(4, self.memory_optimization.value())?;
1279 }
1280 if !self.memory_optimizer_target_node_name_scope.is_empty() {
1281 os.write_string(6, &self.memory_optimizer_target_node_name_scope)?;
1282 }
1283 if self.meta_optimizer_timeout_ms != 0 {
1284 os.write_int64(20, self.meta_optimizer_timeout_ms)?;
1285 }
1286 if let Some(ref v) = self.auto_parallel.as_ref() {
1287 os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1288 os.write_raw_varint32(v.get_cached_size())?;
1289 v.write_to_with_cached_sizes(os)?;
1290 }
1291 if self.fail_on_optimizer_errors != false {
1292 os.write_bool(21, self.fail_on_optimizer_errors)?;
1293 }
1294 if let Some(ref v) = self.scoped_allocator_opts.as_ref() {
1295 os.write_tag(16, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1296 os.write_raw_varint32(v.get_cached_size())?;
1297 v.write_to_with_cached_sizes(os)?;
1298 }
1299 for v in &self.optimizers {
1300 os.write_string(100, &v)?;
1301 };
1302 for v in &self.custom_optimizers {
1303 os.write_tag(200, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1304 os.write_raw_varint32(v.get_cached_size())?;
1305 v.write_to_with_cached_sizes(os)?;
1306 };
1307 if let Some(ref v) = self.inter_optimizer_verifier_config.as_ref() {
1308 os.write_tag(300, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1309 os.write_raw_varint32(v.get_cached_size())?;
1310 v.write_to_with_cached_sizes(os)?;
1311 }
1312 if let Some(ref v) = self.post_optimization_verifier_config.as_ref() {
1313 os.write_tag(301, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1314 os.write_raw_varint32(v.get_cached_size())?;
1315 v.write_to_with_cached_sizes(os)?;
1316 }
1317 os.write_unknown_fields(self.get_unknown_fields())?;
1318 ::std::result::Result::Ok(())
1319 }
1320
1321 fn get_cached_size(&self) -> u32 {
1322 self.cached_size.get()
1323 }
1324
1325 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1326 &self.unknown_fields
1327 }
1328
1329 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1330 &mut self.unknown_fields
1331 }
1332
1333 fn as_any(&self) -> &dyn (::std::any::Any) {
1334 self as &dyn (::std::any::Any)
1335 }
1336 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1337 self as &mut dyn (::std::any::Any)
1338 }
1339 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1340 self
1341 }
1342
1343 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1344 Self::descriptor_static()
1345 }
1346
1347 fn new() -> RewriterConfig {
1348 RewriterConfig::new()
1349 }
1350
1351 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1352 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
1353 unsafe {
1354 descriptor.get(|| {
1355 let mut fields = ::std::vec::Vec::new();
1356 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1357 "layout_optimizer",
1358 |m: &RewriterConfig| { &m.layout_optimizer },
1359 |m: &mut RewriterConfig| { &mut m.layout_optimizer },
1360 ));
1361 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1362 "constant_folding",
1363 |m: &RewriterConfig| { &m.constant_folding },
1364 |m: &mut RewriterConfig| { &mut m.constant_folding },
1365 ));
1366 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1367 "shape_optimization",
1368 |m: &RewriterConfig| { &m.shape_optimization },
1369 |m: &mut RewriterConfig| { &mut m.shape_optimization },
1370 ));
1371 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1372 "remapping",
1373 |m: &RewriterConfig| { &m.remapping },
1374 |m: &mut RewriterConfig| { &mut m.remapping },
1375 ));
1376 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1377 "common_subgraph_elimination",
1378 |m: &RewriterConfig| { &m.common_subgraph_elimination },
1379 |m: &mut RewriterConfig| { &mut m.common_subgraph_elimination },
1380 ));
1381 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1382 "arithmetic_optimization",
1383 |m: &RewriterConfig| { &m.arithmetic_optimization },
1384 |m: &mut RewriterConfig| { &mut m.arithmetic_optimization },
1385 ));
1386 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1387 "dependency_optimization",
1388 |m: &RewriterConfig| { &m.dependency_optimization },
1389 |m: &mut RewriterConfig| { &mut m.dependency_optimization },
1390 ));
1391 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1392 "loop_optimization",
1393 |m: &RewriterConfig| { &m.loop_optimization },
1394 |m: &mut RewriterConfig| { &mut m.loop_optimization },
1395 ));
1396 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1397 "function_optimization",
1398 |m: &RewriterConfig| { &m.function_optimization },
1399 |m: &mut RewriterConfig| { &mut m.function_optimization },
1400 ));
1401 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1402 "debug_stripper",
1403 |m: &RewriterConfig| { &m.debug_stripper },
1404 |m: &mut RewriterConfig| { &mut m.debug_stripper },
1405 ));
1406 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1407 "disable_model_pruning",
1408 |m: &RewriterConfig| { &m.disable_model_pruning },
1409 |m: &mut RewriterConfig| { &mut m.disable_model_pruning },
1410 ));
1411 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1412 "scoped_allocator_optimization",
1413 |m: &RewriterConfig| { &m.scoped_allocator_optimization },
1414 |m: &mut RewriterConfig| { &mut m.scoped_allocator_optimization },
1415 ));
1416 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1417 "pin_to_host_optimization",
1418 |m: &RewriterConfig| { &m.pin_to_host_optimization },
1419 |m: &mut RewriterConfig| { &mut m.pin_to_host_optimization },
1420 ));
1421 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1422 "implementation_selector",
1423 |m: &RewriterConfig| { &m.implementation_selector },
1424 |m: &mut RewriterConfig| { &mut m.implementation_selector },
1425 ));
1426 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1427 "auto_mixed_precision",
1428 |m: &RewriterConfig| { &m.auto_mixed_precision },
1429 |m: &mut RewriterConfig| { &mut m.auto_mixed_precision },
1430 ));
1431 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_Toggle>>(
1432 "auto_mixed_precision_mkl",
1433 |m: &RewriterConfig| { &m.auto_mixed_precision_mkl },
1434 |m: &mut RewriterConfig| { &mut m.auto_mixed_precision_mkl },
1435 ));
1436 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1437 "disable_meta_optimizer",
1438 |m: &RewriterConfig| { &m.disable_meta_optimizer },
1439 |m: &mut RewriterConfig| { &mut m.disable_meta_optimizer },
1440 ));
1441 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_NumIterationsType>>(
1442 "meta_optimizer_iterations",
1443 |m: &RewriterConfig| { &m.meta_optimizer_iterations },
1444 |m: &mut RewriterConfig| { &mut m.meta_optimizer_iterations },
1445 ));
1446 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
1447 "min_graph_nodes",
1448 |m: &RewriterConfig| { &m.min_graph_nodes },
1449 |m: &mut RewriterConfig| { &mut m.min_graph_nodes },
1450 ));
1451 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RewriterConfig_MemOptType>>(
1452 "memory_optimization",
1453 |m: &RewriterConfig| { &m.memory_optimization },
1454 |m: &mut RewriterConfig| { &mut m.memory_optimization },
1455 ));
1456 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1457 "memory_optimizer_target_node_name_scope",
1458 |m: &RewriterConfig| { &m.memory_optimizer_target_node_name_scope },
1459 |m: &mut RewriterConfig| { &mut m.memory_optimizer_target_node_name_scope },
1460 ));
1461 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
1462 "meta_optimizer_timeout_ms",
1463 |m: &RewriterConfig| { &m.meta_optimizer_timeout_ms },
1464 |m: &mut RewriterConfig| { &mut m.meta_optimizer_timeout_ms },
1465 ));
1466 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AutoParallelOptions>>(
1467 "auto_parallel",
1468 |m: &RewriterConfig| { &m.auto_parallel },
1469 |m: &mut RewriterConfig| { &mut m.auto_parallel },
1470 ));
1471 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1472 "fail_on_optimizer_errors",
1473 |m: &RewriterConfig| { &m.fail_on_optimizer_errors },
1474 |m: &mut RewriterConfig| { &mut m.fail_on_optimizer_errors },
1475 ));
1476 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ScopedAllocatorOptions>>(
1477 "scoped_allocator_opts",
1478 |m: &RewriterConfig| { &m.scoped_allocator_opts },
1479 |m: &mut RewriterConfig| { &mut m.scoped_allocator_opts },
1480 ));
1481 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1482 "optimizers",
1483 |m: &RewriterConfig| { &m.optimizers },
1484 |m: &mut RewriterConfig| { &mut m.optimizers },
1485 ));
1486 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RewriterConfig_CustomGraphOptimizer>>(
1487 "custom_optimizers",
1488 |m: &RewriterConfig| { &m.custom_optimizers },
1489 |m: &mut RewriterConfig| { &mut m.custom_optimizers },
1490 ));
1491 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::verifier_config::VerifierConfig>>(
1492 "inter_optimizer_verifier_config",
1493 |m: &RewriterConfig| { &m.inter_optimizer_verifier_config },
1494 |m: &mut RewriterConfig| { &mut m.inter_optimizer_verifier_config },
1495 ));
1496 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::verifier_config::VerifierConfig>>(
1497 "post_optimization_verifier_config",
1498 |m: &RewriterConfig| { &m.post_optimization_verifier_config },
1499 |m: &mut RewriterConfig| { &mut m.post_optimization_verifier_config },
1500 ));
1501 ::protobuf::reflect::MessageDescriptor::new_pb_name::<RewriterConfig>(
1502 "RewriterConfig",
1503 fields,
1504 file_descriptor_proto()
1505 )
1506 })
1507 }
1508 }
1509
1510 fn default_instance() -> &'static RewriterConfig {
1511 static mut instance: ::protobuf::lazy::Lazy<RewriterConfig> = ::protobuf::lazy::Lazy::INIT;
1512 unsafe {
1513 instance.get(RewriterConfig::new)
1514 }
1515 }
1516}
1517
1518impl ::protobuf::Clear for RewriterConfig {
1519 fn clear(&mut self) {
1520 self.layout_optimizer = RewriterConfig_Toggle::DEFAULT;
1521 self.constant_folding = RewriterConfig_Toggle::DEFAULT;
1522 self.shape_optimization = RewriterConfig_Toggle::DEFAULT;
1523 self.remapping = RewriterConfig_Toggle::DEFAULT;
1524 self.common_subgraph_elimination = RewriterConfig_Toggle::DEFAULT;
1525 self.arithmetic_optimization = RewriterConfig_Toggle::DEFAULT;
1526 self.dependency_optimization = RewriterConfig_Toggle::DEFAULT;
1527 self.loop_optimization = RewriterConfig_Toggle::DEFAULT;
1528 self.function_optimization = RewriterConfig_Toggle::DEFAULT;
1529 self.debug_stripper = RewriterConfig_Toggle::DEFAULT;
1530 self.disable_model_pruning = false;
1531 self.scoped_allocator_optimization = RewriterConfig_Toggle::DEFAULT;
1532 self.pin_to_host_optimization = RewriterConfig_Toggle::DEFAULT;
1533 self.implementation_selector = RewriterConfig_Toggle::DEFAULT;
1534 self.auto_mixed_precision = RewriterConfig_Toggle::DEFAULT;
1535 self.auto_mixed_precision_mkl = RewriterConfig_Toggle::DEFAULT;
1536 self.disable_meta_optimizer = false;
1537 self.meta_optimizer_iterations = RewriterConfig_NumIterationsType::DEFAULT_NUM_ITERS;
1538 self.min_graph_nodes = 0;
1539 self.memory_optimization = RewriterConfig_MemOptType::DEFAULT_MEM_OPT;
1540 self.memory_optimizer_target_node_name_scope.clear();
1541 self.meta_optimizer_timeout_ms = 0;
1542 self.auto_parallel.clear();
1543 self.fail_on_optimizer_errors = false;
1544 self.scoped_allocator_opts.clear();
1545 self.optimizers.clear();
1546 self.custom_optimizers.clear();
1547 self.inter_optimizer_verifier_config.clear();
1548 self.post_optimization_verifier_config.clear();
1549 self.unknown_fields.clear();
1550 }
1551}
1552
1553impl ::std::fmt::Debug for RewriterConfig {
1554 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1555 ::protobuf::text_format::fmt(self, f)
1556 }
1557}
1558
1559impl ::protobuf::reflect::ProtobufValue for RewriterConfig {
1560 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1561 ::protobuf::reflect::ReflectValueRef::Message(self)
1562 }
1563}
1564
1565#[derive(PartialEq,Clone,Default)]
1566pub struct RewriterConfig_CustomGraphOptimizer {
1567 pub name: ::std::string::String,
1569 pub parameter_map: ::std::collections::HashMap<::std::string::String, super::attr_value::AttrValue>,
1570 pub unknown_fields: ::protobuf::UnknownFields,
1572 pub cached_size: ::protobuf::CachedSize,
1573}
1574
1575impl<'a> ::std::default::Default for &'a RewriterConfig_CustomGraphOptimizer {
1576 fn default() -> &'a RewriterConfig_CustomGraphOptimizer {
1577 <RewriterConfig_CustomGraphOptimizer as ::protobuf::Message>::default_instance()
1578 }
1579}
1580
1581impl RewriterConfig_CustomGraphOptimizer {
1582 pub fn new() -> RewriterConfig_CustomGraphOptimizer {
1583 ::std::default::Default::default()
1584 }
1585
1586 pub fn get_name(&self) -> &str {
1590 &self.name
1591 }
1592 pub fn clear_name(&mut self) {
1593 self.name.clear();
1594 }
1595
1596 pub fn set_name(&mut self, v: ::std::string::String) {
1598 self.name = v;
1599 }
1600
1601 pub fn mut_name(&mut self) -> &mut ::std::string::String {
1604 &mut self.name
1605 }
1606
1607 pub fn take_name(&mut self) -> ::std::string::String {
1609 ::std::mem::replace(&mut self.name, ::std::string::String::new())
1610 }
1611
1612 pub fn get_parameter_map(&self) -> &::std::collections::HashMap<::std::string::String, super::attr_value::AttrValue> {
1616 &self.parameter_map
1617 }
1618 pub fn clear_parameter_map(&mut self) {
1619 self.parameter_map.clear();
1620 }
1621
1622 pub fn set_parameter_map(&mut self, v: ::std::collections::HashMap<::std::string::String, super::attr_value::AttrValue>) {
1624 self.parameter_map = v;
1625 }
1626
1627 pub fn mut_parameter_map(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, super::attr_value::AttrValue> {
1629 &mut self.parameter_map
1630 }
1631
1632 pub fn take_parameter_map(&mut self) -> ::std::collections::HashMap<::std::string::String, super::attr_value::AttrValue> {
1634 ::std::mem::replace(&mut self.parameter_map, ::std::collections::HashMap::new())
1635 }
1636}
1637
1638impl ::protobuf::Message for RewriterConfig_CustomGraphOptimizer {
1639 fn is_initialized(&self) -> bool {
1640 true
1641 }
1642
1643 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1644 while !is.eof()? {
1645 let (field_number, wire_type) = is.read_tag_unpack()?;
1646 match field_number {
1647 1 => {
1648 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
1649 },
1650 2 => {
1651 ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::attr_value::AttrValue>>(wire_type, is, &mut self.parameter_map)?;
1652 },
1653 _ => {
1654 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1655 },
1656 };
1657 }
1658 ::std::result::Result::Ok(())
1659 }
1660
1661 #[allow(unused_variables)]
1663 fn compute_size(&self) -> u32 {
1664 let mut my_size = 0;
1665 if !self.name.is_empty() {
1666 my_size += ::protobuf::rt::string_size(1, &self.name);
1667 }
1668 my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::attr_value::AttrValue>>(2, &self.parameter_map);
1669 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1670 self.cached_size.set(my_size);
1671 my_size
1672 }
1673
1674 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1675 if !self.name.is_empty() {
1676 os.write_string(1, &self.name)?;
1677 }
1678 ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::attr_value::AttrValue>>(2, &self.parameter_map, os)?;
1679 os.write_unknown_fields(self.get_unknown_fields())?;
1680 ::std::result::Result::Ok(())
1681 }
1682
1683 fn get_cached_size(&self) -> u32 {
1684 self.cached_size.get()
1685 }
1686
1687 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1688 &self.unknown_fields
1689 }
1690
1691 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1692 &mut self.unknown_fields
1693 }
1694
1695 fn as_any(&self) -> &dyn (::std::any::Any) {
1696 self as &dyn (::std::any::Any)
1697 }
1698 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1699 self as &mut dyn (::std::any::Any)
1700 }
1701 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1702 self
1703 }
1704
1705 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1706 Self::descriptor_static()
1707 }
1708
1709 fn new() -> RewriterConfig_CustomGraphOptimizer {
1710 RewriterConfig_CustomGraphOptimizer::new()
1711 }
1712
1713 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1714 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
1715 unsafe {
1716 descriptor.get(|| {
1717 let mut fields = ::std::vec::Vec::new();
1718 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1719 "name",
1720 |m: &RewriterConfig_CustomGraphOptimizer| { &m.name },
1721 |m: &mut RewriterConfig_CustomGraphOptimizer| { &mut m.name },
1722 ));
1723 fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::attr_value::AttrValue>>(
1724 "parameter_map",
1725 |m: &RewriterConfig_CustomGraphOptimizer| { &m.parameter_map },
1726 |m: &mut RewriterConfig_CustomGraphOptimizer| { &mut m.parameter_map },
1727 ));
1728 ::protobuf::reflect::MessageDescriptor::new_pb_name::<RewriterConfig_CustomGraphOptimizer>(
1729 "RewriterConfig.CustomGraphOptimizer",
1730 fields,
1731 file_descriptor_proto()
1732 )
1733 })
1734 }
1735 }
1736
1737 fn default_instance() -> &'static RewriterConfig_CustomGraphOptimizer {
1738 static mut instance: ::protobuf::lazy::Lazy<RewriterConfig_CustomGraphOptimizer> = ::protobuf::lazy::Lazy::INIT;
1739 unsafe {
1740 instance.get(RewriterConfig_CustomGraphOptimizer::new)
1741 }
1742 }
1743}
1744
1745impl ::protobuf::Clear for RewriterConfig_CustomGraphOptimizer {
1746 fn clear(&mut self) {
1747 self.name.clear();
1748 self.parameter_map.clear();
1749 self.unknown_fields.clear();
1750 }
1751}
1752
1753impl ::std::fmt::Debug for RewriterConfig_CustomGraphOptimizer {
1754 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1755 ::protobuf::text_format::fmt(self, f)
1756 }
1757}
1758
1759impl ::protobuf::reflect::ProtobufValue for RewriterConfig_CustomGraphOptimizer {
1760 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1761 ::protobuf::reflect::ReflectValueRef::Message(self)
1762 }
1763}
1764
1765#[derive(Clone,PartialEq,Eq,Debug,Hash)]
1766pub enum RewriterConfig_Toggle {
1767 DEFAULT = 0,
1768 ON = 1,
1769 OFF = 2,
1770 AGGRESSIVE = 3,
1771}
1772
1773impl ::protobuf::ProtobufEnum for RewriterConfig_Toggle {
1774 fn value(&self) -> i32 {
1775 *self as i32
1776 }
1777
1778 fn from_i32(value: i32) -> ::std::option::Option<RewriterConfig_Toggle> {
1779 match value {
1780 0 => ::std::option::Option::Some(RewriterConfig_Toggle::DEFAULT),
1781 1 => ::std::option::Option::Some(RewriterConfig_Toggle::ON),
1782 2 => ::std::option::Option::Some(RewriterConfig_Toggle::OFF),
1783 3 => ::std::option::Option::Some(RewriterConfig_Toggle::AGGRESSIVE),
1784 _ => ::std::option::Option::None
1785 }
1786 }
1787
1788 fn values() -> &'static [Self] {
1789 static values: &'static [RewriterConfig_Toggle] = &[
1790 RewriterConfig_Toggle::DEFAULT,
1791 RewriterConfig_Toggle::ON,
1792 RewriterConfig_Toggle::OFF,
1793 RewriterConfig_Toggle::AGGRESSIVE,
1794 ];
1795 values
1796 }
1797
1798 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
1799 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT;
1800 unsafe {
1801 descriptor.get(|| {
1802 ::protobuf::reflect::EnumDescriptor::new_pb_name::<RewriterConfig_Toggle>("RewriterConfig.Toggle", file_descriptor_proto())
1803 })
1804 }
1805 }
1806}
1807
1808impl ::std::marker::Copy for RewriterConfig_Toggle {
1809}
1810
1811impl ::std::default::Default for RewriterConfig_Toggle {
1812 fn default() -> Self {
1813 RewriterConfig_Toggle::DEFAULT
1814 }
1815}
1816
1817impl ::protobuf::reflect::ProtobufValue for RewriterConfig_Toggle {
1818 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1819 ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor())
1820 }
1821}
1822
1823#[derive(Clone,PartialEq,Eq,Debug,Hash)]
1824pub enum RewriterConfig_NumIterationsType {
1825 DEFAULT_NUM_ITERS = 0,
1826 ONE = 1,
1827 TWO = 2,
1828}
1829
1830impl ::protobuf::ProtobufEnum for RewriterConfig_NumIterationsType {
1831 fn value(&self) -> i32 {
1832 *self as i32
1833 }
1834
1835 fn from_i32(value: i32) -> ::std::option::Option<RewriterConfig_NumIterationsType> {
1836 match value {
1837 0 => ::std::option::Option::Some(RewriterConfig_NumIterationsType::DEFAULT_NUM_ITERS),
1838 1 => ::std::option::Option::Some(RewriterConfig_NumIterationsType::ONE),
1839 2 => ::std::option::Option::Some(RewriterConfig_NumIterationsType::TWO),
1840 _ => ::std::option::Option::None
1841 }
1842 }
1843
1844 fn values() -> &'static [Self] {
1845 static values: &'static [RewriterConfig_NumIterationsType] = &[
1846 RewriterConfig_NumIterationsType::DEFAULT_NUM_ITERS,
1847 RewriterConfig_NumIterationsType::ONE,
1848 RewriterConfig_NumIterationsType::TWO,
1849 ];
1850 values
1851 }
1852
1853 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
1854 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT;
1855 unsafe {
1856 descriptor.get(|| {
1857 ::protobuf::reflect::EnumDescriptor::new_pb_name::<RewriterConfig_NumIterationsType>("RewriterConfig.NumIterationsType", file_descriptor_proto())
1858 })
1859 }
1860 }
1861}
1862
1863impl ::std::marker::Copy for RewriterConfig_NumIterationsType {
1864}
1865
1866impl ::std::default::Default for RewriterConfig_NumIterationsType {
1867 fn default() -> Self {
1868 RewriterConfig_NumIterationsType::DEFAULT_NUM_ITERS
1869 }
1870}
1871
1872impl ::protobuf::reflect::ProtobufValue for RewriterConfig_NumIterationsType {
1873 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1874 ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor())
1875 }
1876}
1877
1878#[derive(Clone,PartialEq,Eq,Debug,Hash)]
1879pub enum RewriterConfig_MemOptType {
1880 DEFAULT_MEM_OPT = 0,
1881 NO_MEM_OPT = 1,
1882 MANUAL = 2,
1883 SWAPPING_HEURISTICS = 4,
1884 RECOMPUTATION_HEURISTICS = 5,
1885 SCHEDULING_HEURISTICS = 6,
1886 HEURISTICS = 3,
1887}
1888
1889impl ::protobuf::ProtobufEnum for RewriterConfig_MemOptType {
1890 fn value(&self) -> i32 {
1891 *self as i32
1892 }
1893
1894 fn from_i32(value: i32) -> ::std::option::Option<RewriterConfig_MemOptType> {
1895 match value {
1896 0 => ::std::option::Option::Some(RewriterConfig_MemOptType::DEFAULT_MEM_OPT),
1897 1 => ::std::option::Option::Some(RewriterConfig_MemOptType::NO_MEM_OPT),
1898 2 => ::std::option::Option::Some(RewriterConfig_MemOptType::MANUAL),
1899 4 => ::std::option::Option::Some(RewriterConfig_MemOptType::SWAPPING_HEURISTICS),
1900 5 => ::std::option::Option::Some(RewriterConfig_MemOptType::RECOMPUTATION_HEURISTICS),
1901 6 => ::std::option::Option::Some(RewriterConfig_MemOptType::SCHEDULING_HEURISTICS),
1902 3 => ::std::option::Option::Some(RewriterConfig_MemOptType::HEURISTICS),
1903 _ => ::std::option::Option::None
1904 }
1905 }
1906
1907 fn values() -> &'static [Self] {
1908 static values: &'static [RewriterConfig_MemOptType] = &[
1909 RewriterConfig_MemOptType::DEFAULT_MEM_OPT,
1910 RewriterConfig_MemOptType::NO_MEM_OPT,
1911 RewriterConfig_MemOptType::MANUAL,
1912 RewriterConfig_MemOptType::SWAPPING_HEURISTICS,
1913 RewriterConfig_MemOptType::RECOMPUTATION_HEURISTICS,
1914 RewriterConfig_MemOptType::SCHEDULING_HEURISTICS,
1915 RewriterConfig_MemOptType::HEURISTICS,
1916 ];
1917 values
1918 }
1919
1920 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
1921 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT;
1922 unsafe {
1923 descriptor.get(|| {
1924 ::protobuf::reflect::EnumDescriptor::new_pb_name::<RewriterConfig_MemOptType>("RewriterConfig.MemOptType", file_descriptor_proto())
1925 })
1926 }
1927 }
1928}
1929
1930impl ::std::marker::Copy for RewriterConfig_MemOptType {
1931}
1932
1933impl ::std::default::Default for RewriterConfig_MemOptType {
1934 fn default() -> Self {
1935 RewriterConfig_MemOptType::DEFAULT_MEM_OPT
1936 }
1937}
1938
1939impl ::protobuf::reflect::ProtobufValue for RewriterConfig_MemOptType {
1940 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1941 ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor())
1942 }
1943}
1944
1945static file_descriptor_proto_data: &'static [u8] = b"\
1946 \n.tensorflow/core/protobuf/rewriter_config.proto\x12\ntensorflow\x1a*te\
1947 nsorflow/core/framework/attr_value.proto\x1a.tensorflow/core/protobuf/ve\
1948 rifier_config.proto\"P\n\x13AutoParallelOptions\x12\x16\n\x06enable\x18\
1949 \x01\x20\x01(\x08R\x06enable\x12!\n\x0cnum_replicas\x18\x02\x20\x01(\x05\
1950 R\x0bnumReplicas\"5\n\x16ScopedAllocatorOptions\x12\x1b\n\tenable_op\x18\
1951 \x01\x20\x03(\tR\x08enableOp\"\xa7\x16\n\x0eRewriterConfig\x12L\n\x10lay\
1952 out_optimizer\x18\x01\x20\x01(\x0e2!.tensorflow.RewriterConfig.ToggleR\
1953 \x0flayoutOptimizer\x12L\n\x10constant_folding\x18\x03\x20\x01(\x0e2!.te\
1954 nsorflow.RewriterConfig.ToggleR\x0fconstantFolding\x12P\n\x12shape_optim\
1955 ization\x18\r\x20\x01(\x0e2!.tensorflow.RewriterConfig.ToggleR\x11shapeO\
1956 ptimization\x12?\n\tremapping\x18\x0e\x20\x01(\x0e2!.tensorflow.Rewriter\
1957 Config.ToggleR\tremapping\x12a\n\x1bcommon_subgraph_elimination\x18\x18\
1958 \x20\x01(\x0e2!.tensorflow.RewriterConfig.ToggleR\x19commonSubgraphElimi\
1959 nation\x12Z\n\x17arithmetic_optimization\x18\x07\x20\x01(\x0e2!.tensorfl\
1960 ow.RewriterConfig.ToggleR\x16arithmeticOptimization\x12Z\n\x17dependency\
1961 _optimization\x18\x08\x20\x01(\x0e2!.tensorflow.RewriterConfig.ToggleR\
1962 \x16dependencyOptimization\x12N\n\x11loop_optimization\x18\t\x20\x01(\
1963 \x0e2!.tensorflow.RewriterConfig.ToggleR\x10loopOptimization\x12V\n\x15f\
1964 unction_optimization\x18\n\x20\x01(\x0e2!.tensorflow.RewriterConfig.Togg\
1965 leR\x14functionOptimization\x12H\n\x0edebug_stripper\x18\x0b\x20\x01(\
1966 \x0e2!.tensorflow.RewriterConfig.ToggleR\rdebugStripper\x122\n\x15disabl\
1967 e_model_pruning\x18\x02\x20\x01(\x08R\x13disableModelPruning\x12e\n\x1ds\
1968 coped_allocator_optimization\x18\x0f\x20\x01(\x0e2!.tensorflow.RewriterC\
1969 onfig.ToggleR\x1bscopedAllocatorOptimization\x12Z\n\x18pin_to_host_optim\
1970 ization\x18\x12\x20\x01(\x0e2!.tensorflow.RewriterConfig.ToggleR\x15pinT\
1971 oHostOptimization\x12Z\n\x17implementation_selector\x18\x16\x20\x01(\x0e\
1972 2!.tensorflow.RewriterConfig.ToggleR\x16implementationSelector\x12S\n\
1973 \x14auto_mixed_precision\x18\x17\x20\x01(\x0e2!.tensorflow.RewriterConfi\
1974 g.ToggleR\x12autoMixedPrecision\x12Z\n\x18auto_mixed_precision_mkl\x18\
1975 \x19\x20\x01(\x0e2!.tensorflow.RewriterConfig.ToggleR\x15autoMixedPrecis\
1976 ionMkl\x124\n\x16disable_meta_optimizer\x18\x13\x20\x01(\x08R\x14disable\
1977 MetaOptimizer\x12h\n\x19meta_optimizer_iterations\x18\x0c\x20\x01(\x0e2,\
1978 .tensorflow.RewriterConfig.NumIterationsTypeR\x17metaOptimizerIterations\
1979 \x12&\n\x0fmin_graph_nodes\x18\x11\x20\x01(\x05R\rminGraphNodes\x12V\n\
1980 \x13memory_optimization\x18\x04\x20\x01(\x0e2%.tensorflow.RewriterConfig\
1981 .MemOptTypeR\x12memoryOptimization\x12S\n'memory_optimizer_target_node_n\
1982 ame_scope\x18\x06\x20\x01(\tR\"memoryOptimizerTargetNodeNameScope\x129\n\
1983 \x19meta_optimizer_timeout_ms\x18\x14\x20\x01(\x03R\x16metaOptimizerTime\
1984 outMs\x12D\n\rauto_parallel\x18\x05\x20\x01(\x0b2\x1f.tensorflow.AutoPar\
1985 allelOptionsR\x0cautoParallel\x127\n\x18fail_on_optimizer_errors\x18\x15\
1986 \x20\x01(\x08R\x15failOnOptimizerErrors\x12V\n\x15scoped_allocator_opts\
1987 \x18\x10\x20\x01(\x0b2\".tensorflow.ScopedAllocatorOptionsR\x13scopedAll\
1988 ocatorOpts\x12\x1e\n\noptimizers\x18d\x20\x03(\tR\noptimizers\x12]\n\x11\
1989 custom_optimizers\x18\xc8\x01\x20\x03(\x0b2/.tensorflow.RewriterConfig.C\
1990 ustomGraphOptimizerR\x10customOptimizers\x12b\n\x1finter_optimizer_verif\
1991 ier_config\x18\xac\x02\x20\x01(\x0b2\x1a.tensorflow.VerifierConfigR\x1ci\
1992 nterOptimizerVerifierConfig\x12f\n!post_optimization_verifier_config\x18\
1993 \xad\x02\x20\x01(\x0b2\x1a.tensorflow.VerifierConfigR\x1epostOptimizatio\
1994 nVerifierConfig\x1a\xea\x01\n\x14CustomGraphOptimizer\x12\x12\n\x04name\
1995 \x18\x01\x20\x01(\tR\x04name\x12f\n\rparameter_map\x18\x02\x20\x03(\x0b2\
1996 A.tensorflow.RewriterConfig.CustomGraphOptimizer.ParameterMapEntryR\x0cp\
1997 arameterMap\x1aV\n\x11ParameterMapEntry\x12\x10\n\x03key\x18\x01\x20\x01\
1998 (\tR\x03key\x12+\n\x05value\x18\x02\x20\x01(\x0b2\x15.tensorflow.AttrVal\
1999 ueR\x05value:\x028\x01\"6\n\x06Toggle\x12\x0b\n\x07DEFAULT\x10\0\x12\x06\
2000 \n\x02ON\x10\x01\x12\x07\n\x03OFF\x10\x02\x12\x0e\n\nAGGRESSIVE\x10\x03\
2001 \"<\n\x11NumIterationsType\x12\x15\n\x11DEFAULT_NUM_ITERS\x10\0\x12\x07\
2002 \n\x03ONE\x10\x01\x12\x07\n\x03TWO\x10\x02\"\x9f\x01\n\nMemOptType\x12\
2003 \x13\n\x0fDEFAULT_MEM_OPT\x10\0\x12\x0e\n\nNO_MEM_OPT\x10\x01\x12\n\n\
2004 \x06MANUAL\x10\x02\x12\x17\n\x13SWAPPING_HEURISTICS\x10\x04\x12\x1c\n\
2005 \x18RECOMPUTATION_HEURISTICS\x10\x05\x12\x19\n\x15SCHEDULING_HEURISTICS\
2006 \x10\x06\x12\x0e\n\nHEURISTICS\x10\x03B\x7f\n\x18org.tensorflow.framewor\
2007 kB\x14RewriterConfigProtosP\x01ZHgithub.com/tensorflow/tensorflow/tensor\
2008 flow/go/core/core_protos_go_proto\xf8\x01\x01J\xb4C\n\x07\x12\x05\0\0\
2009 \xc0\x01\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\x03\x02\
2010 \0\x13\n\t\n\x02\x03\0\x12\x03\x04\04\n\t\n\x02\x03\x01\x12\x03\x05\08\n\
2011 \x08\n\x01\x08\x12\x03\x07\0\x1f\n\t\n\x02\x08\x1f\x12\x03\x07\0\x1f\n\
2012 \x08\n\x01\x08\x12\x03\x08\05\n\t\n\x02\x08\x08\x12\x03\x08\05\n\x08\n\
2013 \x01\x08\x12\x03\t\0\"\n\t\n\x02\x08\n\x12\x03\t\0\"\n\x08\n\x01\x08\x12\
2014 \x03\n\01\n\t\n\x02\x08\x01\x12\x03\n\01\n\x08\n\x01\x08\x12\x03\x0b\0_\
2015 \n\t\n\x02\x08\x0b\x12\x03\x0b\0_\n\n\n\x02\x04\0\x12\x04\r\0\x10\x01\n\
2016 \n\n\x03\x04\0\x01\x12\x03\r\x08\x1b\n\x0b\n\x04\x04\0\x02\0\x12\x03\x0e\
2017 \x02\x12\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x0e\x02\x06\n\x0c\n\x05\x04\
2018 \0\x02\0\x01\x12\x03\x0e\x07\r\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x0e\
2019 \x10\x11\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x0f\x02\x19\n\x0c\n\x05\x04\0\
2020 \x02\x01\x05\x12\x03\x0f\x02\x07\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\
2021 \x0f\x08\x14\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x0f\x17\x18\n\n\n\x02\
2022 \x04\x01\x12\x04\x12\0\x15\x01\n\n\n\x03\x04\x01\x01\x12\x03\x12\x08\x1e\
2023 \nC\n\x04\x04\x01\x02\0\x12\x03\x14\x02\x20\x1a6\x20If\x20present,\x20on\
2024 ly\x20perform\x20optimization\x20for\x20these\x20ops.\n\n\x0c\n\x05\x04\
2025 \x01\x02\0\x04\x12\x03\x14\x02\n\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\
2026 \x14\x0b\x11\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x14\x12\x1b\n\x0c\n\
2027 \x05\x04\x01\x02\0\x03\x12\x03\x14\x1e\x1f\ns\n\x02\x04\x02\x12\x05\x17\
2028 \0\xc0\x01\x01\"f\x20Graph\x20rewriting\x20is\x20experimental\x20and\x20\
2029 subject\x20to\x20change,\x20not\x20covered\x20by\x20any\n\x20API\x20stab\
2030 ility\x20guarantees.\n\n\n\n\x03\x04\x02\x01\x12\x03\x17\x08\x16\n\xc6\
2031 \x01\n\x04\x04\x02\x04\0\x12\x04\x1f\x02'\x032\xb7\x01\x20Configuration\
2032 \x20options\x20for\x20the\x20meta-optimizer.\x20Unless\x20otherwise\x20n\
2033 oted,\x20these\n\x20configuration\x20options\x20do\x20not\x20apply\x20to\
2034 \x20explicitly\x20triggered\x20optimization\n\x20passes\x20in\x20the\x20\
2035 optimizers\x20field.\n\n\x0c\n\x05\x04\x02\x04\0\x01\x12\x03\x1f\x07\r\n\
2036 \r\n\x06\x04\x02\x04\0\x02\0\x12\x03\x20\x04\x10\n\x0e\n\x07\x04\x02\x04\
2037 \0\x02\0\x01\x12\x03\x20\x04\x0b\n\x0e\n\x07\x04\x02\x04\0\x02\0\x02\x12\
2038 \x03\x20\x0e\x0f\n\r\n\x06\x04\x02\x04\0\x02\x01\x12\x03!\x04\x0b\n\x0e\
2039 \n\x07\x04\x02\x04\0\x02\x01\x01\x12\x03!\x04\x06\n\x0e\n\x07\x04\x02\
2040 \x04\0\x02\x01\x02\x12\x03!\t\n\n\r\n\x06\x04\x02\x04\0\x02\x02\x12\x03\
2041 \"\x04\x0c\n\x0e\n\x07\x04\x02\x04\0\x02\x02\x01\x12\x03\"\x04\x07\n\x0e\
2042 \n\x07\x04\x02\x04\0\x02\x02\x02\x12\x03\"\n\x0b\n\xaf\x01\n\x06\x04\x02\
2043 \x04\0\x02\x03\x12\x03&\x04\x13\x1a\x9f\x01\x20Enable\x20some\x20aggress\
2044 ive\x20optimizations\x20that\x20use\x20assumptions\x20that\x20TF\x20grap\
2045 hs\n\x20may\x20break.\x20For\x20example,\x20assume\x20the\x20shape\x20of\
2046 \x20a\x20placeholder\x20matches\x20its\n\x20actual\x20feed.\n\n\x0e\n\
2047 \x07\x04\x02\x04\0\x02\x03\x01\x12\x03&\x04\x0e\n\x0e\n\x07\x04\x02\x04\
2048 \0\x02\x03\x02\x12\x03&\x11\x12\nj\n\x04\x04\x02\x04\x01\x12\x04+\x02/\
2049 \x03\x1a\\\x20Enum\x20controlling\x20the\x20number\x20of\x20times\x20to\
2050 \x20run\x20optimizers.\x20The\x20default\x20is\x20to\n\x20run\x20them\
2051 \x20twice.\n\n\x0c\n\x05\x04\x02\x04\x01\x01\x12\x03+\x07\x18\n\r\n\x06\
2052 \x04\x02\x04\x01\x02\0\x12\x03,\x04\x1a\n\x0e\n\x07\x04\x02\x04\x01\x02\
2053 \0\x01\x12\x03,\x04\x15\n\x0e\n\x07\x04\x02\x04\x01\x02\0\x02\x12\x03,\
2054 \x18\x19\n\r\n\x06\x04\x02\x04\x01\x02\x01\x12\x03-\x04\x0c\n\x0e\n\x07\
2055 \x04\x02\x04\x01\x02\x01\x01\x12\x03-\x04\x07\n\x0e\n\x07\x04\x02\x04\
2056 \x01\x02\x01\x02\x12\x03-\n\x0b\n\r\n\x06\x04\x02\x04\x01\x02\x02\x12\
2057 \x03.\x04\x0c\n\x0e\n\x07\x04\x02\x04\x01\x02\x02\x01\x12\x03.\x04\x07\n\
2058 \x0e\n\x07\x04\x02\x04\x01\x02\x02\x02\x12\x03.\n\x0b\nu\n\x04\x04\x02\
2059 \x02\0\x12\x033\x02\x1e\x1ah\x20Optimize\x20tensor\x20layouts\x20(defaul\
2060 t\x20is\x20ON)\n\x20e.g.\x20This\x20will\x20try\x20to\x20use\x20NCHW\x20\
2061 layout\x20on\x20GPU\x20which\x20is\x20faster.\n\n\x0c\n\x05\x04\x02\x02\
2062 \0\x06\x12\x033\x02\x08\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x033\t\x19\n\
2063 \x0c\n\x05\x04\x02\x02\0\x03\x12\x033\x1c\x1d\n\x91\x01\n\x04\x04\x02\
2064 \x02\x01\x12\x037\x02\x1e\x1a\x83\x01\x20Fold\x20constants\x20(default\
2065 \x20is\x20ON)\n\x20Statically\x20infer\x20the\x20value\x20of\x20tensors\
2066 \x20when\x20possible,\x20and\x20materialize\x20the\n\x20result\x20using\
2067 \x20constants.\n\n\x0c\n\x05\x04\x02\x02\x01\x06\x12\x037\x02\x08\n\x0c\
2068 \n\x05\x04\x02\x02\x01\x01\x12\x037\t\x19\n\x0c\n\x05\x04\x02\x02\x01\
2069 \x03\x12\x037\x1c\x1d\nY\n\x04\x04\x02\x02\x02\x12\x03:\x02!\x1aL\x20Sha\
2070 pe\x20optimizations\x20(default\x20is\x20ON)\n\x20Simplify\x20computatio\
2071 ns\x20made\x20on\x20shapes.\n\n\x0c\n\x05\x04\x02\x02\x02\x06\x12\x03:\
2072 \x02\x08\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03:\t\x1b\n\x0c\n\x05\x04\
2073 \x02\x02\x02\x03\x12\x03:\x1e\x20\n^\n\x04\x04\x02\x02\x03\x12\x03=\x02\
2074 \x18\x1aQ\x20Remapping\x20(default\x20is\x20ON)\n\x20Remap\x20subgraphs\
2075 \x20onto\x20more\x20efficient\x20implementations.\n\n\x0c\n\x05\x04\x02\
2076 \x02\x03\x06\x12\x03=\x02\x08\n\x0c\n\x05\x04\x02\x02\x03\x01\x12\x03=\t\
2077 \x12\n\x0c\n\x05\x04\x02\x02\x03\x03\x12\x03=\x15\x17\n\x85\x01\n\x04\
2078 \x04\x02\x02\x04\x12\x03@\x02*\x1ax\x20Common\x20subgraph\x20elimination\
2079 \x20(default\x20is\x20ON)\n\x20e.g.\x20Simplify\x20arithmetic\x20ops;\
2080 \x20merge\x20ops\x20with\x20same\x20value\x20(like\x20constants).\n\n\
2081 \x0c\n\x05\x04\x02\x02\x04\x06\x12\x03@\x02\x08\n\x0c\n\x05\x04\x02\x02\
2082 \x04\x01\x12\x03@\t$\n\x0c\n\x05\x04\x02\x02\x04\x03\x12\x03@')\n\x82\
2083 \x01\n\x04\x04\x02\x02\x05\x12\x03C\x02%\x1au\x20Arithmetic\x20optimizat\
2084 ions\x20(default\x20is\x20ON)\n\x20e.g.\x20Simplify\x20arithmetic\x20ops\
2085 ;\x20merge\x20ops\x20with\x20same\x20value\x20(like\x20constants).\n\n\
2086 \x0c\n\x05\x04\x02\x02\x05\x06\x12\x03C\x02\x08\n\x0c\n\x05\x04\x02\x02\
2087 \x05\x01\x12\x03C\t\x20\n\x0c\n\x05\x04\x02\x02\x05\x03\x12\x03C#$\n\x8e\
2088 \x01\n\x04\x04\x02\x02\x06\x12\x03F\x02%\x1a\x80\x01\x20Control\x20depen\
2089 dency\x20optimizations\x20(default\x20is\x20ON).\n\x20Remove\x20redundan\
2090 t\x20control\x20dependencies,\x20which\x20may\x20enable\x20other\x20opti\
2091 mization.\n\n\x0c\n\x05\x04\x02\x02\x06\x06\x12\x03F\x02\x08\n\x0c\n\x05\
2092 \x04\x02\x02\x06\x01\x12\x03F\t\x20\n\x0c\n\x05\x04\x02\x02\x06\x03\x12\
2093 \x03F#$\n2\n\x04\x04\x02\x02\x07\x12\x03H\x02\x1f\x1a%\x20Loop\x20optimi\
2094 zations\x20(default\x20is\x20ON).\n\n\x0c\n\x05\x04\x02\x02\x07\x06\x12\
2095 \x03H\x02\x08\n\x0c\n\x05\x04\x02\x02\x07\x01\x12\x03H\t\x1a\n\x0c\n\x05\
2096 \x04\x02\x02\x07\x03\x12\x03H\x1d\x1e\n6\n\x04\x04\x02\x02\x08\x12\x03J\
2097 \x02$\x1a)\x20Function\x20optimizations\x20(default\x20is\x20ON).\n\n\
2098 \x0c\n\x05\x04\x02\x02\x08\x06\x12\x03J\x02\x08\n\x0c\n\x05\x04\x02\x02\
2099 \x08\x01\x12\x03J\t\x1e\n\x0c\n\x05\x04\x02\x02\x08\x03\x12\x03J!#\nJ\n\
2100 \x04\x04\x02\x02\t\x12\x03L\x02\x1d\x1a=\x20Strips\x20debug-related\x20n\
2101 odes\x20from\x20the\x20graph\x20(off\x20by\x20default).\n\n\x0c\n\x05\
2102 \x04\x02\x02\t\x06\x12\x03L\x02\x08\n\x0c\n\x05\x04\x02\x02\t\x01\x12\
2103 \x03L\t\x17\n\x0c\n\x05\x04\x02\x02\t\x03\x12\x03L\x1a\x1c\nC\n\x04\x04\
2104 \x02\x02\n\x12\x03N\x02!\x1a6\x20If\x20true,\x20don't\x20remove\x20unnec\
2105 essary\x20ops\x20from\x20the\x20graph\n\n\x0c\n\x05\x04\x02\x02\n\x05\
2106 \x12\x03N\x02\x06\n\x0c\n\x05\x04\x02\x02\n\x01\x12\x03N\x07\x1c\n\x0c\n\
2107 \x05\x04\x02\x02\n\x03\x12\x03N\x1f\x20\n\x88\x01\n\x04\x04\x02\x02\x0b\
2108 \x12\x03Q\x02,\x1a{\x20Try\x20to\x20allocate\x20some\x20independent\x20O\
2109 p\x20outputs\x20contiguously\x20in\x20order\x20to\n\x20merge\x20or\x20el\
2110 iminate\x20downstream\x20Ops\x20(off\x20by\x20default).\n\n\x0c\n\x05\
2111 \x04\x02\x02\x0b\x06\x12\x03Q\x02\x08\n\x0c\n\x05\x04\x02\x02\x0b\x01\
2112 \x12\x03Q\t&\n\x0c\n\x05\x04\x02\x02\x0b\x03\x12\x03Q)+\n=\n\x04\x04\x02\
2113 \x02\x0c\x12\x03S\x02'\x1a0\x20Force\x20small\x20ops\x20onto\x20the\x20C\
2114 PU\x20(default\x20is\x20OFF).\n\n\x0c\n\x05\x04\x02\x02\x0c\x06\x12\x03S\
2115 \x02\x08\n\x0c\n\x05\x04\x02\x02\x0c\x01\x12\x03S\t!\n\x0c\n\x05\x04\x02\
2116 \x02\x0c\x03\x12\x03S$&\nh\n\x04\x04\x02\x02\r\x12\x03V\x02&\x1a[\x20Ena\
2117 ble\x20the\x20swap\x20of\x20kernel\x20implementations\x20based\x20on\x20\
2118 the\x20device\x20placement\n\x20(default\x20is\x20ON).\n\n\x0c\n\x05\x04\
2119 \x02\x02\r\x06\x12\x03V\x02\x08\n\x0c\n\x05\x04\x02\x02\r\x01\x12\x03V\t\
2120 \x20\n\x0c\n\x05\x04\x02\x02\r\x03\x12\x03V#%\n\xfc\x01\n\x04\x04\x02\
2121 \x02\x0e\x12\x03[\x02#\x1a\xee\x01\x20Optimize\x20data\x20types\x20for\
2122 \x20CUDA\x20(default\x20is\x20OFF).\n\x20This\x20will\x20try\x20to\x20us\
2123 e\x20float16\x20on\x20GPU\x20which\x20is\x20faster.\n\x20Note\x20that\
2124 \x20this\x20can\x20change\x20the\x20numerical\x20stability\x20of\x20the\
2125 \x20graph\x20and\x20may\n\x20require\x20the\x20use\x20of\x20loss\x20scal\
2126 ing\x20to\x20maintain\x20model\x20convergence.\n\n\x0c\n\x05\x04\x02\x02\
2127 \x0e\x06\x12\x03[\x02\x08\n\x0c\n\x05\x04\x02\x02\x0e\x01\x12\x03[\t\x1d\
2128 \n\x0c\n\x05\x04\x02\x02\x0e\x03\x12\x03[\x20\"\n\xb7\x01\n\x04\x04\x02\
2129 \x02\x0f\x12\x03_\x02'\x1a\xa9\x01\x20Optimize\x20data\x20types\x20for\
2130 \x20MKL\x20(default\x20is\x20OFF).\n\x20This\x20will\x20try\x20to\x20use\
2131 \x20bfloat16\x20on\x20CPUs,\x20which\x20is\x20faster.\n\x20Note\x20that\
2132 \x20this\x20can\x20change\x20the\x20numerical\x20stability\x20of\x20the\
2133 \x20graph.\n\n\x0c\n\x05\x04\x02\x02\x0f\x06\x12\x03_\x02\x08\n\x0c\n\
2134 \x05\x04\x02\x02\x0f\x01\x12\x03_\t!\n\x0c\n\x05\x04\x02\x02\x0f\x03\x12\
2135 \x03_$&\nB\n\x04\x04\x02\x02\x10\x12\x03a\x02#\x1a5\x20Disable\x20the\
2136 \x20entire\x20meta\x20optimizer\x20(off\x20by\x20default).\n\n\x0c\n\x05\
2137 \x04\x02\x02\x10\x05\x12\x03a\x02\x06\n\x0c\n\x05\x04\x02\x02\x10\x01\
2138 \x12\x03a\x07\x1d\n\x0c\n\x05\x04\x02\x02\x10\x03\x12\x03a\x20\"\nb\n\
2139 \x04\x04\x02\x02\x11\x12\x03e\x023\x1aU\x20Controls\x20how\x20many\x20ti\
2140 mes\x20we\x20run\x20the\x20optimizers\x20in\x20meta\x20optimizer\x20(def\
2141 ault\n\x20is\x20once).\n\n\x0c\n\x05\x04\x02\x02\x11\x06\x12\x03e\x02\
2142 \x13\n\x0c\n\x05\x04\x02\x02\x11\x01\x12\x03e\x14-\n\x0c\n\x05\x04\x02\
2143 \x02\x11\x03\x12\x03e02\n\xc8\x01\n\x04\x04\x02\x02\x12\x12\x03k\x02\x1d\
2144 \x1a\xba\x01\x20The\x20minimum\x20number\x20of\x20nodes\x20in\x20a\x20gr\
2145 aph\x20to\x20optimizer.\x20For\x20smaller\x20graphs,\n\x20optimization\
2146 \x20is\x20skipped.\n\x200\x20means\x20the\x20system\x20picks\x20an\x20ap\
2147 propriate\x20number.\n\x20<\x200\x20means\x20do\x20not\x20skip\x20optimi\
2148 zation.\n\n\x0c\n\x05\x04\x02\x02\x12\x05\x12\x03k\x02\x07\n\x0c\n\x05\
2149 \x04\x02\x02\x12\x01\x12\x03k\x08\x17\n\x0c\n\x05\x04\x02\x02\x12\x03\
2150 \x12\x03k\x1a\x1c\n\r\n\x04\x04\x02\x04\x02\x12\x05m\x02\x85\x01\x03\n\
2151 \x0c\n\x05\x04\x02\x04\x02\x01\x12\x03m\x07\x11\nN\n\x06\x04\x02\x04\x02\
2152 \x02\0\x12\x03o\x04\x18\x1a?\x20The\x20default\x20setting\x20(SCHEDULING\
2153 \x20and\x20SWAPPING\x20HEURISTICS\x20only)\n\n\x0e\n\x07\x04\x02\x04\x02\
2154 \x02\0\x01\x12\x03o\x04\x13\n\x0e\n\x07\x04\x02\x04\x02\x02\0\x02\x12\
2155 \x03o\x16\x17\n0\n\x06\x04\x02\x04\x02\x02\x01\x12\x03q\x04\x13\x1a!\x20\
2156 Disabled\x20in\x20the\x20meta-optimizer.\n\n\x0e\n\x07\x04\x02\x04\x02\
2157 \x02\x01\x01\x12\x03q\x04\x0e\n\x0e\n\x07\x04\x02\x04\x02\x02\x01\x02\
2158 \x12\x03q\x11\x12\n7\n\x06\x04\x02\x04\x02\x02\x02\x12\x03s\x04\x0f\x1a(\
2159 \x20Driven\x20by\x20manual\x20op-level\x20annotations.\n\n\x0e\n\x07\x04\
2160 \x02\x04\x02\x02\x02\x01\x12\x03s\x04\n\n\x0e\n\x07\x04\x02\x04\x02\x02\
2161 \x02\x02\x12\x03s\r\x0e\n\xfa\x02\n\x06\x04\x02\x04\x02\x02\x03\x12\x03|\
2162 \x04\x1c\x1az\x20Swapping\x20heuristic\x20will\x20move\x20a\x20tensor\
2163 \x20from\x20the\x20GPU\x20to\x20the\x20CPU\x20and\x20move\n\x20it\x20bac\
2164 k\x20when\x20needed\x20to\x20reduce\x20peak\x20memory\x20usage.\n2\xee\
2165 \x01\x20Driven\x20by\x20heuristics.\x20The\x20behavior\x20of\x20these\
2166 \x20heuristics\x20is\x20subject\x20to\n\x20change.\x20Currently\x20inclu\
2167 des\x20an\x20experimental\x20recomputation\x20and\x20swapping\n\x20heuri\
2168 stics.\x20Manual\x20annotations\x20are\x20respected,\x20but\x20additiona\
2169 l\x20nodes\x20are\n\x20selected\x20automatically.\n\n\x0e\n\x07\x04\x02\
2170 \x04\x02\x02\x03\x01\x12\x03|\x04\x17\n\x0e\n\x07\x04\x02\x04\x02\x02\
2171 \x03\x02\x12\x03|\x1a\x1b\n\x9d\x01\n\x06\x04\x02\x04\x02\x02\x04\x12\
2172 \x03\x7f\x04!\x1a\x8d\x01\x20Recomputation\x20heuristics\x20will\x20reco\
2173 mpute\x20ops\x20(such\x20as\x20Relu\x20activation)\n\x20during\x20backpr\
2174 op\x20instead\x20of\x20storing\x20them,\x20reducing\x20peak\x20memory\
2175 \x20usage.\n\n\x0e\n\x07\x04\x02\x04\x02\x02\x04\x01\x12\x03\x7f\x04\x1c\
2176 \n\x0e\n\x07\x04\x02\x04\x02\x02\x04\x02\x12\x03\x7f\x1f\x20\n\x96\x01\n\
2177 \x06\x04\x02\x04\x02\x02\x05\x12\x04\x82\x01\x04\x1e\x1a\x85\x01\x20Sche\
2178 duling\x20will\x20split\x20big\x20ops\x20such\x20as\x20AddN\x20and\x20tr\
2179 y\x20to\x20enforce\x20a\x20schedule\n\x20of\x20the\x20new\x20computation\
2180 s\x20that\x20decreases\x20peak\x20memory\x20usage.\n\n\x0f\n\x07\x04\x02\
2181 \x04\x02\x02\x05\x01\x12\x04\x82\x01\x04\x19\n\x0f\n\x07\x04\x02\x04\x02\
2182 \x02\x05\x02\x12\x04\x82\x01\x1c\x1d\nO\n\x06\x04\x02\x04\x02\x02\x06\
2183 \x12\x04\x84\x01\x04\x13\x1a?\x20Use\x20any\x20combination\x20of\x20swap\
2184 ping\x20and\x20recomputation\x20heuristics.\n\n\x0f\n\x07\x04\x02\x04\
2185 \x02\x02\x06\x01\x12\x04\x84\x01\x04\x0e\n\x0f\n\x07\x04\x02\x04\x02\x02\
2186 \x06\x02\x12\x04\x84\x01\x11\x12\n\xac\x01\n\x04\x04\x02\x02\x13\x12\x04\
2187 \x89\x01\x02%\x1a\x9d\x01\x20Configures\x20memory\x20optimization\x20pas\
2188 ses\x20through\x20the\x20meta-optimizer.\x20Has\x20no\n\x20effect\x20on\
2189 \x20manually\x20requested\x20memory\x20optimization\x20passes\x20in\x20t\
2190 he\x20optimizers\n\x20field.\n\n\r\n\x05\x04\x02\x02\x13\x06\x12\x04\x89\
2191 \x01\x02\x0c\n\r\n\x05\x04\x02\x02\x13\x01\x12\x04\x89\x01\r\x20\n\r\n\
2192 \x05\x04\x02\x02\x13\x03\x12\x04\x89\x01#$\n\xc0\x04\n\x04\x04\x02\x02\
2193 \x14\x12\x04\x92\x01\x025\x1a\xb1\x04\x20A\x20node\x20name\x20scope\x20f\
2194 or\x20node\x20names\x20which\x20are\x20valid\x20outputs\x20of\x20recompu\
2195 tations.\n\x20Inputs\x20to\x20nodes\x20that\x20match\x20this\x20scope\
2196 \x20may\x20be\x20recomputed\x20(subject\x20either\x20to\n\x20manual\x20a\
2197 nnotation\x20of\x20those\x20input\x20nodes\x20or\x20to\x20manual\x20anno\
2198 tation\x20and\n\x20heuristics\x20depending\x20on\x20memory_optimization)\
2199 ,\x20but\x20the\x20nodes\x20themselves\x20will\n\x20not\x20be\x20recompu\
2200 ted.\x20This\x20matches\x20any\x20sub-scopes\x20as\x20well,\x20meaning\
2201 \x20the\x20scope\n\x20can\x20appear\x20not\x20just\x20as\x20a\x20top-lev\
2202 el\x20scope.\x20For\x20example,\x20if\x20the\x20value\x20is\n\x20\"gradi\
2203 ents/\",\x20the\x20default,\x20it\x20will\x20match\x20node\x20name\x20\"\
2204 gradients/foo\",\n\x20\"foo/gradients/bar\",\x20but\x20not\x20\"foo_grad\
2205 ients/\"\n\n\r\n\x05\x04\x02\x02\x14\x05\x12\x04\x92\x01\x02\x08\n\r\n\
2206 \x05\x04\x02\x02\x14\x01\x12\x04\x92\x01\t0\n\r\n\x05\x04\x02\x02\x14\
2207 \x03\x12\x04\x92\x0134\n\xd9\x01\n\x04\x04\x02\x02\x15\x12\x04\x96\x01\
2208 \x02'\x1a\xca\x01\x20Maximum\x20number\x20of\x20milliseconds\x20to\x20sp\
2209 end\x20optimizing\x20a\x20single\x20graph\x20before\n\x20timing\x20out.\
2210 \x20If\x20equal\x20to\x200\x20the\x20system\x20picks\x20a\x20default\x20\
2211 (currently\x205\x20minutes).\n\x20If\x20less\x20than\x200\x20the\x20opti\
2212 mizer\x20will\x20never\x20time\x20out.\n\n\r\n\x05\x04\x02\x02\x15\x05\
2213 \x12\x04\x96\x01\x02\x07\n\r\n\x05\x04\x02\x02\x15\x01\x12\x04\x96\x01\
2214 \x08!\n\r\n\x05\x04\x02\x02\x15\x03\x12\x04\x96\x01$&\n\x98\x01\n\x04\
2215 \x04\x02\x02\x16\x12\x04\x9a\x01\x02(\x1a\x89\x01\x20Configures\x20AutoP\
2216 arallel\x20optimization\x20passes\x20either\x20through\x20the\n\x20meta-\
2217 optimizer\x20or\x20when\x20manually\x20specified\x20through\x20the\x20op\
2218 timizers\x20field.\n\n\r\n\x05\x04\x02\x02\x16\x06\x12\x04\x9a\x01\x02\
2219 \x15\n\r\n\x05\x04\x02\x02\x16\x01\x12\x04\x9a\x01\x16#\n\r\n\x05\x04\
2220 \x02\x02\x16\x03\x12\x04\x9a\x01&'\n\xb5\x01\n\x04\x04\x02\x02\x17\x12\
2221 \x04\x9f\x01\x02%\x1a\xa6\x01\x20If\x20true,\x20any\x20optimization\x20p\
2222 ass\x20failing\x20will\x20cause\x20the\x20MetaOptimizer\x20to\n\x20stop\
2223 \x20with\x20an\x20error.\x20By\x20default\x20-\x20or\x20when\x20set\x20t\
2224 o\x20false,\x20failing\x20passes\x20are\n\x20skipped\x20silently.\n\n\r\
2225 \n\x05\x04\x02\x02\x17\x05\x12\x04\x9f\x01\x02\x06\n\r\n\x05\x04\x02\x02\
2226 \x17\x01\x12\x04\x9f\x01\x07\x1f\n\r\n\x05\x04\x02\x02\x17\x03\x12\x04\
2227 \x9f\x01\"$\n\x0c\n\x04\x04\x02\x02\x18\x12\x04\xa1\x01\x024\n\r\n\x05\
2228 \x04\x02\x02\x18\x06\x12\x04\xa1\x01\x02\x18\n\r\n\x05\x04\x02\x02\x18\
2229 \x01\x12\x04\xa1\x01\x19.\n\r\n\x05\x04\x02\x02\x18\x03\x12\x04\xa1\x011\
2230 3\n\xa3\x05\n\x04\x04\x02\x02\x19\x12\x04\xaf\x01\x02#\x1a\x94\x05\x20If\
2231 \x20non-empty,\x20will\x20use\x20this\x20as\x20an\x20alternative\x20way\
2232 \x20to\x20specify\x20a\x20list\x20of\n\x20optimizations\x20to\x20turn\
2233 \x20on\x20and\x20the\x20order\x20of\x20the\x20optimizations\x20(replacin\
2234 g\x20the\n\x20meta-optimizer).\n\n\x20Of\x20the\x20RewriterConfig\x20opt\
2235 ions,\x20only\x20the\x20AutoParallel\x20configuration\x20options\n\x20(t\
2236 he\x20auto_parallel\x20field)\x20apply\x20to\x20manually\x20requested\
2237 \x20optimization\x20passes\n\x20(\"autoparallel\").\x20Memory\x20optimiz\
2238 ation\x20passes\x20(\"memory\")\x20invoked\x20here\x20are\n\x20not\x20co\
2239 nfigurable\x20(in\x20contrast\x20to\x20memory\x20optimization\x20passes\
2240 \x20through\x20the\n\x20meta-optimizer)\x20and\x20act\x20only\x20on\x20m\
2241 anual\x20op\x20annotations.\n\n\x20Custom\x20optimizers\x20(see\x20custo\
2242 m_optimizers)\x20that\x20are\x20not\x20part\x20of\x20this\n\x20schedule\
2243 \x20will\x20be\x20run\x20after\x20-\x20in\x20the\x20order\x20that\x20the\
2244 y\x20were\x20specified.\n\n\r\n\x05\x04\x02\x02\x19\x04\x12\x04\xaf\x01\
2245 \x02\n\n\r\n\x05\x04\x02\x02\x19\x05\x12\x04\xaf\x01\x0b\x11\n\r\n\x05\
2246 \x04\x02\x02\x19\x01\x12\x04\xaf\x01\x12\x1c\n\r\n\x05\x04\x02\x02\x19\
2247 \x03\x12\x04\xaf\x01\x1f\"\nO\n\x04\x04\x02\x03\0\x12\x06\xb2\x01\x02\
2248 \xb5\x01\x03\x1a?\x20Message\x20to\x20describe\x20custom\x20graph\x20opt\
2249 imizer\x20and\x20its\x20parameters\n\n\r\n\x05\x04\x02\x03\0\x01\x12\x04\
2250 \xb2\x01\n\x1e\n\x0e\n\x06\x04\x02\x03\0\x02\0\x12\x04\xb3\x01\x04\x14\n\
2251 \x0f\n\x07\x04\x02\x03\0\x02\0\x05\x12\x04\xb3\x01\x04\n\n\x0f\n\x07\x04\
2252 \x02\x03\0\x02\0\x01\x12\x04\xb3\x01\x0b\x0f\n\x0f\n\x07\x04\x02\x03\0\
2253 \x02\0\x03\x12\x04\xb3\x01\x12\x13\n\x0e\n\x06\x04\x02\x03\0\x02\x01\x12\
2254 \x04\xb4\x01\x04-\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x06\x12\x04\xb4\x01\
2255 \x04\x1a\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x01\x12\x04\xb4\x01\x1b(\n\
2256 \x0f\n\x07\x04\x02\x03\0\x02\x01\x03\x12\x04\xb4\x01+,\n7\n\x04\x04\x02\
2257 \x02\x1a\x12\x04\xb8\x01\x028\x1a)\x20list\x20of\x20CustomGraphOptimizer\
2258 s\x20to\x20apply.\n\n\r\n\x05\x04\x02\x02\x1a\x04\x12\x04\xb8\x01\x02\n\
2259 \n\r\n\x05\x04\x02\x02\x1a\x06\x12\x04\xb8\x01\x0b\x1f\n\r\n\x05\x04\x02\
2260 \x02\x1a\x01\x12\x04\xb8\x01\x201\n\r\n\x05\x04\x02\x02\x1a\x03\x12\x04\
2261 \xb8\x0147\nX\n\x04\x04\x02\x02\x1b\x12\x04\xbb\x01\x027\x1aJ\x20Verifie\
2262 rConfig\x20specifying\x20the\x20verifiers\x20to\x20be\x20run\x20after\
2263 \x20every\x20optimizer.\n\n\r\n\x05\x04\x02\x02\x1b\x06\x12\x04\xbb\x01\
2264 \x02\x10\n\r\n\x05\x04\x02\x02\x1b\x01\x12\x04\xbb\x01\x110\n\r\n\x05\
2265 \x04\x02\x02\x1b\x03\x12\x04\xbb\x0136\nm\n\x04\x04\x02\x02\x1c\x12\x04\
2266 \xbf\x01\x029\x1a_\x20VerifierConfig\x20specifying\x20the\x20verifiers\
2267 \x20to\x20be\x20run\x20at\x20the\x20end,\x20after\x20all\n\x20optimizers\
2268 \x20have\x20run.\n\n\r\n\x05\x04\x02\x02\x1c\x06\x12\x04\xbf\x01\x02\x10\
2269 \n\r\n\x05\x04\x02\x02\x1c\x01\x12\x04\xbf\x01\x112\n\r\n\x05\x04\x02\
2270 \x02\x1c\x03\x12\x04\xbf\x0158b\x06proto3\
2271";
2272
2273static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;
2274
2275fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
2276 ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
2277}
2278
2279pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
2280 unsafe {
2281 file_descriptor_proto_lazy.get(|| {
2282 parse_descriptor_proto()
2283 })
2284 }
2285}